@discomedia/utils 1.0.55 → 1.0.56

package/dist/test.js

@@ -11,7 +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 { log as log$2 } from 'console';
+import 'console';
 
 /**
  * Logs a message to the console.
@@ -147,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)
 /**
@@ -220,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.
@@ -315,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.
@@ -355,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.
  */
@@ -366,6 +713,348 @@ 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
+ * @returns the trading date as a string in YYYY-MM-DD format
+ */
+/**
+ * Returns the trading date for a given time in YYYY-MM-DD format (NY time).
+ * @param time - string, number, or Date
+ * @returns trading date string
+ */
+function getTradingDate(time) {
+    const date = typeof time === 'number' ? new Date(time) : typeof time === 'string' ? new Date(time) : time;
+    const nyDate = toNYTime(date);
+    return `${nyDate.getUTCFullYear()}-${String(nyDate.getUTCMonth() + 1).padStart(2, '0')}-${String(nyDate.getUTCDate()).padStart(2, '0')}`;
+}
+/**
+ * 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:
@@ -453,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;
 
@@ -462,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();
 		}
 	};
 
@@ -489,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
@@ -502,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, {
@@ -515,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: {
@@ -801,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.16.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 = () => {
@@ -4094,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', {
@@ -4111,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}`, {
@@ -4127,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}`, {
@@ -4144,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), {
@@ -4162,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}`, {
@@ -5640,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
@@ -14506,69 +15192,118 @@ class AlpacaMarketDataAPI extends EventEmitter {
 // Export the singleton instance
 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,
+    }};
+
 // Test file for context functionality
-// testGetTradingDate();
-// testGetTradingStartAndEndDates();
-// testGetLastFullTradingDate();
-// testGetMarketOpenClose();
-// testGetNYTimeZone();
-// testGetNextMarketDay();
-// testCountTradingDays();
-// testGetPreviousMarketDay();
-// testOpenRouter();
-// testGetMarketStatus();
-// testCryptoMarketData();
-/**
- * Test market data subscription for long-running monitoring
- * This test subscribes to minute bars and logs incoming data to verify continuous stream
- * @param symbol Symbol to test (use 'FAKEPACA' for test mode)
- */
-function testMarketDataSubscription(symbol) {
-    log$2(`Starting market data subscription test for ${symbol}`);
-    const marketDataAPI = AlpacaMarketDataAPI.getInstance();
-    // If symbol is FAKEPACA, use test mode
-    {
-        log$2('Using test mode for FAKEPACA');
-        marketDataAPI.setMode('test');
-    }
-    let barCount = 0;
-    let lastBarTime = null;
-    const startTime = new Date();
-    // Subscribe to minute bars
-    marketDataAPI.on('stock-b', (data) => {
-        barCount++;
-        const now = new Date();
-        const barTime = new Date(data.t);
-        lastBarTime = barTime;
-        const timeSinceStart = Math.floor((now.getTime() - startTime.getTime()) / 1000);
-        const minutesSinceStart = Math.floor(timeSinceStart / 60);
-        const secondsSinceStart = timeSinceStart % 60;
-        log$2(`[${minutesSinceStart}m ${secondsSinceStart}s] Bar #${barCount} for ${data.S}: ` +
-            `O=$${data.o.toFixed(2)}, H=$${data.h.toFixed(2)}, L=$${data.l.toFixed(2)}, C=$${data.c.toFixed(2)}, ` +
-            `V=${data.v.toLocaleString()}, Time=${barTime.toLocaleString('en-US', { timeZone: 'America/New_York' })}`);
-    });
-    // Connect and subscribe
-    log$2('Connecting to stock stream...');
-    marketDataAPI.connectStockStream();
-    // Give it a moment to connect, then subscribe
-    setTimeout(() => {
-        log$2(`Subscribing to minute bars for ${symbol}...`);
-        marketDataAPI.subscribe('stock', { bars: [symbol] });
-    }, 2000);
-    // Log status every 5 minutes
-    setInterval(() => {
-        const now = new Date();
-        const timeSinceStart = Math.floor((now.getTime() - startTime.getTime()) / 1000);
-        const minutesSinceStart = Math.floor(timeSinceStart / 60);
-        const hoursSinceStart = Math.floor(minutesSinceStart / 60);
-        const remainingMinutes = minutesSinceStart % 60;
-        const lastBarInfo = lastBarTime
-            ? `Last bar: ${lastBarTime.toLocaleString('en-US', { timeZone: 'America/New_York' })}`
-            : 'No bars received yet';
-        log$2(`Status check - Runtime: ${hoursSinceStart}h ${remainingMinutes}m, ` +
-            `Total bars: ${barCount}, ${lastBarInfo}`, { type: 'info' });
-    }, 5 * 60 * 1000); // Every 5 minutes
-    log$2('Market data subscription test running... (press Ctrl+C to stop)');
+//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}`);
+        }
+    }
 }
 // testGetPortfolioDailyHistory();
 // testWebSocketConnectAndDisconnect();
@@ -14581,5 +15316,6 @@ function testMarketDataSubscription(symbol) {
 // Test market data subscription with a real symbol or FAKEPACA
 // Uncomment one of the following to test:
 // testMarketDataSubscription('SPY');
-testMarketDataSubscription('FAKEPACA');
+// testMarketDataSubscription('FAKEPACA');
+testGetTradingDate();
 //# sourceMappingURL=test.js.map