@discomedia/utils 1.0.54 → 1.0.56

package/dist/test.js

@@ -11,6 +11,7 @@ import require$$0$1 from 'buffer';
 import require$$0$4 from 'fs';
 import require$$1$1 from 'path';
 import require$$2$1 from 'os';
+import 'console';
 
 /**
  * Logs a message to the console.
@@ -146,12 +147,18 @@ const marketEarlyCloses = {
 
 // Constants for NY market times (Eastern Time)
 const MARKET_CONFIG = {
+    TIMEZONE: 'America/New_York',
     UTC_OFFSET_STANDARD: -5, // EST
     UTC_OFFSET_DST: -4, // EDT
     TIMES: {
+        EXTENDED_START: { hour: 4, minute: 0 },
         MARKET_OPEN: { hour: 9, minute: 30 },
+        EARLY_MARKET_END: { hour: 10, minute: 0 },
         MARKET_CLOSE: { hour: 16, minute: 0 },
-        EARLY_CLOSE: { hour: 13, minute: 0 }},
+        EARLY_CLOSE: { hour: 13, minute: 0 },
+        EXTENDED_END: { hour: 20, minute: 0 },
+        EARLY_EXTENDED_END: { hour: 17, minute: 0 },
+    },
 };
 // Helper: Get NY offset for a given UTC date (DST rules for US)
 /**
@@ -219,6 +226,33 @@ function fromNYTime(date) {
     const utcMillis = nyMillis - offset * 60 * 60 * 1000;
     return new Date(utcMillis);
 }
+// Helper: Format date in ISO, unix, etc.
+/**
+ * Formats a date in ISO, unix-seconds, or unix-ms format.
+ * @param date - Date object
+ * @param outputFormat - Output format ('iso', 'unix-seconds', 'unix-ms')
+ * @returns Formatted date string or number
+ */
+function formatDate(date, outputFormat = 'iso') {
+    switch (outputFormat) {
+        case 'unix-seconds':
+            return Math.floor(date.getTime() / 1000);
+        case 'unix-ms':
+            return date.getTime();
+        case 'iso':
+        default:
+            return date.toISOString();
+    }
+}
+// Helper: Format date in NY locale string
+/**
+ * Formats a date in NY locale string.
+ * @param date - Date object
+ * @returns NY locale string
+ */
+function formatNYLocale(date) {
+    return date.toLocaleString('en-US', { timeZone: 'America/New_York' });
+}
 // Market calendar logic
 /**
  * Market calendar logic for holidays, weekends, and market days.
@@ -314,6 +348,82 @@ class MarketCalendar {
         return prevDay;
     }
 }
+// Market open/close times
+/**
+ * Returns market open/close times for a given date, including extended and early closes.
+ * @param date - Date object
+ * @returns MarketOpenCloseResult
+ */
+function getMarketTimes(date) {
+    const calendar = new MarketCalendar();
+    const nyDate = toNYTime(date);
+    if (!calendar.isMarketDay(date)) {
+        return {
+            marketOpen: false,
+            open: null,
+            close: null,
+            openExt: null,
+            closeExt: null,
+        };
+    }
+    const year = nyDate.getUTCFullYear();
+    const month = nyDate.getUTCMonth();
+    const day = nyDate.getUTCDate();
+    // Helper to build NY time for a given hour/minute
+    function buildNYTime(hour, minute) {
+        const d = new Date(Date.UTC(year, month, day, hour, minute, 0, 0));
+        return fromNYTime(d);
+    }
+    let open = buildNYTime(MARKET_CONFIG.TIMES.MARKET_OPEN.hour, MARKET_CONFIG.TIMES.MARKET_OPEN.minute);
+    let close = buildNYTime(MARKET_CONFIG.TIMES.MARKET_CLOSE.hour, MARKET_CONFIG.TIMES.MARKET_CLOSE.minute);
+    let openExt = buildNYTime(MARKET_CONFIG.TIMES.EXTENDED_START.hour, MARKET_CONFIG.TIMES.EXTENDED_START.minute);
+    let closeExt = buildNYTime(MARKET_CONFIG.TIMES.EXTENDED_END.hour, MARKET_CONFIG.TIMES.EXTENDED_END.minute);
+    if (calendar.isEarlyCloseDay(date)) {
+        close = buildNYTime(MARKET_CONFIG.TIMES.EARLY_CLOSE.hour, MARKET_CONFIG.TIMES.EARLY_CLOSE.minute);
+        closeExt = buildNYTime(MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour, MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute);
+    }
+    return {
+        marketOpen: true,
+        open,
+        close,
+        openExt,
+        closeExt,
+    };
+}
+// Is within market hours
+/**
+ * Checks if a date/time is within market hours, extended hours, or continuous.
+ * @param date - Date object
+ * @param intradayReporting - 'market_hours', 'extended_hours', or 'continuous'
+ * @returns true if within hours, false otherwise
+ */
+function isWithinMarketHours(date, intradayReporting = 'market_hours') {
+    const calendar = new MarketCalendar();
+    if (!calendar.isMarketDay(date))
+        return false;
+    const nyDate = toNYTime(date);
+    const minutes = nyDate.getUTCHours() * 60 + nyDate.getUTCMinutes();
+    switch (intradayReporting) {
+        case 'extended_hours': {
+            let endMinutes = MARKET_CONFIG.TIMES.EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_END.minute;
+            if (calendar.isEarlyCloseDay(date)) {
+                endMinutes = MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute;
+            }
+            const startMinutes = MARKET_CONFIG.TIMES.EXTENDED_START.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_START.minute;
+            return minutes >= startMinutes && minutes <= endMinutes;
+        }
+        case 'continuous':
+            return true;
+        default: {
+            let endMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
+            if (calendar.isEarlyCloseDay(date)) {
+                endMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
+            }
+            const startMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
+            return minutes >= startMinutes && minutes <= endMinutes;
+        }
+    }
+}
 // Get last full trading date
 /**
  * Returns the last full trading date (market close) for a given date.
@@ -354,6 +464,244 @@ function getLastFullTradingDateImpl(currentDate = new Date()) {
     const closeMinute = marketCloseMinutes % 60;
     return fromNYTime(new Date(Date.UTC(year, month, day, closeHour, closeMinute, 0, 0)));
 }
+// Get day boundaries
+/**
+ * Returns the start and end boundaries for a market day, extended hours, or continuous.
+ * @param date - Date object
+ * @param intradayReporting - 'market_hours', 'extended_hours', or 'continuous'
+ * @returns Object with start and end Date
+ */
+function getDayBoundaries(date, intradayReporting = 'market_hours') {
+    const calendar = new MarketCalendar();
+    const nyDate = toNYTime(date);
+    const year = nyDate.getUTCFullYear();
+    const month = nyDate.getUTCMonth();
+    const day = nyDate.getUTCDate();
+    function buildNYTime(hour, minute, sec = 0, ms = 0) {
+        const d = new Date(Date.UTC(year, month, day, hour, minute, sec, ms));
+        return fromNYTime(d);
+    }
+    let start;
+    let end;
+    switch (intradayReporting) {
+        case 'extended_hours':
+            start = buildNYTime(MARKET_CONFIG.TIMES.EXTENDED_START.hour, MARKET_CONFIG.TIMES.EXTENDED_START.minute, 0, 0);
+            end = buildNYTime(MARKET_CONFIG.TIMES.EXTENDED_END.hour, MARKET_CONFIG.TIMES.EXTENDED_END.minute, 59, 999);
+            if (calendar.isEarlyCloseDay(date)) {
+                end = buildNYTime(MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour, MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute, 59, 999);
+            }
+            break;
+        case 'continuous':
+            start = new Date(Date.UTC(year, month, day, 0, 0, 0, 0));
+            end = new Date(Date.UTC(year, month, day, 23, 59, 59, 999));
+            break;
+        default:
+            start = buildNYTime(MARKET_CONFIG.TIMES.MARKET_OPEN.hour, MARKET_CONFIG.TIMES.MARKET_OPEN.minute, 0, 0);
+            end = buildNYTime(MARKET_CONFIG.TIMES.MARKET_CLOSE.hour, MARKET_CONFIG.TIMES.MARKET_CLOSE.minute, 59, 999);
+            if (calendar.isEarlyCloseDay(date)) {
+                end = buildNYTime(MARKET_CONFIG.TIMES.EARLY_CLOSE.hour, MARKET_CONFIG.TIMES.EARLY_CLOSE.minute, 59, 999);
+            }
+            break;
+    }
+    return { start, end };
+}
+// Period calculator
+/**
+ * Calculates the start date for a given period ending at endDate.
+ * @param endDate - Date object
+ * @param period - Period string
+ * @returns Date object for period start
+ */
+function calculatePeriodStartDate(endDate, period) {
+    const calendar = new MarketCalendar();
+    let startDate;
+    switch (period) {
+        case 'YTD':
+            startDate = new Date(Date.UTC(endDate.getUTCFullYear(), 0, 1));
+            break;
+        case '1D':
+            startDate = calendar.getPreviousMarketDay(endDate);
+            break;
+        case '3D':
+            startDate = new Date(endDate.getTime() - 3 * 24 * 60 * 60 * 1000);
+            break;
+        case '1W':
+            startDate = new Date(endDate.getTime() - 7 * 24 * 60 * 60 * 1000);
+            break;
+        case '2W':
+            startDate = new Date(endDate.getTime() - 14 * 24 * 60 * 60 * 1000);
+            break;
+        case '1M':
+            startDate = new Date(Date.UTC(endDate.getUTCFullYear(), endDate.getUTCMonth() - 1, endDate.getUTCDate()));
+            break;
+        case '3M':
+            startDate = new Date(Date.UTC(endDate.getUTCFullYear(), endDate.getUTCMonth() - 3, endDate.getUTCDate()));
+            break;
+        case '6M':
+            startDate = new Date(Date.UTC(endDate.getUTCFullYear(), endDate.getUTCMonth() - 6, endDate.getUTCDate()));
+            break;
+        case '1Y':
+            startDate = new Date(Date.UTC(endDate.getUTCFullYear() - 1, endDate.getUTCMonth(), endDate.getUTCDate()));
+            break;
+        default:
+            throw new Error(`Invalid period: ${period}`);
+    }
+    // Ensure start date is a market day
+    while (!calendar.isMarketDay(startDate)) {
+        startDate = calendar.getNextMarketDay(startDate);
+    }
+    return startDate;
+}
+// Get market time period
+/**
+ * Returns the start and end dates for a market time period.
+ * @param params - MarketTimeParams
+ * @returns PeriodDates object
+ */
+function getMarketTimePeriod(params) {
+    const { period, end = new Date(), intraday_reporting = 'market_hours', outputFormat = 'iso' } = params;
+    if (!period)
+        throw new Error('Period is required');
+    const calendar = new MarketCalendar();
+    const nyEndDate = toNYTime(end);
+    let endDate;
+    const isCurrentMarketDay = calendar.isMarketDay(end);
+    const isWithinHours = isWithinMarketHours(end, intraday_reporting);
+    const minutes = nyEndDate.getUTCHours() * 60 + nyEndDate.getUTCMinutes();
+    const marketStartMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
+    if (isCurrentMarketDay) {
+        if (minutes < marketStartMinutes) {
+            // Before market open - use previous day's close
+            const lastMarketDay = calendar.getPreviousMarketDay(end);
+            const { end: dayEnd } = getDayBoundaries(lastMarketDay, intraday_reporting);
+            endDate = dayEnd;
+        }
+        else if (isWithinHours) {
+            // During market hours - use current time
+            endDate = end;
+        }
+        else {
+            // After market close - use today's close
+            const { end: dayEnd } = getDayBoundaries(end, intraday_reporting);
+            endDate = dayEnd;
+        }
+    }
+    else {
+        // Not a market day - use previous market day's close
+        const lastMarketDay = calendar.getPreviousMarketDay(end);
+        const { end: dayEnd } = getDayBoundaries(lastMarketDay, intraday_reporting);
+        endDate = dayEnd;
+    }
+    // Calculate start date
+    const periodStartDate = calculatePeriodStartDate(endDate, period);
+    const { start: dayStart } = getDayBoundaries(periodStartDate, intraday_reporting);
+    if (endDate.getTime() < dayStart.getTime()) {
+        throw new Error('Start date cannot be after end date');
+    }
+    return {
+        start: formatDate(dayStart, outputFormat),
+        end: formatDate(endDate, outputFormat),
+    };
+}
+// Market status
+/**
+ * Returns the current market status for a given date.
+ * @param date - Date object (default: now)
+ * @returns MarketStatus object
+ */
+function getMarketStatusImpl(date = new Date()) {
+    const calendar = new MarketCalendar();
+    const nyDate = toNYTime(date);
+    const minutes = nyDate.getUTCHours() * 60 + nyDate.getUTCMinutes();
+    const isMarketDay = calendar.isMarketDay(date);
+    const isEarlyCloseDay = calendar.isEarlyCloseDay(date);
+    const extendedStartMinutes = MARKET_CONFIG.TIMES.EXTENDED_START.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_START.minute;
+    const marketStartMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
+    const earlyMarketEndMinutes = MARKET_CONFIG.TIMES.EARLY_MARKET_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_MARKET_END.minute;
+    let marketCloseMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
+    let extendedEndMinutes = MARKET_CONFIG.TIMES.EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_END.minute;
+    if (isEarlyCloseDay) {
+        marketCloseMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
+        extendedEndMinutes =
+            MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute;
+    }
+    let status;
+    let nextStatus;
+    let nextStatusTime;
+    let marketPeriod;
+    if (!isMarketDay) {
+        status = 'closed';
+        nextStatus = 'extended hours';
+        marketPeriod = 'closed';
+        const nextMarketDay = calendar.getNextMarketDay(date);
+        nextStatusTime = getDayBoundaries(nextMarketDay, 'extended_hours').start;
+    }
+    else if (minutes < extendedStartMinutes) {
+        status = 'closed';
+        nextStatus = 'extended hours';
+        marketPeriod = 'closed';
+        nextStatusTime = getDayBoundaries(date, 'extended_hours').start;
+    }
+    else if (minutes < marketStartMinutes) {
+        status = 'extended hours';
+        nextStatus = 'open';
+        marketPeriod = 'preMarket';
+        nextStatusTime = getDayBoundaries(date, 'market_hours').start;
+    }
+    else if (minutes < marketCloseMinutes) {
+        status = 'open';
+        nextStatus = 'extended hours';
+        marketPeriod = minutes < earlyMarketEndMinutes ? 'earlyMarket' : 'regularMarket';
+        nextStatusTime = getDayBoundaries(date, 'market_hours').end;
+    }
+    else if (minutes < extendedEndMinutes) {
+        status = 'extended hours';
+        nextStatus = 'closed';
+        marketPeriod = 'afterMarket';
+        nextStatusTime = getDayBoundaries(date, 'extended_hours').end;
+    }
+    else {
+        status = 'closed';
+        nextStatus = 'extended hours';
+        marketPeriod = 'closed';
+        const nextMarketDay = calendar.getNextMarketDay(date);
+        nextStatusTime = getDayBoundaries(nextMarketDay, 'extended_hours').start;
+    }
+    // I think using nyDate here may be wrong - should use current time? i.e. date.getTime()
+    const nextStatusTimeDifference = nextStatusTime.getTime() - date.getTime();
+    return {
+        time: date,
+        timeString: formatNYLocale(nyDate),
+        status,
+        nextStatus,
+        marketPeriod,
+        nextStatusTime,
+        nextStatusTimeDifference,
+        nextStatusTimeString: formatNYLocale(nextStatusTime),
+    };
+}
+// API exports
+/**
+ * Returns market open/close times for a given date.
+ * @param options - { date?: Date }
+ * @returns MarketOpenCloseResult
+ */
+function getMarketOpenClose(options = {}) {
+    const { date = new Date() } = options;
+    return getMarketTimes(date);
+}
+/**
+ * Returns the start and end dates for a market time period as Date objects.
+ * @param params - MarketTimeParams
+ * @returns Object with start and end Date
+ */
+function getStartAndEndDates(params = {}) {
+    const { start, end } = getMarketTimePeriod(params);
+    return {
+        start: typeof start === 'string' || typeof start === 'number' ? new Date(start) : start,
+        end: typeof end === 'string' || typeof end === 'number' ? new Date(end) : end,
+    };
+}
 /**
  * Returns the last full trading date as a Date object.
  */
