@vtxmacro/cli 2026.9.55 → 2026.9.56

package/bin/vtx-service-bootstrap.js

@@ -16,7 +16,7 @@ import { fileURLToPath } from "node:url";
 // agent-cli-release.json
 var agent_cli_release_default = {
   package_name: "@vtxmacro/cli",
-  package_version: "2026.9.55",
+  package_version: "2026.9.56",
   codex_package_name: "@openai/codex",
   codex_version: "0.155.0",
   copilot_sdk_package_name: "@github/copilot-sdk",
@@ -296,6 +296,28 @@ var runtime_policy_generated_default = {
           apiWallets: 20
         },
         exchange_action_batch_size: 40
+      },
+      public_recovery: {
+        fallback_initial_seconds: 2,
+        fallback_max_seconds: 60,
+        permit_lease_seconds: 60,
+        recovery_initial_concurrency: 1,
+        recovery_max_concurrency: 8,
+        recovery_successes_per_step: 4,
+        recovery_min_spacing_ms: 100,
+        queue_poll_ms: 50,
+        recovery_queue_wait_seconds: 10,
+        recovery_quiet_seconds: 30
+      },
+      http: {
+        exchange: {
+          request_timeout_seconds: 10,
+          pool_timeout_seconds: 10
+        },
+        public_critical: {
+          request_timeout_seconds: 10,
+          pool_timeout_seconds: 5
+        }
       }
     }
   }

package/bin/vtx-service-launcher.js

@@ -179,6 +179,28 @@ var runtime_policy_generated_default = {
           apiWallets: 20
         },
         exchange_action_batch_size: 40
+      },
+      public_recovery: {
+        fallback_initial_seconds: 2,
+        fallback_max_seconds: 60,
+        permit_lease_seconds: 60,
+        recovery_initial_concurrency: 1,
+        recovery_max_concurrency: 8,
+        recovery_successes_per_step: 4,
+        recovery_min_spacing_ms: 100,
+        queue_poll_ms: 50,
+        recovery_queue_wait_seconds: 10,
+        recovery_quiet_seconds: 30
+      },
+      http: {
+        exchange: {
+          request_timeout_seconds: 10,
+          pool_timeout_seconds: 10
+        },
+        public_critical: {
+          request_timeout_seconds: 10,
+          pool_timeout_seconds: 5
+        }
       }
     }
   }

package/bin/vtx.js

@@ -77,7 +77,7 @@ var init_agent_cli_release = __esm({
   "agent-cli-release.json"() {
     agent_cli_release_default = {
       package_name: "@vtxmacro/cli",
-      package_version: "2026.9.55",
+      package_version: "2026.9.56",
       codex_package_name: "@openai/codex",
       codex_version: "0.155.0",
       copilot_sdk_package_name: "@github/copilot-sdk",
@@ -20637,6 +20637,28 @@ var init_runtime_policy_generated = __esm({
               apiWallets: 20
             },
             exchange_action_batch_size: 40
+          },
+          public_recovery: {
+            fallback_initial_seconds: 2,
+            fallback_max_seconds: 60,
+            permit_lease_seconds: 60,
+            recovery_initial_concurrency: 1,
+            recovery_max_concurrency: 8,
+            recovery_successes_per_step: 4,
+            recovery_min_spacing_ms: 100,
+            queue_poll_ms: 50,
+            recovery_queue_wait_seconds: 10,
+            recovery_quiet_seconds: 30
+          },
+          http: {
+            exchange: {
+              request_timeout_seconds: 10,
+              pool_timeout_seconds: 10
+            },
+            public_critical: {
+              request_timeout_seconds: 10,
+              pool_timeout_seconds: 5
+            }
           }
         }
       }
@@ -42675,6 +42697,28 @@ var init_runtime_policy_generated2 = __esm({
               apiWallets: 20
             },
             exchange_action_batch_size: 40
+          },
+          public_recovery: {
+            fallback_initial_seconds: 2,
+            fallback_max_seconds: 60,
+            permit_lease_seconds: 60,
+            recovery_initial_concurrency: 1,
+            recovery_max_concurrency: 8,
+            recovery_successes_per_step: 4,
+            recovery_min_spacing_ms: 100,
+            queue_poll_ms: 50,
+            recovery_queue_wait_seconds: 10,
+            recovery_quiet_seconds: 30
+          },
+          http: {
+            exchange: {
+              request_timeout_seconds: 10,
+              pool_timeout_seconds: 10
+            },
+            public_critical: {
+              request_timeout_seconds: 10,
+              pool_timeout_seconds: 5
+            }
           }
         }
       }
@@ -48616,7 +48660,7 @@ var init_runtime_redaction = __esm({
 });
 
 // lib/runtime/hyperliquid-public-read.ts
