@agg-build/hooks 4.17.2 → 4.18.2

package/dist/index.mjs

@@ -1,13 +1,13 @@
 import {
   useRampQuotes,
   useRampSession
-} from "./chunk-BBAKQDOH.mjs";
+} from "./chunk-SBGLJDPJ.mjs";
 import {
   useWithdrawEstimate,
   useWithdrawFlow,
   useWithdrawPreview,
   useWithdrawalLifecycle
-} from "./chunk-IVUHIMRY.mjs";
+} from "./chunk-5B2F3GMC.mjs";
 import {
   AggAuthContext,
   AggBalanceProvider,
@@ -26,20 +26,17 @@ import {
   Venue,
   __async,
   __objRest,
+  __pow,
   __spreadProps,
   __spreadValues,
   appConfigQueryKey,
-  applyOrderbookDepth,
   computeClosedPositionTotals,
-  createMarketChartData,
   createMarketLiveState,
-  createMarketOrderbookDataFromState,
-  createMarketOrderbookDataFromVenueOrderbooks,
   defaultAggUiConfig,
   executionKeys,
   getBuilder,
   getDepositAddress,
-  getIntervalSeconds,
+  getMarketLiveStore,
   getOrCreateBuilder,
   getWalletAddressFromUserProfile,
   invalidateBalanceQueries,
@@ -48,8 +45,6 @@ import {
   invalidateUserClaimState,
   invalidateUserMoneyState,
   marketDataKeys,
-  marketOrderbookDataToResponse,
-  mergeMarketChartData,
   optimizedImageUrl,
   parseEmail,
   parseEmailStrict,
@@ -60,6 +55,7 @@ import {
   resolveMarketWinningOutcome,
   resolveOrderEligibility,
   resolveTradingStateKind,
+  retinaImageUrl,
   sortVenues,
   tradingReducer,
   useAggAuthContext,
@@ -82,6 +78,7 @@ import {
   useExecuteManaged,
   useExecutionProgress,
   useLabels,
+  useLiveStates,
   useManagedBalances,
   useOnBalanceUpdate,
   useOnOrderEvent,
@@ -101,10 +98,10 @@ import {
   useSyncBalances,
   useWithdrawManaged,
   userActivityQueryKeys
-} from "./chunk-KQ5TOPNY.mjs";
+} from "./chunk-ESDA4NZI.mjs";
 
 // src/index.ts
-import { QueryClient as QueryClient4, QueryClientProvider, useQueryClient as useQueryClient2 } from "@tanstack/react-query";
+import { QueryClient as QueryClient4, QueryClientProvider, useQueryClient as useQueryClient5 } from "@tanstack/react-query";
 import { TurnstileChallengeError } from "@agg-build/sdk";
 
 // src/use-geo-block.ts
@@ -170,9 +167,113 @@ var useVenueKeyStatus = (venue, enabled = true) => {
   });
 };
 
+// src/use-hosted-venue-account.ts
+import { useEffect, useRef } from "react";
+import { useMutation, useQuery as useQuery2, useQueryClient } from "@tanstack/react-query";
+var hostedVenueAccountQueryKeys = {
+  all: ["agg", "hosted-venue-account"],
+  account: (venue, userId, mode) => ["agg", "hosted-venue-account", venue, userId, mode]
+};
+function useHostedVenueAccount(venue, enabled = true) {
+  var _a;
+  const client = useAggClient();
+  const { user, isAuthenticated } = useAggAuthContext();
+  const { executionMode, isResolving } = useResolvedExecutionMode();
+  const queryClient = useQueryClient();
+  const userId = (_a = user == null ? void 0 : user.id) != null ? _a : null;
+  const permitted = enabled && isAuthenticated && userId !== null && !isResolving && executionMode === "live";
+  const queryKey = hostedVenueAccountQueryKeys.account(venue, userId, executionMode);
+  const session = useRef({ client, userId, executionMode, permitted });
+  session.current = { client, userId, executionMode, permitted };
+  const assertSession = () => {
+    const current = session.current;
+    if (!permitted || !current.permitted || current.client !== client || current.userId !== userId || current.executionMode !== executionMode)
+      throw new Error("Hosted custody is unavailable for this session");
+  };
+  const account = useQuery2({
+    queryKey,
+    queryFn: () => {
+      assertSession();
+      return client.getHostedVenueAccount(venue, { mode: executionMode });
+    },
+    enabled: permitted,
+    staleTime: 3e3,
+    refetchInterval: permitted ? 5e3 : false,
+    refetchIntervalInBackground: false,
+    retry: false
+  });
+  const provision = useMutation({
+    mutationFn: (request2) => request2.run(),
+    // Retain the dispatch-time user key even if the observer changes users.
+    onSuccess: (result, request2) => {
+      queryClient.setQueryData(request2.queryKey, result);
+      invalidateBalanceQueries(queryClient);
+    },
+    retry: false
+  });
+  const { reset } = provision;
+  useEffect(() => {
+    reset();
+  }, [userId, executionMode, reset]);
+  const request = () => ({
+    queryKey,
+    run: () => {
+      assertSession();
+      return client.provisionHostedVenueAccount(venue, { mode: "live" });
+    }
+  });
+  return {
+    account,
+    provision: __spreadProps(__spreadValues({}, provision), {
+      mutate: () => provision.mutate(request()),
+      mutateAsync: () => provision.mutateAsync(request())
+    }),
+    isAvailable: permitted
+  };
+}
+
+// src/use-hosted-venue-activity.ts
+import { useEffect as useEffect2, useRef as useRef2 } from "react";
+import { useQuery as useQuery3 } from "@tanstack/react-query";
+function useHostedVenueActivity(venue, page = 0, enabled = true) {
+  var _a;
+  const client = useAggClient();
+  const { user, isAuthenticated } = useAggAuthContext();
+  const { executionMode, isResolving } = useResolvedExecutionMode();
+  const userId = (_a = user == null ? void 0 : user.id) != null ? _a : null;
+  const permitted = enabled && isAuthenticated && userId !== null && !isResolving && executionMode === "live" && Number.isInteger(page) && page >= 0 && page <= 9999;
+  const session = useRef2({ client, userId, executionMode, permitted });
+  session.current = { client, userId, executionMode, permitted };
+  const mounted = useRef2(true);
+  useEffect2(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+    };
+  }, []);
+  const assertSession = () => {
+    const current = session.current;
+    if (!mounted.current || !permitted || !current.permitted || current.client !== client || current.userId !== userId || current.executionMode !== executionMode)
+      throw new Error("Hosted activity is unavailable for this session");
+  };
+  const activity = useQuery3({
+    queryKey: [...hostedVenueAccountQueryKeys.all, "activity", venue, userId, executionMode, page],
+    queryFn: () => __async(null, null, function* () {
+      assertSession();
+      const result = yield client.getHostedVenueActivity(venue, { mode: executionMode, page });
+      assertSession();
+      return result;
+    }),
+    enabled: permitted,
+    staleTime: 3e3,
+    retry: false
+  });
+  return { activity, isAvailable: permitted };
+}
+
 // src/use-shared-kyc.ts
 import { useCallback } from "react";
-import { useQuery as useQuery2 } from "@tanstack/react-query";
+import { useQuery as useQuery4 } from "@tanstack/react-query";
 var sharedKycQueryKeys = {
   status: (userId) => ["agg", "shared-kyc", userId]
 };
