@adaptic/utils 0.0.912 → 0.0.913

package/README.md

@@ -387,7 +387,7 @@ Fetches historical bar data for crypto trading pairs.
 
 ## Market Data Functions
 
-### `fetchPolygonPrices(symbol: string, params: object): Promise<PolygonPriceData[]>`
+### `fetchMassivePrices(symbol: string, params: object): Promise<MassivePriceData[]>`
 
 Fetches historical price data from Massive.com.
 
@@ -398,7 +398,7 @@ Fetches historical price data from Massive.com.
 
 **Returns:**
 
-- `Promise<PolygonPriceData[]>`:
+- `Promise<MassivePriceData[]>`:
   ```typescript
   {
     date: string;

package/dist/index.cjs

@@ -2056,13 +2056,13 @@ function validateAlpacaCredentials(auth, options = { throwOnMissing: true }) {
     return true;
 }
 /**
- * Validates Polygon API key
- * @param apiKey - Polygon API key
+ * Validates Massive API key
+ * @param apiKey - Massive API key
  * @throws {Error} If API key is invalid or missing
  */
-function validatePolygonApiKey$1(apiKey) {
+function validateMassiveApiKey$1(apiKey) {
     if (!apiKey || typeof apiKey !== "string" || apiKey.trim().length === 0) {
-        throw new Error("Invalid Polygon API key: must be a non-empty string");
+        throw new Error("Invalid Massive API key: must be a non-empty string");
     }
 }
 /**
@@ -5137,7 +5137,7 @@ function calculateBackoff(attempt, baseDelay, maxDelay) {
  * @template T - The return type of the wrapped function
  * @param fn - The async function to wrap with retry logic
  * @param config - Retry configuration (merged with defaults)
- * @param label - A descriptive label for logging (e.g., 'Polygon.fetchTickerInfo')
+ * @param label - A descriptive label for logging (e.g., 'Massive.fetchTickerInfo')
  * @returns A promise that resolves to the function's return value
  * @throws The last error encountered if all retries are exhausted
  *
@@ -5430,7 +5430,7 @@ async function fetchWithRetry(url, options = {}, retries = 3, initialBackoff = 1
  * @param apiKey - The API key to validate.
  * @returns Promise that resolves to true if valid, false otherwise.
  */
-async function validatePolygonApiKey(apiKey) {
+async function validateMassiveApiKey(apiKey) {
     try {
         const response = await fetch(`https://api.massive.com/v1/meta/symbols?apikey=${apiKey}&limit=1`);
         if (response.status === 401) {
@@ -7051,7 +7051,7 @@ function dateTimeForGS(date) {
  * Massive.com calls
  **********************************************************************************/
 /**
- * Set of Polygon API response statuses that indicate valid, usable data.
+ * Set of Massive API response statuses that indicate valid, usable data.
  * "OK" = real-time data, "DELAYED" = delayed data (still valid, e.g. free-tier plans).
  */
 const MASSIVE_VALID_STATUSES = new Set(["OK", "DELAYED"]);
@@ -7066,14 +7066,14 @@ const massiveLimit = pLimit(MASSIVE_CONCURRENCY_LIMIT);
  * @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.
+ * @returns {Promise<MassiveTickerInfo | null>} The ticker information or null if not found.
  */
 const fetchTickerInfo = async (symbol, options) => {
     if (!options?.apiKey && !MASSIVE_API_KEY) {
-        throw new Error("Polygon API key is missing");
+        throw new Error("Massive API key is missing");
     }
     const apiKey = options?.apiKey || MASSIVE_API_KEY;
-    validatePolygonApiKey$1(apiKey);
+    validateMassiveApiKey$1(apiKey);
     const baseUrl = `https://api.massive.com/v3/reference/tickers/${encodeURIComponent(symbol)}`;
     const params = new URLSearchParams({
         apiKey,
@@ -7090,7 +7090,7 @@ const fetchTickerInfo = async (symbol, options) => {
             // Map the results to the required structure
             const results = data.results;
             if (!results) {
-                throw new Error("No results in Polygon API response");
+                throw new Error("No results in Massive API response");
             }
             // Validate required fields
             const requiredFields = [
@@ -7105,7 +7105,7 @@ const fetchTickerInfo = async (symbol, options) => {
             ];
             for (const field of requiredFields) {
                 if (results[field] === undefined) {
-                    throw new Error(`Missing required field in Polygon API response: ${field}`);
+                    throw new Error(`Missing required field in Massive API response: ${field}`);
                 }
             }
             // Handle optional share_class_shares_outstanding field
@@ -7140,7 +7140,7 @@ const fetchTickerInfo = async (symbol, options) => {
                             ? "NETWORK_ERROR"
                             : "UNKNOWN",
                 url: hideApiKeyFromurl(`${baseUrl}?${params.toString()}`),
-                source: "PolygonAPI.fetchTickerInfo",
+                source: "MassiveAPI.fetchTickerInfo",
                 timestamp: new Date().toISOString(),
             });
             throw new Error(`${contextualMessage}: ${errorMessage}`);
@@ -7153,14 +7153,14 @@ const fetchTickerInfo = async (symbol, options) => {
  * @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.
+ * @returns {Promise<MassiveQuote>} The last trade information.
  */
 const fetchLastTrade = async (symbol, options) => {
     if (!options?.apiKey && !MASSIVE_API_KEY) {
-        throw new Error("Polygon API key is missing");
+        throw new Error("Massive API key is missing");
     }
     const apiKey = options?.apiKey || MASSIVE_API_KEY;
-    validatePolygonApiKey$1(apiKey);
+    validateMassiveApiKey$1(apiKey);
     const baseUrl = `https://api.massive.com/v2/last/trade/${encodeURIComponent(symbol)}`;
     const params = new URLSearchParams({
         apiKey,
@@ -7198,14 +7198,14 @@ const fetchLastTrade = async (symbol, options) => {
                             ? "NETWORK_ERROR"
                             : "UNKNOWN",
                 url: hideApiKeyFromurl(`${baseUrl}?${params.toString()}`),
-                source: "PolygonAPI.fetchLastTrade",
+                source: "MassiveAPI.fetchLastTrade",
                 timestamp: new Date().toISOString(),
             });
             throw new Error(`${contextualMessage}: ${errorMessage}`);
         }
     });
 };
-// use Polygon for all price data fetching
+// use Massive for all price data fetching
 /**
  * Fetches price data for a given stock ticker.
  * @param {Object} params - The parameters for fetching price data.
@@ -7217,14 +7217,14 @@ const fetchLastTrade = async (symbol, options) => {
  * @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.
+ * @returns {Promise<MassivePriceData[]>} The fetched price data.
  */
 const fetchPrices = async (params, options) => {
     if (!options?.apiKey && !MASSIVE_API_KEY) {
-        throw new Error("Polygon API key is missing");
+        throw new Error("Massive API key is missing");
     }
     const apiKey = options?.apiKey || MASSIVE_API_KEY;
-    validatePolygonApiKey$1(apiKey);
+    validateMassiveApiKey$1(apiKey);
     const { ticker, start, end = Date.now().valueOf(), multiplier, timespan, limit = 1000, } = params;
     const baseUrl = `https://api.massive.com/v2/aggs/ticker/${encodeURIComponent(ticker)}/range/${multiplier}/${timespan}/${start}/${end}`;
     const urlParams = new URLSearchParams({
@@ -7245,7 +7245,7 @@ const fetchPrices = async (params, options) => {
                     throw new Error(`Massive.com API responded with status: ${data.status}`);
                 }
                 if (data.status === "DELAYED") {
-                    getLogger().warn(`Massive.com returned DELAYED data for ${params.ticker} — using delayed results`, { ticker: params.ticker, source: "PolygonAPI.fetchPrices" });
+                    getLogger().warn(`Massive.com returned DELAYED data for ${params.ticker} — using delayed results`, { ticker: params.ticker, source: "MassiveAPI.fetchPrices" });
                 }
                 if (data.results) {
                     allResults = [...allResults, ...data.results];
@@ -7288,7 +7288,7 @@ const fetchPrices = async (params, options) => {
                             error.message.includes("NETWORK_ERROR")
                             ? "NETWORK_ERROR"
                             : "UNKNOWN",
-                source: "PolygonAPI.fetchPrices",
+                source: "MassiveAPI.fetchPrices",
                 timestamp: new Date().toISOString(),
             });
             throw new Error(`${contextualMessage}: ${errorMessage}`);
@@ -7297,10 +7297,10 @@ const fetchPrices = async (params, options) => {
 };
 /**
  * Analyzes the price data for a given stock.
- * @param {PolygonPriceData[]} priceData - The price data to analyze.
+ * @param {MassivePriceData[]} priceData - The price data to analyze.
  * @returns {string} The analysis report.
  */
-function analysePolygonPriceData(priceData) {
+function analyseMassivePriceData(priceData) {
     if (!priceData || priceData.length === 0) {
         return "No price data available for analysis.";
     }
@@ -7342,11 +7342,11 @@ Report:
  * @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.
+ * @returns {Promise<MassiveGroupedDailyResponse>} The grouped daily response.
  */
 const fetchGroupedDaily = async (date, options) => {
     if (!options?.apiKey && !MASSIVE_API_KEY) {
-        throw new Error("Polygon API key is missing");
+        throw new Error("Massive API key is missing");
     }
     const baseUrl = `https://api.massive.com/v2/aggs/grouped/locale/us/market/stocks/${date}`;
     const params = new URLSearchParams({
@@ -7394,7 +7394,7 @@ const fetchGroupedDaily = async (date, options) => {
                             ? "NETWORK_ERROR"
                             : "UNKNOWN",
                 url: hideApiKeyFromurl(`${baseUrl}?${params.toString()}`),
-                source: "PolygonAPI.fetchGroupedDaily",
+                source: "MassiveAPI.fetchGroupedDaily",
                 timestamp: new Date().toISOString(),
             });
             throw new Error(`${contextualMessage}: ${errorMessage}`);
@@ -7403,7 +7403,7 @@ const fetchGroupedDaily = async (date, options) => {
 };
 /**
  * Formats the price data into a readable string.
- * @param {PolygonPriceData[]} priceData - The price data to format.
+ * @param {MassivePriceData[]} priceData - The price data to format.
  * @returns {string} The formatted price data.
  */
 function formatPriceData(priceData) {
@@ -7434,11 +7434,11 @@ const fetchDailyOpenClose = async (
  * @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.
+ * @returns {Promise<MassiveDailyOpenClose>} The daily open and close data.
  */
 symbol, date = new Date(), options) => {
     if (!options?.apiKey && !MASSIVE_API_KEY) {
-        throw new Error("Polygon API key is missing");
+        throw new Error("Massive API key is missing");
     }
     const formattedDate = date.toISOString().split("T")[0]; // Format as YYYY-MM-DD
     const baseUrl = `https://api.massive.com/v1/open-close/${encodeURIComponent(symbol)}/${formattedDate}`;
@@ -7485,11 +7485,11 @@ async function getPreviousClose$1(symbol, referenceDate, options) {
  * @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.
+ * @returns {Promise<MassiveTradesResponse>} The fetched trades response.
  */
 const fetchTrades = async (symbol, options) => {
     if (!options?.apiKey && !MASSIVE_API_KEY) {
-        throw new Error("Polygon API key is missing");
+        throw new Error("Massive API key is missing");
     }
     const baseUrl = `https://api.massive.com/v3/trades/${encodeURIComponent(symbol)}`;
     const params = new URLSearchParams({
@@ -7520,7 +7520,7 @@ const fetchTrades = async (symbol, options) => {
             const data = (await response.json());
             if ("message" in data) {
                 // This is an error response
-                throw new Error(`Polygon API Error: ${data.message}`);
+                throw new Error(`Massive API Error: ${data.message}`);
             }
             return data;
         }
@@ -7538,7 +7538,7 @@ const fetchTrades = async (symbol, options) => {
                             ? "NETWORK_ERROR"
                             : "UNKNOWN",
                 url: hideApiKeyFromurl(url),
-                source: "PolygonAPI.fetchTrades",
+                source: "MassiveAPI.fetchTrades",
                 timestamp: new Date().toISOString(),
             });
             throw new Error(`${contextualMessage}: ${errorMessage}`);
@@ -7547,7 +7547,7 @@ const fetchTrades = async (symbol, options) => {
 };
 
 /**
- * Polygon Indices API Implementation
+ * Massive Indices API Implementation
  *
  * This module provides functions to interact with the Massive.com Indices API.
  */
@@ -7556,7 +7556,7 @@ const { ALPACA_INDICES_API_KEY } = process.env;
 // Define concurrency limits for API
 const MASSIVE_INDICES_CONCURRENCY_LIMIT = 5;
 const massiveIndicesLimit = pLimit(MASSIVE_INDICES_CONCURRENCY_LIMIT);
-// Base URL for Polygon API
+// Base URL for Massive API
 const MASSIVE_API_BASE_URL = "https://api.massive.com";
 /**
  * Validates that an API key is available
@@ -7566,17 +7566,17 @@ const MASSIVE_API_BASE_URL = "https://api.massive.com";
 const validateApiKey = (apiKey) => {
     const key = apiKey || ALPACA_INDICES_API_KEY;
     if (!key) {
-        throw new Error("Polygon Indices API key is missing");
+        throw new Error("Massive 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 {MassiveIndicesAggregatesParams} 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
+ * @returns {Promise<MassiveIndicesAggregatesResponse>} The aggregates response
  */
 const fetchIndicesAggregates = async (params, options) => {
     const apiKey = validateApiKey(options?.apiKey);
@@ -7596,7 +7596,7 @@ const fetchIndicesAggregates = async (params, options) => {
             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}`);
+                throw new Error(`Massive API Error: ${data.error}`);
             }
             return data;
         }
@@ -7612,7 +7612,7 @@ const fetchIndicesAggregates = async (params, options) => {
  * @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
+ * @returns {Promise<MassiveIndicesPrevCloseResponse>} The previous close response
  */
 const fetchIndicesPreviousClose = async (indicesTicker, options) => {
     const apiKey = validateApiKey(options?.apiKey);
@@ -7625,7 +7625,7 @@ const fetchIndicesPreviousClose = async (indicesTicker, options) => {
             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}`);
+                throw new Error(`Massive API Error: ${data.error}`);
             }
             return data;
         }
@@ -7642,7 +7642,7 @@ const fetchIndicesPreviousClose = async (indicesTicker, options) => {
  * @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
+ * @returns {Promise<MassiveIndicesDailyOpenCloseResponse>} The daily open/close response
  */
 const fetchIndicesDailyOpenClose = async (indicesTicker, date, options) => {
     const apiKey = validateApiKey(options?.apiKey);
@@ -7655,7 +7655,7 @@ const fetchIndicesDailyOpenClose = async (indicesTicker, date, options) => {
             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}`);
+                throw new Error(`Massive API Error: ${data.error}`);
             }
             return data;
         }
@@ -7668,10 +7668,10 @@ const fetchIndicesDailyOpenClose = async (indicesTicker, date, options) => {
 /**
  * Gets a snapshot of indices data for specified tickers.
  *
- * @param {PolygonIndicesSnapshotParams} [params] - Parameters for the snapshot request
+ * @param {MassiveIndicesSnapshotParams} [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
+ * @returns {Promise<MassiveIndicesSnapshotResponse>} The indices snapshot response
  */
 const fetchIndicesSnapshot = async (params, options) => {
     const apiKey = validateApiKey(options?.apiKey);
@@ -7696,7 +7696,7 @@ const fetchIndicesSnapshot = async (params, options) => {
             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}`);
+                throw new Error(`Massive API Error: ${data.error}`);
             }
             return data;
         }
@@ -7716,7 +7716,7 @@ const fetchIndicesSnapshot = async (params, options) => {
  * @param {string} [options.order] - Order results
  * @param {number} [options.limit] - Limit the number of results
  * @param {string} [options.sort] - Sort field
- * @returns {Promise<PolygonIndicesSnapshotResponse>} The universal snapshot response
+ * @returns {Promise<MassiveIndicesSnapshotResponse>} The universal snapshot response
  */
 const fetchUniversalSnapshot = async (tickers, options) => {
     const apiKey = validateApiKey(options?.apiKey);
@@ -7744,7 +7744,7 @@ const fetchUniversalSnapshot = async (tickers, options) => {
             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}`);
+                throw new Error(`Massive API Error: ${data.error}`);
             }
             return data;
         }
@@ -7755,9 +7755,9 @@ const fetchUniversalSnapshot = async (tickers, options) => {
     });
 };
 /**
- * Converts Polygon Indices bar data to a more standardized format
+ * Converts Massive Indices bar data to a more standardized format
  *
- * @param {PolygonIndicesAggregatesResponse} data - The raw aggregates response
+ * @param {MassiveIndicesAggregatesResponse} 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) => {
@@ -9222,7 +9222,7 @@ async function fetchPerformanceMetrics({ params, client, accountId, alpacaAccoun
  * Structured error type hierarchy for all API integrations
  *
  * This module provides a comprehensive error handling system for external API integrations,
- * including Alpaca, Polygon, and AlphaVantage services.
+ * including Alpaca, Massive, and AlphaVantage services.
  */
 /**
  * Base error class for all @adaptic/utils errors
@@ -9262,9 +9262,9 @@ class AlpacaApiError extends AdapticUtilsError {
 }
 /**
  * Massive.com API specific errors
- * Handles all errors from Polygon market data API
+ * Handles all errors from Massive market data API
  */
-class PolygonApiError extends AdapticUtilsError {
+class MassiveApiError extends AdapticUtilsError {
     statusCode;
     constructor(message, code, statusCode, cause) {
         // Rate limit (429) and server errors (5xx) are retryable
@@ -9419,7 +9419,7 @@ class DataFormatError extends AdapticUtilsError {
  * Token bucket rate limiter for external API integrations
  *
  * Implements client-side rate limiting to prevent exceeding API quotas
- * and ensure fair usage of external services like Alpaca, Polygon, and AlphaVantage.
+ * and ensure fair usage of external services like Alpaca, Massive, and AlphaVantage.
  *
  * @example
  * ```typescript
@@ -48369,7 +48369,7 @@ class AlpacaClient {
             keyId: config.apiKey,
             secretKey: config.apiSecret,
             paper: config.accountType === "PAPER",
-            usePolygon: false,
+            useMassive: false,
         });
         // Set up for direct API calls
         this.apiBaseUrl = getTradingApiUrl(config.accountType);
@@ -60326,7 +60326,7 @@ class LRUCache {
  * request bursts during synchronized cache expiration events.
  *
  * @rationale In algorithmic trading, cache stampedes can:
- * - Overwhelm market data APIs (Alpaca, Polygon) causing rate limiting (200 req/min limits)
+ * - Overwhelm market data APIs (Alpaca, Massive) causing rate limiting (200 req/min limits)
  * - Introduce latency spikes during critical trading windows (market open/close)
  * - Trigger cascading failures when position data becomes unavailable
  * - Cause missed trading opportunities due to stale or unavailable data
@@ -66145,8 +66145,8 @@ const AlpacaCryptoBarsResponseSchema = objectType({
  * Validates API responses against expected shapes to catch breaking API changes early.
  */
 // ===== Raw Price Data Schemas =====
-/** Schema for raw Polygon price data (as returned from aggregates endpoint) */
-const RawPolygonPriceDataSchema = objectType({
+/** Schema for raw Massive price data (as returned from aggregates endpoint) */
+const RawMassivePriceDataSchema = objectType({
     T: stringType(),
     c: numberType(),
     h: numberType(),
@@ -66158,8 +66158,8 @@ const RawPolygonPriceDataSchema = objectType({
     vw: numberType(),
 });
 // ===== Ticker Info Schemas =====
-/** Schema for Polygon ticker info response */
-const PolygonTickerInfoSchema = objectType({
+/** Schema for Massive ticker info response */
+const MassiveTickerInfoSchema = objectType({
     active: booleanType(),
     currency_name: stringType(),
     delisted_utc: stringType().optional(),
@@ -66174,24 +66174,24 @@ const PolygonTickerInfoSchema = objectType({
     type: stringType(),
 });
 /** Schema for the wrapper around ticker details API response */
-const PolygonTickerDetailsResponseSchema = objectType({
-    results: PolygonTickerInfoSchema,
+const MassiveTickerDetailsResponseSchema = objectType({
+    results: MassiveTickerInfoSchema,
     status: stringType(),
     request_id: stringType(),
 });
 // ===== Grouped Daily Schemas =====
-/** Schema for Polygon grouped daily response */
-const PolygonGroupedDailyResponseSchema = objectType({
+/** Schema for Massive grouped daily response */
+const MassiveGroupedDailyResponseSchema = objectType({
     adjusted: booleanType(),
     queryCount: numberType(),
     request_id: stringType(),
     resultsCount: numberType(),
     status: stringType(),
-    results: arrayType(RawPolygonPriceDataSchema),
+    results: arrayType(RawMassivePriceDataSchema),
 });
 // ===== Daily Open Close Schemas =====
-/** Schema for Polygon daily open close response */
-const PolygonDailyOpenCloseSchema = objectType({
+/** Schema for Massive daily open close response */
+const MassiveDailyOpenCloseSchema = objectType({
     afterHours: numberType().optional(),
     close: numberType(),
     from: stringType(),
@@ -66204,8 +66204,8 @@ const PolygonDailyOpenCloseSchema = objectType({
     volume: numberType(),
 });
 // ===== Trade Schemas =====
-/** Schema for a single Polygon trade */
-const PolygonTradeSchema = objectType({
+/** Schema for a single Massive trade */
+const MassiveTradeSchema = objectType({
     conditions: arrayType(numberType()),
     correction: numberType().optional(),
     exchange: numberType(),
@@ -66219,16 +66219,16 @@ const PolygonTradeSchema = objectType({
     trf_id: numberType().optional(),
     trf_timestamp: numberType().optional(),
 });
-/** Schema for Polygon trades response */
-const PolygonTradesResponseSchema = objectType({
+/** Schema for Massive trades response */
+const MassiveTradesResponseSchema = objectType({
     status: literalType("OK"),
     request_id: stringType(),
     next_url: stringType().optional(),
-    results: arrayType(PolygonTradeSchema),
+    results: arrayType(MassiveTradeSchema),
 });
 // ===== Last Trade Schemas =====
-/** Schema for Polygon last trade response */
-const PolygonLastTradeResponseSchema = objectType({
+/** Schema for Massive last trade response */
+const MassiveLastTradeResponseSchema = objectType({
     status: stringType(),
     request_id: stringType(),
     results: objectType({
@@ -66245,20 +66245,20 @@ const PolygonLastTradeResponseSchema = objectType({
     }),
 });
 // ===== Aggregates (Bars) Schemas =====
-/** Schema for Polygon aggregates (bars) response */
-const PolygonAggregatesResponseSchema = objectType({
+/** Schema for Massive aggregates (bars) response */
+const MassiveAggregatesResponseSchema = objectType({
     adjusted: booleanType().optional(),
     next_url: stringType().optional(),
     queryCount: numberType().optional(),
     request_id: stringType(),
-    results: arrayType(RawPolygonPriceDataSchema).optional(),
+    results: arrayType(RawMassivePriceDataSchema).optional(),
     resultsCount: numberType().optional(),
     status: stringType(),
     ticker: stringType().optional(),
 });
 // ===== Error Response Schema =====
-/** Schema for Polygon error response */
-const PolygonErrorResponseSchema = objectType({
+/** Schema for Massive error response */
+const MassiveErrorResponseSchema = objectType({
     status: stringType(),
     request_id: stringType(),
     message: stringType(),
@@ -66318,7 +66318,7 @@ const AVNewsResponseSchema = objectType({
  *
  * Supports:
  * - Cursor-based pagination (Alpaca: `next_page_token` / `page_token`)
- * - URL-based pagination (Polygon: `next_url`)
+ * - URL-based pagination (Massive: `next_url`)
  * - Offset-based pagination (page numbers or skip/take)
  *
  * Provides both async iterator and collect-all patterns.
@@ -66713,7 +66713,7 @@ const adaptic = {
         fetchLastTrade: fetchLastTrade,
         fetchTrades: fetchTrades,
         fetchPrices: fetchPrices,
-        analysePolygonPriceData: analysePolygonPriceData,
+        analyseMassivePriceData: analyseMassivePriceData,
         formatPriceData: formatPriceData,
         fetchDailyOpenClose: fetchDailyOpenClose,
         getPreviousClose: getPreviousClose$1,
@@ -66770,7 +66770,7 @@ const adaptic = {
     utils: {
         logIfDebug: logIfDebug,
         fetchWithRetry: fetchWithRetry,
-        validatePolygonApiKey: validatePolygonApiKey,
+        validateMassiveApiKey: validateMassiveApiKey,
     },
     rateLimiter: {
         TokenBucketRateLimiter,
@@ -66818,23 +66818,23 @@ exports.HttpClientError = HttpClientError;
 exports.HttpServerError = HttpServerError;
 exports.KEEP_ALIVE_DEFAULTS = KEEP_ALIVE_DEFAULTS;
 exports.MARKET_DATA_API = MARKET_DATA_API;
+exports.MassiveAggregatesResponseSchema = MassiveAggregatesResponseSchema;
+exports.MassiveApiError = MassiveApiError;
+exports.MassiveDailyOpenCloseSchema = MassiveDailyOpenCloseSchema;
+exports.MassiveErrorResponseSchema = MassiveErrorResponseSchema;
+exports.MassiveGroupedDailyResponseSchema = MassiveGroupedDailyResponseSchema;
+exports.MassiveLastTradeResponseSchema = MassiveLastTradeResponseSchema;
+exports.MassiveTickerDetailsResponseSchema = MassiveTickerDetailsResponseSchema;
+exports.MassiveTickerInfoSchema = MassiveTickerInfoSchema;
+exports.MassiveTradeZodSchema = MassiveTradeSchema;
+exports.MassiveTradesResponseSchema = MassiveTradesResponseSchema;
 exports.NetworkError = NetworkError;
 exports.NewsError = NewsError;
 exports.OptionStrategyError = OptionStrategyError;
 exports.OptionsDataError = OptionsDataError;
-exports.PolygonAggregatesResponseSchema = PolygonAggregatesResponseSchema;
-exports.PolygonApiError = PolygonApiError;
-exports.PolygonDailyOpenCloseSchema = PolygonDailyOpenCloseSchema;
-exports.PolygonErrorResponseSchema = PolygonErrorResponseSchema;
-exports.PolygonGroupedDailyResponseSchema = PolygonGroupedDailyResponseSchema;
-exports.PolygonLastTradeResponseSchema = PolygonLastTradeResponseSchema;
-exports.PolygonTickerDetailsResponseSchema = PolygonTickerDetailsResponseSchema;
-exports.PolygonTickerInfoSchema = PolygonTickerInfoSchema;
-exports.PolygonTradeZodSchema = PolygonTradeSchema;
-exports.PolygonTradesResponseSchema = PolygonTradesResponseSchema;
 exports.QuoteError = QuoteError;
 exports.RateLimitError = RateLimitError;
-exports.RawPolygonPriceDataSchema = RawPolygonPriceDataSchema;
+exports.RawMassivePriceDataSchema = RawMassivePriceDataSchema;
 exports.StampedeProtectedCache = StampedeProtectedCache;
 exports.TRADING_API = TRADING_API;
 exports.TimeoutError = TimeoutError;
@@ -67047,8 +67047,8 @@ exports.updateAccountConfiguration = updateAccountConfiguration;
 exports.updateTrailingStop = updateTrailingStop;
 exports.validateAlpacaCredentials = validateAlpacaCredentials;
 exports.validateAlphaVantageApiKey = validateAlphaVantageApiKey;
+exports.validateMassiveApiKey = validateMassiveApiKey$1;
 exports.validateMultiLegOrder = validateMultiLegOrder;
-exports.validatePolygonApiKey = validatePolygonApiKey$1;
 exports.validateResponse = validateResponse;
 exports.verifyFetchKeepAlive = verifyFetchKeepAlive;
 exports.waitForOrderFill = waitForOrderFill;