@@ -365,6 +713,43 @@ function getLastFullTradingDateImpl(currentDate = new Date()) {
 function getLastFullTradingDate(currentDate = new Date()) {
     return getLastFullTradingDateImpl(currentDate);
 }
+/**
+ * Returns the next market day after the reference date.
+ * @param referenceDate - Date object (default: now)
+ * @returns Object with date, yyyymmdd string, and ISO string
+ */
+function getNextMarketDay({ referenceDate } = {}) {
+    const calendar = new MarketCalendar();
+    const startDate = referenceDate ?? new Date();
+    // Find the next trading day (UTC Date object)
+    const nextDate = calendar.getNextMarketDay(startDate);
+    // Convert to NY time before extracting Y-M-D parts
+    const nyNext = toNYTime(nextDate);
+    const yyyymmdd = `${nyNext.getUTCFullYear()}-${String(nyNext.getUTCMonth() + 1).padStart(2, '0')}-${String(nyNext.getUTCDate()).padStart(2, '0')}`;
+    return {
+        date: nextDate, // raw Date, unchanged
+        yyyymmdd, // correct trading date string
+        dateISOString: nextDate.toISOString(),
+    };
+}
+/**
+ * Returns the previous market day before the reference date.
+ * @param referenceDate - Date object (default: now)
+ * @returns Object with date, yyyymmdd string, and ISO string
+ */
+function getPreviousMarketDay({ referenceDate } = {}) {
+    const calendar = new MarketCalendar();
+    const startDate = referenceDate || new Date();
+    const prevDate = calendar.getPreviousMarketDay(startDate);
+    // convert to NY time first
+    const nyPrev = toNYTime(prevDate); // ← already in this file
+    const yyyymmdd = `${nyPrev.getUTCFullYear()}-${String(nyPrev.getUTCMonth() + 1).padStart(2, '0')}-${String(nyPrev.getUTCDate()).padStart(2, '0')}`;
+    return {
+        date: prevDate,
+        yyyymmdd,
+        dateISOString: prevDate.toISOString(),
+    };
+}
 /**
  * Returns the trading date for a given time. Note: Just trims the date string; does not validate if the date is a market day.
  * @param time - a string, number (unix timestamp), or Date object representing the time
@@ -380,6 +765,296 @@ function getTradingDate(time) {
     const nyDate = toNYTime(date);
     return `${nyDate.getUTCFullYear()}-${String(nyDate.getUTCMonth() + 1).padStart(2, '0')}-${String(nyDate.getUTCDate()).padStart(2, '0')}`;
 }
+/**
+ * Returns the NY timezone offset string for a given date.
+ * @param date - Date object (default: now)
+ * @returns '-04:00' for EDT, '-05:00' for EST
+ */
+function getNYTimeZone(date) {
+    const offset = getNYOffset(date || new Date());
+    return offset === -4 ? '-04:00' : '-05:00';
+}
+/**
+ * Returns the regular market open and close Date objects for a given trading day string in the
+ * America/New_York timezone (NYSE/NASDAQ calendar).
+ *
+ * This helper is convenient when you have a calendar date like '2025-10-03' and want the precise
+ * open and close Date values for that day. It internally:
+ * - Determines the NY offset for the day using `getNYTimeZone()`.
+ * - Anchors a noon-time Date on that day in NY time to avoid DST edge cases.
+ * - Verifies the day is a market day via `isMarketDay()`.
+ * - Fetches the open/close times via `getMarketOpenClose()`.
+ *
+ * Throws if the provided day is not a market day or if open/close times are unavailable.
+ *
+ * See also:
+ * - `getNYTimeZone(date?: Date)`
+ * - `isMarketDay(date: Date)`
+ * - `getMarketOpenClose(options?: { date?: Date })`
+ *
+ * @param dateStr - Trading day string in 'YYYY-MM-DD' format (Eastern Time date)
+ * @returns An object containing `{ open: Date; close: Date }`
+ * @example
+ * ```ts
+ * const { open, close } = disco.time.getOpenCloseForTradingDay('2025-10-03');
+ * ```
+ */
+function getOpenCloseForTradingDay(dateStr) {
+    // Build a UTC midnight anchor for the date, then derive the NY offset for that day.
+    const utcAnchor = new Date(`${dateStr}T00:00:00Z`);
+    const nyOffset = getNYTimeZone(utcAnchor); // '-04:00' | '-05:00'
+    // Create a NY-local noon date to avoid DST midnight transitions.
+    const nyNoon = new Date(`${dateStr}T12:00:00${nyOffset}`);
+    if (!isMarketDay(nyNoon)) {
+        throw new Error(`Not a market day in ET: ${dateStr}`);
+    }
+    const { open, close } = getMarketOpenClose({ date: nyNoon });
+    if (!open || !close) {
+        throw new Error(`No market times available for ${dateStr}`);
+    }
+    return { open, close };
+}
+/**
+ * Converts any date to the market time zone (America/New_York, Eastern Time).
+ * Returns a new Date object representing the same moment in time but adjusted to NY/Eastern timezone.
+ * Automatically handles daylight saving time transitions (EST/EDT).
+ *
+ * @param date - Date object to convert to market time zone
+ * @returns Date object in NY/Eastern time zone
+ * @example
+ * ```typescript
+ * const utcDate = new Date('2024-01-15T15:30:00Z'); // 3:30 PM UTC
+ * const nyDate = convertDateToMarketTimeZone(utcDate); // 10:30 AM EST (winter) or 11:30 AM EDT (summer)
+ * ```
+ */
+function convertDateToMarketTimeZone(date) {
+    return toNYTime(date);
+}
+/**
+ * Returns the current market status for a given date.
+ * @param options - { date?: Date }
+ * @returns MarketStatus object
+ */
+function getMarketStatus(options = {}) {
+    const { date = new Date() } = options;
+    return getMarketStatusImpl(date);
+}
+/**
+ * Checks if a date is a market day.
+ * @param date - Date object
+ * @returns true if market day, false otherwise
+ */
+function isMarketDay(date) {
+    const calendar = new MarketCalendar();
+    return calendar.isMarketDay(date);
+}
+/**
+ * Returns full trading days from market open to market close.
+ * endDate is always the most recent market close (previous day's close if before open, today's close if after open).
+ * days: 1 or not specified = that day's open; 2 = previous market day's open, etc.
+ */
+/**
+ * Returns full trading days from market open to market close.
+ * @param options - { endDate?: Date, days?: number }
+ * @returns Object with startDate and endDate
+ */
+function getTradingStartAndEndDates(options = {}) {
+    const { endDate = new Date(), days = 1 } = options;
+    const calendar = new MarketCalendar();
+    // Find the most recent market close
+    let endMarketDay = endDate;
+    const nyEnd = toNYTime(endDate);
+    const marketOpenMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
+    const marketCloseMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
+    const minutes = nyEnd.getUTCHours() * 60 + nyEnd.getUTCMinutes();
+    if (!calendar.isMarketDay(endDate) ||
+        minutes < marketOpenMinutes ||
+        (minutes >= marketOpenMinutes && minutes < marketCloseMinutes)) {
+        // Before market open, not a market day, or during market hours: use previous market day
+        endMarketDay = calendar.getPreviousMarketDay(endDate);
+    }
+    else {
+        // After market close: use today
+        endMarketDay = endDate;
+    }
+    // Get market close for endMarketDay
+    const endClose = getMarketOpenClose({ date: endMarketDay }).close;
+    // Find start market day by iterating back over market days
+    let startMarketDay = endMarketDay;
+    let count = Math.max(1, days);
+    for (let i = 1; i < count; i++) {
+        startMarketDay = calendar.getPreviousMarketDay(startMarketDay);
+    }
+    // If days > 1, we need to go back (days-1) market days from endMarketDay
+    if (days > 1) {
+        startMarketDay = endMarketDay;
+        for (let i = 1; i < days; i++) {
+            startMarketDay = calendar.getPreviousMarketDay(startMarketDay);
+        }
+    }
+    const startOpen = getMarketOpenClose({ date: startMarketDay }).open;
+    return { startDate: startOpen, endDate: endClose };
+}
+/**
+ * Counts trading time between two dates (passed as standard Date objects), excluding weekends and holidays, and closed market hours, using other functions in this library.
+ *
+ * This function calculates the actual trading time between two dates by:
+ * 1. Iterating through each calendar day between startDate and endDate (inclusive)
+ * 2. For each day that is a market day (not weekend/holiday), getting market open/close times
+ * 3. Calculating the overlap between the time range and market hours for that day
+ * 4. Summing up all the trading minutes across all days
+ *
+ * The function automatically handles:
+ * - Weekends (Saturday/Sunday) - skipped entirely
+ * - Market holidays - skipped entirely
+ * - Early close days (e.g. day before holidays) - uses early close time
+ * - Times outside market hours - only counts time within 9:30am-4pm ET (or early close)
+ *
+ * Examples:
+ * - 12pm to 3:30pm same day = 3.5 hours = 210 minutes = 0.54 days
+ * - 9:30am to 4pm same day = 6.5 hours = 390 minutes = 1 day
+ * - Friday 2pm to Monday 2pm = 6.5 hours (Friday 2pm-4pm + Monday 9:30am-2pm)
+ *
+ * @param startDate - Start date/time
+ * @param endDate - End date/time (default: now)
+ * @returns Object containing:
+ *   - days: Trading time as fraction of full trading days (6.5 hours = 1 day)
+ *   - hours: Trading time in hours
+ *   - minutes: Trading time in minutes
+ */
+function countTradingDays(startDate, endDate = new Date()) {
+    const calendar = new MarketCalendar();
+    // Ensure start is before end
+    if (startDate.getTime() > endDate.getTime()) {
+        throw new Error('Start date must be before end date');
+    }
+    let totalMinutes = 0;
+    // Get the NY dates for iteration
+    const startNY = toNYTime(startDate);
+    const endNY = toNYTime(endDate);
+    // Create date at start of first day (in NY time)
+    const currentNY = new Date(Date.UTC(startNY.getUTCFullYear(), startNY.getUTCMonth(), startNY.getUTCDate(), 0, 0, 0, 0));
+    // Iterate through each calendar day
+    while (currentNY.getTime() <= endNY.getTime()) {
+        const currentUTC = fromNYTime(currentNY);
+        // Check if this is a market day
+        if (calendar.isMarketDay(currentUTC)) {
+            // Get market hours for this day
+            const marketTimes = getMarketTimes(currentUTC);
+            if (marketTimes.marketOpen && marketTimes.open && marketTimes.close) {
+                // Calculate the overlap between our time range and market hours
+                const dayStart = Math.max(startDate.getTime(), marketTimes.open.getTime());
+                const dayEnd = Math.min(endDate.getTime(), marketTimes.close.getTime());
+                // Only count if there's actual overlap
+                if (dayStart < dayEnd) {
+                    totalMinutes += (dayEnd - dayStart) / (1000 * 60);
+                }
+            }
+        }
+        // Move to next day
+        currentNY.setUTCDate(currentNY.getUTCDate() + 1);
+    }
+    // Convert to days, hours, minutes
+    const MINUTES_PER_TRADING_DAY = 390; // 6.5 hours
+    const days = totalMinutes / MINUTES_PER_TRADING_DAY;
+    const hours = totalMinutes / 60;
+    const minutes = totalMinutes;
+    return {
+        days: Math.round(days * 1000) / 1000, // Round to 3 decimal places
+        hours: Math.round(hours * 100) / 100, // Round to 2 decimal places
+        minutes: Math.round(minutes),
+    };
+}
+/**
+ * Returns the trading day N days back from a reference date, along with its market open time.
+ * Trading days are counted as full or half trading days (days that end count as 1 full trading day).
+ * By default, the most recent completed trading day counts as day 1.
+ * Set includeMostRecentFullDay to false to count strictly before that day.
+ *
+ * @param options - Object with:
+ *   - referenceDate: Date to count back from (default: now)
+ *   - days: Number of trading days to go back (must be an integer >= 1)
+ *   - includeMostRecentFullDay: Whether to include the most recent completed trading day (default: true)
+ * @returns Object containing:
+ *   - date: Trading date in YYYY-MM-DD format
+ *   - marketOpenISO: Market open time as ISO string (e.g., "2025-11-15T13:30:00.000Z")
+ *   - unixTimestamp: Market open time as Unix timestamp in seconds
+ * @example
+ * ```typescript
+ * // Get the trading day 1 day back (most recent full trading day)
+ * const result = getTradingDaysBack({ days: 1 });
+ * console.log(result.date); // "2025-11-01"
+ * console.log(result.marketOpenISO); // "2025-11-01T13:30:00.000Z"
+ * console.log(result.unixTimestamp); // 1730466600
+ *
+ * // Get the trading day 5 days back from a specific date
+ * const result2 = getTradingDaysBack({
+ *   referenceDate: new Date('2025-11-15T12:00:00-05:00'),
+ *   days: 5
+ * });
+ * ```
+ */
+function getTradingDaysBack(options) {
+    const calendar = new MarketCalendar();
+    const { referenceDate, days, includeMostRecentFullDay = true } = options;
+    const refDate = referenceDate || new Date();
+    const daysBack = days;
+    if (!Number.isInteger(daysBack) || daysBack < 1) {
+        throw new Error('days must be an integer >= 1');
+    }
+    // Start from the last full trading date relative to reference
+    let targetDate = getLastFullTradingDateImpl(refDate);
+    if (!includeMostRecentFullDay) {
+        targetDate = calendar.getPreviousMarketDay(targetDate);
+    }
+    // Go back the specified number of days (we're already at day 1, so go back days-1 more)
+    for (let i = 1; i < daysBack; i++) {
+        targetDate = calendar.getPreviousMarketDay(targetDate);
+    }
+    // Get market open time for this date
+    const marketTimes = getMarketTimes(targetDate);
+    if (!marketTimes.open) {
+        throw new Error(`No market open time for target date`);
+    }
+    // Format the date string (YYYY-MM-DD) in NY time
+    const nyDate = toNYTime(marketTimes.open);
+    const dateStr = `${nyDate.getUTCFullYear()}-${String(nyDate.getUTCMonth() + 1).padStart(2, '0')}-${String(nyDate.getUTCDate()).padStart(2, '0')}`;
+    const marketOpenISO = marketTimes.open.toISOString();
+    const unixTimestamp = Math.floor(marketTimes.open.getTime() / 1000);
+    return {
+        date: dateStr,
+        marketOpenISO,
+        unixTimestamp,
+    };
+}
+// Export MARKET_TIMES for compatibility
+const MARKET_TIMES = {
+    TIMEZONE: MARKET_CONFIG.TIMEZONE,
+    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_CLOSE_BEFORE_HOLIDAY: {
+        START: { HOUR: 9, MINUTE: 30, MINUTES: 570 },
+        END: { HOUR: 13, MINUTE: 0, MINUTES: 780 },
+    },
+    EARLY_EXTENDED_BEFORE_HOLIDAY: {
+        START: { HOUR: 13, MINUTE: 0, MINUTES: 780 },
+        END: { HOUR: 17, MINUTE: 0, MINUTES: 1020 },
+    },
+    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 },
+    },
+};
 
 /*
 How it works:
@@ -467,8 +1142,18 @@ class Queue {
 }
 
 function pLimit(concurrency) {
+	let rejectOnClear = false;
+
+	if (typeof concurrency === 'object') {
+		({concurrency, rejectOnClear = false} = concurrency);
+	}
+
 	validateConcurrency(concurrency);
 
+	if (typeof rejectOnClear !== 'boolean') {
+		throw new TypeError('Expected `rejectOnClear` to be a boolean');
+	}
+
 	const queue = new Queue();
 	let activeCount = 0;
 
@@ -476,7 +1161,7 @@ function pLimit(concurrency) {
 		// Process the next queued function if we're under the concurrency limit
 		if (activeCount < concurrency && queue.size > 0) {
 			activeCount++;
-			queue.dequeue()();
+			queue.dequeue().run();
 		}
 	};
 
@@ -503,11 +1188,14 @@ function pLimit(concurrency) {
 		next();
 	};
 
-	const enqueue = (function_, resolve, arguments_) => {
+	const enqueue = (function_, resolve, reject, arguments_) => {
+		const queueItem = {reject};
+
 		// Queue the internal resolve function instead of the run function
 		// to preserve the asynchronous execution context.
 		new Promise(internalResolve => { // eslint-disable-line promise/param-names
-			queue.enqueue(internalResolve);
+			queueItem.run = internalResolve;
+			queue.enqueue(queueItem);
 		}).then(run.bind(undefined, function_, resolve, arguments_)); // eslint-disable-line promise/prefer-await-to-then
 
 		// Start processing immediately if we haven't reached the concurrency limit
@@ -516,8 +1204,8 @@ function pLimit(concurrency) {
 		}
 	};
 
-	const generator = (function_, ...arguments_) => new Promise(resolve => {
-		enqueue(function_, resolve, arguments_);
+	const generator = (function_, ...arguments_) => new Promise((resolve, reject) => {
+		enqueue(function_, resolve, reject, arguments_);
 	});
 
 	Object.defineProperties(generator, {
@@ -529,7 +1217,16 @@ function pLimit(concurrency) {
 		},
 		clearQueue: {
 			value() {
-				queue.clear();
+				if (!rejectOnClear) {
+					queue.clear();
+					return;
+				}
+
+				const abortError = AbortSignal.abort().reason;
+
+				while (queue.size > 0) {
+					queue.dequeue().reject(abortError);
+				}
 			},
 		},
 		concurrency: {
@@ -815,7 +1512,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 = '6.15.0'; // x-release-please-version
+const VERSION = '6.17.0'; // x-release-please-version
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 const isRunningInBrowser = () => {
@@ -4108,12 +4805,7 @@ class Assistants extends APIResource {
     /**
      * Create an assistant with a model and instructions.
      *
-     * @example
-     * ```ts
-     * const assistant = await client.beta.assistants.create({
-     *   model: 'gpt-4o',
-     * });
-     * ```
+     * @deprecated
      */
     create(body, options) {
         return this._client.post('/assistants', {
@@ -4125,12 +4817,7 @@ class Assistants extends APIResource {
     /**
      * Retrieves an assistant.
      *
-     * @example
-     * ```ts
-     * const assistant = await client.beta.assistants.retrieve(
-     *   'assistant_id',
-     * );
-     * ```
+     * @deprecated
      */
     retrieve(assistantID, options) {
         return this._client.get(path `/assistants/${assistantID}`, {
@@ -4141,12 +4828,7 @@ class Assistants extends APIResource {
     /**
      * Modifies an assistant.
      *
-     * @example
-     * ```ts
-     * const assistant = await client.beta.assistants.update(
-     *   'assistant_id',
-     * );
-     * ```
+     * @deprecated
      */
     update(assistantID, body, options) {
         return this._client.post(path `/assistants/${assistantID}`, {
@@ -4158,13 +4840,7 @@ class Assistants extends APIResource {
     /**
      * Returns a list of assistants.
      *
-     * @example
-     * ```ts
-     * // Automatically fetches more pages as needed.
-     * for await (const assistant of client.beta.assistants.list()) {
-     *   // ...
-     * }
-     * ```
+     * @deprecated
      */
     list(query = {}, options) {
         return this._client.getAPIList('/assistants', (CursorPage), {
@@ -4176,11 +4852,7 @@ class Assistants extends APIResource {
     /**
      * Delete an assistant.
      *
-     * @example
-     * ```ts
-     * const assistantDeleted =
-     *   await client.beta.assistants.delete('assistant_id');
-     * ```
+     * @deprecated
      */
     delete(assistantID, options) {
         return this._client.delete(path `/assistants/${assistantID}`, {
@@ -5654,8 +6326,8 @@ Evals.Runs = Runs;
 let Files$1 = class Files extends APIResource {
     /**
      * Upload a file that can be used across various endpoints. Individual files can be
-     * up to 512 MB, and the size of all files uploaded by one organization can be up
-     * to 1 TB.
+     * up to 512 MB, and each project can store up to 2.5 TB of files in total. There
+     * is no organization-wide storage limit.
      *
      * - The Assistants API supports files up to 2 million tokens and of specific file
      *   types. See the
@@ -13295,6 +13967,11 @@ class AlpacaMarketDataAPI extends EventEmitter {
     optionWs = null;
     stockSubscriptions = { trades: [], quotes: [], bars: [] };
     optionSubscriptions = { trades: [], quotes: [], bars: [] };
+    autoReconnect = true;
+    stockReconnectAttempts = 0;
+    optionReconnectAttempts = 0;
+    stockReconnectTimeout = null;
+    optionReconnectTimeout = null;
     setMode(mode = 'production') {
         if (mode === 'sandbox') {
             // sandbox mode
@@ -13323,6 +14000,13 @@ class AlpacaMarketDataAPI extends EventEmitter {
             return 'production';
         }
     }
+    setAutoReconnect(enabled) {
+        this.autoReconnect = enabled;
+        log(`Auto-reconnect ${enabled ? 'enabled' : 'disabled'}`);
+    }
+    getAutoReconnect() {
+        return this.autoReconnect;
+    }
     constructor() {
         super();
         this.dataURL = 'https://data.alpaca.markets/v2';
@@ -13345,6 +14029,36 @@ class AlpacaMarketDataAPI extends EventEmitter {
         }
         return AlpacaMarketDataAPI.instance;
     }
+    getReconnectDelay(attempt) {
+        // 0: instant (0ms), 1: 5s, 2: 10s, 3: 15s, 4+: 60s
+        const delays = [0, 5000, 10000, 15000, 60000];
+        return attempt < delays.length ? delays[attempt] : 60000;
+    }
+    scheduleReconnect(streamType) {
+        if (!this.autoReconnect) {
+            log(`Auto-reconnect disabled, not reconnecting ${streamType} stream`);
+            return;
+        }
+        const attempts = streamType === 'stock' ? this.stockReconnectAttempts : this.optionReconnectAttempts;
+        const delay = this.getReconnectDelay(attempts);
+        log(`Scheduling ${streamType} stream reconnect (attempt ${attempts + 1}) in ${delay}ms`);
+        const timeout = setTimeout(() => {
+            log(`Attempting to reconnect ${streamType} stream (attempt ${attempts + 1})`);
+            if (streamType === 'stock') {
+                this.stockReconnectAttempts++;
+            }
+            else {
+                this.optionReconnectAttempts++;
+            }
+            this.connect(streamType);
+        }, delay);
+        if (streamType === 'stock') {
+            this.stockReconnectTimeout = timeout;
+        }
+        else {
+            this.optionReconnectTimeout = timeout;
+        }
+    }
     on(event, listener) {
         return super.on(event, listener);
     }
@@ -13362,6 +14076,21 @@ class AlpacaMarketDataAPI extends EventEmitter {
         }
         ws.on('open', () => {
             log(`${streamType} stream connected`);
+            // Reset reconnect attempts on successful connection
+            if (streamType === 'stock') {
+                this.stockReconnectAttempts = 0;
+                if (this.stockReconnectTimeout) {
+                    clearTimeout(this.stockReconnectTimeout);
+                    this.stockReconnectTimeout = null;
+                }
+            }
+            else {
+                this.optionReconnectAttempts = 0;
+                if (this.optionReconnectTimeout) {
+                    clearTimeout(this.optionReconnectTimeout);
+                    this.optionReconnectTimeout = null;
+                }
+            }
             const authMessage = {
                 action: 'auth',
                 key: process.env.ALPACA_API_KEY,
@@ -13386,20 +14115,42 @@ class AlpacaMarketDataAPI extends EventEmitter {
                 }
             }
         });
-        ws.on('close', () => {
-            log(`${streamType} stream disconnected`, { type: 'warn' });
+        ws.on('close', (code, reason) => {
+            const reasonStr = reason.toString() || 'No reason provided';
+            const codeDesc = this.getCloseCodeDescription(code);
+            log(`${streamType} stream disconnected - Code: ${code} (${codeDesc}), Reason: ${reasonStr}`, { type: 'warn' });
             if (streamType === 'stock') {
                 this.stockWs = null;
             }
             else {
                 this.optionWs = null;
             }
-            // Optional: implement reconnect logic
+            this.scheduleReconnect(streamType);
         });
         ws.on('error', (error) => {
             log(`${streamType} stream error: ${error.message}`, { type: 'error' });
         });
     }
+    getCloseCodeDescription(code) {
+        const codes = {
+            1000: 'Normal Closure',
+            1001: 'Going Away',
+            1002: 'Protocol Error',
+            1003: 'Unsupported Data',
+            1005: 'No Status Received',
+            1006: 'Abnormal Closure',
+            1007: 'Invalid Frame Payload Data',
+            1008: 'Policy Violation',
+            1009: 'Message Too Big',
+            1010: 'Mandatory Extension',
+            1011: 'Internal Server Error',
+            1012: 'Service Restart',
+            1013: 'Try Again Later',
+            1014: 'Bad Gateway',
+            1015: 'TLS Handshake',
+        };
+        return codes[code] || 'Unknown';
+    }
     sendSubscription(streamType) {
         const ws = streamType === 'stock' ? this.stockWs : this.optionWs;
         const subscriptions = streamType === 'stock' ? this.stockSubscriptions : this.optionSubscriptions;
@@ -13434,11 +14185,21 @@ class AlpacaMarketDataAPI extends EventEmitter {
         }
     }
     disconnectStockStream() {
+        if (this.stockReconnectTimeout) {
+            clearTimeout(this.stockReconnectTimeout);
+            this.stockReconnectTimeout = null;
+        }
+        this.stockReconnectAttempts = 0;
         if (this.stockWs) {
             this.stockWs.close();
         }
     }
     disconnectOptionStream() {
+        if (this.optionReconnectTimeout) {
+            clearTimeout(this.optionReconnectTimeout);
+            this.optionReconnectTimeout = null;
+        }
+        this.optionReconnectAttempts = 0;
         if (this.optionWs) {
             this.optionWs.close();
         }
@@ -14429,1622 +15190,132 @@ class AlpacaMarketDataAPI extends EventEmitter {
     }
 }
 // Export the singleton instance
-const marketDataAPI = AlpacaMarketDataAPI.getInstance();
+AlpacaMarketDataAPI.getInstance();
+
+const disco = {
+    time: {
+        convertDateToMarketTimeZone: convertDateToMarketTimeZone,
+        getStartAndEndDates: getStartAndEndDates,
+        getMarketOpenClose: getMarketOpenClose,
+        getOpenCloseForTradingDay: getOpenCloseForTradingDay,
+        getLastFullTradingDate: getLastFullTradingDate,
+        getNextMarketDay: getNextMarketDay,
+        getPreviousMarketDay: getPreviousMarketDay,
+        getMarketTimePeriod: getMarketTimePeriod,
+        getMarketStatus: getMarketStatus,
+        getNYTimeZone: getNYTimeZone,
+        getTradingDate: getTradingDate,
+        getTradingStartAndEndDates: getTradingStartAndEndDates,
+        getTradingDaysBack: getTradingDaysBack,
+        isMarketDay: isMarketDay,
+        isWithinMarketHours: isWithinMarketHours,
+        countTradingDays: countTradingDays,
+        MARKET_TIMES: MARKET_TIMES,
+    }};
 
-const limitPriceSlippagePercent100 = 0.1; // 0.1%
-/**
-Websocket example
-  const alpacaAPI = createAlpacaTradingAPI(credentials); // type AlpacaCredentials
-  alpacaAPI.onTradeUpdate((update: TradeUpdate) => {
-   this.log(`Received trade update: event ${update.event} for an order to ${update.order.side} ${update.order.qty} of ${update.order.symbol}`);
-  });
-  alpacaAPI.connectWebsocket(); // necessary to connect to the WebSocket
-
-Portfolio History examples
-  // Get standard portfolio history
-  const portfolioHistory = await alpacaAPI.getPortfolioHistory({
-    timeframe: '1D',
-    period: '1M'
-  });
-
-  // Get daily portfolio history with current day included (if available from hourly data)
-  const dailyHistory = await alpacaAPI.getPortfolioDailyHistory({
-    period: '1M'
-  });
-*/
-class AlpacaTradingAPI {
-    static new(credentials) {
-        return new AlpacaTradingAPI(credentials);
-    }
-    static getInstance(credentials) {
-        return new AlpacaTradingAPI(credentials);
-    }
-    ws = null;
-    headers;
-    tradeUpdateCallback = null;
-    credentials;
-    apiBaseUrl;
-    wsUrl;
-    authenticated = false;
-    connecting = false;
-    reconnectDelay = 10000; // 10 seconds between reconnection attempts
-    reconnectTimeout = null;
-    messageHandlers = new Map();
-    debugLogging = false;
-    manualDisconnect = false;
-    /**
-     * Constructor for AlpacaTradingAPI
-     * @param credentials - Alpaca credentials,
-     *   accountName: string; // The account identifier used inthis.logs and tracking
-     *   apiKey: string; // Alpaca API key
-     *   apiSecret: string; // Alpaca API secret
-     *   type: AlpacaAccountType;
-     *   orderType: AlpacaOrderType;
-     * @param options - Optional options
-     *   debugLogging: boolean; // Whether to log messages of type 'debug'
-     */
-    constructor(credentials, options) {
-        this.credentials = credentials;
-        // Set URLs based on account type
-        this.apiBaseUrl =
-            credentials.type === 'PAPER' ? 'https://paper-api.alpaca.markets/v2' : 'https://api.alpaca.markets/v2';
-        this.wsUrl =
-            credentials.type === 'PAPER' ? 'wss://paper-api.alpaca.markets/stream' : 'wss://api.alpaca.markets/stream';
-        this.headers = {
-            'APCA-API-KEY-ID': credentials.apiKey,
-            'APCA-API-SECRET-KEY': credentials.apiSecret,
-            'Content-Type': 'application/json',
-        };
-        // Initialize message handlers
-        this.messageHandlers.set('authorization', this.handleAuthMessage.bind(this));
-        this.messageHandlers.set('listening', this.handleListenMessage.bind(this));
-        this.messageHandlers.set('trade_updates', this.handleTradeUpdate.bind(this));
-        this.debugLogging = options?.debugLogging || false;
-    }
-    log(message, options = { type: 'info' }) {
-        if (this.debugLogging && options.type === 'debug') {
-            return;
-        }
-        log$1(message, { ...options, source: 'AlpacaTradingAPI', account: this.credentials.accountName });
-    }
-    /**
-     * Round a price to the nearest 2 decimal places for Alpaca, or 4 decimal places for prices less than $1
-     * @param price - The price to round
-     * @returns The rounded price
-     */
-    roundPriceForAlpaca = (price) => {
-        return price >= 1 ? Math.round(price * 100) / 100 : Math.round(price * 10000) / 10000;
-    };
-    handleAuthMessage(data) {
-        if (data.status === 'authorized') {
-            this.authenticated = true;
-            this.log('WebSocket authenticated');
-        }
-        else {
-            this.log(`Authentication failed: ${data.message || 'Unknown error'}`, {
-                type: 'error',
-            });
-        }
-    }
-    handleListenMessage(data) {
-        if (data.streams?.includes('trade_updates')) {
-            this.log('Successfully subscribed to trade updates');
-        }
-    }
-    handleTradeUpdate(data) {
-        if (this.tradeUpdateCallback) {
-            this.log(`Trade update: ${data.event} to ${data.order.side} ${data.order.qty} shares${data.event === 'partial_fill' ? ` (filled shares: ${data.order.filled_qty})` : ''}, type ${data.order.type}`, {
-                symbol: data.order.symbol,
-                type: 'debug',
-            });
-            this.tradeUpdateCallback(data);
-        }
-    }
-    handleMessage(message) {
-        try {
-            const data = JSON.parse(message);
-            const handler = this.messageHandlers.get(data.stream);
-            if (handler) {
-                handler(data.data);
-            }
-            else {
-                this.log(`Received message for unknown stream: ${data.stream}`, {
-                    type: 'warn',
-                });
-            }
-        }
-        catch (error) {
-            this.log('Failed to parse WebSocket message', {
-                type: 'error',
-                metadata: { error: error instanceof Error ? error.message : 'Unknown error' },
-            });
-        }
-    }
-    connectWebsocket() {
-        // Reset manual disconnect flag to allow reconnection logic
-        this.manualDisconnect = false;
-        if (this.connecting) {
-            this.log('Connection attempt skipped - already connecting');
-            return;
-        }
-        if (this.ws?.readyState === WebSocket.OPEN) {
-            this.log('Connection attempt skipped - already connected');
-            return;
-        }
-        this.connecting = true;
-        if (this.ws) {
-            this.ws.removeAllListeners();
-            this.ws.terminate();
-            this.ws = null;
-        }
-        this.log(`Connecting to WebSocket at ${this.wsUrl}...`);
-        this.ws = new WebSocket(this.wsUrl);
-        this.ws.on('open', async () => {
-            try {
-                this.log('WebSocket connected');
-                await this.authenticate();
-                await this.subscribeToTradeUpdates();
-                this.connecting = false;
-            }
-            catch (error) {
-                this.log('Failed to setup WebSocket connection', {
-                    type: 'error',
-                    metadata: { error: error instanceof Error ? error.message : 'Unknown error' },
-                });
-                this.ws?.close();
-            }
-        });
-        this.ws.on('message', (data) => {
-            this.handleMessage(data.toString());
-        });
-        this.ws.on('error', (error) => {
-            this.log('WebSocket error', {
-                type: 'error',
-                metadata: { error: error instanceof Error ? error.message : 'Unknown error' },
-            });
-            this.connecting = false;
-        });
-        this.ws.on('close', () => {
-            this.log('WebSocket connection closed');
-            this.authenticated = false;
-            this.connecting = false;
-            // Clear any existing reconnect timeout
-            if (this.reconnectTimeout) {
-                clearTimeout(this.reconnectTimeout);
-                this.reconnectTimeout = null;
-            }
-            // Schedule reconnection unless this was a manual disconnect
-            if (!this.manualDisconnect) {
-                this.reconnectTimeout = setTimeout(() => {
-                    this.log('Attempting to reconnect...');
-                    this.connectWebsocket();
-                }, this.reconnectDelay);
-            }
-        });
-    }
-    /**
-     * Cleanly disconnect from the WebSocket and stop auto-reconnects
-     */
-    disconnect() {
-        // Prevent auto-reconnect scheduling
-        this.manualDisconnect = true;
-        // Clear any scheduled reconnect
-        if (this.reconnectTimeout) {
-            clearTimeout(this.reconnectTimeout);
-            this.reconnectTimeout = null;
-        }
-        if (this.ws) {
-            this.log('Disconnecting WebSocket...');
-            // Remove listeners first to avoid duplicate handlers after reconnects
-            this.ws.removeAllListeners();
-            try {
-                // Attempt graceful close
-                if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
-                    this.ws.close(1000, 'Client disconnect');
-                }
-                else {
-                    this.ws.terminate();
-                }
-            }
-            catch {
-                // Fallback terminate on any error
-                try {
-                    this.ws.terminate();
-                }
-                catch {
-                    /* no-op */
-                }
-            }
-            this.ws = null;
-        }
-        this.authenticated = false;
-        this.connecting = false;
-        this.log('WebSocket disconnected');
-    }
-    async authenticate() {
-        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-            throw new Error('WebSocket not ready for authentication');
-        }
-        const authMessage = {
-            action: 'auth',
-            key: this.credentials.apiKey,
-            secret: this.credentials.apiSecret,
-        };
-        this.ws.send(JSON.stringify(authMessage));
-        return new Promise((resolve, reject) => {
-            const authTimeout = setTimeout(() => {
-                this.log('Authentication timeout', { type: 'error' });
-                reject(new Error('Authentication timed out'));
-            }, 10000);
-            const handleAuthResponse = (data) => {
-                try {
-                    const message = JSON.parse(data.toString());
-                    if (message.stream === 'authorization') {
-                        this.ws?.removeListener('message', handleAuthResponse);
-                        clearTimeout(authTimeout);
-                        if (message.data?.status === 'authorized') {
-                            this.authenticated = true;
-                            resolve();
-                        }
-                        else {
-                            const error = `Authentication failed: ${message.data?.message || 'Unknown error'}`;
-                            this.log(error, { type: 'error' });
-                            reject(new Error(error));
-                        }
-                    }
-                }
-                catch (error) {
-                    this.log('Failed to parse auth response', {
-                        type: 'error',
-                        metadata: { error: error instanceof Error ? error.message : 'Unknown error' },
-                    });
-                }
-            };
-            this.ws?.on('message', handleAuthResponse);
-        });
-    }
-    async subscribeToTradeUpdates() {
-        if (!this.ws || this.ws.readyState !== WebSocket.OPEN || !this.authenticated) {
-            throw new Error('WebSocket not ready for subscription');
-        }
-        const listenMessage = {
-            action: 'listen',
-            data: {
-                streams: ['trade_updates'],
-            },
-        };
-        this.ws.send(JSON.stringify(listenMessage));
-        return new Promise((resolve, reject) => {
-            const listenTimeout = setTimeout(() => {
-                reject(new Error('Subscribe timeout'));
-            }, 10000);
-            const handleListenResponse = (data) => {
-                try {
-                    const message = JSON.parse(data.toString());
-                    if (message.stream === 'listening') {
-                        this.ws?.removeListener('message', handleListenResponse);
-                        clearTimeout(listenTimeout);
-                        if (message.data?.streams?.includes('trade_updates')) {
-                            resolve();
-                        }
-                        else {
-                            reject(new Error('Failed to subscribe to trade updates'));
-                        }
-                    }
-                }
-                catch (error) {
-                    this.log('Failed to parse listen response', {
-                        type: 'error',
-                        metadata: { error: error instanceof Error ? error.message : 'Unknown error' },
-                    });
-                }
-            };
-            this.ws?.on('message', handleListenResponse);
-        });
-    }
-    async makeRequest(endpoint, method = 'GET', body, queryString = '') {
-        const url = `${this.apiBaseUrl}${endpoint}${queryString}`;
-        try {
-            const response = await fetch(url, {
-                method,
-                headers: this.headers,
-                body: body ? JSON.stringify(body) : undefined,
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                this.log(`Alpaca API error (${response.status}): ${errorText}`, { type: 'error' });
-                throw new Error(`Alpaca API error (${response.status}): ${errorText}`);
-            }
-            // Handle responses with no content (e.g., 204 No Content)
-            if (response.status === 204 || response.headers.get('content-length') === '0') {
-                return null;
-            }
-            const contentType = response.headers.get('content-type');
-            if (contentType && contentType.includes('application/json')) {
-                return await response.json();
-            }
-            // For non-JSON responses, return the text content
-            const textContent = await response.text();
-            return textContent || null;
-        }
-        catch (err) {
-            const error = err;
-            this.log(`Error in makeRequest: ${error.message}. Url: ${url}`, {
-                source: 'AlpacaAPI',
-                type: 'error',
-            });
-            throw error;
-        }
-    }
-    async getPositions(assetClass) {
-        const positions = (await this.makeRequest('/positions'));
-        if (assetClass) {
-            return positions.filter((position) => position.asset_class === assetClass);
-        }
-        return positions;
-    }
-    /**
-     * Get all orders
-     * @param params (GetOrdersParams) - optional parameters to filter the orders
-     * - status: 'open' | 'closed' | 'all'
-     * - limit: number
-     * - after: string
-     * - until: string
-     * - direction: 'asc' | 'desc'
-     * - nested: boolean
-     * - symbols: string[], an array of all the symbols
-     * - side: 'buy' | 'sell'
-     * @returns all orders
-     */
-    async getOrders(params = {}) {
-        const queryParams = new URLSearchParams();
-        if (params.status)
-            queryParams.append('status', params.status);
-        if (params.limit)
-            queryParams.append('limit', params.limit.toString());
-        if (params.after)
-            queryParams.append('after', params.after);
-        if (params.until)
-            queryParams.append('until', params.until);
-        if (params.direction)
-            queryParams.append('direction', params.direction);
-        if (params.nested)
-            queryParams.append('nested', params.nested.toString());
-        if (params.symbols)
-            queryParams.append('symbols', params.symbols.join(','));
-        if (params.side)
-            queryParams.append('side', params.side);
-        const endpoint = `/orders${queryParams.toString() ? `?${queryParams.toString()}` : ''}`;
-        try {
-            return await this.makeRequest(endpoint);
-        }
-        catch (error) {
-            this.log(`Error getting orders: ${error}`, { type: 'error' });
-            throw error;
-        }
-    }
-    async getAccountDetails() {
-        try {
-            return await this.makeRequest('/account');
-        }
-        catch (error) {
-            this.log(`Error getting account details: ${error}`, { type: 'error' });
-            throw error;
-        }
-    }
-    /**
-     * Create a trailing stop order
-     * @param symbol (string) - the symbol of the order
-     * @param qty (number) - the quantity of the order
-     * @param side (string) - the side of the order
-     * @param trailPercent100 (number) - the trail percent of the order (scale 100, i.e. 0.5 = 0.5%)
-     * @param position_intent (string) - the position intent of the order
-     */
-    async createTrailingStop(symbol, qty, side, trailPercent100, position_intent) {
-        this.log(`Creating trailing stop ${side.toUpperCase()} ${qty} shares for ${symbol} with trail percent ${trailPercent100}%`, {
-            symbol,
-        });
-        try {
-            await this.makeRequest(`/orders`, 'POST', {
-                symbol,
-                qty: Math.abs(qty),
-                side,
-                position_intent,
-                order_class: 'simple',
-                type: 'trailing_stop',
-                trail_percent: trailPercent100, // Already in decimal form (e.g., 4 for 4%)
-                time_in_force: 'gtc',
-            });
-        }
-        catch (error) {
-            this.log(`Error creating trailing stop: ${error}`, {
-                symbol,
-                type: 'error',
-            });
-            throw error;
-        }
-    }
-    /**
-     * Create a market order
-     * @param symbol (string) - the symbol of the order
-     * @param qty (number) - the quantity of the order
-     * @param side (string) - the side of the order
-     * @param position_intent (string) - the position intent of the order. Important for knowing if a position needs a trailing stop.
-     * @param client_order_id (string) - optional client order id
-     */
-    async createMarketOrder(symbol, qty, side, position_intent, client_order_id) {
-        this.log(`Creating market order for ${symbol}: ${side} ${qty} shares (${position_intent})`, {
-            symbol,
-        });
-        const body = {
-            symbol,
-            qty: Math.abs(qty).toString(),
-            side,
-            position_intent,
-            type: 'market',
-            time_in_force: 'day',
-            order_class: 'simple',
-        };
-        if (client_order_id !== undefined) {
-            body.client_order_id = client_order_id;
-        }
-        try {
-            return await this.makeRequest('/orders', 'POST', body);
-        }
-        catch (error) {
-            this.log(`Error creating market order: ${error}`, { type: 'error' });
-            throw error;
-        }
-    }
-    /**
-     * Create a Market on Open (MOO) order - executes in the opening auction
-     *
-     * IMPORTANT TIMING CONSTRAINTS:
-     * - Valid submission window: After 7:00pm ET and before 9:28am ET
-     * - Orders submitted between 9:28am and 7:00pm ET will be REJECTED
-     * - Orders submitted after 7:00pm ET are queued for the next trading day's opening auction
-     * - Example: An order at 8:00pm Monday will execute at Tuesday's market open (9:30am)
-     *
-     * @param symbol - The symbol of the order
-     * @param qty - The quantity of shares
-     * @param side - Buy or sell
-     * @param position_intent - The position intent (buy_to_open, sell_to_close, etc.)
-     * @param client_order_id - Optional client order id
-     * @returns The created order
-     */
-    async createMOOOrder(symbol, qty, side, position_intent, client_order_id) {
-        this.log(`Creating Market on Open order for ${symbol}: ${side} ${qty} shares (${position_intent})`, {
-            symbol,
-        });
-        const body = {
-            symbol,
-            qty: Math.abs(qty).toString(),
-            side,
-            position_intent,
-            type: 'market',
-            time_in_force: 'opg',
-            order_class: 'simple',
-        };
-        if (client_order_id !== undefined) {
-            body.client_order_id = client_order_id;
-        }
-        try {
-            return await this.makeRequest('/orders', 'POST', body);
-        }
-        catch (error) {
-            this.log(`Error creating MOO order: ${error}`, { type: 'error' });
-            throw error;
-        }
-    }
-    /**
-     * Create a Market on Close (MOC) order - executes in the closing auction
-     *
-     * IMPORTANT TIMING CONSTRAINTS:
-     * - Valid submission window: After 7:00pm ET (previous day) and before 3:50pm ET (same day)
-     * - Orders submitted between 3:50pm and 7:00pm ET will be REJECTED
-     * - Orders submitted after 7:00pm ET are queued for the next trading day's closing auction
-     * - Example: An order at 8:00pm Monday will execute at Tuesday's market close (4:00pm)
-     *
-     * @param symbol - The symbol of the order
-     * @param qty - The quantity of shares
-     * @param side - Buy or sell
-     * @param position_intent - The position intent (buy_to_open, sell_to_close, etc.)
-     * @param client_order_id - Optional client order id
-     * @returns The created order
-     */
-    async createMOCOrder(symbol, qty, side, position_intent, client_order_id) {
-        this.log(`Creating Market on Close order for ${symbol}: ${side} ${qty} shares (${position_intent})`, {
-            symbol,
-        });
-        const body = {
-            symbol,
-            qty: Math.abs(qty).toString(),
-            side,
-            position_intent,
-            type: 'market',
-            time_in_force: 'cls',
-            order_class: 'simple',
-        };
-        if (client_order_id !== undefined) {
-            body.client_order_id = client_order_id;
-        }
-        try {
-            return await this.makeRequest('/orders', 'POST', body);
-        }
-        catch (error) {
-            this.log(`Error creating MOC order: ${error}`, { type: 'error' });
-            throw error;
-        }
-    }
-    /**
-     * Get the current trail percent for a symbol, assuming that it has an open position and a trailing stop order to close it. Because this relies on an orders request for one symbol, you can't do it too often.
-     * @param symbol (string) - the symbol of the order
-     * @returns the current trail percent
-     */
-    async getCurrentTrailPercent(symbol) {
-        try {
-            const orders = await this.getOrders({
-                status: 'open',
-                symbols: [symbol],
-            });
-            const trailingStopOrder = orders.find((order) => order.type === 'trailing_stop' &&
-                (order.position_intent === 'sell_to_close' || order.position_intent === 'buy_to_close'));
-            if (!trailingStopOrder) {
-                this.log(`No closing trailing stop order found for ${symbol}`, {
-                    symbol,
-                });
-                return null;
-            }
-            if (!trailingStopOrder.trail_percent) {
-                this.log(`Trailing stop order found for ${symbol} but no trail_percent value`, {
-                    symbol,
-                });
-                return null;
-            }
-            const trailPercent = parseFloat(trailingStopOrder.trail_percent);
-            return trailPercent;
-        }
-        catch (error) {
-            this.log(`Error getting current trail percent: ${error}`, {
-                symbol,
-                type: 'error',
-            });
-            throw error;
-        }
-    }
-    /**
-     * Update the trail percent for a trailing stop order
-     * @param symbol (string) - the symbol of the order
-     * @param trailPercent100 (number) - the trail percent of the order (scale 100, i.e. 0.5 = 0.5%)
-     */
-    async updateTrailingStop(symbol, trailPercent100) {
-        // First get all open orders for this symbol
-        const orders = await this.getOrders({
-            status: 'open',
-            symbols: [symbol],
-        });
-        // Find the trailing stop order
-        const trailingStopOrder = orders.find((order) => order.type === 'trailing_stop');
-        if (!trailingStopOrder) {
-            this.log(`No open trailing stop order found for ${symbol}`, { type: 'error', symbol });
-            return;
-        }
-        // Check if the trail_percent is already set to the desired value
-        const currentTrailPercent = trailingStopOrder.trail_percent ? parseFloat(trailingStopOrder.trail_percent) : null;
-        // Compare with a small epsilon to handle floating point precision
-        const epsilon = 0.0001;
-        if (currentTrailPercent !== null && Math.abs(currentTrailPercent - trailPercent100) < epsilon) {
-            this.log(`Trailing stop for ${symbol} already set to ${trailPercent100}% (current: ${currentTrailPercent}%), skipping update`, {
-                symbol,
-            });
-            return;
-        }
-        this.log(`Updating trailing stop for ${symbol} from ${currentTrailPercent}% to ${trailPercent100}%`, {
-            symbol,
-        });
-        try {
-            await this.makeRequest(`/orders/${trailingStopOrder.id}`, 'PATCH', {
-                trail: trailPercent100.toString(), // Changed from trail_percent to trail
-            });
-        }
-        catch (error) {
-            this.log(`Error updating trailing stop: ${error}`, {
-                symbol,
-                type: 'error',
-            });
-            throw error;
-        }
-    }
-    /**
-     * Cancel all open orders
-     */
-    async cancelAllOrders() {
-        this.log(`Canceling all open orders`);
-        try {
-            await this.makeRequest('/orders', 'DELETE');
-        }
-        catch (error) {
-            this.log(`Error canceling all orders: ${error}`, { type: 'error' });
-        }
-    }
-    /**
-     * Cancel a specific order by its ID
-     * @param orderId The id of the order to cancel
-     * @throws Error if the order is not cancelable (status 422) or if the order doesn't exist
-     * @returns Promise that resolves when the order is successfully canceled
-     */
-    async cancelOrder(orderId) {
-        this.log(`Attempting to cancel order ${orderId}`);
-        try {
-            await this.makeRequest(`/orders/${orderId}`, 'DELETE');
-            this.log(`Successfully canceled order ${orderId}`);
-        }
-        catch (error) {
-            // If the error is a 422, it means the order is not cancelable
-            if (error instanceof Error && error.message.includes('422')) {
-                this.log(`Order ${orderId} is not cancelable`, {
-                    type: 'error',
-                });
-                throw new Error(`Order ${orderId} is not cancelable`);
-            }
-            // Re-throw other errors
-            throw error;
-        }
-    }
-    /**
-     * Create a limit order
-     * @param symbol (string) - the symbol of the order
-     * @param qty (number) - the quantity of the order
-     * @param side (string) - the side of the order
-     * @param limitPrice (number) - the limit price of the order
-     * @param position_intent (string) - the position intent of the order
-     * @param extended_hours (boolean) - whether the order is in extended hours
-     * @param client_order_id (string) - the client order id of the order
-     */
-    async createLimitOrder(symbol, qty, side, limitPrice, position_intent, extended_hours = false, client_order_id) {
-        this.log(`Creating limit order for ${symbol}: ${side} ${qty} shares at $${limitPrice.toFixed(2)} (${position_intent})`, {
-            symbol,
-        });
-        const body = {
-            symbol,
-            qty: Math.abs(qty).toString(),
-            side,
-            position_intent,
-            type: 'limit',
-            limit_price: this.roundPriceForAlpaca(limitPrice).toString(),
-            time_in_force: 'day',
-            order_class: 'simple',
-            extended_hours,
-        };
-        if (client_order_id !== undefined) {
-            body.client_order_id = client_order_id;
-        }
-        try {
-            return await this.makeRequest('/orders', 'POST', body);
-        }
-        catch (error) {
-            this.log(`Error creating limit order: ${error}`, { type: 'error' });
-            throw error;
-        }
-    }
-    /**
-     * Close all equities positions
-     * @param options (object) - the options for closing the positions
-     * - cancel_orders (boolean) - whether to cancel related orders
-     * - useLimitOrders (boolean) - whether to use limit orders to close the positions
-     */
-    async closeAllPositions(options = { cancel_orders: true, useLimitOrders: false }) {
-        this.log(`Closing all positions${options.useLimitOrders ? ' using limit orders' : ''}${options.cancel_orders ? ' and canceling open orders' : ''}`);
-        if (options.useLimitOrders) {
-            // Get all positions
-            const positions = await this.getPositions('us_equity');
-            if (positions.length === 0) {
-                this.log('No positions to close');
-                return;
-            }
-            this.log(`Found ${positions.length} positions to close`);
-            // Get latest quotes for all positions
-            const symbols = positions.map((position) => position.symbol);
-            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', {
-                    type: 'error',
-                });
-                return;
-            }
-            if (lengthOfQuotes !== positions.length) {
-                this.log(`Received ${lengthOfQuotes} quotes for ${positions.length} positions, expected ${positions.length} quotes`, { type: 'warn' });
-                return;
-            }
-            // Create limit orders to close each position
-            for (const position of positions) {
-                const quote = quotesResponse.quotes[position.symbol];
-                if (!quote) {
-                    this.log(`No quote available for ${position.symbol}, skipping limit order`, {
-                        symbol: position.symbol,
-                        type: 'warn',
-                    });
-                    continue;
-                }
-                const qty = Math.abs(parseFloat(position.qty));
-                const side = position.side === 'long' ? 'sell' : 'buy';
-                const positionIntent = side === 'sell' ? 'sell_to_close' : 'buy_to_close';
-                // Get the current price from the quote
-                const currentPrice = side === 'sell' ? quote.bp : quote.ap; // Use bid for sells, ask for buys
-                if (!currentPrice) {
-                    this.log(`No valid price available for ${position.symbol}, skipping limit order`, {
-                        symbol: position.symbol,
-                        type: 'warn',
-                    });
-                    continue;
-                }
-                // Apply slippage from config
-                const limitSlippagePercent1 = limitPriceSlippagePercent100 / 100;
-                const limitPrice = side === 'sell'
-                    ? this.roundPriceForAlpaca(currentPrice * (1 - limitSlippagePercent1)) // Sell slightly lower
-                    : this.roundPriceForAlpaca(currentPrice * (1 + limitSlippagePercent1)); // Buy slightly higher
-                this.log(`Creating limit order to close ${position.symbol} position: ${side} ${qty} shares at $${limitPrice.toFixed(2)}`, {
-                    symbol: position.symbol,
-                });
-                await this.createLimitOrder(position.symbol, qty, side, limitPrice, positionIntent);
-            }
-        }
-        else {
-            await this.makeRequest('/positions', 'DELETE', undefined, options.cancel_orders ? '?cancel_orders=true' : '');
-        }
-    }
-    /**
-     * Close all equities positions using limit orders during extended hours trading
-     * @param cancelOrders Whether to cancel related orders (default: true)
-     * @returns Promise that resolves when all positions are closed
-     */
-    async closeAllPositionsAfterHours() {
-        this.log('Closing all positions using limit orders during extended hours trading');
-        // Get all positions
-        const positions = await this.getPositions();
-        this.log(`Found ${positions.length} positions to close`);
-        if (positions.length === 0) {
-            this.log('No positions to close');
-            return;
-        }
-        await this.cancelAllOrders();
-        this.log(`Cancelled all open orders`);
-        // Get latest quotes for all positions
-        const symbols = positions.map((position) => position.symbol);
-        const quotesResponse = await marketDataAPI.getLatestQuotes(symbols);
-        // Create limit orders to close each position
-        for (const position of positions) {
-            const quote = quotesResponse.quotes[position.symbol];
-            if (!quote) {
-                this.log(`No quote available for ${position.symbol}, skipping limit order`, {
-                    symbol: position.symbol,
-                    type: 'warn',
-                });
-                continue;
-            }
-            const qty = Math.abs(parseFloat(position.qty));
-            const side = position.side === 'long' ? 'sell' : 'buy';
-            const positionIntent = side === 'sell' ? 'sell_to_close' : 'buy_to_close';
-            // Get the current price from the quote
-            const currentPrice = side === 'sell' ? quote.bp : quote.ap; // Use bid for sells, ask for buys
-            if (!currentPrice) {
-                this.log(`No valid price available for ${position.symbol}, skipping limit order`, {
-                    symbol: position.symbol,
-                    type: 'warn',
-                });
-                continue;
-            }
-            // Apply slippage from config
-            const limitSlippagePercent1 = limitPriceSlippagePercent100 / 100;
-            const limitPrice = side === 'sell'
-                ? this.roundPriceForAlpaca(currentPrice * (1 - limitSlippagePercent1)) // Sell slightly lower
-                : this.roundPriceForAlpaca(currentPrice * (1 + limitSlippagePercent1)); // Buy slightly higher
-            this.log(`Creating extended hours limit order to close ${position.symbol} position: ${side} ${qty} shares at $${limitPrice.toFixed(2)}`, {
-                symbol: position.symbol,
-            });
-            await this.createLimitOrder(position.symbol, qty, side, limitPrice, positionIntent, true // Enable extended hours trading
-            );
-        }
-        this.log(`All positions closed: ${positions.map((p) => p.symbol).join(', ')}`);
-    }
-    onTradeUpdate(callback) {
-        this.tradeUpdateCallback = callback;
-    }
-    /**
-     * Get portfolio history for the account
-     * @param params Parameters for the portfolio history request
-     * @returns Portfolio history data
-     */
-    async getPortfolioHistory(params) {
-        const queryParams = new URLSearchParams();
-        if (params.timeframe)
-            queryParams.append('timeframe', params.timeframe);
-        if (params.period)
-            queryParams.append('period', params.period);
-        if (params.extended_hours !== undefined)
-            queryParams.append('extended_hours', params.extended_hours.toString());
-        if (params.start)
-            queryParams.append('start', params.start);
-        if (params.end)
-            queryParams.append('end', params.end);
-        if (params.date_end)
-            queryParams.append('date_end', params.date_end);
-        const response = await this.makeRequest(`/account/portfolio/history?${queryParams.toString()}`);
-        return response;
-    }
-    /**
-     * Get portfolio daily history for the account, ensuring the most recent day is included
-     * by combining daily and hourly history if needed.
-     *
-     * This function performs two API calls:
-     * 1. Retrieves daily portfolio history
-     * 2. Retrieves hourly portfolio history to check for more recent data
-     *
-     * If hourly history has timestamps more recent than the last timestamp in daily history,
-     * it appends one additional day to the daily history using the most recent hourly values.
-     *
-     * @param params Parameters for the portfolio history request (same as getPortfolioHistory except timeframe is forced to '1D')
-     * @returns Portfolio history data with daily timeframe, including the most recent day if available from hourly data
-     */
-    async getPortfolioDailyHistory(params) {
-        // Get daily and hourly history in parallel
-        const dailyParams = { ...params, timeframe: '1D' };
-        const hourlyParams = { timeframe: '1Min', period: '1D' };
-        const [dailyHistory, hourlyHistory] = await Promise.all([
-            this.getPortfolioHistory(dailyParams),
-            this.getPortfolioHistory(hourlyParams),
-        ]);
-        // If no hourly history, return daily as-is
-        if (!hourlyHistory.timestamp || hourlyHistory.timestamp.length === 0) {
-            return dailyHistory;
-        }
-        // Get the last timestamp from daily history
-        const lastDailyTimestamp = dailyHistory.timestamp[dailyHistory.timestamp.length - 1];
-        // Check if hourly history has more recent data
-        const recentHourlyData = hourlyHistory.timestamp
-            .map((timestamp, index) => ({ timestamp, index }))
-            .filter(({ timestamp }) => timestamp > lastDailyTimestamp);
-        // If no more recent hourly data, return daily history as-is
-        if (recentHourlyData.length === 0) {
-            return dailyHistory;
-        }
-        // Get the most recent hourly data point
-        const mostRecentHourly = recentHourlyData[recentHourlyData.length - 1];
-        const mostRecentIndex = mostRecentHourly.index;
-        // Calculate the timestamp for the new daily entry.
-        // Alpaca's daily history timestamps are at 00:00:00Z for the calendar day
-        // following the NY trading date. Derive the trading date in NY time from the
-        // most recent intraday timestamp, then set the new daily timestamp to
-        // midnight UTC of the next calendar day.
-        const mostRecentMs = mostRecentHourly.timestamp * 1000; // hourly timestamps are seconds
-        const tradingDateStr = getTradingDate(new Date(mostRecentMs)); // e.g., '2025-09-05' (NY trading date)
-        const [yearStr, monthStr, dayStr] = tradingDateStr.split('-');
-        const year = Number(yearStr);
-        const month = Number(monthStr); // 1-based
-        const day = Number(dayStr);
-        const newDailyTimestamp = Math.floor(Date.UTC(year, month - 1, day + 1, 0, 0, 0, 0) / 1000);
-        // Create a new daily history entry with the most recent hourly values
-        const updatedDailyHistory = {
-            ...dailyHistory,
-            timestamp: [...dailyHistory.timestamp, newDailyTimestamp],
-            equity: [...dailyHistory.equity, hourlyHistory.equity[mostRecentIndex]],
-            profit_loss: [...dailyHistory.profit_loss, hourlyHistory.profit_loss[mostRecentIndex]],
-            profit_loss_pct: [...dailyHistory.profit_loss_pct, hourlyHistory.profit_loss_pct[mostRecentIndex]],
-        };
-        return updatedDailyHistory;
-    }
-    /**
-     * Get option contracts based on specified parameters
-     * @param params Parameters to filter option contracts
-     * @returns Option contracts matching the criteria
-     */
-    async getOptionContracts(params) {
-        const queryParams = new URLSearchParams();
-        queryParams.append('underlying_symbols', params.underlying_symbols.join(','));
-        if (params.expiration_date_gte)
-            queryParams.append('expiration_date_gte', params.expiration_date_gte);
-        if (params.expiration_date_lte)
-            queryParams.append('expiration_date_lte', params.expiration_date_lte);
-        if (params.strike_price_gte)
-            queryParams.append('strike_price_gte', params.strike_price_gte);
-        if (params.strike_price_lte)
-            queryParams.append('strike_price_lte', params.strike_price_lte);
-        if (params.type)
-            queryParams.append('type', params.type);
-        if (params.status)
-            queryParams.append('status', params.status);
-        if (params.limit)
-            queryParams.append('limit', params.limit.toString());
-        if (params.page_token)
-            queryParams.append('page_token', params.page_token);
-        this.log(`Fetching option contracts for ${params.underlying_symbols.join(', ')}`, {
-            symbol: params.underlying_symbols.join(', '),
-        });
-        const response = (await this.makeRequest(`/options/contracts?${queryParams.toString()}`));
-        this.log(`Found ${response.option_contracts.length} option contracts`, {
-            symbol: params.underlying_symbols.join(', '),
-        });
-        return response;
-    }
-    /**
-     * Get a specific option contract by symbol or ID
-     * @param symbolOrId The symbol or ID of the option contract
-     * @returns The option contract details
-     */
-    async getOptionContract(symbolOrId) {
-        this.log(`Fetching option contract details for ${symbolOrId}`, {
-            symbol: symbolOrId,
-        });
-        const response = (await this.makeRequest(`/options/contracts/${symbolOrId}`));
-        this.log(`Found option contract details for ${symbolOrId}: ${response.name}`, {
-            symbol: symbolOrId,
-        });
-        return response;
-    }
-    /**
-     * Create a simple option order (market or limit)
-     * @param symbol Option contract symbol
-     * @param qty Quantity of contracts (must be a whole number)
-     * @param side Buy or sell
-     * @param position_intent Position intent (buy_to_open, buy_to_close, sell_to_open, sell_to_close)
-     * @param type Order type (market or limit)
-     * @param limitPrice Limit price (required for limit orders)
-     * @returns The created order
-     */
-    async createOptionOrder(symbol, qty, side, position_intent, type, limitPrice) {
-        if (!Number.isInteger(qty) || qty <= 0) {
-            this.log('Quantity must be a positive whole number for option orders', { type: 'error' });
-        }
-        if (type === 'limit' && limitPrice === undefined) {
-            this.log('Limit price is required for limit orders', { type: 'error' });
-        }
-        this.log(`Creating ${type} option order for ${symbol}: ${side} ${qty} contracts (${position_intent})${type === 'limit' ? ` at $${limitPrice?.toFixed(2)}` : ''}`, {
-            symbol,
-        });
-        const orderData = {
-            symbol,
-            qty: qty.toString(),
-            side,
-            position_intent,
-            type,
-            time_in_force: 'day',
-            order_class: 'simple',
-            extended_hours: false,
-        };
-        if (type === 'limit' && limitPrice !== undefined) {
-            orderData.limit_price = this.roundPriceForAlpaca(limitPrice).toString();
-        }
-        return this.makeRequest('/orders', 'POST', orderData);
-    }
-    /**
-     * Create a multi-leg option order
-     * @param legs Array of order legs
-     * @param qty Quantity of the multi-leg order (must be a whole number)
-     * @param type Order type (market or limit)
-     * @param limitPrice Limit price (required for limit orders)
-     * @returns The created multi-leg order
-     */
-    async createMultiLegOptionOrder(legs, qty, type, limitPrice) {
-        if (!Number.isInteger(qty) || qty <= 0) {
-            this.log('Quantity must be a positive whole number for option orders', { type: 'error' });
-        }
-        if (type === 'limit' && limitPrice === undefined) {
-            this.log('Limit price is required for limit orders', { type: 'error' });
-        }
-        if (legs.length < 2) {
-            this.log('Multi-leg orders require at least 2 legs', { type: 'error' });
-        }
-        const legSymbols = legs.map((leg) => leg.symbol).join(', ');
-        this.log(`Creating multi-leg ${type} option order with ${legs.length} legs (${legSymbols})${type === 'limit' ? ` at $${limitPrice?.toFixed(2)}` : ''}`, {
-            symbol: legSymbols,
-        });
-        const orderData = {
-            order_class: 'mleg',
-            qty: qty.toString(),
-            type,
-            time_in_force: 'day',
-            legs,
-        };
-        if (type === 'limit' && limitPrice !== undefined) {
-            orderData.limit_price = this.roundPriceForAlpaca(limitPrice).toString();
-        }
-        return this.makeRequest('/orders', 'POST', orderData);
-    }
-    /**
-     * Exercise an option contract
-     * @param symbolOrContractId The symbol or ID of the option contract to exercise
-     * @returns Response from the exercise request
-     */
-    async exerciseOption(symbolOrContractId) {
-        this.log(`Exercising option contract ${symbolOrContractId}`, {
-            symbol: symbolOrContractId,
-        });
-        return this.makeRequest(`/positions/${symbolOrContractId}/exercise`, 'POST');
-    }
-    /**
-     * Get option positions
-     * @returns Array of option positions
-     */
-    async getOptionPositions() {
-        this.log('Fetching option positions');
-        const positions = await this.getPositions('us_option');
-        return positions;
-    }
-    async getOptionsOpenSpreadTrades() {
-        this.log('Fetching option open trades');
-        // this function will get all open positions, extract the symbol and see when they were created.
-        // figures out when the earliest date was (should be today)
-        // then it pulls all orders after the earliest date that were closed and that were of class 'mleg'
-        // Each of these contains two orders. they look like this:
-    }
-    /**
-     * Get option account activities (exercises, assignments, expirations)
-     * @param activityType Type of option activity to filter by
-     * @param date Date to filter activities (YYYY-MM-DD format)
-     * @returns Array of option account activities
-     */
-    async getOptionActivities(activityType, date) {
-        const queryParams = new URLSearchParams();
-        if (activityType) {
-            queryParams.append('activity_types', activityType);
-        }
-        else {
-            queryParams.append('activity_types', 'OPEXC,OPASN,OPEXP');
-        }
-        if (date) {
-            queryParams.append('date', date);
-        }
-        this.log(`Fetching option activities${activityType ? ` of type ${activityType}` : ''}${date ? ` for date ${date}` : ''}`);
-        return this.makeRequest(`/account/activities?${queryParams.toString()}`);
-    }
-    /**
-     * Create a long call spread (buy lower strike call, sell higher strike call)
-     * @param lowerStrikeCallSymbol Symbol of the lower strike call option
-     * @param higherStrikeCallSymbol Symbol of the higher strike call option
-     * @param qty Quantity of spreads to create (must be a whole number)
-     * @param limitPrice Limit price for the spread
-     * @returns The created multi-leg order
-     */
-    async createLongCallSpread(lowerStrikeCallSymbol, higherStrikeCallSymbol, qty, limitPrice) {
-        this.log(`Creating long call spread: Buy ${lowerStrikeCallSymbol}, Sell ${higherStrikeCallSymbol}, Qty: ${qty}, Price: $${limitPrice.toFixed(2)}`, {
-            symbol: `${lowerStrikeCallSymbol},${higherStrikeCallSymbol}`,
-        });
-        const legs = [
-            {
-                symbol: lowerStrikeCallSymbol,
-                ratio_qty: '1',
-                side: 'buy',
-                position_intent: 'buy_to_open',
-            },
-            {
-                symbol: higherStrikeCallSymbol,
-                ratio_qty: '1',
-                side: 'sell',
-                position_intent: 'sell_to_open',
-            },
-        ];
-        return this.createMultiLegOptionOrder(legs, qty, 'limit', limitPrice);
-    }
-    /**
-     * Create a long put spread (buy higher strike put, sell lower strike put)
-     * @param higherStrikePutSymbol Symbol of the higher strike put option
-     * @param lowerStrikePutSymbol Symbol of the lower strike put option
-     * @param qty Quantity of spreads to create (must be a whole number)
-     * @param limitPrice Limit price for the spread
-     * @returns The created multi-leg order
-     */
-    async createLongPutSpread(higherStrikePutSymbol, lowerStrikePutSymbol, qty, limitPrice) {
-        this.log(`Creating long put spread: Buy ${higherStrikePutSymbol}, Sell ${lowerStrikePutSymbol}, Qty: ${qty}, Price: $${limitPrice.toFixed(2)}`, {
-            symbol: `${higherStrikePutSymbol},${lowerStrikePutSymbol}`,
-        });
-        const legs = [
-            {
-                symbol: higherStrikePutSymbol,
-                ratio_qty: '1',
-                side: 'buy',
-                position_intent: 'buy_to_open',
-            },
-            {
-                symbol: lowerStrikePutSymbol,
-                ratio_qty: '1',
-                side: 'sell',
-                position_intent: 'sell_to_open',
-            },
-        ];
-        return this.createMultiLegOptionOrder(legs, qty, 'limit', limitPrice);
-    }
-    /**
-     * Create an iron condor (sell call spread and put spread)
-     * @param longPutSymbol Symbol of the lower strike put (long)
-     * @param shortPutSymbol Symbol of the higher strike put (short)
-     * @param shortCallSymbol Symbol of the lower strike call (short)
-     * @param longCallSymbol Symbol of the higher strike call (long)
-     * @param qty Quantity of iron condors to create (must be a whole number)
-     * @param limitPrice Limit price for the iron condor (credit)
-     * @returns The created multi-leg order
-     */
-    async createIronCondor(longPutSymbol, shortPutSymbol, shortCallSymbol, longCallSymbol, qty, limitPrice) {
-        this.log(`Creating iron condor with ${qty} contracts at $${limitPrice.toFixed(2)}`, {
-            symbol: `${longPutSymbol},${shortPutSymbol},${shortCallSymbol},${longCallSymbol}`,
-        });
-        const legs = [
-            {
-                symbol: longPutSymbol,
-                ratio_qty: '1',
-                side: 'buy',
-                position_intent: 'buy_to_open',
-            },
-            {
-                symbol: shortPutSymbol,
-                ratio_qty: '1',
-                side: 'sell',
-                position_intent: 'sell_to_open',
-            },
-            {
-                symbol: shortCallSymbol,
-                ratio_qty: '1',
-                side: 'sell',
-                position_intent: 'sell_to_open',
-            },
-            {
-                symbol: longCallSymbol,
-                ratio_qty: '1',
-                side: 'buy',
-                position_intent: 'buy_to_open',
-            },
-        ];
-        try {
-            return await this.createMultiLegOptionOrder(legs, qty, 'limit', limitPrice);
-        }
-        catch (error) {
-            this.log(`Error creating iron condor: ${error}`, { type: 'error' });
-            throw error;
-        }
-    }
-    /**
-     * Create a covered call (sell call option against owned stock)
-     * @param stockSymbol Symbol of the underlying stock
-     * @param callOptionSymbol Symbol of the call option to sell
-     * @param qty Quantity of covered calls to create (must be a whole number)
-     * @param limitPrice Limit price for the call option
-     * @returns The created order
-     */
-    async createCoveredCall(stockSymbol, callOptionSymbol, qty, limitPrice) {
-        this.log(`Creating covered call: Sell ${callOptionSymbol} against ${stockSymbol}, Qty: ${qty}, Price: $${limitPrice.toFixed(2)}`, {
-            symbol: `${stockSymbol},${callOptionSymbol}`,
-        });
-        // For covered calls, we don't need to include the stock leg if we already own the shares
-        // We just create a simple sell order for the call option
-        try {
-            return await this.createOptionOrder(callOptionSymbol, qty, 'sell', 'sell_to_open', 'limit', limitPrice);
-        }
-        catch (error) {
-            this.log(`Error creating covered call: ${error}`, { type: 'error' });
-            throw error;
-        }
-    }
-    /**
-     * Roll an option position to a new expiration or strike
-     * @param currentOptionSymbol Symbol of the current option position
-     * @param newOptionSymbol Symbol of the new option to roll to
-     * @param qty Quantity of options to roll (must be a whole number)
-     * @param currentPositionSide Side of the current position ('buy' or 'sell')
-     * @param limitPrice Net limit price for the roll
-     * @returns The created multi-leg order
-     */
-    async rollOptionPosition(currentOptionSymbol, newOptionSymbol, qty, currentPositionSide, limitPrice) {
-        this.log(`Rolling ${qty} ${currentOptionSymbol} to ${newOptionSymbol} at net price $${limitPrice.toFixed(2)}`, {
-            symbol: `${currentOptionSymbol},${newOptionSymbol}`,
-        });
-        // If current position is long, we need to sell to close and buy to open
-        // If current position is short, we need to buy to close and sell to open
-        const closePositionSide = currentPositionSide === 'buy' ? 'sell' : 'buy';
-        const openPositionSide = currentPositionSide;
-        const closePositionIntent = closePositionSide === 'buy' ? 'buy_to_close' : 'sell_to_close';
-        const openPositionIntent = openPositionSide === 'buy' ? 'buy_to_open' : 'sell_to_open';
-        const legs = [
-            {
-                symbol: currentOptionSymbol,
-                ratio_qty: '1',
-                side: closePositionSide,
-                position_intent: closePositionIntent,
-            },
-            {
-                symbol: newOptionSymbol,
-                ratio_qty: '1',
-                side: openPositionSide,
-                position_intent: openPositionIntent,
-            },
-        ];
-        try {
-            return await this.createMultiLegOptionOrder(legs, qty, 'limit', limitPrice);
-        }
-        catch (error) {
-            this.log(`Error rolling option position: ${error}`, { type: 'error' });
-            throw error;
-        }
-    }
-    /**
-     * Get option chain for a specific underlying symbol and expiration date
-     * @param underlyingSymbol The underlying stock symbol
-     * @param expirationDate The expiration date (YYYY-MM-DD format)
-     * @returns Option contracts for the specified symbol and expiration date
-     */
-    async getOptionChain(underlyingSymbol, expirationDate) {
-        this.log(`Fetching option chain for ${underlyingSymbol} with expiration date ${expirationDate}`, {
-            symbol: underlyingSymbol,
-        });
-        try {
-            const params = {
-                underlying_symbols: [underlyingSymbol],
-                expiration_date_gte: expirationDate,
-                expiration_date_lte: expirationDate,
-                status: 'active',
-                limit: 500, // Get a large number to ensure we get all strikes
-            };
-            const response = await this.getOptionContracts(params);
-            return response.option_contracts || [];
-        }
-        catch (error) {
-            this.log(`Failed to fetch option chain for ${underlyingSymbol}: ${error instanceof Error ? error.message : 'Unknown error'}`, {
-                type: 'error',
-                symbol: underlyingSymbol,
-            });
-            return [];
-        }
-    }
-    /**
-     * Get all available expiration dates for a specific underlying symbol
-     * @param underlyingSymbol The underlying stock symbol
-     * @returns Array of available expiration dates
-     */
-    async getOptionExpirationDates(underlyingSymbol) {
-        this.log(`Fetching available expiration dates for ${underlyingSymbol}`, {
-            symbol: underlyingSymbol,
-        });
-        try {
-            const params = {
-                underlying_symbols: [underlyingSymbol],
-                status: 'active',
-                limit: 1000, // Get a large number to ensure we get contracts with all expiration dates
-            };
-            const response = await this.getOptionContracts(params);
-            // Extract unique expiration dates
-            const expirationDates = new Set();
-            if (response.option_contracts) {
-                response.option_contracts.forEach((contract) => {
-                    expirationDates.add(contract.expiration_date);
-                });
-            }
-            // Convert to array and sort
-            return Array.from(expirationDates).sort();
-        }
-        catch (error) {
-            this.log(`Failed to fetch expiration dates for ${underlyingSymbol}: ${error instanceof Error ? error.message : 'Unknown error'}`, {
-                type: 'error',
-                symbol: underlyingSymbol,
-            });
-            return [];
-        }
-    }
-    /**
-     * Get the current options trading level for the account
-     * @returns The options trading level (0-3)
-     */
-    async getOptionsTradingLevel() {
-        this.log('Fetching options trading level');
-        const accountDetails = await this.getAccountDetails();
-        return accountDetails.options_trading_level || 0;
-    }
-    /**
-     * Check if the account has options trading enabled
-     * @returns Boolean indicating if options trading is enabled
-     */
-    async isOptionsEnabled() {
-        this.log('Checking if options trading is enabled');
-        const accountDetails = await this.getAccountDetails();
-        // Check if options trading level is 2 or higher (Level 2+ allows buying calls/puts)
-        // Level 0: Options disabled
-        // Level 1: Only covered calls and cash-secured puts
-        // Level 2+: Can buy calls and puts (required for executeOptionsOrder)
-        const optionsLevel = accountDetails.options_trading_level || 0;
-        const isEnabled = optionsLevel >= 2;
-        this.log(`Options trading level: ${optionsLevel}, enabled: ${isEnabled}`);
-        return isEnabled;
-    }
-    /**
-     * Close all option positions
-     * @param cancelOrders Whether to cancel related orders (default: true)
-     * @returns Response from the close positions request
-     */
-    async closeAllOptionPositions(cancelOrders = true) {
-        this.log(`Closing all option positions${cancelOrders ? ' and canceling related orders' : ''}`);
-        const optionPositions = await this.getOptionPositions();
-        if (optionPositions.length === 0) {
-            this.log('No option positions to close');
-            return;
-        }
-        // Create market orders to close each position
-        for (const position of optionPositions) {
-            const side = position.side === 'long' ? 'sell' : 'buy';
-            const positionIntent = side === 'sell' ? 'sell_to_close' : 'buy_to_close';
-            this.log(`Closing ${position.side} position of ${position.qty} contracts for ${position.symbol}`, {
-                symbol: position.symbol,
-            });
-            await this.createOptionOrder(position.symbol, parseInt(position.qty), side, positionIntent, 'market');
-        }
-        if (cancelOrders) {
-            // Get all open option orders
-            const orders = await this.getOrders({ status: 'open' });
-            const optionOrders = orders.filter((order) => order.asset_class === 'us_option');
-            // Cancel each open option order
-            for (const order of optionOrders) {
-                this.log(`Canceling open order for ${order.symbol}`, {
-                    symbol: order.symbol,
-                });
-                await this.makeRequest(`/orders/${order.id}`, 'DELETE');
-            }
-        }
-    }
-    /**
-     * Close a specific option position
-     * @param symbol The option contract symbol
-     * @param qty Optional quantity to close (defaults to entire position)
-     * @returns The created order
-     */
-    async closeOptionPosition(symbol, qty) {
-        this.log(`Closing option position for ${symbol}${qty ? ` (${qty} contracts)` : ''}`, {
-            symbol,
-        });
-        // Get the position details
-        const positions = await this.getOptionPositions();
-        const position = positions.find((p) => p.symbol === symbol);
-        if (!position) {
-            throw new Error(`No position found for option contract ${symbol}`);
-        }
-        const quantityToClose = qty || parseInt(position.qty);
-        const side = position.side === 'long' ? 'sell' : 'buy';
-        const positionIntent = side === 'sell' ? 'sell_to_close' : 'buy_to_close';
-        try {
-            return await this.createOptionOrder(symbol, quantityToClose, side, positionIntent, 'market');
-        }
-        catch (error) {
-            this.log(`Error closing option position: ${error}`, { type: 'error' });
-            throw error;
-        }
-    }
-    /**
-     * Create a complete equities trade with optional stop loss and take profit
-     * @param params Trade parameters including symbol, qty, side, and optional referencePrice
-     * @param options Trade options including order type, extended hours, stop loss, and take profit settings
-     * @returns The created order
-     */
-    async createEquitiesTrade(params, options) {
-        const { symbol, qty, side, referencePrice } = params;
-        const { type = 'market', limitPrice, extendedHours = false, useStopLoss = false, stopPrice, stopPercent100, useTakeProfit = false, takeProfitPrice, takeProfitPercent100, clientOrderId, } = options || {};
-        // Validation: Extended hours + market order is not allowed
-        if (extendedHours && type === 'market') {
-            this.log('Cannot create market order with extended hours enabled', {
-                symbol,
-                type: 'error',
-            });
-            throw new Error('Cannot create market order with extended hours enabled');
-        }
-        // Validation: Limit orders require limit price
-        if (type === 'limit' && limitPrice === undefined) {
-            this.log('Limit price is required for limit orders', {
-                symbol,
-                type: 'error',
-            });
-            throw new Error('Limit price is required for limit orders');
-        }
-        let calculatedStopPrice;
-        let calculatedTakeProfitPrice;
-        // Handle stop loss validation and calculation
-        if (useStopLoss) {
-            if (stopPrice === undefined && stopPercent100 === undefined) {
-                this.log('Either stopPrice or stopPercent100 must be provided when useStopLoss is true', {
-                    symbol,
-                    type: 'error',
-                });
-                throw new Error('Either stopPrice or stopPercent100 must be provided when useStopLoss is true');
-            }
-            if (stopPercent100 !== undefined) {
-                if (referencePrice === undefined) {
-                    this.log('referencePrice is required when using stopPercent100', {
-                        symbol,
-                        type: 'error',
-                    });
-                    throw new Error('referencePrice is required when using stopPercent100');
-                }
-                // Calculate stop price based on percentage and side
-                const stopPercentDecimal = stopPercent100 / 100;
-                if (side === 'buy') {
-                    // For buy orders, stop loss is below the reference price
-                    calculatedStopPrice = referencePrice * (1 - stopPercentDecimal);
-                }
-                else {
-                    // For sell orders, stop loss is above the reference price
-                    calculatedStopPrice = referencePrice * (1 + stopPercentDecimal);
-                }
-            }
-            else {
-                calculatedStopPrice = stopPrice;
-            }
-        }
-        // Handle take profit validation and calculation
-        if (useTakeProfit) {
-            if (takeProfitPrice === undefined && takeProfitPercent100 === undefined) {
-                this.log('Either takeProfitPrice or takeProfitPercent100 must be provided when useTakeProfit is true', {
-                    symbol,
-                    type: 'error',
-                });
-                throw new Error('Either takeProfitPrice or takeProfitPercent100 must be provided when useTakeProfit is true');
-            }
-            if (takeProfitPercent100 !== undefined) {
-                if (referencePrice === undefined) {
-                    this.log('referencePrice is required when using takeProfitPercent100', {
-                        symbol,
-                        type: 'error',
-                    });
-                    throw new Error('referencePrice is required when using takeProfitPercent100');
-                }
-                // Calculate take profit price based on percentage and side
-                const takeProfitPercentDecimal = takeProfitPercent100 / 100;
-                if (side === 'buy') {
-                    // For buy orders, take profit is above the reference price
-                    calculatedTakeProfitPrice = referencePrice * (1 + takeProfitPercentDecimal);
-                }
-                else {
-                    // For sell orders, take profit is below the reference price
-                    calculatedTakeProfitPrice = referencePrice * (1 - takeProfitPercentDecimal);
-                }
-            }
-            else {
-                calculatedTakeProfitPrice = takeProfitPrice;
-            }
-        }
-        // Determine order class based on what's enabled
-        let orderClass = 'simple';
-        if (useStopLoss && useTakeProfit) {
-            orderClass = 'bracket';
-        }
-        else if (useStopLoss || useTakeProfit) {
-            orderClass = 'oto';
-        }
-        // Build the order request
-        const orderData = {
-            symbol,
-            qty: Math.abs(qty).toString(),
-            side,
-            type,
-            time_in_force: 'day',
-            order_class: orderClass,
-            extended_hours: extendedHours,
-            position_intent: side === 'buy' ? 'buy_to_open' : 'sell_to_open',
-        };
-        if (clientOrderId) {
-            orderData.client_order_id = clientOrderId;
-        }
-        // Add limit price for limit orders
-        if (type === 'limit' && limitPrice !== undefined) {
-            orderData.limit_price = this.roundPriceForAlpaca(limitPrice).toString();
-        }
-        // Add stop loss if enabled
-        if (useStopLoss && calculatedStopPrice !== undefined) {
-            orderData.stop_loss = {
-                stop_price: this.roundPriceForAlpaca(calculatedStopPrice).toString(),
-            };
-        }
-        // Add take profit if enabled
-        if (useTakeProfit && calculatedTakeProfitPrice !== undefined) {
-            orderData.take_profit = {
-                limit_price: this.roundPriceForAlpaca(calculatedTakeProfitPrice).toString(),
-            };
-        }
-        const logMessage = `Creating ${orderClass} ${type} ${side} order for ${symbol}: ${qty} shares${type === 'limit' ? ` at $${limitPrice?.toFixed(2)}` : ''}${useStopLoss ? ` with stop loss at $${calculatedStopPrice?.toFixed(2)}` : ''}${useTakeProfit ? ` with take profit at $${calculatedTakeProfitPrice?.toFixed(2)}` : ''}${extendedHours ? ' (extended hours)' : ''}`;
-        this.log(logMessage, {
-            symbol,
-        });
-        try {
-            return await this.makeRequest('/orders', 'POST', orderData);
-        }
-        catch (error) {
-            this.log(`Error creating equities trade: ${error}`, {
-                symbol,
-                type: 'error',
-            });
-            throw error;
-        }
+// Test file for context functionality
+//testGetMarketStatus();
+// Test getTradingDate for grouping data
+function testGetTradingDate() {
+    const testCases = [
+        {
+            label: 'Market day (regular)',
+            input: '2025-07-10T10:00:00-04:00',
+            expected: '2025-07-10',
+        },
+        {
+            label: 'Weekend (Saturday, should return it anyway )',
+            input: '2025-07-12T12:00:00-04:00',
+            expected: '2025-07-12',
+        },
+        {
+            label: 'Holiday (Independence Day, should return it anyway)',
+            input: '2025-07-04T12:00:00-04:00',
+            expected: '2025-07-04',
+        },
+        {
+            label: 'Input as Date object',
+            input: new Date('2025-07-10T10:00:00-04:00'),
+            expected: '2025-07-10',
+        },
+        {
+            label: 'Input as timestamp (number)',
+            input: new Date('2025-07-10T10:00:00-04:00').getTime(),
+            expected: '2025-07-10',
+        },
+        {
+            label: 'Input as ISO string',
+            input: '2025-07-10T10:00:00-04:00',
+            expected: '2025-07-10',
+        },
+        {
+            label: 'Edge case (Jan 24, 2026, early morning EST)',
+            input: '2026-01-24T00:30:00-05:00',
+            expected: '2026-01-24',
+        },
+        {
+            label: 'Edge case (Jan 24, 2026, late night EST)',
+            input: '2026-01-24T23:59:59-05:00',
+            expected: '2026-01-24',
+        },
+        {
+            label: 'Edge case (Jan 25, 2026, start of day EST)',
+            input: '2026-01-25T00:00:00-05:00',
+            expected: '2026-01-25',
+        },
+        {
+            label: 'Edge case (Jan 25, 2026, late night EST)',
+            input: '2026-01-25T23:59:59-05:00',
+            expected: '2026-01-25',
+        },
+        {
+            label: 'Edge case (Jan 26, 2026, start of day EST)',
+            input: '2026-01-26T00:00:00-05:00',
+            expected: '2026-01-26',
+        },
+        {
+            label: 'Edge case (Jan 26, 2026, 02:00Z = Jan 25, 21:00 EST)',
+            input: '2026-01-26T02:00:00Z',
+            expected: '2026-01-25',
+        },
+        {
+            label: 'Edge case (Jan 26, 2026, 04:59:59Z = Jan 25, 23:59:59 EST)',
+            input: '2026-01-26T04:59:59Z',
+            expected: '2026-01-25',
+        },
+        {
+            label: 'Edge case (Jan 26, 2026, 05:00:00Z = Jan 26, 00:00:00 EST)',
+            input: '2026-01-26T05:00:00Z',
+            expected: '2026-01-26',
+        },
+        {
+            label: 'Edge case (Jan 24, 2026, timestamp input EST)',
+            input: new Date('2026-01-24T12:00:00-05:00').getTime(),
+            expected: '2026-01-24',
+        },
+    ];
+    for (const { label, input, expected } of testCases) {
+        const result = disco.time.getTradingDate(input);
+        const pass = result === expected;
+        console.log(`\nTest: ${label}`);
+        console.log(`  Input: ${input instanceof Date ? input.toISOString() : input}`);
+        console.log(`  Result: ${result} ${pass ? '✓' : `✗ (expected ${expected})`}`);
+        if (!pass) {
+            console.error(`  FAILED: Expected ${expected}, got ${result}`);
+        }
     }
 }
-
-// Test file for context functionality
-async function testMOOAndMOCOrders() {
-    console.log('\n--- Testing Market on Open and Market on Close Orders ---');
-    console.log('NOTE: MOO orders must be submitted after 7:00pm ET and before 9:28am ET');
-    console.log('NOTE: MOC orders must be submitted after 7:00pm ET and before 3:50pm ET');
-    console.log('Orders submitted outside these windows will be rejected.\n');
-    const log = (message, options = { type: 'info' }) => {
-        log$1(message, { ...options, source: 'Test' });
-    };
-    if (!process.env.ALPACA_TRADING_API_KEY ||
-        !process.env.ALPACA_TRADING_SECRET_KEY ||
-        !process.env.ALPACA_TRADING_ACCOUNT_TYPE) {
-        log('Missing required ALPACA_TRADING_* environment variables', { type: 'error' });
-        return;
-    }
-    const credentials = {
-        accountName: 'Test Account',
-        apiKey: process.env.ALPACA_TRADING_API_KEY,
-        apiSecret: process.env.ALPACA_TRADING_SECRET_KEY,
-        type: process.env.ALPACA_TRADING_ACCOUNT_TYPE,
-        orderType: 'limit',
-        engine: 'quant',
-    };
-    const tradingAPI = AlpacaTradingAPI.getInstance(credentials);
-    try {
-        // Test creating a Market on Open order
-        log('Creating Market on Open (MOO) order for SPY...');
-        const mooOrder = await tradingAPI.createMOOOrder('SPY', 1, 'buy', 'buy_to_open', 'test-moo-order');
-        log(`MOO order created successfully: ${mooOrder.id}`);
-        log(`  Symbol: ${mooOrder.symbol}`);
-        log(`  Qty: ${mooOrder.qty}`);
-        log(`  Side: ${mooOrder.side}`);
-        log(`  Type: ${mooOrder.type}`);
-        log(`  Time in Force: ${mooOrder.time_in_force}`);
-        log(`  Status: ${mooOrder.status}`);
-        // Wait a moment before canceling
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-        // Cancel the MOO order
-        log(`Canceling MOO order ${mooOrder.id}...`);
-        await tradingAPI.cancelOrder(mooOrder.id);
-        log(`MOO order canceled successfully`);
-        // Wait a moment before next order
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-        // Test creating a Market on Close order
-        log('Creating Market on Close (MOC) order for SPY...');
-        const mocOrder = await tradingAPI.createMOCOrder('SPY', 1, 'sell', 'sell_to_open', 'test-moc-order');
-        log(`MOC order created successfully: ${mocOrder.id}`);
-        log(`  Symbol: ${mocOrder.symbol}`);
-        log(`  Qty: ${mocOrder.qty}`);
-        log(`  Side: ${mocOrder.side}`);
-        log(`  Type: ${mocOrder.type}`);
-        log(`  Time in Force: ${mocOrder.time_in_force}`);
-        log(`  Status: ${mocOrder.status}`);
-        // Wait a moment before canceling
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-        // Cancel the MOC order
-        log(`Canceling MOC order ${mocOrder.id}...`);
-        await tradingAPI.cancelOrder(mocOrder.id);
-        log(`MOC order canceled successfully`);
-        log('\nMOO/MOC order test completed successfully');
-    }
-    catch (error) {
-        log(`Error during MOO/MOC order test: ${error instanceof Error ? error.message : 'Unknown error'}`, {
-            type: 'error',
-        });
-        throw error;
-    }
-}
-// testGetTradingDate();
-// testGetTradingStartAndEndDates();
-// testGetLastFullTradingDate();
-// testGetMarketOpenClose();
-// testGetNYTimeZone();
-// testGetNextMarketDay();
-// testCountTradingDays();
-// testGetPreviousMarketDay();
-// testOpenRouter();
-// testGetMarketStatus();
-// testCryptoMarketData();
 // testGetPortfolioDailyHistory();
 // testWebSocketConnectAndDisconnect();
 // testGetAssetsShortableFilter();
-// testMarketDataAPI();
 // testLLM();
 // testImageModelDefaults();
 // testGetTradingDaysBack();
-testMOOAndMOCOrders();
+// testMOOAndMOCOrders();
+// testMarketDataAPI();
+// Test market data subscription with a real symbol or FAKEPACA
+// Uncomment one of the following to test:
+// testMarketDataSubscription('SPY');
+// testMarketDataSubscription('FAKEPACA');
+testGetTradingDate();
 //# sourceMappingURL=test.js.map