@adaptic/utils 0.0.994 → 0.0.996

package/dist/index.cjs

@@ -6947,8 +6947,38 @@ async function closePosition$1(auth, symbolOrAssetId, params) {
                         account: auth.adapticAccountId || "direct",
                         symbol: normalizedSymbol,
                     });
-                    await cancelOrder$1(auth, order.id);
-                    cancelledCount++;
+                    try {
+                        await cancelOrder$1(auth, order.id);
+                        cancelledCount++;
+                    }
+                    catch (cancelError) {
+                        // Alpaca rejects DELETE on an order that is already in
+                        // pending_cancel / pending_replace with HTTP 422 code
+                        // 42210000 ("order pending cancel"). The order is already
+                        // dying — which is exactly what this sweep wants — so
+                        // aborting the entire position close here is wrong: it
+                        // left REDUCE/EXIT risk actions permanently blocked when a
+                        // protective stop wedged in pending_cancel at the broker
+                        // (observed live 2026-06-10: an 8-day-old pending_cancel
+                        // trailing stop on a naked short made every exit attempt
+                        // throw). Treat already-cancelling as success-in-progress
+                        // and let the subsequent close attempt get the broker's
+                        // authoritative answer on held quantity. Any other cancel
+                        // failure still aborts the close as before.
+                        const message = cancelError instanceof Error
+                            ? cancelError.message
+                            : String(cancelError);
+                        const alreadyCancelling = message.includes("42210000") ||
+                            message.includes("order pending cancel");
+                        if (!alreadyCancelling) {
+                            throw cancelError;
+                        }
+                        getLogger().warn(`Order ${order.id} (${order.symbol}) is already pending cancel at the broker — proceeding with position close without it`, {
+                            account: auth.adapticAccountId || "direct",
+                            symbol: normalizedSymbol,
+                            type: "warn",
+                        });
+                    }
                 }
             }
             if (cancelledCount > 0) {
@@ -6964,12 +6994,17 @@ async function closePosition$1(auth, symbolOrAssetId, params) {
                 const verifyDelayMs = 500;
                 for (let attempt = 1; attempt <= maxVerifyAttempts; attempt++) {
                     await new Promise((r) => setTimeout(r, verifyDelayMs));
-                    const remainingOrders = isCryptoSymbol$1(symbolOrAssetId)
+                    const allRemainingOrders = isCryptoSymbol$1(symbolOrAssetId)
                         ? (await getOrders$1(auth, { status: "open" })).filter((o) => o.symbol.replace(/[-/]/g, "") === normalizedSymbol)
                         : await getOrders$1(auth, {
                             status: "open",
                             symbols: [normalizedSymbol],
                         });
+                    // Orders stuck in pending_cancel / pending_replace are already
+                    // terminalising (or wedged — see the 42210000 handling above);
+                    // waiting longer will not change them, so they must not make
+                    // the verification spin to exhaustion on every close attempt.
+                    const remainingOrders = allRemainingOrders.filter((o) => o.status !== "pending_cancel" && o.status !== "pending_replace");
                     if (remainingOrders.length === 0) {
                         getLogger().info(`Cancel verification passed for ${normalizedSymbol} (attempt ${attempt}/${maxVerifyAttempts})`, {
                             account: auth.adapticAccountId || "direct",
@@ -9320,8 +9355,11 @@ const fetchTrades = async (symbol, options) => {
  *
  * This module provides functions to interact with the Massive.com Indices API.
  */
-// Constants from environment variables
-const { ALPACA_INDICES_API_KEY } = process.env;
+// Constants from environment variables.
+// Backward-compat: ALPACA_INDICES_API_KEY is the pre-2026-Q2 name (vendor was
+// renamed Alpaca → Massive); MASSIVE_INDICES_API_KEY is preferred. The fallback
+// stays so consumers that haven't migrated env vars don't break.
+const { MASSIVE_INDICES_API_KEY, ALPACA_INDICES_API_KEY } = process.env;
 // Define concurrency limits for API
 const MASSIVE_INDICES_CONCURRENCY_LIMIT = 5;
 const massiveIndicesLimit = pLimit(MASSIVE_INDICES_CONCURRENCY_LIMIT);
@@ -9333,7 +9371,7 @@ const MASSIVE_API_BASE_URL = "https://api.massive.com";
  * @throws {Error} If no API key is available
  */
 const validateApiKey = (apiKey) => {
-    const key = apiKey || ALPACA_INDICES_API_KEY;
+    const key = apiKey || MASSIVE_INDICES_API_KEY || ALPACA_INDICES_API_KEY;
     if (!key) {
         throw new Error("Massive Indices API key is missing");
     }