-var policy, weights, budgets, unpersistedBudgets, cache, pending2, PREFIX, abortError2, checkAbort, wait, storage, loadBudget, saveBudget, withBudgetLock, HyperliquidPublicReadError, cooldownError, admit, cooldown, cacheTtlMs, eligibleCache, reserveHyperliquidPublicReads, releaseHyperliquidPublicReadReservation, admitHyperliquidExchangeRequest, recordHyperliquidExchangeResponse, readHyperliquidPublicInfo;
+var policy, weights, recoveryPolicy, budgets, unpersistedBudgets, cache, pending2, PREFIX, abortError2, checkAbort, wait, storage, loadBudget, saveBudget, withBudgetLock, HyperliquidPublicReadError, getHyperliquidPublicReadBudget, cooldownError, recoveryWaitError, fallbackDelayMs, admit, cooldown, finishHyperliquidRecoveryRequest, assertHyperliquidRecoveryDispatch, cacheTtlMs, eligibleCache, reserveHyperliquidPublicReads, releaseHyperliquidPublicReadReservation, admitHyperliquidExchangeRequest, recordHyperliquidExchangeResponse, readHyperliquidPublicInfo;
 var init_hyperliquid_public_read = __esm({
   "lib/runtime/hyperliquid-public-read.ts"() {
     "use strict";
@@ -48627,6 +48671,7 @@ var init_hyperliquid_public_read = __esm({
     init_runtime_policy_generated();
     policy = runtime_policy_generated_default.exchange.hyperliquid.client_public_read_budget;
     weights = runtime_policy_generated_default.exchange.hyperliquid.read_budget.weights;
+    recoveryPolicy = runtime_policy_generated_default.exchange.hyperliquid.public_recovery;
     budgets = /* @__PURE__ */ new Map();
     unpersistedBudgets = /* @__PURE__ */ new Set();
     cache = /* @__PURE__ */ new Map();
@@ -48684,7 +48729,15 @@ var init_hyperliquid_public_read = __esm({
     withBudgetLock = async (key, signal, work) => {
       checkAbort(signal);
       if (typeof navigator !== "undefined" && navigator.locks?.request) {
-        return navigator.locks.request(key, { ...signal ? { signal } : {} }, work);
+        const result2 = await navigator.locks.request(key, { ...signal ? { signal } : {} }, () => {
+          try {
+            return { ok: true, value: work() };
+          } catch (error48) {
+            return { ok: false, error: error48 };
+          }
+        });
+        if (!result2.ok) throw result2.error;
+        return result2.value;
       }
       return work();
     };
@@ -48701,6 +48754,15 @@ var init_hyperliquid_public_read = __esm({
         this.name = "HyperliquidPublicReadError";
       }
     };
+    getHyperliquidPublicReadBudget = (endpoint) => {
+      const budget = loadBudget(`${PREFIX}${endpoint.replace(/\/$/, "")}`);
+      return {
+        usedWeight: budget.reservations.filter((r) => r.at > Date.now() - policy.window_seconds * 1e3).reduce((sum, r) => sum + r.weight, 0),
+        maxWeight: policy.max_weight,
+        windowSeconds: policy.window_seconds,
+        cooldownUntilMs: budget.cooldownUntil
+      };
+    };
     cooldownError = (requestType, until) => new HyperliquidPublicReadError(
       "public_cooldown_active",
       "Hyperliquid public request cooldown is active.",
@@ -48708,48 +48770,129 @@ var init_hyperliquid_public_read = __esm({
       void 0,
       Math.max(0, until - Date.now())
     );
-    admit = async (apiUrl, requestType, signal, bundleWeight, bundleId, deadlineMs) => {
+    recoveryWaitError = (requestType) => new HyperliquidPublicReadError(
+      "public_recovery_wait",
+      "Hyperliquid provider recovery could not dispatch before the request deadline.",
+      requestType
+    );
+    fallbackDelayMs = (failures) => Math.min(
+      recoveryPolicy.fallback_max_seconds * 1e3,
+      recoveryPolicy.fallback_initial_seconds * 1e3 * 2 ** Math.min(30, Math.max(0, failures - 1)) * (0.5 + Math.random())
+    );
+    admit = async (apiUrl, requestType, signal, weightOverride, deadlineMs) => {
       const key = `${PREFIX}${apiUrl}`;
-      const weight = bundleWeight ?? weights[requestType] ?? policy.default_request_weight;
-      if (!(weight > 0 && weight <= policy.max_weight)) throw new HyperliquidPublicReadError("public_budget_exhausted", "Hyperliquid public request exceeds the available allowance.", requestType, void 0, void 0, weight, void 0, policy.max_weight);
-      for (; ; ) {
-        checkAbort(signal);
-        const { delay: delay2, usedWeight } = await withBudgetLock(key, signal, () => {
-          const now = Date.now();
-          const budget = loadBudget(key);
-          budget.reservations = budget.reservations.filter((r) => r.at > now - policy.window_seconds * 1e3);
-          if (budget.cooldownUntil > now) throw cooldownError(requestType, budget.cooldownUntil);
-          let used = budget.reservations.reduce((sum, r) => sum + r.weight, 0);
-          const usedWeight2 = used;
-          if (used + weight <= policy.max_weight) {
-            budget.reservations.push({ at: now, weight, ...bundleId ? { id: bundleId } : {} });
+      const weight = weightOverride ?? weights[requestType] ?? policy.default_request_weight;
+      const ticket = crypto.randomUUID();
+      const deadline = Math.min(deadlineMs ?? Infinity, Date.now() + recoveryPolicy.recovery_queue_wait_seconds * 1e3);
+      let admitted = false;
+      try {
+        for (; ; ) {
+          checkAbort(signal);
+          if (deadlineMs != null && Date.now() >= deadlineMs) throw recoveryWaitError(requestType);
+          const result2 = await withBudgetLock(key, signal, () => {
+            const now = Date.now();
+            const budget = loadBudget(key);
+            if (budget.cooldownUntil > now) throw cooldownError(requestType, budget.cooldownUntil);
+            const recovery = budget.recovery;
+            let permit = null;
+            if (recovery) {
+              recovery.active = recovery.active.filter((entry) => entry.expiresAt > now);
+              recovery.queue = recovery.queue.filter((entry) => entry.expiresAt > now);
+              if (now >= deadline) throw recoveryWaitError(requestType);
+              if (!recovery.queue.some((entry) => entry.id === ticket)) recovery.queue.push({ id: ticket, expiresAt: deadline });
+              if (recovery.queue[0]?.id !== ticket || recovery.active.length >= recovery.concurrency || recovery.nextAt > now) {
+                saveBudget(key, budget);
+                return { ready: false, permit: null };
+              }
+              recovery.queue.shift();
+              const expiresAt = now + recoveryPolicy.permit_lease_seconds * 1e3;
+              recovery.active.push({ id: ticket, expiresAt });
+              recovery.nextAt = now + recoveryPolicy.recovery_min_spacing_ms;
+              permit = { endpoint: apiUrl, id: ticket, generation: recovery.generation, expiresAt };
+            }
+            budget.reservations = budget.reservations.filter((entry) => entry.at > now - policy.window_seconds * 1e3);
+            budget.reservations.push({ at: now, weight });
             saveBudget(key, budget);
-            return { delay: 0, usedWeight: usedWeight2 };
+            return { ready: true, permit };
+          });
+          if (result2.ready) {
+            admitted = true;
+            return result2.permit;
           }
-          for (const reservation of budget.reservations) {
-            used -= reservation.weight;
-            if (used + weight <= policy.max_weight) return { delay: Math.max(1, reservation.at + policy.window_seconds * 1e3 - now), usedWeight: usedWeight2 };
+          await wait(Math.min(recoveryPolicy.queue_poll_ms, Math.max(1, deadline - Date.now())), signal);
+        }
+      } finally {
+        if (!admitted) await withBudgetLock(key, void 0, () => {
+          const budget = loadBudget(key);
+          if (budget.recovery) {
+            budget.recovery.queue = budget.recovery.queue.filter((entry) => entry.id !== ticket);
+            saveBudget(key, budget);
           }
-          throw new Error("Invalid Hyperliquid public read budget.");
         });
-        if (!delay2) return;
-        if (bundleWeight != null || deadlineMs != null && Date.now() + delay2 >= deadlineMs) {
-          throw new HyperliquidPublicReadError("public_budget_exhausted", "Hyperliquid local public request allowance is exhausted.", requestType, void 0, delay2, weight, usedWeight, policy.max_weight);
-        }
-        await wait(delay2, signal);
       }
     };
     cooldown = async (apiUrl, retryAfter) => {
       const key = `${PREFIX}${apiUrl}`;
       await withBudgetLock(key, void 0, () => {
         const now = Date.now();
-        const seconds = retryAfter == null ? NaN : Number(retryAfter);
-        const providerUntil = Number.isFinite(seconds) ? now + seconds * 1e3 : Date.parse(retryAfter ?? "");
         const budget = loadBudget(key);
-        budget.cooldownUntil = Math.max(budget.cooldownUntil, now + policy.cooldown_seconds * 1e3, Number.isFinite(providerUntil) ? providerUntil : 0);
+        if (!budget.recovery && now - (budget.lastFailure ?? 0) >= recoveryPolicy.recovery_quiet_seconds * 1e3) budget.failures = 0;
+        budget.failures = (budget.failures ?? 0) + 1;
+        const trimmed = retryAfter?.trim() ?? "";
+        const seconds = trimmed !== "" ? Number(trimmed) : NaN;
+        const providerUntil = Number.isFinite(seconds) && seconds >= 0 ? now + seconds * 1e3 : trimmed && !Number.isFinite(seconds) ? Date.parse(trimmed) : NaN;
+        const until = Number.isFinite(providerUntil) ? Math.max(now, Number(providerUntil)) : now + fallbackDelayMs(budget.failures);
+        budget.cooldownUntil = Math.max(budget.cooldownUntil, until);
+        budget.lastFailure = now;
+        budget.recovery = {
+          generation: crypto.randomUUID(),
+          concurrency: recoveryPolicy.recovery_initial_concurrency,
+          successes: 0,
+          nextAt: budget.cooldownUntil,
+          queue: budget.recovery?.queue ?? [],
+          active: []
+        };
+        saveBudget(key, budget);
+      });
+    };
+    finishHyperliquidRecoveryRequest = async (permit, outcome) => {
+      if (!permit) return;
+      const key = `${PREFIX}${permit.endpoint}`;
+      await withBudgetLock(key, void 0, () => {
+        const budget = loadBudget(key);
+        const recovery = budget.recovery;
+        if (!recovery || recovery.generation !== permit.generation) return;
+        const now = Date.now();
+        const member = recovery.active.find((entry) => entry.id === permit.id);
+        recovery.active = recovery.active.filter((entry) => entry.id !== permit.id);
+        if (member && member.expiresAt > now) {
+          if (outcome === "success") {
+            recovery.successes += 1;
+            if (recovery.successes >= recoveryPolicy.recovery_successes_per_step) {
+              if (recovery.concurrency >= recoveryPolicy.recovery_max_concurrency) {
+                if (recovery.queue.length === 0 && recovery.active.length === 0) delete budget.recovery;
+              } else {
+                recovery.concurrency = Math.min(recoveryPolicy.recovery_max_concurrency, recovery.concurrency * 2);
+                recovery.successes = 0;
+              }
+            }
+          } else if (outcome === "failure") {
+            recovery.successes = 0;
+            recovery.concurrency = recoveryPolicy.recovery_initial_concurrency;
+            recovery.nextAt = Math.max(recovery.nextAt, now + fallbackDelayMs(budget.failures ?? 1));
+          }
+        }
         saveBudget(key, budget);
       });
     };
+    assertHyperliquidRecoveryDispatch = (endpoint, permit, requestType) => {
+      const budget = loadBudget(`${PREFIX}${endpoint.replace(/\/$/, "")}`);
+      if (budget.cooldownUntil > Date.now()) throw cooldownError(requestType, budget.cooldownUntil);
+      if (permit && (permit.expiresAt <= Date.now() || budget.recovery && (budget.recovery.generation !== permit.generation || !budget.recovery.active.some((entry) => entry.id === permit.id && entry.expiresAt > Date.now())))) {
+        throw recoveryWaitError(requestType);
+      }
+      if (!permit && budget.recovery) throw recoveryWaitError(requestType);
+    };
     cacheTtlMs = (body, options) => {
       const requestType = String(body.type);
       return (["meta", "spotMeta", "perpDexs"].includes(requestType) ? policy.metadata_ttl_seconds : requestType === "userFees" ? policy.user_fees_ttl_seconds : options.cacheAccountMode && ["userAbstraction", "userDexAbstraction"].includes(requestType) ? policy.account_mode_ttl_seconds : 0) * 1e3;
@@ -48761,47 +48904,26 @@ var init_hyperliquid_public_read = __esm({
       return ttl > 0 && existing && Date.now() >= existing.fetchedAtMs && horizon - existing.fetchedAtMs < ttl ? existing : void 0;
     };
     reserveHyperliquidPublicReads = async (endpoint, bodies, signal, options = {}) => {
+      checkAbort(signal);
       const apiUrl = endpoint.replace(/\/$/, "");
       const cached2 = /* @__PURE__ */ new Map();
-      const remaining = /* @__PURE__ */ new Map();
-      let weight = 0;
       for (const body of bodies) {
-        const key = JSON.stringify(body);
         const hit = eligibleCache(apiUrl, body, options);
-        if (hit) {
-          cached2.set(key, hit);
-          continue;
-        }
-        remaining.set(key, (remaining.get(key) ?? 0) + 1);
-        weight += weights[String(body.type)] ?? policy.default_request_weight;
+        if (hit) cached2.set(JSON.stringify(body), hit);
       }
-      const id2 = crypto.randomUUID();
-      const admittedAtMs = Date.now();
-      if (weight) await admit(apiUrl, "bundle", signal, weight, id2, options.cacheValidUntilMs);
-      return { id: id2, closed: false, endpoint: apiUrl, expiresAtMs: admittedAtMs + policy.window_seconds * 1e3, remaining, cached: cached2, cacheValidUntilMs: options.cacheValidUntilMs };
+      return { closed: false, endpoint: apiUrl, cached: cached2, cacheValidUntilMs: options.cacheValidUntilMs };
     };
     releaseHyperliquidPublicReadReservation = async (reservation) => {
       reservation.closed = true;
-      const key = `${PREFIX}${reservation.endpoint}`;
-      await withBudgetLock(key, void 0, () => {
-        const budget = loadBudget(key);
-        const row = budget.reservations.find((entry) => entry.id === reservation.id);
-        if (row) {
-          const unused = [...reservation.remaining].reduce((sum, [body, count4]) => sum + (weights[String(JSON.parse(body).type)] ?? policy.default_request_weight) * count4, 0);
-          row.weight = Math.max(0, row.weight - unused);
-          budget.reservations = budget.reservations.filter((entry) => entry.weight > 0);
-          saveBudget(key, budget);
-        }
-        reservation.remaining.clear();
-      });
     };
     admitHyperliquidExchangeRequest = async (endpoint, action, signal) => {
       const batchLength = Math.max(0, ...[action.orders, action.cancels, action.modifies].filter(Array.isArray).map((value) => value.length));
       const weight = weights.exchange + Math.floor(batchLength / runtime_policy_generated_default.exchange.hyperliquid.read_budget.exchange_action_batch_size);
-      await admit(endpoint.replace(/\/$/, ""), "exchange", signal, weight);
+      return admit(endpoint.replace(/\/$/, ""), "exchange", signal, weight);
     };
-    recordHyperliquidExchangeResponse = async (endpoint, response) => {
+    recordHyperliquidExchangeResponse = async (endpoint, response, permit) => {
       if (response.status === 429) await cooldown(endpoint.replace(/\/$/, ""), response.headers.get("Retry-After"));
+      await finishHyperliquidRecoveryRequest(permit, response.status < 400 ? "success" : "failure");
     };
     readHyperliquidPublicInfo = async (endpoint, body, options = {}) => {
       const apiUrl = endpoint.replace(/\/$/, "");
@@ -48810,71 +48932,101 @@ var init_hyperliquid_public_read = __esm({
       const ttlMs = cacheTtlMs(body, cacheOptions);
       const key = `${apiUrl}:${JSON.stringify(body)}`;
       checkAbort(options.signal);
-      if (ttlMs) {
-        for (; ; ) {
-          const existing = options.reservation?.cached.get(JSON.stringify(body)) ?? eligibleCache(apiUrl, body, cacheOptions);
-          if (existing) return existing;
-          const running = pending2.get(key);
-          if (!running) break;
-          await new Promise((resolve13, reject) => {
-            const aborted2 = () => {
-              options.signal?.removeEventListener("abort", aborted2);
-              reject(abortError2(options.signal));
-            };
-            options.signal?.addEventListener("abort", aborted2, { once: true });
-            running.then(() => {
-              options.signal?.removeEventListener("abort", aborted2);
-              resolve13();
-            });
-          });
-          checkAbort(options.signal);
-        }
-      }
+      const transportPolicy = runtime_policy_generated_default.exchange.hyperliquid.http.public_critical;
+      const deadline = Math.min(
+        Date.now() + (transportPolicy.request_timeout_seconds + transportPolicy.pool_timeout_seconds) * 1e3,
+        options.deadlineMs ?? Infinity,
+        options.reservation?.cacheValidUntilMs ?? Infinity
+      );
+      const controller = new AbortController();
+      const signal = controller.signal;
+      const callerAborted = () => controller.abort(abortError2(options.signal));
+      options.signal?.addEventListener("abort", callerAborted, { once: true });
+      let timer;
+      const armDeadline = (until) => {
+        clearTimeout(timer);
+        const timeout = () => controller.abort(new DOMException("Hyperliquid public request timed out.", "TimeoutError"));
+        if (until <= Date.now()) timeout();
+        else timer = setTimeout(timeout, until - Date.now());
+      };
+      armDeadline(deadline);
+      let permit = null;
+      let outcome = "cancelled";
       let settled;
-      if (ttlMs) pending2.set(key, new Promise((resolve13) => {
-        settled = resolve13;
-      }));
+      let acquiring = false;
       try {
-        const reservedKey = JSON.stringify(body);
-        const remaining = options.reservation?.remaining.get(reservedKey) ?? 0;
-        if (options.reservation?.endpoint === apiUrl && remaining > 0) {
-          if (Date.now() >= options.reservation.expiresAtMs) throw new HyperliquidPublicReadError("public_budget_exhausted", "Hyperliquid public read reservation expired.", requestType);
-          await withBudgetLock(`${PREFIX}${apiUrl}`, options.signal, () => {
-            if (options.reservation.closed) throw new HyperliquidPublicReadError("public_budget_exhausted", "Hyperliquid public read bundle is closed.", requestType);
-            if ((options.reservation.remaining.get(reservedKey) ?? 0) <= 0) throw new HyperliquidPublicReadError("public_budget_exhausted", "Hyperliquid request is outside its admitted bundle.", requestType);
-            const budget = loadBudget(`${PREFIX}${apiUrl}`);
-            const row = budget.reservations.find((entry) => entry.id === options.reservation.id);
-            if (!row || Date.now() >= options.reservation.expiresAtMs) throw new HyperliquidPublicReadError("public_budget_exhausted", "Hyperliquid public read reservation expired.", requestType);
-            row.at = Date.now();
-            budget.reservations.sort((a, b2) => a.at - b2.at);
-            options.reservation.remaining.set(reservedKey, (options.reservation.remaining.get(reservedKey) ?? 0) - 1);
-            saveBudget(`${PREFIX}${apiUrl}`, budget);
+        checkAbort(signal);
+        if (ttlMs) {
+          for (; ; ) {
+            const existing = options.reservation?.cached.get(JSON.stringify(body)) ?? eligibleCache(apiUrl, body, cacheOptions);
+            if (existing) return existing;
+            const running = pending2.get(key);
+            if (!running) break;
+            await new Promise((resolve13, reject) => {
+              const aborted2 = () => {
+                signal.removeEventListener("abort", aborted2);
+                reject(abortError2(signal));
+              };
+              signal.addEventListener("abort", aborted2, { once: true });
+              running.then(() => {
+                signal.removeEventListener("abort", aborted2);
+                resolve13();
+              });
+            });
+            checkAbort(signal);
+          }
+          pending2.set(key, new Promise((resolve13) => {
+            settled = resolve13;
+          }));
+        }
+        if (options.reservation?.closed) throw new DOMException("Hyperliquid account read was cancelled.", "AbortError");
+        acquiring = true;
+        permit = await admit(apiUrl, requestType, signal, void 0, deadline);
+        acquiring = false;
+        armDeadline(Math.min(deadline, permit?.expiresAt ?? Infinity));
+        checkAbort(signal);
+        if (options.reservation?.closed) throw new DOMException("Hyperliquid account read was cancelled.", "AbortError");
+        assertHyperliquidRecoveryDispatch(apiUrl, permit, requestType);
+        outcome = "failure";
+        let transportAborted;
+        let response;
+        let payload;
+        try {
+          const aborted2 = new Promise((_resolve, reject) => {
+            transportAborted = () => reject(abortError2(signal));
+            signal.addEventListener("abort", transportAborted, { once: true });
           });
-        } else if (options.reservation) throw new HyperliquidPublicReadError("public_budget_exhausted", "Hyperliquid request is outside its admitted bundle.", requestType);
-        else await admit(apiUrl, requestType, options.signal, void 0, void 0, options.deadlineMs);
-        checkAbort(options.signal);
-        if (options.reservation?.closed) throw new HyperliquidPublicReadError("public_budget_exhausted", "Hyperliquid public read bundle is closed.", requestType);
-        const cooldownUntil = loadBudget(`${PREFIX}${apiUrl}`).cooldownUntil;
-        if (cooldownUntil > Date.now()) throw cooldownError(requestType, cooldownUntil);
-        const response = await fetch(`${apiUrl}/info`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(body),
-          signal: options.signal
-        });
-        if (response.status === 429) await cooldown(apiUrl, response.headers.get("Retry-After"));
-        const payload = await response.json().catch((error48) => {
-          if (error48 instanceof SyntaxError) return {};
-          throw error48;
-        });
+          const transport = (async () => {
+            const received = await fetch(`${apiUrl}/info`, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify(body),
+              signal
+            });
+            checkAbort(signal);
+            if (received.status === 429) {
+              await cooldown(apiUrl, received.headers.get("Retry-After"));
+              throw new HyperliquidPublicReadError("public_rate_limited", "Hyperliquid public API returned HTTP 429.", requestType, 429);
+            }
+            const receivedPayload = await received.json().catch((error48) => {
+              if (error48 instanceof SyntaxError) return {};
+              throw error48;
+            });
+            checkAbort(signal);
+            return { response: received, payload: receivedPayload };
+          })();
+          ({ response, payload } = await Promise.race([transport, aborted2]));
+        } finally {
+          if (transportAborted) signal.removeEventListener("abort", transportAborted);
+        }
         if (!response.ok) {
           const detail = sanitizeRuntimeDiagnosticValue(typeof payload?.response === "string" ? payload.response : typeof payload?.detail === "string" ? payload.detail : "");
-          if (response.status === 429) throw new HyperliquidPublicReadError("public_rate_limited", "Hyperliquid public API returned HTTP 429.", requestType, 429);
           throw Object.assign(new Error(`Hyperliquid info request failed (${response.status}) request_type=${requestType}.${detail ? ` ${detail}` : ""}`), {
             status: response.status,
             requestType
           });
         }
+        outcome = "success";
         const result2 = { payload, fetchedAtMs: Date.now() };
         if (ttlMs) {
           cache.set(key, result2);
@@ -48882,14 +49034,26 @@ var init_hyperliquid_public_read = __esm({
         }
         return result2;
       } catch (error48) {
-        if (options.signal?.aborted || error48 instanceof HyperliquidPublicReadError) throw error48;
+        if (options.signal?.aborted) {
+          outcome = "cancelled";
+          throw abortError2(options.signal);
+        }
+        if (acquiring && signal.aborted && signal.reason?.name === "TimeoutError") throw recoveryWaitError(requestType);
+        if (error48 instanceof HyperliquidPublicReadError) throw error48;
         if (error48 instanceof TypeError) throw new HyperliquidPublicReadError("public_network_error", "Hyperliquid public request network failure.", requestType);
         if (error48 instanceof Error && (error48.name === "TimeoutError" || error48.name === "AbortError")) throw new HyperliquidPublicReadError("public_timeout", "Hyperliquid public request timed out.", requestType);
         throw error48;
       } finally {
-        if (ttlMs) {
-          pending2.delete(key);
-          settled?.();
+        clearTimeout(timer);
+        options.signal?.removeEventListener("abort", callerAborted);
+        controller.abort();
+        try {
+          await finishHyperliquidRecoveryRequest(permit, outcome);
+        } finally {
+          if (settled) {
+            pending2.delete(key);
+            settled();
+          }
         }
       }
     };
@@ -49987,7 +50151,7 @@ var init_network_debug = __esm({
 });
 
 // lib/runtime/hyperliquid-account-state-adapter.ts
-var unsupportedUserActiveAssetCache, MAX_UNSUPPORTED_USER_ACTIVE_ASSET_CACHE_KEYS, UNSUPPORTED_USER_ACTIVE_ASSET_STORAGE_KEY, USER_FILLS_CACHE_STORAGE_PREFIX, ACCOUNT_STATE_CACHE_STORAGE_PREFIX, INFO_RATE_LIMIT_COOLDOWN_STORAGE_PREFIX, INFO_RATE_LIMIT_COOLDOWN_MIN_MS, INFO_RATE_LIMIT_COOLDOWN_MAX_MS, browserUserFillsCache, browserUserFillsInFlight, HYPERLIQUID_USER_FILLS_PROVIDER_PAGE_CAP, browserAccountStateCache, browserAccountStateInFlight, browserInfoRateLimitCooldowns, UNSUPPORTED_USER_ACTIVE_ASSET_DETAIL_PATTERNS, unsupportedUserActiveAssetCacheHydrated, hydrateUnsupportedUserActiveAssetCache, persistUnsupportedUserActiveAssetCache, toPositiveFinite, toFinite, firstFiniteNumber, parseFundingUsdcFromInfoPosition, buildActiveAssetCacheKey, buildUserFillsCacheKey, buildUserFillsStorageKey, buildAccountStateCacheKey, buildAccountStateStorageKey, normalizeInfoRateLimitApiUrl, normalizeInfoRequestType, buildInfoRateLimitCooldownKey, buildInfoRateLimitCooldownStorageKey, readInfoRateLimitCooldownUntilMs, hasActiveInfoRateLimitCooldown, writeInfoRateLimitCooldown, extractInfoRequestTypeFromRateLimitError, recordInfoRateLimitCooldownFromError, requireNonNegativeConfigSeconds, requireAccountStateCacheConfig, requireUserFillsCacheConfig, normalizeFillSymbol, buildSymbolFilter, filterFillsBySymbols, readBrowserUserFillsCache, writeBrowserUserFillsCache, cloneBrowserAccountStateResult, withAccountStateEvidence, readBrowserAccountStateCache, writeBrowserAccountStateCache, isRateLimitError, createAbortError, waitForSharedBrowserRequest, waitForSharedBrowserUserFills, getBrowserActiveAssetTypeCandidates, normalizeHyperliquidErrorDetail, isUnsupportedUserActiveAssetError, rememberUnsupportedUserActiveAssetKey, parseInfoPositions, requireFinitePromptMetric, requirePromptClearinghouseState, requirePromptSpotState, normalizePerpDexName, listConfiguredPerpDexs, listPerpDexsForAccountState, prefixHip3PositionCoins, aggregateClearinghouseResponses, hasCompletePerpDexAccountMetrics, normalizeBrowserFillToTradeHistory, isPerpFill, fetchHyperliquidInfoPayload, requireHyperliquidApiUrl, requireWalletAddress, parseInfoPositionSnapshot, fetchBrowserAccountState, fetchBrowserAccountStateUncached, fetchBrowserUserFills, fetchBrowserPositionSnapshot;
+var unsupportedUserActiveAssetCache, MAX_UNSUPPORTED_USER_ACTIVE_ASSET_CACHE_KEYS, UNSUPPORTED_USER_ACTIVE_ASSET_STORAGE_KEY, USER_FILLS_CACHE_STORAGE_PREFIX, ACCOUNT_STATE_CACHE_STORAGE_PREFIX, browserUserFillsCache, browserUserFillsInFlight, HYPERLIQUID_USER_FILLS_PROVIDER_PAGE_CAP, browserAccountStateCache, browserAccountStateInFlight, UNSUPPORTED_USER_ACTIVE_ASSET_DETAIL_PATTERNS, unsupportedUserActiveAssetCacheHydrated, hydrateUnsupportedUserActiveAssetCache, persistUnsupportedUserActiveAssetCache, toPositiveFinite, toFinite, firstFiniteNumber, parseFundingUsdcFromInfoPosition, buildActiveAssetCacheKey, buildUserFillsCacheKey, buildUserFillsStorageKey, buildAccountStateCacheKey, buildAccountStateStorageKey, hasActiveInfoRateLimitCooldown, requireNonNegativeConfigSeconds, requireAccountStateCacheConfig, requireUserFillsCacheConfig, normalizeFillSymbol, buildSymbolFilter, filterFillsBySymbols, readBrowserUserFillsCache, writeBrowserUserFillsCache, cloneBrowserAccountStateResult, withAccountStateEvidence, readBrowserAccountStateCache, writeBrowserAccountStateCache, isRateLimitError, createAbortError, waitForSharedBrowserRequest, waitForSharedBrowserUserFills, getBrowserActiveAssetTypeCandidates, normalizeHyperliquidErrorDetail, isUnsupportedUserActiveAssetError, rememberUnsupportedUserActiveAssetKey, parseInfoPositions, requireFinitePromptMetric, requirePromptClearinghouseState, requirePromptSpotState, normalizePerpDexName, listConfiguredPerpDexs, listPerpDexsForAccountState, prefixHip3PositionCoins, aggregateClearinghouseResponses, hasCompletePerpDexAccountMetrics, normalizeBrowserFillToTradeHistory, isPerpFill, awaitAccountReads, fetchHyperliquidInfoPayload, requireHyperliquidApiUrl, requireWalletAddress, parseInfoPositionSnapshot, fetchBrowserAccountState, fetchBrowserAccountStateUncached, fetchBrowserUserFills, fetchBrowserPositionSnapshot;
 var init_hyperliquid_account_state_adapter = __esm({
   "lib/runtime/hyperliquid-account-state-adapter.ts"() {
     "use strict";
@@ -50008,15 +50172,11 @@ var init_hyperliquid_account_state_adapter = __esm({
     UNSUPPORTED_USER_ACTIVE_ASSET_STORAGE_KEY = "vtx:hyperliquid:unsupported-user-active-asset:v1";
     USER_FILLS_CACHE_STORAGE_PREFIX = "vtx:hyperliquid:user-fills:v1:";
     ACCOUNT_STATE_CACHE_STORAGE_PREFIX = "vtx:hyperliquid:account-state:v1:";
-    INFO_RATE_LIMIT_COOLDOWN_STORAGE_PREFIX = "vtx:hyperliquid:info-rate-limit-cooldown:v1:";
-    INFO_RATE_LIMIT_COOLDOWN_MIN_MS = 5e3;
-    INFO_RATE_LIMIT_COOLDOWN_MAX_MS = 6e4;
     browserUserFillsCache = /* @__PURE__ */ new Map();
     browserUserFillsInFlight = /* @__PURE__ */ new Map();
     HYPERLIQUID_USER_FILLS_PROVIDER_PAGE_CAP = 2e3;
     browserAccountStateCache = /* @__PURE__ */ new Map();
     browserAccountStateInFlight = /* @__PURE__ */ new Map();
-    browserInfoRateLimitCooldowns = /* @__PURE__ */ new Map();
     UNSUPPORTED_USER_ACTIVE_ASSET_DETAIL_PATTERNS = [
       /unsupported/i,
       /not\s+supported/i,
@@ -50134,93 +50294,7 @@ var init_hyperliquid_account_state_adapter = __esm({
     buildAccountStateStorageKey = (cacheKey) => {
       return `${ACCOUNT_STATE_CACHE_STORAGE_PREFIX}${cacheKey}`;
     };
-    normalizeInfoRateLimitApiUrl = (apiUrl) => {
-      return String(apiUrl || "").trim().replace(/\/$/, "").toLowerCase();
-    };
-    normalizeInfoRequestType = (requestType) => {
-      return String(requestType || "").trim() || "info";
-    };
-    buildInfoRateLimitCooldownKey = (apiUrl, requestType) => {
-      return [
-        normalizeInfoRateLimitApiUrl(apiUrl),
-        normalizeInfoRequestType(requestType)
-      ].join("::");
-    };
-    buildInfoRateLimitCooldownStorageKey = (cooldownKey) => {
-      return `${INFO_RATE_LIMIT_COOLDOWN_STORAGE_PREFIX}${encodeURIComponent(cooldownKey)}`;
-    };
-    readInfoRateLimitCooldownUntilMs = (apiUrl, requestType, nowMs = Date.now()) => {
-      const cooldownKey = buildInfoRateLimitCooldownKey(apiUrl, requestType);
-      const memoryValue = browserInfoRateLimitCooldowns.get(cooldownKey);
-      if (Number.isFinite(memoryValue)) {
-        if (Number(memoryValue) > nowMs) {
-          return Number(memoryValue);
-        }
-        browserInfoRateLimitCooldowns.delete(cooldownKey);
-      }
-      if (typeof window === "undefined" || !window.localStorage) {
-        return 0;
-      }
-      try {
-        const storageKey = buildInfoRateLimitCooldownStorageKey(cooldownKey);
-        const rawValue = window.localStorage.getItem(storageKey);
-        if (!rawValue) {
-          return 0;
-        }
-        const parsed = JSON.parse(rawValue);
-        const untilMs = Number(parsed?.untilMs);
-        if (!Number.isFinite(untilMs) || untilMs <= nowMs) {
-          window.localStorage.removeItem(storageKey);
-          return 0;
-        }
-        browserInfoRateLimitCooldowns.set(cooldownKey, untilMs);
-        return untilMs;
-      } catch {
-        return 0;
-      }
-    };
-    hasActiveInfoRateLimitCooldown = (apiUrl, requestTypes, nowMs = Date.now()) => requestTypes.some((requestType) => readInfoRateLimitCooldownUntilMs(apiUrl, requestType, nowMs) > nowMs);
-    writeInfoRateLimitCooldown = (apiUrl, requestType, staleIf429MaxAgeMs, nowMs = Date.now()) => {
-      if (!Number.isFinite(staleIf429MaxAgeMs) || staleIf429MaxAgeMs <= 0) {
-        return;
-      }
-      const cooldownKey = buildInfoRateLimitCooldownKey(apiUrl, requestType);
-      const cooldownMs = Math.max(
-        INFO_RATE_LIMIT_COOLDOWN_MIN_MS,
-        Math.min(INFO_RATE_LIMIT_COOLDOWN_MAX_MS, staleIf429MaxAgeMs)
-      );
-      const untilMs = nowMs + cooldownMs;
-      browserInfoRateLimitCooldowns.set(cooldownKey, untilMs);
-      if (typeof window === "undefined" || !window.localStorage) {
-        return;
-      }
-      try {
-        window.localStorage.setItem(
-          buildInfoRateLimitCooldownStorageKey(cooldownKey),
-          JSON.stringify({ untilMs })
-        );
-      } catch {
-      }
-    };
-    extractInfoRequestTypeFromRateLimitError = (error48) => {
-      const explicitType = normalizeInfoRequestType(error48?.requestType);
-      if (explicitType !== "info") {
-        return explicitType;
-      }
-      const detail = normalizeHyperliquidErrorDetail(error48);
-      const match = /\brequest_type=([A-Za-z0-9_:-]+)/.exec(detail);
-      return match?.[1] ? normalizeInfoRequestType(match[1]) : null;
-    };
-    recordInfoRateLimitCooldownFromError = (apiUrl, error48, staleIf429MaxAgeMs, nowMs = Date.now()) => {
-      if (!isRateLimitError(error48)) {
-        return;
-      }
-      const requestType = extractInfoRequestTypeFromRateLimitError(error48);
-      if (!requestType) {
-        return;
-      }
-      writeInfoRateLimitCooldown(apiUrl, requestType, staleIf429MaxAgeMs, nowMs);
-    };
+    hasActiveInfoRateLimitCooldown = (apiUrl, _requestTypes, nowMs = Date.now()) => getHyperliquidPublicReadBudget(apiUrl).cooldownUntilMs > nowMs;
     requireNonNegativeConfigSeconds = (value, path) => {
       const numeric2 = Number(value);
       if (!Number.isFinite(numeric2) || numeric2 < 0) {
@@ -50744,6 +50818,19 @@ var init_hyperliquid_account_state_adapter = __esm({
       }
       return true;
     };
+    awaitAccountReads = async (reads) => {
+      try {
+        return await Promise.all(reads);
+      } catch (error48) {
+        if (error48 instanceof HyperliquidPublicReadError && error48.code === "public_cooldown_active") {
+          const settled = await Promise.allSettled(reads);
+          for (const result2 of settled) {
+            if (result2.status === "rejected" && result2.reason instanceof HyperliquidPublicReadError && result2.reason.code === "public_rate_limited") throw result2.reason;
+          }
+        }
+        throw error48;
+      }
+    };
     fetchHyperliquidInfoPayload = async (apiUrl, body, signal, reservation) => {
       const trace = startRuntimeNetworkDebugTrace({ kind: "exchange", label: `hyperliquid_info:${String(body.type)}`, method: "POST", url: `${apiUrl.replace(/\/$/, "")}/info` });
       try {
@@ -50867,7 +50954,6 @@ var init_hyperliquid_account_state_adapter = __esm({
           "Browser account state request aborted."
         ));
       } catch (error48) {
-        recordInfoRateLimitCooldownFromError(apiUrl, error48, staleIf429MaxAgeMs);
         const staleCache = readBrowserAccountStateCache(cacheKey);
         if (!input.forceRefresh && isRateLimitError(error48) && staleCache && Date.now() - staleCache.fetchedAtMs <= staleIf429MaxAgeMs) {
           return withAccountStateEvidence(staleCache.result, "stale_if_429", staleCache.fetchedAtMs, staleIf429MaxAgeMs);
@@ -50927,10 +51013,10 @@ var init_hyperliquid_account_state_adapter = __esm({
             capturedAt: new Date(capturedAtMs).toISOString()
           };
         })() : Promise.resolve(null);
-        await Promise.all([userFeesPromise, exactAccountModePromise]);
+        await awaitAccountReads([userFeesPromise, exactAccountModePromise]);
         const metadataByDex = /* @__PURE__ */ new Map();
         if (input.includeEffectiveTakerRate === true) {
-          await Promise.all(["", ...dexNames].map(async (dex) => {
+          await awaitAccountReads(["", ...dexNames].map(async (dex) => {
             try {
               metadataByDex.set(dex, await fetchHyperliquidInfoPayload(apiUrl, { type: "meta", ...dex ? { dex } : {} }, input.signal, reservation));
             } catch (error48) {
@@ -50949,7 +51035,7 @@ var init_hyperliquid_account_state_adapter = __esm({
           if (input.includeEffectiveTakerRate === true) {
             requirePromptClearinghouseState(defaultResponse, "default");
           }
-          const dexResponses = await Promise.all(
+          const dexResponses = await awaitAccountReads(
             dexNames.map(async (dexName) => {
               const response = await fetchHyperliquidInfoPayload(
                 apiUrl,
@@ -50994,7 +51080,6 @@ var init_hyperliquid_account_state_adapter = __esm({
               reservation
             );
           } catch (error48) {
-            recordInfoRateLimitCooldownFromError(apiUrl, error48, staleIf429MaxAgeMs);
             if (input.forceRefresh || input.includeEffectiveTakerRate === true) {
               throw error48;
             }
@@ -51015,7 +51100,6 @@ var init_hyperliquid_account_state_adapter = __esm({
               return { payload, type: typeName };
             } catch (error48) {
               lastError = error48;
-              recordInfoRateLimitCooldownFromError(apiUrl, error48, staleIf429MaxAgeMs);
               if (isRateLimitError(error48)) throw error48;
               if (typeName === "userActiveAssetData" && isUnsupportedUserActiveAssetError(error48)) {
                 rememberUnsupportedUserActiveAssetKey(activeAssetCacheKey);
@@ -51024,7 +51108,7 @@ var init_hyperliquid_account_state_adapter = __esm({
           }
           throw lastError instanceof Error ? lastError : new Error("Failed to fetch browser active asset data.");
         })();
-        const [perpsResult, spotResult, activeAssetResult, userFeesResult, exactAccountMode] = await Promise.all([
+        const [perpsResult, spotResult, activeAssetResult, userFeesResult, exactAccountMode] = await awaitAccountReads([
           perpsPromise,
           spotPromise,
           activeAssetPromise,
@@ -51050,7 +51134,7 @@ var init_hyperliquid_account_state_adapter = __esm({
             ...parseInfoPositions(perpsResponse).filter((position) => Number(position.size) !== 0).map((position) => position.symbol)
           ].map(normalizeHyperliquidMarketSymbol).filter(Boolean))].sort();
           const feeDexes = [...new Set(feeSymbols.map(getHyperliquidMarketDex))];
-          const metadata = await Promise.all(feeDexes.map(async (dex) => {
+          const metadata = await awaitAccountReads(feeDexes.map(async (dex) => {
             try {
               const payload = metadataByDex.get(dex) ?? null;
               return [dex, payload];
@@ -51245,7 +51329,6 @@ var init_hyperliquid_account_state_adapter = __esm({
         providerRowCount = liveResult.providerRowCount;
         fetchedAtMs = liveResult.fetchedAtMs;
       } catch (error48) {
-        recordInfoRateLimitCooldownFromError(apiUrl, error48, staleIf429MaxAgeMs);
         const staleCache = readBrowserUserFillsCache(cacheKey);
         if (isRateLimitError(error48) && !input.forceRefresh) {
           evidenceSource = "stale_if_429";
@@ -83844,6 +83927,7 @@ var init_hyperliquid_client = __esm({
     init_define_VTX_EXO_POLICY();
     init_define_VTX_GROK_POLICY();
     init_define_VTX_PI_MODEL_POLICY();
+    init_runtime_policy_generated();
     init_hyperliquid_public_read();
     init_api2();
     init_abort();
@@ -85514,6 +85598,7 @@ var init_hyperliquid_client = __esm({
           const serializedPayload = JSON.stringify(input.payload);
           const durableMutation = input.durableMutation;
           let exchangeDispatched = false;
+          let recoveryPermit = null;
           let settlementAttempted = false;
           assertFreshPreparedExecutionContext(input.preparedContext);
           const captureTimeoutMs = Number(
@@ -85670,8 +85755,9 @@ var init_hyperliquid_client = __esm({
               }
             }
             try {
-              await admitHyperliquidExchangeRequest(apiUrl, input.payload.action, input.signal);
+              recoveryPermit = await admitHyperliquidExchangeRequest(apiUrl, input.payload.action, input.signal);
               assertFreshPreparedExecutionContext(input.preparedContext);
+              assertHyperliquidRecoveryDispatch(apiUrl, recoveryPermit, "exchange");
             } catch (preparedContextError) {
               await settleDurableMutation("rejected");
               if (isAbortLikeError(preparedContextError) || preparedContextError instanceof HyperliquidPublicReadError) throw preparedContextError;
@@ -85699,16 +85785,44 @@ var init_hyperliquid_client = __esm({
               }
             }
             exchangeDispatched = true;
-            const response = await fetch(requestUrl, {
-              method: "POST",
-              headers: {
-                "Content-Type": "application/json"
-              },
-              body: serializedPayload
-            });
-            responseStatus = response.status;
-            await recordHyperliquidExchangeResponse(apiUrl, response);
-            const payload = await response.json().catch(() => ({}));
+            const transportController = new AbortController();
+            const exchangeTimeout = runtime_policy_generated_default.exchange.hyperliquid.http.exchange;
+            const transportTimeoutMs = Math.min(
+              (exchangeTimeout.request_timeout_seconds + exchangeTimeout.pool_timeout_seconds) * 1e3,
+              recoveryPermit ? Math.max(0, recoveryPermit.expiresAt - Date.now()) : Infinity
+            );
+            let transportTimer;
+            let response;
+            let payload;
+            try {
+              const transport = (async () => {
+                const received = await fetch(requestUrl, {
+                  method: "POST",
+                  headers: { "Content-Type": "application/json" },
+                  body: serializedPayload,
+                  signal: transportController.signal
+                });
+                if (transportController.signal.aborted) throw transportController.signal.reason;
+                responseStatus = received.status;
+                await recordHyperliquidExchangeResponse(apiUrl, received);
+                const body = await received.json().catch(() => ({}));
+                if (transportController.signal.aborted) throw transportController.signal.reason;
+                return { response: received, payload: body };
+              })();
+              const timeout = new Promise((_resolve, reject) => {
+                transportTimer = globalThis.setTimeout(() => {
+                  const error48 = new DOMException("Hyperliquid exchange transport timed out.", "TimeoutError");
+                  transportController.abort(error48);
+                  reject(error48);
+                }, transportTimeoutMs);
+              });
+              ({ response, payload } = await Promise.race([transport, timeout]));
+            } finally {
+              globalThis.clearTimeout(transportTimer);
+              transportController.abort();
+            }
+            await finishHyperliquidRecoveryRequest(recoveryPermit, response.status < 400 ? "success" : "failure").catch(() => void 0);
+            recoveryPermit = null;
             if (!response.ok) {
               await settleDurableMutation("transport_ambiguous");
               throw new RuntimeExecutionError(
@@ -85773,6 +85887,8 @@ var init_hyperliquid_client = __esm({
               );
             }
             throw error48;
+          } finally {
+            await finishHyperliquidRecoveryRequest(recoveryPermit, exchangeDispatched ? "failure" : "cancelled").catch(() => void 0);
           }
         });
       } catch (error48) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vtxmacro/cli",
-  "version": "2026.9.55",
+  "version": "2026.9.56",
   "description": "VTX Macro CLI, MCP server, and durable external inference host.",
   "type": "module",
   "license": "UNLICENSED",