@@ -181,7 +282,7 @@ var useSharedKyc = () => {
   const client = useAggClient();
   const { isAuthenticated, user } = useAggAuthContext();
   const userId = (_a = user == null ? void 0 : user.id) != null ? _a : null;
-  const query = useQuery2({
+  const query = useQuery4({
     queryKey: sharedKycQueryKeys.status(userId),
     queryFn: () => client.getSharedKycStatus(),
     enabled: isAuthenticated && userId !== null,
@@ -340,10 +441,10 @@ function useCategoryChildren(options) {
 }
 
 // src/use-debounced-value.ts
-import { useEffect, useState as useState2 } from "react";
+import { useEffect as useEffect3, useState as useState2 } from "react";
 function useDebouncedValue(value, delay) {
   const [debouncedValue, setDebouncedValue] = useState2(value);
-  useEffect(() => {
+  useEffect3(() => {
     const timeoutId = window.setTimeout(() => {
       setDebouncedValue(value);
     }, delay);
@@ -364,11 +465,13 @@ function useExecutionOrders(options = {}) {
     orderType,
     orderId,
     quoteId,
+    venueMarketIds,
     mode,
     limit = 50,
     enabled = true,
     refetchIntervalMs = false
   } = options;
+  const venueMarketIdsKey = (venueMarketIds == null ? void 0 : venueMarketIds.length) ? [...new Set(venueMarketIds)].sort() : null;
   const query = useInfiniteQuery2({
     // quoteId + orderId are part of the cache key — different filters
     // produce different result sets, so they have to vary the key.
@@ -377,16 +480,17 @@ function useExecutionOrders(options = {}) {
       status != null ? status : "all",
       quoteId != null ? quoteId : null,
       orderId != null ? orderId : null,
+      ...venueMarketIdsKey ? [{ venueMarketIds: venueMarketIdsKey }] : [],
       ...orderType ? [orderType] : [],
       ...mode ? [mode] : [],
       limit
     ],
-    queryFn: ({ pageParam }) => client.getExecutionOrders(__spreadProps(__spreadValues({
+    queryFn: ({ pageParam }) => client.getExecutionOrders(__spreadProps(__spreadValues(__spreadValues({
       status,
       orderType,
       orderId,
       quoteId
-    }, mode ? { mode } : {}), {
+    }, venueMarketIdsKey ? { venueMarketIds: venueMarketIdsKey } : {}), mode ? { mode } : {}), {
       limit,
       cursor: pageParam
     })),
@@ -406,6 +510,85 @@ function useExecutionOrders(options = {}) {
   });
 }
 
+// src/use-execution-orders-for-markets.ts
+import { useQueries as useQueries2 } from "@tanstack/react-query";
+import { useMemo } from "react";
+var MAX_ORDER_VENUE_MARKET_IDS_PER_REQUEST = 75;
+var DEFAULT_PAGE_LIMIT = 100;
+var DEFAULT_MAX_PAGES_PER_BATCH = 5;
+var combineBatches = (results) => {
+  var _a, _b;
+  return {
+    orders: results.flatMap((result) => {
+      var _a2, _b2;
+      return (_b2 = (_a2 = result.data) == null ? void 0 : _a2.orders) != null ? _b2 : [];
+    }),
+    isLoading: results.some((result) => result.isLoading),
+    error: (_b = (_a = results.find((result) => result.error)) == null ? void 0 : _a.error) != null ? _b : null,
+    isTruncated: results.some((result) => {
+      var _a2;
+      return ((_a2 = result.data) == null ? void 0 : _a2.hasMore) === true;
+    })
+  };
+};
+var chunk = (items, size) => {
+  const chunks = [];
+  for (let index = 0; index < items.length; index += size) {
+    chunks.push(items.slice(index, index + size));
+  }
+  return chunks;
+};
+function useExecutionOrdersForMarkets({
+  venueMarketIds,
+  status,
+  orderType,
+  mode,
+  limit = DEFAULT_PAGE_LIMIT,
+  maxPagesPerBatch = DEFAULT_MAX_PAGES_PER_BATCH,
+  enabled = true
+}) {
+  const client = useAggClient();
+  const batchKey = [...new Set(venueMarketIds)].sort().join(",");
+  const batches = useMemo(
+    () => batchKey ? chunk(batchKey.split(","), MAX_ORDER_VENUE_MARKET_IDS_PER_REQUEST) : [],
+    [batchKey]
+  );
+  return useQueries2({
+    combine: combineBatches,
+    queries: batches.map((batchVenueMarketIds) => ({
+      queryKey: [
+        "execution-orders",
+        "by-markets",
+        batchVenueMarketIds,
+        status != null ? status : "all",
+        orderType != null ? orderType : null,
+        mode != null ? mode : null,
+        limit,
+        maxPagesPerBatch
+      ],
+      queryFn: () => __async(null, null, function* () {
+        var _a;
+        const orders = [];
+        let cursor;
+        for (let page = 0; page < maxPagesPerBatch; page += 1) {
+          const response = yield client.getExecutionOrders(__spreadValues(__spreadProps(__spreadValues({
+            venueMarketIds: batchVenueMarketIds,
+            status,
+            orderType
+          }, mode ? { mode } : {}), {
+            limit
+          }), cursor ? { cursor } : {}));
+          orders.push(...response.data);
+          cursor = response.hasMore ? (_a = response.nextCursor) != null ? _a : void 0 : void 0;
+          if (!cursor) return { orders, hasMore: false };
+        }
+        return { orders, hasMore: true };
+      }),
+      enabled
+    }))
+  });
+}
+
 // src/use-user-activity.ts
 import { keepPreviousData, useInfiniteQuery as useInfiniteQuery3 } from "@tanstack/react-query";
 var DEFAULT_PENDING_REFETCH_INTERVAL_MS = 15e3;
@@ -532,17 +715,376 @@ function useExecutionPositions(options = {}) {
 }
 
 // src/use-live-candle-overlay.ts
-import { useCallback as useCallback5, useMemo as useMemo4 } from "react";
+import { useCallback as useCallback5, useMemo as useMemo5 } from "react";
 
 // src/use-live-candles.ts
-import { useMemo as useMemo3 } from "react";
+import { useMemo as useMemo4 } from "react";
 import { mergeCandles, mergeClosedCandles } from "@agg-build/sdk";
 
 // src/use-market-chart.ts
-import { keepPreviousData as keepPreviousData2, useQueries as useQueries2 } from "@tanstack/react-query";
+import { keepPreviousData as keepPreviousData2, useQueries as useQueries3, useQueryClient as useQueryClient2 } from "@tanstack/react-query";
+
+// src/read-retry.ts
+import { isAggApiError } from "@agg-build/sdk";
+import { isServer } from "@tanstack/react-query";
+var MAX_TIMER_DELAY_MS = 2147483647;
+var hint = (error) => {
+  if (!isAggApiError(error)) return void 0;
+  const value = error.retryAfterMs;
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+};
+function withReadRetry(options) {
+  return {
+    retry: (failureCount, error) => {
+      var _a, _b;
+      if (((_a = hint(error)) != null ? _a : 0) > MAX_TIMER_DELAY_MS) return false;
+      const retry = (_b = options.retry) != null ? _b : isServer ? 0 : 3;
+      return typeof retry === "function" ? retry(failureCount, error) : retry === true || typeof retry === "number" && failureCount < retry;
+    },
+    retryDelay: (attempt, error) => {
+      var _a, _b;
+      return (_b = hint(error)) != null ? _b : typeof options.retryDelay === "function" ? options.retryDelay(attempt, error) : (_a = options.retryDelay) != null ? _a : Math.min(1e3 * __pow(2, attempt), 3e4);
+    }
+  };
+}
+
+// src/market-data/chart-cache.ts
+var MAX_CACHE_RETENTION_SECONDS = 7 * 30 * 24 * 60 * 60 + 14 * 24 * 60 * 60;
+var getIntervalSeconds = (interval) => {
+  switch (interval) {
+    case "1m":
+      return 60;
+    case "5m":
+      return 5 * 60;
+    case "1h":
+      return 60 * 60;
+    case "1d":
+      return 24 * 60 * 60;
+  }
+};
+var resolveMaxLastUpdateTs = (venues) => {
+  let max = null;
+  for (const venueData of Object.values(venues)) {
+    if (venueData.lastUpdateTs != null && (max == null || venueData.lastUpdateTs > max)) {
+      max = venueData.lastUpdateTs;
+    }
+  }
+  return max;
+};
+var sortCandles = (candles) => {
+  return [...candles].sort((left, right) => left.time - right.time);
+};
+var createMarketChartData = (params) => {
+  var _a;
+  const candles = sortCandles(
+    params.response.data.map((candle) => __spreadProps(__spreadValues({
+      time: Math.floor(candle.t / 1e3),
+      open: candle.o,
+      high: candle.h,
+      low: candle.l,
+      close: candle.c
+    }, Number.isFinite(candle.mean) ? { mean: candle.mean } : {}), {
+      volume: candle.v,
+      source: "rest"
+    }))
+  );
+  const lastCandle = candles[candles.length - 1];
+  const lastUpdateTs = (_a = lastCandle == null ? void 0 : lastCandle.time) != null ? _a : null;
+  const venues = {
+    [params.response.venue]: {
+      venue: params.response.venue,
+      outcomeIds: [params.response.venueMarketOutcomeId],
+      candles,
+      liveCandle: null,
+      lineValue: lastCandle == null ? void 0 : lastCandle.close,
+      lastTrade: null,
+      lastUpdateTs
+    }
+  };
+  return {
+    marketId: params.marketId,
+    delivery: params.response.meta,
+    outcomeIds: [params.response.venueMarketOutcomeId],
+    primaryVenue: params.response.venue,
+    interval: params.interval,
+    startTs: params.startTs,
+    endTs: params.endTs,
+    venues,
+    lastUpdateTs
+  };
+};
+var mergeMarketChartData = (params) => {
+  var _a, _b, _c, _d, _e;
+  if (params.datasets.length === 0) {
+    return null;
+  }
+  const primaryVenue = (_b = (_a = params.datasets[0]) == null ? void 0 : _a.primaryVenue) != null ? _b : "aggregate";
+  const outcomeIds = Array.from(
+    new Set(
+      params.datasets.flatMap((dataset) => {
+        return dataset.outcomeIds.length > 0 ? dataset.outcomeIds : [dataset.marketId];
+      })
+    )
+  );
+  const venues = params.datasets.reduce((acc, dataset) => {
+    for (const [venue, venueData] of Object.entries(dataset.venues)) {
+      const existingVenueData = acc[venue];
+      acc[venue] = existingVenueData ? __spreadProps(__spreadValues({}, venueData), {
+        outcomeIds: Array.from(
+          /* @__PURE__ */ new Set([...existingVenueData.outcomeIds, ...venueData.outcomeIds])
+        )
+      }) : venueData;
+    }
+    return acc;
+  }, {});
+  return {
+    marketId: params.marketId,
+    delivery: (_e = (_c = params.datasets.find((dataset) => dataset.marketId === params.marketId)) == null ? void 0 : _c.delivery) != null ? _e : (_d = params.datasets[0]) == null ? void 0 : _d.delivery,
+    outcomeIds,
+    primaryVenue,
+    interval: params.interval,
+    startTs: params.startTs,
+    endTs: params.endTs,
+    venues,
+    lastUpdateTs: resolveMaxLastUpdateTs(venues)
+  };
+};
+
+// src/market-data/chart-retry-gate.ts
+import { isAggApiError as isAggApiError3 } from "@agg-build/sdk";
+
+// src/market-data/chart-history.ts
+import {
+  loadImmutableHistory,
+  isAggApiError as isAggApiError2
+} from "@agg-build/sdk";
+var ChartDeliveryError = class extends Error {
+  constructor(state, retryAfterMs) {
+    super(`Chart delivery ${state}`);
+    this.state = state;
+    this.retryAfterMs = retryAfterMs;
+    this.name = "ChartDeliveryError";
+  }
+};
+var usable = (response) => {
+  var _a;
+  if (response.data.length === 0 && ((_a = response.meta) == null ? void 0 : _a.state) && response.meta.state !== "empty")
+    throw new ChartDeliveryError(response.meta.state, response.meta.retryAfterMs);
+  return response;
+};
+var withActualFreshness = (response) => {
+  var _a, _b;
+  const serverTime = Number.isFinite(response.meta.serverTime) ? response.meta.serverTime : Date.now();
+  const lastBarOpenTime = (_b = (_a = response.data.at(-1)) == null ? void 0 : _a.t) != null ? _b : null;
+  return __spreadProps(__spreadValues({}, response), {
+    meta: __spreadProps(__spreadValues({}, response.meta), {
+      serverTime,
+      lastBarOpenTime,
+      staleSeconds: lastBarOpenTime == null ? null : Math.max(0, (serverTime - lastBarOpenTime) / 1e3)
+    })
+  });
+};
+function fetchChartHistory(client, socket, request, signal, onInitial) {
+  return __async(this, null, function* () {
+    var _a, _b, _c;
+    const readBars = (params) => __async(null, null, function* () {
+      const response = yield client.getChartBars(params, __spreadValues({
+        signal
+      }, socket ? { decode: (text) => socket.decodeHistory(text) } : {}));
+      signal == null ? void 0 : signal.throwIfAborted();
+      if (response.venueMarketOutcomeId !== request.venueMarketOutcomeId)
+        throw new Error("Chart history identity mismatch");
+      return response;
+    });
+    if (!client.preferImmutableHistory) return usable(yield readBars(request));
+    let verified;
+    try {
+      const manifest2 = yield client.getChartHistoryManifest(request, { signal });
+      if (manifest2.venueMarketOutcomeId !== request.venueMarketOutcomeId)
+        throw new Error("Chart manifest identity mismatch");
+      if (manifest2.meta.complete) {
+        const history2 = yield socket ? socket.loadHistory(manifest2, { signal }) : loadImmutableHistory({ manifest: manifest2, signal });
+        verified = {
+          manifest: manifest2,
+          history: history2.filter(
+            (bar) => (request.from == null || bar.t >= request.from) && bar.t < request.to
+          )
+        };
+      }
+    } catch (error) {
+      if ((signal == null ? void 0 : signal.aborted) || isAggApiError2(error) && (error.status === 429 || error.status === 503))
+        throw error;
+    }
+    signal == null ? void 0 : signal.throwIfAborted();
+    if (!verified) return usable(yield readBars(request));
+    const { manifest, history } = verified;
+    const fullyCovered = manifest.finalizedThrough >= request.to;
+    const initial = withActualFreshness({
+      venueMarketOutcomeId: manifest.venueMarketOutcomeId,
+      venue: manifest.venue,
+      resolution: manifest.resolution,
+      data: history,
+      meta: __spreadProps(__spreadValues({}, manifest.meta), {
+        state: fullyCovered ? history.length ? "ready" : "empty" : "warming",
+        complete: fullyCovered
+      })
+    });
+    if (fullyCovered) return usable(initial);
+    if (history.length > 0) onInitial == null ? void 0 : onInitial(initial);
+    signal == null ? void 0 : signal.throwIfAborted();
+    try {
+      const tail = yield readBars(__spreadProps(__spreadValues({}, request), {
+        resolution: manifest.resolution,
+        from: Math.max((_a = request.from) != null ? _a : 0, manifest.finalizedThrough),
+        countBack: void 0
+      }));
+      if (tail.venue !== manifest.venue || tail.resolution !== manifest.resolution)
+        throw new Error("Chart tail series mismatch");
+      const data = [
+        ...history,
+        ...tail.data.filter((bar) => bar.t >= manifest.finalizedThrough && bar.t < request.to)
+      ];
+      const incomplete = tail.meta.complete === false || ["warming", "failed", "unsupported"].includes((_b = tail.meta.state) != null ? _b : "");
+      return usable(
+        withActualFreshness(__spreadProps(__spreadValues({}, tail), {
+          resolution: manifest.resolution,
+          data,
+          meta: __spreadProps(__spreadValues(__spreadValues({}, initial.meta), tail.meta), {
+            complete: !incomplete,
+            state: incomplete ? (_c = tail.meta.state) != null ? _c : "warming" : data.length ? "ready" : "empty"
+          })
+        }))
+      );
+    } catch (error) {
+      if (signal == null ? void 0 : signal.aborted) throw error;
+      return usable(
+        withActualFreshness(__spreadProps(__spreadValues({}, initial), {
+          meta: __spreadValues(__spreadProps(__spreadValues({}, initial.meta), {
+            state: error instanceof ChartDeliveryError ? error.state : "failed",
+            complete: false
+          }), (error instanceof ChartDeliveryError || isAggApiError2(error)) && error.retryAfterMs != null ? { retryAfterMs: error.retryAfterMs } : {})
+        }))
+      );
+    }
+  });
+}
+
+// src/market-data/chart-retry-gate.ts
+var MAX_TIMER_DELAY_MS2 = 2147483647;
+var notBefore = /* @__PURE__ */ new WeakMap();
+var validDelay = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+function record(query, delay) {
+  if (validDelay(delay) && delay > 0)
+    notBefore.set(query, Math.min(Number.MAX_SAFE_INTEGER, Date.now() + delay));
+  else notBefore.delete(query);
+}
+function chartRetryRemaining(query) {
+  var _a;
+  return Math.max(0, ((_a = notBefore.get(query)) != null ? _a : 0) - Date.now());
+}
+function chartRefetchInterval(query, interval) {
+  if (interval === false) return false;
+  const remaining = chartRetryRemaining(query);
+  return remaining > MAX_TIMER_DELAY_MS2 ? false : Math.max(interval, remaining);
+}
+function waitForDeadline(query, signal) {
+  return __async(this, null, function* () {
+    while (chartRetryRemaining(query) > 0) {
+      signal.throwIfAborted();
+      yield new Promise((resolve, reject) => {
+        const aborted = () => {
+          clearTimeout(timer);
+          signal.removeEventListener("abort", aborted);
+          reject(signal.reason);
+        };
+        const timer = setTimeout(
+          () => {
+            signal.removeEventListener("abort", aborted);
+            resolve();
+          },
+          Math.min(chartRetryRemaining(query), MAX_TIMER_DELAY_MS2)
+        );
+        signal.addEventListener("abort", aborted, { once: true });
+        if (signal.aborted) aborted();
+      });
+    }
+    signal.throwIfAborted();
+  });
+}
+function runChartQuery(query, signal, load) {
+  return __async(this, null, function* () {
+    var _a;
+    yield waitForDeadline(query, signal);
+    try {
+      const data = yield load();
+      signal.throwIfAborted();
+      const delivery = data.delivery;
+      record(
+        query,
+        delivery && delivery.complete !== true && !["ready", "empty"].includes((_a = delivery.state) != null ? _a : "") ? delivery.retryAfterMs : void 0
+      );
+      return data;
+    } catch (error) {
+      if (!signal.aborted) {
+        const delay = isAggApiError3(error) ? error.retryAfterMs : error instanceof ChartDeliveryError && validDelay(error.retryAfterMs) ? error.retryAfterMs : void 0;
+        record(query, delay);
+      }
+      throw error;
+    }
+  });
+}
+
+// src/market-data/chart-tail.ts
+var closedCaches = /* @__PURE__ */ new WeakMap();
+var toChart = (candle) => ({
+  time: candle.openTime,
+  open: candle.o,
+  high: candle.h,
+  low: candle.l,
+  close: candle.c,
+  volume: candle.v,
+  source: "ws"
+});
+function overlayCandleTail(history, live, rolling) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  const tail = (_a = live == null ? void 0 : live.candles) == null ? void 0 : _a[history.interval];
+  const venue = history.venues[history.primaryVenue];
+  if (!tail || !venue || !rolling && history.endTs != null && history.endTs < Date.now())
+    return history;
+  const last = (_c = (_b = venue.candles.at(-1)) == null ? void 0 : _b.time) != null ? _c : -Infinity;
+  const closed = tail.closed.filter((candle) => candle.openTime > last);
+  const key = closed.map((candle) => `${candle.openTime}:${candle.c}:${candle.v}`).join("|");
+  let cached = closedCaches.get(history);
+  if (!cached || cached.key !== key) {
+    cached = {
+      key,
+      candles: closed.length ? [...venue.candles, ...closed.map(toChart)] : venue.candles
+    };
+    closedCaches.set(history, cached);
+  }
+  const forming = tail.forming && tail.forming.openTime >= last ? toChart(tail.forming) : null;
+  const lastSourceTime = Math.max(
+    (_e = (_d = live.orderbook) == null ? void 0 : _d.timestamp) != null ? _e : -Infinity,
+    (_g = (_f = live.trades[0]) == null ? void 0 : _f.timestamp) != null ? _g : -Infinity,
+    (_h = venue.lastUpdateTs) != null ? _h : -Infinity
+  );
+  const lastUpdateTs = Number.isFinite(lastSourceTime) ? lastSourceTime : null;
+  return __spreadProps(__spreadValues({}, history), {
+    lastUpdateTs,
+    venues: __spreadProps(__spreadValues({}, history.venues), {
+      [history.primaryVenue]: __spreadProps(__spreadValues({}, venue), {
+        candles: cached.candles,
+        liveCandle: forming,
+        lineValue: (_i = forming == null ? void 0 : forming.close) != null ? _i : venue.lineValue,
+        lastTrade: (_j = live.trades[0]) != null ? _j : venue.lastTrade,
+        lastUpdateTs
+      })
+    })
+  });
+}
 
 // src/market-data/subscription.ts
-import { useEffect as useEffect2, useMemo } from "react";
+import { useEffect as useEffect4, useMemo as useMemo2 } from "react";
 function useMarketDataSubscription({
   marketId,
   additionalMarketIds,
@@ -551,7 +1093,7 @@ function useMarketDataSubscription({
   trades = false
 }) {
   const ws = useAggWebSocket();
-  const allIds = useMemo(() => {
+  const allIds = useMemo2(() => {
     const ids = /* @__PURE__ */ new Set();
     if (marketId) ids.add(marketId);
     if (additionalMarketIds) {
@@ -562,7 +1104,7 @@ function useMarketDataSubscription({
     return [...ids];
   }, [marketId, additionalMarketIds]);
   const stableKey = allIds.join("|");
-  useEffect2(() => {
+  useEffect4(() => {
     if (!ws || !allIds.length || !enabled || !orderbook && !trades) return;
     const unsubscribers = [];
     for (const id of allIds) {
@@ -584,9 +1126,11 @@ function useMarketDataSubscription({
 }
 
 // src/use-market-chart.ts
-function useMarketChart(options) {
-  var _a, _b, _c;
+function useMarketChartQueries(options) {
+  var _a, _b;
   const client = useAggClient();
+  const queryClient = useQueryClient2();
+  const socket = useAggWebSocket();
   const isConnected = useAggWebSocketConnectionState();
   const {
     features: { enableLiveUpdates }
@@ -594,6 +1138,7 @@ function useMarketChart(options) {
   const {
     marketId,
     venueMarketIds,
+    liveOutcomeIds,
     interval = "5m",
     startTs = null,
     endTs = null,
@@ -601,9 +1146,10 @@ function useMarketChart(options) {
     enabled = true,
     live,
     refetchIntervalMs = null,
+    staleTimeMs,
     rangeKey
   } = options;
-  const resolvedRangeKey = rangeKey != null ? rangeKey : interval;
+  const resolvedRangeKey = rangeKey != null ? rangeKey : `${interval}:${startTs != null ? startTs : "count"}:${endTs != null ? endTs : "unset"}`;
   const liveEnabled = live != null ? live : enableLiveUpdates;
   const outcomeIds = (() => {
     const ids = /* @__PURE__ */ new Set();
@@ -617,72 +1163,197 @@ function useMarketChart(options) {
   })();
   const primaryOutcomeId = (_a = marketId != null ? marketId : venueMarketIds == null ? void 0 : venueMarketIds.find(Boolean)) != null ? _a : null;
   const isQueryEnabled = enabled && outcomeIds.length > 0 && endTs != null && (startTs != null || countBack != null);
+  const subscribedIds = liveOutcomeIds ? outcomeIds.filter((id) => liveOutcomeIds.includes(id)) : outcomeIds;
+  const subscribedPrimaryId = primaryOutcomeId && subscribedIds.includes(primaryOutcomeId) ? primaryOutcomeId : (_b = subscribedIds[0]) != null ? _b : null;
   useMarketDataSubscription({
-    marketId: primaryOutcomeId,
-    additionalMarketIds: outcomeIds.slice(1),
-    enabled: Boolean(isQueryEnabled && liveEnabled),
+    marketId: subscribedPrimaryId,
+    additionalMarketIds: subscribedIds.filter((id) => id !== subscribedPrimaryId),
+    enabled: Boolean(isQueryEnabled && liveEnabled && subscribedIds.length > 0),
     orderbook: true,
     trades: true
   });
-  const queries = useQueries2({
-    queries: outcomeIds.map((outcomeId) => ({
+  const queries = useQueries3({
+    queries: outcomeIds.map((outcomeId) => __spreadProps(__spreadValues({
       // Cache key is intentionally time-free. The rolling window's
       // startTs/endTs advance on every bucket but the user expects the same
       // chart on revisit — see comment on `marketDataKeys.chart`. queryFn
       // closes over the current window so refetches still fetch fresh data.
       queryKey: marketDataKeys.chart(outcomeId, interval, resolvedRangeKey, countBack),
       queryFn: (_0) => __async(null, [_0], function* ({ signal }) {
-        const response = yield client.getChartBars(
-          {
-            venueMarketOutcomeId: outcomeId,
-            resolution: interval,
-            from: startTs != null ? startTs : void 0,
-            to: endTs,
-            countBack: countBack != null ? countBack : void 0
-          },
-          { signal }
-        );
-        return createMarketChartData({
-          marketId: outcomeId,
-          interval,
-          startTs,
-          endTs,
-          response
+        const owner = queryClient.getQueryCache().find({
+          queryKey: marketDataKeys.chart(outcomeId, interval, resolvedRangeKey, countBack),
+          exact: true
         });
+        if (!owner) throw new Error("Chart query was removed before fetching");
+        return runChartQuery(owner, signal, () => __async(null, null, function* () {
+          var _a2;
+          const response = yield fetchChartHistory(
+            client,
+            socket,
+            {
+              venueMarketOutcomeId: outcomeId,
+              resolution: interval,
+              from: startTs != null ? startTs : void 0,
+              to: endTs,
+              countBack: countBack != null ? countBack : void 0
+            },
+            signal,
+            (initial) => {
+              var _a3;
+              if (signal.aborted) return;
+              queryClient.setQueryData(
+                marketDataKeys.chart(outcomeId, interval, resolvedRangeKey, countBack),
+                createMarketChartData({
+                  marketId: outcomeId,
+                  interval: (_a3 = initial.resolution) != null ? _a3 : interval,
+                  startTs,
+                  endTs,
+                  response: initial
+                })
+              );
+            }
+          );
+          return createMarketChartData({
+            marketId: outcomeId,
+            interval: (_a2 = response.resolution) != null ? _a2 : interval,
+            startTs,
+            endTs,
+            response
+          });
+        }));
       }),
       enabled: isQueryEnabled,
+      meta: { chartWindow: rangeKey ? "rolling" : "fixed", chartEndTs: endTs },
       // Treat data as fresh for one bucket — within that window the
       // existing entry serves remounts without a refetch, and the
       // `refetchInterval` below schedules the next bucket's refresh.
-      staleTime: refetchIntervalMs != null && refetchIntervalMs > 0 ? refetchIntervalMs : 3e4,
+      staleTime: (query) => {
+        var _a2;
+        if (rangeKey && endTs != null && ((_a2 = query.state.data) == null ? void 0 : _a2.endTs) != null && query.state.data.endTs < endTs)
+          return 0;
+        return staleTimeMs != null ? staleTimeMs : refetchIntervalMs != null && refetchIntervalMs > 0 ? refetchIntervalMs : 3e4;
+      },
       // 60 min — survives typical tab/page revisits without re-fetching.
       gcTime: 60 * 6e4,
-      refetchOnWindowFocus: false,
-      retry: 1,
+      refetchOnWindowFocus: false
+    }, withReadRetry({
+      retry: (failureCount, error) => {
+        if (error instanceof ChartDeliveryError) {
+          if (error.state === "unsupported") return false;
+          if (error.state === "warming") return failureCount < 8;
+        }
+        return failureCount < 1;
+      },
+      retryDelay: (_attempt, error) => error instanceof ChartDeliveryError && error.retryAfterMs != null ? Math.min(error.state === "warming" ? 1e3 : 5e3, Math.max(0, error.retryAfterMs)) : 1e3
+    })), {
       placeholderData: keepPreviousData2,
-      refetchInterval: refetchIntervalMs != null && refetchIntervalMs > 0 ? refetchIntervalMs : false,
+      refetchInterval: (query) => chartRefetchInterval(
+        query,
+        refetchIntervalMs != null && refetchIntervalMs > 0 ? refetchIntervalMs : false
+      ),
       refetchIntervalInBackground: false
     }))
   });
+  const liveStates = useLiveStates(isQueryEnabled ? outcomeIds : []);
+  const overlaid = queries.map((query, index) => {
+    var _a2, _b2;
+    return __spreadProps(__spreadValues({}, query), {
+      data: ((_a2 = query.data) == null ? void 0 : _a2.marketId) === outcomeIds[index] ? overlayCandleTail(query.data, (_b2 = liveStates[index]) == null ? void 0 : _b2.data, !!rangeKey) : void 0
+    });
+  });
+  const availability = {};
+  if (isQueryEnabled)
+    queries.forEach((query, index) => {
+      var _a2, _b2, _c, _d;
+      const sameOutcome = ((_a2 = query.data) == null ? void 0 : _a2.marketId) === outcomeIds[index];
+      const metadata = sameOutcome ? (_b2 = query.data) == null ? void 0 : _b2.delivery : void 0;
+      const error = query.error;
+      const pending = query.isLoading || query.isPlaceholderData || query.isFetching;
+      const state = error instanceof ChartDeliveryError ? error.state : error ? "failed" : pending || !sameOutcome ? "warming" : (_c = metadata == null ? void 0 : metadata.state) != null ? _c : Object.values(query.data.venues).some(
+        (venue) => venue.candles.length > 0 || venue.liveCandle
+      ) ? "ready" : "empty";
+      availability[outcomeIds[index]] = __spreadValues(__spreadProps(__spreadValues({}, metadata), {
+        state,
+        complete: (state === "ready" || state === "empty") && ((_d = metadata == null ? void 0 : metadata.complete) != null ? _d : true)
+      }), error instanceof ChartDeliveryError && error.retryAfterMs != null ? { retryAfterMs: error.retryAfterMs } : {});
+    });
+  return {
+    queries: overlaid,
+    availability,
+    outcomeIds,
+    primaryOutcomeId,
+    interval,
+    startTs,
+    endTs,
+    isQueryEnabled,
+    liveEnabled: liveEnabled && subscribedIds.length > 0,
+    isConnected
+  };
+}
+function useMarketCharts(options) {
+  const { queries, availability, outcomeIds, isQueryEnabled, liveEnabled, isConnected } = useMarketChartQueries(options);
+  const charts = {};
+  const errors = {};
+  queries.forEach((query, index) => {
+    var _a;
+    const outcomeId = outcomeIds[index];
+    if (((_a = query.data) == null ? void 0 : _a.marketId) === outcomeId && !query.isPlaceholderData)
+      charts[outcomeId] = query.data;
+    if (query.error)
+      errors[outcomeId] = query.error instanceof Error ? query.error : new Error(String(query.error));
+  });
+  return {
+    availability,
+    charts,
+    errors,
+    isLoading: Boolean(
+      isQueryEnabled && queries.some((query) => query.isLoading || query.isPlaceholderData)
+    ),
+    isLive: Boolean(isQueryEnabled && liveEnabled && isConnected),
+    refetch: () => __async(null, null, function* () {
+      return Promise.all(queries.map((query) => query.refetch()));
+    })
+  };
+}
+function useMarketChart(options) {
+  var _a, _b, _c, _d;
+  const {
+    queries,
+    availability,
+    primaryOutcomeId,
+    interval,
+    startTs,
+    endTs,
+    isQueryEnabled,
+    liveEnabled,
+    isConnected
+  } = useMarketChartQueries(options);
   const successfulDatasets = queries.flatMap((query) => {
     return query.data ? [query.data] : [];
   });
   const data = primaryOutcomeId && successfulDatasets.length > 0 ? mergeMarketChartData({
     marketId: primaryOutcomeId,
-    interval,
+    interval: (_b = (_a = successfulDatasets[0]) == null ? void 0 : _a.interval) != null ? _b : interval,
     startTs,
     endTs,
     datasets: successfulDatasets
   }) : null;
-  const hasPendingQuery = queries.some((query) => query.isLoading);
-  const firstError = (_c = (_b = queries.find((query) => query.error != null)) == null ? void 0 : _b.error) != null ? _c : null;
+  const hasPendingQuery = queries.some((query) => query.isLoading || query.isPlaceholderData);
+  const firstError = (_d = (_c = queries.find((query) => query.error != null)) == null ? void 0 : _c.error) != null ? _d : null;
   const error = data == null && !hasPendingQuery ? firstError instanceof Error ? firstError : firstError ? new Error(String(firstError)) : null : null;
-  const isLoading = Boolean(isQueryEnabled && data == null && hasPendingQuery);
+  const isInRange = (candle) => (startTs == null || candle.time >= startTs / 1e3) && (endTs == null || candle.time <= endTs / 1e3);
+  const hasVisibleHistory = queries.some(
+    (query) => !query.isPlaceholderData && query.data && Object.entries(query.data.venues).some(
+      ([venueName, venue]) => (!options.visibleVenue || venueName === options.visibleVenue) && (venue.candles.some(isInRange) || venue.liveCandle != null && isInRange(venue.liveCandle))
+    )
+  );
+  const isLoading = Boolean(isQueryEnabled && hasPendingQuery && !hasVisibleHistory);
   return {
     data,
+    availability,
     isLoading,
     error,
-    isLive: Boolean(liveEnabled && primaryOutcomeId && isConnected),
+    isLive: Boolean(isQueryEnabled && liveEnabled && primaryOutcomeId && isConnected),
     refetch: () => __async(null, null, function* () {
       return Promise.all(queries.map((query) => query.refetch()));
     })
@@ -690,13 +1361,13 @@ function useMarketChart(options) {
 }
 
 // src/use-live-market-stores.ts
-import { useEffect as useEffect3, useMemo as useMemo2, useReducer, useRef } from "react";
+import { useEffect as useEffect5, useMemo as useMemo3, useReducer, useRef as useRef3 } from "react";
 function useLiveMarketStores(venueMarketIds) {
   const ws = useAggWebSocket();
   const [, forceRender] = useReducer((c) => c + 1, 0);
-  const subsRef = useRef(/* @__PURE__ */ new Map());
-  const stableKey = useMemo2(() => venueMarketIds.slice().sort().join("|"), [venueMarketIds]);
-  useEffect3(() => {
+  const subsRef = useRef3(/* @__PURE__ */ new Map());
+  const stableKey = useMemo3(() => venueMarketIds.slice().sort().join("|"), [venueMarketIds]);
+  useEffect5(() => {
     if (!ws || venueMarketIds.length === 0) return;
     const current = subsRef.current;
     const desired = new Set(venueMarketIds);
@@ -733,7 +1404,7 @@ function candleToLive(c, source) {
 function useLiveCandles(options) {
   var _a;
   const { market, interval = "5m", mode = "venue", startTs, endTs } = options;
-  const venueMarketIds = useMemo3(() => {
+  const venueMarketIds = useMemo4(() => {
     if (!market) return [];
     if (mode === "venue") return [market.id];
     const ids = [market.id];
@@ -753,7 +1424,7 @@ function useLiveCandles(options) {
     endTs: endTs != null ? endTs : null,
     enabled: !!restMarketId && startTs != null && endTs != null
   });
-  const liveData = useMemo3(() => {
+  const liveData = useMemo4(() => {
     if (builders.length === 0) return { closed: [], forming: null };
     if (mode === "venue" || builders.length === 1) {
       return {
@@ -766,7 +1437,7 @@ function useLiveCandles(options) {
       forming: mergeCandles(builders.map((b) => b.getForming(interval)))
     };
   }, [builders, interval, mode]);
-  const candles = useMemo3(() => {
+  const candles = useMemo4(() => {
     const byTime = /* @__PURE__ */ new Map();
     if (chartData) {
       const venueEntries = Object.values(chartData.venues);
@@ -791,7 +1462,7 @@ function useLiveCandles(options) {
     merged.sort((a, b) => a.time - b.time);
     return merged;
   }, [chartData, liveData.closed]);
-  const liveCandle = useMemo3(() => {
+  const liveCandle = useMemo4(() => {
     if (!liveData.forming) return null;
     return candleToLive(liveData.forming, "live");
   }, [liveData.forming]);
@@ -850,8 +1521,8 @@ function useLiveCandleOverlay(options) {
     }),
     [scale]
   );
-  const scaledCandles = useMemo4(() => rawCandles.map(scaleCandle), [rawCandles, scaleCandle]);
-  const liveCandle = useMemo4(() => rawLive ? scaleCandle(rawLive) : null, [rawLive, scaleCandle]);
+  const scaledCandles = useMemo5(() => rawCandles.map(scaleCandle), [rawCandles, scaleCandle]);
+  const liveCandle = useMemo5(() => rawLive ? scaleCandle(rawLive) : null, [rawLive, scaleCandle]);
   return {
     liveCandle,
     scaledCandles,
@@ -862,7 +1533,7 @@ function useLiveCandleOverlay(options) {
 }
 
 // src/use-event-orderbook-data.ts
-import { useEffect as useEffect4, useMemo as useMemo5 } from "react";
+import { useEffect as useEffect6, useMemo as useMemo6 } from "react";
 function extractSelectedOutcomeIds(selectedMarket) {
   var _a, _b, _c;
   if (!selectedMarket) return [];
@@ -882,17 +1553,17 @@ function useEventOrderbookData(venueMarkets, selectedMarketId) {
   const {
     features: { enableLiveUpdates }
   } = useAggUiConfig();
-  const selectedMarket = useMemo5(() => {
+  const selectedMarket = useMemo6(() => {
     var _a;
     if (!selectedMarketId || !(venueMarkets == null ? void 0 : venueMarkets.length)) return null;
     return (_a = venueMarkets.find((m) => m.id === selectedMarketId)) != null ? _a : null;
   }, [venueMarkets, selectedMarketId]);
-  const selectedOutcomeIds = useMemo5(
+  const selectedOutcomeIds = useMemo6(
     () => extractSelectedOutcomeIds(selectedMarket),
     [selectedMarket]
   );
   const selectedKey = selectedOutcomeIds.join("|");
-  useEffect4(() => {
+  useEffect6(() => {
     if (!ws || !enableLiveUpdates || !selectedOutcomeIds.length) return;
     const unsubscribers = selectedOutcomeIds.map((id) => ws.subscribe(id, "orderbook"));
     return () => {
@@ -901,8 +1572,11 @@ function useEventOrderbookData(venueMarkets, selectedMarketId) {
   }, [ws, selectedKey, enableLiveUpdates]);
 }
 
-// src/use-live-market.ts
-import { useQuery as useQuery3 } from "@tanstack/react-query";
+// src/use-market-orderbook.ts
+import { useQuery as useQuery5, useQueryClient as useQueryClient3 } from "@tanstack/react-query";
+
+// src/market-data/orderbook-snapshot.ts
+var orderbookTimestampSeconds = (timestamp) => timestamp >= 1e12 ? timestamp / 1e3 : timestamp;
 function outcomeOrderbookToState(response, marketId) {
   var _a, _b, _c, _d;
   const { venue, orderbook, midpoint, spread, seq, checksum, timestamp, venueMarketOutcomeId } = response;
@@ -936,56 +1610,351 @@ function outcomeOrderbookToState(response, marketId) {
     spread,
     seq,
     checksum,
-    timestamp
+    timestamp: orderbookTimestampSeconds(timestamp)
+  };
+}
+
+// src/market-data/orderbook-cache.ts
+var truncateLevels = (levels, depth) => {
+  if (depth == null) return levels;
+  return levels.slice(0, Math.max(0, depth));
+};
+var truncateVenueOrderbooks = (venueOrderbooks, depth) => {
+  if (depth == null) return venueOrderbooks;
+  return Object.fromEntries(
+    Object.entries(venueOrderbooks).map(([venue, book]) => [
+      venue,
+      {
+        bids: truncateLevels(book.bids, depth),
+        asks: truncateLevels(book.asks, depth)
+      }
+    ])
+  );
+};
+var aggregateVenueLevels = (venueOrderbooks, side) => {
+  var _a;
+  const levelsByPrice = /* @__PURE__ */ new Map();
+  for (const [venue, orderbook] of Object.entries(venueOrderbooks)) {
+    for (const level of orderbook[side]) {
+      const currentLevel = levelsByPrice.get(level.price);
+      if (currentLevel) {
+        currentLevel.size += level.size;
+        currentLevel.venues[venue] = ((_a = currentLevel.venues[venue]) != null ? _a : 0) + level.size;
+        continue;
+      }
+      levelsByPrice.set(level.price, {
+        price: level.price,
+        size: level.size,
+        venues: {
+          [venue]: level.size
+        }
+      });
+    }
+  }
+  return [...levelsByPrice.values()].sort(
+    (left, right) => side === "bids" ? right.price - left.price : left.price - right.price
+  );
+};
+var createMarketOrderbookDataFromVenueOrderbooks = ({
+  marketId,
+  venueOrderbooks,
+  timestamp = Math.floor(Date.now() / 1e3)
+}) => {
+  var _a, _b, _c, _d;
+  const bids = aggregateVenueLevels(venueOrderbooks, "bids");
+  const asks = aggregateVenueLevels(venueOrderbooks, "asks");
+  const bestBid = (_b = (_a = bids[0]) == null ? void 0 : _a.price) != null ? _b : null;
+  const bestAsk = (_d = (_c = asks[0]) == null ? void 0 : _c.price) != null ? _d : null;
+  return {
+    marketId,
+    orderbook: {
+      bids,
+      asks
+    },
+    venueOrderbooks,
+    venues: Object.fromEntries(
+      Object.entries(venueOrderbooks).map(([venue, orderbook]) => {
+        var _a2, _b2, _c2, _d2;
+        return [
+          venue,
+          {
+            bestBid: (_b2 = (_a2 = orderbook.bids[0]) == null ? void 0 : _a2.price) != null ? _b2 : null,
+            bestAsk: (_d2 = (_c2 = orderbook.asks[0]) == null ? void 0 : _c2.price) != null ? _d2 : null
+          }
+        ];
+      })
+    ),
+    midpoint: bestBid != null && bestAsk != null ? (bestBid + bestAsk) / 2 : null,
+    spread: bestBid != null && bestAsk != null ? bestAsk - bestBid : null,
+    timestamp,
+    snapshotVersion: 0,
+    integrity: "ok"
+  };
+};
+var createMarketOrderbookDataFromState = (state, options) => {
+  var _a;
+  return {
+    marketId: state.marketId,
+    orderbook: {
+      bids: state.bids,
+      asks: state.asks
+    },
+    venueOrderbooks: state.venueOrderbooks,
+    venues: state.venues,
+    midpoint: state.midpoint,
+    spread: state.spread,
+    timestamp: state.timestamp,
+    snapshotVersion: (_a = options == null ? void 0 : options.snapshotVersion) != null ? _a : 0,
+    seq: state.seq,
+    checksum: state.checksum,
+    integrity: "ok"
+  };
+};
+var marketOrderbookDataToResponse = (data) => {
+  return {
+    venueMarketId: data.marketId,
+    orderbook: data.orderbook,
+    venueOrderbooks: data.venueOrderbooks,
+    venues: data.venues,
+    midpoint: data.midpoint,
+    spread: data.spread,
+    timestamp: data.timestamp,
+    seq: data.seq,
+    checksum: data.checksum,
+    matchedMarkets: data.matchedMarkets
+  };
+};
+var applyOrderbookDepth = (data, depth) => {
+  if (depth == null) return data;
+  return __spreadProps(__spreadValues({}, data), {
+    orderbook: {
+      bids: truncateLevels(data.orderbook.bids, depth),
+      asks: truncateLevels(data.orderbook.asks, depth)
+    },
+    venueOrderbooks: truncateVenueOrderbooks(data.venueOrderbooks, depth)
+  });
+};
+
+// src/market-data/snapshot-selection.ts
+import { computeChecksum } from "@agg-build/sdk";
+var SOCKET_GRACE_MS = 200;
+var REST_BUDGET_MS = 1500;
+var MAX_SEED_AGE_MS = 5e3;
+function hasFreshSnapshot(store, id, now = Date.now()) {
+  const state = store.get(id);
+  return !!state.orderbook && state.integrity === "ok" && now - state.orderbook.timestamp * 1e3 <= MAX_SEED_AGE_MS && state.orderbook.timestamp * 1e3 <= now + 1e3;
+}
+function createOrderbookSnapshotQuery(client, store, ids, socketHealthy) {
+  return fetchSnapshotQuery.bind(null, client, store, ids, socketHealthy);
+}
+function fetchSnapshotQuery(client, store, ids, socketHealthy, { signal }) {
+  return selectOrderbookSnapshots(client, store, ids, socketHealthy, signal);
+}
+function selectOrderbookSnapshots(client, store, ids, socketHealthy, signal) {
+  return __async(this, null, function* () {
+    if (ids.length > 100) throw new Error("Orderbook snapshot batch exceeds 100 outcomes");
+    const missing = () => ids.filter((id) => !hasFreshSnapshot(store, id));
+    if (!missing().length || signal.aborted) return {};
+    if (socketHealthy) {
+      yield new Promise((resolve) => {
+        let unsubscribe2 = () => {
+        };
+        const finish = () => {
+          clearTimeout(timer2);
+          unsubscribe2();
+          signal.removeEventListener("abort", finish);
+          resolve();
+        };
+        const timer2 = setTimeout(finish, SOCKET_GRACE_MS);
+        unsubscribe2 = store.subscribe(ids, () => {
+          if (!missing().length) finish();
+        });
+        signal.addEventListener("abort", finish, { once: true });
+      });
+    }
+    const requested = missing();
+    if (!requested.length || signal.aborted) return {};
+    const initialStates = new Map(requested.map((id) => [id, store.get(id)]));
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    signal.addEventListener("abort", abort, { once: true });
+    const timer = setTimeout(abort, REST_BUDGET_MS);
+    const unsubscribe = store.subscribe(requested, () => {
+      if (!missing().length) controller.abort();
+    });
+    try {
+      const response = yield client.getOutcomeOrderbooks(
+        { venueMarketOutcomeIds: requested },
+        { signal: controller.signal }
+      );
+      if (signal.aborted) return {};
+      return Object.fromEntries(
+        response.data.flatMap((book, index) => {
+          const id = requested[index];
+          if (!book || !id || hasFreshSnapshot(store, id)) return [];
+          if (book.venueMarketOutcomeId !== id)
+            throw new Error("Orderbook snapshot identity mismatch");
+          if (!Number.isFinite(book.timestamp) || !Number.isSafeInteger(book.seq) || book.seq < 0 || !Number.isInteger(book.checksum))
+            throw new Error("Invalid orderbook snapshot metadata");
+          const snapshot = outcomeOrderbookToState(book, id);
+          if (![...snapshot.bids, ...snapshot.asks].every(
+            (level) => Number.isFinite(level.price) && Number.isFinite(level.size) && level.size >= 0
+          ))
+            throw new Error("Invalid orderbook snapshot levels");
+          const projectedChecksum = book.snapshotChecksum;
+          if (projectedChecksum != null && computeChecksum(snapshot) !== projectedChecksum)
+            throw new Error("Orderbook snapshot checksum mismatch");
+          const current = store.get(id);
+          const live = current.orderbook;
+          const initial = initialStates.get(id);
+          const initialBook = initial.orderbook;
+          if (current.orderbookSnapshotVersion !== initial.orderbookSnapshotVersion || !!live !== !!initialBook || live && initialBook && (live.seq !== initialBook.seq || live.checksum !== initialBook.checksum || live.timestamp !== initialBook.timestamp))
+            return [];
+          if (live) {
+            const sameGeneration = current.isConnected && current.integrity === "ok" && current.orderbookGeneration === current.connectionGeneration;
+            if (snapshot.timestamp < live.timestamp || sameGeneration && snapshot.seq <= live.seq)
+              return [];
+            if (!sameGeneration && snapshot.timestamp <= live.timestamp) return [];
+          }
+          store.update(id, (previous) => __spreadProps(__spreadValues({}, previous), {
+            orderbook: snapshot,
+            integrity: "ok",
+            orderbookError: null
+          }));
+          return [[id, book]];
+        })
+      );
+    } catch (error) {
+      if (signal.aborted || !missing().length) return {};
+      throw error;
+    } finally {
+      clearTimeout(timer);
+      unsubscribe();
+      signal.removeEventListener("abort", abort);
+    }
+  });
+}
+
+// src/use-market-orderbook.ts
+function useMarketOrderbook(options) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const queryClient = useQueryClient3();
+  const client = useAggClient();
+  const ws = useAggWebSocket();
+  const isConnected = useAggWebSocketConnectionState();
+  const {
+    features: { enableLiveUpdates }
+  } = useAggUiConfig();
+  const { venueMarketOutcomeId, marketId, depth, enabled = true, venueOutcomes, live } = options;
+  const selectedId = (_a = venueMarketOutcomeId != null ? venueMarketOutcomeId : marketId) != null ? _a : null;
+  const liveEnabled = live != null ? live : enableLiveUpdates;
+  const outcomeIds = venueOutcomes == null ? void 0 : venueOutcomes.map((v) => v.venueMarketOutcomeId).filter(Boolean);
+  const subscriptionIds = (outcomeIds == null ? void 0 : outcomeIds.length) ? [...new Set(outcomeIds)] : selectedId ? [selectedId] : [];
+  const selectedOutcomeId = (_b = subscriptionIds[0]) != null ? _b : null;
+  useMarketDataSubscription({
+    marketId: selectedOutcomeId,
+    additionalMarketIds: subscriptionIds.slice(1),
+    enabled: enabled && !!selectedOutcomeId,
+    orderbook: true
+  });
+  const store = getMarketLiveStore(queryClient);
+  const liveQueries = useLiveStates(enabled ? subscriptionIds : []);
+  const sortedIds = [...subscriptionIds].sort();
+  const preferSocket = enabled && Boolean(ws) && (isConnected || subscriptionIds.every((id) => {
+    var _a2;
+    return ((_a2 = store.get(id).connectionGeneration) != null ? _a2 : 0) === 0;
+  }));
+  const seedQuery = useQuery5({
+    queryKey: ["market-orderbook-seed", sortedIds],
+    queryFn: createOrderbookSnapshotQuery(client, store, sortedIds, preferSocket),
+    enabled: enabled && subscriptionIds.length > 0,
+    staleTime: 5e3,
+    gcTime: 6e4,
+    refetchOnWindowFocus: false,
+    retry: false
+  });
+  const liveStates = subscriptionIds.map((subscriptionId, index) => {
+    var _a2, _b2, _c2;
+    return (_c2 = (_b2 = (_a2 = liveQueries[index]) == null ? void 0 : _a2.data) != null ? _b2 : store.peek(subscriptionId)) != null ? _c2 : createMarketLiveState(subscriptionId);
+  });
+  const seededOrderbooks = subscriptionIds.map((subscriptionId, index) => {
+    var _a2, _b2, _c2, _d2;
+    const liveBook = (_b2 = (_a2 = liveStates[index]) == null ? void 0 : _a2.orderbook) != null ? _b2 : null;
+    if (liveBook) return liveBook;
+    const seed = (_c2 = seedQuery.data) == null ? void 0 : _c2[subscriptionId];
+    return ((_d2 = seed == null ? void 0 : seed.orderbook) == null ? void 0 : _d2.bids) && seed.orderbook.asks ? outcomeOrderbookToState(seed, subscriptionId) : null;
+  });
+  const primaryOrderbook = (_c = seededOrderbooks[0]) != null ? _c : null;
+  const primarySnapshotVersion = (_e = (_d = liveStates[0]) == null ? void 0 : _d.orderbookSnapshotVersion) != null ? _e : 0;
+  const data = primaryOrderbook ? applyOrderbookDepth(
+    createMarketOrderbookDataFromState(primaryOrderbook, {
+      snapshotVersion: primarySnapshotVersion
+    }),
+    depth
+  ) : null;
+  const dataById = Object.fromEntries(
+    seededOrderbooks.flatMap((orderbook, index) => {
+      var _a2;
+      if (!orderbook) return [];
+      return [
+        [
+          subscriptionIds[index],
+          applyOrderbookDepth(
+            createMarketOrderbookDataFromState(orderbook, {
+              snapshotVersion: (_a2 = liveStates[index]) == null ? void 0 : _a2.orderbookSnapshotVersion
+            }),
+            depth
+          )
+        ]
+      ];
+    })
+  );
+  const hasAnyOrderbook = seededOrderbooks.some((orderbook) => orderbook != null);
+  const seedLoading = seedQuery.isLoading;
+  const liveOrderbookErrorMessage = enabled && liveEnabled && !hasAnyOrderbook ? (_g = (_f = liveStates.find(
+    (liveState) => typeof liveState.orderbookError === "string" && liveState.orderbookError.length > 0
+  )) == null ? void 0 : _f.orderbookError) != null ? _g : null : null;
+  return {
+    data,
+    dataById,
+    isLoading: enabled && !hasAnyOrderbook && liveOrderbookErrorMessage == null && seedLoading,
+    error: liveOrderbookErrorMessage ? new Error(liveOrderbookErrorMessage) : !hasAnyOrderbook && seedQuery.error instanceof Error ? seedQuery.error : null,
+    isLive: Boolean(enabled && liveEnabled && selectedOutcomeId && isConnected),
+    refetch: () => __async(null, null, function* () {
+      if (!enabled) return;
+      if (subscriptionIds.length === 0) return;
+      subscriptionIds.forEach(
+        (subscriptionId) => store.update(subscriptionId, (previous) => __spreadProps(__spreadValues({}, previous), { orderbookError: null }))
+      );
+      ws == null ? void 0 : ws.resnapshot(subscriptionIds);
+      return seedQuery.refetch();
+    })
   };
 }
+
+// src/use-live-market.ts
 function useLiveMarket(canonicalMarketId) {
-  var _a, _b;
-  const client = useAggClient();
-  const isConnected = useAggWebSocketConnectionState();
   const {
     features: { enableLiveUpdates }
   } = useAggUiConfig();
-  const isLiveSubscriptionEnabled = Boolean(canonicalMarketId && enableLiveUpdates);
-  useMarketDataSubscription({
-    marketId: canonicalMarketId,
-    enabled: isLiveSubscriptionEnabled,
-    orderbook: true
-  });
-  const query = useQuery3({
-    queryKey: marketDataKeys.live(canonicalMarketId != null ? canonicalMarketId : "__disabled__"),
-    queryFn: () => __async(null, null, function* () {
-      return createMarketLiveState(canonicalMarketId != null ? canonicalMarketId : "__disabled__");
-    }),
-    enabled: false,
-    staleTime: Infinity,
-    gcTime: 5 * 6e4,
-    initialData: () => createMarketLiveState(canonicalMarketId != null ? canonicalMarketId : "__disabled__", {
-      isConnected: Boolean(isLiveSubscriptionEnabled && isConnected)
-    })
-  });
-  const seedQuery = useQuery3({
-    queryKey: ["live-market-seed", canonicalMarketId],
-    queryFn: ({ signal }) => canonicalMarketId ? client.getOutcomeOrderbook(canonicalMarketId, { signal }) : Promise.resolve(null),
-    enabled: Boolean(canonicalMarketId),
-    staleTime: 5e3,
-    gcTime: 6e4,
-    refetchOnWindowFocus: false,
-    retry: 1
+  const connected = useAggWebSocketConnectionState();
+  const [snapshot] = useLiveStates([canonicalMarketId != null ? canonicalMarketId : "__disabled__"]);
+  useMarketOrderbook({
+    venueMarketOutcomeId: canonicalMarketId,
+    enabled: !!canonicalMarketId,
+    live: enableLiveUpdates
   });
-  const data = (_a = query.data) != null ? _a : createMarketLiveState(canonicalMarketId != null ? canonicalMarketId : "__disabled__");
-  const orderbook = (_b = data.orderbook) != null ? _b : canonicalMarketId && seedQuery.data ? outcomeOrderbookToState(seedQuery.data, canonicalMarketId) : null;
+  const data = snapshot.data;
   return {
-    orderbook,
+    orderbook: data.orderbook,
     trades: data.trades,
-    isConnected: isLiveSubscriptionEnabled ? data.isConnected : false,
+    isConnected: !!canonicalMarketId && enableLiveUpdates && connected,
     integrity: data.integrity
   };
 }
 
 // src/use-live-outcome-prices.ts
-import { useMemo as useMemo6, useRef as useRef2 } from "react";
-import { useQueries as useQueries3 } from "@tanstack/react-query";
+import { useMemo as useMemo7, useRef as useRef4 } from "react";
 var EMPTY_PRICES = /* @__PURE__ */ new Map();
 var buildMidpointFingerprint = (outcomeIds, queries) => {
   var _a, _b, _c;
@@ -1000,7 +1969,7 @@ function useLiveOutcomePrices(venueMarkets) {
   const {
     features: { enableLiveUpdates }
   } = useAggUiConfig();
-  const outcomeIds = useMemo6(() => {
+  const outcomeIds = useMemo7(() => {
     var _a, _b;
     if (!(venueMarkets == null ? void 0 : venueMarkets.length)) return [];
     const ids = /* @__PURE__ */ new Set();
@@ -1014,22 +1983,13 @@ function useLiveOutcomePrices(venueMarkets) {
     }
     return [...ids].sort();
   }, [venueMarkets]);
-  const queries = useQueries3({
-    queries: outcomeIds.map((id) => ({
-      queryKey: marketDataKeys.live(id),
-      queryFn: () => createMarketLiveState(id),
-      enabled: false,
-      staleTime: Infinity,
-      gcTime: 5 * 6e4,
-      initialData: () => createMarketLiveState(id)
-    }))
-  });
+  const queries = useLiveStates(outcomeIds);
   const fingerprint = buildMidpointFingerprint(outcomeIds, queries);
-  const prevRef = useRef2({
+  const prevRef = useRef4({
     fingerprint: "",
     prices: EMPTY_PRICES
   });
-  const data = useMemo6(() => {
+  const data = useMemo7(() => {
     var _a, _b, _c;
     if (!(venueMarkets == null ? void 0 : venueMarkets.length)) return EMPTY_PRICES;
     if (fingerprint === prevRef.current.fingerprint) {
@@ -1056,8 +2016,7 @@ function findLivePriceById(livePrices, id) {
 }
 
 // src/use-live-best-prices.ts
-import { useMemo as useMemo7, useRef as useRef3 } from "react";
-import { useQueries as useQueries4 } from "@tanstack/react-query";
+import { useMemo as useMemo8, useRef as useRef5 } from "react";
 var EMPTY = /* @__PURE__ */ new Map();
 var EMPTY_CANDIDATES = /* @__PURE__ */ new Map();
 var extractOutcomeBestPrices = (state) => {
@@ -1086,7 +2045,7 @@ function useLiveBestPrices(venueMarkets) {
   const {
     features: { enableLiveUpdates }
   } = useAggUiConfig();
-  const outcomeIds = useMemo7(() => {
+  const outcomeIds = useMemo8(() => {
     var _a, _b;
     if (!(venueMarkets == null ? void 0 : venueMarkets.length)) return [];
     const ids = /* @__PURE__ */ new Set();
@@ -1100,22 +2059,13 @@ function useLiveBestPrices(venueMarkets) {
     }
     return [...ids].sort();
   }, [venueMarkets]);
-  const queries = useQueries4({
-    queries: outcomeIds.map((id) => ({
-      queryKey: marketDataKeys.live(id),
-      queryFn: () => createMarketLiveState(id),
-      enabled: false,
-      staleTime: Infinity,
-      gcTime: 5 * 6e4,
-      initialData: () => createMarketLiveState(id)
-    }))
-  });
+  const queries = useLiveStates(outcomeIds);
   const fingerprint = buildFingerprint(outcomeIds, queries);
-  const prevRef = useRef3({
+  const prevRef = useRef5({
     fingerprint: "",
     result: EMPTY
   });
-  return useMemo7(() => {
+  return useMemo8(() => {
     var _a, _b, _c, _d;
     if (!(venueMarkets == null ? void 0 : venueMarkets.length) || !enableLiveUpdates) return EMPTY;
     if (fingerprint === prevRef.current.fingerprint) return prevRef.current.result;
@@ -1305,7 +2255,7 @@ function useLiveBestPriceCandidates(venueMarkets) {
   const {
     features: { enableLiveUpdates }
   } = useAggUiConfig();
-  const outcomeIds = useMemo7(() => {
+  const outcomeIds = useMemo8(() => {
     var _a, _b;
     if (!(venueMarkets == null ? void 0 : venueMarkets.length)) return [];
     const ids = /* @__PURE__ */ new Set();
@@ -1319,22 +2269,13 @@ function useLiveBestPriceCandidates(venueMarkets) {
     }
     return [...ids].sort();
   }, [venueMarkets]);
-  const queries = useQueries4({
-    queries: outcomeIds.map((id) => ({
-      queryKey: marketDataKeys.live(id),
-      queryFn: () => createMarketLiveState(id),
-      enabled: false,
-      staleTime: Infinity,
-      gcTime: 5 * 6e4,
-      initialData: () => createMarketLiveState(id)
-    }))
-  });
+  const queries = useLiveStates(outcomeIds);
   const fingerprint = buildCandidateFingerprint(outcomeIds, queries);
-  const prevRef = useRef3({
+  const prevRef = useRef5({
     fingerprint: "",
     result: EMPTY_CANDIDATES
   });
-  return useMemo7(() => {
+  return useMemo8(() => {
     if (!(venueMarkets == null ? void 0 : venueMarkets.length) || !enableLiveUpdates) return EMPTY_CANDIDATES;
     if (fingerprint === prevRef.current.fingerprint) return prevRef.current.result;
     const states = outcomeIds.map((_, i) => {
@@ -1363,8 +2304,8 @@ function useLiveTrades(canonicalMarketId) {
 }
 
 // src/use-midpoints.ts
-import { useQuery as useQuery4 } from "@tanstack/react-query";
-import { useMemo as useMemo8 } from "react";
+import { useQuery as useQuery6 } from "@tanstack/react-query";
+import { useMemo as useMemo9 } from "react";
 var normalizeVenueMarketIds = (venueMarkets) => {
   var _a;
   const ids = /* @__PURE__ */ new Set();
@@ -1376,6 +2317,21 @@ var normalizeVenueMarketIds = (venueMarkets) => {
   }
   return [...ids].sort((left, right) => left.localeCompare(right));
 };
+var EMPTY_MIDPOINTS_POLL_MS = 5e3;
+var EMPTY_MIDPOINTS_MAX_FETCHES = 12;
+var hasUsableMidpoint = (item) => {
+  var _a;
+  if (!item) return false;
+  if (item.midpoint != null) return true;
+  return ((_a = item.outcomes) != null ? _a : []).some(
+    (outcome) => outcome.midpoint != null || outcome.bestBid != null || outcome.bestAsk != null
+  );
+};
+var isMidpointResponseComplete = (data, primaryVenueMarketIds) => {
+  if (!(data == null ? void 0 : data.data)) return false;
+  const itemByMarketId = new Map(data.data.map((item) => [item.venueMarketId, item]));
+  return primaryVenueMarketIds.every((id) => hasUsableMidpoint(itemByMarketId.get(id)));
+};
 var normalizeOutcomeLabel = (label) => {
   return typeof label === "string" ? label.trim().toLowerCase() : "";
 };
@@ -1537,22 +2493,30 @@ function useMidpoints(venueMarkets, options) {
     market: { maxMidpointIdsPerRequest: configuredMaxMidpointIdsPerRequest }
   } = useAggUiConfig();
   const maxMidpointIdsPerRequest = (_a = options == null ? void 0 : options.maxMidpointIdsPerRequest) != null ? _a : configuredMaxMidpointIdsPerRequest;
-  const ids = useMemo8(() => normalizeVenueMarketIds(venueMarkets), [venueMarkets]);
-  const bestMidpointCandidateOutcomeIds = useMemo8(
+  const ids = useMemo9(() => normalizeVenueMarketIds(venueMarkets), [venueMarkets]);
+  const bestMidpointCandidateOutcomeIds = useMemo9(
     () => resolveBestMidpointCandidateOutcomeIds(venueMarkets),
     [venueMarkets]
   );
-  const { data, isLoading } = useQuery4({
+  const primaryVenueMarketIds = useMemo9(
+    () => (venueMarkets != null ? venueMarkets : []).map((market) => market.id).filter(Boolean),
+    [venueMarkets]
+  );
+  const { data, isLoading } = useQuery6({
     queryKey: ["midpoints", ids, maxMidpointIdsPerRequest],
     queryFn: () => client.getMidpoints(ids, { bestPrice: true, maxMidpointIdsPerRequest }),
     enabled: ids.length > 0,
-    staleTime: Infinity,
+    // Complete responses stay cached for the session (unchanged behavior).
+    // Incomplete ones are stale, so a remount refetches them and a short,
+    // bounded poll picks up prices once a cold venue book warms.
+    staleTime: (query) => isMidpointResponseComplete(query.state.data, primaryVenueMarketIds) ? Infinity : 0,
+    refetchInterval: (query) => !isMidpointResponseComplete(query.state.data, primaryVenueMarketIds) && query.state.dataUpdateCount < EMPTY_MIDPOINTS_MAX_FETCHES ? EMPTY_MIDPOINTS_POLL_MS : false,
     gcTime: 30 * 6e4,
-    refetchOnMount: false,
+    refetchOnMount: true,
     refetchOnWindowFocus: false,
     refetchOnReconnect: false
   });
-  const result = useMemo8(() => {
+  const result = useMemo9(() => {
     var _a2, _b, _c, _d, _e, _f;
     const map = /* @__PURE__ */ new Map();
     const currentMap = /* @__PURE__ */ new Map();
@@ -1605,7 +2569,7 @@ function useMidpoints(venueMarkets, options) {
     }
     return { map, currentMap, venueMap };
   }, [data, venueMarkets]);
-  const { bestMidpoint, bestMidpointVenue } = useMemo8(() => {
+  const { bestMidpoint, bestMidpointVenue } = useMemo9(() => {
     let value;
     let venue;
     for (const outcomeId of bestMidpointCandidateOutcomeIds) {
@@ -1626,7 +2590,7 @@ function useMidpoints(venueMarkets, options) {
     }
     return { bestMidpoint: value, bestMidpointVenue: venue };
   }, [bestMidpointCandidateOutcomeIds, result.map, result.venueMap]);
-  const { bestPrices, bestPriceVenuesByOutcomeId } = useMemo8(
+  const { bestPrices, bestPriceVenuesByOutcomeId } = useMemo9(
     () => extractBestPrices(data == null ? void 0 : data.data, venueMarkets),
     [data == null ? void 0 : data.data, venueMarkets]
   );
@@ -1644,7 +2608,7 @@ function useMidpoints(venueMarkets, options) {
 }
 
 // src/use-rolling-chart-window.ts
-import { useEffect as useEffect5, useMemo as useMemo9, useState as useState4 } from "react";
+import { useEffect as useEffect7, useMemo as useMemo10, useState as useState4 } from "react";
 var RANGE_SECONDS_BY_RANGE = {
   "1H": 60 * 60,
   "6H": 6 * 60 * 60,
@@ -1675,135 +2639,27 @@ var useRollingChartWindow = (options) => {
   var _a;
   const tickMs = (_a = options.tickMs) != null ? _a : 1e3;
   const optionsNowMs = options.nowMs;
-  const nowMs = useMemo9(() => optionsNowMs != null ? optionsNowMs : (() => Date.now()), [optionsNowMs]);
+  const nowMs = useMemo10(() => optionsNowMs != null ? optionsNowMs : (() => Date.now()), [optionsNowMs]);
   const [nowSec, setNowSec] = useState4(() => Math.floor(nowMs() / 1e3));
-  useEffect5(() => {
+  useEffect7(() => {
     setNowSec(Math.floor(nowMs() / 1e3));
     const handle = setInterval(() => {
       setNowSec(Math.floor(nowMs() / 1e3));
     }, tickMs);
     return () => clearInterval(handle);
   }, [tickMs, nowMs]);
-  return useMemo9(
+  return useMemo10(
     () => resolveRollingWindow({ range: options.range, nowSec, interval: options.interval }),
     [options.range, options.interval, nowSec]
   );
 };
 
-// src/use-market-orderbook.ts
-import { useQueries as useQueries5, useQueryClient } from "@tanstack/react-query";
-function useMarketOrderbook(options) {
-  var _a, _b, _c, _d, _e, _f, _g;
-  const queryClient = useQueryClient();
-  const client = useAggClient();
-  const ws = useAggWebSocket();
-  const isConnected = useAggWebSocketConnectionState();
-  const {
-    features: { enableLiveUpdates }
-  } = useAggUiConfig();
-  const { venueMarketOutcomeId, marketId, depth, enabled = true, venueOutcomes, live } = options;
-  const selectedId = (_a = venueMarketOutcomeId != null ? venueMarketOutcomeId : marketId) != null ? _a : null;
-  const liveEnabled = live != null ? live : enableLiveUpdates;
-  const outcomeIds = venueOutcomes == null ? void 0 : venueOutcomes.map((v) => v.venueMarketOutcomeId).filter(Boolean);
-  const subscriptionIds = (outcomeIds == null ? void 0 : outcomeIds.length) ? [...new Set(outcomeIds)] : selectedId ? [selectedId] : [];
-  const selectedOutcomeId = (_b = subscriptionIds[0]) != null ? _b : null;
-  useMarketDataSubscription({
-    marketId: selectedOutcomeId,
-    additionalMarketIds: subscriptionIds.slice(1),
-    enabled: enabled && !!selectedOutcomeId,
-    orderbook: true
-  });
-  const liveQueries = useQueries5({
-    queries: subscriptionIds.map((subscriptionId) => ({
-      queryKey: marketDataKeys.live(subscriptionId),
-      queryFn: () => createMarketLiveState(subscriptionId),
-      staleTime: Infinity,
-      gcTime: 5 * 6e4,
-      refetchOnMount: false,
-      refetchOnWindowFocus: false,
-      refetchOnReconnect: false
-    }))
-  });
-  const seedQueries = useQueries5({
-    queries: subscriptionIds.map((subscriptionId) => ({
-      queryKey: ["market-orderbook-seed", subscriptionId],
-      queryFn: ({ signal }) => client.getOutcomeOrderbook(subscriptionId, { signal }),
-      enabled: enabled && !!subscriptionId,
-      staleTime: 5e3,
-      gcTime: 6e4,
-      refetchOnWindowFocus: false,
-      retry: 1
-    }))
-  });
-  const liveStates = subscriptionIds.map((subscriptionId, index) => {
-    var _a2, _b2;
-    return (_b2 = (_a2 = liveQueries[index]) == null ? void 0 : _a2.data) != null ? _b2 : createMarketLiveState(subscriptionId);
-  });
-  const seededOrderbooks = subscriptionIds.map((subscriptionId, index) => {
-    var _a2, _b2, _c2, _d2;
-    const liveBook = (_b2 = (_a2 = liveStates[index]) == null ? void 0 : _a2.orderbook) != null ? _b2 : null;
-    if (liveBook) return liveBook;
-    const seed = (_c2 = seedQueries[index]) == null ? void 0 : _c2.data;
-    return ((_d2 = seed == null ? void 0 : seed.orderbook) == null ? void 0 : _d2.bids) && seed.orderbook.asks ? outcomeOrderbookToState(seed, subscriptionId) : null;
-  });
-  const primaryOrderbook = (_c = seededOrderbooks[0]) != null ? _c : null;
-  const primarySnapshotVersion = (_e = (_d = liveStates[0]) == null ? void 0 : _d.orderbookSnapshotVersion) != null ? _e : 0;
-  const data = primaryOrderbook ? applyOrderbookDepth(
-    createMarketOrderbookDataFromState(primaryOrderbook, {
-      snapshotVersion: primarySnapshotVersion
-    }),
-    depth
-  ) : null;
-  const dataById = Object.fromEntries(
-    seededOrderbooks.flatMap((orderbook, index) => {
-      var _a2;
-      if (!orderbook) return [];
-      return [
-        [
-          subscriptionIds[index],
-          applyOrderbookDepth(
-            createMarketOrderbookDataFromState(orderbook, {
-              snapshotVersion: (_a2 = liveStates[index]) == null ? void 0 : _a2.orderbookSnapshotVersion
-            }),
-            depth
-          )
-        ]
-      ];
-    })
-  );
-  const hasAnyOrderbook = seededOrderbooks.some((orderbook) => orderbook != null);
-  const seedLoading = seedQueries.some((query) => query.isLoading);
-  const liveOrderbookErrorMessage = enabled && liveEnabled && !hasAnyOrderbook ? (_g = (_f = liveStates.find(
-    (liveState) => typeof liveState.orderbookError === "string" && liveState.orderbookError.length > 0
-  )) == null ? void 0 : _f.orderbookError) != null ? _g : null : null;
-  return {
-    data,
-    dataById,
-    isLoading: enabled && !hasAnyOrderbook && liveOrderbookErrorMessage == null && (isConnected || seedLoading),
-    error: liveOrderbookErrorMessage ? new Error(liveOrderbookErrorMessage) : null,
-    isLive: Boolean(liveEnabled && selectedOutcomeId && isConnected),
-    refetch: () => __async(null, null, function* () {
-      if (!enabled) return;
-      if (subscriptionIds.length === 0) return;
-      subscriptionIds.forEach((subscriptionId) => {
-        queryClient.setQueryData(
-          marketDataKeys.live(subscriptionId),
-          (previous) => __spreadProps(__spreadValues({}, previous != null ? previous : createMarketLiveState(subscriptionId)), {
-            orderbookError: null
-          })
-        );
-      });
-      ws == null ? void 0 : ws.resnapshot(subscriptionIds);
-    })
-  };
-}
-
 // src/use-arb.ts
-import { useEffect as useEffect6, useRef as useRef4, useState as useState5 } from "react";
+import { useEffect as useEffect8, useRef as useRef6, useState as useState5 } from "react";
 function useMarketArb(marketId) {
   const ws = useAggWebSocket();
   const [state, setState] = useState5({ arbReturn: null, isLive: false });
-  useEffect6(() => {
+  useEffect8(() => {
     if (!ws || !marketId) return;
     const cached = ws.getArb(marketId);
     if (cached != null) {
@@ -1823,9 +2679,9 @@ var EMPTY_ARB_FEED = {
 function useArbFeed() {
   const ws = useAggWebSocket();
   const [state, setState] = useState5(EMPTY_ARB_FEED);
-  const stateRef = useRef4(state);
+  const stateRef = useRef6(state);
   stateRef.current = state;
-  useEffect6(() => {
+  useEffect8(() => {
     if (!ws) return;
     const off = ws.subscribeArbFeed((batch) => {
       setState((prev) => {
@@ -1857,7 +2713,9 @@ function useArbFeed() {
 }
 
 // src/use-order-book.ts
-import { keepPreviousData as keepPreviousData3, useQuery as useQuery5 } from "@tanstack/react-query";
+import { keepPreviousData as keepPreviousData3, useQuery as useQuery7 } from "@tanstack/react-query";
+var fetchBatchBookQuery = (client, venueMarketIds, { signal }) => client.getOrderbooks({ venueMarketIds }, { signal });
+var createBatchBookQuery = (client, venueMarketIds) => fetchBatchBookQuery.bind(null, client, venueMarketIds);
 function useOrderBook(options) {
   const client = useAggClient();
   const { orderbooks, enabled = true, canonicalMarketId } = options;
@@ -1870,14 +2728,9 @@ function useOrderBook(options) {
       venueMarketOutcomeId: outcome.id
     })) : void 0
   });
-  const batchedResult = useQuery5({
+  const batchedResult = useQuery7({
     queryKey: requestedVenueMarketIds.length ? ["orderbooks", requestedVenueMarketIds, null] : ["orderbooks", "__disabled__", null],
-    queryFn: ({ signal }) => client.getOrderbooks(
-      {
-        venueMarketIds: requestedVenueMarketIds
-      },
-      { signal }
-    ),
+    queryFn: createBatchBookQuery(client, requestedVenueMarketIds),
     enabled: enabled && !canonicalMarketId && requestedVenueMarketIds.length > 0,
     staleTime: 1e4,
     gcTime: 5 * 6e4,
@@ -1938,7 +2791,7 @@ function useOrderBook(options) {
 }
 
 // src/use-orderbook-quote.ts
-import { keepPreviousData as keepPreviousData4, useQuery as useQuery6 } from "@tanstack/react-query";
+import { keepPreviousData as keepPreviousData4, useQuery as useQuery8 } from "@tanstack/react-query";
 var QUOTE_DEBOUNCE_MS = 300;
 var createUnavailableOrderbookError = (message, code, retryable) => {
   const error = new Error(message);
@@ -2000,7 +2853,7 @@ function useOrderbookQuote(options) {
   const { marketId, side, size, enabled = true } = options;
   const debouncedSize = useDebouncedValue(size, QUOTE_DEBOUNCE_MS);
   const shouldFetch = enabled && !!marketId && debouncedSize > 0;
-  const query = useQuery6({
+  const query = useQuery8({
     queryKey: marketId ? marketDataKeys.orderbookQuote(marketId, side, debouncedSize) : ["market-data", "orderbook-quote", "__disabled__"],
     queryFn: () => __async(null, null, function* () {
       var _a2, _b, _c, _d;
@@ -2042,12 +2895,12 @@ function useOrderbookQuote(options) {
 }
 
 // src/use-orders.ts
-import { useQuery as useQuery7 } from "@tanstack/react-query";
+import { useQuery as useQuery9 } from "@tanstack/react-query";
 function useOrders(options = {}) {
   var _a, _b, _c, _d;
   const client = useAggClient();
   const { userId, status, limit = 50, offset = 0, enabled = true } = options;
-  const query = useQuery7({
+  const query = useQuery9({
     queryKey: ["orders", userId != null ? userId : "me", status != null ? status : "all", limit, offset],
     queryFn: () => client.getOrders({
       userId,
@@ -2070,15 +2923,24 @@ import {
   keepPreviousData as keepPreviousData5,
   useInfiniteQuery as useInfiniteQuery5
 } from "@tanstack/react-query";
-import { useContext as useContext2, useEffect as useEffect7, useState as useState6 } from "react";
+import { useContext as useContext2, useEffect as useEffect9, useState as useState6 } from "react";
 function useSearch(options) {
   var _a, _b, _c, _d;
   const client = useContext2(AggClientContext);
   const queryClient = useContext2(QueryClientContext);
   const [fallbackQueryClient] = useState6(() => new QueryClient());
-  const { q, type, categoryIds, status, limit = 20, enabled = true, deep = false } = options;
+  const {
+    q,
+    type,
+    categoryIds,
+    status,
+    limit = 20,
+    enabled = true,
+    deep = false,
+    mode = "full"
+  } = options;
   const isEnabled = enabled && q.length > 0;
-  useEffect7(() => {
+  useEffect9(() => {
     if (queryClient) return void 0;
     fallbackQueryClient.mount();
     return () => {
@@ -2088,32 +2950,40 @@ function useSearch(options) {
   if (isEnabled && !client) {
     throw new Error("useSearch must be used within an <AggProvider>");
   }
+  const queryKey = [
+    "search",
+    q,
+    type,
+    (_a = categoryIds == null ? void 0 : categoryIds.join(",")) != null ? _a : "",
+    (_b = status == null ? void 0 : status.join(",")) != null ? _b : "",
+    limit,
+    deep,
+    mode
+  ];
+  const effectiveQueryClient = queryClient != null ? queryClient : fallbackQueryClient;
+  const retryOptions = withReadRetry(effectiveQueryClient.defaultQueryOptions({ queryKey }));
   const query = useInfiniteQuery5(
-    {
+    __spreadProps(__spreadValues({
       // deep is part of the key — TanStack treats deep vs light as
       // independent queries so users can have both modes cached side-by-side.
-      queryKey: [
-        "search",
-        q,
-        type,
-        (_a = categoryIds == null ? void 0 : categoryIds.join(",")) != null ? _a : "",
-        (_b = status == null ? void 0 : status.join(",")) != null ? _b : "",
-        limit,
-        deep
-      ],
-      queryFn: (_0) => __async(null, [_0], function* ({ pageParam }) {
+      queryKey,
+      queryFn: (_0) => __async(null, [_0], function* ({ pageParam, signal }) {
         if (!client) {
           throw new Error("useSearch must be used within an <AggProvider>");
         }
-        const res = yield client.search({
-          q,
-          type,
-          categoryIds,
-          status,
-          limit,
-          cursor: pageParam,
-          deep
-        });
+        const res = yield client.search(
+          {
+            q,
+            type,
+            categoryIds,
+            status,
+            limit,
+            cursor: pageParam,
+            deep,
+            mode
+          },
+          { signal }
+        );
         return res;
       }),
       initialPageParam: void 0,
@@ -2122,10 +2992,11 @@ function useSearch(options) {
         if (!lastPage.hasMore) return void 0;
         return (_a2 = lastPage.nextCursor) != null ? _a2 : void 0;
       },
-      placeholderData: keepPreviousData5,
+      placeholderData: keepPreviousData5
+    }, retryOptions), {
       enabled: isEnabled && !!client
-    },
-    queryClient != null ? queryClient : fallbackQueryClient
+    }),
+    effectiveQueryClient
   );
   const data = (_d = (_c = query.data) == null ? void 0 : _c.pages.flatMap((page) => page.data)) != null ? _d : [];
   return {
@@ -2165,7 +3036,8 @@ function useMarketSearch(options) {
     status,
     limit,
     enabled: suggestionsEnabled,
-    deep: false
+    deep: false,
+    mode: "instant"
   });
   const submittedQ = (_a = submittedQuery == null ? void 0 : submittedQuery.trim()) != null ? _a : "";
   const resultsQuery = useSearch({
@@ -2230,7 +3102,7 @@ function useMarketSearch(options) {
 }
 
 // src/use-smart-route.ts
-import { keepPreviousData as keepPreviousData6, useQuery as useQuery8 } from "@tanstack/react-query";
+import { keepPreviousData as keepPreviousData6, useQuery as useQuery10 } from "@tanstack/react-query";
 
 // src/smart-route-refresh-policy.ts
 var THIN_SMART_ROUTE_REFETCH_INTERVAL_MS = 5e3;
@@ -2370,7 +3242,7 @@ var getIsDocumentVisible = () => {
   return document.visibilityState !== "hidden";
 };
 function useSmartRoute(options) {
-  var _a, _b, _c, _d, _e, _f;
+  var _a, _b, _c, _d, _e, _f, _g;
   const client = useAggClient();
   const {
     venueMarketOutcomeId,
@@ -2394,7 +3266,7 @@ function useSmartRoute(options) {
   const resolvedVenueMarketOutcomeId = (_a = venueMarketOutcomeId != null ? venueMarketOutcomeId : venueMarketId) != null ? _a : outcomeId;
   const hasValidInput = (maxSpend != null ? maxSpend : 0) > 0 || (sellShares != null ? sellShares : 0) > 0;
   const queryEnabled = enabled && !!resolvedVenueMarketOutcomeId && hasValidInput;
-  const query = useQuery8({
+  const query = useQuery10({
     queryKey: [
       "smart-route",
       resolvedVenueMarketOutcomeId,
@@ -2407,8 +3279,11 @@ function useSmartRoute(options) {
       slipCapBps != null ? slipCapBps : null,
       compareVenues != null ? compareVenues : false,
       deepEstimate != null ? deepEstimate : false,
-      ...balanceCacheScope ? [(_b = balanceCacheScope.accountId) != null ? _b : null, (_c = balanceCacheScope.balanceVersion) != null ? _c : null] : [],
-      ...tradeSide === "sell" ? [(_d = sellCacheScope == null ? void 0 : sellCacheScope.accountId) != null ? _d : null, (_e = sellCacheScope == null ? void 0 : sellCacheScope.positionVersion) != null ? _e : null] : []
+      ...balanceCacheScope ? [
+        (_b = balanceCacheScope.accountId) != null ? _b : null,
+        (_d = (_c = balanceCacheScope.balanceKey) != null ? _c : balanceCacheScope.balanceVersion) != null ? _d : null
+      ] : [],
+      ...tradeSide === "sell" ? [(_e = sellCacheScope == null ? void 0 : sellCacheScope.accountId) != null ? _e : null, (_f = sellCacheScope == null ? void 0 : sellCacheScope.positionVersion) != null ? _f : null] : []
     ],
     queryFn: (_0) => __async(null, [_0], function* ({ signal }) {
       return client.getSmartRoute(
@@ -2466,7 +3341,7 @@ function useSmartRoute(options) {
     }
   }
   return {
-    data: (_f = query.data) != null ? _f : null,
+    data: (_g = query.data) != null ? _g : null,
     isLoading: query.isLoading,
     isFetching: query.isFetching,
     error: error instanceof Error ? error : error ? new Error(String(error)) : null,
@@ -2476,7 +3351,7 @@ function useSmartRoute(options) {
 }
 
 // src/use-limit-order-venue-quotes.ts
-import { keepPreviousData as keepPreviousData7, useQueries as useQueries6, useQuery as useQuery9 } from "@tanstack/react-query";
+import { keepPreviousData as keepPreviousData7, useQueries as useQueries4, useQuery as useQuery11 } from "@tanstack/react-query";
 var getIsDocumentVisible2 = () => {
   if (typeof document === "undefined") return true;
   return document.visibilityState !== "hidden";
@@ -2531,7 +3406,7 @@ var useLimitOrderVenueQuotes = (options) => {
   const hasRequiredAccount = tradeSide === "buy" || Boolean(accountId);
   const queryEnabled = enabled && hasValidInput && hasRequiredAccount;
   const serializedChainBalances = chainBalances ? JSON.stringify(chainBalances) : null;
-  const tickMetadataQuery = useQuery9({
+  const tickMetadataQuery = useQuery11({
     queryKey: ["orderbooks", marketId != null ? marketId : "__disabled__", "limit-order-ticks"],
     queryFn: ({ signal }) => client.getOrderbooks({ venueMarketIds: [marketId] }, { signal }),
     enabled: enabled && Boolean(marketId),
@@ -2540,7 +3415,7 @@ var useLimitOrderVenueQuotes = (options) => {
     refetchOnWindowFocus: false,
     retry: 1
   });
-  const queries = useQueries6({
+  const queries = useQueries4({
     queries: uniqueRequests.map((request) => ({
       queryKey: [
         "smart-route",
@@ -2622,7 +3497,7 @@ var useLimitOrderVenueQuotes = (options) => {
 };
 
 // src/use-venue-sell-quotes.ts
-import { useQueries as useQueries7 } from "@tanstack/react-query";
+import { useQueries as useQueries5 } from "@tanstack/react-query";
 var getIsDocumentVisible3 = () => {
   if (typeof document === "undefined") return true;
   return document.visibilityState !== "hidden";
@@ -2653,7 +3528,7 @@ var useVenueSellQuotes = (options) => {
     refreshContext
   } = options;
   const uniqueRequests = getUniqueVenueRequests2(requests);
-  const queries = useQueries7({
+  const queries = useQueries5({
     queries: uniqueRequests.map((request) => {
       const hasValidInput = request.requestedSellShares > 0 && request.sellShares > 0 && request.availableShares > 0;
       const queryEnabled = enabled && !!venueMarketOutcomeId && !!accountId && hasValidInput;
@@ -2768,13 +3643,13 @@ function useUserHoldings(options) {
 }
 
 // src/use-enriched-venue-event.ts
-import { useMemo as useMemo10 } from "react";
+import { useMemo as useMemo11 } from "react";
 
 // src/use-venue-event.ts
-import { useQuery as useQuery11 } from "@tanstack/react-query";
+import { useQuery as useQuery13 } from "@tanstack/react-query";
 
 // src/use-recurring-crypto-markets.ts
-import { useQuery as useQuery10 } from "@tanstack/react-query";
+import { useQuery as useQuery12 } from "@tanstack/react-query";
 var RESOLVING_POLL_INTERVAL_MS = 15e3;
 var FALLBACK_VENUE_EVENT_PAGE_LIMIT = 100;
 var FALLBACK_VENUE_EVENT_MAX_PAGES = 5;
@@ -3274,7 +4149,7 @@ var useRecurringCryptoMarkets = ({
   const client = useAggClient();
   const identity = event ? resolveRecurringCryptoIdentity(event) : null;
   const isEnabled = enabled && event != null && identity != null;
-  const query = useQuery10({
+  const query = useQuery12({
     queryKey: [
       "recurring-crypto-markets",
       event == null ? void 0 : event.id,
@@ -3336,7 +4211,7 @@ function useVenueEvent(options) {
   var _a;
   const client = useAggClient();
   const { eventId, enabled = true, cluster } = options;
-  const query = useQuery11({
+  const query = useQuery13({
     queryKey: ["venue-event", eventId, cluster === false ? "no-cluster" : ""],
     queryFn: (_0) => __async(null, [_0], function* ({ signal }) {
       return client.getVenueEventById(eventId, { signal, cluster });
@@ -3357,7 +4232,7 @@ function useVenueEvent(options) {
 
 // src/use-venue-markets.ts
 import { QueryClient as QueryClient2, QueryClientContext as QueryClientContext2, useInfiniteQuery as useInfiniteQuery7 } from "@tanstack/react-query";
-import { useContext as useContext3, useEffect as useEffect8, useState as useState8 } from "react";
+import { useContext as useContext3, useEffect as useEffect10, useState as useState8 } from "react";
 function useVenueMarkets(options) {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
   const client = useContext3(AggClientContext);
@@ -3379,7 +4254,7 @@ function useVenueMarkets(options) {
   const sortBy = options == null ? void 0 : options.sortBy;
   const sortDir = options == null ? void 0 : options.sortDir;
   const context = options == null ? void 0 : options.context;
-  useEffect8(() => {
+  useEffect10(() => {
     if (queryClient) return void 0;
     fallbackQueryClient.mount();
     return () => {
@@ -3409,28 +4284,31 @@ function useVenueMarkets(options) {
         sortDir != null ? sortDir : "",
         context != null ? context : ""
       ],
-      queryFn: (_0) => __async(null, [_0], function* ({ pageParam }) {
+      queryFn: (_0) => __async(null, [_0], function* ({ pageParam, signal }) {
         if (!client) {
           throw new Error("useVenueMarkets must be used within an <AggProvider>");
         }
-        const res = yield client.getVenueMarkets({
-          venue,
-          venueEventId,
-          cluster,
-          search,
-          matchStatus,
-          status,
-          aggKey,
-          sportsMarketType,
-          period,
-          marketCategory,
-          marketGroup,
-          limit,
-          cursor: pageParam,
-          sortBy,
-          sortDir,
-          context
-        });
+        const res = yield client.getVenueMarkets(
+          {
+            venue,
+            venueEventId,
+            cluster,
+            search,
+            matchStatus,
+            status,
+            aggKey,
+            sportsMarketType,
+            period,
+            marketCategory,
+            marketGroup,
+            limit,
+            cursor: pageParam,
+            sortBy,
+            sortDir,
+            context
+          },
+          { signal }
+        );
         return res;
       }),
       initialPageParam: void 0,
@@ -3447,10 +4325,10 @@ function useVenueMarkets(options) {
   const hasNextPage = !!query.hasNextPage;
   const { fetchNextPage, isFetchingNextPage } = query;
   const fetchAll = (_j = options == null ? void 0 : options.fetchAll) != null ? _j : false;
-  useEffect8(() => {
-    if (!fetchAll || !hasNextPage || isFetchingNextPage) return;
+  useEffect10(() => {
+    if (!enabled || !client || !fetchAll || !hasNextPage || isFetchingNextPage) return;
     void fetchNextPage();
-  }, [fetchAll, hasNextPage, isFetchingNextPage, fetchNextPage]);
+  }, [enabled, client, fetchAll, hasNextPage, isFetchingNextPage, fetchNextPage]);
   return __spreadProps(__spreadValues({}, query), {
     markets,
     hasNextPage
@@ -3473,7 +4351,7 @@ function useEnrichedVenueEvent(options) {
   const _a = useVenueEvent(options), { event, isLoading, error } = _a, rest = __objRest(_a, ["event", "isLoading", "error"]);
   const eventEndedAt = (event == null ? void 0 : event.endDate) && Number.isFinite(Date.parse(event.endDate)) ? Date.parse(event.endDate) : null;
   const shouldFetchOnlyOpenMarkets = eventEndedAt == null || eventEndedAt >= Date.now();
-  const { markets: openMarkets, isLoading: isEnrichingOpenMarkets } = useVenueMarkets({
+  const openQuery = useVenueMarkets({
     venueEventId: options.eventId,
     cluster: options.cluster,
     enabled: ((_b = options.enabled) != null ? _b : true) && !!event,
@@ -3483,10 +4361,11 @@ function useEnrichedVenueEvent(options) {
     // MarketDetailsList (including limit, part of the query key) preserves the
     // shared React Query cache key and the event-type ordering.
     limit: 100,
-    fetchAll: true
+    fetchAll: !options.progressive
   });
+  const { markets: openMarkets, isLoading: isEnrichingOpenMarkets } = openQuery;
   const shouldFetchAllMarketsFallback = ((_c = options.enabled) != null ? _c : true) && !!event && shouldFetchOnlyOpenMarkets && !isEnrichingOpenMarkets && openMarkets.length === 0;
-  const { markets: fallbackMarkets, isLoading: isEnrichingFallbackMarkets } = useVenueMarkets({
+  const fallbackQuery = useVenueMarkets({
     venueEventId: options.eventId,
     cluster: options.cluster,
     enabled: shouldFetchAllMarketsFallback,
@@ -3494,11 +4373,13 @@ function useEnrichedVenueEvent(options) {
     // closed/resolved markets, still render the event page instead of the
     // unavailable state.
     limit: 100,
-    fetchAll: true
+    fetchAll: !options.progressive
   });
+  const { markets: fallbackMarkets, isLoading: isEnrichingFallbackMarkets } = fallbackQuery;
+  const activeQuery = shouldFetchAllMarketsFallback ? fallbackQuery : openQuery;
   const markets = fallbackMarkets.length > 0 ? fallbackMarkets : openMarkets;
   const isEnriching = isEnrichingOpenMarkets || isEnrichingFallbackMarkets;
-  const enrichedEvent = useMemo10(() => {
+  const enrichedEvent = useMemo11(() => {
     if (!event) return void 0;
     if (markets.length === 0) return event;
     return mergeEventWithFullMarkets(event, markets);
@@ -3507,6 +4388,9 @@ function useEnrichedVenueEvent(options) {
     event: enrichedEvent,
     isLoading,
     isEnriching,
+    hasMoreMarkets: !!activeQuery.hasNextPage,
+    loadMoreMarkets: activeQuery.fetchNextPage,
+    isLoadingMoreMarkets: !!activeQuery.isFetchingNextPage,
     error
   });
 }
@@ -3518,7 +4402,7 @@ import {
   keepPreviousData as keepPreviousData8,
   useInfiniteQuery as useInfiniteQuery8
 } from "@tanstack/react-query";
-import { useContext as useContext4, useEffect as useEffect9, useMemo as useMemo11, useRef as useRef5, useState as useState9 } from "react";
+import { useContext as useContext4, useEffect as useEffect11, useMemo as useMemo12, useRef as useRef7, useState as useState9 } from "react";
 function useVenueEvents(options) {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
   const client = useContext4(AggClientContext);
@@ -3540,7 +4424,7 @@ function useVenueEvents(options) {
   const endDateFrom = options == null ? void 0 : options.endDateFrom;
   const grouped = options == null ? void 0 : options.grouped;
   const initialPages = options == null ? void 0 : options.initialPages;
-  useEffect9(() => {
+  useEffect11(() => {
     if (queryClient) return void 0;
     fallbackQueryClient.mount();
     return () => {
@@ -3568,7 +4452,7 @@ function useVenueEvents(options) {
         grouped != null ? grouped : false,
         limit
       ],
-      queryFn: (_0) => __async(null, [_0], function* ({ pageParam }) {
+      queryFn: (_0) => __async(null, [_0], function* ({ pageParam, signal }) {
         if (!client) {
           throw new Error("useVenueEvents must be used within an <AggProvider>");
         }
@@ -3586,7 +4470,8 @@ function useVenueEvents(options) {
           maxYesPrice,
           endDateFrom,
           grouped,
-          cursor: pageParam
+          cursor: pageParam,
+          signal
         });
         return res;
       }),
@@ -3602,12 +4487,13 @@ function useVenueEvents(options) {
     },
     queryClient != null ? queryClient : fallbackQueryClient
   );
-  const prefetchedRef = useRef5(false);
-  useEffect9(() => {
+  const prefetchedRef = useRef7(false);
+  useEffect11(() => {
     var _a2, _b2;
+    if (!enabled || !client) return;
     if (prefetchedRef.current) return;
     if (!initialPages || initialPages <= 1) return;
-    if (query.isLoading) return;
+    if (query.isLoading || query.isFetching || query.isError || query.isPlaceholderData) return;
     const pagesLoaded = (_b2 = (_a2 = query.data) == null ? void 0 : _a2.pages.length) != null ? _b2 : 0;
     if (pagesLoaded >= initialPages || !query.hasNextPage) {
       prefetchedRef.current = true;
@@ -3615,13 +4501,18 @@ function useVenueEvents(options) {
     }
     void query.fetchNextPage();
   }, [
+    enabled,
+    client,
     initialPages,
     query.isLoading,
+    query.isFetching,
+    query.isError,
+    query.isPlaceholderData,
     (_h = query.data) == null ? void 0 : _h.pages.length,
     query.hasNextPage,
     query.fetchNextPage
   ]);
-  const events = useMemo11(
+  const events = useMemo12(
     () => {
       var _a2, _b2;
       return (_b2 = (_a2 = query.data) == null ? void 0 : _a2.pages.flatMap((page) => page.data)) != null ? _b2 : [];
@@ -3639,7 +4530,7 @@ function useVenueEvents(options) {
 }
 
 // src/use-sports-live.ts
-import { useQuery as useQuery12 } from "@tanstack/react-query";
+import { useQuery as useQuery14 } from "@tanstack/react-query";
 var SPORTS_LIVE_POLL_INTERVAL_MS = 5e3;
 var SPORTS_SCHEDULED_POLL_INTERVAL_MS = 3e4;
 var sportsLiveQueryKey = (sortedEventIds) => ["sports-live", ...sortedEventIds];
@@ -3659,7 +4550,7 @@ var useSportsLive = (eventIds, enabled = true) => {
   const sortedEventIds = [
     ...new Set(eventIds.map((eventId) => eventId.trim()).filter(Boolean))
   ].sort();
-  const query = useQuery12({
+  const query = useQuery14({
     queryKey: sportsLiveQueryKey(sortedEventIds),
     queryFn: ({ signal }) => client.getSportsLive(sortedEventIds, { signal }),
     enabled: enabled && sortedEventIds.length > 0,
@@ -3679,7 +4570,7 @@ var useSportsLive = (eventIds, enabled = true) => {
 };
 
 // src/use-venue-market-midpoints.ts
-import { keepPreviousData as keepPreviousData9, useQuery as useQuery13 } from "@tanstack/react-query";
+import { keepPreviousData as keepPreviousData9, useQuery as useQuery15 } from "@tanstack/react-query";
 var normalizeVenueMarketIds2 = (venueMarketIds) => {
   return [
     ...new Set(venueMarketIds.map((venueMarketId) => venueMarketId.trim()).filter(Boolean))
@@ -3718,7 +4609,7 @@ function useVenueMarketMidpoints(options) {
   const enabled = (_a = options.enabled) != null ? _a : true;
   const requestedVenueMarketIds = normalizeVenueMarketIds2(options.venueMarketIds);
   const maxMidpointIdsPerRequest = (_b = options.maxMidpointIdsPerRequest) != null ? _b : configuredMaxMidpointIdsPerRequest;
-  const query = useQuery13({
+  const query = useQuery15({
     queryKey: requestedVenueMarketIds.length ? ["venue-market-midpoints", requestedVenueMarketIds, maxMidpointIdsPerRequest] : ["venue-market-midpoints", "__disabled__"],
     queryFn: (_0) => __async(null, [_0], function* ({ signal }) {
       if (requestedVenueMarketIds.length === 0) {
@@ -3794,7 +4685,7 @@ var computePriceGaps = ({
 };
 
 // src/use-viewport-midpoints.ts
-import { useEffect as useEffect10, useMemo as useMemo12, useRef as useRef6, useState as useState10 } from "react";
+import { useEffect as useEffect12, useMemo as useMemo13, useRef as useRef8, useState as useState10 } from "react";
 var buildOutcomeMidpointMap = (outcomes) => {
   const m = /* @__PURE__ */ new Map();
   if (!outcomes) return m;
@@ -3848,14 +4739,14 @@ function useViewportMidpoints(visibleMarkets, options) {
   } = useAggUiConfig();
   const maxMidpointIdsPerRequest = (_a = options == null ? void 0 : options.maxMidpointIdsPerRequest) != null ? _a : configuredMaxMidpointIdsPerRequest;
   const [cache, setCache] = useState10(() => /* @__PURE__ */ new Map());
-  const inFlightRef = useRef6(/* @__PURE__ */ new Set());
-  const visibleRef = useRef6(visibleMarkets);
+  const inFlightRef = useRef8(/* @__PURE__ */ new Set());
+  const visibleRef = useRef8(visibleMarkets);
   visibleRef.current = visibleMarkets;
-  const visibleFp = useMemo12(
+  const visibleFp = useMemo13(
     () => [...new Set(visibleMarkets.map((m) => m.id))].sort().join("|"),
     [visibleMarkets]
   );
-  useEffect10(() => {
+  useEffect12(() => {
     const toFetch = resolveUncachedVisibleMarketIds(visibleRef.current, cache, inFlightRef.current);
     if (!toFetch.length) return;
     let cancelled = false;
@@ -3879,7 +4770,7 @@ function useViewportMidpoints(visibleMarkets, options) {
       cancelled = true;
     };
   }, [visibleFp, cache, maxMidpointIdsPerRequest]);
-  const { prices, venueByOutcomeId } = useMemo12(() => {
+  const { prices, venueByOutcomeId } = useMemo13(() => {
     var _a2, _b, _c, _d;
     const map = /* @__PURE__ */ new Map();
     const venueMap = /* @__PURE__ */ new Map();
@@ -3912,15 +4803,15 @@ function useViewportMidpoints(visibleMarkets, options) {
 }
 
 // src/use-visible-ids.ts
-import { useCallback as useCallback7, useEffect as useEffect11, useRef as useRef7, useState as useState11 } from "react";
+import { useCallback as useCallback7, useEffect as useEffect13, useRef as useRef9, useState as useState11 } from "react";
 function useVisibleIds(options = {}) {
   const { rootMargin = "0px", threshold = 0 } = options;
   const [visibleIds, setVisibleIds] = useState11(() => /* @__PURE__ */ new Set());
-  const observerRef = useRef7(null);
-  const elementsRef = useRef7(/* @__PURE__ */ new Map());
-  const elementIdRef = useRef7(/* @__PURE__ */ new WeakMap());
-  const callbackRefsRef = useRef7(/* @__PURE__ */ new Map());
-  useEffect11(() => {
+  const observerRef = useRef9(null);
+  const elementsRef = useRef9(/* @__PURE__ */ new Map());
+  const elementIdRef = useRef9(/* @__PURE__ */ new WeakMap());
+  const callbackRefsRef = useRef9(/* @__PURE__ */ new Map());
+  useEffect13(() => {
     if (typeof IntersectionObserver === "undefined") return;
     const observer = new IntersectionObserver(
       (entries) => {
@@ -3985,7 +4876,7 @@ function useVisibleIds(options = {}) {
 }
 
 // src/use-paper-onboarding.ts
-import { useCallback as useCallback8, useEffect as useEffect12, useState as useState12 } from "react";
+import { useCallback as useCallback8, useEffect as useEffect14, useState as useState12 } from "react";
 var STORAGE_KEY = "agg_paper_onboarding_seen";
 var isBrowser = () => typeof window !== "undefined" && "localStorage" in window;
 var seenKey = (userId) => `${STORAGE_KEY}:${userId}`;
@@ -4010,14 +4901,14 @@ function usePaperOnboarding() {
   const userId = user == null ? void 0 : user.id;
   const [dismissed, setDismissed] = useState12(false);
   const [seen, setSeen] = useState12(null);
-  useEffect12(() => {
+  useEffect14(() => {
     if (!userId) {
       setSeen(null);
       return;
     }
     setSeen(hasSeen(userId));
   }, [userId]);
-  useEffect12(() => {
+  useEffect14(() => {
     setDismissed(false);
   }, [userId]);
   const dismiss = useCallback8(() => {
@@ -4027,6 +4918,206 @@ function usePaperOnboarding() {
   const isOpen = isPaperMode && !isResolving && isAuthenticated && Boolean(userId) && seen === false && !dismissed;
   return { isOpen, dismiss };
 }
+
+// src/use-settlement-details-data.ts
+import { useQuery as useQuery16 } from "@tanstack/react-query";
+function useSettlementDetailsData(options) {
+  const client = useAggClient();
+  const { eventId, market, enabled, needsEvent, needsMarket } = options;
+  const eventQuery = useQuery16({
+    queryKey: ["settlement-details", "event", client.appId, eventId],
+    queryFn: ({ signal }) => client.getVenueEventById(eventId, { signal }),
+    enabled: enabled && needsEvent,
+    staleTime: 5 * 6e4,
+    gcTime: 10 * 6e4,
+    retry: false
+  });
+  const marketQuery = useQuery16({
+    queryKey: ["settlement-details", "market", client.appId, market.id],
+    queryFn: (_0) => __async(null, [_0], function* ({ signal }) {
+      const response = yield client.getVenueMarkets(
+        { venue: market.venue, externalIdentifier: [market.externalIdentifier], limit: 1 },
+        { signal }
+      );
+      const selected = response.data.find((candidate) => candidate.id === market.id);
+      if (!selected) throw new Error("Selected market details unavailable");
+      return { selected, markets: response.data };
+    }),
+    enabled: enabled && needsMarket,
+    staleTime: 5 * 6e4,
+    gcTime: 10 * 6e4,
+    retry: false
+  });
+  return { eventQuery, marketQuery };
+}
+
+// src/use-hosted-venue-transfers.ts
+import { useEffect as useEffect15, useRef as useRef10, useState as useState13 } from "react";
+import { useMutation as useMutation2, useQuery as useQuery17, useQueryClient as useQueryClient4 } from "@tanstack/react-query";
+var validRequest = (value) => {
+  var _a;
+  const row = value;
+  return !!row && ((_a = row.request) == null ? void 0 : _a.mode) === "live" && /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
+    row.request.requestId
+  ) && /^[1-9][0-9]{0,31}$/.test(row.request.amountRaw) && /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(row.request.destinationAddress) && (row.withdrawalId === void 0 || /^[a-zA-Z0-9_-]{1,256}$/.test(row.withdrawalId));
+};
+function useHostedVenueTransfers(accountId, environment) {
+  var _a, _b, _c, _d, _e;
+  const client = useAggClient();
+  const { user, isAuthenticated } = useAggAuthContext();
+  const { executionMode, isResolving } = useResolvedExecutionMode();
+  const queryClient = useQueryClient4();
+  const userId = (_a = user == null ? void 0 : user.id) != null ? _a : null;
+  const permitted = isAuthenticated && !!userId && !isResolving && executionMode === "live";
+  const scope = JSON.stringify([userId, accountId, environment]);
+  const storageKey = "agg:betdex-withdrawal:" + scope;
+  const [entry, setEntry] = useState13({
+    scope: "",
+    ready: false,
+    journal: null,
+    invalid: false
+  });
+  const session = useRef10({ client, scope, permitted });
+  session.current = { client, scope, permitted };
+  const mounted = useRef10(true);
+  const dispatching = useRef10(false);
+  const intent = useRef10(null);
+  const current = entry.scope === scope ? entry : null;
+  const journal = (_b = current == null ? void 0 : current.journal) != null ? _b : null;
+  const assertSession = () => {
+    if (!mounted.current || !permitted || !session.current.permitted || session.current.client !== client || session.current.scope !== scope)
+      throw new Error("Hosted transfers are unavailable for this session");
+  };
+  const save = (next) => {
+    localStorage.setItem(storageKey, JSON.stringify(next));
+    if (mounted.current && session.current.scope === scope) {
+      intent.current = { scope, journal: next };
+      setEntry({ scope, ready: true, journal: next, invalid: false });
+    }
+  };
+  const assertResult = (result2) => {
+    if (result2.accountId !== accountId || result2.environment !== environment)
+      throw new Error("Hosted transfer identity mismatch");
+  };
+  const invalidate = () => {
+    void queryClient.invalidateQueries({
+      queryKey: hostedVenueAccountQueryKeys.account("betdex", userId, "live")
+    });
+    invalidateBalanceQueries(queryClient);
+  };
+  const deposit = useMutation2({
+    mutationFn: () => __async(null, null, function* () {
+      assertSession();
+      const result2 = yield client.getHostedVenueDepositAddress("betdex", { mode: "live" });
+      assertResult(result2);
+      assertSession();
+      return { scope, result: result2 };
+    }),
+    retry: false
+  });
+  const withdrawal = useMutation2({
+    mutationFn: (request) => __async(null, null, function* () {
+      assertSession();
+      if (dispatching.current) throw new Error("Withdrawal request is already pending");
+      dispatching.current = true;
+      try {
+        save(request);
+        const result2 = request.withdrawalId ? yield client.getHostedVenueWithdrawal("betdex", request.withdrawalId, { mode: "live" }) : yield client.withdrawHostedVenue("betdex", request.request);
+        assertResult(result2);
+        save(__spreadProps(__spreadValues({}, request), { withdrawalId: result2.id }));
+        assertSession();
+        invalidate();
+        return { scope, result: result2 };
+      } finally {
+        dispatching.current = false;
+      }
+    }),
+    retry: false
+  });
+  const status = useQuery17({
+    queryKey: ["agg", "hosted-venue-withdrawal", scope, journal == null ? void 0 : journal.withdrawalId],
+    queryFn: () => __async(null, null, function* () {
+      assertSession();
+      if (!(journal == null ? void 0 : journal.withdrawalId)) throw new Error("Withdrawal identity is unavailable");
+      const result2 = yield client.getHostedVenueWithdrawal("betdex", journal.withdrawalId, {
+        mode: "live"
+      });
+      assertResult(result2);
+      assertSession();
+      if (result2.status === "confirmed" || result2.status === "failed") invalidate();
+      return result2;
+    }),
+    enabled: permitted && !!(journal == null ? void 0 : journal.withdrawalId),
+    retry: false,
+    refetchInterval: (query) => {
+      var _a2;
+      return ((_a2 = query.state.data) == null ? void 0 : _a2.status) === "processing" ? 2e3 : false;
+    },
+    refetchIntervalInBackground: false
+  });
+  useEffect15(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+    };
+  }, []);
+  const resetDeposit = deposit.reset;
+  const resetWithdrawal = withdrawal.reset;
+  useEffect15(() => {
+    resetDeposit();
+    resetWithdrawal();
+    if (!permitted) return;
+    try {
+      const text = localStorage.getItem(storageKey);
+      const value = text ? JSON.parse(text) : null;
+      if (value !== null && !validRequest(value)) throw new Error("Invalid saved withdrawal");
+      intent.current = value ? { scope, journal: value } : null;
+      setEntry({ scope, ready: true, journal: value, invalid: false });
+    } catch (e) {
+      setEntry({ scope, ready: false, journal: null, invalid: true });
+    }
+  }, [storageKey, scope, permitted, resetDeposit, resetWithdrawal]);
+  const result = (_d = status.data) != null ? _d : ((_c = withdrawal.data) == null ? void 0 : _c.scope) === scope ? withdrawal.data.result : void 0;
+  const terminal = (result == null ? void 0 : result.status) === "confirmed" || (result == null ? void 0 : result.status) === "failed";
+  return {
+    isAvailable: permitted,
+    ready: !!(current == null ? void 0 : current.ready),
+    storageError: !!(current == null ? void 0 : current.invalid),
+    deposit: __spreadProps(__spreadValues({}, deposit), { data: ((_e = deposit.data) == null ? void 0 : _e.scope) === scope ? deposit.data.result : void 0 }),
+    withdrawal: __spreadProps(__spreadValues({}, withdrawal), { data: result, isError: withdrawal.isError || status.isError }),
+    request: journal == null ? void 0 : journal.request,
+    submit: (amountRaw, destinationAddress) => __async(null, null, function* () {
+      var _a2;
+      assertSession();
+      if (!(current == null ? void 0 : current.ready) || current.invalid || journal || ((_a2 = intent.current) == null ? void 0 : _a2.scope) === scope)
+        throw new Error("Resolve the existing withdrawal first");
+      const request = {
+        mode: "live",
+        requestId: crypto.randomUUID(),
+        amountRaw,
+        destinationAddress
+      };
+      if (!validRequest({ request })) throw new Error("Invalid withdrawal request");
+      save({ request });
+      return withdrawal.mutateAsync({ request });
+    }),
+    check: () => __async(null, null, function* () {
+      assertSession();
+      if (!journal || !(current == null ? void 0 : current.ready)) throw new Error("No saved withdrawal");
+      return withdrawal.mutateAsync(journal);
+    }),
+    clear: () => {
+      var _a2;
+      assertSession();
+      if (!terminal || dispatching.current || ((_a2 = intent.current) == null ? void 0 : _a2.journal.withdrawalId) !== (result == null ? void 0 : result.id))
+        throw new Error("Withdrawal is not terminal");
+      localStorage.removeItem(storageKey);
+      intent.current = null;
+      setEntry({ scope, ready: true, journal: null, invalid: false });
+      withdrawal.reset();
+    }
+  };
+}
 export {
   AUTH_CHOOSER_OPEN_EVENT,
   AggBalanceProvider,
@@ -4037,6 +5128,7 @@ export {
   CONFIRMED_MATCH_STATUSES,
   DEFAULT_AGG_ROOT_CLASS_NAME,
   EventListStateProvider,
+  MAX_ORDER_VENUE_MARKET_IDS_PER_REQUEST,
   MAX_PRICE_GAP_PCT,
   MIN_PRICE_GAP_PCT,
   MarketStatus,
@@ -4067,6 +5159,7 @@ export {
   getVisibleVenueIdsByConfig,
   getVisibleVenuesByConfig,
   getWalletAddressFromUserProfile,
+  hostedVenueAccountQueryKeys,
   invalidateBalanceQueries,
   invalidatePositionQueries,
   invalidateUserActivityQueries,
@@ -4092,6 +5185,7 @@ export {
   resolveRecurringCryptoTimeline,
   resolveRollingWindow,
   resolveTradingStateKind,
+  retinaImageUrl,
   sharedKycQueryKeys,
   sortVenues,
   sportsLiveQueryKey,
@@ -4123,10 +5217,14 @@ export {
   useEventTradingContext,
   useExecuteManaged,
   useExecutionOrders,
+  useExecutionOrdersForMarkets,
   useExecutionPositions,
   useExecutionProgress,
   useExternalId,
   useGeoBlock,
+  useHostedVenueAccount,
+  useHostedVenueActivity,
+  useHostedVenueTransfers,
   useLabels,
   useLimitOrderVenueQuotes,
   useLinkAccount,
@@ -4141,6 +5239,7 @@ export {
   useManagedBalances,
   useMarketArb,
   useMarketChart,
+  useMarketCharts,
   useMarketOrderbook,
   useMarketSearch,
   useMidpoints,
@@ -4156,7 +5255,7 @@ export {
   usePaperOnboarding,
   usePlaceLimitOrder,
   usePositions,
-  useQueryClient2 as useQueryClient,
+  useQueryClient5 as useQueryClient,
   useRampQuotes,
   useRampSession,
   useRecurringCryptoMarkets,
@@ -4169,6 +5268,7 @@ export {
   useSdkLabels,
   useSdkUiConfig,
   useSearch,
+  useSettlementDetailsData,
   useSharedKyc,
   useSmartRoute,
   useSportsLive,