@agg-build/hooks 1.0.0

package/dist/chunk-CDPQERUC.mjs

@@ -0,0 +1,3601 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __pow = Math.pow;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// ../common/src/enums/venue.ts
+var Venue = /* @__PURE__ */ ((Venue2) => {
+  Venue2["kalshi"] = "kalshi";
+  Venue2["polymarket"] = "polymarket";
+  Venue2["limitless"] = "limitless";
+  Venue2["opinion"] = "opinion";
+  Venue2["predict"] = "predict";
+  Venue2["probable"] = "probable";
+  Venue2["myriad"] = "myriad";
+  Venue2["hyperliquid"] = "hyperliquid";
+  return Venue2;
+})(Venue || {});
+
+// ../common/src/enums/market-status.ts
+var MatchStatus = /* @__PURE__ */ ((MatchStatus2) => {
+  MatchStatus2["pending"] = "pending";
+  MatchStatus2["unmatched"] = "unmatched";
+  MatchStatus2["review"] = "review";
+  MatchStatus2["matched"] = "matched";
+  MatchStatus2["verified"] = "verified";
+  MatchStatus2["rejected"] = "rejected";
+  return MatchStatus2;
+})(MatchStatus || {});
+var MatchType = /* @__PURE__ */ ((MatchType2) => {
+  MatchType2["manual"] = "manual";
+  MatchType2["llm"] = "llm";
+  return MatchType2;
+})(MatchType || {});
+var CONFIRMED_MATCH_STATUSES = ["matched" /* matched */, "verified" /* verified */];
+var MarketStatus = /* @__PURE__ */ ((MarketStatus2) => {
+  MarketStatus2["open"] = "open";
+  MarketStatus2["closed"] = "closed";
+  MarketStatus2["resolved"] = "resolved";
+  MarketStatus2["unopened"] = "unopened";
+  MarketStatus2["paused"] = "paused";
+  return MarketStatus2;
+})(MarketStatus || {});
+
+// ../common/src/utils/auth.ts
+function getWalletAddressFromUserProfile(user) {
+  var _a, _b, _c, _d, _e;
+  const oauthWallet = (_b = (_a = user == null ? void 0 : user.accounts) == null ? void 0 : _a.find(
+    (a) => a.type === "oauth" /* oauth */ && String(a.provider).toLowerCase() === "wallet"
+  )) != null ? _b : null;
+  if (oauthWallet == null ? void 0 : oauthWallet.providerAccountId) return oauthWallet.providerAccountId;
+  const siweAccount = (_d = (_c = user == null ? void 0 : user.accounts) == null ? void 0 : _c.find((a) => a.type === "siwe" /* siwe */)) != null ? _d : null;
+  return (_e = siweAccount == null ? void 0 : siweAccount.providerAccountId) != null ? _e : void 0;
+}
+
+// ../common/src/utils/validate.ts
+var EMAIL_MSG = "Enter a valid email address.";
+var EMAIL_MAX_LEN = 254;
+function isEmail(v) {
+  const n = v.length;
+  if (n === 0 || n > EMAIL_MAX_LEN) return false;
+  let atIdx = -1;
+  for (let i = 0; i < n; i++) {
+    const c = v.charCodeAt(i);
+    if (c === 32 || c >= 9 && c <= 13) return false;
+    if (c === 64) {
+      if (atIdx !== -1) return false;
+      atIdx = i;
+    }
+  }
+  if (atIdx <= 0 || atIdx === n - 1) return false;
+  for (let i = atIdx + 2; i < n - 1; i++) {
+    if (v.charCodeAt(i) === 46) return true;
+  }
+  return false;
+}
+function parseEmail(raw) {
+  const email = raw.trim();
+  if (!isEmail(email)) {
+    return { success: false, error: { issues: [{ message: EMAIL_MSG }] } };
+  }
+  return { success: true, data: { email } };
+}
+function parseEmailStrict(raw) {
+  var _a;
+  const result = parseEmail(raw);
+  if (!result.success) {
+    const err = new Error(EMAIL_MSG);
+    err.issues = (_a = result.error) == null ? void 0 : _a.issues;
+    throw err;
+  }
+  return result.data;
+}
+
+// ../common/src/utils/image-url.ts
+function pickVariant(px) {
+  if (px <= 44 /* sm */) return 44 /* sm */;
+  if (px <= 48 /* md */) return 48 /* md */;
+  if (px <= 60 /* lg */) return 60 /* lg */;
+  return 0 /* original */;
+}
+var VARIANT_RE = /\/(original|raw|\d+)\.webp$/;
+function optimizedImageUrl(url, maxPx) {
+  if (!url) return void 0;
+  if (!VARIANT_RE.test(url)) return url;
+  const variant = pickVariant(maxPx);
+  const filename = variant === 0 /* original */ ? "original.webp" : `${variant}.webp`;
+  return url.replace(VARIANT_RE, `/${filename}`);
+}
+
+// ../common/src/utils/sort-venues.ts
+var VENUE_SORT_ORDER = [
+  "polymarket" /* polymarket */,
+  "kalshi" /* kalshi */,
+  "opinion" /* opinion */,
+  "limitless" /* limitless */,
+  "predict" /* predict */,
+  "myriad" /* myriad */,
+  "hyperliquid" /* hyperliquid */
+];
+var venueOrderIndex = new Map(VENUE_SORT_ORDER.map((v, i) => [v, i]));
+var getVenueOrder = (venue) => {
+  var _a;
+  return (_a = venueOrderIndex.get(venue)) != null ? _a : VENUE_SORT_ORDER.length;
+};
+var sortVenues = (venues) => [...venues].sort((a, b) => getVenueOrder(a) - getVenueOrder(b));
+
+// src/candle-store.ts
+import { CandleBuilder } from "@agg-build/sdk";
+var MAX_BUILDERS = 60;
+var builders = /* @__PURE__ */ new Map();
+function getOrCreateBuilder(marketId) {
+  const existing = builders.get(marketId);
+  if (existing) {
+    builders.delete(marketId);
+    builders.set(marketId, existing);
+    return existing;
+  }
+  evict();
+  const builder = new CandleBuilder();
+  builders.set(marketId, builder);
+  return builder;
+}
+function getBuilder(marketId) {
+  return builders.get(marketId);
+}
+function resetAllBuilders() {
+  for (const builder of builders.values()) {
+    builder.reset();
+  }
+}
+function evict() {
+  var _a;
+  if (builders.size < MAX_BUILDERS) return;
+  const oldest = builders.keys().next().value;
+  if (oldest) {
+    (_a = builders.get(oldest)) == null ? void 0 : _a.dispose();
+    builders.delete(oldest);
+  }
+}
+
+// src/core/ui-config/labels.ts
+var enUsLabels = {
+  common: {
+    close: "Close",
+    loading: "Loading",
+    retry: "Retry",
+    errorPrefix: "Error",
+    tabsAria: "Tabs",
+    hiddenTabsAria: "Hidden tabs",
+    selectAria: "Select",
+    lineChartAria: "Line chart",
+    candlestickChartAria: "Candlestick chart",
+    lineChartSeriesSwitchAria: "Chart series switch",
+    lineChartSeriesOptionAria: (seriesLabel) => `Show ${seriesLabel} series`,
+    chartTypeSwitchAria: "Chart type switch",
+    lineChartType: "Line",
+    candlestickChartType: "Candlestick"
+  },
+  venues: {
+    polymarket: "Polymarket",
+    kalshi: "Kalshi",
+    opinion: "Opinion",
+    predict: "Predict",
+    limitless: "Limitless",
+    probable: "Probable",
+    myriad: "Myriad",
+    hyperliquid: "Hyperliquid"
+  },
+  auth: {
+    connect: (connectorName) => connectorName ? `Sign in with ${connectorName}` : "Sign in",
+    signIn: "Sign in",
+    signingIn: "Signing in...",
+    signInStatement: "Sign in to AGG",
+    emailAddress: "Email address",
+    continue: "Continue",
+    emailUnavailable: "Email sign-in is currently unavailable.",
+    signInWithMethod: (methodLabel) => `Sign in with ${methodLabel}`,
+    socialWalletNotice: "A wallet will automatically be created for you when signing up with a social account.",
+    learnMore: "Learn more",
+    dividerOr: "OR",
+    connectWallet: "Connect wallet",
+    terms: "Terms",
+    privacyPolicy: "Privacy Policy",
+    legalNoticePrefix: "By signing in, you agree to our",
+    legalNoticeSeparator: "&",
+    deposit: "Deposit",
+    depositGeoBlocked: "Deposits are not available in your region.",
+    balances: "Balances",
+    viewAll: "View All",
+    loadingBalances: "Loading balances...",
+    myProfile: "My Profile",
+    withdraw: "Withdraw",
+    disconnect: "Disconnect",
+    claimWinnings: "Claim Now",
+    claimableWinningsBadge: (count) => `${count} claimable winning${count === 1 ? "" : "s"}`,
+    claimableWinningsTooltip: (count) => `${count} position${count === 1 ? "" : "s"} ready to claim`,
+    walletMenuFor: (profileLabel) => `Profile menu for ${profileLabel}`
+  },
+  deposit: {
+    title: "Deposit",
+    back: "Go back",
+    balancePrefix: "Balance:",
+    balanceLabel: "Balance",
+    done: "Done",
+    methods: {
+      walletTitle: (walletLabel) => `Use your wallet (${walletLabel})`,
+      walletDescription: "Deposit instantly from your connected wallet",
+      cryptoTitle: "Send crypto",
+      cryptoDescription: "Transfer from any wallet or exchange",
+      cardTitle: "Deposit with card",
+      cardDescription: "Buy crypto instantly with your card"
+    },
+    walletFlow: {
+      title: "Use your wallet",
+      tokenLabel: "Token",
+      networkLabel: "Network",
+      amountLabel: "Amount",
+      max: "Max",
+      feePrefix: "Fee ~",
+      confirm: "Confirm Deposit"
+    },
+    sendCrypto: {
+      title: "Send crypto",
+      tokenLabel: "Supported token",
+      networkLabel: "Supported network",
+      depositAddressLabel: "Your deposit address",
+      copy: "Copy",
+      copied: "Copied!",
+      minDepositPrefix: "Min deposit",
+      warning: "Send only the selected token on the selected network. Wrong token or network may results in permanently lost funds.",
+      qrPlaceholder: "QR code placeholder",
+      addressLoadingTitle: "Preparing your deposit address...",
+      addressLoadingDescription: "We're generating your address, this usually takes a few seconds."
+    },
+    cardFlow: {
+      title: "Buy crypto",
+      amountLabel: "Amount",
+      currencyLabel: "Currency",
+      tokenLabel: "Token",
+      networkLabel: "Network",
+      destinationWalletLabel: "Destination wallet",
+      getQuotes: "Get Quotes",
+      minRequired: (amount) => `Min required: ${amount}`,
+      minAmountError: (amount) => `Enter at least ${amount} to continue`,
+      selectProviderTitle: "Select provider",
+      feeLabel: "Fee",
+      providerBadges: {
+        best: "BEST",
+        lowKyc: "LOW KYC"
+      },
+      successTitle: "Purchase complete",
+      successDescription: "Your USDC has been successfully added to your balance.",
+      pendingTitle: (provider) => `Complete your payment on ${provider}`,
+      pendingDescription: "Once your transaction is finished, your balance may take a few minutes to update. The deposit will appear in your activity once it's successful.",
+      viewActivity: "View Activity",
+      chooseAnotherProvider: "Choose another provider",
+      summary: {
+        provider: "Provider",
+        fees: "Fees"
+      },
+      loadingQuotes: "Finding the best rates...",
+      errorLoadingQuotesTitle: "Failed to load quotes",
+      errorLoadingQuotesDescription: "Please try again.",
+      retry: "Retry",
+      noQuotes: "No quotes available for this configuration.",
+      widgetTitle: "Complete Purchase"
+    },
+    processingTitle: "Processing deposit",
+    processingSteps: {
+      submitting: "Waiting for wallet confirmation",
+      submitted: "Wallet confirmed",
+      confirming: "Processing transaction\u2026",
+      updatingBalance: "Updating balance",
+      fundsAvailable: "Funds available"
+    },
+    successTitle: "Deposit complete",
+    successDescription: "Your USDC has been successfully added to your balance.",
+    summary: {
+      amountReceived: "Amount received",
+      network: "Network",
+      fromWallet: "From wallet",
+      gasFee: "Gas fee"
+    }
+  },
+  withdraw: {
+    title: "Withdraw",
+    back: "Go back",
+    done: "Done",
+    balancePrefix: "Balance:",
+    methods: {
+      cardTitle: "Withdraw with card",
+      cardDescription: "Withdraw funds to your card"
+    },
+    cardFlow: {
+      title: "Sell crypto",
+      amountLabel: "Amount",
+      currencyLabel: "Currency",
+      tokenLabel: "Token",
+      networkLabel: "Network",
+      destinationWalletLabel: "Destination wallet",
+      getQuotes: "Get Quotes",
+      selectProviderTitle: "Select provider",
+      feeLabel: "Fee",
+      providerBadges: {
+        best: "BEST",
+        lowKyc: "LOW KYC"
+      },
+      successTitle: "Withdrawal complete",
+      successDescription: "Your USDC has been successfully sent to your wallet.",
+      summary: {
+        provider: "Provider",
+        toWallet: "To wallet",
+        fees: "Fees"
+      }
+    },
+    summary: {
+      amountReceived: "Amount received",
+      network: "Network"
+    }
+  },
+  markets: {
+    emptyNoOpen: "No open markets available.",
+    emptyResolved: "This event has been resolved."
+  },
+  home: {
+    trending: "Trending",
+    topMarkets: "Top Markets",
+    newMarkets: "New Markets",
+    categoryTabsAria: "Home page category tabs"
+  },
+  userProfile: {
+    activity: {
+      depositType: "Deposit",
+      withdrawalType: "Withdraw",
+      depositTitles: {
+        connectedWallet: "Deposit from connected wallet",
+        externalWallet: "Deposit from external wallet",
+        card: "Deposit with card"
+      },
+      withdrawalTitle: (tokenSymbol) => `Withdraw ${tokenSymbol}`
+    },
+    positions: {
+      totalTradedHeader: "Total traded",
+      amountWonHeader: "Amount won",
+      claimHeader: "Claim",
+      claim: "Claim",
+      claimed: "Claimed",
+      pending: "Pending",
+      won: "Won",
+      lost: "Lost",
+      resolved: "Resolved",
+      marketClosed: "Market closed",
+      closed: "Closed"
+    }
+  },
+  eventList: {
+    matchedTab: "Matched",
+    loading: (title) => `Loading ${title}`,
+    tabsAria: (title) => `${title} tabs`,
+    emptyAria: "No events found",
+    emptyTitle: "No Events Found",
+    emptyDescription: "We couldn't find any events matching your filters.\nTry adjusting them or check back later.",
+    empty: "No events found for this tab.",
+    errorTitle: "Something went wrong",
+    errorDescription: "We're having trouble loading data right now.\nTry refreshing or check back later.",
+    viewResolved: "View resolved",
+    hideResolved: "Hide resolved"
+  },
+  search: {
+    placeholder: "Search...",
+    inputAria: "Search markets",
+    resultsAria: "Search results",
+    resultAria: (title) => `View ${title}`,
+    resultsSummary: (countLabel, query) => `${countLabel} search results for "${query}"`,
+    seeAllResults: "See all results",
+    loadingResults: "Loading search results",
+    noResultsTitle: "No markets found",
+    noResultsDescription: "Check your spelling or try a broader search term."
+  },
+  eventItem: {
+    loading: "Loading market tile",
+    unavailableAria: "Market tile unavailable",
+    unavailableTitle: "Market unavailable",
+    unavailableDescription: "We could not load this market right now.",
+    arbitrage: "Arbitrage",
+    priceGap: "Price Gap",
+    volumeSuffix: "Vol.",
+    marketSingular: "Market",
+    marketPlural: "Markets",
+    venueSingular: "Venue",
+    venuePlural: "Venues"
+  },
+  eventItemDetails: {
+    loading: "Loading market details",
+    unavailableAria: "Market details unavailable",
+    unavailableTitle: "Market details unavailable",
+    unavailableDescription: "We could not load this market right now.",
+    notFoundAria: "Event not found",
+    notFoundTitle: "Event Not Found",
+    notFoundDescription: "We couldn't find this event or it may no longer exist.",
+    chartUnavailableAria: "Chart unavailable",
+    chartUnavailableTitle: "Chart Unavailable",
+    chartUnavailableDescription: "We couldn't load live chart data for this event.",
+    historicalLineChartAria: (title) => `${title} historical line chart`,
+    outcomeSelectorAria: "Outcome selector",
+    yes: "Yes",
+    no: "No",
+    allTimeRange: "All",
+    volumeSuffix: "Vol.",
+    marketSelectPlaceholder: "Select market",
+    marketSelectSearchPlaceholder: "Search markets...",
+    marketSelectEmpty: "No markets found"
+  },
+  settlementSummary: {
+    title: "Settlement",
+    readFullDetails: "Read full details",
+    showLess: "Show less"
+  },
+  marketDetails: {
+    loading: "Loading market details",
+    unavailableAria: "Market details unavailable",
+    unavailableTitle: "Market details unavailable",
+    unavailableDescription: "We could not load this market right now.",
+    notFoundAria: "Market not found",
+    notFoundTitle: "Market Not Found",
+    notFoundDescription: "We couldn't find this market or it may no longer exist.",
+    chartUnavailableAria: "Chart unavailable",
+    chartUnavailableTitle: "Chart Unavailable",
+    chartUnavailableDescription: "We couldn't load live chart data for this market.",
+    orderBookEmptyAria: "No orders yet",
+    orderBookEmptyTitle: "No orders yet",
+    orderBookEmptyDescription: "Be the first to set the price on this market.",
+    orderBookResolvedAria: "Market resolved",
+    orderBookResolvedTitle: "Market Resolved",
+    orderBookResolvedDescription: "This market has been resolved and is no longer trading.",
+    orderBookUnavailableAria: "Orderbook unavailable",
+    orderBookUnavailableTitle: "Orderbook Unavailable",
+    orderBookUnavailableDescription: "We couldn't load live order data for this market.",
+    marketOutcomesAria: "Market outcomes",
+    tabsAria: "Market details tabs",
+    toggleOpenDetailsAria: (title) => `Open details for ${title}`,
+    toggleCloseDetailsAria: (title) => `Close details for ${title}`,
+    loadingOrderbookAria: "Loading orderbook",
+    loadingOrderbookLabel: "Loading orderbook...",
+    asks: "Asks",
+    bids: "Bids",
+    spread: "Spread",
+    midPrice: "Mid",
+    tradePrefix: "Trade",
+    priceColumn: "Price",
+    sharesColumn: "Shares",
+    totalColumn: "Total",
+    lastPrice: "Last",
+    graphAria: (title) => `${title} price history`,
+    outcomeSelectorAria: "Outcome selector",
+    showOutcomeAria: (label) => `Show ${label} outcome`,
+    viewResolved: "View resolved",
+    hideResolved: "Hide resolved",
+    volumeUnavailable: "Volume unavailable",
+    tabs: {
+      orderBook: "Order Book",
+      graph: "Graph",
+      other: "Other"
+    },
+    meta: {
+      status: "Status",
+      created: "Created",
+      opens: "Opens",
+      closes: "Closes",
+      markets: "Markets",
+      unknown: "Unknown",
+      venueSingular: "Venue",
+      venuePlural: "Venues",
+      volumeSuffix: "Vol."
+    }
+  },
+  trading: {
+    settlementSection: "Settlement",
+    settlementDifferencesTitle: "Key differences across venues",
+    settlementLoading: "Loading settlement",
+    settlementDetailsAria: (venueLabel) => `${venueLabel} settlement details`,
+    settlementShowMoreAria: (ctaLabel, venueLabel) => `${ctaLabel} for ${venueLabel}`,
+    settlementDescriptionLabel: "Description",
+    settlementRulesPrimaryLabel: "Resolution rules",
+    settlementRulesSecondaryLabel: "Additional rules",
+    disclaimer: "By trading, you agree to the Terms of Use of each exchange.",
+    geoBlockTermsLink: "Terms of Use",
+    geoBlockGenericMessage: "Trading is not available in your region. See ",
+    geoBlockVenueMessage: (venueLabel) => `Trading on ${venueLabel} is not available in your region. See `,
+    geoBlockMessageSuffix: " for more information.",
+    geoBlockModalAriaLabel: "Geo-restricted location",
+    geoBlockModalTitle: "Trading is not available in your current location",
+    geoBlockModalDescription: "You appear to be located in a restricted jurisdiction. You can still browse markets in view-only mode or return when you're in a supported region.",
+    geoBlockModalConfirm: "Confirm",
+    averagePrice: (value) => `${(value * 100).toLocaleString("en-US", {
+      minimumFractionDigits: 0,
+      maximumFractionDigits: 2
+    })}\xA2 avg. price`,
+    balance: (value) => `Balance ${value}`,
+    shares: (value) => `${value.toLocaleString("en-US", {
+      minimumFractionDigits: Number.isInteger(value) ? 0 : 2,
+      maximumFractionDigits: 6
+    })} shares`,
+    slippage: (value) => `Slippage: ${value}%`,
+    editSlippage: (value) => `Edit ${value}`,
+    collapseSlippage: (value) => `Collapse ${value}`,
+    resetSlippage: "Auto",
+    slippageWarning: (value) => `Slippage below ${value}% may prevent your order from executing.`,
+    slippageLow: (value) => `Slippage below ${value}% may prevent your order from executing.`,
+    slippageHigh: (value) => `Slippage above ${value}% increases the chance of an unfavorable trade.`,
+    showAdditionalVenues: (count) => `Show ${count} more venue${count === 1 ? "" : "s"}`,
+    hideAdditionalVenues: "Hide additional venues",
+    quoteExpired: "Quote expired. Please refresh.",
+    orderSubmitted: "Order submitted",
+    orderPending: "Your order is being processed...",
+    orderFailed: "Order failed. Please try again.",
+    orderDisabledEventResolved: "This event has been resolved.",
+    orderDisabledEventClosed: "This event is no longer accepting orders.",
+    orderDisabledEventPaused: "Trading is temporarily paused for this event.",
+    orderDisabledEventUnopened: "Trading has not opened yet for this event.",
+    orderDisabledEventUnavailable: "Trading is currently unavailable.",
+    orderDisabledMarketResolved: "This market has been resolved.",
+    orderDisabledMarketClosed: "This market is no longer accepting orders.",
+    orderDisabledMarketPaused: "Trading is temporarily paused for this market.",
+    orderDisabledMarketUnopened: "Trading has not opened yet for this market.",
+    orderDisabledMarketUnavailable: "Trading is currently unavailable for this market.",
+    orderDisabledNoMarket: "Select a market to place an order.",
+    orderDisabledNoOutcome: "Select an outcome to place an order.",
+    orderDisabledNoEvent: "No event selected.",
+    insufficientBalance: "Insufficient balance",
+    refreshQuote: "Refresh Quote",
+    confirmOrder: "Confirm Order",
+    withdrawSubmitted: "Withdrawal submitted",
+    withdrawProcessing: "Your withdrawal is being processed...",
+    estimatedCost: (value) => `Est. cost ${value}`,
+    partialFill: (filledSize, requestedSize) => `Only ${filledSize} of ${requestedSize} shares available at this price.`,
+    insufficientLiquidity: "Not enough liquidity available for this order size.",
+    noMarketSelected: "Select a market to place an order.",
+    noOrderbooks: "No live orderbooks are available for this market right now.",
+    quoteUnavailable: "Quote temporarily unavailable. Please try again.",
+    selectedVenueUnavailable: "The venue you selected is no longer available on this route. Review the updated options and try again.",
+    engineUnavailable: "The routing engine is temporarily unavailable. Please try again in a moment.",
+    insufficientInputAmount: "Trade amount is too small to cover bridging and execution costs. Increase your spend or deposit funds on the destination chain.",
+    minOrderSizeViolated: "Order size is below the venue minimum. Increase your spend.",
+    minimumOrderAmount: (amount) => `Minimum order is $${amount}`,
+    insufficientPosition: (totalShares) => `You only have ${totalShares} shares available to sell.`,
+    insufficientPositionGeneric: "You don't have enough shares to sell.",
+    insufficientSellDepth: "Not enough bid liquidity on the matched venues for this sell amount.",
+    noBidsAboveMinPrice: "No venue bids above the minimum price.",
+    signInRequired: "Sign in to get a routed quote",
+    kycRequired: "Verify to trade Kalshi",
+    kycNotVerifiedTooltip: "You have not been verified yet",
+    kycVerifyModalTitle: "Verify Your Identity",
+    kycVerifyModalDescription: "To start trading on Kalshi, you'll need to complete identity verification through dFlow. It only takes a few minutes and helps us stay compliant with regulations.",
+    kycStartVerification: "Start Verification",
+    kycDoItLater: "Do It Later",
+    kycSuccessTitle: "Verification successful",
+    kycSuccessDescription: "Your identity has been confirmed and you now have full access to trade on Kalshi markets.",
+    kycSuccessDone: "Done",
+    outcome: (label) => `Outcome: ${label}`,
+    smartRouting: "Smart Routing",
+    orderSplitting: "Order Splitting",
+    splitOrderDescription: "We split your order for the best price:",
+    viewAllRoutes: (count) => `View all (${count})`,
+    hideRoutes: "Hide routes",
+    venueUnavailableInRegion: "Unavailable in your region",
+    toWin: (tab) => tab === "buy" ? "To win" : "Payout",
+    buyingOutcome: (label) => `Buying ${label}`,
+    sellingOutcome: (label) => `Selling ${label}`,
+    findingBestRoute: "Finding the best route...",
+    submittingOrderProgress: "Submitting order...",
+    orderSubmittedProgress: (orderId) => `Order #${orderId.replace(/^#/, "")} submitted`,
+    executingOnVenue: (venueLabel) => `Executing on ${venueLabel}...`,
+    confirmTransactionInWallet: "Confirm the transaction in your wallet",
+    executionConfirmed: "Execution confirmed",
+    orderSuccessTitle: "Order placed",
+    orderSuccessDescription: "Your order has been submitted successfully.",
+    orderFailureTitle: "Order failed",
+    orderFailureDescription: (message) => message || "Something went wrong. Please try again.",
+    orderDone: "Done",
+    orderNewTrade: "New Trade",
+    orderShare: "Share",
+    orderRetry: "Try again",
+    orderContinue: "Continue",
+    orderDismiss: "Dismiss",
+    orderRetryVenue: (venueLabel) => `Retry ${venueLabel}`,
+    orderPartialFillStatus: (venueLabel) => `${venueLabel} order partially filled`,
+    orderVenueUnavailableStatus: (venueLabel) => `${venueLabel} unavailable, your funds have not been charged.`,
+    orderMarketResolvedStatus: (venueLabel) => `Market resolved on ${venueLabel} and is no longer accepting orders.`,
+    orderSummaryShares: "Shares",
+    orderSummaryAvgPrice: "Avg. price",
+    orderSummaryEstCost: "Est. cost",
+    orderSummaryVenue: "Venue",
+    orderComplete: "Order complete",
+    orderFilledAtPrice: (venueLabel, priceLabel) => `${venueLabel} order filled at ${priceLabel}`,
+    orderFilledAtPriceWithAmount: (venueLabel, priceLabel, amountLabel) => `${venueLabel} order filled at ${priceLabel} (${amountLabel})`,
+    orderPartiallyFilledAtPriceWithAmount: (venueLabel, priceLabel, amountLabel) => `${venueLabel} order partially filled at ${priceLabel} (${amountLabel})`,
+    orderSkip: "Skip",
+    orderRetryRemaining: "Retry remaining",
+    resolvedEarningsTitle: "Your Earnings",
+    resolvedSharesLabel: "Shares",
+    resolvedTotalPayoutLabel: "Total payout",
+    claimWinnings: "Claim Winnings",
+    boughtOutcomeAtPrice: (label, priceLabel) => `Bought ${label} at ${priceLabel}`,
+    soldOutcomeAtPrice: (label, priceLabel) => `Sold ${label} at ${priceLabel}`,
+    potentialReturnBonus: (value) => `+${value} Better Payout`,
+    withSmartRouting: "with Smart Routing",
+    buy: "Buy",
+    sell: "Sell",
+    amount: (side) => `${side === "buy" ? "Amount" : "Shares"}`
+  },
+  onboarding: {
+    modal: {
+      title: "Onboarding",
+      stepHowItWorks: "How it works",
+      stepProfileSetup: "Set up your profile",
+      stepConnectAccounts: "Connect accounts"
+    },
+    howItWorks: {
+      title: "How it works",
+      continue: "Continue",
+      features: {
+        createAccount: {
+          title: "Create Your Account",
+          description: "Add a few basic details to set up your account and personalize your experience on the platform."
+        },
+        linkAccounts: {
+          title: "Link Trading Accounts",
+          description: "Connect supported exchanges to unlock additional markets and liquidity. Trade across decentralized markets in one interface."
+        },
+        bestPrices: {
+          title: "Best Prices Always",
+          description: "Our real-time aggregated orderbook lets you shop lines across exchanges and automatically splits predictions to optimize trades."
+        },
+        stayInControl: {
+          title: "You Stay in Control",
+          description: "All trades are executed on the original platform. We never custody funds or move money on your behalf."
+        }
+      }
+    },
+    profileSetup: {
+      title: "Set up your profile",
+      uploadProfilePictureAria: "Upload profile picture",
+      profilePreviewAlt: "Profile preview",
+      usernameLabel: "Username",
+      usernamePlaceholder: "e.g. CryptoJohn",
+      continue: "Continue"
+    },
+    connectAccounts: {
+      title: "Connect Accounts",
+      connect: "Connect",
+      connectAccount: "Connect Account",
+      continue: "Continue",
+      onchainTitle: "Onchain exchanges",
+      onchainMobileTitle: (additionalVenueCount) => `Polymarket +${additionalVenueCount} venues`,
+      onchainDescription: "Trade multiple venues with one signature.",
+      onchainMobileDescription: "Trade multiple exchanges with one signature",
+      kalshiTitle: "US regulated exchanges",
+      kalshiMobileTitle: "Kalshi",
+      kalshiDescription: "Trade on regulated markets via Kalshi.",
+      kalshiMobileDescription: "Connect your Kalshi account"
+    },
+    connectOnchainModal: {
+      ariaLabel: "Connect Onchain Exchanges",
+      title: "Connect Onchain Exchanges",
+      description: "Sign in with your wallet to trade across supported\nonchain prediction markets.",
+      supportedVenuesLabel: "Supported venues:",
+      connect: "Sign In with Wallet",
+      cancel: "Cancel",
+      fallbackError: "Signature declined. Please try again."
+    },
+    connectKalshiModal: {
+      ariaLabel: "Connect Kalshi Account",
+      title: "Connect Kalshi Account",
+      description: "You'll generate an API key in Kalshi profile and add it to connect your account. These keys are used only to execute trades on your behalf.",
+      stepOne: {
+        label: "Step 1",
+        title: "Generate a Read/Write API Key in Kalshi",
+        instructions: {
+          signIn: "1. Sign in to your Kalshi account.",
+          goToProfilePrefix: "2. Go to your",
+          profileText: "Profile",
+          goToProfileSeparator: ":",
+          profileUrl: "https://kalshi.com/account/profile",
+          clickCreateKeyPrefix: "3. Click",
+          createKeyText: "Create Key",
+          clickCreateKeySuffix: ".",
+          selectPermissionsPrefix: "4. Select",
+          readWriteText: "Read/Write",
+          selectPermissionsSuffix: " permissions.",
+          createKey: "5. Create the key."
+        },
+        footerLineOne: "Kalshi will display your API Key ID and Private Key.",
+        footerLineTwo: "You'll need both for the next step."
+      },
+      stepTwo: {
+        label: "Step 2",
+        title: "Paste Your Kalshi API Credentials",
+        description: "These credentials are encrypted and used only to execute trades on your behalf. We can't access your funds directly.",
+        apiKeyIdLabel: "API Key ID",
+        apiKeyIdPlaceholder: "a3f9c1b2-7d4e-4c91-9f2a-8b6e1d3c5a77",
+        privateKeyLabel: "Private Key",
+        privateKeyPlaceholder: "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASC..."
+      },
+      help: {
+        label: "Having trouble?",
+        docsLinkLabel: "View Kalshi docs",
+        tutorialLinkLabel: "Watch tutorial video"
+      },
+      actions: {
+        cancel: "Cancel",
+        verifyConnection: "Verify Connection"
+      },
+      fallbackError: "Verification failed. Please check your credentials and try again."
+    }
+  },
+  eventMarketPage: {
+    unavailableAria: "Event market page unavailable",
+    unavailableTitle: "Something went wrong",
+    unavailableDescription: "We're having trouble loading this event right now.\nTry refreshing or check back later.",
+    loadingSettlementQuestion: "Loading settlement",
+    loadingSettlementDifferencesTitle: "Loading settlement",
+    loadingSettlementPlaceholder: "Loading",
+    tradingResolvedBadge: "Resolved",
+    tradingResolvedTitle: "Market resolved",
+    tradingResolvedDescription: "Trading has ended for this event. You can review the final result.",
+    tradingClosedBadge: "Closed",
+    tradingClosedTitle: "Trading closed",
+    tradingClosedDescription: "This event is no longer accepting new orders.",
+    tradingPausedBadge: "Paused",
+    tradingPausedTitle: "Trading paused",
+    tradingPausedDescription: "Trading is temporarily unavailable for this event.",
+    tradingUnopenedBadge: "Upcoming",
+    tradingUnopenedTitle: "Trading not open yet",
+    tradingUnopenedDescription: "This event is listed, but trading has not opened yet.",
+    tradingUnavailableBadge: "Unavailable",
+    tradingUnavailableTitle: "Trading unavailable",
+    tradingUnavailableDescription: "Trading is currently unavailable for this event.",
+    resolvedAt: (dateLabel) => `Resolved ${dateLabel}`,
+    closedAt: (dateLabel) => `Closed ${dateLabel}`,
+    opensAt: (dateLabel) => `Opens ${dateLabel}`,
+    winningOutcome: (label) => `Winning outcome: ${label}`,
+    resolvedOutcome: (label) => `Resolved: ${label}`,
+    marketDetailsAriaByDate: (dateLabel) => `Market details for ${dateLabel}`,
+    marketDetailsAriaByQuestion: (question) => `Market details for ${question}`
+  },
+  header: {
+    bannerAria: "Site header",
+    logoAria: "Home"
+  }
+};
+var defaultAggUiLabelsByLocale = {
+  "en-US": enUsLabels,
+  en: enUsLabels
+};
+var isObjectValue = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+var mergeObjectValues = (baseValue, overrideValue) => {
+  const mergedEntries = Object.entries(baseValue).map(([key, value]) => {
+    const nextOverrideValue = overrideValue[key];
+    if (typeof nextOverrideValue === "undefined") {
+      return [key, value];
+    }
+    if (isObjectValue(value) && isObjectValue(nextOverrideValue)) {
+      return [key, mergeObjectValues(value, nextOverrideValue)];
+    }
+    return [key, nextOverrideValue];
+  });
+  return Object.fromEntries(mergedEntries);
+};
+var resolveAggUiLabels = (locale) => {
+  var _a;
+  if (defaultAggUiLabelsByLocale[locale]) {
+    return defaultAggUiLabelsByLocale[locale];
+  }
+  const baseLocale = locale.split("-")[0];
+  return (_a = defaultAggUiLabelsByLocale[baseLocale]) != null ? _a : enUsLabels;
+};
+var mergeAggUiLabels = (baseLabels, overrides) => {
+  if (!overrides) return baseLabels;
+  return mergeObjectValues(baseLabels, overrides);
+};
+
+// src/core/ui-config/utils.ts
+var DEFAULT_LOCALE = "en-US";
+var createFormatters = (locale) => {
+  const number = new Intl.NumberFormat(locale, {
+    maximumFractionDigits: 2
+  });
+  const percent = new Intl.NumberFormat(locale, {
+    style: "percent",
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 0
+  });
+  const currency = new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency: "USD",
+    maximumFractionDigits: 2
+  });
+  const compactCurrency = new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency: "USD",
+    notation: "compact",
+    maximumFractionDigits: 0
+  });
+  const date = new Intl.DateTimeFormat(locale, {
+    month: "long",
+    day: "numeric",
+    year: "numeric"
+  });
+  return {
+    formatNumber: (value) => number.format(value),
+    formatPercent: (value) => percent.format(value),
+    formatCurrency: (value) => currency.format(value),
+    formatCompactCurrency: (value) => compactCurrency.format(value),
+    formatDate: (value) => date.format(value)
+  };
+};
+var defaultFormatters = createFormatters(DEFAULT_LOCALE);
+var defaultAggUiSearchConfig = {
+  value: "",
+  result: null,
+  isShowingAllResults: false
+};
+var defaultAggUiConfig = {
+  enableLogs: false,
+  enableWebsocketsLogs: false,
+  general: {
+    locale: DEFAULT_LOCALE,
+    theme: "light",
+    rootClassName: "",
+    labels: resolveAggUiLabels(DEFAULT_LOCALE)
+  },
+  features: {
+    enableAnimations: true,
+    enableLiveUpdates: true,
+    enableGradients: false
+  },
+  market: {
+    arbitrageThreshold: 0
+  },
+  chart: {
+    defaultChartTimeRange: "1D",
+    selectedChartTimeRange: "1D",
+    setSelectedChartTimeRange: () => {
+    }
+  },
+  formatting: defaultFormatters,
+  search: defaultAggUiSearchConfig
+};
+var mergeAggUiSearchConfig = (config) => {
+  var _a, _b, _c;
+  return {
+    value: (_a = config == null ? void 0 : config.value) != null ? _a : defaultAggUiSearchConfig.value,
+    onChange: config == null ? void 0 : config.onChange,
+    onSelect: config == null ? void 0 : config.onSelect,
+    openResults: config == null ? void 0 : config.openResults,
+    closeResults: config == null ? void 0 : config.closeResults,
+    result: (_b = config == null ? void 0 : config.result) != null ? _b : null,
+    isShowingAllResults: (_c = config == null ? void 0 : config.isShowingAllResults) != null ? _c : defaultAggUiSearchConfig.isShowingAllResults
+  };
+};
+var mergeAggUiConfig = (persisted, config) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K;
+  const locale = (_d = (_c = (_a = config == null ? void 0 : config.general) == null ? void 0 : _a.locale) != null ? _c : (_b = persisted.general) == null ? void 0 : _b.locale) != null ? _d : DEFAULT_LOCALE;
+  const theme = (_h = (_g = (_e = config == null ? void 0 : config.general) == null ? void 0 : _e.theme) != null ? _g : (_f = persisted.general) == null ? void 0 : _f.theme) != null ? _h : defaultAggUiConfig.general.theme;
+  const formatters = createFormatters(locale);
+  const defaultLabels = resolveAggUiLabels(locale);
+  return {
+    enableLogs: (_i = config == null ? void 0 : config.enableLogs) != null ? _i : defaultAggUiConfig.enableLogs,
+    enableWebsocketsLogs: (_j = config == null ? void 0 : config.enableWebsocketsLogs) != null ? _j : defaultAggUiConfig.enableWebsocketsLogs,
+    general: {
+      locale,
+      theme,
+      rootClassName: (_l = (_k = config == null ? void 0 : config.general) == null ? void 0 : _k.rootClassName) != null ? _l : defaultAggUiConfig.general.rootClassName,
+      labels: mergeAggUiLabels(defaultLabels, (_m = config == null ? void 0 : config.general) == null ? void 0 : _m.labels)
+    },
+    features: {
+      enableAnimations: (_o = (_n = config == null ? void 0 : config.features) == null ? void 0 : _n.enableAnimations) != null ? _o : defaultAggUiConfig.features.enableAnimations,
+      enableLiveUpdates: (_q = (_p = config == null ? void 0 : config.features) == null ? void 0 : _p.enableLiveUpdates) != null ? _q : defaultAggUiConfig.features.enableLiveUpdates,
+      enableGradients: (_s = (_r = config == null ? void 0 : config.features) == null ? void 0 : _r.enableGradients) != null ? _s : defaultAggUiConfig.features.enableGradients
+    },
+    market: {
+      arbitrageThreshold: (_u = (_t = config == null ? void 0 : config.market) == null ? void 0 : _t.arbitrageThreshold) != null ? _u : defaultAggUiConfig.market.arbitrageThreshold
+    },
+    chart: {
+      defaultChartTimeRange: (_w = (_v = config == null ? void 0 : config.chart) == null ? void 0 : _v.defaultChartTimeRange) != null ? _w : defaultAggUiConfig.chart.defaultChartTimeRange,
+      selectedChartTimeRange: (_A = (_z = (_x = persisted.chart) == null ? void 0 : _x.selectedChartTimeRange) != null ? _z : (_y = config == null ? void 0 : config.chart) == null ? void 0 : _y.defaultChartTimeRange) != null ? _A : defaultAggUiConfig.chart.defaultChartTimeRange,
+      setSelectedChartTimeRange: defaultAggUiConfig.chart.setSelectedChartTimeRange
+    },
+    formatting: {
+      formatNumber: (_C = (_B = config == null ? void 0 : config.formatting) == null ? void 0 : _B.formatNumber) != null ? _C : formatters.formatNumber,
+      formatPercent: (_E = (_D = config == null ? void 0 : config.formatting) == null ? void 0 : _D.formatPercent) != null ? _E : formatters.formatPercent,
+      formatCurrency: (_G = (_F = config == null ? void 0 : config.formatting) == null ? void 0 : _F.formatCurrency) != null ? _G : formatters.formatCurrency,
+      formatCompactCurrency: (_I = (_H = config == null ? void 0 : config.formatting) == null ? void 0 : _H.formatCompactCurrency) != null ? _I : formatters.formatCompactCurrency,
+      formatDate: (_K = (_J = config == null ? void 0 : config.formatting) == null ? void 0 : _J.formatDate) != null ? _K : formatters.formatDate
+    },
+    search: mergeAggUiSearchConfig(config == null ? void 0 : config.search),
+    walletActions: config == null ? void 0 : config.walletActions,
+    solanaRpcUrl: config == null ? void 0 : config.solanaRpcUrl
+  };
+};
+
+// src/execution/query-keys.ts
+var executionKeys = {
+  all: () => ["execution"],
+  balances: () => ["execution", "balances"],
+  positions: (cursor, limit, status) => ["execution", "positions", cursor != null ? cursor : null, limit != null ? limit : null, status != null ? status : null],
+  positionsPrefix: () => ["execution", "positions"],
+  claimableClosedPositionsCount: () => ["execution", "positions", "claimable-count"],
+  orders: (status, cursor, limit) => ["execution", "orders", status != null ? status : null, cursor != null ? cursor : null, limit != null ? limit : null],
+  ordersPrefix: () => ["execution", "orders"],
+  depositAddresses: () => ["execution", "deposit-addresses"]
+};
+
+// src/execution/balance-invalidation.ts
+var balanceQueryKeys = {
+  execution: () => executionKeys.balances(),
+  // Kept as an alias for backward compatibility with existing callers.
+  // The balance provider now uses the same canonical execution balances key.
+  provider: () => executionKeys.balances(),
+  venue: (venuesKey) => ["venue-balances", venuesKey],
+  venuePrefix: () => ["venue-balances"]
+};
+var BALANCE_REFRESHING_ORDER_EVENTS = /* @__PURE__ */ new Set(["filled", "partial_fill"]);
+var invalidateBalanceQueries = (queryClient, options) => {
+  var _a;
+  const refetchType = (_a = options == null ? void 0 : options.refetchType) != null ? _a : "active";
+  const executionKey = balanceQueryKeys.execution();
+  const providerKey = balanceQueryKeys.provider();
+  queryClient.invalidateQueries({
+    queryKey: executionKey,
+    refetchType
+  });
+  const isProviderKeyDistinct = providerKey.length !== executionKey.length || providerKey.some((segment, index) => segment !== executionKey[index]);
+  if (isProviderKeyDistinct) {
+    queryClient.invalidateQueries({
+      queryKey: providerKey,
+      refetchType
+    });
+  }
+  queryClient.invalidateQueries({
+    queryKey: balanceQueryKeys.venuePrefix(),
+    refetchType
+  });
+};
+var invalidatePositionQueries = (queryClient, options) => {
+  var _a;
+  queryClient.invalidateQueries({
+    queryKey: executionKeys.positionsPrefix(),
+    refetchType: (_a = options == null ? void 0 : options.refetchType) != null ? _a : "active"
+  });
+};
+var shouldInvalidateBalancesForOrderEvent = (event, currentUserId) => {
+  if (!BALANCE_REFRESHING_ORDER_EVENTS.has(event.event)) return false;
+  if (!currentUserId) return true;
+  return event.userId === currentUserId;
+};
+
+// src/core/providers/balance-provider.tsx
+import { useQuery } from "@tanstack/react-query";
+import { useCallback, useContext, useMemo } from "react";
+
+// src/core/providers/contexts.ts
+import { createContext } from "react";
+var AggClientContext = createContext(null);
+var AggUiContext = createContext(defaultAggUiConfig);
+var AggLabelsContext = createContext(defaultAggUiConfig.general.labels);
+var AggAuthContext = createContext(null);
+var AggBalanceContext = createContext(null);
+
+// src/core/providers/balance-provider.tsx
+import { jsx } from "react/jsx-runtime";
+var CHAIN_LABELS = {
+  1: "Ethereum",
+  10: "Optimism",
+  56: "BNB",
+  137: "Polygon",
+  8453: "Base",
+  42161: "Arbitrum",
+  43114: "Avalanche",
+  11155111: "Sepolia",
+  792703809: "Solana"
+};
+var chainLabelFromId = (chainId) => {
+  var _a;
+  return (_a = CHAIN_LABELS[chainId]) != null ? _a : `Chain ${chainId}`;
+};
+var toTokenUnits = (raw, decimals) => {
+  const numeric = Number(raw);
+  if (!Number.isFinite(numeric)) return 0;
+  return numeric / __pow(10, decimals);
+};
+var isUsdBasedToken = (tokenSymbol) => {
+  var _a;
+  return (_a = tokenSymbol == null ? void 0 : tokenSymbol.toUpperCase()) == null ? void 0 : _a.includes("USD");
+};
+var EMPTY_MANAGED_BALANCES = {
+  cash: [],
+  positions: []
+};
+function AggBalanceProvider({ children }) {
+  const client = useContext(AggClientContext);
+  const authContext = useContext(AggAuthContext);
+  if (!authContext) {
+    throw new Error("AggBalanceProvider must be used within an <AggAuthProvider>");
+  }
+  const { isAuthenticated } = authContext;
+  const balancesQuery = useQuery({
+    queryKey: balanceQueryKeys.provider(),
+    queryFn: () => __async(null, null, function* () {
+      if (!client || !isAuthenticated) {
+        return EMPTY_MANAGED_BALANCES;
+      }
+      return client.getManagedBalances();
+    }),
+    enabled: Boolean(client && isAuthenticated),
+    staleTime: 1e4
+  });
+  const managedBalancesData = balancesQuery.data;
+  const managedBalances = useMemo(
+    () => managedBalancesData != null ? managedBalancesData : EMPTY_MANAGED_BALANCES,
+    [managedBalancesData]
+  );
+  const connectedVenues = useMemo(() => {
+    return Array.from(new Set(managedBalances.positions.map((position) => position.venue))).sort(
+      (a, b) => a.localeCompare(b)
+    );
+  }, [managedBalances.positions]);
+  const balancesError = balancesQuery.error;
+  const isBalancesLoading = balancesQuery.isLoading;
+  const refetchBalances = balancesQuery.refetch;
+  const totalBalance = useMemo(() => {
+    const cash = managedBalances.cash;
+    return cash.reduce((sum, token) => {
+      if (!isUsdBasedToken(token.tokenSymbol)) return sum;
+      const tokenAcrossChains = token.chains.reduce(
+        (chainSum, chain) => {
+          var _a;
+          return chainSum + toTokenUnits(chain.balanceRaw, (_a = chain.decimals) != null ? _a : token.decimals);
+        },
+        0
+      );
+      return sum + tokenAcrossChains;
+    }, 0);
+  }, [managedBalances]);
+  const balanceBreakdown = useMemo(() => {
+    var _a, _b;
+    const byChain = /* @__PURE__ */ new Map();
+    const cash = managedBalances.cash;
+    for (const token of cash) {
+      if (!isUsdBasedToken(token.tokenSymbol)) continue;
+      for (const chain of token.chains) {
+        const current = (_a = byChain.get(chain.chainId)) != null ? _a : {
+          label: chainLabelFromId(chain.chainId),
+          balance: 0,
+          accountCount: 0
+        };
+        current.balance += toTokenUnits(chain.balanceRaw, (_b = chain.decimals) != null ? _b : token.decimals);
+        current.accountCount += 1;
+        byChain.set(chain.chainId, current);
+      }
+    }
+    return Array.from(byChain.entries()).sort((a, b) => a[1].label.localeCompare(b[1].label)).map(([chainId, value2]) => ({
+      key: String(chainId),
+      label: value2.label,
+      balance: value2.balance,
+      accountCount: value2.accountCount,
+      venues: connectedVenues.length > 0 ? connectedVenues : void 0
+    }));
+  }, [connectedVenues, managedBalances]);
+  const positionsBalanceTotal = useMemo(() => {
+    const positions = managedBalances.positions;
+    return positions.reduce(
+      (sum, position) => sum + (Number.isFinite(position.balance) ? position.balance : 0),
+      0
+    );
+  }, [managedBalances]);
+  const refetch = useCallback(() => {
+    if (!isAuthenticated) return;
+    void refetchBalances();
+  }, [isAuthenticated, refetchBalances]);
+  const refetchConnectionStatus = useCallback(() => {
+    if (!client || !isAuthenticated) return;
+    void client.getCurrentUser();
+  }, [client, isAuthenticated]);
+  const value = useMemo(() => {
+    if (!isAuthenticated) {
+      return {
+        managedBalances,
+        totalBalance: 0,
+        positionsBalanceTotal: 0,
+        balanceBreakdown: [],
+        connectedVenues: [],
+        isLoading: false,
+        error: null,
+        refetch,
+        refetchConnectionStatus
+      };
+    }
+    const error = balancesError instanceof Error ? balancesError : balancesError ? new Error(String(balancesError)) : null;
+    return {
+      managedBalances,
+      totalBalance,
+      positionsBalanceTotal,
+      balanceBreakdown,
+      connectedVenues,
+      isLoading: isBalancesLoading,
+      error,
+      refetch,
+      refetchConnectionStatus
+    };
+  }, [
+    balanceBreakdown,
+    balancesError,
+    connectedVenues,
+    isBalancesLoading,
+    isAuthenticated,
+    managedBalances,
+    positionsBalanceTotal,
+    refetch,
+    refetchConnectionStatus,
+    totalBalance
+  ]);
+  return /* @__PURE__ */ jsx(AggBalanceContext.Provider, { value, children });
+}
+
+// src/core/providers/event-list-state-context.tsx
+import { createContext as createContext2, useCallback as useCallback2, useContext as useContext2, useRef } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var STALENESS_THRESHOLD_MS = 5 * 60 * 1e3;
+var MAX_INITIAL_PAGES = 10;
+var EventListStateContext = createContext2(null);
+function EventListStateProvider({ children }) {
+  const snapshotRef = useRef(null);
+  const capture = useCallback2((state) => {
+    snapshotRef.current = __spreadProps(__spreadValues({}, state), {
+      loadedPageCount: Math.min(state.loadedPageCount, MAX_INITIAL_PAGES),
+      capturedAt: Date.now()
+    });
+  }, []);
+  const consume = useCallback2(() => {
+    const snapshot = snapshotRef.current;
+    snapshotRef.current = null;
+    if (!snapshot) return null;
+    const age = Date.now() - snapshot.capturedAt;
+    if (age > STALENESS_THRESHOLD_MS) return null;
+    return snapshot;
+  }, []);
+  const value = useRef({ capture, consume });
+  value.current.capture = capture;
+  value.current.consume = consume;
+  const stableValue = useRef({
+    capture: (...args) => value.current.capture(...args),
+    consume: () => value.current.consume()
+  }).current;
+  return /* @__PURE__ */ jsx2(EventListStateContext.Provider, { value: stableValue, children });
+}
+function useEventListState() {
+  const context = useContext2(EventListStateContext);
+  if (!context) {
+    throw new Error("useEventListState must be used within an <AggProvider>");
+  }
+  return context;
+}
+
+// src/core/providers/hooks.ts
+import { useContext as useContext3 } from "react";
+var useAggClient = () => {
+  const client = useContext3(AggClientContext);
+  if (!client) {
+    throw new Error("useAggClient must be used within an <AggProvider>");
+  }
+  return client;
+};
+var useAggUiConfig = () => {
+  return useContext3(AggUiContext);
+};
+var useAggLabels = () => {
+  return useContext3(AggLabelsContext);
+};
+var useAggAuthContext = () => {
+  const context = useContext3(AggAuthContext);
+  if (!context) {
+    throw new Error("useAggAuthContext must be used within an <AggProvider>");
+  }
+  return context;
+};
+var useAggAuthState = useAggAuthContext;
+var useAggBalanceContext = () => {
+  const context = useContext3(AggBalanceContext);
+  if (!context) {
+    throw new Error("useAggBalanceContext must be used within an <AggProvider>");
+  }
+  return context;
+};
+var useAggBalanceState = useAggBalanceContext;
+var useAggBalance = useAggBalanceContext;
+var useSdkUiConfig = useAggUiConfig;
+var useSdkLabels = useAggLabels;
+var useLabels = useAggLabels;
+
+// src/core/providers/ws-provider.tsx
+import {
+  createContext as createContext3,
+  useCallback as useCallback3,
+  useContext as useContext4,
+  useEffect,
+  useMemo as useMemo2,
+  useRef as useRef2,
+  useState
+} from "react";
+import { useQueryClient } from "@tanstack/react-query";
+
+// src/market-data/chart-cache.ts
+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 createVenueData = (venue, outcomeIds = []) => ({
+  venue,
+  outcomeIds,
+  candles: [],
+  liveCandle: null,
+  lineValue: void 0,
+  lastTrade: null
+});
+var sortCandles = (candles) => {
+  return [...candles].sort((left, right) => left.time - right.time);
+};
+var createMarketChartData = (params) => {
+  const candles = sortCandles(
+    params.response.data.map((candle) => ({
+      time: Math.floor(candle.t / 1e3),
+      open: candle.o,
+      high: candle.h,
+      low: candle.l,
+      close: candle.c,
+      volume: candle.v,
+      source: "rest"
+    }))
+  );
+  const lastCandle = candles[candles.length - 1];
+  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
+    }
+  };
+  return {
+    marketId: params.marketId,
+    outcomeIds: [params.response.venueMarketOutcomeId],
+    primaryVenue: params.response.venue,
+    interval: params.interval,
+    startTs: params.startTs,
+    endTs: params.endTs,
+    venues
+  };
+};
+var mergeMarketChartData = (params) => {
+  var _a, _b;
+  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,
+    outcomeIds,
+    primaryVenue,
+    interval: params.interval,
+    startTs: params.startTs,
+    endTs: params.endTs,
+    venues
+  };
+};
+var applyTradeToMarketChart = (data, trade) => {
+  var _a, _b, _c;
+  if (!data || data.marketId !== trade.outcomeId) {
+    return data;
+  }
+  const currentVenue = (_a = data.venues[trade.venue]) != null ? _a : createVenueData(trade.venue);
+  const intervalSeconds = getIntervalSeconds(data.interval);
+  const expectedCandleTime = trade.timestamp - trade.timestamp % intervalSeconds;
+  let liveCandle = currentVenue.liveCandle;
+  if (liveCandle && liveCandle.time === expectedCandleTime) {
+    liveCandle = __spreadProps(__spreadValues({}, liveCandle), {
+      close: trade.price,
+      high: Math.max(liveCandle.high, trade.price),
+      low: Math.min(liveCandle.low, trade.price),
+      volume: ((_b = liveCandle.volume) != null ? _b : 0) + trade.size,
+      source: "trade"
+    });
+  } else if (!liveCandle || liveCandle.time !== expectedCandleTime) {
+    liveCandle = {
+      time: expectedCandleTime,
+      open: trade.price,
+      high: trade.price,
+      low: trade.price,
+      close: trade.price,
+      volume: trade.size,
+      source: "trade"
+    };
+  }
+  return __spreadProps(__spreadValues({}, data), {
+    venues: __spreadProps(__spreadValues({}, data.venues), {
+      [trade.venue]: __spreadProps(__spreadValues({}, currentVenue), {
+        outcomeIds: currentVenue.outcomeIds.includes(trade.outcomeId) ? currentVenue.outcomeIds : [...currentVenue.outcomeIds, trade.outcomeId],
+        liveCandle,
+        lineValue: (_c = liveCandle == null ? void 0 : liveCandle.close) != null ? _c : trade.price,
+        lastTrade: trade
+      })
+    })
+  });
+};
+
+// src/market-data/live-cache.ts
+var MAX_TRADES = 50;
+var createMarketLiveState = (marketId, overrides) => __spreadValues({
+  marketId,
+  orderbook: null,
+  orderbookSnapshotVersion: 0,
+  orderbookError: null,
+  trades: [],
+  isConnected: false,
+  integrity: "ok"
+}, overrides);
+var withLiveConnectionState = (data, isConnected) => {
+  if (!data) return data;
+  if (data.isConnected === isConnected) return data;
+  return __spreadProps(__spreadValues({}, data), {
+    isConnected
+  });
+};
+var withLiveOrderbook = (data, orderbook, source) => {
+  const current = data != null ? data : createMarketLiveState(orderbook.marketId);
+  return __spreadProps(__spreadValues({}, current), {
+    orderbook,
+    orderbookSnapshotVersion: source === "snapshot" ? current.orderbookSnapshotVersion + 1 : current.orderbookSnapshotVersion,
+    orderbookError: null,
+    integrity: "ok"
+  });
+};
+var withLiveOrderbookError = (data, marketId, orderbookError) => {
+  const current = data != null ? data : createMarketLiveState(marketId);
+  if (current.orderbookError === orderbookError && current.marketId === marketId) {
+    return current;
+  }
+  return __spreadProps(__spreadValues({}, current), {
+    marketId,
+    orderbookError
+  });
+};
+var withLiveIntegrity = (data, integrity) => {
+  if (!data) return data;
+  if (data.integrity === integrity) return data;
+  return __spreadProps(__spreadValues({}, data), {
+    integrity
+  });
+};
+var withLiveTrade = (data, trade) => {
+  const current = data != null ? data : createMarketLiveState(trade.outcomeId);
+  const trades = [trade, ...current.trades].slice(0, MAX_TRADES);
+  return __spreadProps(__spreadValues({}, current), {
+    trades
+  });
+};
+
+// 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 withOrderbookIntegrity = (data, integrity) => {
+  if (!data) return data;
+  if (data.integrity === integrity) return data;
+  return __spreadProps(__spreadValues({}, data), {
+    integrity
+  });
+};
+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/query-keys.ts
+var marketDataKeys = {
+  all: () => ["market-data"],
+  live: (marketId) => ["market-data", "live", marketId],
+  livePrefix: () => ["market-data", "live"],
+  orderbook: (marketId, selectionKey, depth) => ["market-data", "orderbook", marketId, selectionKey != null ? selectionKey : null, depth != null ? depth : null],
+  orderbookPrefix: (marketId) => marketId == null ? ["market-data", "orderbook"] : ["market-data", "orderbook", marketId],
+  orderbookQuote: (marketId, side, size) => ["market-data", "orderbook-quote", marketId, side, size],
+  chart: (marketId, interval, startTs, endTs, countBack) => ["market-data", "chart", marketId, interval, startTs, endTs, countBack != null ? countBack : null],
+  chartPrefix: (marketId, interval) => {
+    if (!marketId) return ["market-data", "chart"];
+    if (!interval) return ["market-data", "chart", marketId];
+    return ["market-data", "chart", marketId, interval];
+  }
+};
+
+// src/core/providers/ws-provider.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+var AggWebSocketContext = createContext3(null);
+var AggWebSocketConnectionContext = createContext3(false);
+var AggWsUserEventContext = createContext3(null);
+var snapshotUnavailableOutcomeIdPattern = /snapshot unavailable for\s+([^\s]+)/i;
+var ORDERBOOK_DEBUG_TOP_LEVELS = 5;
+var resolveSnapshotUnavailableOutcomeId = (errorMessage) => {
+  var _a;
+  const matchedOutcomeId = (_a = snapshotUnavailableOutcomeIdPattern.exec(errorMessage)) == null ? void 0 : _a[1];
+  if (!matchedOutcomeId) return null;
+  return matchedOutcomeId.replace(/[.,;:!?]+$/, "");
+};
+var summarizeTopLevels = (levels) => {
+  return levels.slice(0, ORDERBOOK_DEBUG_TOP_LEVELS).map((level) => ({ price: level.price, size: level.size }));
+};
+var debugOrderbook = (enabled, event, payload) => {
+  if (!enabled) return;
+  console.debug(`[AggHooks][ws-provider] ${event}`, payload);
+};
+function useAggWebSocket() {
+  return useContext4(AggWebSocketContext);
+}
+function useAggWebSocketConnectionState() {
+  return useContext4(AggWebSocketConnectionContext);
+}
+function useOnOrderSubmitted(callback) {
+  const listeners = useContext4(AggWsUserEventContext);
+  const callbackRef = useRef2(callback);
+  callbackRef.current = callback;
+  const hasCallback = callback !== null;
+  useEffect(() => {
+    if (!listeners || !callbackRef.current) return;
+    const handler = (msg) => {
+      var _a;
+      (_a = callbackRef.current) == null ? void 0 : _a.call(callbackRef, msg);
+    };
+    return listeners.addOrderSubmittedListener(handler);
+  }, [listeners, hasCallback]);
+}
+function useOnBalanceUpdate(callback) {
+  const listeners = useContext4(AggWsUserEventContext);
+  const callbackRef = useRef2(callback);
+  callbackRef.current = callback;
+  const hasCallback = callback !== null;
+  useEffect(() => {
+    if (!listeners || !callbackRef.current) return;
+    const handler = (msg) => {
+      var _a;
+      (_a = callbackRef.current) == null ? void 0 : _a.call(callbackRef, msg);
+    };
+    return listeners.addBalanceUpdateListener(handler);
+  }, [listeners, hasCallback]);
+}
+function useOnOrderEvent(callback) {
+  const listeners = useContext4(AggWsUserEventContext);
+  const callbackRef = useRef2(callback);
+  callbackRef.current = callback;
+  const hasCallback = callback !== null;
+  useEffect(() => {
+    if (!listeners || !callbackRef.current) return;
+    const handler = (msg) => {
+      var _a;
+      (_a = callbackRef.current) == null ? void 0 : _a.call(callbackRef, msg);
+    };
+    return listeners.addOrderEventListener(handler);
+  }, [listeners, hasCallback]);
+}
+function useOnRedeemEvent(callback) {
+  const listeners = useContext4(AggWsUserEventContext);
+  const callbackRef = useRef2(callback);
+  callbackRef.current = callback;
+  const hasCallback = callback !== null;
+  useEffect(() => {
+    if (!listeners || !callbackRef.current) return;
+    const handler = (msg) => {
+      var _a;
+      (_a = callbackRef.current) == null ? void 0 : _a.call(callbackRef, msg);
+    };
+    return listeners.addRedeemEventListener(handler);
+  }, [listeners, hasCallback]);
+}
+function AggWebSocketProvider({ children }) {
+  const client = useAggClient();
+  const { enableWebsocketsLogs } = useAggUiConfig();
+  const queryClient = useQueryClient();
+  const [ws, setWs] = useState(null);
+  const [isConnected, setIsConnected] = useState(false);
+  const [isClientAuthenticated, setIsClientAuthenticated] = useState(client.isAuthenticated);
+  const wsRef = useRef2(null);
+  const resyncDeadlineByMarketRef = useRef2(/* @__PURE__ */ new Map());
+  const lastBalanceInvalidationAtRef = useRef2(0);
+  useEffect(() => {
+    setIsClientAuthenticated(client.isAuthenticated);
+    return client.onAuthStateChange((authenticated) => {
+      setIsClientAuthenticated(authenticated);
+    });
+  }, [client]);
+  const orderSubmittedListenersRef = useRef2(/* @__PURE__ */ new Set());
+  const balanceUpdateListenersRef = useRef2(/* @__PURE__ */ new Set());
+  const orderEventListenersRef = useRef2(/* @__PURE__ */ new Set());
+  const redeemEventListenersRef = useRef2(/* @__PURE__ */ new Set());
+  const userEventListeners = useMemo2(
+    () => ({
+      addOrderSubmittedListener: (cb) => {
+        orderSubmittedListenersRef.current.add(cb);
+        return () => {
+          orderSubmittedListenersRef.current.delete(cb);
+        };
+      },
+      addBalanceUpdateListener: (cb) => {
+        balanceUpdateListenersRef.current.add(cb);
+        return () => {
+          balanceUpdateListenersRef.current.delete(cb);
+        };
+      },
+      addOrderEventListener: (cb) => {
+        orderEventListenersRef.current.add(cb);
+        return () => {
+          orderEventListenersRef.current.delete(cb);
+        };
+      },
+      addRedeemEventListener: (cb) => {
+        redeemEventListenersRef.current.add(cb);
+        return () => {
+          redeemEventListenersRef.current.delete(cb);
+        };
+      }
+    }),
+    []
+  );
+  const syncOrderbookQueries = useCallback3(
+    (marketId, updater) => {
+      var _a;
+      const queries = queryClient.getQueryCache().findAll({
+        queryKey: marketDataKeys.orderbookPrefix(marketId)
+      });
+      for (const query of queries) {
+        const depth = (_a = query.queryKey[4]) != null ? _a : null;
+        queryClient.setQueryData(
+          query.queryKey,
+          (previous) => updater(query.queryKey, depth, previous)
+        );
+      }
+    },
+    [queryClient]
+  );
+  const syncChartQueries = useCallback3(
+    (marketId, updater) => {
+      const queries = queryClient.getQueryCache().findAll({
+        queryKey: marketDataKeys.chartPrefix(marketId)
+      });
+      for (const query of queries) {
+        queryClient.setQueryData(
+          query.queryKey,
+          (previous) => updater(query.queryKey, previous)
+        );
+      }
+    },
+    [queryClient]
+  );
+  const syncLiveQuery = useCallback3(
+    (marketId, updater) => {
+      queryClient.setQueryData(marketDataKeys.live(marketId), (previous) => {
+        return updater(previous);
+      });
+    },
+    [queryClient]
+  );
+  const invalidateBalanceCaches = useCallback3(() => {
+    const now = Date.now();
+    if (now - lastBalanceInvalidationAtRef.current < 750) return;
+    lastBalanceInvalidationAtRef.current = now;
+    invalidateBalanceQueries(queryClient);
+  }, [queryClient]);
+  const invalidatePositionCaches = useCallback3(() => {
+    invalidatePositionQueries(queryClient);
+  }, [queryClient]);
+  const callbacks = useMemo2(
+    () => ({
+      onSnapshot: (marketId, book) => {
+        const orderbook = createMarketOrderbookDataFromState(book);
+        resyncDeadlineByMarketRef.current.delete(marketId);
+        syncOrderbookQueries(marketId, (_queryKey, depth, previous) => {
+          var _a;
+          const previousSnapshotVersion = (_a = previous == null ? void 0 : previous.snapshotVersion) != null ? _a : 0;
+          return applyOrderbookDepth(
+            __spreadProps(__spreadValues({}, orderbook), {
+              snapshotVersion: previousSnapshotVersion + 1
+            }),
+            depth
+          );
+        });
+        syncLiveQuery(marketId, (previous) => withLiveOrderbook(previous, book, "snapshot"));
+        if (book.midpoint != null) {
+          getOrCreateBuilder(marketId).addMidpoint(book.midpoint, book.timestamp);
+        }
+      },
+      onDelta: (marketId, book) => {
+        var _a, _b;
+        const previousLiveState = queryClient.getQueryData(marketDataKeys.live(marketId));
+        debugOrderbook(enableWebsocketsLogs, "delta_received", {
+          outcomeId: marketId,
+          seq: book.seq,
+          checksum: book.checksum,
+          hasTargetOrderbook: Boolean(previousLiveState == null ? void 0 : previousLiveState.orderbook),
+          beforeTop: (previousLiveState == null ? void 0 : previousLiveState.orderbook) ? {
+            bids: summarizeTopLevels(previousLiveState.orderbook.bids),
+            asks: summarizeTopLevels(previousLiveState.orderbook.asks)
+          } : null,
+          afterTop: {
+            bids: summarizeTopLevels(book.bids),
+            asks: summarizeTopLevels(book.asks)
+          }
+        });
+        const orderbook = createMarketOrderbookDataFromState(book);
+        resyncDeadlineByMarketRef.current.delete(marketId);
+        syncOrderbookQueries(marketId, (_queryKey, depth, previous) => {
+          var _a2;
+          const previousSnapshotVersion = (_a2 = previous == null ? void 0 : previous.snapshotVersion) != null ? _a2 : 0;
+          return applyOrderbookDepth(
+            __spreadProps(__spreadValues({}, orderbook), {
+              snapshotVersion: previousSnapshotVersion
+            }),
+            depth
+          );
+        });
+        syncLiveQuery(marketId, (previous) => withLiveOrderbook(previous, book, "delta"));
+        const nextLiveState = queryClient.getQueryData(
+          marketDataKeys.live(marketId)
+        );
+        debugOrderbook(enableWebsocketsLogs, "delta_cached", {
+          outcomeId: marketId,
+          seq: (_b = (_a = nextLiveState == null ? void 0 : nextLiveState.orderbook) == null ? void 0 : _a.seq) != null ? _b : null,
+          selectorTop: (nextLiveState == null ? void 0 : nextLiveState.orderbook) ? {
+            bids: summarizeTopLevels(nextLiveState.orderbook.bids),
+            asks: summarizeTopLevels(nextLiveState.orderbook.asks)
+          } : null
+        });
+        if (book.midpoint != null) {
+          getOrCreateBuilder(marketId).addMidpoint(book.midpoint, book.timestamp);
+        }
+      },
+      onTrade: (trade) => {
+        syncChartQueries(trade.outcomeId, (_queryKey, previous) => {
+          return applyTradeToMarketChart(previous, trade);
+        });
+        syncLiveQuery(trade.outcomeId, (previous) => withLiveTrade(previous, trade));
+        getOrCreateBuilder(trade.outcomeId).addTrade(trade.price, trade.size, trade.timestamp);
+      },
+      onHeartbeat: () => {
+        const now = Date.now();
+        resyncDeadlineByMarketRef.current.forEach((deadline, marketId) => {
+          var _a;
+          if (deadline > now) return;
+          (_a = wsRef.current) == null ? void 0 : _a.resnapshot(marketId);
+          resyncDeadlineByMarketRef.current.set(marketId, now + 35e3);
+        });
+      },
+      onDiagnostics: (event) => {
+        var _a;
+        if (event.type !== "seq_gap" && event.type !== "checksum_mismatch") return;
+        const id = (_a = event.outcomeId) != null ? _a : event.marketId;
+        resyncDeadlineByMarketRef.current.set(id, Date.now() + 35e3);
+        syncOrderbookQueries(
+          id,
+          (_queryKey, _depth, previous) => withOrderbookIntegrity(previous, "resyncing")
+        );
+        syncLiveQuery(id, (previous) => withLiveIntegrity(previous, "resyncing"));
+      },
+      onOrderSubmitted: (msg) => {
+        for (const listener of orderSubmittedListenersRef.current) {
+          listener(msg);
+        }
+      },
+      onBalanceUpdate: (msg) => {
+        if (isClientAuthenticated) {
+          invalidateBalanceCaches();
+        }
+        for (const listener of balanceUpdateListenersRef.current) {
+          listener(msg);
+        }
+      },
+      onOrderEvent: (msg) => {
+        var _a, _b;
+        if (isClientAuthenticated) {
+          const currentUserId = (_b = (_a = client.user) == null ? void 0 : _a.id) != null ? _b : null;
+          if (shouldInvalidateBalancesForOrderEvent(msg, currentUserId)) {
+            invalidateBalanceCaches();
+            invalidatePositionCaches();
+          }
+        }
+        for (const listener of orderEventListenersRef.current) {
+          listener(msg);
+        }
+      },
+      onRedeemEvent: (msg) => {
+        for (const listener of redeemEventListenersRef.current) {
+          listener(msg);
+        }
+      },
+      onError: (msg) => {
+        const outcomeId = resolveSnapshotUnavailableOutcomeId(msg.message);
+        if (!outcomeId) return;
+        syncLiveQuery(
+          outcomeId,
+          (previous) => withLiveOrderbookError(previous, outcomeId, msg.message)
+        );
+      },
+      onConnectionStateChange: (connected) => {
+        setIsConnected(connected);
+        if (connected) {
+          queryClient.invalidateQueries({
+            queryKey: marketDataKeys.chartPrefix(),
+            refetchType: "active"
+          });
+        } else {
+          resetAllBuilders();
+        }
+        const liveQueries = queryClient.getQueryCache().findAll({
+          queryKey: marketDataKeys.livePrefix()
+        });
+        for (const query of liveQueries) {
+          queryClient.setQueryData(query.queryKey, (previous) => {
+            return withLiveConnectionState(
+              previous,
+              connected
+            );
+          });
+        }
+      }
+    }),
+    [
+      client,
+      enableWebsocketsLogs,
+      invalidateBalanceCaches,
+      invalidatePositionCaches,
+      isClientAuthenticated,
+      queryClient,
+      syncChartQueries,
+      syncLiveQuery,
+      syncOrderbookQueries
+    ]
+  );
+  useEffect(() => {
+    let instance = null;
+    const resyncDeadlineByMarket = resyncDeadlineByMarketRef.current;
+    try {
+      instance = client.createWebSocket(callbacks, { enableLogs: enableWebsocketsLogs });
+    } catch (e) {
+      console.warn(
+        "[AggUI] WebSocket connection could not be established. Ensure wsUrl is configured in createAggClient(). Real-time features (live prices, order updates) are disabled."
+      );
+      setWs(null);
+      wsRef.current = null;
+      setIsConnected(false);
+      return;
+    }
+    setWs(instance);
+    wsRef.current = instance;
+    return () => {
+      instance == null ? void 0 : instance.destroy();
+      if (wsRef.current === instance) {
+        wsRef.current = null;
+      }
+      resyncDeadlineByMarket.clear();
+      setWs(null);
+      setIsConnected(false);
+    };
+  }, [callbacks, client, enableWebsocketsLogs, isClientAuthenticated]);
+  return /* @__PURE__ */ jsx3(AggWebSocketConnectionContext.Provider, { value: isConnected, children: /* @__PURE__ */ jsx3(AggWsUserEventContext.Provider, { value: userEventListeners, children: /* @__PURE__ */ jsx3(AggWebSocketContext.Provider, { value: ws, children }) }) });
+}
+
+// src/core/ui-config/constants.ts
+var DEFAULT_AGG_ROOT_CLASS_NAME = "agg-root";
+var CHART_TIME_RANGES = ["1H", "6H", "1D", "1W", "1M", "ALL"];
+
+// src/core/providers/event-trading-context.tsx
+import { createContext as createContext4, useCallback as useCallback4, useContext as useContext5, useMemo as useMemo3, useReducer, useRef as useRef3 } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var OPEN_TRADING_STATE = {
+  kind: "open",
+  status: "open" /* open */,
+  isOpen: true,
+  isTradingDisabled: false,
+  startsAt: null,
+  endsAt: null,
+  resolvesAt: null,
+  winningOutcome: null
+};
+var resolveTradingStateKind = (status) => {
+  if (!status || status === "open" /* open */) return "open";
+  if (status === "resolved" /* resolved */) return "resolved";
+  if (status === "paused" /* paused */) return "paused";
+  if (status === "unopened" /* unopened */) return "unopened";
+  return "closed";
+};
+var resolveMarketWinningOutcome = (market) => {
+  var _a;
+  if (!market) return null;
+  return (_a = market.venueMarketOutcomes.find((outcome) => outcome.winner === true)) != null ? _a : null;
+};
+var AFFIRMATIVE_WINNER_LABELS = /* @__PURE__ */ new Set(["yes", "up", "buy", "long", "true"]);
+var isAffirmativeWinnerLabel = (label) => {
+  if (!label) return false;
+  return AFFIRMATIVE_WINNER_LABELS.has(label.trim().toLowerCase());
+};
+var resolvePreferredWinningMarket = (marketStates) => {
+  var _a, _b;
+  const marketWithAffirmativeWinner = marketStates.find(
+    (item) => {
+      var _a2;
+      return isAffirmativeWinnerLabel((_a2 = item.state.winningOutcome) == null ? void 0 : _a2.label);
+    }
+  );
+  if (marketWithAffirmativeWinner) {
+    return marketWithAffirmativeWinner.market;
+  }
+  return (_b = (_a = marketStates.find((item) => item.state.winningOutcome)) == null ? void 0 : _a.market) != null ? _b : null;
+};
+var resolveMarketTradingState = (market) => {
+  var _a, _b, _c, _d;
+  if (!market) {
+    return __spreadProps(__spreadValues({}, OPEN_TRADING_STATE), {
+      kind: "unavailable",
+      status: null,
+      isOpen: false,
+      isTradingDisabled: true,
+      market: null
+    });
+  }
+  const kind = resolveTradingStateKind(market.status);
+  return {
+    kind,
+    status: (_a = market.status) != null ? _a : kind === "open" ? "open" /* open */ : null,
+    isOpen: kind === "open",
+    isTradingDisabled: kind !== "open",
+    startsAt: (_b = market.startDate) != null ? _b : null,
+    endsAt: (_c = market.endDate) != null ? _c : null,
+    resolvesAt: (_d = market.resolutionDate) != null ? _d : null,
+    market,
+    winningOutcome: resolveMarketWinningOutcome(market)
+  };
+};
+var deriveEventTradingStateKind = (marketStates) => {
+  if (marketStates.length === 0) return "unavailable";
+  if (marketStates.some((marketState) => marketState.kind === "open")) return "open";
+  if (marketStates.every((marketState) => marketState.kind === "resolved")) return "resolved";
+  if (marketStates.every((marketState) => marketState.kind === "paused")) return "paused";
+  if (marketStates.every((marketState) => marketState.kind === "unopened")) return "unopened";
+  return "closed";
+};
+var resolveEventStateStatus = (event, kind) => {
+  if (event.status) return event.status;
+  if (kind === "unavailable") return null;
+  if (kind === "open") return "open" /* open */;
+  if (kind === "resolved") return "resolved" /* resolved */;
+  if (kind === "paused") return "paused" /* paused */;
+  if (kind === "unopened") return "unopened" /* unopened */;
+  return "closed" /* closed */;
+};
+var resolveEventWinningOutcome = (marketStates, preferredMarket) => {
+  var _a, _b, _c, _d;
+  if (preferredMarket) {
+    return (_b = (_a = marketStates.find((item) => item.market.id === preferredMarket.id)) == null ? void 0 : _a.state.winningOutcome) != null ? _b : null;
+  }
+  return (_d = (_c = marketStates.find((item) => item.state.winningOutcome)) == null ? void 0 : _c.state.winningOutcome) != null ? _d : null;
+};
+var resolveEventTradingState = (event) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+  if (!(event == null ? void 0 : event.venueMarkets.length)) {
+    return __spreadProps(__spreadValues({}, OPEN_TRADING_STATE), {
+      kind: "unavailable",
+      status: (_a = event == null ? void 0 : event.status) != null ? _a : null,
+      isOpen: false,
+      isTradingDisabled: true,
+      startsAt: (_b = event == null ? void 0 : event.startDate) != null ? _b : null,
+      endsAt: (_c = event == null ? void 0 : event.endDate) != null ? _c : null,
+      displayMarkets: [],
+      tradableMarkets: [],
+      marketStates: [],
+      primaryMarket: null
+    });
+  }
+  const marketStates = event.venueMarkets.map((market) => ({
+    market,
+    state: resolveMarketTradingState(market)
+  }));
+  const derivedKind = deriveEventTradingStateKind(marketStates.map((item) => item.state));
+  const explicitKind = event.status ? resolveTradingStateKind(event.status) : null;
+  const kind = explicitKind && (explicitKind !== "open" || derivedKind === "open") ? explicitKind : derivedKind;
+  const preferredWinningMarket = resolvePreferredWinningMarket(marketStates);
+  const tradableMarkets = marketStates.filter((item) => item.state.isOpen).map((item) => item.market);
+  const displayMarkets = kind === "open" ? tradableMarkets : event.venueMarkets;
+  const primaryMarket = (_g = (_f = (_e = (_d = kind !== "open" ? preferredWinningMarket : null) != null ? _d : displayMarkets[0]) != null ? _e : tradableMarkets[0]) != null ? _f : event.venueMarkets[0]) != null ? _g : null;
+  return {
+    kind,
+    status: resolveEventStateStatus(event, kind),
+    isOpen: kind === "open",
+    isTradingDisabled: kind !== "open",
+    startsAt: (_i = (_h = event.startDate) != null ? _h : primaryMarket == null ? void 0 : primaryMarket.startDate) != null ? _i : null,
+    endsAt: (_k = (_j = event.endDate) != null ? _j : primaryMarket == null ? void 0 : primaryMarket.endDate) != null ? _k : null,
+    resolvesAt: (_n = (_m = (_l = marketStates.find((item) => item.state.resolvesAt)) == null ? void 0 : _l.state.resolvesAt) != null ? _m : primaryMarket == null ? void 0 : primaryMarket.resolutionDate) != null ? _n : null,
+    winningOutcome: resolveEventWinningOutcome(marketStates, preferredWinningMarket),
+    displayMarkets,
+    tradableMarkets,
+    marketStates,
+    primaryMarket
+  };
+};
+var toEventReason = (kind) => {
+  var _a;
+  const mapped = {
+    resolved: "event_resolved",
+    closed: "event_closed",
+    paused: "event_paused",
+    unopened: "event_unopened",
+    unavailable: "event_unavailable"
+  };
+  return (_a = mapped[kind]) != null ? _a : "event_unavailable";
+};
+var toMarketReason = (kind) => {
+  var _a;
+  const mapped = {
+    resolved: "market_resolved",
+    closed: "market_closed",
+    paused: "market_paused",
+    unopened: "market_unopened",
+    unavailable: "market_unavailable"
+  };
+  return (_a = mapped[kind]) != null ? _a : "market_unavailable";
+};
+var resolveOrderEligibility = (params) => {
+  var _a;
+  if (!params.event) return { canPlaceOrder: false, reason: "no_event_selected" };
+  if (!params.market) return { canPlaceOrder: false, reason: "no_market_selected" };
+  if (!params.outcome) return { canPlaceOrder: false, reason: "no_outcome_selected" };
+  const eventState = (_a = params.eventTradingState) != null ? _a : resolveEventTradingState(params.event);
+  if (eventState.isTradingDisabled) {
+    return { canPlaceOrder: false, reason: toEventReason(eventState.kind) };
+  }
+  const marketState = resolveMarketTradingState(params.market);
+  if (marketState.isTradingDisabled) {
+    return { canPlaceOrder: false, reason: toMarketReason(marketState.kind) };
+  }
+  return { canPlaceOrder: true, reason: "eligible" };
+};
+function resolveDefaultMarket(event) {
+  var _a;
+  if (!(event == null ? void 0 : event.venueMarkets.length)) return null;
+  const tradableMarket = event.venueMarkets.find(
+    (market) => resolveMarketTradingState(market).isOpen
+  );
+  if (tradableMarket) return tradableMarket;
+  const marketStates = event.venueMarkets.map((market) => ({
+    market,
+    state: resolveMarketTradingState(market)
+  }));
+  const preferredWinningMarket = resolvePreferredWinningMarket(marketStates);
+  return (_a = preferredWinningMarket != null ? preferredWinningMarket : event.venueMarkets[0]) != null ? _a : null;
+}
+function resolveDefaultOutcome(market) {
+  var _a, _b;
+  const yesOutcome = market == null ? void 0 : market.venueMarketOutcomes.find((o) => {
+    var _a2;
+    return ((_a2 = o == null ? void 0 : o.label) == null ? void 0 : _a2.toLowerCase()) === "yes";
+  });
+  if (yesOutcome) return yesOutcome;
+  return (_b = (_a = market == null ? void 0 : market.venueMarketOutcomes) == null ? void 0 : _a[0]) != null ? _b : null;
+}
+function findMarketById(event, marketId) {
+  var _a;
+  if (!event) return null;
+  return (_a = event.venueMarkets.find((m) => m.id === marketId)) != null ? _a : null;
+}
+function findOutcomeById(market, outcomeId) {
+  var _a;
+  if (!market) return null;
+  return (_a = market.venueMarketOutcomes.find((o) => o.id === outcomeId)) != null ? _a : null;
+}
+function findOutcomeAcrossMarkets(event, outcomeId) {
+  if (!event) return null;
+  for (const market of event.venueMarkets) {
+    const outcome = market.venueMarketOutcomes.find((o) => o.id === outcomeId);
+    if (outcome) return { market, outcome };
+  }
+  return null;
+}
+function tradingReducer(state, action) {
+  var _a, _b;
+  switch (action.type) {
+    case "INITIALIZE_EVENT": {
+      if (!action.event) {
+        return { event: null, market: null, outcome: null };
+      }
+      const market = resolveDefaultMarket(action.event);
+      return {
+        event: action.event,
+        market,
+        outcome: resolveDefaultOutcome(market)
+      };
+    }
+    case "SYNC_EVENT": {
+      const nextEvent = action.event;
+      const preservedMarket = state.market ? findMarketById(nextEvent, state.market.id) : null;
+      if (preservedMarket) {
+        const preservedMarketState = resolveMarketTradingState(preservedMarket);
+        if (preservedMarketState.isTradingDisabled) {
+          const tradableAlternative = resolveDefaultMarket(nextEvent);
+          if (tradableAlternative && resolveMarketTradingState(tradableAlternative).isOpen) {
+            return {
+              event: nextEvent,
+              market: tradableAlternative,
+              outcome: resolveDefaultOutcome(tradableAlternative)
+            };
+          }
+        }
+        const preservedOutcome = state.outcome ? findOutcomeById(preservedMarket, state.outcome.id) : null;
+        return {
+          event: nextEvent,
+          market: preservedMarket,
+          outcome: preservedOutcome != null ? preservedOutcome : resolveDefaultOutcome(preservedMarket)
+        };
+      }
+      const defaultMarket = resolveDefaultMarket(nextEvent);
+      return {
+        event: nextEvent,
+        market: defaultMarket,
+        outcome: resolveDefaultOutcome(defaultMarket)
+      };
+    }
+    case "SELECT_MARKET": {
+      const market = (_b = (_a = findMarketById(state.event, action.marketId)) != null ? _a : action.market) != null ? _b : null;
+      if (!market) return state;
+      if (resolveMarketTradingState(market).kind === "resolved") return state;
+      return __spreadProps(__spreadValues({}, state), {
+        market,
+        outcome: resolveDefaultOutcome(market)
+      });
+    }
+    case "SELECT_OUTCOME": {
+      if (state.market) {
+        const outcomeInCurrentMarket = findOutcomeById(state.market, action.outcomeId);
+        if (outcomeInCurrentMarket) {
+          if (resolveMarketTradingState(state.market).kind === "resolved") {
+            return state;
+          }
+          return __spreadProps(__spreadValues({}, state), { outcome: outcomeInCurrentMarket });
+        }
+      }
+      const found = findOutcomeAcrossMarkets(state.event, action.outcomeId);
+      if (!found) return state;
+      const targetMarketState = resolveMarketTradingState(found.market);
+      if (targetMarketState.isTradingDisabled) return state;
+      return __spreadProps(__spreadValues({}, state), {
+        market: found.market,
+        outcome: found.outcome
+      });
+    }
+    case "SELECT_MARKET_AND_OUTCOME": {
+      const market = findMarketById(state.event, action.marketId);
+      if (!market) return state;
+      if (resolveMarketTradingState(market).kind === "resolved") return state;
+      const outcome = findOutcomeById(market, action.outcomeId);
+      if (!outcome) return state;
+      return __spreadProps(__spreadValues({}, state), { market, outcome });
+    }
+    default: {
+      const _exhaustive = action;
+      return _exhaustive;
+    }
+  }
+}
+function logAction(actionType, payload, prev, next, enableLogs) {
+  var _a, _b, _c, _d, _e;
+  if (!enableLogs) return;
+  console.group(`[EventTrading] ${actionType}`);
+  console.log("payload", payload);
+  console.log("prev", prev);
+  console.log("next", next);
+  console.log("IDS", {
+    eventId: (_a = next.event) == null ? void 0 : _a.id,
+    marketIds: (_b = next.event) == null ? void 0 : _b.venueMarkets.map((m) => m.id),
+    outcomeIds: (_c = next.event) == null ? void 0 : _c.venueMarkets.flatMap((m) => m.venueMarketOutcomes.map((o) => o.id)),
+    selectedMarketId: (_d = next.market) == null ? void 0 : _d.id,
+    selectedOutcomeId: (_e = next.outcome) == null ? void 0 : _e.id
+  });
+  console.groupEnd();
+}
+var initialState = {
+  event: null,
+  market: null,
+  outcome: null
+};
+var EventTradingContext = createContext4(void 0);
+var useEventTradingContext = () => {
+  return useContext5(EventTradingContext);
+};
+var EventTradingProvider = ({
+  children,
+  enableLogs = false
+}) => {
+  const [state, rawDispatch] = useReducer(tradingReducer, initialState);
+  const stateRef = useRef3(state);
+  stateRef.current = state;
+  const dispatch = useCallback4(
+    (action) => {
+      const prev = stateRef.current;
+      rawDispatch(action);
+      const next = tradingReducer(prev, action);
+      logAction(action.type, action, prev, next, enableLogs);
+    },
+    [enableLogs]
+  );
+  const initializeFromEvent = useCallback4(
+    (event) => dispatch({ type: "INITIALIZE_EVENT", event }),
+    [dispatch]
+  );
+  const syncEvent = useCallback4(
+    (event) => dispatch({ type: "SYNC_EVENT", event }),
+    [dispatch]
+  );
+  const selectMarket = useCallback4(
+    (marketId, market) => dispatch({ type: "SELECT_MARKET", marketId, market }),
+    [dispatch]
+  );
+  const selectOutcome = useCallback4(
+    (outcomeId) => dispatch({ type: "SELECT_OUTCOME", outcomeId }),
+    [dispatch]
+  );
+  const selectMarketAndOutcome = useCallback4(
+    (marketId, outcomeId) => dispatch({ type: "SELECT_MARKET_AND_OUTCOME", marketId, outcomeId }),
+    [dispatch]
+  );
+  const value = useMemo3(
+    () => {
+      var _a, _b, _c, _d, _e, _f, _g, _h;
+      return {
+        selectedEvent: state.event,
+        selectedMarket: state.market,
+        selectedOutcome: state.outcome,
+        selectedEventId: (_b = (_a = state.event) == null ? void 0 : _a.id) != null ? _b : null,
+        selectedMarketId: (_d = (_c = state.market) == null ? void 0 : _c.id) != null ? _d : null,
+        selectedOutcomeId: (_f = (_e = state.outcome) == null ? void 0 : _e.id) != null ? _f : null,
+        selectedVenue: (_h = (_g = state.market) == null ? void 0 : _g.venue) != null ? _h : null,
+        initializeFromEvent,
+        syncEvent,
+        selectMarket,
+        selectOutcome,
+        selectMarketAndOutcome
+      };
+    },
+    [state, initializeFromEvent, syncEvent, selectMarket, selectOutcome, selectMarketAndOutcome]
+  );
+  return /* @__PURE__ */ jsx4(EventTradingContext.Provider, { value, children });
+};
+
+// src/core/providers/ui-provider.tsx
+import { useCallback as useCallback5, useEffect as useEffect2, useMemo as useMemo4, useState as useState2 } from "react";
+
+// src/core/ui-config/storage.ts
+var STORAGE_KEY = "agg_sdk_ui";
+var isBrowser = () => typeof window !== "undefined" && "localStorage" in window;
+var normalizeTheme = (value) => {
+  if (value === "light" || value === "dark") {
+    return value;
+  }
+  return void 0;
+};
+var normalizeChartTimeRange = (value) => {
+  if (typeof value === "string" && CHART_TIME_RANGES.includes(value)) {
+    return value;
+  }
+  return void 0;
+};
+var loadPersistedConfig = () => {
+  var _a, _b, _c;
+  if (!isBrowser()) return {};
+  try {
+    const raw = window.localStorage.getItem(STORAGE_KEY);
+    if (!raw) return {};
+    const parsed = JSON.parse(raw);
+    const locale = typeof ((_a = parsed.general) == null ? void 0 : _a.locale) === "string" ? parsed.general.locale : void 0;
+    const theme = normalizeTheme((_b = parsed.general) == null ? void 0 : _b.theme);
+    const selectedChartTimeRange = normalizeChartTimeRange((_c = parsed.chart) == null ? void 0 : _c.selectedChartTimeRange);
+    const result = {};
+    if (locale || theme) {
+      result.general = { locale, theme };
+    }
+    if (selectedChartTimeRange) {
+      result.chart = { selectedChartTimeRange };
+    }
+    return result;
+  } catch (e) {
+    return {};
+  }
+};
+var persistConfig = (config) => {
+  if (!isBrowser()) return;
+  const theme = normalizeTheme(config.theme);
+  const selectedChartTimeRange = normalizeChartTimeRange(config.selectedChartTimeRange);
+  const payload = __spreadValues({
+    general: {
+      locale: config.locale,
+      theme
+    }
+  }, selectedChartTimeRange ? { chart: { selectedChartTimeRange } } : {});
+  try {
+    window.localStorage.setItem(STORAGE_KEY, JSON.stringify(payload));
+  } catch (e) {
+  }
+};
+
+// src/core/ui-config/theme-utils.ts
+var applyThemeToDocument = (theme) => {
+  if (typeof document === "undefined") return;
+  const isDark = theme === "dark";
+  document.documentElement.dataset.aggTheme = theme;
+  document.documentElement.classList.toggle("dark", isDark);
+  document.documentElement.classList.toggle("agg-dark", isDark);
+  document.documentElement.classList.toggle("light", !isDark);
+  const aggRoots = document.querySelectorAll(".agg-root");
+  aggRoots.forEach((rootElement) => {
+    rootElement.dataset.aggTheme = theme;
+    rootElement.classList.toggle("dark", isDark);
+    rootElement.classList.toggle("agg-dark", isDark);
+    rootElement.classList.toggle("light", !isDark);
+  });
+};
+
+// src/core/providers/ui-provider.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+var hasWarnedMissingAggStyles = false;
+var warnIfAggStylesAreMissing = () => {
+  if (hasWarnedMissingAggStyles) return;
+  if (typeof window === "undefined" || typeof document === "undefined") return;
+  const rootElement = document.querySelector(`.${DEFAULT_AGG_ROOT_CLASS_NAME}`);
+  if (!rootElement) return;
+  const computedStyle = window.getComputedStyle(rootElement);
+  const hasSemanticColorToken = computedStyle.getPropertyValue("--agg-color-primary").trim().length > 0;
+  const hasTailwindColorToken = computedStyle.getPropertyValue("--color-agg-primary").trim().length > 0;
+  const hasTailwindRadiusToken = computedStyle.getPropertyValue("--radius-agg-md").trim().length > 0;
+  if (hasSemanticColorToken && hasTailwindColorToken && hasTailwindRadiusToken) {
+    return;
+  }
+  hasWarnedMissingAggStyles = true;
+  console.warn(
+    '[agg] Missing AGG UI styles. Import "@agg-build/ui/styles.css" once at your app entrypoint so agg token utilities resolve correctly.'
+  );
+};
+function logConfig(config, enableLogs) {
+  if (!enableLogs) return;
+  console.group(`[AggUiProvider]`);
+  console.log("config", config);
+  console.groupEnd();
+}
+var getSearchStateAfterSelect = (selectedEvent) => {
+  return {
+    value: "",
+    result: selectedEvent,
+    isShowingAllResults: false
+  };
+};
+var AggUiProvider = ({ config, children }) => {
+  const persisted = useMemo4(() => loadPersistedConfig(), []);
+  const mergedConfig = useMemo4(() => mergeAggUiConfig(persisted, config), [persisted, config]);
+  const [selectedChartTimeRange, setSelectedChartTimeRange] = useState2(
+    mergedConfig.chart.selectedChartTimeRange
+  );
+  const handleSetSelectedChartTimeRange = useCallback5((range) => {
+    setSelectedChartTimeRange(range);
+  }, []);
+  const [searchValue, setSearchValue] = useState2(mergedConfig.search.value);
+  const [searchResult, setSearchResult] = useState2(mergedConfig.search.result);
+  const [isShowingAllResults, setIsShowingAllResults] = useState2(
+    mergedConfig.search.isShowingAllResults
+  );
+  useEffect2(() => {
+    setSearchValue(mergedConfig.search.value);
+  }, [mergedConfig.search.value]);
+  useEffect2(() => {
+    setSearchResult(mergedConfig.search.result);
+  }, [mergedConfig.search.result]);
+  useEffect2(() => {
+    setIsShowingAllResults(mergedConfig.search.isShowingAllResults);
+  }, [mergedConfig.search.isShowingAllResults]);
+  const handleSearchChange = useCallback5(
+    (value) => {
+      var _a, _b;
+      setSearchValue(value);
+      setSearchResult(null);
+      setIsShowingAllResults(false);
+      (_b = (_a = mergedConfig.search).onChange) == null ? void 0 : _b.call(_a, value);
+    },
+    [mergedConfig.search]
+  );
+  const handleSearchSelect = useCallback5(
+    (value) => {
+      var _a, _b;
+      const nextSearchState = getSearchStateAfterSelect(value);
+      setSearchValue(nextSearchState.value);
+      setSearchResult(nextSearchState.result);
+      setIsShowingAllResults(nextSearchState.isShowingAllResults);
+      (_b = (_a = mergedConfig.search).onSelect) == null ? void 0 : _b.call(_a, value);
+    },
+    [mergedConfig.search]
+  );
+  const handleOpenResults = useCallback5(() => {
+    var _a, _b;
+    setIsShowingAllResults(true);
+    (_b = (_a = mergedConfig.search).openResults) == null ? void 0 : _b.call(_a);
+  }, [mergedConfig.search]);
+  const handleCloseResults = useCallback5(() => {
+    var _a, _b;
+    setIsShowingAllResults(false);
+    (_b = (_a = mergedConfig.search).closeResults) == null ? void 0 : _b.call(_a);
+  }, [mergedConfig.search]);
+  const resolvedConfig = useMemo4(() => {
+    return __spreadProps(__spreadValues({}, mergedConfig), {
+      chart: __spreadProps(__spreadValues({}, mergedConfig.chart), {
+        selectedChartTimeRange,
+        setSelectedChartTimeRange: handleSetSelectedChartTimeRange
+      }),
+      search: __spreadProps(__spreadValues({}, mergedConfig.search), {
+        value: searchValue,
+        onChange: handleSearchChange,
+        onSelect: handleSearchSelect,
+        openResults: handleOpenResults,
+        closeResults: handleCloseResults,
+        result: searchResult,
+        isShowingAllResults
+      })
+    });
+  }, [
+    handleCloseResults,
+    handleOpenResults,
+    handleSearchChange,
+    handleSearchSelect,
+    handleSetSelectedChartTimeRange,
+    isShowingAllResults,
+    mergedConfig,
+    searchResult,
+    searchValue,
+    selectedChartTimeRange
+  ]);
+  useEffect2(() => {
+    persistConfig({
+      locale: resolvedConfig.general.locale,
+      theme: resolvedConfig.general.theme,
+      selectedChartTimeRange: resolvedConfig.chart.selectedChartTimeRange
+    });
+  }, [
+    resolvedConfig.general.locale,
+    resolvedConfig.general.theme,
+    resolvedConfig.chart.selectedChartTimeRange
+  ]);
+  useEffect2(() => {
+    applyThemeToDocument(resolvedConfig.general.theme);
+  }, [resolvedConfig.general.theme]);
+  useEffect2(() => {
+    warnIfAggStylesAreMissing();
+  }, []);
+  const resolvedRootClassName = [
+    DEFAULT_AGG_ROOT_CLASS_NAME,
+    resolvedConfig.general.theme === "dark" ? "dark" : null,
+    resolvedConfig.general.rootClassName
+  ].filter(Boolean).join(" ");
+  logConfig(resolvedConfig, resolvedConfig.enableLogs);
+  return /* @__PURE__ */ jsx5(AggLabelsContext.Provider, { value: resolvedConfig.general.labels, children: /* @__PURE__ */ jsx5(AggUiContext.Provider, { value: resolvedConfig, children: /* @__PURE__ */ jsx5(EventTradingProvider, { enableLogs: resolvedConfig.enableLogs, children: /* @__PURE__ */ jsx5(
+    "div",
+    {
+      className: resolvedRootClassName,
+      "data-agg-animations": resolvedConfig.features.enableAnimations ? "true" : "false",
+      "data-agg-gradients": resolvedConfig.features.enableGradients ? "true" : "false",
+      "data-agg-theme": resolvedConfig.general.theme,
+      children
+    }
+  ) }) }) });
+};
+
+// src/core/providers/agg-provider.tsx
+import { useQueryClient as useQueryClient2 } from "@tanstack/react-query";
+
+// src/core/providers/auth-provider.tsx
+import { useCallback as useCallback6, useContext as useContext6, useEffect as useEffect3, useMemo as useMemo5, useState as useState3 } from "react";
+
+// src/core/providers/auth-utils.ts
+import { TurnstileChallengeError } from "@agg-build/sdk";
+var createPlaceholderUserProfile = (input) => {
+  return {
+    id: input.id,
+    username: null,
+    avatarUrl: null,
+    externalId: null,
+    isLocationBlocked: false,
+    venueAccounts: null,
+    accounts: [],
+    wallets: []
+  };
+};
+var createWalletSessionUser = (input) => {
+  return __spreadProps(__spreadValues({}, createPlaceholderUserProfile({ id: input.id })), {
+    accounts: [
+      {
+        type: "siwe" /* siwe */,
+        provider: "wallet" /* wallet */,
+        providerAccountId: input.address
+      }
+    ]
+  });
+};
+var getBrowserAuthLocation = () => {
+  if (typeof window === "undefined") {
+    return {
+      domain: "localhost",
+      uri: "http://localhost"
+    };
+  }
+  return {
+    domain: window.location.host,
+    uri: window.location.origin
+  };
+};
+var resolveAuthCallbackUrl = (callbackUrl) => {
+  return callbackUrl instanceof URL ? callbackUrl : typeof callbackUrl === "string" ? new URL(
+    callbackUrl,
+    typeof window === "undefined" ? "http://localhost" : window.location.origin
+  ) : typeof window === "undefined" ? null : new URL(window.location.href);
+};
+var parseAuthCallbackCode = (callbackUrl) => {
+  var _a;
+  const resolvedUrl = resolveAuthCallbackUrl(callbackUrl);
+  return (_a = resolvedUrl == null ? void 0 : resolvedUrl.searchParams.get("code")) != null ? _a : null;
+};
+var getAuthCallbackCleanupPath = (callbackUrl) => {
+  const resolvedUrl = resolveAuthCallbackUrl(callbackUrl);
+  if (!resolvedUrl) return null;
+  const params = new URLSearchParams(resolvedUrl.search);
+  params.delete("code");
+  const search = params.toString();
+  return `${resolvedUrl.pathname}${search ? `?${search}` : ""}`;
+};
+var exchangeAuthCallbackCode = (client, callbackUrl) => __async(null, null, function* () {
+  const code = parseAuthCallbackCode(callbackUrl);
+  if (!code) return null;
+  const result = yield client.exchangeAuthCode(code);
+  return {
+    cleanupPath: getAuthCallbackCleanupPath(callbackUrl),
+    user: result.user
+  };
+});
+var parseAuthCallbackTokens = (callbackUrl) => {
+  var _a, _b;
+  const resolvedUrl = resolveAuthCallbackUrl(callbackUrl);
+  if (!resolvedUrl) return null;
+  const hash = resolvedUrl.hash.startsWith("#") ? resolvedUrl.hash.slice(1) : resolvedUrl.hash;
+  if (!hash) return null;
+  const params = new URLSearchParams(hash);
+  const accessToken = params.get("access_token");
+  const refreshToken = params.get("refresh_token");
+  if (!accessToken || !refreshToken) return null;
+  const userId = (_a = params.get("user_id")) != null ? _a : void 0;
+  const tokenType = (_b = params.get("token_type")) != null ? _b : void 0;
+  return {
+    accessToken,
+    refreshToken,
+    tokenType,
+    userId
+  };
+};
+var createAuthCallbackSession = (tokens) => {
+  return {
+    accessToken: tokens.accessToken,
+    refreshToken: tokens.refreshToken,
+    user: tokens.userId ? createPlaceholderUserProfile({ id: tokens.userId }) : void 0
+  };
+};
+var executeWalletAuthFlow = (input) => __async(null, null, function* () {
+  var _a, _b;
+  const address = input.options.address.trim();
+  const chain = (_a = input.options.chain) != null ? _a : "ethereum";
+  const provider = chain === "solana" ? "siws" : "siwe";
+  const location = (_b = input.location) != null ? _b : getBrowserAuthLocation();
+  const startResult = yield input.client.authStart(__spreadValues({
+    provider
+  }, input.options.turnstileToken ? { turnstileToken: input.options.turnstileToken } : {}));
+  if (startResult.type === "challenge_required") {
+    if (!startResult.siteKey) {
+      throw new Error("Server returned challenge_required but no siteKey was provided.");
+    }
+    throw new TurnstileChallengeError(startResult.siteKey);
+  }
+  if (startResult.type !== "nonce") {
+    throw new Error(`AGG auth start returned an unexpected "${startResult.type}" response`);
+  }
+  const message = chain === "solana" ? input.client.buildSiwsMessage({
+    domain: location.domain,
+    address,
+    uri: location.uri,
+    nonce: startResult.nonce,
+    chainId: typeof input.options.chainId === "string" ? input.options.chainId : "mainnet",
+    statement: input.options.statement
+  }) : input.client.buildSiweMessage({
+    domain: location.domain,
+    address,
+    uri: location.uri,
+    nonce: startResult.nonce,
+    chainId: typeof input.options.chainId === "number" ? input.options.chainId : void 0,
+    statement: input.options.statement
+  });
+  const signature = yield input.options.signMessage(message);
+  const result = yield input.client.verify({ message, signature });
+  return {
+    accessToken: result.accessToken,
+    refreshToken: result.refreshToken,
+    user: createWalletSessionUser({
+      id: result.user.id,
+      address
+    })
+  };
+});
+
+// src/core/providers/auth-provider.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
+var getClientAuthSnapshot = (client) => {
+  var _a;
+  return {
+    isAuthenticated: (_a = client == null ? void 0 : client.isAuthenticated) != null ? _a : false,
+    user: client == null ? void 0 : client.user
+  };
+};
+var toError = (value) => {
+  return value instanceof Error ? value : new Error(String(value));
+};
+var replaceAuthCallbackUrl = (cleanupPath) => {
+  if (!cleanupPath || typeof window === "undefined") return;
+  window.history.replaceState(null, "", cleanupPath);
+};
+function AggAuthProvider({ children }) {
+  const client = useContext6(AggClientContext);
+  const snapshot = getClientAuthSnapshot(client);
+  const [isAuthenticated, setIsAuthenticated] = useState3(snapshot.isAuthenticated);
+  const [user, setUser] = useState3(snapshot.user);
+  const [isLoading, setIsLoading] = useState3(false);
+  const [error, setError] = useState3(null);
+  const isWeb3User = useMemo5(() => {
+    const accounts = user == null ? void 0 : user.accounts;
+    if (!Array.isArray(accounts)) return true;
+    return accounts.some((account) => {
+      var _a;
+      const provider = String((_a = account.provider) != null ? _a : "").toLowerCase();
+      return provider === "wallet" || provider === "solana_wallet";
+    });
+  }, [user]);
+  const refreshCurrentUser = useCallback6((targetClient) => __async(null, null, function* () {
+    const fullUser = yield targetClient.getCurrentUser();
+    setIsAuthenticated(true);
+    setUser(fullUser);
+    return fullUser;
+  }), []);
+  useEffect3(() => {
+    const state = getClientAuthSnapshot(client);
+    setIsAuthenticated(state.isAuthenticated);
+    setUser(state.user);
+    setIsLoading(false);
+    setError(null);
+    if (!client) return;
+    if (state.isAuthenticated) {
+      refreshCurrentUser(client).catch(() => {
+        client.clearAccessToken();
+      });
+    } else if (client.authStatus === "unknown") {
+      client.refreshAccessToken().then(() => refreshCurrentUser(client)).catch(() => {
+        client.clearAccessToken();
+      });
+    }
+  }, [client, refreshCurrentUser]);
+  useEffect3(() => {
+    if (!client) return;
+    return client.onAuthStateChange((authenticated) => {
+      setIsAuthenticated(authenticated);
+      setUser(client.user);
+      if (!authenticated) {
+        setIsLoading(false);
+        setError(null);
+      }
+    });
+  }, [client]);
+  const signIn = useCallback6(
+    (options) => __async(null, null, function* () {
+      if (!client) {
+        const missingClientError = new Error("Agg client is not configured in <AggProvider>");
+        setError(missingClientError);
+        throw missingClientError;
+      }
+      const address = options.address.trim();
+      if (!address) {
+        const missingAddressError = new Error("Wallet address is required");
+        setError(missingAddressError);
+        throw missingAddressError;
+      }
+      setIsLoading(true);
+      setError(null);
+      try {
+        const result = yield executeWalletAuthFlow({
+          client,
+          options: __spreadProps(__spreadValues({}, options), {
+            address
+          })
+        });
+        client.setSession(result);
+        setIsAuthenticated(true);
+        setUser(result.user);
+        yield refreshCurrentUser(client);
+      } catch (signInError) {
+        const resolvedError = toError(signInError);
+        setError(resolvedError);
+        throw resolvedError;
+      } finally {
+        setIsLoading(false);
+      }
+    }),
+    [client, refreshCurrentUser]
+  );
+  const startAuth = useCallback6(
+    (options) => __async(null, null, function* () {
+      if (!client) {
+        const missingClientError = new Error("Agg client is not configured in <AggProvider>");
+        setError(missingClientError);
+        throw missingClientError;
+      }
+      setIsLoading(true);
+      setError(null);
+      try {
+        return yield client.authStart(options);
+      } catch (startAuthError) {
+        const resolvedError = toError(startAuthError);
+        setError(resolvedError);
+        throw resolvedError;
+      } finally {
+        setIsLoading(false);
+      }
+    }),
+    [client]
+  );
+  const setSession = useCallback6(
+    (session) => __async(null, null, function* () {
+      if (!client) {
+        const missingClientError = new Error("Agg client is not configured in <AggProvider>");
+        setError(missingClientError);
+        throw missingClientError;
+      }
+      setIsLoading(true);
+      setError(null);
+      try {
+        client.setSession(session);
+        const resolvedUser = yield refreshCurrentUser(client);
+        setIsAuthenticated(true);
+        setUser(resolvedUser);
+        return resolvedUser;
+      } catch (sessionError) {
+        client.clearAccessToken();
+        setIsAuthenticated(false);
+        setUser(void 0);
+        const resolvedError = toError(sessionError);
+        setError(resolvedError);
+        throw resolvedError;
+      } finally {
+        setIsLoading(false);
+      }
+    }),
+    [client, refreshCurrentUser]
+  );
+  const handleAuthCallback = useCallback6(
+    (callbackUrl) => __async(null, null, function* () {
+      if (!client) {
+        const missingClientError = new Error("Agg client is not configured in <AggProvider>");
+        setError(missingClientError);
+        throw missingClientError;
+      }
+      setIsLoading(true);
+      setError(null);
+      try {
+        const exchangedSession = yield exchangeAuthCallbackCode(client, callbackUrl);
+        if (exchangedSession) {
+          const resolvedUser2 = yield refreshCurrentUser(client);
+          if (callbackUrl === void 0) {
+            replaceAuthCallbackUrl(exchangedSession.cleanupPath);
+          }
+          return resolvedUser2;
+        }
+        const tokens = parseAuthCallbackTokens(callbackUrl);
+        if (!tokens) return null;
+        client.setSession(createAuthCallbackSession(tokens));
+        setIsAuthenticated(client.isAuthenticated);
+        setUser(client.user);
+        const resolvedUser = yield refreshCurrentUser(client);
+        if (callbackUrl === void 0) {
+          replaceAuthCallbackUrl(getAuthCallbackCleanupPath(callbackUrl));
+        }
+        return resolvedUser;
+      } catch (callbackError) {
+        const resolvedError = toError(callbackError);
+        setError(resolvedError);
+        throw resolvedError;
+      } finally {
+        setIsLoading(false);
+      }
+    }),
+    [client, refreshCurrentUser]
+  );
+  const signOut = useCallback6(() => __async(null, null, function* () {
+    yield client == null ? void 0 : client.signOut();
+    setIsAuthenticated(false);
+    setUser(void 0);
+    setError(null);
+  }), [client]);
+  const clearError = useCallback6(() => {
+    setError(null);
+  }, []);
+  const value = useMemo5(() => {
+    return {
+      isAuthenticated,
+      isWeb3User,
+      user,
+      isLoading,
+      error,
+      signIn,
+      startAuth,
+      setSession,
+      handleAuthCallback,
+      signOut,
+      clearError
+    };
+  }, [
+    clearError,
+    error,
+    handleAuthCallback,
+    isAuthenticated,
+    isWeb3User,
+    isLoading,
+    setSession,
+    signIn,
+    signOut,
+    startAuth,
+    user
+  ]);
+  return /* @__PURE__ */ jsx6(AggAuthContext.Provider, { value, children });
+}
+
+// src/core/providers/client-provider.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+function AggClientProvider({ client, children }) {
+  return /* @__PURE__ */ jsx7(AggClientContext.Provider, { value: client != null ? client : null, children });
+}
+
+// src/core/providers/agg-provider.tsx
+import { jsx as jsx8 } from "react/jsx-runtime";
+var hasWarnedMissingQueryClient = false;
+function useQueryClientCheck() {
+  try {
+    useQueryClient2();
+  } catch (e) {
+    if (!hasWarnedMissingQueryClient) {
+      hasWarnedMissingQueryClient = true;
+      console.error(
+        "[agg] AggProvider requires a QueryClientProvider ancestor. Either wrap AggProvider in a <QueryClientProvider>, or use <AggProviders> which includes one automatically."
+      );
+    }
+  }
+}
+var AggProvider = ({ client, config, children }) => {
+  useQueryClientCheck();
+  if (!client) {
+    throw new Error(
+      "AggProvider requires a valid AggClient instance. Pass one via the 'client' prop, or use <AggProviders> which handles setup automatically."
+    );
+  }
+  return /* @__PURE__ */ jsx8(AggClientProvider, { client, children: /* @__PURE__ */ jsx8(AggUiProvider, { config, children: /* @__PURE__ */ jsx8(EventListStateProvider, { children: /* @__PURE__ */ jsx8(AggWebSocketProvider, { children: /* @__PURE__ */ jsx8(AggAuthProvider, { children: /* @__PURE__ */ jsx8(AggBalanceProvider, { children }) }) }) }) }) });
+};
+
+// src/use-ramp-quotes.ts
+import { useMutation } from "@tanstack/react-query";
+function useRampQuotes() {
+  const client = useAggClient();
+  return useMutation({
+    mutationFn: (params) => __async(null, null, function* () {
+      return client.getRampQuotes(params);
+    })
+  });
+}
+
+// src/use-ramp-session.ts
+import { useMutation as useMutation2 } from "@tanstack/react-query";
+function useRampSession() {
+  const client = useAggClient();
+  return useMutation2({
+    mutationFn: (params) => __async(null, null, function* () {
+      return client.createRampSession(params);
+    })
+  });
+}
+
+// src/execution/use-quote-managed.ts
+import { useMutation as useMutation3 } from "@tanstack/react-query";
+function useQuoteManaged(options) {
+  const client = useAggClient();
+  return useMutation3({
+    mutationFn: (params) => client.quoteManaged(params),
+    onSuccess: options == null ? void 0 : options.onSuccess,
+    onError: options == null ? void 0 : options.onError
+  });
+}
+
+// src/execution/use-execute-managed.ts
+import { useMutation as useMutation4, useQueryClient as useQueryClient3 } from "@tanstack/react-query";
+function useExecuteManaged(options) {
+  const client = useAggClient();
+  const queryClient = useQueryClient3();
+  return useMutation4({
+    mutationFn: (params) => client.executeManaged(params),
+    onSuccess: (data) => {
+      var _a;
+      queryClient.invalidateQueries({ queryKey: executionKeys.ordersPrefix() });
+      queryClient.invalidateQueries({ queryKey: executionKeys.positionsPrefix() });
+      invalidateBalanceQueries(queryClient);
+      (_a = options == null ? void 0 : options.onSuccess) == null ? void 0 : _a.call(options, data);
+    },
+    onError: options == null ? void 0 : options.onError
+  });
+}
+
+// src/execution/use-withdraw-managed.ts
+import { useMutation as useMutation5, useQueryClient as useQueryClient4 } from "@tanstack/react-query";
+function useWithdrawManaged(options) {
+  const client = useAggClient();
+  const queryClient = useQueryClient4();
+  return useMutation5({
+    mutationFn: (params) => client.withdrawManaged(params),
+    onSuccess: (data) => {
+      var _a;
+      invalidateBalanceQueries(queryClient);
+      (_a = options == null ? void 0 : options.onSuccess) == null ? void 0 : _a.call(options, data);
+    },
+    onError: options == null ? void 0 : options.onError
+  });
+}
+
+// src/execution/use-managed-balances.ts
+import { useQuery as useQuery2 } from "@tanstack/react-query";
+function useManagedBalances(options) {
+  const client = useAggClient();
+  const { enabled = true } = options != null ? options : {};
+  const query = useQuery2({
+    queryKey: executionKeys.balances(),
+    queryFn: () => client.getManagedBalances(),
+    enabled,
+    staleTime: 1e4,
+    gcTime: 5 * 6e4,
+    retry: 1
+  });
+  return __spreadProps(__spreadValues({}, query), {
+    balances: query.data
+  });
+}
+
+// src/execution/use-positions.ts
+import { useQuery as useQuery3 } from "@tanstack/react-query";
+function usePositions(options) {
+  var _a, _b, _c, _d;
+  const client = useAggClient();
+  const { enabled = true, cursor, limit, status } = options != null ? options : {};
+  const query = useQuery3({
+    queryKey: executionKeys.positions(cursor, limit, status),
+    queryFn: () => client.getPositions({ cursor, limit, status }),
+    enabled,
+    staleTime: 1e4,
+    gcTime: 5 * 6e4,
+    retry: 1
+  });
+  return __spreadProps(__spreadValues({}, query), {
+    positions: (_a = query.data) == null ? void 0 : _a.data,
+    nextCursor: (_b = query.data) == null ? void 0 : _b.nextCursor,
+    hasMore: (_d = (_c = query.data) == null ? void 0 : _c.hasMore) != null ? _d : false
+  });
+}
+
+// src/execution/use-deposit-addresses.ts
+import { useEffect as useEffect4, useMemo as useMemo6, useRef as useRef4, useState as useState4 } from "react";
+import { useQuery as useQuery4 } from "@tanstack/react-query";
+var SVM_CHAIN_IDS = /* @__PURE__ */ new Set([792703809]);
+function getDepositAddress(chainId, data) {
+  return chainId !== void 0 && SVM_CHAIN_IDS.has(chainId) ? data.svmAddress : data.evmAddress;
+}
+function useDepositAddresses(options) {
+  var _a;
+  const client = useAggClient();
+  const {
+    enabled = true,
+    poll = true,
+    refetchIntervalMs = 5e3,
+    timeoutMs = 6e4
+  } = options != null ? options : {};
+  const [isTimedOut, setIsTimedOut] = useState4(false);
+  const timeoutRef = useRef4(null);
+  useEffect4(() => {
+    if (!enabled || !poll) return void 0;
+    setIsTimedOut(false);
+    timeoutRef.current = setTimeout(() => setIsTimedOut(true), timeoutMs);
+    return () => {
+      if (timeoutRef.current) clearTimeout(timeoutRef.current);
+    };
+  }, [enabled, poll, timeoutMs]);
+  const query = useQuery4({
+    queryKey: executionKeys.depositAddresses(),
+    queryFn: () => client.getDepositAddresses(),
+    enabled,
+    staleTime: 6e4,
+    gcTime: 5 * 6e4,
+    retry: 1,
+    refetchInterval: (q) => {
+      if (!poll || isTimedOut) return false;
+      const data = q.state.data;
+      if ((data == null ? void 0 : data.ready) === true) return false;
+      return refetchIntervalMs;
+    }
+  });
+  const isReady = ((_a = query.data) == null ? void 0 : _a.ready) === true;
+  const readyData = isReady ? query.data : void 0;
+  const evmAddress = useMemo6(() => readyData == null ? void 0 : readyData.evmAddress, [readyData]);
+  const svmAddress = useMemo6(() => readyData == null ? void 0 : readyData.svmAddress, [readyData]);
+  const supportedChains = useMemo6(() => readyData == null ? void 0 : readyData.supportedChains, [readyData]);
+  return __spreadProps(__spreadValues({}, query), {
+    isReady,
+    isTimedOut,
+    evmAddress,
+    svmAddress,
+    supportedChains,
+    depositAddresses: query.data,
+    /** Resolve the correct address (EVM or SVM) for a given chainId. */
+    getAddress: (chainId) => readyData ? getDepositAddress(chainId, readyData) : void 0
+  });
+}
+
+// src/execution/use-sync-balances.ts
+import { useMutation as useMutation6, useQueryClient as useQueryClient5 } from "@tanstack/react-query";
+function useSyncBalances(options) {
+  const client = useAggClient();
+  const queryClient = useQueryClient5();
+  return useMutation6({
+    mutationFn: () => client.syncManagedBalances(),
+    onSuccess: () => {
+      var _a;
+      invalidateBalanceQueries(queryClient);
+      (_a = options == null ? void 0 : options.onSuccess) == null ? void 0 : _a.call(options);
+    },
+    onError: options == null ? void 0 : options.onError
+  });
+}
+
+// src/execution/use-execution-progress.ts
+import { useCallback as useCallback7, useEffect as useEffect5, useRef as useRef5, useState as useState5 } from "react";
+var TERMINAL_ORDER_STATUSES = /* @__PURE__ */ new Set(["filled", "partial_fill", "failed", "cancelled"]);
+var ORDER_POLL_INTERVAL_MS = 5e3;
+function mapOrderStatusToTerminalEvent(status) {
+  if (status === "filled") return "filled";
+  if (status === "partial_fill") return "partial_fill";
+  if (status === "failed" || status === "cancelled") return "failed";
+  return null;
+}
+function useExecutionProgress({
+  orderIds,
+  enabled
+}) {
+  const [phase, setPhase] = useState5("idle");
+  const [submittedOrders, setSubmittedOrders] = useState5([]);
+  const [latestBalance, setLatestBalance] = useState5(null);
+  const [dagProgress, setDagProgress] = useState5(null);
+  const [terminalOrderEvents, setTerminalOrderEvents] = useState5([]);
+  const orderIdSetRef = useRef5(/* @__PURE__ */ new Set());
+  const submittedOrderVenueByIdRef = useRef5(/* @__PURE__ */ new Map());
+  useEffect5(() => {
+    orderIdSetRef.current = new Set(orderIds != null ? orderIds : []);
+  }, [orderIds]);
+  useEffect5(() => {
+    if (enabled && orderIds && orderIds.length > 0) {
+      setPhase("pending");
+      setSubmittedOrders([]);
+      setLatestBalance(null);
+      setDagProgress(null);
+      setTerminalOrderEvents([]);
+      submittedOrderVenueByIdRef.current = /* @__PURE__ */ new Map();
+    } else if (!enabled) {
+      setPhase("idle");
+      submittedOrderVenueByIdRef.current = /* @__PURE__ */ new Map();
+    }
+  }, [enabled, orderIds]);
+  const handleOrderSubmitted = useCallback7((msg) => {
+    if (!orderIdSetRef.current.has(msg.orderId)) return;
+    const trimmedVenue = msg.venue.trim();
+    if (trimmedVenue) {
+      submittedOrderVenueByIdRef.current.set(msg.orderId, trimmedVenue);
+    }
+    setSubmittedOrders((prev) => [...prev, msg]);
+    setPhase("order_submitted");
+  }, []);
+  const handleBalanceUpdate = useCallback7((msg) => {
+    setLatestBalance(msg);
+    setPhase((current) => {
+      if (current === "order_submitted" || current === "pending") {
+        return "balance_updated";
+      }
+      return current;
+    });
+  }, []);
+  const handleOrderEvent = useCallback7((msg) => {
+    var _a, _b, _c;
+    if (!orderIdSetRef.current.has(msg.orderId)) return;
+    const trimmedVenue = msg.venue.trim();
+    if (trimmedVenue) {
+      submittedOrderVenueByIdRef.current.set(msg.orderId, trimmedVenue);
+    }
+    const { event } = msg;
+    if (event === "filled" || event === "partial_fill" || event === "failed" || event === "bridge_ws_subscribe_failed") {
+      const mappedEvent = event === "bridge_ws_subscribe_failed" ? "failed" : event;
+      const resolvedVenue = trimmedVenue || submittedOrderVenueByIdRef.current.get(msg.orderId) || "";
+      if (resolvedVenue) {
+        submittedOrderVenueByIdRef.current.set(msg.orderId, resolvedVenue);
+      }
+      const nextTerminalEvent = {
+        orderId: msg.orderId,
+        venue: resolvedVenue,
+        event: mappedEvent,
+        filledAmountRaw: msg.filledAmountRaw,
+        remainingAmountRaw: msg.remainingAmountRaw,
+        errorReason: event === "bridge_ws_subscribe_failed" ? (_a = msg.errorReason) != null ? _a : "Bridge event subscription failed." : msg.errorReason,
+        timestamp: msg.timestamp
+      };
+      setTerminalOrderEvents((prev) => {
+        const nextEvents = [
+          ...prev.filter((terminalEvent) => terminalEvent.orderId !== msg.orderId),
+          nextTerminalEvent
+        ];
+        return nextEvents.sort((left, right) => left.timestamp - right.timestamp);
+      });
+      return;
+    }
+    if (event === "dag_started") {
+      const initialStepTypes = {};
+      if (msg.stepTypes) {
+        for (const [seq, type] of Object.entries(msg.stepTypes)) {
+          initialStepTypes[Number(seq)] = type;
+        }
+      }
+      setDagProgress({
+        dagRunId: (_b = msg.dagRunId) != null ? _b : "",
+        totalSteps: (_c = msg.totalSteps) != null ? _c : 0,
+        currentSequence: 0,
+        currentStepType: null,
+        completedSequences: [],
+        stepTypes: initialStepTypes,
+        status: "running",
+        errorReason: null
+      });
+      return;
+    }
+    if (event === "step_started") {
+      setDagProgress((prev) => {
+        var _a2, _b2;
+        if (!prev) return prev;
+        const seq = (_a2 = msg.sequence) != null ? _a2 : prev.currentSequence;
+        const stepType = (_b2 = msg.stepType) != null ? _b2 : prev.currentStepType;
+        return __spreadProps(__spreadValues({}, prev), {
+          currentSequence: seq,
+          currentStepType: stepType,
+          stepTypes: stepType != null ? __spreadProps(__spreadValues({}, prev.stepTypes), { [seq]: stepType }) : prev.stepTypes
+        });
+      });
+      return;
+    }
+    if (event === "step_waiting") {
+      setDagProgress((prev) => {
+        var _a2, _b2;
+        if (!prev) return prev;
+        const seq = (_a2 = msg.sequence) != null ? _a2 : prev.currentSequence;
+        const stepType = (_b2 = msg.stepType) != null ? _b2 : prev.currentStepType;
+        return __spreadProps(__spreadValues({}, prev), {
+          currentSequence: seq,
+          currentStepType: stepType,
+          stepTypes: stepType != null ? __spreadProps(__spreadValues({}, prev.stepTypes), { [seq]: stepType }) : prev.stepTypes
+        });
+      });
+      return;
+    }
+    if (event === "step_completed") {
+      setDagProgress((prev) => {
+        if (!prev) return prev;
+        const seq = msg.sequence;
+        const stepType = msg.stepType;
+        return __spreadProps(__spreadValues({}, prev), {
+          completedSequences: seq != null ? [...prev.completedSequences, seq] : prev.completedSequences,
+          stepTypes: seq != null && stepType != null ? __spreadProps(__spreadValues({}, prev.stepTypes), { [seq]: stepType }) : prev.stepTypes
+        });
+      });
+      return;
+    }
+    if (event === "dag_completed") {
+      setDagProgress((prev) => {
+        if (!prev) return prev;
+        return __spreadProps(__spreadValues({}, prev), { status: "completed" });
+      });
+      return;
+    }
+    if (event === "dag_failed") {
+      setDagProgress((prev) => {
+        var _a2;
+        if (!prev) return prev;
+        return __spreadProps(__spreadValues({}, prev), {
+          status: "failed",
+          errorReason: (_a2 = msg.errorReason) != null ? _a2 : null
+        });
+      });
+      return;
+    }
+  }, []);
+  const isListening = enabled && !!orderIds && orderIds.length > 0;
+  useOnOrderSubmitted(isListening ? handleOrderSubmitted : null);
+  useOnBalanceUpdate(isListening ? handleBalanceUpdate : null);
+  useOnOrderEvent(isListening ? handleOrderEvent : null);
+  const client = useAggClient();
+  const terminalOrderIdsRef = useRef5(/* @__PURE__ */ new Set());
+  const pollInFlightRef = useRef5(false);
+  useEffect5(() => {
+    terminalOrderIdsRef.current = new Set(terminalOrderEvents.map((e) => e.orderId));
+  }, [terminalOrderEvents]);
+  useEffect5(() => {
+    if (!isListening || !(orderIds == null ? void 0 : orderIds.length)) return;
+    let cancelled = false;
+    let interval = null;
+    const stopPolling = () => {
+      if (interval !== null) {
+        clearInterval(interval);
+        interval = null;
+      }
+    };
+    const reconcile = () => __async(null, null, function* () {
+      var _a, _b, _c;
+      if (cancelled || pollInFlightRef.current) return;
+      const pending = orderIds.filter((id) => !terminalOrderIdsRef.current.has(id));
+      if (pending.length === 0) {
+        stopPolling();
+        return;
+      }
+      pollInFlightRef.current = true;
+      try {
+        const orders = yield Promise.all(
+          pending.map((orderId) => __async(null, null, function* () {
+            var _a2, _b2;
+            try {
+              const res = yield client.getExecutionOrders({ orderId, limit: 1 });
+              return (_b2 = (_a2 = res.data) == null ? void 0 : _a2[0]) != null ? _b2 : null;
+            } catch (e) {
+              return null;
+            }
+          }))
+        );
+        if (cancelled) return;
+        const terminalEvents = [];
+        for (const order of orders) {
+          if (!order) continue;
+          if (!TERMINAL_ORDER_STATUSES.has(order.status)) continue;
+          const mapped = mapOrderStatusToTerminalEvent(order.status);
+          if (!mapped) continue;
+          terminalEvents.push({
+            orderId: order.id,
+            venue: (_a = order.venue) != null ? _a : "",
+            event: mapped,
+            filledAmountRaw: (_b = order.filledAmountRaw) != null ? _b : void 0,
+            errorReason: (_c = order.errorMessage) != null ? _c : void 0,
+            timestamp: new Date(order.updatedAt).getTime() || Date.now()
+          });
+        }
+        if (terminalEvents.length > 0) {
+          setTerminalOrderEvents((prev) => {
+            const nextById = /* @__PURE__ */ new Map();
+            for (const ev of prev) nextById.set(ev.orderId, ev);
+            for (const ev of terminalEvents) {
+              const existing = nextById.get(ev.orderId);
+              if (!existing || existing.timestamp < ev.timestamp) {
+                nextById.set(ev.orderId, ev);
+              }
+            }
+            return Array.from(nextById.values()).sort((l, r) => l.timestamp - r.timestamp);
+          });
+        }
+        const covered = /* @__PURE__ */ new Set([
+          ...terminalOrderIdsRef.current,
+          ...terminalEvents.map((e) => e.orderId)
+        ]);
+        if (orderIds.every((id) => covered.has(id))) {
+          stopPolling();
+        }
+      } finally {
+        pollInFlightRef.current = false;
+      }
+    });
+    void reconcile();
+    interval = setInterval(() => {
+      void reconcile();
+    }, ORDER_POLL_INTERVAL_MS);
+    return () => {
+      cancelled = true;
+      stopPolling();
+    };
+  }, [client, isListening, orderIds]);
+  return { phase, submittedOrders, latestBalance, dagProgress, terminalOrderEvents };
+}
+
+// src/execution/compute-closed-position-totals.ts
+var computeClosedPositionTotals = (group) => {
+  const outcomes = group.venueMarket.venueMarketOutcomes;
+  const isResolved = group.venueMarket.status === "resolved";
+  let totalTraded = 0;
+  let amountWon = 0;
+  const winningOutcomeIds = /* @__PURE__ */ new Set();
+  let winningCount = 0;
+  let settledCount = 0;
+  for (const outcome of outcomes) {
+    totalTraded += outcome.avgEntryPrice * outcome.totalSize;
+    if (isResolved) {
+      if (outcome.winner === true) {
+        amountWon += outcome.totalValue;
+        winningCount += 1;
+        for (const breakdown of outcome.venueBreakdown) {
+          if (breakdown.venueMarketOutcomeId) {
+            winningOutcomeIds.add(breakdown.venueMarketOutcomeId);
+          }
+        }
+      }
+    } else {
+      amountWon += outcome.totalValue;
+    }
+    if (outcome.winner !== null) {
+      settledCount += 1;
+    }
+  }
+  const returnPct = totalTraded === 0 ? 0 : (amountWon - totalTraded) / totalTraded;
+  return {
+    totalTraded,
+    amountWon,
+    returnPct,
+    winningOutcomeIds: Array.from(winningOutcomeIds),
+    isPartialWin: winningCount > 0 && winningCount < settledCount
+  };
+};
+
+// src/execution/use-redeem.ts
+import { useMutation as useMutation7, useQueryClient as useQueryClient6 } from "@tanstack/react-query";
+var useRedeem = () => {
+  const client = useAggClient();
+  const queryClient = useQueryClient6();
+  return useMutation7({
+    mutationFn: (body) => client.redeem(body),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: executionKeys.positionsPrefix() });
+      queryClient.invalidateQueries({ queryKey: executionKeys.balances() });
+      queryClient.invalidateQueries({ queryKey: executionKeys.claimableClosedPositionsCount() });
+    }
+  });
+};
+
+// src/execution/use-on-redeem-event.ts
+var useOnRedeemEvent2 = (listener) => {
+  useOnRedeemEvent(listener);
+};
+
+// src/execution/use-redeem-eligible-count.ts
+import { useQuery as useQuery5 } from "@tanstack/react-query";
+var CLAIMABLE_COUNT_PAGE_LIMIT = 100;
+var getClaimableClosedPositionsCount = (client) => __async(null, null, function* () {
+  var _a;
+  let total = 0;
+  let cursor;
+  do {
+    const page = yield client.getExecutionPositions({
+      status: "closed",
+      limit: CLAIMABLE_COUNT_PAGE_LIMIT,
+      cursor
+    });
+    for (const group of page.data) {
+      if (group.redeemStatus === "eligible") {
+        total += 1;
+      }
+    }
+    cursor = page.hasMore ? (_a = page.nextCursor) != null ? _a : void 0 : void 0;
+  } while (cursor);
+  return total;
+});
+var useRedeemEligibleCount = () => {
+  var _a;
+  const client = useAggClient();
+  const { isAuthenticated } = useAggAuthState();
+  const query = useQuery5({
+    queryKey: executionKeys.claimableClosedPositionsCount(),
+    queryFn: () => getClaimableClosedPositionsCount(client),
+    enabled: isAuthenticated,
+    staleTime: 3e4,
+    refetchInterval: isAuthenticated ? 45e3 : false
+  });
+  if (!isAuthenticated) return 0;
+  return (_a = query.data) != null ? _a : 0;
+};
+
+export {
+  __spreadValues,
+  __spreadProps,
+  __objRest,
+  __async,
+  Venue,
+  MatchStatus,
+  MatchType,
+  CONFIRMED_MATCH_STATUSES,
+  MarketStatus,
+  getWalletAddressFromUserProfile,
+  parseEmail,
+  parseEmailStrict,
+  optimizedImageUrl,
+  sortVenues,
+  getOrCreateBuilder,
+  getBuilder,
+  resolveAggUiLabels,
+  defaultAggUiConfig,
+  AggClientContext,
+  AggAuthContext,
+  executionKeys,
+  invalidateBalanceQueries,
+  invalidatePositionQueries,
+  AggBalanceProvider,
+  EventListStateProvider,
+  useEventListState,
+  createMarketChartData,
+  mergeMarketChartData,
+  createMarketLiveState,
+  createMarketOrderbookDataFromVenueOrderbooks,
+  createMarketOrderbookDataFromState,
+  marketOrderbookDataToResponse,
+  applyOrderbookDepth,
+  marketDataKeys,
+  useAggClient,
+  useAggUiConfig,
+  useAggLabels,
+  useAggAuthContext,
+  useAggAuthState,
+  useAggBalanceContext,
+  useAggBalanceState,
+  useAggBalance,
+  useSdkUiConfig,
+  useSdkLabels,
+  useLabels,
+  useAggWebSocket,
+  useAggWebSocketConnectionState,
+  useOnOrderSubmitted,
+  useOnBalanceUpdate,
+  DEFAULT_AGG_ROOT_CLASS_NAME,
+  CHART_TIME_RANGES,
+  resolveTradingStateKind,
+  resolveMarketWinningOutcome,
+  resolveMarketTradingState,
+  resolveEventTradingState,
+  resolveOrderEligibility,
+  resolveDefaultMarket,
+  tradingReducer,
+  useEventTradingContext,
+  AggUiProvider,
+  AggProvider,
+  useRampQuotes,
+  useRampSession,
+  useQuoteManaged,
+  useExecuteManaged,
+  useWithdrawManaged,
+  useManagedBalances,
+  usePositions,
+  getDepositAddress,
+  useDepositAddresses,
+  useSyncBalances,
+  useExecutionProgress,
+  computeClosedPositionTotals,
+  useRedeem,
+  useOnRedeemEvent2 as useOnRedeemEvent,
+  useRedeemEligibleCount
+};