@adaptic/utils 0.1.41 → 0.1.43

package/dist/index.cjs

@@ -12280,13 +12280,13 @@ class DisplayManager {
  * @param options.symbol The trading symbol associated with this log.
  * @param options.logToFile Force logging to a file even when no symbol is provided.
  */
-function log$l(message, options = { source: "Server", type: "info" }) {
+function log$m(message, options = { source: "Server", type: "info" }) {
     const displayManager = DisplayManager.getInstance();
     displayManager.log(message, options);
 }
 
-const log$k = (message, options = { type: "info" }) => {
-    log$l(message, { ...options, source: "AlpacaMarketDataAPI" });
+const log$l = (message, options = { type: "info" }) => {
+    log$m(message, { ...options, source: "AlpacaMarketDataAPI" });
 };
 // Default settings for market data API
 const DEFAULT_ADJUSTMENT = "all";
@@ -12416,7 +12416,7 @@ class AlpacaMarketDataAPI extends require$$0$4.EventEmitter {
             this.cryptoWs = ws;
         }
         ws.on("open", () => {
-            log$k(`${streamType} stream connected`, { type: "info" });
+            log$l(`${streamType} stream connected`, { type: "info" });
             const authMessage = {
                 action: "auth",
                 key: process.env.ALPACA_API_KEY,
@@ -12431,36 +12431,36 @@ class AlpacaMarketDataAPI extends require$$0$4.EventEmitter {
                 messages = JSON.parse(rawData);
             }
             catch (e) {
-                log$k(`${streamType} stream received invalid JSON: ${rawData.substring(0, 200)}`, { type: "error" });
+                log$l(`${streamType} stream received invalid JSON: ${rawData.substring(0, 200)}`, { type: "error" });
                 return;
             }
             for (const message of messages) {
                 if (message.T === "success" && message.msg === "authenticated") {
-                    log$k(`${streamType} stream authenticated`, { type: "info" });
+                    log$l(`${streamType} stream authenticated`, { type: "info" });
                     this.sendSubscription(streamType);
                 }
                 else if (message.T === "success" && message.msg === "connected") {
-                    log$k(`${streamType} stream connected message received`, {
+                    log$l(`${streamType} stream connected message received`, {
                         type: "debug",
                     });
                 }
                 else if (message.T === "subscription") {
-                    log$k(`${streamType} subscription confirmed: trades=${message.trades?.length || 0}, quotes=${message.quotes?.length || 0}, bars=${message.bars?.length || 0}`, { type: "info" });
+                    log$l(`${streamType} subscription confirmed: trades=${message.trades?.length || 0}, quotes=${message.quotes?.length || 0}, bars=${message.bars?.length || 0}`, { type: "info" });
                 }
                 else if (message.T === "error") {
-                    log$k(`${streamType} stream error: ${message.msg} (code: ${message.code}, raw: ${JSON.stringify(message)})`, { type: "error" });
+                    log$l(`${streamType} stream error: ${message.msg} (code: ${message.code}, raw: ${JSON.stringify(message)})`, { type: "error" });
                 }
                 else if (message.S) {
                     super.emit(`${streamType}-${message.T}`, message);
                     super.emit(`${streamType}-data`, message);
                 }
                 else {
-                    log$k(`${streamType} received unknown message type: ${JSON.stringify(message)}`, { type: "debug" });
+                    log$l(`${streamType} received unknown message type: ${JSON.stringify(message)}`, { type: "debug" });
                 }
             }
         });
         ws.on("close", () => {
-            log$k(`${streamType} stream disconnected`, { type: "warn" });
+            log$l(`${streamType} stream disconnected`, { type: "warn" });
             if (streamType === "stock") {
                 this.stockWs = null;
             }
@@ -12473,7 +12473,7 @@ class AlpacaMarketDataAPI extends require$$0$4.EventEmitter {
             // Optional: implement reconnect logic
         });
         ws.on("error", (error) => {
-            log$k(`${streamType} stream error: ${error.message}`, { type: "error" });
+            log$l(`${streamType} stream error: ${error.message}`, { type: "error" });
         });
     }
     sendSubscription(streamType) {
@@ -12491,7 +12491,7 @@ class AlpacaMarketDataAPI extends require$$0$4.EventEmitter {
             ws = this.cryptoWs;
             subscriptions = this.cryptoSubscriptions;
         }
-        log$k(`sendSubscription called for ${streamType} (wsReady=${ws?.readyState === WebSocket.OPEN}, trades=${subscriptions.trades?.length || 0}, quotes=${subscriptions.quotes?.length || 0}, bars=${subscriptions.bars?.length || 0})`, {
+        log$l(`sendSubscription called for ${streamType} (wsReady=${ws?.readyState === WebSocket.OPEN}, trades=${subscriptions.trades?.length || 0}, quotes=${subscriptions.quotes?.length || 0}, bars=${subscriptions.bars?.length || 0})`, {
             type: "debug",
         });
         if (ws && ws.readyState === WebSocket.OPEN) {
@@ -12511,19 +12511,19 @@ class AlpacaMarketDataAPI extends require$$0$4.EventEmitter {
                     ...subMessagePayload,
                 };
                 const messageJson = JSON.stringify(subMessage);
-                log$k(`Sending ${streamType} subscription: ${messageJson}`, {
+                log$l(`Sending ${streamType} subscription: ${messageJson}`, {
                     type: "info",
                 });
                 ws.send(messageJson);
             }
             else {
-                log$k(`No ${streamType} subscriptions to send (all arrays empty)`, {
+                log$l(`No ${streamType} subscriptions to send (all arrays empty)`, {
                     type: "debug",
                 });
             }
         }
         else {
-            log$k(`Cannot send ${streamType} subscription: WebSocket not ready`, {
+            log$l(`Cannot send ${streamType} subscription: WebSocket not ready`, {
                 type: "warn",
             });
         }
@@ -12653,7 +12653,7 @@ class AlpacaMarketDataAPI extends require$$0$4.EventEmitter {
             });
             if (!response.ok) {
                 const errorText = await response.text();
-                log$k(`Market Data API error (${response.status}): ${errorText}`, {
+                log$l(`Market Data API error (${response.status}): ${errorText}`, {
                     type: "error",
                 });
                 throw new Error(`Market Data API error (${response.status}): ${errorText}`);
@@ -12663,9 +12663,9 @@ class AlpacaMarketDataAPI extends require$$0$4.EventEmitter {
         }
         catch (err) {
             const error = err;
-            log$k(`Error in makeRequest: ${error.message}. Endpoint: ${endpoint}. Url: ${url.toString()}`, { type: "error" });
+            log$l(`Error in makeRequest: ${error.message}. Endpoint: ${endpoint}. Url: ${url.toString()}`, { type: "error" });
             if (error instanceof TypeError) {
-                log$k(`Network error details: ${error.stack}`, { type: "error" });
+                log$l(`Network error details: ${error.stack}`, { type: "error" });
             }
             throw error;
         }
@@ -12689,7 +12689,7 @@ class AlpacaMarketDataAPI extends require$$0$4.EventEmitter {
         symbols.forEach((symbol) => {
             allBars[symbol] = [];
         });
-        log$k(`Starting historical bars fetch for ${symbolsStr} (${params.timeframe}, ${params.start || "no start"} to ${params.end || "no end"})`, {
+        log$l(`Starting historical bars fetch for ${symbolsStr} (${params.timeframe}, ${params.start || "no start"} to ${params.end || "no end"})`, {
             type: "info",
         });
         while (hasMorePages) {
@@ -12702,7 +12702,7 @@ class AlpacaMarketDataAPI extends require$$0$4.EventEmitter {
             };
             const response = await this.makeRequest("/stocks/bars", "GET", requestParams);
             if (!response.bars) {
-                log$k(`No bars data found in response for ${symbolsStr}`, {
+                log$l(`No bars data found in response for ${symbolsStr}`, {
                     type: "warn",
                 });
                 break;
@@ -12738,12 +12738,12 @@ class AlpacaMarketDataAPI extends require$$0$4.EventEmitter {
             const dateRangeStr = earliestTimestamp && latestTimestamp
                 ? `${earliestTimestamp.toLocaleDateString("en-US", { timeZone: "America/New_York" })} to ${latestTimestamp.toLocaleDateString("en-US", { timeZone: "America/New_York" })}`
                 : "unknown range";
-            log$k(`Page ${pageCount}: Fetched ${pageBarsCount.toLocaleString()} bars (total: ${totalBarsCount.toLocaleString()}) for ${symbolsStr}, date range: ${dateRangeStr}${hasMorePages ? ", more pages available" : ", complete"}`, {
+            log$l(`Page ${pageCount}: Fetched ${pageBarsCount.toLocaleString()} bars (total: ${totalBarsCount.toLocaleString()}) for ${symbolsStr}, date range: ${dateRangeStr}${hasMorePages ? ", more pages available" : ", complete"}`, {
                 type: "info",
             });
             // Prevent infinite loops
             if (pageCount > 1000) {
-                log$k(`Stopping pagination after ${pageCount} pages to prevent infinite loop`, { type: "warn" });
+                log$l(`Stopping pagination after ${pageCount} pages to prevent infinite loop`, { type: "warn" });
                 break;
             }
         }
@@ -12751,7 +12751,7 @@ class AlpacaMarketDataAPI extends require$$0$4.EventEmitter {
         const symbolCounts = Object.entries(allBars)
             .map(([symbol, bars]) => `${symbol}: ${bars.length}`)
             .join(", ");
-        log$k(`Historical bars fetch complete: ${totalBarsCount.toLocaleString()} total bars across ${pageCount} pages (${symbolCounts})`, {
+        log$l(`Historical bars fetch complete: ${totalBarsCount.toLocaleString()} total bars across ${pageCount} pages (${symbolCounts})`, {
             type: "info",
         });
         return {
@@ -12807,7 +12807,7 @@ class AlpacaMarketDataAPI extends require$$0$4.EventEmitter {
     async getLatestQuotes(symbols, feed, currency) {
         // Return empty response if symbols array is empty to avoid API error
         if (!symbols || symbols.length === 0) {
-            log$k("No symbols provided to getLatestQuotes, returning empty response", {
+            log$l("No symbols provided to getLatestQuotes, returning empty response", {
                 type: "warn",
             });
             return {
@@ -12851,7 +12851,7 @@ class AlpacaMarketDataAPI extends require$$0$4.EventEmitter {
             limit: 1,
         });
         if (!response.bars[symbol] || response.bars[symbol].length === 0) {
-            log$k(`No previous close data available for ${symbol}`, {
+            log$l(`No previous close data available for ${symbol}`, {
                 type: "error",
                 symbol,
             });
@@ -13028,7 +13028,7 @@ class AlpacaMarketDataAPI extends require$$0$4.EventEmitter {
         symbols.forEach((symbol) => {
             allBars[symbol] = [];
         });
-        log$k(`Starting historical options bars fetch for ${symbolsStr} (${params.timeframe}, ${params.start || "no start"} to ${params.end || "no end"})`, {
+        log$l(`Starting historical options bars fetch for ${symbolsStr} (${params.timeframe}, ${params.start || "no start"} to ${params.end || "no end"})`, {
             type: "info",
         });
         while (hasMorePages) {
@@ -13039,7 +13039,7 @@ class AlpacaMarketDataAPI extends require$$0$4.EventEmitter {
             };
             const response = await this.makeRequest("/options/bars", "GET", requestParams, "v1beta1");
             if (!response.bars) {
-                log$k(`No options bars data found in response for ${symbolsStr}`, {
+                log$l(`No options bars data found in response for ${symbolsStr}`, {
                     type: "warn",
                 });
                 break;
@@ -13071,12 +13071,12 @@ class AlpacaMarketDataAPI extends require$$0$4.EventEmitter {
             const dateRangeStr = earliestTimestamp && latestTimestamp
                 ? `${earliestTimestamp.toLocaleDateString("en-US", { timeZone: "America/New_York" })} to ${latestTimestamp.toLocaleDateString("en-US", { timeZone: "America/New_York" })}`
                 : "unknown range";
-            log$k(`Page ${pageCount}: Fetched ${pageBarsCount.toLocaleString()} option bars (total: ${totalBarsCount.toLocaleString()}) for ${symbolsStr}, date range: ${dateRangeStr}${hasMorePages ? ", more pages available" : ", complete"}`, {
+            log$l(`Page ${pageCount}: Fetched ${pageBarsCount.toLocaleString()} option bars (total: ${totalBarsCount.toLocaleString()}) for ${symbolsStr}, date range: ${dateRangeStr}${hasMorePages ? ", more pages available" : ", complete"}`, {
                 type: "info",
             });
             // Prevent infinite loops
             if (pageCount > 1000) {
-                log$k(`Stopping options bars pagination after ${pageCount} pages to prevent infinite loop`, { type: "warn" });
+                log$l(`Stopping options bars pagination after ${pageCount} pages to prevent infinite loop`, { type: "warn" });
                 break;
             }
         }
@@ -13084,7 +13084,7 @@ class AlpacaMarketDataAPI extends require$$0$4.EventEmitter {
         const symbolCounts = Object.entries(allBars)
             .map(([symbol, bars]) => `${symbol}: ${bars.length}`)
             .join(", ");
-        log$k(`Historical options bars fetch complete: ${totalBarsCount.toLocaleString()} total bars across ${pageCount} pages (${symbolCounts})`, {
+        log$l(`Historical options bars fetch complete: ${totalBarsCount.toLocaleString()} total bars across ${pageCount} pages (${symbolCounts})`, {
             type: "info",
         });
         return {
@@ -13112,7 +13112,7 @@ class AlpacaMarketDataAPI extends require$$0$4.EventEmitter {
         symbols.forEach((symbol) => {
             allTrades[symbol] = [];
         });
-        log$k(`Starting historical options trades fetch for ${symbolsStr} (${params.start || "no start"} to ${params.end || "no end"})`, {
+        log$l(`Starting historical options trades fetch for ${symbolsStr} (${params.start || "no start"} to ${params.end || "no end"})`, {
             type: "info",
         });
         while (hasMorePages) {
@@ -13123,7 +13123,7 @@ class AlpacaMarketDataAPI extends require$$0$4.EventEmitter {
             };
             const response = await this.makeRequest("/options/trades", "GET", requestParams, "v1beta1");
             if (!response.trades) {
-                log$k(`No options trades data found in response for ${symbolsStr}`, {
+                log$l(`No options trades data found in response for ${symbolsStr}`, {
                     type: "warn",
                 });
                 break;
@@ -13155,12 +13155,12 @@ class AlpacaMarketDataAPI extends require$$0$4.EventEmitter {
             const dateRangeStr = earliestTimestamp && latestTimestamp
                 ? `${earliestTimestamp.toLocaleDateString("en-US", { timeZone: "America/New_York" })} to ${latestTimestamp.toLocaleDateString("en-US", { timeZone: "America/New_York" })}`
                 : "unknown range";
-            log$k(`Page ${pageCount}: Fetched ${pageTradesCount.toLocaleString()} option trades (total: ${totalTradesCount.toLocaleString()}) for ${symbolsStr}, date range: ${dateRangeStr}${hasMorePages ? ", more pages available" : ", complete"}`, {
+            log$l(`Page ${pageCount}: Fetched ${pageTradesCount.toLocaleString()} option trades (total: ${totalTradesCount.toLocaleString()}) for ${symbolsStr}, date range: ${dateRangeStr}${hasMorePages ? ", more pages available" : ", complete"}`, {
                 type: "info",
             });
             // Prevent infinite loops
             if (pageCount > 1000) {
-                log$k(`Stopping options trades pagination after ${pageCount} pages to prevent infinite loop`, { type: "warn" });
+                log$l(`Stopping options trades pagination after ${pageCount} pages to prevent infinite loop`, { type: "warn" });
                 break;
             }
         }
@@ -13168,7 +13168,7 @@ class AlpacaMarketDataAPI extends require$$0$4.EventEmitter {
         const symbolCounts = Object.entries(allTrades)
             .map(([symbol, trades]) => `${symbol}: ${trades.length}`)
             .join(", ");
-        log$k(`Historical options trades fetch complete: ${totalTradesCount.toLocaleString()} total trades across ${pageCount} pages (${symbolCounts})`, {
+        log$l(`Historical options trades fetch complete: ${totalTradesCount.toLocaleString()} total trades across ${pageCount} pages (${symbolCounts})`, {
             type: "info",
         });
         return {
@@ -13328,14 +13328,14 @@ class AlpacaMarketDataAPI extends require$$0$4.EventEmitter {
                 ...(pageToken && { page_token: pageToken }),
             });
             const url = `${this.v1beta1url}/news?${queryParams}`;
-            log$k(`Fetching news from: ${url}`, { type: "debug", symbol });
+            log$l(`Fetching news from: ${url}`, { type: "debug", symbol });
             const response = await fetch(url, {
                 method: "GET",
                 headers: this.headers,
             });
             if (!response.ok) {
                 const errorText = await response.text();
-                log$k(`Alpaca news API error (${response.status}): ${errorText}`, {
+                log$l(`Alpaca news API error (${response.status}): ${errorText}`, {
                     type: "error",
                     symbol,
                 });
@@ -13343,7 +13343,7 @@ class AlpacaMarketDataAPI extends require$$0$4.EventEmitter {
             }
             const data = await response.json();
             if (!data.news || !Array.isArray(data.news)) {
-                log$k(`No news data found in Alpaca response for ${symbol}`, {
+                log$l(`No news data found in Alpaca response for ${symbol}`, {
                     type: "warn",
                     symbol,
                 });
@@ -13365,7 +13365,7 @@ class AlpacaMarketDataAPI extends require$$0$4.EventEmitter {
             fetchedCount = newsArticles.length;
             pageToken = data.next_page_token || null;
             hasMorePages = !!pageToken && (!maxLimit || fetchedCount < maxLimit);
-            log$k(`Fetched ${transformedNews.length} news articles (total: ${fetchedCount}) for ${symbol}. More pages: ${hasMorePages}`, { type: "debug", symbol });
+            log$l(`Fetched ${transformedNews.length} news articles (total: ${fetchedCount}) for ${symbol}. More pages: ${hasMorePages}`, { type: "debug", symbol });
             if (maxLimit && fetchedCount >= maxLimit) {
                 newsArticles = newsArticles.slice(0, maxLimit);
                 break;
@@ -13442,7 +13442,7 @@ class AlpacaTradingAPI {
         if (this.debugLogging && options.type === "debug") {
             return;
         }
-        log$l(message, {
+        log$m(message, {
             ...options,
             source: "AlpacaTradingAPI",
             account: this.credentials.accountName,
@@ -37026,19 +37026,19 @@ function requireCalendar () {
 	return calendar;
 }
 
-var clock;
+var clock$2;
 var hasRequiredClock;
 
 function requireClock () {
-	if (hasRequiredClock) return clock;
+	if (hasRequiredClock) return clock$2;
 	hasRequiredClock = 1;
 	function get() {
 	    return this.sendRequest("/clock");
 	}
-	clock = {
+	clock$2 = {
 	    get,
 	};
-	return clock;
+	return clock$2;
 }
 
 var asset;
@@ -53245,8 +53245,8 @@ var Alpaca = /*@__PURE__*/getDefaultExportFromCjs(distExports);
  * Alpaca SDK Client Factory
  * Provides unified access to Alpaca Trading API using official SDK
  */
-const log$j = (message, options = { type: "info" }) => {
-    log$l(message, { ...options, source: "AlpacaClient" });
+const log$k = (message, options = { type: "info" }) => {
+    log$m(message, { ...options, source: "AlpacaClient" });
 };
 /**
  * AlpacaClient wraps the official SDK with additional features:
@@ -53277,7 +53277,7 @@ class AlpacaClient {
             "APCA-API-SECRET-KEY": config.apiSecret,
             "Content-Type": "application/json",
         };
-        log$j(`AlpacaClient initialized (${config.accountType} mode)`, {
+        log$k(`AlpacaClient initialized (${config.accountType} mode)`, {
             type: "info",
         });
     }
@@ -53315,7 +53315,7 @@ class AlpacaClient {
         }
         catch (error) {
             this.isConnected = false;
-            log$j(`Credential validation failed: ${error.message}`, {
+            log$k(`Credential validation failed: ${error.message}`, {
                 type: "error",
             });
             throw error;
@@ -53375,7 +53375,7 @@ class AlpacaClient {
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : "Unknown error";
-            log$j(`API request to ${endpoint} failed: ${errorMessage}`, {
+            log$k(`API request to ${endpoint} failed: ${errorMessage}`, {
                 type: "error",
             });
             throw error;
@@ -53391,7 +53391,7 @@ const clientCache = new Map();
 function createAlpacaClient(config) {
     const cacheKey = `${config.apiKey}-${config.accountType}`;
     if (clientCache.has(cacheKey)) {
-        log$j(`Returning cached client for ${config.accountType}`, { type: "debug" });
+        log$k(`Returning cached client for ${config.accountType}`, { type: "debug" });
         return clientCache.get(cacheKey);
     }
     const client = new AlpacaClient(config);
@@ -53419,7 +53419,7 @@ function createClientFromEnv() {
  */
 function clearClientCache() {
     clientCache.clear();
-    log$j("Client cache cleared", { type: "info" });
+    log$k("Client cache cleared", { type: "info" });
 }
 
 // src/alpaca/trading/bracket-orders.ts
@@ -53429,8 +53429,8 @@ function clearClientCache() {
  * @param message - The message to log.
  * @param options - Optional logging options.
  */
-const log$i = (message, options = { type: "info" }) => {
-    log$l(message, { ...options, source: "BracketOrders" });
+const log$j = (message, options = { type: "info" }) => {
+    log$m(message, { ...options, source: "BracketOrders" });
 };
 /**
  * Validates bracket order parameters.
@@ -53459,13 +53459,13 @@ function validateBracketOrderParams(params) {
         // For a buy order, take profit should be higher than entry, stop loss lower
         params.limitPrice || params.takeProfit.limitPrice; // Use a reference price
         if (params.takeProfit.limitPrice <= params.stopLoss.stopPrice) {
-            log$i("Warning: Take profit price should typically be higher than stop loss price for buy orders", { type: "warn" });
+            log$j("Warning: Take profit price should typically be higher than stop loss price for buy orders", { type: "warn" });
         }
     }
     else {
         // For a sell order, take profit should be lower than entry, stop loss higher
         if (params.takeProfit.limitPrice >= params.stopLoss.stopPrice) {
-            log$i("Warning: Take profit price should typically be lower than stop loss price for sell orders", { type: "warn" });
+            log$j("Warning: Take profit price should typically be lower than stop loss price for sell orders", { type: "warn" });
         }
     }
 }
@@ -53512,12 +53512,12 @@ function roundPriceForAlpaca$4(price) {
  * ```
  */
 async function createBracketOrder(executor, params) {
-    log$i(`Creating bracket order: ${params.side} ${params.qty} ${params.symbol}`, {
+    log$j(`Creating bracket order: ${params.side} ${params.qty} ${params.symbol}`, {
         type: "info",
     });
-    log$i(`  Entry: ${params.type}${params.limitPrice ? ` @ $${params.limitPrice}` : ""}`, { type: "debug" });
-    log$i(`  Take Profit: $${params.takeProfit.limitPrice}`, { type: "debug" });
-    log$i(`  Stop Loss: $${params.stopLoss.stopPrice}${params.stopLoss.limitPrice ? ` (limit $${params.stopLoss.limitPrice})` : ""}`, { type: "debug" });
+    log$j(`  Entry: ${params.type}${params.limitPrice ? ` @ $${params.limitPrice}` : ""}`, { type: "debug" });
+    log$j(`  Take Profit: $${params.takeProfit.limitPrice}`, { type: "debug" });
+    log$j(`  Stop Loss: $${params.stopLoss.stopPrice}${params.stopLoss.limitPrice ? ` (limit $${params.stopLoss.limitPrice})` : ""}`, { type: "debug" });
     // Validate parameters
     validateBracketOrderParams(params);
     try {
@@ -53553,8 +53553,8 @@ async function createBracketOrder(executor, params) {
         }
         // Execute the order
         const order = await executor.createOrder(orderParams);
-        log$i(`Bracket order created successfully: ${order.id}`, { type: "info" });
-        log$i(`  Order status: ${order.status}`, { type: "debug" });
+        log$j(`Bracket order created successfully: ${order.id}`, { type: "info" });
+        log$j(`  Order status: ${order.status}`, { type: "debug" });
         // Parse the legs from the response
         const legs = order.legs || [];
         // Find take profit leg - it's a limit order at the take profit price
@@ -53563,10 +53563,10 @@ async function createBracketOrder(executor, params) {
         // Find stop loss leg - it's a stop or stop_limit order
         const stopLossLeg = legs.find((leg) => leg.type === "stop" || leg.type === "stop_limit") || null;
         if (takeProfitLeg) {
-            log$i(`  Take profit leg ID: ${takeProfitLeg.id}`, { type: "debug" });
+            log$j(`  Take profit leg ID: ${takeProfitLeg.id}`, { type: "debug" });
         }
         if (stopLossLeg) {
-            log$i(`  Stop loss leg ID: ${stopLossLeg.id}`, { type: "debug" });
+            log$j(`  Stop loss leg ID: ${stopLossLeg.id}`, { type: "debug" });
         }
         return {
             entryOrder: order,
@@ -53577,7 +53577,7 @@ async function createBracketOrder(executor, params) {
     }
     catch (error) {
         const err = error;
-        log$i(`Bracket order failed: ${err.message}`, { type: "error" });
+        log$j(`Bracket order failed: ${err.message}`, { type: "error" });
         throw new Error(`Failed to create bracket order for ${params.symbol}: ${err.message}`);
     }
 }
@@ -53609,9 +53609,9 @@ async function createBracketOrder(executor, params) {
  * ```
  */
 async function createProtectiveBracket(executor, params) {
-    log$i(`Creating protective bracket for ${params.symbol}: ${params.qty} shares`, { type: "info" });
-    log$i(`  Take Profit: $${params.takeProfit.limitPrice}`, { type: "debug" });
-    log$i(`  Stop Loss: $${params.stopLoss.stopPrice}${params.stopLoss.limitPrice ? ` (limit $${params.stopLoss.limitPrice})` : ""}`, { type: "debug" });
+    log$j(`Creating protective bracket for ${params.symbol}: ${params.qty} shares`, { type: "info" });
+    log$j(`  Take Profit: $${params.takeProfit.limitPrice}`, { type: "debug" });
+    log$j(`  Stop Loss: $${params.stopLoss.stopPrice}${params.stopLoss.limitPrice ? ` (limit $${params.stopLoss.limitPrice})` : ""}`, { type: "debug" });
     // Validate parameters
     if (!params.symbol || params.symbol.trim() === "") {
         throw new Error("Symbol is required for protective bracket");
@@ -53627,7 +53627,7 @@ async function createProtectiveBracket(executor, params) {
     }
     // For a protective sell bracket, take profit should be higher than stop loss
     if (params.takeProfit.limitPrice <= params.stopLoss.stopPrice) {
-        log$i("Warning: Take profit price should be higher than stop loss price for protective sell bracket", { type: "warn" });
+        log$j("Warning: Take profit price should be higher than stop loss price for protective sell bracket", { type: "warn" });
     }
     try {
         // Build the OCO order parameters
@@ -53648,7 +53648,7 @@ async function createProtectiveBracket(executor, params) {
         };
         // Execute the order
         const order = await executor.createOrder(orderParams);
-        log$i(`Protective bracket created successfully: ${order.id}`, {
+        log$j(`Protective bracket created successfully: ${order.id}`, {
             type: "info",
         });
         // Parse the legs from the response
@@ -53666,7 +53666,7 @@ async function createProtectiveBracket(executor, params) {
     }
     catch (error) {
         const err = error;
-        log$i(`Protective bracket failed: ${err.message}`, { type: "error" });
+        log$j(`Protective bracket failed: ${err.message}`, { type: "error" });
         throw new Error(`Failed to create protective bracket for ${params.symbol}: ${err.message}`);
     }
 }
@@ -53704,8 +53704,8 @@ var bracketOrders$1 = /*#__PURE__*/Object.freeze({
     default: bracketOrders
 });
 
-const log$h = (message, options = { type: "info" }) => {
-    log$l(message, { ...options, source: "Account" });
+const log$i = (message, options = { type: "info" }) => {
+    log$m(message, { ...options, source: "Account" });
 };
 /**
  * Get account details from Alpaca
@@ -53713,16 +53713,16 @@ const log$h = (message, options = { type: "info" }) => {
  * @returns Promise resolving to account details
  */
 async function getAccountDetails(client) {
-    log$h("Fetching account details");
+    log$i("Fetching account details");
     try {
         const sdk = client.getSDK();
         const account = await sdk.getAccount();
-        log$h(`Account details fetched successfully for account ${account.account_number}`);
+        log$i(`Account details fetched successfully for account ${account.account_number}`);
         return account;
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        log$h(`Failed to fetch account details: ${errorMessage}`, { type: "error" });
+        log$i(`Failed to fetch account details: ${errorMessage}`, { type: "error" });
         throw error;
     }
 }
@@ -53732,16 +53732,16 @@ async function getAccountDetails(client) {
  * @returns Promise resolving to account configuration
  */
 async function getAccountConfiguration(client) {
-    log$h("Fetching account configuration");
+    log$i("Fetching account configuration");
     try {
         const sdk = client.getSDK();
         const config = await sdk.getAccountConfigurations();
-        log$h("Account configuration fetched successfully");
+        log$i("Account configuration fetched successfully");
         return config;
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        log$h(`Failed to fetch account configuration: ${errorMessage}`, {
+        log$i(`Failed to fetch account configuration: ${errorMessage}`, {
             type: "error",
         });
         throw error;
@@ -53754,16 +53754,16 @@ async function getAccountConfiguration(client) {
  * @returns Promise resolving to updated account configuration
  */
 async function updateAccountConfiguration(client, config) {
-    log$h("Updating account configuration");
+    log$i("Updating account configuration");
     try {
         const sdk = client.getSDK();
         const updatedConfig = await sdk.updateAccountConfigurations(config);
-        log$h("Account configuration updated successfully");
+        log$i("Account configuration updated successfully");
         return updatedConfig;
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        log$h(`Failed to update account configuration: ${errorMessage}`, {
+        log$i(`Failed to update account configuration: ${errorMessage}`, {
             type: "error",
         });
         throw error;
@@ -53776,17 +53776,17 @@ async function updateAccountConfiguration(client, config) {
  * @returns Promise resolving to portfolio history response
  */
 async function getPortfolioHistory(client, params) {
-    log$h(`Fetching portfolio history with period: ${params.period || "default"}, timeframe: ${params.timeframe || "default"}`);
+    log$i(`Fetching portfolio history with period: ${params.period || "default"}, timeframe: ${params.timeframe || "default"}`);
     try {
         const sdk = client.getSDK();
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const history = await sdk.getPortfolioHistory(params);
-        log$h(`Portfolio history fetched successfully with ${history.equity?.length || 0} data points`);
+        log$i(`Portfolio history fetched successfully with ${history.equity?.length || 0} data points`);
         return history;
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        log$h(`Failed to fetch portfolio history: ${errorMessage}`, {
+        log$i(`Failed to fetch portfolio history: ${errorMessage}`, {
             type: "error",
         });
         throw error;
@@ -53798,7 +53798,7 @@ async function getPortfolioHistory(client, params) {
  * @returns Promise resolving to trading eligibility status
  */
 async function checkTradingEligibility(client) {
-    log$h("Checking trading eligibility");
+    log$i("Checking trading eligibility");
     try {
         const account = await getAccountDetails(client);
         const reasons = [];
@@ -53837,12 +53837,12 @@ async function checkTradingEligibility(client) {
             dayTradeCount: account.daytrade_count,
             isPatternDayTrader: account.pattern_day_trader,
         };
-        log$h(`Trading eligibility check complete: canTrade=${canTrade}${reasons.length > 0 ? `, reasons: ${reasons.join("; ")}` : ""}`);
+        log$i(`Trading eligibility check complete: canTrade=${canTrade}${reasons.length > 0 ? `, reasons: ${reasons.join("; ")}` : ""}`);
         return eligibility;
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        log$h(`Failed to check trading eligibility: ${errorMessage}`, {
+        log$i(`Failed to check trading eligibility: ${errorMessage}`, {
             type: "error",
         });
         throw error;
@@ -53854,7 +53854,7 @@ async function checkTradingEligibility(client) {
  * @returns Promise resolving to buying power breakdown
  */
 async function getBuyingPower(client) {
-    log$h("Fetching buying power breakdown");
+    log$i("Fetching buying power breakdown");
     try {
         const account = await getAccountDetails(client);
         const breakdown = {
@@ -53866,12 +53866,12 @@ async function getBuyingPower(client) {
             // Crypto buying power is typically equal to cash for spot trading
             cryptoBuyingPower: parseFloat(account.cash),
         };
-        log$h(`Buying power breakdown: cash=$${breakdown.cash.toFixed(2)}, dayTrading=$${breakdown.dayTradingBuyingPower.toFixed(2)}, regT=$${breakdown.regtBuyingPower.toFixed(2)}`);
+        log$i(`Buying power breakdown: cash=$${breakdown.cash.toFixed(2)}, dayTrading=$${breakdown.dayTradingBuyingPower.toFixed(2)}, regT=$${breakdown.regtBuyingPower.toFixed(2)}`);
         return breakdown;
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        log$h(`Failed to fetch buying power: ${errorMessage}`, { type: "error" });
+        log$i(`Failed to fetch buying power: ${errorMessage}`, { type: "error" });
         throw error;
     }
 }
@@ -53881,16 +53881,16 @@ async function getBuyingPower(client) {
  * @returns Promise resolving to options trading level (0-3)
  */
 async function getOptionsTradingLevel(client) {
-    log$h("Fetching options trading level");
+    log$i("Fetching options trading level");
     try {
         const account = await getAccountDetails(client);
         const level = account.options_trading_level || 0;
-        log$h(`Options trading level: ${level}`);
+        log$i(`Options trading level: ${level}`);
         return level;
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        log$h(`Failed to fetch options trading level: ${errorMessage}`, {
+        log$i(`Failed to fetch options trading level: ${errorMessage}`, {
             type: "error",
         });
         throw error;
@@ -53902,7 +53902,7 @@ async function getOptionsTradingLevel(client) {
  * @returns Promise resolving to PDT status
  */
 async function getPDTStatus(client) {
-    log$h("Fetching PDT status");
+    log$i("Fetching PDT status");
     try {
         const account = await getAccountDetails(client);
         const equity = parseFloat(account.equity);
@@ -53935,12 +53935,12 @@ async function getPDTStatus(client) {
             dayTradesRemaining: dayTradesRemaining === Infinity ? -1 : dayTradesRemaining, // Use -1 for unlimited
             canDayTrade,
         };
-        log$h(`PDT status: isPDT=${isPDT}, dayTradeCount=${dayTradeCount}, remaining=${dayTradesRemaining === Infinity ? "unlimited" : dayTradesRemaining}`);
+        log$i(`PDT status: isPDT=${isPDT}, dayTradeCount=${dayTradeCount}, remaining=${dayTradesRemaining === Infinity ? "unlimited" : dayTradesRemaining}`);
         return status;
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        log$h(`Failed to fetch PDT status: ${errorMessage}`, { type: "error" });
+        log$i(`Failed to fetch PDT status: ${errorMessage}`, { type: "error" });
         throw error;
     }
 }
@@ -53952,7 +53952,7 @@ async function getPDTStatus(client) {
  * @returns Promise resolving to array of daily returns
  */
 async function getDailyReturns(client, period = "1M") {
-    log$h(`Calculating daily returns for period: ${period}`);
+    log$i(`Calculating daily returns for period: ${period}`);
     try {
         const history = await getPortfolioHistory(client, {
             period,
@@ -53961,7 +53961,7 @@ async function getDailyReturns(client, period = "1M") {
         if (!history.timestamp ||
             !history.equity ||
             history.timestamp.length === 0) {
-            log$h("No portfolio history data available", { type: "warn" });
+            log$i("No portfolio history data available", { type: "warn" });
             return [];
         }
         const dailyReturns = [];
@@ -53984,12 +53984,12 @@ async function getDailyReturns(client, period = "1M") {
                 dailyReturn,
             });
         }
-        log$h(`Calculated ${dailyReturns.length} daily returns`);
+        log$i(`Calculated ${dailyReturns.length} daily returns`);
         return dailyReturns;
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        log$h(`Failed to calculate daily returns: ${errorMessage}`, {
+        log$i(`Failed to calculate daily returns: ${errorMessage}`, {
             type: "error",
         });
         throw error;
@@ -54002,7 +54002,7 @@ async function getDailyReturns(client, period = "1M") {
  * @returns Promise resolving to period performance metrics
  */
 async function calculatePeriodPerformance(client, period = "1M") {
-    log$h(`Calculating period performance for: ${period}`);
+    log$i(`Calculating period performance for: ${period}`);
     try {
         const dailyReturns = await getDailyReturns(client, period);
         if (dailyReturns.length < 2) {
@@ -54068,12 +54068,12 @@ async function calculatePeriodPerformance(client, period = "1M") {
             losingDays,
             winRate,
         };
-        log$h(`Period performance: totalReturn=${totalReturnPct.toFixed(2)}%, maxDrawdown=${maxDrawdownPct.toFixed(2)}%, sharpe=${sharpeRatio?.toFixed(2) || "N/A"}`);
+        log$i(`Period performance: totalReturn=${totalReturnPct.toFixed(2)}%, maxDrawdown=${maxDrawdownPct.toFixed(2)}%, sharpe=${sharpeRatio?.toFixed(2) || "N/A"}`);
         return performance;
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        log$h(`Failed to calculate period performance: ${errorMessage}`, {
+        log$i(`Failed to calculate period performance: ${errorMessage}`, {
             type: "error",
         });
         throw error;
@@ -54086,13 +54086,13 @@ async function calculatePeriodPerformance(client, period = "1M") {
  * @returns Promise resolving to equity curve data points
  */
 async function getEquityCurve(client, params = { period: "1M", timeframe: "1D" }) {
-    log$h(`Fetching equity curve with period: ${params.period || "default"}`);
+    log$i(`Fetching equity curve with period: ${params.period || "default"}`);
     try {
         const history = await getPortfolioHistory(client, params);
         if (!history.timestamp ||
             !history.equity ||
             history.timestamp.length === 0) {
-            log$h("No portfolio history data available for equity curve", {
+            log$i("No portfolio history data available for equity curve", {
                 type: "warn",
             });
             return [];
@@ -54114,12 +54114,12 @@ async function getEquityCurve(client, params = { period: "1M", timeframe: "1D" }
                 cumulativeReturn,
             });
         }
-        log$h(`Generated equity curve with ${curve.length} data points`);
+        log$i(`Generated equity curve with ${curve.length} data points`);
         return curve;
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        log$h(`Failed to get equity curve: ${errorMessage}`, { type: "error" });
+        log$i(`Failed to get equity curve: ${errorMessage}`, { type: "error" });
         throw error;
     }
 }
@@ -54129,7 +54129,7 @@ async function getEquityCurve(client, params = { period: "1M", timeframe: "1D" }
  * @returns Promise resolving to account summary
  */
 async function getAccountSummary(client) {
-    log$h("Fetching account summary");
+    log$i("Fetching account summary");
     try {
         const account = await getAccountDetails(client);
         const equity = parseFloat(account.equity);
@@ -54146,12 +54146,12 @@ async function getAccountSummary(client) {
             todayProfitLoss,
             todayProfitLossPct,
         };
-        log$h(`Account summary: equity=$${summary.equity.toFixed(2)}, cash=$${summary.cash.toFixed(2)}, todayP/L=${summary.todayProfitLossPct.toFixed(2)}%`);
+        log$i(`Account summary: equity=$${summary.equity.toFixed(2)}, cash=$${summary.cash.toFixed(2)}, todayP/L=${summary.todayProfitLossPct.toFixed(2)}%`);
         return summary;
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        log$h(`Failed to get account summary: ${errorMessage}`, { type: "error" });
+        log$i(`Failed to get account summary: ${errorMessage}`, { type: "error" });
         throw error;
     }
 }
@@ -54161,17 +54161,17 @@ async function getAccountSummary(client) {
  * @returns Promise resolving to boolean indicating margin status
  */
 async function isMarginAccount(client) {
-    log$h("Checking margin account status");
+    log$i("Checking margin account status");
     try {
         const account = await getAccountDetails(client);
         // Multiplier > 1 indicates margin account
         const isMargin = account.multiplier !== "1";
-        log$h(`Margin account: ${isMargin} (multiplier: ${account.multiplier})`);
+        log$i(`Margin account: ${isMargin} (multiplier: ${account.multiplier})`);
         return isMargin;
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        log$h(`Failed to check margin account status: ${errorMessage}`, {
+        log$i(`Failed to check margin account status: ${errorMessage}`, {
             type: "error",
         });
         throw error;
@@ -54183,7 +54183,7 @@ async function isMarginAccount(client) {
  * @returns Promise resolving to margin information
  */
 async function getMarginInfo(client) {
-    log$h("Fetching margin information");
+    log$i("Fetching margin information");
     try {
         const account = await getAccountDetails(client);
         const initialMargin = parseFloat(account.initial_margin);
@@ -54199,12 +54199,12 @@ async function getMarginInfo(client) {
             sma: parseFloat(account.sma),
             marginCallAmount,
         };
-        log$h(`Margin info: multiplier=${marginInfo.multiplier}, initialMargin=$${marginInfo.initialMargin.toFixed(2)}, maintenanceMargin=$${marginInfo.maintenanceMargin.toFixed(2)}`);
+        log$i(`Margin info: multiplier=${marginInfo.multiplier}, initialMargin=$${marginInfo.initialMargin.toFixed(2)}, maintenanceMargin=$${marginInfo.maintenanceMargin.toFixed(2)}`);
         return marginInfo;
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        log$h(`Failed to get margin information: ${errorMessage}`, { type: "error" });
+        log$i(`Failed to get margin information: ${errorMessage}`, { type: "error" });
         throw error;
     }
 }
@@ -54252,8 +54252,8 @@ var account$1 = /*#__PURE__*/Object.freeze({
  *
  * @module order-utils
  */
-const log$g = (message, options = { type: "info" }) => {
-    log$l(message, { ...options, source: "OrderUtils" });
+const log$h = (message, options = { type: "info" }) => {
+    log$m(message, { ...options, source: "OrderUtils" });
 };
 /**
  * Default delay between pagination requests to avoid rate limits (in milliseconds)
@@ -54347,7 +54347,7 @@ function buildOrderQueryParams(params) {
 async function getOrdersBySymbol(client, symbol, params = {}) {
     const sdk = client.getSDK();
     try {
-        log$g(`Fetching orders for symbol: ${symbol}`, {
+        log$h(`Fetching orders for symbol: ${symbol}`, {
             type: "debug",
             metadata: { symbol, ...params },
         });
@@ -54370,14 +54370,14 @@ async function getOrdersBySymbol(client, symbol, params = {}) {
         if (params.side)
             queryParams.side = params.side;
         const orders = await sdk.getOrders(queryParams);
-        log$g(`Found ${orders.length} orders for ${symbol}`, {
+        log$h(`Found ${orders.length} orders for ${symbol}`, {
             type: "debug",
             metadata: { symbol, count: orders.length },
         });
         return orders;
     }
     catch (error) {
-        log$g(`Error fetching orders for symbol ${symbol}: ${error.message}`, {
+        log$h(`Error fetching orders for symbol ${symbol}: ${error.message}`, {
             type: "error",
             metadata: { symbol, error: error.message },
         });
@@ -54400,7 +54400,7 @@ async function getOrdersBySymbol(client, symbol, params = {}) {
 async function getOpenOrders$1(client, params = {}) {
     const sdk = client.getSDK();
     try {
-        log$g("Fetching open orders", { type: "debug" });
+        log$h("Fetching open orders", { type: "debug" });
         // Build query parameters as Record<string, unknown> to match SDK expectations
         const queryParams = {
             status: "open",
@@ -54421,14 +54421,14 @@ async function getOpenOrders$1(client, params = {}) {
         if (params.side)
             queryParams.side = params.side;
         const orders = await sdk.getOrders(queryParams);
-        log$g(`Found ${orders.length} open orders`, {
+        log$h(`Found ${orders.length} open orders`, {
             type: "debug",
             metadata: { count: orders.length },
         });
         return orders;
     }
     catch (error) {
-        log$g(`Error fetching open orders: ${error.message}`, {
+        log$h(`Error fetching open orders: ${error.message}`, {
             type: "error",
             metadata: { error: error.message },
         });
@@ -54454,7 +54454,7 @@ async function getFilledOrders(client, params) {
     client.getSDK();
     const { startDate, endDate, symbols, side } = params;
     try {
-        log$g(`Fetching filled orders from ${startDate.toISOString()} to ${endDate.toISOString()}`, {
+        log$h(`Fetching filled orders from ${startDate.toISOString()} to ${endDate.toISOString()}`, {
             type: "debug",
             metadata: {
                 startDate: startDate.toISOString(),
@@ -54479,14 +54479,14 @@ async function getFilledOrders(client, params) {
         });
         // Filter to only filled orders
         const filledOrders = allOrders.filter((order) => FILLED_ORDER_STATUSES.includes(order.status));
-        log$g(`Found ${filledOrders.length} filled orders in date range`, {
+        log$h(`Found ${filledOrders.length} filled orders in date range`, {
             type: "debug",
             metadata: { count: filledOrders.length },
         });
         return filledOrders;
     }
     catch (error) {
-        log$g(`Error fetching filled orders: ${error.message}`, {
+        log$h(`Error fetching filled orders: ${error.message}`, {
             type: "error",
             metadata: { error: error.message },
         });
@@ -54523,7 +54523,7 @@ async function getOrderHistory(client, params = {}) {
     const effectivePageSize = Math.min(pageSize, MAX_ORDERS_PER_REQUEST);
     const sdk = client.getSDK();
     try {
-        log$g(`Fetching order history page ${page} (size: ${effectivePageSize})`, {
+        log$h(`Fetching order history page ${page} (size: ${effectivePageSize})`, {
             type: "debug",
             metadata: { page, pageSize: effectivePageSize },
         });
@@ -54596,7 +54596,7 @@ async function getOrderHistory(client, params = {}) {
         };
     }
     catch (error) {
-        log$g(`Error fetching order history: ${error.message}`, {
+        log$h(`Error fetching order history: ${error.message}`, {
             type: "error",
             metadata: { error: error.message },
         });
@@ -54636,7 +54636,7 @@ async function getAllOrders(client, params = {}) {
             const orders = await sdk.getOrders(sdkParams);
             return orders;
         }
-        log$g("Fetching all orders with pagination", {
+        log$h("Fetching all orders with pagination", {
             type: "debug",
             metadata: { params: queryParams },
         });
@@ -54655,7 +54655,7 @@ async function getAllOrders(client, params = {}) {
             const sdkParams = buildOrderQueryParams(batchParams);
             const batch = (await sdk.getOrders(sdkParams));
             pageCount++;
-            log$g(`Fetched page ${pageCount}: ${batch.length} orders`, {
+            log$h(`Fetched page ${pageCount}: ${batch.length} orders`, {
                 type: "debug",
                 metadata: { pageCount, batchSize: batch.length },
             });
@@ -54680,14 +54680,14 @@ async function getAllOrders(client, params = {}) {
                 }
             }
         }
-        log$g(`Fetched total of ${allOrders.length} orders across ${pageCount} pages`, {
+        log$h(`Fetched total of ${allOrders.length} orders across ${pageCount} pages`, {
             type: "info",
             metadata: { totalOrders: allOrders.length, pageCount },
         });
         return allOrders;
     }
     catch (error) {
-        log$g(`Error fetching all orders: ${error.message}`, {
+        log$h(`Error fetching all orders: ${error.message}`, {
             type: "error",
             metadata: { error: error.message },
         });
@@ -54722,7 +54722,7 @@ async function waitForOrderFill(client, params) {
     const { orderId, timeoutMs = 60000, pollIntervalMs = 1000 } = params;
     const sdk = client.getSDK();
     const startTime = Date.now();
-    log$g(`Waiting for order ${orderId} to fill (timeout: ${timeoutMs}ms)`, {
+    log$h(`Waiting for order ${orderId} to fill (timeout: ${timeoutMs}ms)`, {
         type: "debug",
         metadata: { orderId, timeoutMs, pollIntervalMs },
     });
@@ -54732,7 +54732,7 @@ async function waitForOrderFill(client, params) {
             if (elapsed >= timeoutMs) {
                 // Fetch final state before returning
                 const order = (await sdk.getOrder(orderId));
-                log$g(`Order ${orderId} timed out after ${elapsed}ms, status: ${order.status}`, {
+                log$h(`Order ${orderId} timed out after ${elapsed}ms, status: ${order.status}`, {
                     type: "warn",
                     metadata: { orderId, elapsed, status: order.status },
                 });
@@ -54745,7 +54745,7 @@ async function waitForOrderFill(client, params) {
             const order = (await sdk.getOrder(orderId));
             // Check if filled
             if (FILLED_ORDER_STATUSES.includes(order.status)) {
-                log$g(`Order ${orderId} filled after ${elapsed}ms`, {
+                log$h(`Order ${orderId} filled after ${elapsed}ms`, {
                     type: "info",
                     metadata: { orderId, elapsed, status: order.status },
                 });
@@ -54757,7 +54757,7 @@ async function waitForOrderFill(client, params) {
             }
             // Check if terminal but not filled
             if (TERMINAL_ORDER_STATUSES.includes(order.status)) {
-                log$g(`Order ${orderId} reached terminal state ${order.status} after ${elapsed}ms`, {
+                log$h(`Order ${orderId} reached terminal state ${order.status} after ${elapsed}ms`, {
                     type: "info",
                     metadata: { orderId, elapsed, status: order.status },
                 });
@@ -54772,7 +54772,7 @@ async function waitForOrderFill(client, params) {
         }
     }
     catch (error) {
-        log$g(`Error waiting for order fill: ${error.message}`, {
+        log$h(`Error waiting for order fill: ${error.message}`, {
             type: "error",
             metadata: { orderId, error: error.message },
         });
@@ -55130,8 +55130,8 @@ const LOG_SOURCE$7 = "TrailingStops";
 /**
  * Internal logging helper with consistent source
  */
-const log$f = (message, options = { type: "info" }) => {
-    log$l(message, { ...options, source: LOG_SOURCE$7 });
+const log$g = (message, options = { type: "info" }) => {
+    log$m(message, { ...options, source: LOG_SOURCE$7 });
 };
 /**
  * Validation error for trailing stop parameters
@@ -55219,7 +55219,7 @@ async function createTrailingStop(client, params) {
     const trailDescription = params.trailPercent
         ? `${params.trailPercent}%`
         : `$${params.trailPrice?.toFixed(2)}`;
-    log$f(`Creating trailing stop: ${params.side} ${params.qty} ${params.symbol} (trail: ${trailDescription})`, {
+    log$g(`Creating trailing stop: ${params.side} ${params.qty} ${params.symbol} (trail: ${trailDescription})`, {
         type: "info",
     });
     try {
@@ -55243,12 +55243,12 @@ async function createTrailingStop(client, params) {
             orderParams.client_order_id = params.clientOrderId;
         }
         const order = await sdk.createOrder(orderParams);
-        log$f(`Trailing stop created: orderId=${order.id}, HWM=${order.hwm || "pending"}, status=${order.status}`, { type: "info" });
+        log$g(`Trailing stop created: orderId=${order.id}, HWM=${order.hwm || "pending"}, status=${order.status}`, { type: "info" });
         return order;
     }
     catch (error) {
         const err = error;
-        log$f(`Trailing stop creation failed for ${params.symbol}: ${err.message}`, {
+        log$g(`Trailing stop creation failed for ${params.symbol}: ${err.message}`, {
             type: "error",
         });
         throw new Error(`Failed to create trailing stop for ${params.symbol}: ${err.message}`);
@@ -55294,7 +55294,7 @@ async function updateTrailingStop(client, orderId, updates) {
     const updateDescription = updates.trailPercent
         ? `${updates.trailPercent}%`
         : `$${updates.trailPrice?.toFixed(2)}`;
-    log$f(`Updating trailing stop ${orderId} to trail: ${updateDescription}`, {
+    log$g(`Updating trailing stop ${orderId} to trail: ${updateDescription}`, {
         type: "info",
     });
     try {
@@ -55307,14 +55307,14 @@ async function updateTrailingStop(client, orderId, updates) {
             replaceParams.trail = updates.trailPrice.toString();
         }
         const order = await sdk.replaceOrder(orderId, replaceParams);
-        log$f(`Trailing stop updated: orderId=${order.id}, new replacement created`, {
+        log$g(`Trailing stop updated: orderId=${order.id}, new replacement created`, {
             type: "info",
         });
         return order;
     }
     catch (error) {
         const err = error;
-        log$f(`Trailing stop update failed for ${orderId}: ${err.message}`, {
+        log$g(`Trailing stop update failed for ${orderId}: ${err.message}`, {
             type: "error",
         });
         throw new Error(`Failed to update trailing stop ${orderId}: ${err.message}`);
@@ -55344,18 +55344,18 @@ async function getTrailingStopHWM(client, orderId) {
         const order = await sdk.getOrder(orderId);
         // Validate this is actually a trailing stop order
         if (order.type !== "trailing_stop") {
-            log$f(`Order ${orderId} is not a trailing stop order (type: ${order.type})`, { type: "warn" });
+            log$g(`Order ${orderId} is not a trailing stop order (type: ${order.type})`, { type: "warn" });
         }
         const result = {
             hwm: order.hwm ? parseFloat(order.hwm) : null,
             currentStop: order.stop_price ? parseFloat(order.stop_price) : null,
         };
-        log$f(`Retrieved HWM for ${orderId}: HWM=${result.hwm ?? "N/A"}, currentStop=${result.currentStop ?? "N/A"}`, { type: "debug" });
+        log$g(`Retrieved HWM for ${orderId}: HWM=${result.hwm ?? "N/A"}, currentStop=${result.currentStop ?? "N/A"}`, { type: "debug" });
         return result;
     }
     catch (error) {
         const err = error;
-        log$f(`Failed to get trailing stop HWM for ${orderId}: ${err.message}`, {
+        log$g(`Failed to get trailing stop HWM for ${orderId}: ${err.message}`, {
             type: "error",
         });
         throw new Error(`Failed to get trailing stop HWM for ${orderId}: ${err.message}`);
@@ -55375,21 +55375,21 @@ async function getTrailingStopHWM(client, orderId) {
  */
 async function cancelTrailingStop(client, orderId) {
     const sdk = client.getSDK();
-    log$f(`Canceling trailing stop order: ${orderId}`, { type: "info" });
+    log$g(`Canceling trailing stop order: ${orderId}`, { type: "info" });
     try {
         await sdk.cancelOrder(orderId);
-        log$f(`Trailing stop order canceled: ${orderId}`, { type: "info" });
+        log$g(`Trailing stop order canceled: ${orderId}`, { type: "info" });
     }
     catch (error) {
         const err = error;
         // Check if the order was already filled or canceled
         if (err.message.includes("order is not cancelable")) {
-            log$f(`Trailing stop ${orderId} is not cancelable (may already be filled or canceled)`, {
+            log$g(`Trailing stop ${orderId} is not cancelable (may already be filled or canceled)`, {
                 type: "warn",
             });
             throw new Error(`Trailing stop ${orderId} is not cancelable: order may already be filled or canceled`);
         }
-        log$f(`Failed to cancel trailing stop ${orderId}: ${err.message}`, {
+        log$g(`Failed to cancel trailing stop ${orderId}: ${err.message}`, {
             type: "error",
         });
         throw new Error(`Failed to cancel trailing stop ${orderId}: ${err.message}`);
@@ -55430,28 +55430,28 @@ async function createPortfolioTrailingStops(client, params) {
     const sdk = client.getSDK();
     const results = new Map();
     const excludeSet = new Set(params.excludeSymbols?.map((s) => s.toUpperCase()) || []);
-    log$f(`Creating portfolio trailing stops at ${params.trailPercent}%`, {
+    log$g(`Creating portfolio trailing stops at ${params.trailPercent}%`, {
         type: "info",
     });
     try {
         const positions = await sdk.getPositions();
         if (positions.length === 0) {
-            log$f("No positions found in portfolio", { type: "info" });
+            log$g("No positions found in portfolio", { type: "info" });
             return results;
         }
-        log$f(`Found ${positions.length} positions, checking for eligible trailing stops`, { type: "debug" });
+        log$g(`Found ${positions.length} positions, checking for eligible trailing stops`, { type: "debug" });
         const errors = [];
         for (const position of positions) {
             const symbol = position.symbol.toUpperCase();
             // Skip excluded symbols
             if (excludeSet.has(symbol)) {
-                log$f(`Skipping ${symbol} (excluded)`, { type: "debug" });
+                log$g(`Skipping ${symbol} (excluded)`, { type: "debug" });
                 continue;
             }
             // Only create trailing stops for long positions
             const qty = parseFloat(position.qty);
             if (qty <= 0) {
-                log$f(`Skipping ${symbol} (not a long position, qty: ${qty})`, {
+                log$g(`Skipping ${symbol} (not a long position, qty: ${qty})`, {
                     type: "debug",
                 });
                 continue;
@@ -55469,7 +55469,7 @@ async function createPortfolioTrailingStops(client, params) {
             catch (err) {
                 const errorMessage = err.message;
                 errors.push({ symbol, error: errorMessage });
-                log$f(`Failed to create trailing stop for ${symbol}: ${errorMessage}`, {
+                log$g(`Failed to create trailing stop for ${symbol}: ${errorMessage}`, {
                     type: "error",
                 });
             }
@@ -55478,9 +55478,9 @@ async function createPortfolioTrailingStops(client, params) {
         const successCount = results.size;
         const failureCount = errors.length;
         const skippedCount = positions.length - successCount - failureCount;
-        log$f(`Portfolio trailing stops complete: ${successCount} created, ${failureCount} failed, ${skippedCount} skipped`, { type: "info" });
+        log$g(`Portfolio trailing stops complete: ${successCount} created, ${failureCount} failed, ${skippedCount} skipped`, { type: "info" });
         if (errors.length > 0) {
-            log$f(`Failed symbols: ${errors.map((e) => `${e.symbol} (${e.error})`).join(", ")}`, {
+            log$g(`Failed symbols: ${errors.map((e) => `${e.symbol} (${e.error})`).join(", ")}`, {
                 type: "warn",
             });
         }
@@ -55488,7 +55488,7 @@ async function createPortfolioTrailingStops(client, params) {
     }
     catch (error) {
         const err = error;
-        log$f(`Failed to create portfolio trailing stops: ${err.message}`, {
+        log$g(`Failed to create portfolio trailing stops: ${err.message}`, {
             type: "error",
         });
         throw new Error(`Failed to create portfolio trailing stops: ${err.message}`);
@@ -55523,14 +55523,14 @@ async function getOpenTrailingStops(client, symbol) {
         const orders = (await sdk.getOrders(queryParams));
         // Filter to only trailing stop orders
         const trailingStops = orders.filter((order) => order.type === "trailing_stop");
-        log$f(`Found ${trailingStops.length} open trailing stop orders${symbol ? ` for ${symbol}` : ""}`, {
+        log$g(`Found ${trailingStops.length} open trailing stop orders${symbol ? ` for ${symbol}` : ""}`, {
             type: "debug",
         });
         return trailingStops;
     }
     catch (error) {
         const err = error;
-        log$f(`Failed to get open trailing stops: ${err.message}`, { type: "error" });
+        log$g(`Failed to get open trailing stops: ${err.message}`, { type: "error" });
         throw new Error(`Failed to get open trailing stops: ${err.message}`);
     }
 }
@@ -55568,7 +55568,7 @@ async function hasActiveTrailingStop(client, symbol) {
 async function cancelTrailingStopsForSymbol(client, symbol) {
     const trailingStops = await getOpenTrailingStops(client, symbol);
     if (trailingStops.length === 0) {
-        log$f(`No trailing stops to cancel for ${symbol}`, { type: "debug" });
+        log$g(`No trailing stops to cancel for ${symbol}`, { type: "debug" });
         return 0;
     }
     let canceledCount = 0;
@@ -55583,9 +55583,9 @@ async function cancelTrailingStopsForSymbol(client, symbol) {
         }
     }
     if (errors.length > 0) {
-        log$f(`Some trailing stops failed to cancel for ${symbol}: ${errors.join(", ")}`, { type: "warn" });
+        log$g(`Some trailing stops failed to cancel for ${symbol}: ${errors.join(", ")}`, { type: "warn" });
     }
-    log$f(`Canceled ${canceledCount}/${trailingStops.length} trailing stops for ${symbol}`, { type: "info" });
+    log$g(`Canceled ${canceledCount}/${trailingStops.length} trailing stops for ${symbol}`, { type: "info" });
     return canceledCount;
 }
 /**
@@ -55628,8 +55628,8 @@ var trailingStops$1 = /*#__PURE__*/Object.freeze({
  *
  * @module oco-orders
  */
-const log$e = (message, options = { type: "info" }) => {
-    log$l(message, { ...options, source: "OCOOrders" });
+const log$f = (message, options = { type: "info" }) => {
+    log$m(message, { ...options, source: "OCOOrders" });
 };
 /**
  * Round a price to the nearest 2 decimal places for Alpaca,
@@ -55738,7 +55738,7 @@ async function createOCOOrder(client, params) {
     // Validate parameters
     validateOCOParams(params);
     const { symbol, qty, side, takeProfit, stopLoss, timeInForce = "gtc", } = params;
-    log$e(`Creating OCO order for ${symbol}: ${side} ${qty} shares | ` +
+    log$f(`Creating OCO order for ${symbol}: ${side} ${qty} shares | ` +
         `Take profit at $${takeProfit.limitPrice.toFixed(2)} | ` +
         `Stop loss at $${stopLoss.stopPrice.toFixed(2)}` +
         (stopLoss.limitPrice
@@ -55763,7 +55763,7 @@ async function createOCOOrder(client, params) {
         if (stopLoss.limitPrice !== undefined) {
             orderRequest.stop_loss.limit_price = roundPriceForAlpaca$2(stopLoss.limitPrice).toString();
         }
-        log$e(`Submitting OCO order request: ${JSON.stringify(orderRequest)}`, {
+        log$f(`Submitting OCO order request: ${JSON.stringify(orderRequest)}`, {
             symbol,
             type: "debug",
         });
@@ -55772,7 +55772,7 @@ async function createOCOOrder(client, params) {
         // Extract leg orders from the response
         const legs = order.legs || [];
         if (legs.length < 2) {
-            log$e(`OCO order created but legs not found in response. Order ID: ${order.id}`, { symbol, type: "warn" });
+            log$f(`OCO order created but legs not found in response. Order ID: ${order.id}`, { symbol, type: "warn" });
         }
         // Identify take profit and stop loss orders from legs
         // Take profit is the limit order, stop loss is the stop/stop_limit order
@@ -55780,7 +55780,7 @@ async function createOCOOrder(client, params) {
         const stopLossOrder = legs.find((leg) => leg.type === "stop" || leg.type === "stop_limit") ||
             legs.find((leg) => leg !== takeProfitOrder) ||
             order;
-        log$e(`OCO order created successfully | Parent ID: ${order.id} | ` +
+        log$f(`OCO order created successfully | Parent ID: ${order.id} | ` +
             `Take profit ID: ${takeProfitOrder.id} | Stop loss ID: ${stopLossOrder.id}`, { symbol, type: "info" });
         return {
             takeProfitOrder,
@@ -55791,7 +55791,7 @@ async function createOCOOrder(client, params) {
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        log$e(`Failed to create OCO order for ${symbol}: ${errorMessage}`, {
+        log$f(`Failed to create OCO order for ${symbol}: ${errorMessage}`, {
             symbol,
             type: "error",
         });
@@ -55811,17 +55811,17 @@ async function createOCOOrder(client, params) {
  * await cancelOCOOrder(client, result.parentOrderId);
  */
 async function cancelOCOOrder(client, parentOrderId) {
-    log$e(`Canceling OCO order group: ${parentOrderId}`, { type: "info" });
+    log$f(`Canceling OCO order group: ${parentOrderId}`, { type: "info" });
     const sdk = client.getSDK();
     try {
         await sdk.cancelOrder(parentOrderId);
-        log$e(`OCO order group canceled successfully: ${parentOrderId}`, {
+        log$f(`OCO order group canceled successfully: ${parentOrderId}`, {
             type: "info",
         });
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        log$e(`Failed to cancel OCO order ${parentOrderId}: ${errorMessage}`, {
+        log$f(`Failed to cancel OCO order ${parentOrderId}: ${errorMessage}`, {
             type: "error",
         });
         throw error;
@@ -55843,17 +55843,17 @@ async function cancelOCOOrder(client, parentOrderId) {
  * });
  */
 async function getOCOOrderStatus(client, parentOrderId) {
-    log$e(`Getting OCO order status: ${parentOrderId}`, { type: "debug" });
+    log$f(`Getting OCO order status: ${parentOrderId}`, { type: "debug" });
     const sdk = client.getSDK();
     try {
         const order = (await sdk.getOrder(parentOrderId));
-        log$e(`OCO order ${parentOrderId} status: ${order.status} | ` +
+        log$f(`OCO order ${parentOrderId} status: ${order.status} | ` +
             `Legs: ${order.legs?.length || 0}`, { type: "debug" });
         return order;
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        log$e(`Failed to get OCO order status ${parentOrderId}: ${errorMessage}`, {
+        log$f(`Failed to get OCO order status ${parentOrderId}: ${errorMessage}`, {
             type: "error",
         });
         throw error;
@@ -55959,8 +55959,8 @@ var ocoOrders$1 = /*#__PURE__*/Object.freeze({
  *
  * @module oto-orders
  */
-const log$d = (message, options = { type: "info" }) => {
-    log$l(message, { ...options, source: "OTOOrders" });
+const log$e = (message, options = { type: "info" }) => {
+    log$m(message, { ...options, source: "OTOOrders" });
 };
 /**
  * Round a price to the nearest 2 decimal places for Alpaca,
@@ -56030,7 +56030,7 @@ function validateOTOParams(params) {
     // Validate logical order of sides for typical use cases
     // Primary buy should typically trigger sell (exit), and vice versa
     if (params.side === dependent.side) {
-        log$d(`Warning: Primary and dependent orders have the same side (${params.side}). ` +
+        log$e(`Warning: Primary and dependent orders have the same side (${params.side}). ` +
             "This is unusual - typically entry and exit are opposite sides.", { symbol: params.symbol, type: "warn" });
     }
 }
@@ -56126,7 +56126,7 @@ async function createOTOOrder(client, params) {
         dependentDescription += ` trail ${dependent.trailPercent}%`;
     if (dependent.trailPrice)
         dependentDescription += ` trail $${dependent.trailPrice.toFixed(2)}`;
-    log$d(`Creating OTO order for ${symbol}: Primary [${primaryDescription}] -> Dependent [${dependentDescription}]`, { symbol, type: "info" });
+    log$e(`Creating OTO order for ${symbol}: Primary [${primaryDescription}] -> Dependent [${dependentDescription}]`, { symbol, type: "info" });
     const sdk = client.getSDK();
     try {
         // Build the OTO order request
@@ -56186,7 +56186,7 @@ async function createOTOOrder(client, params) {
                 orderRequest.stop_loss.trail_price = roundPriceForAlpaca$1(dependent.trailPrice).toString();
             }
         }
-        log$d(`Submitting OTO order request: ${JSON.stringify(orderRequest)}`, {
+        log$e(`Submitting OTO order request: ${JSON.stringify(orderRequest)}`, {
             symbol,
             type: "debug",
         });
@@ -56197,7 +56197,7 @@ async function createOTOOrder(client, params) {
         // The primary order is the parent, dependent is in legs
         const primaryOrder = order;
         const dependentOrder = legs.length > 0 ? legs[0] : null;
-        log$d(`OTO order created successfully | Parent ID: ${order.id} | Status: ${order.status}` +
+        log$e(`OTO order created successfully | Parent ID: ${order.id} | Status: ${order.status}` +
             (dependentOrder ? ` | Dependent ID: ${dependentOrder.id}` : ""), { symbol, type: "info" });
         return {
             primaryOrder,
@@ -56208,7 +56208,7 @@ async function createOTOOrder(client, params) {
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        log$d(`Failed to create OTO order for ${symbol}: ${errorMessage}`, {
+        log$e(`Failed to create OTO order for ${symbol}: ${errorMessage}`, {
             symbol,
             type: "error",
         });
@@ -56228,17 +56228,17 @@ async function createOTOOrder(client, params) {
  * await cancelOTOOrder(client, result.parentOrderId);
  */
 async function cancelOTOOrder(client, parentOrderId) {
-    log$d(`Canceling OTO order group: ${parentOrderId}`, { type: "info" });
+    log$e(`Canceling OTO order group: ${parentOrderId}`, { type: "info" });
     const sdk = client.getSDK();
     try {
         await sdk.cancelOrder(parentOrderId);
-        log$d(`OTO order group canceled successfully: ${parentOrderId}`, {
+        log$e(`OTO order group canceled successfully: ${parentOrderId}`, {
             type: "info",
         });
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        log$d(`Failed to cancel OTO order ${parentOrderId}: ${errorMessage}`, {
+        log$e(`Failed to cancel OTO order ${parentOrderId}: ${errorMessage}`, {
             type: "error",
         });
         throw error;
@@ -56260,17 +56260,17 @@ async function cancelOTOOrder(client, parentOrderId) {
  * }
  */
 async function getOTOOrderStatus(client, parentOrderId) {
-    log$d(`Getting OTO order status: ${parentOrderId}`, { type: "debug" });
+    log$e(`Getting OTO order status: ${parentOrderId}`, { type: "debug" });
     const sdk = client.getSDK();
     try {
         const order = (await sdk.getOrder(parentOrderId));
-        log$d(`OTO order ${parentOrderId} status: ${order.status} | ` +
+        log$e(`OTO order ${parentOrderId} status: ${order.status} | ` +
             `Legs: ${order.legs?.length || 0}`, { type: "debug" });
         return order;
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        log$d(`Failed to get OTO order status ${parentOrderId}: ${errorMessage}`, {
+        log$e(`Failed to get OTO order status ${parentOrderId}: ${errorMessage}`, {
             type: "error",
         });
         throw error;
@@ -56457,8 +56457,119 @@ var otoOrders$1 = /*#__PURE__*/Object.freeze({
     shortWithStopLoss: shortWithStopLoss
 });
 
+const log$d = (message, options = { type: "info" }) => {
+    log$m(message, { ...options, source: "AlpacaClock" });
+};
+/**
+ * Formats a Date to a YYYY-MM-DD string suitable for Alpaca calendar API requests.
+ *
+ * @param date - The date to format
+ * @returns Date string in YYYY-MM-DD format
+ */
+function formatCalendarDate(date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    return `${year}-${month}-${day}`;
+}
+/**
+ * Fetches the current market clock from Alpaca (GET /v2/clock).
+ *
+ * Returns the current server time, whether the market is open, and the next
+ * open/close timestamps. Useful for determining whether trading is currently
+ * possible before placing orders.
+ *
+ * @param client - An initialized AlpacaClient instance
+ * @returns Promise resolving to the current market clock status
+ *
+ * @example
+ * ```ts
+ * const clock = await getAlpacaClock(client);
+ * if (clock.is_open) {
+ *   console.log('Market is open, next close:', clock.next_close);
+ * } else {
+ *   console.log('Market closed, next open:', clock.next_open);
+ * }
+ * ```
+ *
+ * @throws {Error} If the Alpaca API request fails
+ */
+async function getAlpacaClock(client) {
+    log$d("Fetching market clock");
+    try {
+        const sdk = client.getSDK();
+        const clock = await sdk.getClock();
+        log$d(`Market clock fetched: is_open=${clock.is_open}, next_open=${clock.next_open}`);
+        return clock;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        log$d(`Failed to fetch market clock: ${errorMessage}`, { type: "error" });
+        throw error;
+    }
+}
+/**
+ * Fetches the market trading calendar from Alpaca (GET /v2/calendar).
+ *
+ * Returns the scheduled open and close times for each trading day within the
+ * requested date range. The calendar accounts for market holidays and early
+ * closures. Dates default to today when omitted.
+ *
+ * @param client - An initialized AlpacaClient instance
+ * @param options - Optional start/end dates for the calendar range
+ * @returns Promise resolving to an array of trading calendar days
+ *
+ * @example
+ * ```ts
+ * // Fetch the next 5 trading days
+ * const today = new Date();
+ * const nextWeek = new Date(today);
+ * nextWeek.setDate(today.getDate() + 7);
+ *
+ * const calendar = await getAlpacaCalendar(client, {
+ *   start: today,
+ *   end: nextWeek,
+ * });
+ * console.log('Trading days this week:', calendar.length);
+ * ```
+ *
+ * @throws {Error} If the Alpaca API request fails
+ */
+async function getAlpacaCalendar(client, options) {
+    const startStr = options?.start
+        ? formatCalendarDate(options.start)
+        : undefined;
+    const endStr = options?.end ? formatCalendarDate(options.end) : undefined;
+    log$d(`Fetching market calendar${startStr ? ` from ${startStr}` : ""}${endStr ? ` to ${endStr}` : ""}`);
+    try {
+        const sdk = client.getSDK();
+        const calendar = await sdk.getCalendar({
+            start: startStr,
+            end: endStr,
+        });
+        log$d(`Market calendar fetched: ${calendar.length} trading days`);
+        return calendar;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        log$d(`Failed to fetch market calendar: ${errorMessage}`, { type: "error" });
+        throw error;
+    }
+}
+var clock = {
+    getAlpacaClock,
+    getAlpacaCalendar,
+};
+
+var clock$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    default: clock,
+    getAlpacaCalendar: getAlpacaCalendar,
+    getAlpacaClock: getAlpacaClock
+});
+
 const log$c = (message, options = { type: "info" }) => {
-    log$l(message, { ...options, source: "AlpacaQuotes" });
+    log$m(message, { ...options, source: "AlpacaQuotes" });
 };
 /**
  * Error thrown when quote operations fail
@@ -56688,7 +56799,7 @@ var quotes$1 = /*#__PURE__*/Object.freeze({
 });
 
 const log$b = (message, options = { type: "info" }) => {
-    log$l(message, { ...options, source: "AlpacaBars" });
+    log$m(message, { ...options, source: "AlpacaBars" });
 };
 /**
  * Error thrown when bar operations fail
@@ -57054,7 +57165,7 @@ var bars$1 = /*#__PURE__*/Object.freeze({
 });
 
 const log$a = (message, options = { type: "info" }) => {
-    log$l(message, { ...options, source: "AlpacaTrades" });
+    log$m(message, { ...options, source: "AlpacaTrades" });
 };
 /**
  * Error thrown when trade operations fail
@@ -57431,7 +57542,7 @@ var trades$1 = /*#__PURE__*/Object.freeze({
 });
 
 const log$9 = (message, options = { type: "info" }) => {
-    log$l(message, { ...options, source: "AlpacaNews" });
+    log$m(message, { ...options, source: "AlpacaNews" });
 };
 /**
  * Error thrown when news operations fail
@@ -57904,7 +58015,7 @@ const LOG_SOURCE$6 = "OptionsContracts";
  * Internal logging helper with consistent source
  */
 const log$8 = (message, options = { type: "info" }) => {
-    log$l(message, { ...options, source: LOG_SOURCE$6 });
+    log$m(message, { ...options, source: LOG_SOURCE$6 });
 };
 // ============================================================================
 // API Functions
@@ -58613,7 +58724,7 @@ const LOG_SOURCE$5 = "OptionsOrders";
  * Internal logging helper with consistent source
  */
 const log$7 = (message, options = { type: "info" }) => {
-    log$l(message, { ...options, source: LOG_SOURCE$5 });
+    log$m(message, { ...options, source: LOG_SOURCE$5 });
 };
 // ============================================================================
 // Single-Leg Option Orders
@@ -59468,7 +59579,7 @@ const LOG_SOURCE$4 = "AlpacaOrders";
  * Internal logging helper with consistent source
  */
 const log$6 = (message, options = { type: "info" }) => {
-    log$l(message, { ...options, source: LOG_SOURCE$4 });
+    log$m(message, { ...options, source: LOG_SOURCE$4 });
 };
 /**
  * Creates a new order using the Alpaca SDK.
@@ -59881,7 +59992,7 @@ const LOG_SOURCE$3 = "OptionsStrategies";
  * Internal logging helper with consistent source
  */
 const log$5 = (message, options = { type: "info" }) => {
-    log$l(message, { ...options, source: LOG_SOURCE$3 });
+    log$m(message, { ...options, source: LOG_SOURCE$3 });
 };
 /**
  * Error class for option strategy operations
@@ -60483,7 +60594,7 @@ const LOG_SOURCE$2 = "OptionsData";
  * Internal logging helper with consistent source
  */
 const log$4 = (message, options = { type: "info" }) => {
-    log$l(message, { ...options, source: LOG_SOURCE$2 });
+    log$m(message, { ...options, source: LOG_SOURCE$2 });
 };
 /**
  * Error class for options data operations
@@ -60989,7 +61100,7 @@ const LOG_SOURCE$1 = "CryptoOrders";
  * Internal logging helper with consistent source
  */
 const log$3 = (message, options = { type: "info" }) => {
-    log$l(message, { ...options, source: LOG_SOURCE$1 });
+    log$m(message, { ...options, source: LOG_SOURCE$1 });
 };
 /**
  * Error thrown when crypto order operations fail
@@ -61481,7 +61592,7 @@ const LOG_SOURCE = "CryptoData";
  * Internal logging helper with consistent source
  */
 const log$2 = (message, options = { type: "info" }) => {
-    log$l(message, { ...options, source: LOG_SOURCE });
+    log$m(message, { ...options, source: LOG_SOURCE });
 };
 /**
  * Error thrown when crypto data operations fail
@@ -62300,7 +62411,7 @@ var streams$1 = /*#__PURE__*/Object.freeze({
 });
 
 const log$1 = (message, options = { type: "info" }) => {
-    log$l(message, { ...options, source: "SmartOrders" });
+    log$m(message, { ...options, source: "SmartOrders" });
 };
 /**
  * Analyze parameters and determine the best order type
@@ -62738,7 +62849,7 @@ var smartOrders$1 = /*#__PURE__*/Object.freeze({
 const log = (message, options = {
     type: "info",
 }) => {
-    log$l(message, { ...options, source: "Positions" });
+    log$m(message, { ...options, source: "Positions" });
 };
 // ============================================================================
 // Helper Functions
@@ -63518,6 +63629,8 @@ const alpaca = {
     positions: positions$1,
     // Trading - Account
     account: account$1,
+    // Trading - Clock & Calendar
+    clock: clock$1,
     // Market Data
     quotes: quotes$1,
     bars: bars$1,
@@ -71413,6 +71526,8 @@ const adaptic = {
         sdkPositions: alpaca.positions,
         /** @description Account information and configuration - SDK-based (requires AlpacaClient) */
         sdkAccount: alpaca.account,
+        /** @description Market clock and trading calendar - SDK-based (requires AlpacaClient) */
+        sdkClock: alpaca.clock,
         // Legacy API (with original signatures for backward compatibility)
         /** @description Standard order operations - Legacy API (uses AlpacaAuth) */
         orders: {
@@ -71673,6 +71788,7 @@ exports.cancelTrailingStop = cancelTrailingStop;
 exports.cancelTrailingStopsForSymbol = cancelTrailingStopsForSymbol;
 exports.checkTradingEligibility = checkTradingEligibility;
 exports.clearClientCache = clearClientCache;
+exports.clock = clock;
 exports.closeAllOptionPositions = closeAllOptionPositions;
 exports.closeOptionPosition = closeOptionPosition;
 exports.createAlpacaClient = createAlpacaClient;
@@ -71725,6 +71841,8 @@ exports.getAccountDetails = getAccountDetails;
 exports.getAccountSummary = getAccountSummary;
 exports.getAgentPoolStatus = getAgentPoolStatus;
 exports.getAllOrders = getAllOrders;
+exports.getAlpacaCalendar = getAlpacaCalendar;
+exports.getAlpacaClock = getAlpacaClock;
 exports.getAverageDailyVolume = getAverageDailyVolume;
 exports.getBars = getBars;
 exports.getBuyingPower = getBuyingPower;