@discomedia/utils 1.0.59 → 1.0.60

package/dist/index.cjs

@@ -1382,933 +1382,6 @@ async function fetchWithRetry(url, options = {}, retries = 3, initialBackoff = 1
     }
     throw new Error('Failed to fetch after multiple attempts');
 }
-/**
- * Validates a Polygon.io API key by making a test request.
- * @param apiKey - The API key to validate.
- * @returns Promise that resolves to true if valid, false otherwise.
- */
-async function validatePolygonApiKey(apiKey) {
-    try {
-        const response = await fetch(`https://api.polygon.io/v1/meta/symbols?apikey=${apiKey}&limit=1`);
-        if (response.status === 401) {
-            throw new Error('Invalid or expired Polygon.io API key');
-        }
-        if (response.status === 403) {
-            throw new Error('Polygon.io API key lacks required permissions');
-        }
-        return response.ok;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-        console.error('Polygon.io API key validation failed:', errorMessage);
-        return false;
-    }
-}
-
-/*
-How it works:
-`this.#head` is an instance of `Node` which keeps track of its current value and nests another instance of `Node` that keeps the value that comes after it. When a value is provided to `.enqueue()`, the code needs to iterate through `this.#head`, going deeper and deeper to find the last value. However, iterating through every single item is slow. This problem is solved by saving a reference to the last value as `this.#tail` so that it can reference it to add a new value.
-*/
-
-class Node {
-	value;
-	next;
-
-	constructor(value) {
-		this.value = value;
-	}
-}
-
-class Queue {
-	#head;
-	#tail;
-	#size;
-
-	constructor() {
-		this.clear();
-	}
-
-	enqueue(value) {
-		const node = new Node(value);
-
-		if (this.#head) {
-			this.#tail.next = node;
-			this.#tail = node;
-		} else {
-			this.#head = node;
-			this.#tail = node;
-		}
-
-		this.#size++;
-	}
-
-	dequeue() {
-		const current = this.#head;
-		if (!current) {
-			return;
-		}
-
-		this.#head = this.#head.next;
-		this.#size--;
-		return current.value;
-	}
-
-	peek() {
-		if (!this.#head) {
-			return;
-		}
-
-		return this.#head.value;
-
-		// TODO: Node.js 18.
-		// return this.#head?.value;
-	}
-
-	clear() {
-		this.#head = undefined;
-		this.#tail = undefined;
-		this.#size = 0;
-	}
-
-	get size() {
-		return this.#size;
-	}
-
-	* [Symbol.iterator]() {
-		let current = this.#head;
-
-		while (current) {
-			yield current.value;
-			current = current.next;
-		}
-	}
-
-	* drain() {
-		while (this.#head) {
-			yield this.dequeue();
-		}
-	}
-}
-
-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;
-
-	const resumeNext = () => {
-		// Process the next queued function if we're under the concurrency limit
-		if (activeCount < concurrency && queue.size > 0) {
-			activeCount++;
-			queue.dequeue().run();
-		}
-	};
-
-	const next = () => {
-		activeCount--;
-		resumeNext();
-	};
-
-	const run = async (function_, resolve, arguments_) => {
-		// Execute the function and capture the result promise
-		const result = (async () => function_(...arguments_))();
-
-		// Resolve immediately with the promise (don't wait for completion)
-		resolve(result);
-
-		// Wait for the function to complete (success or failure)
-		// We catch errors here to prevent unhandled rejections,
-		// but the original promise rejection is preserved for the caller
-		try {
-			await result;
-		} catch {}
-
-		// Decrement active count and process next queued function
-		next();
-	};
-
-	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
-			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
-		if (activeCount < concurrency) {
-			resumeNext();
-		}
-	};
-
-	const generator = (function_, ...arguments_) => new Promise((resolve, reject) => {
-		enqueue(function_, resolve, reject, arguments_);
-	});
-
-	Object.defineProperties(generator, {
-		activeCount: {
-			get: () => activeCount,
-		},
-		pendingCount: {
-			get: () => queue.size,
-		},
-		clearQueue: {
-			value() {
-				if (!rejectOnClear) {
-					queue.clear();
-					return;
-				}
-
-				const abortError = AbortSignal.abort().reason;
-
-				while (queue.size > 0) {
-					queue.dequeue().reject(abortError);
-				}
-			},
-		},
-		concurrency: {
-			get: () => concurrency,
-
-			set(newConcurrency) {
-				validateConcurrency(newConcurrency);
-				concurrency = newConcurrency;
-
-				queueMicrotask(() => {
-					// eslint-disable-next-line no-unmodified-loop-condition
-					while (activeCount < concurrency && queue.size > 0) {
-						resumeNext();
-					}
-				});
-			},
-		},
-		map: {
-			async value(iterable, function_) {
-				const promises = Array.from(iterable, (value, index) => this(function_, value, index));
-				return Promise.all(promises);
-			},
-		},
-	});
-
-	return generator;
-}
-
-function validateConcurrency(concurrency) {
-	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
-		throw new TypeError('Expected `concurrency` to be a number from 1 and up');
-	}
-}
-
-/**********************************************************************************
- * Polygon.io calls
- **********************************************************************************/
-// Constants from environment variables
-const POLYGON_API_KEY = process.env.POLYGON_API_KEY;
-// Define concurrency limits per API
-const POLYGON_CONCURRENCY_LIMIT = 100;
-const polygonLimit = pLimit(POLYGON_CONCURRENCY_LIMIT);
-// Use to update general information about stocks
-/**
- * Fetches general information about a stock ticker.
- * @param {string} symbol - The stock ticker symbol to fetch information for.
- * @param {Object} [options] - Optional parameters.
- * @param {string} [options.apiKey] - The API key to use for the request.
- * @returns {Promise<PolygonTickerInfo | null>} The ticker information or null if not found.
- */
-const fetchTickerInfo = async (symbol, options) => {
-    if (!options?.apiKey && !POLYGON_API_KEY) {
-        throw new Error('Polygon API key is missing');
-    }
-    const baseUrl = `https://api.polygon.io/v3/reference/tickers/${encodeURIComponent(symbol)}`;
-    const params = new URLSearchParams({
-        apiKey: options?.apiKey || POLYGON_API_KEY,
-    });
-    return polygonLimit(async () => {
-        try {
-            const response = await fetchWithRetry(`${baseUrl}?${params.toString()}`, {}, 3, 1000);
-            const data = await response.json();
-            // Check for "NOT_FOUND" status and return null
-            if (data.status === 'NOT_FOUND') {
-                console.warn(`Ticker not found: ${symbol}`);
-                return null;
-            }
-            // Map the results to the required structure
-            const results = data.results;
-            if (!results) {
-                throw new Error('No results in Polygon API response');
-            }
-            // Validate required fields
-            const requiredFields = [
-                'active',
-                'currency_name',
-                'locale',
-                'market',
-                'name',
-                'primary_exchange',
-                'ticker',
-                'type',
-            ];
-            for (const field of requiredFields) {
-                if (results[field] === undefined) {
-                    throw new Error(`Missing required field in Polygon API response: ${field}`);
-                }
-            }
-            // Handle optional share_class_shares_outstanding field
-            if (results.share_class_shares_outstanding === undefined) {
-                results.share_class_shares_outstanding = null;
-            }
-            return {
-                ticker: results.ticker,
-                type: results.type,
-                active: results.active,
-                currency_name: results.currency_name,
-                description: results.description ?? 'No description available',
-                locale: results.locale,
-                market: results.market,
-                market_cap: results.market_cap ?? 0,
-                name: results.name,
-                primary_exchange: results.primary_exchange,
-                share_class_shares_outstanding: results.share_class_shares_outstanding,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            const contextualMessage = `Error fetching ticker info for ${symbol}`;
-            console.error(`${contextualMessage}: ${errorMessage}`, {
-                symbol,
-                errorType: error instanceof Error && error.message.includes('AUTH_ERROR')
-                    ? 'AUTH_ERROR'
-                    : error instanceof Error && error.message.includes('RATE_LIMIT')
-                        ? 'RATE_LIMIT'
-                        : error instanceof Error && error.message.includes('NETWORK_ERROR')
-                            ? 'NETWORK_ERROR'
-                            : 'UNKNOWN',
-                url: hideApiKeyFromurl(`${baseUrl}?${params.toString()}`),
-                source: 'PolygonAPI.fetchTickerInfo',
-                timestamp: new Date().toISOString(),
-            });
-            throw new Error(`${contextualMessage}: ${errorMessage}`);
-        }
-    });
-};
-// Fetch last trade using Polygon.io
-/**
- * Fetches the last trade for a given stock ticker.
- * @param {string} symbol - The stock ticker symbol to fetch the last trade for.
- * @param {Object} [options] - Optional parameters.
- * @param {string} [options.apiKey] - The API key to use for the request.
- * @returns {Promise<PolygonQuote>} The last trade information.
- */
-const fetchLastTrade = async (symbol, options) => {
-    if (!options?.apiKey && !POLYGON_API_KEY) {
-        throw new Error('Polygon API key is missing');
-    }
-    const baseUrl = `https://api.polygon.io/v2/last/trade/${encodeURIComponent(symbol)}`;
-    const params = new URLSearchParams({
-        apiKey: options?.apiKey || POLYGON_API_KEY,
-    });
-    return polygonLimit(async () => {
-        try {
-            const response = await fetchWithRetry(`${baseUrl}?${params.toString()}`, {}, 3, 1000);
-            const data = await response.json();
-            if (data.status !== 'OK' || !data.results) {
-                throw new Error(`Polygon.io API error: ${data.status || 'No results'} ${data.error || ''}`);
-            }
-            const { p: price, s: vol, t: timestamp } = data.results;
-            if (typeof price !== 'number' || typeof vol !== 'number' || typeof timestamp !== 'number') {
-                throw new Error('Invalid trade data received from Polygon.io API');
-            }
-            return {
-                price,
-                vol,
-                time: new Date(Math.floor(timestamp / 1000000)), // Convert nanoseconds to milliseconds
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            const contextualMessage = `Error fetching last trade for ${symbol}`;
-            console.error(`${contextualMessage}: ${errorMessage}`, {
-                symbol,
-                errorType: error instanceof Error && error.message.includes('AUTH_ERROR')
-                    ? 'AUTH_ERROR'
-                    : error instanceof Error && error.message.includes('RATE_LIMIT')
-                        ? 'RATE_LIMIT'
-                        : error instanceof Error && error.message.includes('NETWORK_ERROR')
-                            ? 'NETWORK_ERROR'
-                            : 'UNKNOWN',
-                url: hideApiKeyFromurl(`${baseUrl}?${params.toString()}`),
-                source: 'PolygonAPI.fetchLastTrade',
-                timestamp: new Date().toISOString(),
-            });
-            throw new Error(`${contextualMessage}: ${errorMessage}`);
-        }
-    });
-};
-// use Polygon for all price data fetching
-/**
- * Fetches price data for a given stock ticker.
- * @param {Object} params - The parameters for fetching price data.
- * @param {string} params.ticker - The stock ticker symbol.
- * @param {number} params.start - The start timestamp for fetching price data.
- * @param {number} [params.end] - The end timestamp for fetching price data.
- * @param {number} params.multiplier - The multiplier for the price data.
- * @param {string} params.timespan - The timespan for the price data.
- * @param {number} [params.limit] - The maximum number of price data points to fetch.
- * @param {Object} [options] - Optional parameters.
- * @param {string} [options.apiKey] - The API key to use for the request.
- * @returns {Promise<PolygonPriceData[]>} The fetched price data.
- */
-const fetchPrices = async (params, options) => {
-    if (!options?.apiKey && !POLYGON_API_KEY) {
-        throw new Error('Polygon API key is missing');
-    }
-    const { ticker, start, end = Date.now().valueOf(), multiplier, timespan, limit = 1000 } = params;
-    const baseUrl = `https://api.polygon.io/v2/aggs/ticker/${encodeURIComponent(ticker)}/range/${multiplier}/${timespan}/${start}/${end}`;
-    const urlParams = new URLSearchParams({
-        apiKey: options?.apiKey || POLYGON_API_KEY,
-        adjusted: 'true',
-        sort: 'asc',
-        limit: limit.toString(),
-    });
-    return polygonLimit(async () => {
-        try {
-            let allResults = [];
-            let nextUrl = `${baseUrl}?${urlParams.toString()}`;
-            while (nextUrl) {
-                //console.log(`Debug: Fetching ${nextUrl}`);
-                const response = await fetchWithRetry(nextUrl, {}, 3, 1000);
-                const data = await response.json();
-                if (data.status !== 'OK') {
-                    throw new Error(`Polygon.io API responded with status: ${data.status}`);
-                }
-                if (data.results) {
-                    allResults = [...allResults, ...data.results];
-                }
-                // Check if there's a next page and append API key
-                nextUrl = data.next_url ? `${data.next_url}&apiKey=${options?.apiKey || POLYGON_API_KEY}` : '';
-            }
-            return allResults.map((entry) => ({
-                date: new Date(entry.t).toLocaleString('en-US', {
-                    year: 'numeric',
-                    month: 'short',
-                    day: '2-digit',
-                    hour: '2-digit',
-                    minute: '2-digit',
-                    second: '2-digit',
-                    timeZone: 'America/New_York',
-                    timeZoneName: 'short',
-                    hourCycle: 'h23',
-                }),
-                timeStamp: entry.t,
-                open: entry.o,
-                high: entry.h,
-                low: entry.l,
-                close: entry.c,
-                vol: entry.v,
-                vwap: entry.vw,
-                trades: entry.n,
-            }));
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            const contextualMessage = `Error fetching price data for ${ticker}`;
-            console.error(`${contextualMessage}: ${errorMessage}`, {
-                ticker,
-                errorType: error instanceof Error && error.message.includes('AUTH_ERROR')
-                    ? 'AUTH_ERROR'
-                    : error instanceof Error && error.message.includes('RATE_LIMIT')
-                        ? 'RATE_LIMIT'
-                        : error instanceof Error && error.message.includes('NETWORK_ERROR')
-                            ? 'NETWORK_ERROR'
-                            : 'UNKNOWN',
-                source: 'PolygonAPI.fetchPrices',
-                timestamp: new Date().toISOString(),
-            });
-            throw new Error(`${contextualMessage}: ${errorMessage}`);
-        }
-    });
-};
-/**
- * Analyzes the price data for a given stock.
- * @param {PolygonPriceData[]} priceData - The price data to analyze.
- * @returns {string} The analysis report.
- */
-function analysePolygonPriceData(priceData) {
-    if (!priceData || priceData.length === 0) {
-        return 'No price data available for analysis.';
-    }
-    // Parse the dates into Date objects
-    const parsedData = priceData.map((entry) => ({
-        ...entry,
-        date: new Date(entry.date),
-    }));
-    // Sort the data by date
-    parsedData.sort((a, b) => a.date.getTime() - b.date.getTime());
-    // Extract start and end times
-    const startTime = parsedData[0].date;
-    const endTime = parsedData[parsedData.length - 1].date;
-    // Calculate the total time in hours
-    (endTime.getTime() - startTime.getTime()) / (1000 * 60 * 60);
-    // Calculate the interval between data points
-    const intervals = parsedData
-        .slice(1)
-        .map((_, i) => (parsedData[i + 1].date.getTime() - parsedData[i].date.getTime()) / 1000); // in seconds
-    const avgInterval = intervals.length > 0 ? intervals.reduce((sum, interval) => sum + interval, 0) / intervals.length : 0;
-    // Format the report
-    const report = `
-Report:
-* Start time of data (US Eastern): ${startTime.toLocaleString('en-US', { timeZone: 'America/New_York' })}
-* End time of data (US Eastern): ${endTime.toLocaleString('en-US', { timeZone: 'America/New_York' })}
-* Number of data points: ${priceData.length}
-* Average interval between data points (seconds): ${avgInterval.toFixed(2)}
-  `;
-    return report.trim();
-}
-/**
- * Fetches grouped daily price data for a specific date.
- * @param {string} date - The date to fetch grouped daily data for.
- * @param {Object} [options] - Optional parameters.
- * @param {string} [options.apiKey] - The API key to use for the request.
- * @param {boolean} [options.adjusted] - Whether to adjust the data.
- * @param {boolean} [options.includeOTC] - Whether to include OTC data.
- * @returns {Promise<PolygonGroupedDailyResponse>} The grouped daily response.
- */
-const fetchGroupedDaily = async (date, options) => {
-    if (!options?.apiKey && !POLYGON_API_KEY) {
-        throw new Error('Polygon API key is missing');
-    }
-    const baseUrl = `https://api.polygon.io/v2/aggs/grouped/locale/us/market/stocks/${date}`;
-    const params = new URLSearchParams({
-        apiKey: options?.apiKey || POLYGON_API_KEY,
-        adjusted: options?.adjusted !== false ? 'true' : 'false',
-        include_otc: options?.includeOTC ? 'true' : 'false',
-    });
-    return polygonLimit(async () => {
-        try {
-            const response = await fetchWithRetry(`${baseUrl}?${params.toString()}`, {}, 3, 1000);
-            const data = await response.json();
-            if (data.status !== 'OK') {
-                throw new Error(`Polygon.io API responded with status: ${data.status}`);
-            }
-            return {
-                adjusted: data.adjusted,
-                queryCount: data.queryCount,
-                request_id: data.request_id,
-                resultsCount: data.resultsCount,
-                status: data.status,
-                results: data.results.map((result) => ({
-                    symbol: result.T,
-                    timeStamp: result.t,
-                    open: result.o,
-                    high: result.h,
-                    low: result.l,
-                    close: result.c,
-                    vol: result.v,
-                    vwap: result.vw,
-                    trades: result.n,
-                })),
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            const contextualMessage = `Error fetching grouped daily data for ${date}`;
-            console.error(`${contextualMessage}: ${errorMessage}`, {
-                date,
-                errorType: error instanceof Error && error.message.includes('AUTH_ERROR')
-                    ? 'AUTH_ERROR'
-                    : error instanceof Error && error.message.includes('RATE_LIMIT')
-                        ? 'RATE_LIMIT'
-                        : error instanceof Error && error.message.includes('NETWORK_ERROR')
-                            ? 'NETWORK_ERROR'
-                            : 'UNKNOWN',
-                url: hideApiKeyFromurl(`${baseUrl}?${params.toString()}`),
-                source: 'PolygonAPI.fetchGroupedDaily',
-                timestamp: new Date().toISOString(),
-            });
-            throw new Error(`${contextualMessage}: ${errorMessage}`);
-        }
-    });
-};
-/**
- * Formats the price data into a readable string.
- * @param {PolygonPriceData[]} priceData - The price data to format.
- * @returns {string} The formatted price data.
- */
-function formatPriceData(priceData) {
-    if (!priceData || priceData.length === 0)
-        return 'No price data available';
-    return priceData
-        .map((d) => {
-        // For daily data, remove the time portion if it's all zeros
-        const dateStr = d.date.includes(', 00:00:00') ? d.date.split(', 00:00:00')[0] : d.date;
-        return [
-            dateStr,
-            `O: ${formatCurrency(d.open)}`,
-            `H: ${formatCurrency(d.high)}`,
-            `L: ${formatCurrency(d.low)}`,
-            `C: ${formatCurrency(d.close)}`,
-            `Vol: ${d.vol}`,
-        ].join(' | ');
-    })
-        .join('\n');
-}
-const fetchDailyOpenClose = async (
-/**
- * Fetches the daily open and close data for a given stock ticker.
- * @param {string} symbol - The stock ticker symbol to fetch data for.
- * @param {Date} [date=new Date()] - The date to fetch data for.
- * @param {Object} [options] - Optional parameters.
- * @param {string} [options.apiKey] - The API key to use for the request.
- * @param {boolean} [options.adjusted] - Whether to adjust the data.
- * @returns {Promise<PolygonDailyOpenClose>} The daily open and close data.
- */
-symbol, date = new Date(), options) => {
-    if (!options?.apiKey && !POLYGON_API_KEY) {
-        throw new Error('Polygon API key is missing');
-    }
-    const formattedDate = date.toISOString().split('T')[0]; // Format as YYYY-MM-DD
-    const baseUrl = `https://api.polygon.io/v1/open-close/${encodeURIComponent(symbol)}/${formattedDate}`;
-    const params = new URLSearchParams({
-        apiKey: options?.apiKey || POLYGON_API_KEY,
-        adjusted: (options?.adjusted ?? true).toString(),
-    });
-    return polygonLimit(async () => {
-        const response = await fetchWithRetry(`${baseUrl}?${params.toString()}`, {}, 3, 1000);
-        const data = await response.json();
-        if (data.status !== 'OK') {
-            throw new Error(`Failed to fetch daily open/close data for ${symbol}: ${data.status}`);
-        }
-        return data;
-    });
-};
-/**
- * Gets the previous close price for a given stock ticker.
- * @param {string} symbol - The stock ticker symbol to fetch the previous close for.
- * @param {Date} [referenceDate] - The reference date to use for fetching the previous close.
- * @returns {Promise<{ close: number; date: Date }>} The previous close price and date.
- */
-async function getPreviousClose(symbol, referenceDate, options) {
-    const previousDate = getLastFullTradingDate(referenceDate);
-    const lastOpenClose = await fetchDailyOpenClose(symbol, previousDate, options);
-    if (!lastOpenClose) {
-        throw new Error(`Could not fetch last trade price for ${symbol}`);
-    }
-    return {
-        close: lastOpenClose.close,
-        date: previousDate,
-    };
-}
-/**
- * Fetches trade data for a given stock ticker.
- * @param {string} symbol - The stock ticker symbol to fetch trades for.
- * @param {Object} [options] - Optional parameters.
- * @param {string} [options.apiKey] - The API key to use for the request.
- * @param {string | number} [options.timestamp] - The timestamp for fetching trades.
- * @param {string | number} [options.timestampgt] - Greater than timestamp for fetching trades.
- * @param {string | number} [options.timestampgte] - Greater than or equal to timestamp for fetching trades.
- * @param {string | number} [options.timestamplt] - Less than timestamp for fetching trades.
- * @param {string | number} [options.timestamplte] - Less than or equal to timestamp for fetching trades.
- * @param {'asc' | 'desc'} [options.order] - The order of the trades.
- * @param {number} [options.limit] - The maximum number of trades to fetch.
- * @param {string} [options.sort] - The sort order for the trades.
- * @returns {Promise<PolygonTradesResponse>} The fetched trades response.
- */
-const fetchTrades = async (symbol, options) => {
-    if (!options?.apiKey && !POLYGON_API_KEY) {
-        throw new Error('Polygon API key is missing');
-    }
-    const baseUrl = `https://api.polygon.io/v3/trades/${encodeURIComponent(symbol)}`;
-    const params = new URLSearchParams({
-        apiKey: options?.apiKey || POLYGON_API_KEY,
-    });
-    // Add optional parameters if they exist
-    if (options?.timestamp)
-        params.append('timestamp', options.timestamp.toString());
-    if (options?.timestampgt)
-        params.append('timestamp.gt', options.timestampgt.toString());
-    if (options?.timestampgte)
-        params.append('timestamp.gte', options.timestampgte.toString());
-    if (options?.timestamplt)
-        params.append('timestamp.lt', options.timestamplt.toString());
-    if (options?.timestamplte)
-        params.append('timestamp.lte', options.timestamplte.toString());
-    if (options?.order)
-        params.append('order', options.order);
-    if (options?.limit)
-        params.append('limit', options.limit.toString());
-    if (options?.sort)
-        params.append('sort', options.sort);
-    return polygonLimit(async () => {
-        const url = `${baseUrl}?${params.toString()}`;
-        try {
-            console.log(`[DEBUG] Fetching trades for ${symbol} from ${url}`);
-            const response = await fetchWithRetry(url, {}, 3, 1000);
-            const data = (await response.json());
-            if ('message' in data) {
-                // This is an error response
-                throw new Error(`Polygon API Error: ${data.message}`);
-            }
-            return data;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            const contextualMessage = `Error fetching trades for ${symbol}`;
-            console.error(`${contextualMessage}: ${errorMessage}`, {
-                symbol,
-                errorType: error instanceof Error && error.message.includes('AUTH_ERROR')
-                    ? 'AUTH_ERROR'
-                    : error instanceof Error && error.message.includes('RATE_LIMIT')
-                        ? 'RATE_LIMIT'
-                        : error instanceof Error && error.message.includes('NETWORK_ERROR')
-                            ? 'NETWORK_ERROR'
-                            : 'UNKNOWN',
-                url: hideApiKeyFromurl(url),
-                source: 'PolygonAPI.fetchTrades',
-                timestamp: new Date().toISOString(),
-            });
-            throw new Error(`${contextualMessage}: ${errorMessage}`);
-        }
-    });
-};
-
-/**
- * Polygon Indices API Implementation
- *
- * This module provides functions to interact with the Polygon.io Indices API.
- */
-// Constants from environment variables
-const { ALPACA_INDICES_API_KEY } = process.env;
-// Define concurrency limits for API
-const POLYGON_INDICES_CONCURRENCY_LIMIT = 5;
-const polygonIndicesLimit = pLimit(POLYGON_INDICES_CONCURRENCY_LIMIT);
-// Base URL for Polygon API
-const POLYGON_API_BASE_URL = 'https://api.polygon.io';
-/**
- * Validates that an API key is available
- * @param {string | undefined} apiKey - Optional API key to use
- * @throws {Error} If no API key is available
- */
-const validateApiKey = (apiKey) => {
-    const key = apiKey || ALPACA_INDICES_API_KEY;
-    if (!key) {
-        throw new Error('Polygon Indices API key is missing');
-    }
-    return key;
-};
-/**
- * Fetches aggregate bars for an index over a given date range in custom time window sizes.
- *
- * @param {PolygonIndicesAggregatesParams} params - Parameters for the aggregates request
- * @param {Object} [options] - Optional parameters
- * @param {string} [options.apiKey] - API key to use for the request
- * @returns {Promise<PolygonIndicesAggregatesResponse>} The aggregates response
- */
-const fetchIndicesAggregates = async (params, options) => {
-    const apiKey = validateApiKey(options?.apiKey);
-    const { indicesTicker, multiplier, timespan, from, to, sort = 'asc', limit } = params;
-    const url = new URL(`${POLYGON_API_BASE_URL}/v2/aggs/ticker/${encodeURIComponent(indicesTicker)}/range/${multiplier}/${timespan}/${from}/${to}`);
-    const queryParams = new URLSearchParams();
-    queryParams.append('apiKey', apiKey);
-    if (sort) {
-        queryParams.append('sort', sort);
-    }
-    if (limit) {
-        queryParams.append('limit', limit.toString());
-    }
-    url.search = queryParams.toString();
-    return polygonIndicesLimit(async () => {
-        try {
-            const response = await fetchWithRetry(url.toString(), {}, 3, 300);
-            const data = await response.json();
-            if (data.status === 'ERROR') {
-                throw new Error(`Polygon API Error: ${data.error}`);
-            }
-            return data;
-        }
-        catch (error) {
-            console.error('Error fetching indices aggregates:', error);
-            throw error;
-        }
-    });
-};
-/**
- * Gets the previous day's open, high, low, and close (OHLC) for the specified index.
- *
- * @param {string} indicesTicker - The ticker symbol of the index
- * @param {Object} [options] - Optional parameters
- * @param {string} [options.apiKey] - API key to use for the request
- * @returns {Promise<PolygonIndicesPrevCloseResponse>} The previous close response
- */
-const fetchIndicesPreviousClose = async (indicesTicker, options) => {
-    const apiKey = validateApiKey(options?.apiKey);
-    const url = new URL(`${POLYGON_API_BASE_URL}/v2/aggs/ticker/${encodeURIComponent(indicesTicker)}/prev`);
-    const queryParams = new URLSearchParams();
-    queryParams.append('apiKey', apiKey);
-    url.search = queryParams.toString();
-    return polygonIndicesLimit(async () => {
-        try {
-            const response = await fetchWithRetry(url.toString(), {}, 3, 300);
-            const data = await response.json();
-            if (data.status === 'ERROR') {
-                throw new Error(`Polygon API Error: ${data.error}`);
-            }
-            return data;
-        }
-        catch (error) {
-            console.error('Error fetching indices previous close:', error);
-            throw error;
-        }
-    });
-};
-/**
- * Gets the open, close and afterhours values of an index symbol on a certain date.
- *
- * @param {string} indicesTicker - The ticker symbol of the index
- * @param {string} date - The date in YYYY-MM-DD format
- * @param {Object} [options] - Optional parameters
- * @param {string} [options.apiKey] - API key to use for the request
- * @returns {Promise<PolygonIndicesDailyOpenCloseResponse>} The daily open/close response
- */
-const fetchIndicesDailyOpenClose = async (indicesTicker, date, options) => {
-    const apiKey = validateApiKey(options?.apiKey);
-    const url = new URL(`${POLYGON_API_BASE_URL}/v1/open-close/${encodeURIComponent(indicesTicker)}/${date}`);
-    const queryParams = new URLSearchParams();
-    queryParams.append('apiKey', apiKey);
-    url.search = queryParams.toString();
-    return polygonIndicesLimit(async () => {
-        try {
-            const response = await fetchWithRetry(url.toString(), {}, 3, 300);
-            const data = await response.json();
-            if (data.status === 'ERROR') {
-                throw new Error(`Polygon API Error: ${data.error}`);
-            }
-            return data;
-        }
-        catch (error) {
-            console.error('Error fetching indices daily open/close:', error);
-            throw error;
-        }
-    });
-};
-/**
- * Gets a snapshot of indices data for specified tickers.
- *
- * @param {PolygonIndicesSnapshotParams} [params] - Parameters for the snapshot request
- * @param {Object} [options] - Optional parameters
- * @param {string} [options.apiKey] - API key to use for the request
- * @returns {Promise<PolygonIndicesSnapshotResponse>} The indices snapshot response
- */
-const fetchIndicesSnapshot = async (params, options) => {
-    const apiKey = validateApiKey(options?.apiKey);
-    const url = new URL(`${POLYGON_API_BASE_URL}/v3/snapshot/indices`);
-    const queryParams = new URLSearchParams();
-    queryParams.append('apiKey', apiKey);
-    if (params?.tickers?.length) {
-        queryParams.append('ticker.any_of', params.tickers.join(','));
-    }
-    if (params?.order) {
-        queryParams.append('order', params.order);
-    }
-    if (params?.limit) {
-        queryParams.append('limit', params.limit.toString());
-    }
-    if (params?.sort) {
-        queryParams.append('sort', params.sort);
-    }
-    url.search = queryParams.toString();
-    return polygonIndicesLimit(async () => {
-        try {
-            const response = await fetchWithRetry(url.toString(), {}, 3, 300);
-            const data = await response.json();
-            if (data.status === 'ERROR') {
-                throw new Error(`Polygon API Error: ${data.error}`);
-            }
-            return data;
-        }
-        catch (error) {
-            console.error('Error fetching indices snapshot:', error);
-            throw error;
-        }
-    });
-};
-/**
- * Gets snapshots for assets of all types, including indices.
- *
- * @param {string[]} tickers - Array of tickers to fetch snapshots for
- * @param {Object} [options] - Optional parameters
- * @param {string} [options.apiKey] - API key to use for the request
- * @param {string} [options.type] - Filter by asset type
- * @param {string} [options.order] - Order results
- * @param {number} [options.limit] - Limit the number of results
- * @param {string} [options.sort] - Sort field
- * @returns {Promise<any>} The universal snapshot response
- */
-const fetchUniversalSnapshot = async (tickers, options) => {
-    const apiKey = validateApiKey(options?.apiKey);
-    const url = new URL(`${POLYGON_API_BASE_URL}/v3/snapshot`);
-    const queryParams = new URLSearchParams();
-    queryParams.append('apiKey', apiKey);
-    if (tickers.length) {
-        queryParams.append('ticker.any_of', tickers.join(','));
-    }
-    if (options?.type) {
-        queryParams.append('type', options.type);
-    }
-    if (options?.order) {
-        queryParams.append('order', options.order);
-    }
-    if (options?.limit) {
-        queryParams.append('limit', options.limit.toString());
-    }
-    if (options?.sort) {
-        queryParams.append('sort', options.sort);
-    }
-    url.search = queryParams.toString();
-    return polygonIndicesLimit(async () => {
-        try {
-            const response = await fetchWithRetry(url.toString(), {}, 3, 300);
-            const data = await response.json();
-            if (data.status === 'ERROR') {
-                throw new Error(`Polygon API Error: ${data.error}`);
-            }
-            return data;
-        }
-        catch (error) {
-            console.error('Error fetching universal snapshot:', error);
-            throw error;
-        }
-    });
-};
-/**
- * Converts Polygon Indices bar data to a more standardized format
- *
- * @param {PolygonIndicesAggregatesResponse} data - The raw aggregates response
- * @returns {Array<{date: string, open: number, high: number, low: number, close: number, timestamp: number}>} Formatted bar data
- */
-const formatIndicesBarData = (data) => {
-    return data.results.map((bar) => {
-        const date = new Date(bar.t);
-        return {
-            date: date.toISOString().split('T')[0],
-            open: bar.o,
-            high: bar.h,
-            low: bar.l,
-            close: bar.c,
-            timestamp: bar.t,
-        };
-    });
-};
 
 function __classPrivateFieldSet(receiver, state, value, kind, f) {
     if (typeof state === "function" ? receiver !== state || true : !state.has(receiver))
@@ -11061,428 +10134,6 @@ class PerformanceTimer {
     }
 }
 
-/**
- * Calculates Bollinger Bands for a given set of price data.
- * Bollinger Bands consist of a middle band (SMA) and two outer bands
- * that are standard deviations away from the middle band.
- *
- * @param priceData - An array of price data objects containing closing prices.
- * @param params - An object containing optional parameters for the calculation.
- * @param params.period - The number of periods to use for the SMA (default is 20).
- * @param params.standardDeviations - The number of standard deviations for the outer bands (default is 2).
- * @returns An array of BollingerBandsData objects containing the calculated bands.
- */
-function calculateBollingerBands(priceData, { period = 20, standardDeviations = 2 } = {}) {
-    if (priceData.length < period) {
-        logIfDebug(`Insufficient data for Bollinger Bands calculation: required periods: ${period}, but only received ${priceData.length} periods of data`);
-        return [];
-    }
-    const result = [];
-    for (let i = period - 1; i < priceData.length; i++) {
-        const periodSlice = priceData.slice(i - period + 1, i + 1);
-        const prices = periodSlice.map((d) => d.close);
-        // Calculate middle band (SMA)
-        const sum = prices.reduce((acc, price) => acc + price, 0);
-        const sma = sum / period;
-        // Calculate standard deviation
-        const squaredDifferences = prices.map((price) => Math.pow(price - sma, 2));
-        const variance = squaredDifferences.reduce((acc, val) => acc + val, 0) / period;
-        const standardDeviation = Math.sqrt(variance);
-        // Calculate bands
-        const upperBand = sma + standardDeviation * standardDeviations;
-        const lowerBand = sma - standardDeviation * standardDeviations;
-        result.push({
-            date: priceData[i].date,
-            middle: parseFloat(sma.toFixed(2)),
-            upper: parseFloat(upperBand.toFixed(2)),
-            lower: parseFloat(lowerBand.toFixed(2)),
-            close: priceData[i].close,
-        });
-    }
-    // logIfDebug(`Calculated Bollinger Bands for ${result.length} periods`);
-    return result;
-}
-/**
- * Calculates the Exponential Moving Average (EMA) for a given set of price data.
- * The EMA gives more weight to recent prices, making it more responsive to new information.
- *
- * @param priceData - An array of price data objects containing closing prices.
- * @param params - An object containing optional parameters for the calculation.
- * @param params.period - The number of periods to use for the EMA (default is 20).
- * @param params.period2 - An optional second period for a second EMA (default is 9).
- * @returns An array of EMAData objects containing the calculated EMA values.
- */
-function calculateEMA(priceData, { period = 20, period2 = 9 } = {}) {
-    if (priceData.length < period || (period2 && priceData.length < period2)) {
-        logIfDebug(`Insufficient data for EMA calculation: required periods: ${period}, ${period2}, but only received ${priceData.length} periods of data`);
-        return [];
-    }
-    const result = [];
-    const multiplier = 2 / (period + 1);
-    const multiplier2 = period2 ? 2 / (period2 + 1) : 0;
-    // Calculate initial SMA for first period
-    let sum = 0;
-    for (let i = 0; i < period; i++) {
-        sum += priceData[i].close;
-    }
-    let prevEMA = sum / period;
-    // Calculate initial SMA for second period if needed
-    let prevEMA2;
-    if (period2) {
-        sum = 0;
-        for (let i = 0; i < period2; i++) {
-            sum += priceData[i].close;
-        }
-        prevEMA2 = sum / period2;
-    }
-    // Add first EMA(s)
-    const firstEntry = {
-        date: priceData[Math.max(period, period2 || 0) - 1].date,
-        ema: parseFloat(prevEMA.toFixed(2)),
-        close: priceData[Math.max(period, period2 || 0) - 1].close,
-    };
-    if (period2) {
-        firstEntry.ema2 = parseFloat(prevEMA2.toFixed(2));
-    }
-    result.push(firstEntry);
-    // Calculate EMA for remaining periods
-    for (let i = Math.max(period, period2 || 0); i < priceData.length; i++) {
-        const currentClose = priceData[i].close;
-        const currentEMA = (currentClose - prevEMA) * multiplier + prevEMA;
-        prevEMA = currentEMA;
-        const entry = {
-            date: priceData[i].date,
-            ema: parseFloat(currentEMA.toFixed(2)),
-            close: currentClose,
-        };
-        if (period2) {
-            const currentEMA2 = (currentClose - prevEMA2) * multiplier2 + prevEMA2;
-            prevEMA2 = currentEMA2;
-            entry.ema2 = parseFloat(currentEMA2.toFixed(2));
-        }
-        result.push(entry);
-    }
-    // logIfDebug(`Calculated EMA for ${result.length} periods`);
-    return result;
-}
-/**
- * Calculates Fibonacci retracement and extension levels based on price data.
- * Fibonacci levels are used to identify potential support and resistance levels.
- *
- * @param priceData - An array of price data objects containing high and low prices.
- * @param params - An object containing optional parameters for the calculation.
- * @param params.lookbackPeriod - The number of periods to look back for swing high/low (default is 20).
- * @param params.retracementLevels - An array of retracement levels to calculate (default is [0.236, 0.382, 0.5, 0.618, 0.786]).
- * @param params.extensionLevels - An array of extension levels to calculate (default is [1.272, 1.618, 2.618]).
- * @param params.reverseDirection - A boolean indicating if the trend is reversed (default is false).
- * @returns An array of FibonacciData objects containing the calculated levels.
- */
-function calculateFibonacciLevels(priceData, { lookbackPeriod = 20, retracementLevels = [0.236, 0.382, 0.5, 0.618, 0.786], extensionLevels = [1.272, 1.618, 2.618], reverseDirection = false, } = {}) {
-    const result = [];
-    for (let i = 0; i < priceData.length; i++) {
-        const periodSlice = priceData.slice(Math.max(0, i - lookbackPeriod + 1), i + 1);
-        const swingHigh = Math.max(...periodSlice.map((d) => d.high));
-        const swingLow = Math.min(...periodSlice.map((d) => d.low));
-        const priceRange = swingHigh - swingLow;
-        const trend = reverseDirection ? 'downtrend' : 'uptrend';
-        let levels = [];
-        if (priceRange > 0) {
-            // Calculate retracement levels
-            retracementLevels.forEach((level) => {
-                const price = reverseDirection ? swingLow + priceRange * level : swingHigh - priceRange * level;
-                levels.push({
-                    level,
-                    price: parseFloat(price.toFixed(2)),
-                    type: 'retracement',
-                });
-            });
-            // Calculate extension levels
-            extensionLevels.forEach((level) => {
-                const price = reverseDirection
-                    ? swingHigh - priceRange * (level - 1) // For downtrend
-                    : swingHigh + priceRange * (level - 1); // For uptrend
-                levels.push({
-                    level,
-                    price: parseFloat(price.toFixed(2)),
-                    type: 'extension',
-                });
-            });
-            // Sort levels by price
-            levels.sort((a, b) => (reverseDirection ? b.price - a.price : a.price - b.price));
-        }
-        else {
-            logIfDebug(`Price range is zero on date ${priceData[i].date}; no levels calculated.`);
-        }
-        result.push({
-            date: priceData[i].date,
-            levels,
-            swingHigh,
-            swingLow,
-            trend,
-            close: priceData[i].close,
-        });
-    }
-    // logIfDebug(`Calculated Fibonacci levels for ${result.length} periods`);
-    return result;
-}
-/**
- * Calculates the Moving Average Convergence Divergence (MACD) for a given set of price data.
- * MACD is a trend-following momentum indicator that shows the relationship between two EMAs.
- *
- * @param priceData - An array of price data objects containing closing prices.
- * @param params - An object containing optional parameters for the calculation.
- * @param params.shortPeriod - The short EMA period (default is 12).
- * @param params.longPeriod - The long EMA period (default is 26).
- * @param params.signalPeriod - The signal line period (default is 9).
- * @returns An array of MACDData objects containing the calculated MACD values.
- */
-function calculateMACD(priceData, { shortPeriod = 12, longPeriod = 26, signalPeriod = 9 } = {}) {
-    if (priceData.length < longPeriod + signalPeriod) {
-        logIfDebug(`Insufficient data for MACD calculation: required periods: ${longPeriod + signalPeriod}, but only received ${priceData.length} periods of data`);
-        return [];
-    }
-    const emaShort = calculateEMA(priceData, { period: shortPeriod });
-    const emaLong = calculateEMA(priceData, { period: longPeriod });
-    // Align EMAs by trimming the beginning of emaShort to match emaLong length
-    if (emaShort.length < emaLong.length) {
-        logIfDebug('Short EMA length is less than Long EMA length for MACD calculation');
-        return [];
-    }
-    const emaShortAligned = emaShort.slice(emaShort.length - emaLong.length);
-    const macdLine = emaShortAligned.map((short, i) => short.ema - emaLong[i].ema);
-    const result = [];
-    if (macdLine.length < signalPeriod) {
-        logIfDebug(`Insufficient MACD data for Signal Line calculation: required periods: ${signalPeriod}, but only received ${macdLine.length} periods of data`);
-        return [];
-    }
-    const signalMultiplier = 2 / (signalPeriod + 1);
-    let signalEMA = macdLine.slice(0, signalPeriod).reduce((sum, val) => sum + val, 0) / signalPeriod;
-    for (let i = signalPeriod; i < macdLine.length; i++) {
-        const macdValue = macdLine[i];
-        signalEMA = (macdValue - signalEMA) * signalMultiplier + signalEMA;
-        const hist = macdValue - signalEMA;
-        result.push({
-            date: emaLong[i].date, // Use emaLong's date for alignment
-            macd: parseFloat(macdValue.toFixed(2)),
-            signal: parseFloat(signalEMA.toFixed(2)),
-            histogram: parseFloat(hist.toFixed(2)),
-            close: emaLong[i].close,
-        });
-    }
-    // logIfDebug(`Calculated MACD for ${result.length} periods`);
-    return result;
-}
-/**
- * Calculates the Relative Strength Index (RSI) for a given set of price data.
- * RSI is a momentum oscillator that measures the speed and change of price movements.
- *
- * @param priceData - An array of price data objects containing closing prices.
- * @param params - An object containing optional parameters for the calculation.
- * @param params.period - The number of periods to use for the RSI (default is 14).
- * @returns An array of RSIData objects containing the calculated RSI values.
- */
-function calculateRSI(priceData, { period = 14 } = {}) {
-    if (priceData.length < period + 1) {
-        logIfDebug(`Insufficient data for RSI calculation: required periods: ${period + 1}, but only received ${priceData.length} periods of data`);
-        return [];
-    }
-    const result = [];
-    let avgGain = 0;
-    let avgLoss = 0;
-    // Calculate first average gain and loss
-    for (let i = 1; i <= period; i++) {
-        const change = priceData[i].close - priceData[i - 1].close;
-        if (change >= 0) {
-            avgGain += change;
-        }
-        else {
-            avgLoss += Math.abs(change);
-        }
-    }
-    avgGain = avgGain / period;
-    avgLoss = avgLoss / period;
-    // Calculate RSI for the first period
-    let rs = avgGain / avgLoss;
-    let rsi = 100 - 100 / (1 + rs);
-    result.push({
-        date: priceData[period].date,
-        rsi: parseFloat(rsi.toFixed(2)),
-        close: priceData[period].close,
-    });
-    // Calculate subsequent periods using smoothed averages
-    for (let i = period + 1; i < priceData.length; i++) {
-        const change = priceData[i].close - priceData[i - 1].close;
-        const gain = change >= 0 ? change : 0;
-        const loss = change < 0 ? Math.abs(change) : 0;
-        // Use smoothed averages
-        avgGain = (avgGain * (period - 1) + gain) / period;
-        avgLoss = (avgLoss * (period - 1) + loss) / period;
-        rs = avgGain / avgLoss;
-        rsi = 100 - 100 / (1 + rs);
-        result.push({
-            date: priceData[i].date,
-            rsi: parseFloat(rsi.toFixed(2)),
-            close: priceData[i].close,
-        });
-    }
-    // logIfDebug(`Calculated RSI for ${result.length} periods`);
-    return result;
-}
-/**
- * Calculates the Stochastic Oscillator for a given set of price data.
- * The Stochastic Oscillator compares a particular closing price of a security to a range of its prices over a certain period of time.
- *
- * @param priceData - An array of price data objects containing high, low, and closing prices.
- * @param params - An object containing optional parameters for the calculation.
- * @param params.lookbackPeriod - The number of periods to look back for the calculation of %K (default is 5).
- * @param params.signalPeriod - The number of periods for the %D signal line (default is 3).
- * @param params.smoothingFactor - The smoothing factor for %K (default is 3).
- * @returns An array of StochData objects containing the calculated %K and %D values.
- */
-function calculateStochasticOscillator(priceData, { lookbackPeriod = 5, signalPeriod = 3, smoothingFactor = 3 } = {}) {
-    if (priceData.length < lookbackPeriod) {
-        logIfDebug(`Insufficient data for Stochastic Oscillator calculation: required periods: ${lookbackPeriod}, but only received ${priceData.length} periods of data`);
-        return [];
-    }
-    const kValues = [];
-    const result = [];
-    let kSum = 0;
-    let dSum = 0;
-    for (let i = lookbackPeriod - 1; i < priceData.length; i++) {
-        const periodSlice = priceData.slice(i - lookbackPeriod + 1, i + 1);
-        const currentClose = periodSlice[periodSlice.length - 1].close;
-        const highPrices = periodSlice.map((d) => d.high);
-        const lowPrices = periodSlice.map((d) => d.low);
-        const highestHigh = Math.max(...highPrices);
-        const lowestLow = Math.min(...lowPrices);
-        const k = highestHigh === lowestLow ? 0 : ((currentClose - lowestLow) / (highestHigh - lowestLow)) * 100;
-        kValues.push(k);
-        kSum += k;
-        if (kValues.length > smoothingFactor)
-            kSum -= kValues[kValues.length - smoothingFactor - 1];
-        const smoothedK = kSum / Math.min(kValues.length, smoothingFactor);
-        dSum += smoothedK;
-        if (kValues.length > smoothingFactor + signalPeriod - 1)
-            dSum -= kValues[kValues.length - smoothingFactor - signalPeriod];
-        const smoothedD = dSum / Math.min(kValues.length - smoothingFactor + 1, signalPeriod);
-        if (kValues.length >= smoothingFactor + signalPeriod - 1) {
-            result.push({
-                date: priceData[i].date,
-                slowK: parseFloat(smoothedK.toFixed(2)),
-                slowD: parseFloat(smoothedD.toFixed(2)),
-                close: currentClose,
-            });
-        }
-    }
-    // logIfDebug(`Calculated Stochastic Oscillator for ${result.length} periods`);
-    return result;
-}
-/**
- * Calculates support and resistance levels based on price data.
- * Support and resistance levels are price levels at which a stock tends to stop and reverse.
- *
- * @param priceData - An array of price data objects containing high, low, and closing prices.
- * @param params - An object containing optional parameters for the calculation.
- * @param params.maxLevels - The maximum number of support/resistance levels to return (default is 5).
- * @param params.lookbackPeriod - The number of periods to look back for pivot points (default is 10).
- * @returns An array of SupportResistanceData objects containing the calculated levels.
- */
-function calculateSupportAndResistance(priceData, { maxLevels = 5, lookbackPeriod = 10 } = {}) {
-    const result = [];
-    for (let i = 0; i < priceData.length; i++) {
-        const startIdx = Math.max(0, i - lookbackPeriod);
-        const analysisWindow = priceData.slice(startIdx, i + 1);
-        const pivotPoints = [];
-        // **Compute Volatility Metrics**
-        const priceChanges = analysisWindow.slice(1).map((bar, idx) => Math.abs(bar.close - analysisWindow[idx].close));
-        const avgPriceChange = priceChanges.reduce((sum, change) => sum + change, 0) / priceChanges.length;
-        const volatility = avgPriceChange / analysisWindow[0].close; // Relative volatility
-        // **Adjust Sensitivity and minGapBetweenLevels Dynamically**
-        const sensitivity = volatility * 2; // Adjust the multiplier as needed
-        const minGapBetweenLevels = volatility * 100; // Convert to percentage
-        // Analyze each point in window for pivot status
-        for (let j = 1; j < analysisWindow.length - 1; j++) {
-            const curr = analysisWindow[j];
-            const prevBar = analysisWindow[j - 1];
-            const nextBar = analysisWindow[j + 1];
-            // Check for high pivot
-            if (curr.high > prevBar.high && curr.high > nextBar.high) {
-                const existingPivot = pivotPoints.find((p) => Math.abs(p.price - curr.high) / curr.high < sensitivity);
-                if (existingPivot) {
-                    existingPivot.count++;
-                    existingPivot.volume += curr.vol; // **Include Volume**
-                }
-                else {
-                    pivotPoints.push({ price: curr.high, count: 1, volume: curr.vol });
-                }
-            }
-            // Check for low pivot
-            if (curr.low < prevBar.low && curr.low < nextBar.low) {
-                const existingPivot = pivotPoints.find((p) => Math.abs(p.price - curr.low) / curr.low < sensitivity);
-                if (existingPivot) {
-                    existingPivot.count++;
-                    existingPivot.volume += curr.vol; // **Include Volume**
-                }
-                else {
-                    pivotPoints.push({ price: curr.low, count: 1, volume: curr.vol });
-                }
-            }
-        }
-        // Group nearby levels
-        const currentPrice = priceData[i].close;
-        const levels = [];
-        // Sort pivots by price
-        pivotPoints.sort((a, b) => a.price - b.price);
-        // Group close pivots
-        let currentGroup = [];
-        for (let j = 0; j < pivotPoints.length; j++) {
-            if (currentGroup.length === 0) {
-                currentGroup.push(pivotPoints[j]);
-            }
-            else {
-                const lastPrice = currentGroup[currentGroup.length - 1].price;
-                if ((Math.abs(pivotPoints[j].price - lastPrice) / lastPrice) * 100 <= minGapBetweenLevels) {
-                    currentGroup.push(pivotPoints[j]);
-                }
-                else {
-                    // Process current group
-                    if (currentGroup.length > 0) {
-                        const totalVolume = currentGroup.reduce((sum, p) => sum + p.volume, 0);
-                        const avgPrice = currentGroup.reduce((sum, p) => sum + p.price * p.volume, 0) / totalVolume;
-                        const totalStrength = currentGroup.reduce((sum, p) => sum + p.count * (p.volume / totalVolume), 0);
-                        levels.push({
-                            price: parseFloat(avgPrice.toFixed(2)),
-                            strength: parseFloat(totalStrength.toFixed(2)),
-                            type: avgPrice > currentPrice ? 'resistance' : 'support',
-                        });
-                    }
-                    currentGroup = [pivotPoints[j]];
-                }
-            }
-        }
-        // Process final group
-        if (currentGroup.length > 0) {
-            const totalVolume = currentGroup.reduce((sum, p) => sum + p.volume, 0);
-            const avgPrice = currentGroup.reduce((sum, p) => sum + p.price * p.volume, 0) / totalVolume;
-            const totalStrength = currentGroup.reduce((sum, p) => sum + p.count * (p.volume / totalVolume), 0);
-            levels.push({
-                price: parseFloat(avgPrice.toFixed(2)),
-                strength: parseFloat(totalStrength.toFixed(2)),
-                type: avgPrice > currentPrice ? 'resistance' : 'support',
-            });
-        }
-        // Sort by strength and limit
-        const finalLevels = levels.sort((a, b) => b.strength - a.strength).slice(0, maxLevels);
-        result.push({
-            date: priceData[i].date,
-            levels: finalLevels,
-            close: currentPrice,
-        });
-    }
-    logIfDebug(`Found ${result.reduce((sum, r) => sum + r.levels.length, 0)} support/resistance levels across ${result.length} periods`);
-    return result;
-}
-
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
@@ -19888,40 +18539,12 @@ const disco = {
         pct: formatPercentage,
         dateTimeForGS: dateTimeForGS,
     },
-    indices: {
-        fetchAggregates: fetchIndicesAggregates,
-        fetchPreviousClose: fetchIndicesPreviousClose,
-        fetchDailyOpenClose: fetchIndicesDailyOpenClose,
-        fetchSnapshot: fetchIndicesSnapshot,
-        fetchUniversalSnapshot: fetchUniversalSnapshot,
-        formatBarData: formatIndicesBarData,
-    },
     llm: {
         call: makeLLMCall,
         seek: makeDeepseekCall,
         images: makeImagesCall,
         open: makeOpenRouterCall,
     },
-    polygon: {
-        fetchTickerInfo: fetchTickerInfo,
-        fetchGroupedDaily: fetchGroupedDaily,
-        fetchLastTrade: fetchLastTrade,
-        fetchTrades: fetchTrades,
-        fetchPrices: fetchPrices,
-        analysePolygonPriceData: analysePolygonPriceData,
-        formatPriceData: formatPriceData,
-        fetchDailyOpenClose: fetchDailyOpenClose,
-        getPreviousClose: getPreviousClose,
-    },
-    ta: {
-        calculateEMA: calculateEMA,
-        calculateMACD: calculateMACD,
-        calculateRSI: calculateRSI,
-        calculateStochasticOscillator: calculateStochasticOscillator,
-        calculateBollingerBands: calculateBollingerBands,
-        calculateSupportAndResistance: calculateSupportAndResistance,
-        calculateFibonacciLevels: calculateFibonacciLevels,
-    },
     time: {
         convertDateToMarketTimeZone: convertDateToMarketTimeZone,
         getStartAndEndDates: getStartAndEndDates,
@@ -19944,7 +18567,6 @@ const disco = {
     utils: {
         logIfDebug: logIfDebug,
         fetchWithRetry: fetchWithRetry,
-        validatePolygonApiKey: validatePolygonApiKey,
         Timer: PerformanceTimer,
     },
 };