@agg-build/sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,2581 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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());
+  });
+};
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AccountProvider: () => AccountProvider,
+  AccountType: () => AccountType,
+  AggClient: () => AggClient,
+  AggWebSocket: () => AggWebSocket,
+  CONFIRMED_MATCH_STATUSES: () => CONFIRMED_MATCH_STATUSES,
+  CandleBuilder: () => CandleBuilder,
+  Chain: () => Chain,
+  IMAGE_SIZES: () => IMAGE_SIZES,
+  ImageSize: () => ImageSize,
+  MarketStatus: () => MarketStatus,
+  MatchStatus: () => MatchStatus,
+  MatchType: () => MatchType,
+  OrderStatus: () => OrderStatus,
+  TradeSide: () => TradeSide,
+  TurnstileChallengeError: () => TurnstileChallengeError,
+  VENUES: () => VENUES,
+  Venue: () => Venue,
+  aggregateMidpoint: () => aggregateMidpoint,
+  applyOrderbookDelta: () => applyOrderbookDelta,
+  computeBestSplitsByAmount: () => computeBestSplitsByAmount2,
+  computeChecksum: () => computeChecksum,
+  createAggClient: () => createAggClient,
+  enumGuard: () => enumGuard,
+  formatMarketQuestion: () => formatMarketQuestion,
+  formatOutcomeLabel: () => formatOutcomeLabel,
+  getWalletAddressFromUserProfile: () => getWalletAddressFromUserProfile,
+  hasShape: () => hasShape,
+  isEmail: () => isEmail,
+  isEnum: () => isEnum,
+  isFiniteNonNeg: () => isFiniteNonNeg,
+  isNonEmptyString: () => isNonEmptyString,
+  mergeCandles: () => mergeCandles,
+  mergeClosedCandles: () => mergeClosedCandles,
+  normalizeVenueMarketCluster: () => normalizeVenueMarketCluster,
+  optimizedImageUrl: () => optimizedImageUrl,
+  parse: () => parse,
+  parseEmail: () => parseEmail,
+  parseEmailStrict: () => parseEmailStrict,
+  safeParse: () => safeParse,
+  snapshotToOrderbook: () => snapshotToOrderbook,
+  sortVenues: () => sortVenues
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../common/src/enums/venue.ts
+var Venue = /* @__PURE__ */ ((Venue3) => {
+  Venue3["kalshi"] = "kalshi";
+  Venue3["polymarket"] = "polymarket";
+  Venue3["limitless"] = "limitless";
+  Venue3["opinion"] = "opinion";
+  Venue3["predict"] = "predict";
+  Venue3["probable"] = "probable";
+  Venue3["myriad"] = "myriad";
+  Venue3["hyperliquid"] = "hyperliquid";
+  return Venue3;
+})(Venue || {});
+var VENUES = [
+  "kalshi" /* kalshi */,
+  "polymarket" /* polymarket */,
+  "limitless" /* limitless */,
+  "opinion" /* opinion */,
+  "predict" /* predict */,
+  "probable" /* probable */,
+  "myriad" /* myriad */,
+  "hyperliquid" /* hyperliquid */
+];
+
+// ../common/src/enums/image-size.ts
+var ImageSize = /* @__PURE__ */ ((ImageSize2) => {
+  ImageSize2[ImageSize2["sm"] = 44] = "sm";
+  ImageSize2[ImageSize2["md"] = 48] = "md";
+  ImageSize2[ImageSize2["lg"] = 60] = "lg";
+  ImageSize2[ImageSize2["original"] = 0] = "original";
+  return ImageSize2;
+})(ImageSize || {});
+var IMAGE_SIZES = [44 /* sm */, 48 /* md */, 60 /* lg */];
+
+// ../common/src/enums/account.ts
+var AccountType = /* @__PURE__ */ ((AccountType2) => {
+  AccountType2["oauth"] = "oauth";
+  AccountType2["siwe"] = "siwe";
+  AccountType2["siws"] = "siws";
+  AccountType2["email"] = "email";
+  return AccountType2;
+})(AccountType || {});
+var AccountProvider = /* @__PURE__ */ ((AccountProvider2) => {
+  AccountProvider2["wallet"] = "wallet";
+  AccountProvider2["solana_wallet"] = "solana_wallet";
+  AccountProvider2["google"] = "google";
+  AccountProvider2["twitter"] = "twitter";
+  AccountProvider2["apple"] = "apple";
+  AccountProvider2["email"] = "email";
+  return AccountProvider2;
+})(AccountProvider || {});
+
+// ../common/src/enums/chain.ts
+var Chain = /* @__PURE__ */ ((Chain2) => {
+  Chain2["evm"] = "evm";
+  Chain2["svm"] = "svm";
+  return Chain2;
+})(Chain || {});
+
+// ../common/src/enums/market-status.ts
+var MatchStatus = /* @__PURE__ */ ((MatchStatus3) => {
+  MatchStatus3["pending"] = "pending";
+  MatchStatus3["unmatched"] = "unmatched";
+  MatchStatus3["review"] = "review";
+  MatchStatus3["matched"] = "matched";
+  MatchStatus3["verified"] = "verified";
+  MatchStatus3["rejected"] = "rejected";
+  return MatchStatus3;
+})(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__ */ ((MarketStatus3) => {
+  MarketStatus3["open"] = "open";
+  MarketStatus3["closed"] = "closed";
+  MarketStatus3["resolved"] = "resolved";
+  MarketStatus3["unopened"] = "unopened";
+  MarketStatus3["paused"] = "paused";
+  return MarketStatus3;
+})(MarketStatus || {});
+
+// ../common/src/enums/trading.ts
+var OrderStatus = /* @__PURE__ */ ((OrderStatus2) => {
+  OrderStatus2["pending"] = "pending";
+  OrderStatus2["signing"] = "signing";
+  OrderStatus2["pending_bridge"] = "pending_bridge";
+  OrderStatus2["submitting"] = "submitting";
+  OrderStatus2["submitted"] = "submitted";
+  OrderStatus2["filled"] = "filled";
+  OrderStatus2["partial_fill"] = "partial_fill";
+  return OrderStatus2;
+})(OrderStatus || {});
+var TradeSide = /* @__PURE__ */ ((TradeSide2) => {
+  TradeSide2["Buy"] = "buy";
+  TradeSide2["Sell"] = "sell";
+  return TradeSide2;
+})(TradeSide || {});
+
+// ../common/src/utils/format-market-display.ts
+function formatOutcomeLabel(venue, outcome, _market) {
+  return outcome.label;
+}
+function formatMarketQuestion(venue, market) {
+  var _a, _b, _c, _d;
+  if ((_a = market.shortTitle) == null ? void 0 : _a.trim()) return market.shortTitle.trim();
+  if (venue === "kalshi" /* kalshi */) {
+    const firstTitle = (_d = (_c = (_b = market.venueMarketOutcomes) == null ? void 0 : _b[0]) == null ? void 0 : _c.title) == null ? void 0 : _d.trim();
+    if (firstTitle) return firstTitle;
+  }
+  return market.question.trim();
+}
+
+// ../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
+function safeParse(value, guard) {
+  if (guard(value)) return { success: true, data: value };
+  return { success: false };
+}
+function parse(value, guard, message = "Validation failed") {
+  if (guard(value)) return value;
+  const err = new Error(message);
+  err.issues = [{ message }];
+  throw err;
+}
+function isEnum(values) {
+  return (v) => typeof v === "string" && values.has(v);
+}
+function enumGuard(source) {
+  const values = new Set(Array.isArray(source) ? source : Object.values(source));
+  return isEnum(values);
+}
+function isFiniteNonNeg(v) {
+  return typeof v === "number" && Number.isFinite(v) && v >= 0;
+}
+function isNonEmptyString(v) {
+  return typeof v === "string" && v.length > 0;
+}
+function hasShape(v, checks) {
+  if (typeof v !== "object" || v === null) return false;
+  const obj = v;
+  for (const [key, check] of Object.entries(checks)) {
+    if (!(key in obj) || !check(obj[key])) return false;
+  }
+  return true;
+}
+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/trading-splits.ts
+function computeBestSplitsByAmount(selections, side, maxDollarAmount) {
+  var _a;
+  if (selections.length === 0 || maxDollarAmount <= 0) {
+    return { splits: [], totalSize: 0, totalCost: 0 };
+  }
+  const levels = [];
+  for (const o of selections) {
+    const venue = o.market.venue;
+    const venueMarketOutcomeId = o.outcome.id;
+    const outcomeExternalIdentifier = (_a = o.outcome.externalIdentifier) != null ? _a : void 0;
+    if (side === "buy" /* Buy */) {
+      [...o.orderbook.asks].sort((a, b) => a.price - b.price).forEach(
+        (l) => {
+          var _a2;
+          return levels.push({
+            venue,
+            venueMarketOutcomeId,
+            outcomeExternalIdentifier,
+            price: l.price,
+            size: l.size,
+            negRisk: (_a2 = o.orderbook.negRisk) != null ? _a2 : false
+          });
+        }
+      );
+    } else {
+      [...o.orderbook.bids].sort((a, b) => b.price - a.price).forEach(
+        (l) => {
+          var _a2;
+          return levels.push({
+            venue,
+            venueMarketOutcomeId,
+            outcomeExternalIdentifier,
+            price: 1 - l.price,
+            size: l.size,
+            negRisk: (_a2 = o.orderbook.negRisk) != null ? _a2 : false
+          });
+        }
+      );
+    }
+  }
+  levels.sort((a, b) => a.price - b.price);
+  let totalCost = 0;
+  const fills = [];
+  for (const l of levels) {
+    if (totalCost >= maxDollarAmount) break;
+    const remainingBudget = maxDollarAmount - totalCost;
+    const maxSizeAtLevel = Math.min(l.size, remainingBudget / l.price);
+    if (maxSizeAtLevel <= 0) continue;
+    const take = maxSizeAtLevel;
+    fills.push({
+      venue: l.venue,
+      venueMarketOutcomeId: l.venueMarketOutcomeId,
+      outcomeExternalIdentifier: l.outcomeExternalIdentifier,
+      price: l.price,
+      size: take,
+      negRisk: l.negRisk
+    });
+    totalCost += l.price * take;
+  }
+  if (fills.length === 0) {
+    return { splits: [], totalSize: 0, totalCost: 0 };
+  }
+  const byOutcome = {};
+  for (const f of fills) {
+    const key = `${f.venue}:${f.venueMarketOutcomeId}`;
+    const existing = byOutcome[key];
+    if (!existing) {
+      byOutcome[key] = {
+        size: f.size,
+        venue: f.venue,
+        venueMarketOutcomeId: f.venueMarketOutcomeId,
+        outcomeExternalIdentifier: f.outcomeExternalIdentifier,
+        negRisk: f.negRisk
+      };
+    } else {
+      existing.size += f.size;
+    }
+  }
+  const splits = [];
+  let totalSize = 0;
+  for (const key in byOutcome) {
+    const { size, venue, venueMarketOutcomeId, outcomeExternalIdentifier, negRisk } = byOutcome[key];
+    totalSize += size;
+    let price = 0;
+    if (size > 0) {
+      const outcomeFills = fills.filter(
+        (f) => f.venue === venue && f.venueMarketOutcomeId === venueMarketOutcomeId
+      );
+      if (side === "buy" /* Buy */) {
+        const rawPrice = Math.max(...outcomeFills.map((f) => f.price));
+        price = Math.ceil(rawPrice * 100) / 100;
+      } else {
+        const rawPrice = Math.min(...outcomeFills.map((f) => 1 - f.price));
+        price = Math.floor(rawPrice * 100) / 100;
+      }
+    }
+    splits.push({
+      venue,
+      venueMarketOutcomeId,
+      side,
+      price,
+      size,
+      negRisk,
+      outcomeExternalIdentifier
+    });
+  }
+  return {
+    splits,
+    totalSize,
+    totalCost
+  };
+}
+
+// ../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/venue-market-cluster.ts
+var toNonEmptyString = (value) => {
+  if (typeof value !== "string") return void 0;
+  const trimmedValue = value.trim();
+  return trimmedValue ? trimmedValue : void 0;
+};
+var addGraphEdge = (adjacencyById, fromMarketId, toMarketId) => {
+  var _a, _b;
+  if (fromMarketId === toMarketId) return;
+  const fromNeighbors = (_a = adjacencyById.get(fromMarketId)) != null ? _a : /* @__PURE__ */ new Set();
+  fromNeighbors.add(toMarketId);
+  adjacencyById.set(fromMarketId, fromNeighbors);
+  const toNeighbors = (_b = adjacencyById.get(toMarketId)) != null ? _b : /* @__PURE__ */ new Set();
+  toNeighbors.add(fromMarketId);
+  adjacencyById.set(toMarketId, toNeighbors);
+};
+var collectDirectRelationMarkets = (market) => {
+  var _a, _b, _c;
+  const relationMarkets = [];
+  const seenRelationIds = /* @__PURE__ */ new Set();
+  const addRelationMarket = (relationMarket) => {
+    if (!relationMarket) return;
+    if (seenRelationIds.has(relationMarket.id)) return;
+    seenRelationIds.add(relationMarket.id);
+    relationMarkets.push(relationMarket);
+  };
+  for (const matchedVenueMarket of (_a = market.matchedVenueMarkets) != null ? _a : []) {
+    addRelationMarket(matchedVenueMarket);
+  }
+  addRelationMarket((_c = (_b = market.matchEntry) == null ? void 0 : _b.targetVenueMarket) != null ? _c : void 0);
+  return relationMarkets;
+};
+var dedupeSourceMarketsById = (markets) => {
+  const seenMarketIds = /* @__PURE__ */ new Set();
+  return markets.filter((market) => {
+    if (seenMarketIds.has(market.id)) {
+      return false;
+    }
+    seenMarketIds.add(market.id);
+    return true;
+  });
+};
+var collectUniqueRelatedMarkets = (markets, sourceMarketsById) => {
+  const relatedMarketsById = /* @__PURE__ */ new Map();
+  for (const market of markets) {
+    for (const relatedMarket of collectDirectRelationMarkets(market)) {
+      if (sourceMarketsById.has(relatedMarket.id) || relatedMarketsById.has(relatedMarket.id)) {
+        continue;
+      }
+      relatedMarketsById.set(relatedMarket.id, relatedMarket);
+    }
+  }
+  return Array.from(relatedMarketsById.values());
+};
+var normalizeVenueMarketCluster = (markets, selectedMarketId) => {
+  var _a, _b;
+  if (markets.length === 0) return [];
+  const orderedSourceMarkets = dedupeSourceMarketsById(markets);
+  const sourceMarketsById = new Map(orderedSourceMarkets.map((market) => [market.id, market]));
+  const orderedRelatedMarkets = collectUniqueRelatedMarkets(
+    orderedSourceMarkets,
+    sourceMarketsById
+  );
+  const relatedMarketsById = new Map(orderedRelatedMarkets.map((market) => [market.id, market]));
+  const resolvedSelectedMarketId = toNonEmptyString(selectedMarketId);
+  if (!resolvedSelectedMarketId) {
+    return [...orderedSourceMarkets, ...orderedRelatedMarkets];
+  }
+  const adjacencyById = /* @__PURE__ */ new Map();
+  for (const market of orderedSourceMarkets) {
+    for (const relatedMarket of collectDirectRelationMarkets(market)) {
+      addGraphEdge(adjacencyById, market.id, relatedMarket.id);
+    }
+    const targetVenueMarketId = toNonEmptyString((_a = market.matchEntry) == null ? void 0 : _a.targetVenueMarketId);
+    if (targetVenueMarketId) {
+      addGraphEdge(adjacencyById, market.id, targetVenueMarketId);
+    }
+  }
+  if (!sourceMarketsById.has(resolvedSelectedMarketId) && !relatedMarketsById.has(resolvedSelectedMarketId)) {
+    return [];
+  }
+  const visitedMarketIds = /* @__PURE__ */ new Set();
+  const queue = [resolvedSelectedMarketId];
+  while (queue.length > 0) {
+    const currentMarketId = queue.shift();
+    if (!currentMarketId || visitedMarketIds.has(currentMarketId)) {
+      continue;
+    }
+    visitedMarketIds.add(currentMarketId);
+    const neighborMarketIds = adjacencyById.get(currentMarketId);
+    for (const neighborMarketId of Array.from(neighborMarketIds != null ? neighborMarketIds : /* @__PURE__ */ new Set())) {
+      if (!visitedMarketIds.has(neighborMarketId)) {
+        queue.push(neighborMarketId);
+      }
+    }
+  }
+  const orderedClusterMarkets = [];
+  const appendedMarketIds = /* @__PURE__ */ new Set();
+  const appendMarket = (market) => {
+    if (!market) return;
+    if (!visitedMarketIds.has(market.id)) return;
+    if (appendedMarketIds.has(market.id)) return;
+    appendedMarketIds.add(market.id);
+    orderedClusterMarkets.push(market);
+  };
+  appendMarket(
+    (_b = sourceMarketsById.get(resolvedSelectedMarketId)) != null ? _b : relatedMarketsById.get(resolvedSelectedMarketId)
+  );
+  for (const market of orderedSourceMarkets) {
+    appendMarket(market);
+  }
+  for (const market of orderedRelatedMarkets) {
+    appendMarket(market);
+  }
+  return orderedClusterMarkets;
+};
+
+// ../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/orderbook-utils.ts
+var PRICE_KEY_SCALE = 1e9;
+function crc32(str) {
+  let crc = 4294967295;
+  for (let i = 0; i < str.length; i++) {
+    crc ^= str.charCodeAt(i);
+    for (let j = 0; j < 8; j++) {
+      crc = crc >>> 1 ^ (crc & 1 ? 3988292384 : 0);
+    }
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function computeChecksum(book) {
+  let checksum = 0;
+  for (const b of book.bids) checksum ^= crc32(`B${b.price}:${b.size}`);
+  for (const a of book.asks) checksum ^= crc32(`A${a.price}:${a.size}`);
+  return checksum >>> 0;
+}
+function attributedToLevel(wire) {
+  return { price: wire[0], size: wire[1], venues: __spreadValues({}, wire[2]) };
+}
+function venueLevelToLevel(wire) {
+  return { price: wire[0], size: wire[1] };
+}
+function convertVenueBooks(raw) {
+  const result = {};
+  for (const [venue, book] of Object.entries(raw)) {
+    result[venue] = {
+      bids: book.bids.map(venueLevelToLevel),
+      asks: book.asks.map(venueLevelToLevel)
+    };
+  }
+  return result;
+}
+function snapshotToOrderbook(snapshot) {
+  return {
+    marketId: snapshot.outcomeId,
+    outcomeId: snapshot.outcomeId,
+    bids: snapshot.bids.map(attributedToLevel),
+    asks: snapshot.asks.map(attributedToLevel),
+    venueOrderbooks: convertVenueBooks(snapshot.venueOrderbooks),
+    venues: __spreadValues({}, snapshot.venues),
+    midpoint: snapshot.midpoint,
+    spread: snapshot.spread,
+    seq: snapshot.seq,
+    checksum: snapshot.checksum,
+    timestamp: snapshot.timestamp
+  };
+}
+function applyOrderbookDelta(state, delta) {
+  var _a, _b;
+  const bids = applyChanges([...state.bids], delta.bidChanges, "desc");
+  const asks = applyChanges([...state.asks], delta.askChanges, "asc");
+  const impliedBidChangesByVenue = deriveVenueChangesFromAttributedChanges(
+    state.bids,
+    delta.bidChanges
+  );
+  const impliedAskChangesByVenue = deriveVenueChangesFromAttributedChanges(
+    state.asks,
+    delta.askChanges
+  );
+  const venueOrderbooks = __spreadValues({}, state.venueOrderbooks);
+  const venuesWithDelta = /* @__PURE__ */ new Set([
+    ...Object.keys(delta.venueDeltaBooks),
+    ...Object.keys(impliedBidChangesByVenue),
+    ...Object.keys(impliedAskChangesByVenue)
+  ]);
+  for (const venue of venuesWithDelta) {
+    const explicitChanges = delta.venueDeltaBooks[venue];
+    const bidChanges = mergeVenueLevelChanges(
+      explicitChanges == null ? void 0 : explicitChanges.bidChanges,
+      impliedBidChangesByVenue[venue]
+    );
+    const askChanges = mergeVenueLevelChanges(
+      explicitChanges == null ? void 0 : explicitChanges.askChanges,
+      impliedAskChangesByVenue[venue]
+    );
+    if (bidChanges.length === 0 && askChanges.length === 0) continue;
+    const existing = (_a = venueOrderbooks[venue]) != null ? _a : { bids: [], asks: [] };
+    venueOrderbooks[venue] = {
+      bids: applyVenueChanges([...existing.bids], bidChanges, "desc"),
+      asks: applyVenueChanges([...existing.asks], askChanges, "asc")
+    };
+  }
+  return {
+    marketId: state.marketId,
+    outcomeId: (_b = state.outcomeId) != null ? _b : delta.outcomeId,
+    bids,
+    asks,
+    venueOrderbooks,
+    venues: __spreadValues(__spreadValues({}, state.venues), delta.venues),
+    midpoint: delta.midpoint,
+    spread: delta.spread,
+    seq: delta.seq,
+    checksum: delta.checksum,
+    timestamp: delta.timestamp
+  };
+}
+function toPriceKey(price) {
+  return String(Math.round(price * PRICE_KEY_SCALE));
+}
+function applyChanges(levels, changes, sort) {
+  const levelsByPrice = new Map(levels.map((level) => [toPriceKey(level.price), level]));
+  for (const [price, size, venues] of changes) {
+    const key = toPriceKey(price);
+    if (size === 0) {
+      levelsByPrice.delete(key);
+      continue;
+    }
+    levelsByPrice.set(key, {
+      price,
+      size,
+      venues: __spreadValues({}, venues != null ? venues : {})
+    });
+  }
+  levels = [...levelsByPrice.values()];
+  levels.sort(sort === "desc" ? (a, b) => b.price - a.price : (a, b) => a.price - b.price);
+  return levels;
+}
+function applyVenueChanges(levels, changes, sort) {
+  const levelsByPrice = new Map(levels.map((level) => [toPriceKey(level.price), level]));
+  for (const [price, size] of changes) {
+    const key = toPriceKey(price);
+    if (size === 0) {
+      levelsByPrice.delete(key);
+      continue;
+    }
+    levelsByPrice.set(key, { price, size });
+  }
+  levels = [...levelsByPrice.values()];
+  levels.sort(sort === "desc" ? (a, b) => b.price - a.price : (a, b) => a.price - b.price);
+  return levels;
+}
+function mergeVenueLevelChanges(primary, fallback) {
+  if (!(primary == null ? void 0 : primary.length)) return fallback ? [...fallback] : [];
+  if (!(fallback == null ? void 0 : fallback.length)) return [...primary];
+  const changesByPrice = /* @__PURE__ */ new Map();
+  for (const change of fallback) {
+    changesByPrice.set(toPriceKey(change[0]), change);
+  }
+  for (const change of primary) {
+    changesByPrice.set(toPriceKey(change[0]), change);
+  }
+  return [...changesByPrice.values()];
+}
+function deriveVenueChangesFromAttributedChanges(previousLevels, changes) {
+  var _a, _b;
+  const previousLevelsByPrice = new Map(
+    previousLevels.map((level) => [toPriceKey(level.price), level])
+  );
+  const venueChanges = {};
+  for (const [price, size, nextVenuesRaw] of changes) {
+    const key = toPriceKey(price);
+    const previousLevel = previousLevelsByPrice.get(key);
+    const previousVenues = (_a = previousLevel == null ? void 0 : previousLevel.venues) != null ? _a : {};
+    const nextVenues = nextVenuesRaw != null ? nextVenuesRaw : {};
+    const affectedVenues = /* @__PURE__ */ new Set([...Object.keys(previousVenues), ...Object.keys(nextVenues)]);
+    for (const venue of affectedVenues) {
+      const nextSize = Number((_b = nextVenues[venue]) != null ? _b : 0);
+      if (!Number.isFinite(nextSize)) continue;
+      if (!venueChanges[venue]) {
+        venueChanges[venue] = [];
+      }
+      venueChanges[venue].push([price, nextSize]);
+    }
+    if (size === 0) {
+      previousLevelsByPrice.delete(key);
+      continue;
+    }
+    previousLevelsByPrice.set(key, {
+      price,
+      size,
+      venues: __spreadValues({}, nextVenues)
+    });
+  }
+  return venueChanges;
+}
+
+// src/agg-websocket.ts
+var RECONNECT_BASE_MS = 1e3;
+var RECONNECT_MAX_MS = 3e4;
+var STALE_TIMEOUT_MS = 45e3;
+var ORDERBOOK_DEBUG_TOP_LEVELS = 5;
+var AggWebSocket = class {
+  constructor(options) {
+    this.ws = null;
+    // ── Subscription tracking ──
+    this.subs = /* @__PURE__ */ new Map();
+    this.pendingSubs = /* @__PURE__ */ new Set();
+    this.pendingTradeSubs = /* @__PURE__ */ new Set();
+    this.pendingResnapshots = /* @__PURE__ */ new Set();
+    // ── Post-connect batching (coalesces same-tick sub/unsub calls into one frame) ──
+    this.pendingFlushSubs = /* @__PURE__ */ new Set();
+    this.pendingFlushUnsubs = /* @__PURE__ */ new Set();
+    this.pendingFlushTradeSubs = /* @__PURE__ */ new Set();
+    this.pendingFlushTradeUnsubs = /* @__PURE__ */ new Set();
+    this.flushScheduled = false;
+    // ── Orderbook state per market ──
+    this.books = /* @__PURE__ */ new Map();
+    /** Markets currently resyncing (awaiting snapshot after seq gap / checksum mismatch). */
+    this.resyncing = /* @__PURE__ */ new Set();
+    // ── Connection state ──
+    this.connecting = false;
+    this._connected = false;
+    this.reconnectAttempts = 0;
+    this.reconnectTimer = null;
+    this.staleTimer = null;
+    this.lastMessageTime = 0;
+    this.destroyed = false;
+    var _a, _b;
+    this.url = options.url;
+    this.callbacks = (_a = options.callbacks) != null ? _a : {};
+    this.initialToken = options.initialToken;
+    this.enableLogs = (_b = options.enableLogs) != null ? _b : false;
+  }
+  // ── Public API ──
+  get connected() {
+    return this._connected;
+  }
+  /** Get the current orderbook state for an outcome (or null if no snapshot received yet). */
+  getBook(outcomeId) {
+    var _a;
+    return (_a = this.books.get(outcomeId)) != null ? _a : null;
+  }
+  /** Whether an outcome is currently resyncing (waiting for fresh snapshot). */
+  isResyncing(outcomeId) {
+    return this.resyncing.has(outcomeId);
+  }
+  /**
+   * Subscribe to a feed by outcome ID.
+   * @param outcomeId  The venueMarketOutcomeId to subscribe to.
+   * @param channel    "orderbook" (default) or "trades".
+   * Returns an unsubscribe function (ref-counted).
+   */
+  subscribe(outcomeId, channel = "orderbook") {
+    if (channel === "trades") {
+      return this._subscribeTrades(outcomeId);
+    }
+    let sub = this.subs.get(outcomeId);
+    if (!sub) {
+      sub = { refCount: 0, tradeRefs: 0 };
+      this.subs.set(outcomeId, sub);
+      this.pendingSubs.add(outcomeId);
+      this.ensureConnected();
+      if (this._connected) {
+        this.pendingFlushUnsubs.delete(outcomeId);
+        this.pendingFlushSubs.add(outcomeId);
+        this.pendingSubs.delete(outcomeId);
+        this.scheduleFlush();
+      }
+    }
+    sub.refCount++;
+    return () => {
+      const s = this.subs.get(outcomeId);
+      if (!s) return;
+      s.refCount--;
+      if (s.refCount <= 0 && s.tradeRefs <= 0) {
+        this.subs.delete(outcomeId);
+        this.books.delete(outcomeId);
+        this.resyncing.delete(outcomeId);
+        if (this._connected) {
+          if (this.pendingFlushSubs.has(outcomeId)) {
+            this.pendingFlushSubs.delete(outcomeId);
+          } else {
+            this.pendingFlushUnsubs.add(outcomeId);
+            this.scheduleFlush();
+          }
+        }
+        this.pendingSubs.delete(outcomeId);
+        this.pendingResnapshots.delete(outcomeId);
+      }
+    };
+  }
+  /**
+   * Subscribe to an outcome's trade feed.
+   * @deprecated Use `subscribe(outcomeId, "trades")` instead.
+   * Returns an unsubscribe function.
+   */
+  subscribeTrades(outcomeId) {
+    return this._subscribeTrades(outcomeId);
+  }
+  _subscribeTrades(outcomeId) {
+    let sub = this.subs.get(outcomeId);
+    if (!sub) {
+      sub = { refCount: 0, tradeRefs: 0 };
+      this.subs.set(outcomeId, sub);
+    }
+    if (sub.tradeRefs === 0) {
+      this.pendingTradeSubs.add(outcomeId);
+      this.ensureConnected();
+      if (this._connected) {
+        this.pendingFlushTradeUnsubs.delete(outcomeId);
+        this.pendingFlushTradeSubs.add(outcomeId);
+        this.pendingTradeSubs.delete(outcomeId);
+        this.scheduleFlush();
+      }
+    }
+    sub.tradeRefs++;
+    return () => {
+      const s = this.subs.get(outcomeId);
+      if (!s) return;
+      s.tradeRefs--;
+      if (s.tradeRefs <= 0) {
+        s.tradeRefs = 0;
+        if (this._connected) {
+          if (this.pendingFlushTradeSubs.has(outcomeId)) {
+            this.pendingFlushTradeSubs.delete(outcomeId);
+          } else {
+            this.pendingFlushTradeUnsubs.add(outcomeId);
+            this.scheduleFlush();
+          }
+        }
+        this.pendingTradeSubs.delete(outcomeId);
+        this.pendingResnapshots.delete(outcomeId);
+        if (s.refCount <= 0) {
+          this.subs.delete(outcomeId);
+        }
+      }
+    };
+  }
+  /** Send a JWT to authenticate (or re-authenticate) the connection. */
+  authenticate(token) {
+    if (this._connected) {
+      this.send({ action: "authenticate", token });
+    }
+  }
+  /** Request a fresh snapshot for one or more subscribed outcomes. */
+  resnapshot(outcomeIdOrIds) {
+    const outcomeIds = Array.isArray(outcomeIdOrIds) ? outcomeIdOrIds : [outcomeIdOrIds];
+    outcomeIds.forEach((outcomeId) => {
+      this.requestResnapshot(outcomeId, true);
+    });
+  }
+  /** Connect (idempotent). Called automatically on first subscribe. */
+  connect() {
+    this.ensureConnected();
+  }
+  /** Disconnect and clean up. Reusable — call connect() to reconnect. */
+  disconnect() {
+    var _a, _b;
+    this.cancelReconnect();
+    this.cancelStaleTimer();
+    this._connected = false;
+    this.connecting = false;
+    if (this.ws) {
+      this.ws.onclose = null;
+      this.ws.close();
+      this.ws = null;
+    }
+    (_b = (_a = this.callbacks).onConnectionStateChange) == null ? void 0 : _b.call(_a, false);
+  }
+  /** Permanently destroy. Cannot reconnect after this. */
+  destroy() {
+    this.destroyed = true;
+    this.disconnect();
+    this.subs.clear();
+    this.books.clear();
+    this.resyncing.clear();
+    this.pendingSubs.clear();
+    this.pendingTradeSubs.clear();
+    this.pendingResnapshots.clear();
+    this.pendingFlushSubs.clear();
+    this.pendingFlushUnsubs.clear();
+    this.pendingFlushTradeSubs.clear();
+    this.pendingFlushTradeUnsubs.clear();
+    this.flushScheduled = false;
+  }
+  /** Update callbacks (e.g., after React re-render). */
+  setCallbacks(callbacks) {
+    this.callbacks = callbacks;
+  }
+  // ── Connection management ──
+  ensureConnected() {
+    var _a;
+    if (this.destroyed) return;
+    if (((_a = this.ws) == null ? void 0 : _a.readyState) === WebSocket.OPEN || this.connecting) return;
+    this.doConnect();
+  }
+  doConnect() {
+    if (this.destroyed) return;
+    this.connecting = true;
+    const ws = new WebSocket(this.url);
+    this.ws = ws;
+    ws.onopen = () => {
+      this.connecting = false;
+      this.reconnectAttempts = 0;
+      this.resetStaleTimer();
+      if (this.initialToken) {
+        this.send({ action: "authenticate", token: this.initialToken });
+      }
+    };
+    ws.onmessage = (event) => {
+      this.lastMessageTime = Date.now();
+      this.resetStaleTimer();
+      try {
+        const raw = JSON.parse(event.data);
+        this.handleMessage(raw);
+      } catch (e) {
+      }
+    };
+    ws.onclose = () => {
+      var _a, _b;
+      this.ws = null;
+      this.connecting = false;
+      const wasConnected = this._connected;
+      this._connected = false;
+      this.cancelStaleTimer();
+      if (wasConnected) {
+        (_b = (_a = this.callbacks).onConnectionStateChange) == null ? void 0 : _b.call(_a, false);
+      }
+      if (!this.destroyed && this.subs.size > 0) {
+        this.scheduleReconnect();
+      }
+    };
+    ws.onerror = () => {
+    };
+  }
+  scheduleReconnect() {
+    this.cancelReconnect();
+    const delay = Math.min(
+      RECONNECT_BASE_MS * Math.pow(2, this.reconnectAttempts),
+      RECONNECT_MAX_MS
+    );
+    this.reconnectAttempts++;
+    this.emitDiagnostic({ type: "reconnect", attempt: this.reconnectAttempts, delayMs: delay });
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.doConnect();
+    }, delay);
+  }
+  cancelReconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  // ── Staleness detection ──
+  resetStaleTimer() {
+    this.cancelStaleTimer();
+    this.staleTimer = setTimeout(() => {
+      const age = Date.now() - this.lastMessageTime;
+      this.emitDiagnostic({ type: "stale_connection", lastMessageAge: age });
+      if (this.ws) {
+        this.ws.close();
+      }
+    }, STALE_TIMEOUT_MS);
+  }
+  cancelStaleTimer() {
+    if (this.staleTimer) {
+      clearTimeout(this.staleTimer);
+      this.staleTimer = null;
+    }
+  }
+  // ── Message handling ──
+  handleMessage(raw) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+    const type = raw.type;
+    switch (type) {
+      case "orderbook_snapshot":
+        this.handleSnapshot(raw);
+        break;
+      case "orderbook_delta":
+        this.handleDelta(raw);
+        break;
+      case "trade":
+        this.handleTrade(raw);
+        break;
+      case "heartbeat":
+        this.handleHeartbeat(raw);
+        break;
+      case "subscribed":
+        (_b = (_a = this.callbacks).onSubscribed) == null ? void 0 : _b.call(_a, raw);
+        break;
+      case "unsubscribed":
+        (_d = (_c = this.callbacks).onUnsubscribed) == null ? void 0 : _d.call(_c, raw);
+        break;
+      case "connected":
+        this.handleConnected(raw);
+        break;
+      case "authenticated":
+        (_f = (_e = this.callbacks).onAuthenticated) == null ? void 0 : _f.call(_e, raw);
+        break;
+      case "market_resolved":
+        this.handleMarketResolved(raw);
+        break;
+      case "error":
+        (_h = (_g = this.callbacks).onError) == null ? void 0 : _h.call(_g, raw);
+        break;
+      case "order_submitted":
+        this.handleOrderSubmitted(raw);
+        break;
+      case "balance_update":
+        this.handleBalanceUpdate(raw);
+        break;
+      case "order_event":
+        (_j = (_i = this.callbacks).onOrderEvent) == null ? void 0 : _j.call(_i, raw);
+        break;
+      case "redeem_event":
+        this.handleRedeemEvent(raw);
+        break;
+    }
+  }
+  /**
+   * Server confirmed the connection — gateway has validated our appId and is
+   * ready to accept subscriptions. Now flush all pending subs.
+   */
+  handleConnected(msg) {
+    var _a, _b, _c, _d;
+    this._connected = true;
+    (_b = (_a = this.callbacks).onConnectionStateChange) == null ? void 0 : _b.call(_a, true);
+    (_d = (_c = this.callbacks).onConnected) == null ? void 0 : _d.call(_c, msg);
+    const orderbookSet = new Set(this.activeOrderbookMarkets());
+    this.pendingSubs.forEach((id) => orderbookSet.add(id));
+    this.pendingFlushSubs.forEach((id) => orderbookSet.add(id));
+    const orderbookIds = Array.from(orderbookSet);
+    if (orderbookIds.length > 0) {
+      this.sendSubscribe(orderbookIds);
+    }
+    this.pendingSubs.clear();
+    this.pendingFlushSubs.clear();
+    this.pendingFlushUnsubs.clear();
+    const tradeSet = new Set(this.activeTradeMarkets());
+    this.pendingTradeSubs.forEach((id) => tradeSet.add(id));
+    this.pendingFlushTradeSubs.forEach((id) => tradeSet.add(id));
+    const tradeIds = Array.from(tradeSet);
+    if (tradeIds.length > 0) {
+      this.send({ action: "subscribe", channel: "trades", outcomeIds: tradeIds });
+    }
+    this.pendingTradeSubs.clear();
+    this.pendingFlushTradeSubs.clear();
+    this.pendingFlushTradeUnsubs.clear();
+    const resnapshotIds = Array.from(this.pendingResnapshots);
+    if (resnapshotIds.length > 0) {
+      this.send({ action: "resnapshot", channel: "orderbook", outcomeIds: resnapshotIds });
+    }
+    this.pendingResnapshots.clear();
+  }
+  handleSnapshot(raw) {
+    var _a, _b;
+    const msg = __spreadProps(__spreadValues({}, raw), { timestamp: raw.timestamp / 1e3 });
+    const book = snapshotToOrderbook(msg);
+    this.books.set(msg.outcomeId, book);
+    this.resyncing.delete(msg.outcomeId);
+    this.pendingResnapshots.delete(msg.outcomeId);
+    this.debugOrderbook("snapshot_applied", {
+      outcomeId: msg.outcomeId,
+      seq: msg.seq,
+      checksum: msg.checksum,
+      bidsTop: this.summarizeTopLevels(book.bids),
+      asksTop: this.summarizeTopLevels(book.asks)
+    });
+    (_b = (_a = this.callbacks).onSnapshot) == null ? void 0 : _b.call(_a, msg.outcomeId, book);
+  }
+  handleDelta(raw) {
+    var _a, _b;
+    const outcomeId = raw.outcomeId;
+    const current = this.books.get(outcomeId);
+    const deltaTop = {
+      bids: raw.bidChanges.slice(0, ORDERBOOK_DEBUG_TOP_LEVELS).map(([price, size]) => ({
+        price,
+        size
+      })),
+      asks: raw.askChanges.slice(0, ORDERBOOK_DEBUG_TOP_LEVELS).map(([price, size]) => ({
+        price,
+        size
+      }))
+    };
+    this.debugOrderbook("delta_received", {
+      outcomeId,
+      seq: raw.seq,
+      checksum: raw.checksum,
+      hasCurrentBook: Boolean(current),
+      deltaTop
+    });
+    if (!current) {
+      this.debugOrderbook("delta_missing_snapshot", { outcomeId, seq: raw.seq });
+      this.requestResnapshot(outcomeId);
+      return;
+    }
+    if (raw.seq <= current.seq) {
+      this.debugOrderbook("delta_stale_ignored", {
+        outcomeId,
+        currentSeq: current.seq,
+        receivedSeq: raw.seq
+      });
+      return;
+    }
+    if (raw.seq > current.seq + 1) {
+      this.debugOrderbook("delta_seq_gap", {
+        outcomeId,
+        expectedSeq: current.seq + 1,
+        receivedSeq: raw.seq
+      });
+      this.emitDiagnostic({
+        type: "seq_gap",
+        marketId: outcomeId,
+        outcomeId,
+        expected: current.seq + 1,
+        received: raw.seq
+      });
+      this.requestResnapshot(outcomeId);
+      return;
+    }
+    const msg = __spreadProps(__spreadValues({}, raw), { timestamp: raw.timestamp / 1e3 });
+    const newBook = applyOrderbookDelta(current, msg);
+    this.debugOrderbook("delta_applied_locally", {
+      outcomeId,
+      fromSeq: current.seq,
+      toSeq: newBook.seq,
+      beforeTop: {
+        bids: this.summarizeTopLevels(current.bids),
+        asks: this.summarizeTopLevels(current.asks)
+      },
+      afterTop: {
+        bids: this.summarizeTopLevels(newBook.bids),
+        asks: this.summarizeTopLevels(newBook.asks)
+      }
+    });
+    const computed = computeChecksum(newBook);
+    if (computed !== msg.checksum) {
+      this.debugOrderbook("delta_checksum_mismatch", {
+        outcomeId,
+        seq: msg.seq,
+        expected: msg.checksum,
+        computed
+      });
+      this.emitDiagnostic({
+        type: "checksum_mismatch",
+        marketId: outcomeId,
+        outcomeId,
+        expected: msg.checksum,
+        computed
+      });
+      this.requestResnapshot(outcomeId);
+      return;
+    }
+    this.books.set(outcomeId, newBook);
+    this.debugOrderbook("delta_committed", {
+      outcomeId,
+      seq: newBook.seq,
+      checksum: newBook.checksum,
+      bidsTop: this.summarizeTopLevels(newBook.bids),
+      asksTop: this.summarizeTopLevels(newBook.asks)
+    });
+    (_b = (_a = this.callbacks).onDelta) == null ? void 0 : _b.call(_a, outcomeId, newBook);
+  }
+  handleTrade(raw) {
+    var _a, _b;
+    const msg = __spreadProps(__spreadValues({}, raw), { timestamp: raw.timestamp / 1e3 });
+    (_b = (_a = this.callbacks).onTrade) == null ? void 0 : _b.call(_a, msg);
+  }
+  handleHeartbeat(raw) {
+    var _a, _b;
+    const msg = __spreadProps(__spreadValues({}, raw), { ts: raw.ts / 1e3 });
+    (_b = (_a = this.callbacks).onHeartbeat) == null ? void 0 : _b.call(_a, msg);
+  }
+  handleMarketResolved(raw) {
+    var _a, _b;
+    const msg = __spreadProps(__spreadValues({}, raw), { timestamp: raw.timestamp / 1e3 });
+    this.books.delete(msg.outcomeId);
+    this.pendingResnapshots.delete(msg.outcomeId);
+    this.resyncing.delete(msg.outcomeId);
+    (_b = (_a = this.callbacks).onMarketResolved) == null ? void 0 : _b.call(_a, msg);
+  }
+  handleOrderSubmitted(raw) {
+    var _a, _b;
+    const msg = __spreadProps(__spreadValues({}, raw), { timestamp: raw.timestamp / 1e3 });
+    (_b = (_a = this.callbacks).onOrderSubmitted) == null ? void 0 : _b.call(_a, msg);
+  }
+  handleBalanceUpdate(raw) {
+    var _a, _b;
+    const msg = __spreadProps(__spreadValues({}, raw), { timestamp: raw.timestamp / 1e3 });
+    (_b = (_a = this.callbacks).onBalanceUpdate) == null ? void 0 : _b.call(_a, msg);
+  }
+  handleRedeemEvent(raw) {
+    var _a, _b;
+    const msg = __spreadProps(__spreadValues({}, raw), { timestamp: raw.timestamp / 1e3 });
+    (_b = (_a = this.callbacks).onRedeemEvent) == null ? void 0 : _b.call(_a, msg);
+  }
+  // ── Resnapshot ──
+  requestResnapshot(outcomeId, force = false) {
+    if (this.resyncing.has(outcomeId) && !force) return;
+    this.resyncing.add(outcomeId);
+    if (this._connected) {
+      this.send({ action: "resnapshot", channel: "orderbook", outcomeIds: [outcomeId] });
+      this.pendingResnapshots.delete(outcomeId);
+      return;
+    }
+    this.pendingResnapshots.add(outcomeId);
+    this.ensureConnected();
+  }
+  // ── Helpers ──
+  /**
+   * Schedule a microtask that flushes queued subscribe/unsubscribe frames.
+   * Coalesces multiple same-tick sub/unsub calls into at most one frame per
+   * channel+action pair.
+   */
+  scheduleFlush() {
+    if (this.flushScheduled) return;
+    this.flushScheduled = true;
+    queueMicrotask(() => {
+      this.flushScheduled = false;
+      if (!this._connected) {
+        this.pendingFlushSubs.clear();
+        this.pendingFlushUnsubs.clear();
+        this.pendingFlushTradeSubs.clear();
+        this.pendingFlushTradeUnsubs.clear();
+        return;
+      }
+      this.flushPending();
+    });
+  }
+  flushPending() {
+    for (const id of [...this.pendingFlushSubs]) {
+      if (this.pendingFlushUnsubs.has(id)) {
+        this.pendingFlushSubs.delete(id);
+        this.pendingFlushUnsubs.delete(id);
+      }
+    }
+    if (this.pendingFlushSubs.size > 0) {
+      this.sendSubscribe(Array.from(this.pendingFlushSubs));
+      this.pendingFlushSubs.clear();
+    }
+    if (this.pendingFlushUnsubs.size > 0) {
+      this.send({
+        action: "unsubscribe",
+        channel: "orderbook",
+        outcomeIds: Array.from(this.pendingFlushUnsubs)
+      });
+      this.pendingFlushUnsubs.clear();
+    }
+    for (const id of [...this.pendingFlushTradeSubs]) {
+      if (this.pendingFlushTradeUnsubs.has(id)) {
+        this.pendingFlushTradeSubs.delete(id);
+        this.pendingFlushTradeUnsubs.delete(id);
+      }
+    }
+    if (this.pendingFlushTradeSubs.size > 0) {
+      this.send({
+        action: "subscribe",
+        channel: "trades",
+        outcomeIds: Array.from(this.pendingFlushTradeSubs)
+      });
+      this.pendingFlushTradeSubs.clear();
+    }
+    if (this.pendingFlushTradeUnsubs.size > 0) {
+      this.send({
+        action: "unsubscribe",
+        channel: "trades",
+        outcomeIds: Array.from(this.pendingFlushTradeUnsubs)
+      });
+      this.pendingFlushTradeUnsubs.clear();
+    }
+  }
+  sendSubscribe(outcomeIds) {
+    this.send({ action: "subscribe", channel: "orderbook", outcomeIds });
+  }
+  send(msg) {
+    var _a;
+    if (((_a = this.ws) == null ? void 0 : _a.readyState) === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+  activeOrderbookMarkets() {
+    const markets = [];
+    this.subs.forEach((sub, id) => {
+      if (sub.refCount > 0) markets.push(id);
+    });
+    return markets;
+  }
+  activeTradeMarkets() {
+    const markets = [];
+    this.subs.forEach((sub, id) => {
+      if (sub.tradeRefs > 0) markets.push(id);
+    });
+    return markets;
+  }
+  emitDiagnostic(event) {
+    var _a, _b;
+    (_b = (_a = this.callbacks).onDiagnostics) == null ? void 0 : _b.call(_a, event);
+  }
+  summarizeTopLevels(levels) {
+    return levels.slice(0, ORDERBOOK_DEBUG_TOP_LEVELS).map((level) => ({ price: level.price, size: level.size }));
+  }
+  debugOrderbook(event, payload) {
+    if (!this.isOrderbookDebugEnabled()) return;
+    console.debug(`[AggWebSocket][orderbook] ${event}`, payload);
+  }
+  isOrderbookDebugEnabled() {
+    return this.enableLogs;
+  }
+};
+
+// src/client.ts
+var COOKIE_REFRESH_DELIVERY = "cookie-refresh";
+var isUserProfile = (user) => {
+  return "accounts" in user && "wallets" in user && "avatarUrl" in user;
+};
+var createPersistedHintUserProfile = (input) => {
+  const normalizedWalletAddress = typeof input.walletAddress === "string" && input.walletAddress.trim().length > 0 ? input.walletAddress : null;
+  return {
+    id: input.id,
+    username: input.username,
+    avatarUrl: input.avatarUrl,
+    externalId: null,
+    isLocationBlocked: false,
+    accounts: normalizedWalletAddress ? [
+      {
+        type: "siwe" /* siwe */,
+        provider: "wallet" /* wallet */,
+        providerAccountId: normalizedWalletAddress
+      }
+    ] : [],
+    wallets: [],
+    venueAccounts: []
+  };
+};
+var normalizeSessionUser = (user, currentUser) => {
+  if (!user) return void 0;
+  if (isUserProfile(user)) return user;
+  if ((currentUser == null ? void 0 : currentUser.id) === user.id) return currentUser;
+  return createPersistedHintUserProfile({
+    id: user.id,
+    username: null,
+    avatarUrl: null,
+    walletAddress: null
+  });
+};
+var mapChartResolution = (resolution) => {
+  switch (resolution) {
+    case void 0:
+      return void 0;
+    case "1m":
+      return "1";
+    case "5m":
+      return "5";
+    case "1h":
+      return "60";
+    case "1d":
+      return "1D";
+  }
+};
+var AUTH_PATHS = /* @__PURE__ */ new Set([
+  "/auth/start",
+  "/auth/verify",
+  "/auth/token/refresh",
+  "/auth/token/exchange",
+  "/auth/sign-out"
+]);
+var AggClient = class {
+  constructor(options) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this._authStatus = "unauthenticated";
+    this.authChannel = null;
+    /** In-flight refresh promise — serializes concurrent 401 retries so only one refresh runs. */
+    this.pendingRefresh = null;
+    var _a, _b;
+    if (!options.appId && !options.adminKey) {
+      throw new Error("AggClient requires at least one of appId or adminKey");
+    }
+    this.appId = options.appId;
+    this.adminKey = options.adminKey;
+    this.apiKey = options.apiKey;
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.wsUrl = options.wsUrl;
+    this.authOptions = options.auth;
+    this.storageKey = `agg_auth_${(_a = this.appId) != null ? _a : "default"}`;
+    this.authDelivery = (_b = options.authDelivery) != null ? _b : "body";
+    this.shouldPersistSession = options.persistSession !== false;
+    this.restoreSession();
+    this.initAuthChannel();
+  }
+  withAuthPayload(payload) {
+    var _a, _b, _c;
+    if (typeof payload.earlyAccessCode === "string" && payload.earlyAccessCode.trim().length > 0) {
+      return payload;
+    }
+    const earlyAccessCode = (_c = (_b = (_a = this.authOptions) == null ? void 0 : _a.getEarlyAccessCode) == null ? void 0 : _b.call(_a)) == null ? void 0 : _c.trim();
+    if (!earlyAccessCode) {
+      return payload;
+    }
+    return __spreadProps(__spreadValues({}, payload), {
+      earlyAccessCode
+    });
+  }
+  // --- Session persistence (tokens are NEVER persisted — only a sanitized UI hint) ---
+  restoreSession() {
+    var _a, _b, _c;
+    if (!this.shouldPersistSession || typeof globalThis.localStorage === "undefined") return;
+    try {
+      const raw = localStorage.getItem(this.storageKey);
+      if (!raw) return;
+      const data = JSON.parse(raw);
+      if ("accessToken" in data) {
+        localStorage.removeItem(this.storageKey);
+        return;
+      }
+      const snapshot = data;
+      if (((_a = snapshot.authHint) == null ? void 0 : _a.wasAuthenticated) && ((_b = snapshot.user) == null ? void 0 : _b.id)) {
+        this.currentUser = createPersistedHintUserProfile({
+          id: snapshot.user.id,
+          username: snapshot.user.username,
+          avatarUrl: snapshot.user.avatarUrl,
+          walletAddress: (_c = snapshot.user.walletAddress) != null ? _c : null
+        });
+        this._authStatus = "unknown";
+      }
+    } catch (e) {
+      localStorage.removeItem(this.storageKey);
+    }
+  }
+  persistSession() {
+    var _a;
+    if (!this.shouldPersistSession || typeof globalThis.localStorage === "undefined") return;
+    if (this.accessToken && this.currentUser) {
+      const snapshot = {
+        user: {
+          id: this.currentUser.id,
+          username: this.currentUser.username,
+          avatarUrl: this.currentUser.avatarUrl,
+          walletAddress: (_a = getWalletAddressFromUserProfile(this.currentUser)) != null ? _a : null
+        },
+        authHint: { wasAuthenticated: true }
+      };
+      localStorage.setItem(this.storageKey, JSON.stringify(snapshot));
+    } else {
+      localStorage.removeItem(this.storageKey);
+    }
+  }
+  // --- Cross-tab auth sync via BroadcastChannel ---
+  initAuthChannel() {
+    var _a;
+    if (typeof globalThis.BroadcastChannel === "undefined") return;
+    try {
+      this.authChannel = new BroadcastChannel(`agg_auth_${(_a = this.appId) != null ? _a : "default"}`);
+      this.authChannel.onmessage = (event) => {
+        var _a2;
+        const { type } = (_a2 = event.data) != null ? _a2 : {};
+        if (type === "logout") {
+          this.accessToken = void 0;
+          this.refreshTokenValue = void 0;
+          this.currentUser = void 0;
+          this._authStatus = "unauthenticated";
+          this.persistSession();
+          this.notifyListeners();
+        } else if (type === "login") {
+          this.refreshAccessToken().then(() => this.getCurrentUser()).catch(() => {
+          });
+        }
+      };
+    } catch (e) {
+      this.authChannel = null;
+    }
+  }
+  /** Release resources (BroadcastChannel, etc.). Safe to call multiple times. */
+  destroy() {
+    var _a;
+    (_a = this.authChannel) == null ? void 0 : _a.close();
+    this.authChannel = null;
+  }
+  // --- Core HTTP helper ---
+  /**
+   * Generic HTTP method with automatic header injection and 401 retry.
+   * Attaches `x-app-id`, `Authorization: Bearer`, and `x-admin-key` headers as appropriate.
+   * On 401, attempts a single token refresh and retries the request.
+   * @param path - API path (e.g. `/venue-events`)
+   * @param init - Fetch init options, plus optional `query` object for URL search params
+   */
+  request(path, init) {
+    return __async(this, null, function* () {
+      const response = yield this.rawFetch(path, init);
+      if (response.status === 401 && this.accessToken && !AUTH_PATHS.has(path)) {
+        try {
+          yield this.refreshWithDedup();
+          const retryResponse = yield this.rawFetch(path, init);
+          if (!retryResponse.ok) {
+            return this.throwResponseError(retryResponse);
+          }
+          return retryResponse.json();
+        } catch (e) {
+          this.clearAccessToken();
+          return this.throwResponseError(response);
+        }
+      }
+      if (!response.ok) {
+        return this.throwResponseError(response);
+      }
+      return response.json();
+    });
+  }
+  rawFetch(path, init) {
+    return __async(this, null, function* () {
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (this.appId) {
+        headers["x-app-id"] = this.appId;
+      }
+      if (this.adminKey) {
+        headers["x-admin-key"] = this.adminKey;
+      }
+      if (this.apiKey) {
+        headers["x-app-api-key"] = this.apiKey;
+      }
+      if (this.accessToken) {
+        headers["authorization"] = `Bearer ${this.accessToken}`;
+      }
+      const url = new URL(`${this.baseUrl}${path}`);
+      if (init == null ? void 0 : init.query) {
+        for (const [key, value] of Object.entries(init.query)) {
+          if (Array.isArray(value)) {
+            for (const v of value) {
+              v !== void 0 && url.searchParams.append(key, v == null ? void 0 : v.toString());
+            }
+          } else {
+            value !== void 0 && url.searchParams.set(key, value == null ? void 0 : value.toString());
+          }
+        }
+      }
+      return fetch(url, __spreadProps(__spreadValues({}, init), {
+        headers: __spreadValues(__spreadValues({}, headers), init == null ? void 0 : init.headers)
+      }));
+    });
+  }
+  throwResponseError(response) {
+    return __async(this, null, function* () {
+      let message = response.status === 404 ? "Market not found" : `AGG API error: ${response.status} ${response.statusText}`;
+      let code;
+      let retryable;
+      try {
+        const body = yield response.json();
+        if (typeof body.message === "string" && body.message.length > 0) {
+          message = body.message;
+        }
+        if (typeof body.code === "string" && body.code.length > 0) {
+          code = body.code;
+        }
+        if (typeof body.retryable === "boolean") {
+          retryable = body.retryable;
+        }
+      } catch (e) {
+      }
+      const error = new Error(message);
+      error.status = response.status;
+      if (code) error.code = code;
+      if (retryable !== void 0) error.retryable = retryable;
+      throw error;
+    });
+  }
+  /**
+   * Deduplicates concurrent refresh attempts — if multiple requests hit 401 at the same time,
+   * only one refresh call is made and the rest wait for it.
+   */
+  refreshWithDedup() {
+    if (!this.pendingRefresh) {
+      this.pendingRefresh = this.refreshAccessToken().finally(() => {
+        this.pendingRefresh = null;
+      });
+    }
+    return this.pendingRefresh;
+  }
+  buildAuthRequestInit(init, options) {
+    if (this.authDelivery !== COOKIE_REFRESH_DELIVERY) {
+      return init;
+    }
+    const headers = __spreadValues({}, init.headers);
+    if ((options == null ? void 0 : options.includeDeliveryHeader) !== false) {
+      headers["x-auth-delivery"] = COOKIE_REFRESH_DELIVERY;
+    }
+    return __spreadProps(__spreadValues({}, init), {
+      credentials: "include",
+      headers
+    });
+  }
+  buildUserAuthResult(response, user) {
+    return response.refreshToken === void 0 ? { accessToken: response.accessToken, user } : {
+      accessToken: response.accessToken,
+      refreshToken: response.refreshToken,
+      user
+    };
+  }
+  performSignOutRequest() {
+    return __async(this, null, function* () {
+      yield this.request(
+        "/auth/sign-out",
+        this.buildAuthRequestInit({ method: "POST", body: "{}" }, { includeDeliveryHeader: false })
+      );
+    });
+  }
+  // --- Auth & session state ---
+  /** Set the user access token (for future user-tier auth). */
+  setAccessToken(token) {
+    this.accessToken = token;
+    this._authStatus = "authenticated";
+    this.persistSession();
+    this.notifyListeners();
+  }
+  /** Set the current auth session tokens and optionally seed the user profile. */
+  setSession(session) {
+    const wasAuthenticated = this.isAuthenticated;
+    this.accessToken = session.accessToken;
+    if ("refreshToken" in session) {
+      this.refreshTokenValue = session.refreshToken;
+    }
+    if (session.user !== void 0) {
+      this.currentUser = normalizeSessionUser(session.user, this.currentUser);
+    }
+    this._authStatus = "authenticated";
+    this.persistSession();
+    this.notifyListeners();
+    if (!wasAuthenticated) {
+      this.broadcastAuth("login");
+    }
+  }
+  /** Clear the user access token, refresh token, and user info. Broadcasts cross-tab logout. */
+  clearAccessToken() {
+    this.accessToken = void 0;
+    this.refreshTokenValue = void 0;
+    this.currentUser = void 0;
+    this._authStatus = "unauthenticated";
+    this.persistSession();
+    this.notifyListeners();
+    this.broadcastAuth("logout");
+  }
+  broadcastAuth(type) {
+    var _a;
+    try {
+      (_a = this.authChannel) == null ? void 0 : _a.postMessage({ type });
+    } catch (e) {
+    }
+  }
+  /** Current auth lifecycle status. */
+  get authStatus() {
+    return this._authStatus;
+  }
+  /** Whether a user access token is currently set. */
+  get isAuthenticated() {
+    return !!this.accessToken;
+  }
+  /** Primary wallet address derived from the current user profile. */
+  get address() {
+    return getWalletAddressFromUserProfile(this.currentUser);
+  }
+  /** Subscribe to auth state changes. Returns an unsubscribe function. */
+  onAuthStateChange(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  notifyListeners() {
+    const authenticated = this.isAuthenticated;
+    for (const listener of Array.from(this.listeners)) {
+      listener(authenticated);
+    }
+  }
+  /** Get the currently authenticated user, if any. */
+  get user() {
+    return this.currentUser;
+  }
+  // --- SIWE auth ---
+  /** Build an EIP-4361 SIWE message string (pure formatting, no crypto). */
+  buildSiweMessage(params) {
+    var _a, _b;
+    const chainId = (_a = params.chainId) != null ? _a : 1;
+    const issuedAt = (_b = params.issuedAt) != null ? _b : (/* @__PURE__ */ new Date()).toISOString();
+    let message = `${params.domain} wants you to sign in with your Ethereum account:
+${params.address}`;
+    if (params.statement) {
+      message += `
+
+${params.statement}`;
+    }
+    message += `
+
+URI: ${params.uri}
+Version: 1
+Chain ID: ${chainId}
+Nonce: ${params.nonce}
+Issued At: ${issuedAt}`;
+    return message;
+  }
+  /** Build a SIWS message string for Solana wallet sign-in (pure formatting, no crypto). */
+  buildSiwsMessage(params) {
+    var _a, _b;
+    const chainId = (_a = params.chainId) != null ? _a : "mainnet";
+    const issuedAt = (_b = params.issuedAt) != null ? _b : (/* @__PURE__ */ new Date()).toISOString();
+    let message = `${params.domain} wants you to sign in with your Solana account:
+${params.address}`;
+    if (params.statement) {
+      message += `
+
+${params.statement}`;
+    }
+    message += `
+
+URI: ${params.uri}
+Version: 1
+Chain ID: ${chainId}
+Nonce: ${params.nonce}
+Issued At: ${issuedAt}`;
+    return message;
+  }
+  /** Verify a SIWE/SIWS signature with the API, store the token + user. */
+  verify(args) {
+    return __async(this, null, function* () {
+      const res = yield this.request(
+        "/auth/verify",
+        this.buildAuthRequestInit({
+          method: "POST",
+          body: JSON.stringify(this.withAuthPayload(args))
+        })
+      );
+      this.setSession({
+        accessToken: res.accessToken,
+        refreshToken: res.refreshToken,
+        user: res.user
+      });
+      try {
+        const user = yield this.getCurrentUser();
+        return this.buildUserAuthResult(res, user);
+      } catch (error) {
+        this.clearAccessToken();
+        throw error;
+      }
+    });
+  }
+  /** Backwards-compatible alias for `verify()`. */
+  verifySignIn(args) {
+    return __async(this, null, function* () {
+      return this.verify(args);
+    });
+  }
+  /** Initiate an auth flow (SIWE nonce, OAuth redirect URL, or magic link). */
+  authStart(body) {
+    return __async(this, null, function* () {
+      return this.request("/auth/start", {
+        method: "POST",
+        body: JSON.stringify(this.withAuthPayload(body)),
+        credentials: "include"
+      });
+    });
+  }
+  /** Backwards-compatible alias for `authStart()`. */
+  startAuth(body) {
+    return __async(this, null, function* () {
+      return this.authStart(body);
+    });
+  }
+  /**
+   * Start an account-link flow. Requires the caller to already be signed in — sends
+   * the bearer automatically. Response shape:
+   *  - OAuth providers → `{ type: "redirect", url }`; redirect the browser to `url`.
+   *  - Email → `{ type: "magic_link", success: true }`; check the destination inbox.
+   *
+   * After the provider callback runs, the browser lands back on the app's `redirectUrl`
+   * with a `link_confirm_token` query param. Feed that token to `linkAccountConfirm()`
+   * to persist the Account row.
+   *
+   * Wallet linking (siwe/siws) is not supported yet — it requires a different message
+   * binding protocol than sign-in to be safe against signature phishing.
+   */
+  linkAccount(body) {
+    return __async(this, null, function* () {
+      return this.request(
+        "/users/me/link-account/start",
+        this.buildAuthRequestInit({ method: "POST", body: JSON.stringify(body) })
+      );
+    });
+  }
+  /**
+   * Exchange a `link_confirm_token` for a linked `Account` row. The server matches
+   * the current bearer's `principalId` to the token's `principalId` before writing —
+   * this is the final ownership check.
+   */
+  linkAccountConfirm(token) {
+    return __async(this, null, function* () {
+      return this.request(
+        "/users/me/link-account/confirm",
+        this.buildAuthRequestInit({ method: "POST", body: JSON.stringify({ token }) })
+      );
+    });
+  }
+  /** Exchange a one-time auth code (from OAuth/magic-link callback) for tokens. */
+  exchangeAuthCode(code) {
+    return __async(this, null, function* () {
+      const res = yield this.request(
+        "/auth/token/exchange",
+        this.buildAuthRequestInit({
+          method: "POST",
+          body: JSON.stringify({ code })
+        })
+      );
+      this.setSession({
+        accessToken: res.accessToken,
+        refreshToken: res.refreshToken,
+        user: res.user
+      });
+      try {
+        const user = yield this.getCurrentUser();
+        return this.buildUserAuthResult(res, user);
+      } catch (error) {
+        this.clearAccessToken();
+        throw error;
+      }
+    });
+  }
+  /** Refresh the access token using the stored refresh token. */
+  refreshAccessToken() {
+    return __async(this, null, function* () {
+      if (this.authDelivery !== COOKIE_REFRESH_DELIVERY && !this.refreshTokenValue) {
+        throw new Error("No refresh token available");
+      }
+      const res = yield this.request(
+        "/auth/token/refresh",
+        this.buildAuthRequestInit({
+          method: "POST",
+          body: JSON.stringify(
+            this.authDelivery === COOKIE_REFRESH_DELIVERY ? {} : { refreshToken: this.refreshTokenValue }
+          )
+        })
+      );
+      this.setSession({
+        accessToken: res.accessToken,
+        refreshToken: res.refreshToken,
+        user: res.user
+      });
+      return res.accessToken;
+    });
+  }
+  /** Get the current user's profile. */
+  getCurrentUser() {
+    return __async(this, null, function* () {
+      const user = yield this.request("/users/me");
+      this.currentUser = user;
+      this.persistSession();
+      this.notifyListeners();
+      return user;
+    });
+  }
+  /** Update the current user (e.g. username). Requires currentUser.id; call getCurrentUser() first if needed. */
+  updateUser(data) {
+    return __async(this, null, function* () {
+      var _a;
+      if (!((_a = this.currentUser) == null ? void 0 : _a.id)) {
+        const profile2 = yield this.getCurrentUser();
+        if (!(profile2 == null ? void 0 : profile2.id)) throw new Error("Not authenticated");
+      }
+      const profile = yield this.request("/users/me", {
+        method: "PATCH",
+        body: JSON.stringify(data)
+      });
+      this.currentUser = profile;
+      this.persistSession();
+      this.notifyListeners();
+      return profile;
+    });
+  }
+  /** Link a partner-provided external user ID assertion to the current user. */
+  linkExternalId(params) {
+    return __async(this, null, function* () {
+      const profile = yield this.request("/users/me/external-id", {
+        method: "POST",
+        body: JSON.stringify(params)
+      });
+      this.currentUser = profile;
+      this.persistSession();
+      this.notifyListeners();
+      return profile;
+    });
+  }
+  /** Create a presigned avatar upload URL for the current user. */
+  createAvatarUploadUrl(contentType) {
+    return __async(this, null, function* () {
+      return this.request(
+        "/users/me/avatar",
+        {
+          method: "POST",
+          body: JSON.stringify({ contentType })
+        }
+      );
+    });
+  }
+  /** Disconnect a linked auth provider from the current user. */
+  disconnectAccount(provider) {
+    return __async(this, null, function* () {
+      return this.request(`/users/me/accounts/${provider}`, {
+        method: "DELETE",
+        body: JSON.stringify({})
+      });
+    });
+  }
+  /** Sign out — revoke all tokens server-side and clear local session. */
+  signOut() {
+    return __async(this, null, function* () {
+      if (this.accessToken) {
+        try {
+          yield this.performSignOutRequest();
+        } catch (error) {
+          if (this.authDelivery === COOKIE_REFRESH_DELIVERY && error.status === 401) {
+            try {
+              yield this.refreshAccessToken();
+              yield this.performSignOutRequest();
+            } catch (e) {
+            }
+          }
+        }
+      }
+      this.refreshTokenValue = void 0;
+      this.clearAccessToken();
+    });
+  }
+  /** Get user holdings (positions) for a venue. Uses backend to resolve venue-specific identifiers. */
+  getUserHoldings(params) {
+    return __async(this, null, function* () {
+      const { venue, venueMarketId, venueEventId, cursor } = params;
+      const query = { venue };
+      if (venueMarketId != null) query.venueMarketId = venueMarketId;
+      if (venueEventId != null) query.venueEventId = venueEventId;
+      if (cursor != null) query.cursor = cursor;
+      return this.request("/trading/holdings", {
+        query
+      });
+    });
+  }
+  /** List trade-executor orders for the authenticated user. */
+  getOrders() {
+    return __async(this, arguments, function* (params = {}) {
+      const query = {};
+      if (params.userId) query.userId = params.userId;
+      if (params.status) query.status = params.status;
+      if (params.limit != null) query.limit = String(params.limit);
+      if (params.offset != null) query.offset = String(params.offset);
+      return this.request("/orders", {
+        query: Object.keys(query).length ? query : void 0
+      });
+    });
+  }
+  /** List execution orders for the authenticated user (cursor pagination). */
+  getExecutionOrders() {
+    return __async(this, arguments, function* (params = {}) {
+      const query = {};
+      if (params.orderId) query.orderId = params.orderId;
+      if (params.status) query.status = params.status;
+      if (params.cursor) query.cursor = params.cursor;
+      if (params.limit != null) query.limit = String(params.limit);
+      return this.request("/execution/orders", {
+        query: Object.keys(query).length ? query : void 0
+      });
+    });
+  }
+  /** Unified user activity feed (trades, deposits, withdrawals, bridges, wallet ops). */
+  getUserActivity() {
+    return __async(this, arguments, function* (params = {}) {
+      const query = {};
+      if (params.type) query.type = params.type;
+      if (params.cursor) query.cursor = params.cursor;
+      if (params.limit != null) query.limit = String(params.limit);
+      return this.request("/users/activity", {
+        query: Object.keys(query).length ? query : void 0
+      });
+    });
+  }
+  /** List execution positions for the authenticated user (cursor pagination). */
+  getExecutionPositions() {
+    return __async(this, arguments, function* (params = {}) {
+      const query = {};
+      if (params.cursor) query.cursor = params.cursor;
+      if (params.limit != null) query.limit = String(params.limit);
+      if (params.status) query.status = params.status;
+      return this.request("/execution/positions", {
+        query: Object.keys(query).length ? query : void 0
+      });
+    });
+  }
+  /** Get managed wallet balances, including per-chain cash balances and per-venue position balances. */
+  getManagedBalances() {
+    return __async(this, null, function* () {
+      return this.request("/execution/balances");
+    });
+  }
+  /** Cancel a pending managed execution by order id. */
+  cancelManagedOrder(orderId, options) {
+    return __async(this, null, function* () {
+      return this.request(
+        `/execution/orders/${encodeURIComponent(orderId)}/cancel`,
+        {
+          method: "POST",
+          body: JSON.stringify({}),
+          signal: options == null ? void 0 : options.signal
+        }
+      );
+    });
+  }
+  // --- Venue events & venue markets (primary) ---
+  /** List venue events with optional filters. Requires appId or admin auth. Supports cursor-based pagination. */
+  getVenueEvents(options) {
+    return __async(this, null, function* () {
+      var _a;
+      const query = {};
+      if ((options == null ? void 0 : options.venues) && options.venues.length > 0) query.venues = options.venues;
+      if ((_a = options == null ? void 0 : options.search) == null ? void 0 : _a.trim()) query.search = options.search.trim();
+      if ((options == null ? void 0 : options.categoryIds) && options.categoryIds.length > 0)
+        query.categoryIds = options.categoryIds;
+      if ((options == null ? void 0 : options.matchStatus) && options.matchStatus.length > 0)
+        query.matchStatus = options.matchStatus;
+      if ((options == null ? void 0 : options.status) && options.status.length > 0) query.status = options.status;
+      if (options == null ? void 0 : options.sortBy) query.sortBy = options.sortBy;
+      if (options == null ? void 0 : options.sortDir) query.sortDir = options.sortDir;
+      if ((options == null ? void 0 : options.limit) != null) query.limit = String(options.limit);
+      if (options == null ? void 0 : options.cursor) query.cursor = options.cursor;
+      if ((options == null ? void 0 : options.minYesPrice) != null) query.minYesPrice = String(options.minYesPrice);
+      if ((options == null ? void 0 : options.maxYesPrice) != null) query.maxYesPrice = String(options.maxYesPrice);
+      if (options == null ? void 0 : options.endDateFrom) query.endDateFrom = options.endDateFrom;
+      return this.request("/venue-events", {
+        query: Object.keys(query).length > 0 ? query : void 0
+      });
+    });
+  }
+  /** Get a single venue event by ID. Requires appId or admin auth. */
+  getVenueEventById(id, options) {
+    return __async(this, null, function* () {
+      return this.request(`/venue-events/${encodeURIComponent(id)}`, {
+        signal: options == null ? void 0 : options.signal
+      });
+    });
+  }
+  /** List venue markets with optional filters. Requires appId or admin auth. Supports cursor-based pagination. */
+  getVenueMarkets(options) {
+    return __async(this, null, function* () {
+      var _a;
+      const query = {};
+      if (options == null ? void 0 : options.venue) query.venue = options.venue;
+      if (options == null ? void 0 : options.venueEventId) query.venueEventId = options.venueEventId;
+      if ((_a = options == null ? void 0 : options.search) == null ? void 0 : _a.trim()) query.search = options.search.trim();
+      if (options == null ? void 0 : options.matchStatus) query.matchStatus = options.matchStatus;
+      if (options == null ? void 0 : options.status) query.status = options.status;
+      if ((options == null ? void 0 : options.categoryIds) && options.categoryIds.length > 0)
+        query.categoryIds = options.categoryIds;
+      if ((options == null ? void 0 : options.limit) != null) query.limit = String(options.limit);
+      if (options == null ? void 0 : options.cursor) query.cursor = options.cursor;
+      if (options == null ? void 0 : options.sortBy) query.sortBy = options.sortBy;
+      if (options == null ? void 0 : options.sortDir) query.sortDir = options.sortDir;
+      return this.request("/venue-markets", {
+        query: Object.keys(query).length > 0 ? query : void 0
+      });
+    });
+  }
+  /** Get categories with cursor-based pagination. Requires appId. */
+  getCategories(options) {
+    return __async(this, null, function* () {
+      const query = {};
+      if ((options == null ? void 0 : options.limit) != null) query.limit = String(options.limit);
+      if (options == null ? void 0 : options.cursor) query.cursor = options.cursor;
+      return this.request("/categories", {
+        query: Object.keys(query).length > 0 ? query : void 0
+      });
+    });
+  }
+  /** Get per-app UI config (disabled venues + category presets). Requires appId. */
+  getAppConfig(init) {
+    return __async(this, null, function* () {
+      return this.request("/app/config", init);
+    });
+  }
+  /** Search events or markets by query string. Supports cursor-based pagination. */
+  search(params) {
+    return __async(this, null, function* () {
+      const query = {
+        q: params.q,
+        type: params.type
+      };
+      if (params.categoryIds && params.categoryIds.length > 0) query.categoryIds = params.categoryIds;
+      if (params.limit != null) query.limit = String(params.limit);
+      if (params.cursor) query.cursor = params.cursor;
+      return this.request("/search", {
+        query
+      });
+    });
+  }
+  // --- Chart data ---
+  /** Get the canonical TradingView-style bar series for a single venue market outcome. */
+  getChartBars(params, options) {
+    return __async(this, null, function* () {
+      const resolution = mapChartResolution(params.resolution);
+      const query = {
+        venueMarketOutcomeId: params.venueMarketOutcomeId,
+        to: String(params.to)
+      };
+      if (resolution) query.resolution = resolution;
+      if (params.from != null) query.from = String(params.from);
+      if (params.countBack != null) query.countBack = String(params.countBack);
+      return this.request("/charts/bars", {
+        query,
+        signal: options == null ? void 0 : options.signal
+      });
+    });
+  }
+  // --- Batch orderbooks ---
+  /** Get live per-venue orderbooks for the explicit venueMarketIds requested. */
+  getOrderbooks(params, options) {
+    return __async(this, null, function* () {
+      const query = {
+        venueMarketIds: params.venueMarketIds
+      };
+      if (params.depth != null) query.depth = String(params.depth);
+      return this.request("/orderbooks", {
+        query,
+        signal: options == null ? void 0 : options.signal
+      });
+    });
+  }
+  getMidpoints(paramsOrVenueMarketIds, options) {
+    return __async(this, null, function* () {
+      const venueMarketIds = Array.isArray(paramsOrVenueMarketIds) ? paramsOrVenueMarketIds : paramsOrVenueMarketIds.venueMarketIds;
+      const query = { venueMarketIds };
+      return this.request("/midpoints", {
+        query,
+        signal: options == null ? void 0 : options.signal
+      });
+    });
+  }
+  /** Get a single outcome-level orderbook from the engine. */
+  getOutcomeOrderbook(outcomeId, options) {
+    return __async(this, null, function* () {
+      const query = {};
+      if ((options == null ? void 0 : options.depth) != null) query.depth = String(options.depth);
+      try {
+        return yield this.request(`/orderbook/outcome/${outcomeId}`, {
+          query,
+          signal: options == null ? void 0 : options.signal
+        });
+      } catch (err) {
+        if ((err == null ? void 0 : err.status) === 404) return null;
+        throw err;
+      }
+    });
+  }
+  // --- Market data / orderbook ---
+  /**
+   * Compute optimal order routing across venues via the MILP solver.
+   * Returns a user-scoped quote with per-venue fills and verification timing.
+   * Deprecated aliases are accepted for source compatibility during the
+   * outcome-level migration window.
+   */
+  getSmartRoute(params, options) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const venueMarketOutcomeId = (_b = (_a = params.venueMarketOutcomeId) != null ? _a : params.venueMarketId) != null ? _b : params.outcomeId;
+      if (!venueMarketOutcomeId) {
+        throw new Error("getSmartRoute requires venueMarketOutcomeId");
+      }
+      const query = {};
+      if (params.maxSpend != null) query.maxSpend = String(params.maxSpend);
+      if (params.sellShares != null) query.sellShares = String(params.sellShares);
+      if (params.chainBalances) query.chainBalances = JSON.stringify(params.chainBalances);
+      if (params.slipCapBps != null) query.slipCapBps = String(params.slipCapBps);
+      if (params.compareVenues) query.compareVenues = "true";
+      if (params.tradeSide) query.side = params.tradeSide;
+      const response = yield this.request(
+        `/orderbook/${encodeURIComponent(venueMarketOutcomeId)}/route`,
+        { query, signal: options == null ? void 0 : options.signal }
+      );
+      return params.side ? __spreadProps(__spreadValues({}, response), { side: params.side }) : response;
+    });
+  }
+  /**
+   * Create an AggWebSocket instance configured with this client's appId and optional auth token.
+   * Requires `wsUrl` to be set in the client options.
+   */
+  createWebSocket(callbacks, options) {
+    var _a;
+    if (!this.wsUrl) {
+      throw new Error("AggClient.createWebSocket() requires wsUrl to be set in client options");
+    }
+    const url = new URL(this.wsUrl);
+    if (this.appId) url.searchParams.set("appId", this.appId);
+    return new AggWebSocket({
+      url: url.toString(),
+      callbacks,
+      initialToken: this.accessToken,
+      enableLogs: (_a = options == null ? void 0 : options.enableLogs) != null ? _a : false
+    });
+  }
+  /** Request a quote for a managed trade. Returns quoteId (2-min TTL), execution steps, and splits. */
+  quoteManaged(params) {
+    return __async(this, null, function* () {
+      return this.request("/execution/quote", {
+        method: "POST",
+        body: JSON.stringify(params)
+      });
+    });
+  }
+  /** Execute a previously quoted managed trade. Returns pending order IDs. */
+  executeManaged(params) {
+    return __async(this, null, function* () {
+      return this.request("/execution/fill", {
+        method: "POST",
+        body: JSON.stringify(params)
+      });
+    });
+  }
+  /** Redeem resolved winning positions by venue market outcome ids. */
+  redeem(body) {
+    return __async(this, null, function* () {
+      return this.request("/execution/redeem", {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+    });
+  }
+  /** Withdraw funds from managed wallets to an external address. */
+  withdrawManaged(params) {
+    return __async(this, null, function* () {
+      return this.request("/execution/withdraw", {
+        method: "POST",
+        body: JSON.stringify(params)
+      });
+    });
+  }
+  /** Trigger an on-chain balance sync for all tracked tokens across all chains. */
+  syncManagedBalances() {
+    return __async(this, null, function* () {
+      return this.request("/execution/sync-balances", {
+        method: "POST",
+        body: JSON.stringify({})
+      });
+    });
+  }
+  /** Get managed wallet deposit addresses (EVM + Solana). Returns 202 shape while provisioning. */
+  getDepositAddresses() {
+    return __async(this, null, function* () {
+      return this.request("/execution/deposit-addresses");
+    });
+  }
+  /** Get open positions grouped by matched market with per-venue breakdown. */
+  getPositions(params) {
+    return __async(this, null, function* () {
+      const query = {};
+      if (params == null ? void 0 : params.cursor) query.cursor = params.cursor;
+      if ((params == null ? void 0 : params.limit) != null) query.limit = String(params.limit);
+      if (params == null ? void 0 : params.status) query.status = params.status;
+      return this.request("/execution/positions", {
+        query: Object.keys(query).length > 0 ? query : void 0
+      });
+    });
+  }
+  // --- Ramp ---
+  /** Get crypto purchase quotes. */
+  getRampQuotes(params) {
+    return __async(this, null, function* () {
+      return this.request("/ramp/quotes", {
+        method: "POST",
+        body: JSON.stringify(params)
+      });
+    });
+  }
+  /** Create a ramp widget session for checkout. */
+  createRampSession(params) {
+    return __async(this, null, function* () {
+      return this.request("/ramp/session", {
+        method: "POST",
+        body: JSON.stringify(params)
+      });
+    });
+  }
+  /** Initiate KYC verification for a venue. Returns a KYC URL to redirect the user to. */
+  initiateKyc(venue, redirectUri) {
+    return __async(this, null, function* () {
+      return this.request(`/kyc/${venue}`, {
+        method: "POST",
+        body: JSON.stringify({ redirectUri })
+      });
+    });
+  }
+};
+
+// src/best-split.ts
+var computeBestSplitsByAmount2 = computeBestSplitsByAmount;
+
+// src/errors.ts
+var TurnstileChallengeError = class extends Error {
+  constructor(siteKey) {
+    super("Bot protection challenge required. Render Turnstile widget and retry.");
+    this.name = "TurnstileChallengeError";
+    this.siteKey = siteKey;
+  }
+};
+
+// src/candle-builder.ts
+var INTERVAL_SECS = {
+  "1m": 60,
+  "5m": 300,
+  "1h": 3600,
+  "1d": 86400
+};
+var ALL_INTERVALS = ["1m", "5m", "1h", "1d"];
+var MAX_CLOSED = 500;
+var CandleBuilder = class {
+  constructor() {
+    this.forming = /* @__PURE__ */ new Map();
+    this.closedMap = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Set();
+    this._midpoint = null;
+    this.dirty = false;
+    this.scheduled = false;
+    for (const interval of ALL_INTERVALS) {
+      this.closedMap.set(interval, []);
+    }
+  }
+  /** Feed a midpoint (from orderbook delta). Updates O/H/L/C for all intervals. */
+  addMidpoint(midpoint, timestampSecs) {
+    if (!Number.isFinite(midpoint) || !Number.isFinite(timestampSecs)) return;
+    this._midpoint = midpoint;
+    for (const interval of ALL_INTERVALS) {
+      this.updateCandle(interval, midpoint, timestampSecs);
+    }
+    this.markDirty();
+  }
+  /** Feed a trade. Updates volume + refines H/L/C from trade price. */
+  addTrade(price, size, timestampSecs) {
+    if (!Number.isFinite(price) || !Number.isFinite(size) || !Number.isFinite(timestampSecs))
+      return;
+    for (const interval of ALL_INTERVALS) {
+      this.updateCandle(interval, price, timestampSecs, size);
+    }
+    this.markDirty();
+  }
+  /** Current forming candle for an interval. */
+  getForming(interval) {
+    var _a;
+    return (_a = this.forming.get(interval)) != null ? _a : null;
+  }
+  /** Closed candles for an interval (ring buffer, max 500, newest last). */
+  getClosed(interval) {
+    var _a;
+    return (_a = this.closedMap.get(interval)) != null ? _a : [];
+  }
+  /** Current midpoint (latest value fed). */
+  get midpoint() {
+    return this._midpoint;
+  }
+  /**
+   * Subscribe to state changes. Returns unsubscribe function.
+   * BATCHED: callbacks fire at most once per rAF frame (~16ms).
+   * In non-browser environments, falls back to 16ms setTimeout.
+   */
+  onChange(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /** Clear all state (on reconnect). */
+  reset() {
+    this.forming.clear();
+    for (const interval of ALL_INTERVALS) {
+      this.closedMap.set(interval, []);
+    }
+    this._midpoint = null;
+    this.dirty = false;
+  }
+  /** Clear all state AND unsubscribe all listeners. Called on store eviction. */
+  dispose() {
+    this.reset();
+    this.listeners.clear();
+  }
+  updateCandle(interval, price, timestampSecs, tradeSize) {
+    const secs = INTERVAL_SECS[interval];
+    const openTime = Math.floor(timestampSecs / secs) * secs;
+    const current = this.forming.get(interval);
+    if (current && current.openTime !== openTime) {
+      const closed = this.closedMap.get(interval);
+      closed.push(__spreadProps(__spreadValues({}, current), { isFinal: true }));
+      if (closed.length > MAX_CLOSED) closed.shift();
+      this.forming.set(interval, {
+        openTime,
+        o: price,
+        h: price,
+        l: price,
+        c: price,
+        v: tradeSize != null ? tradeSize : 0,
+        tradeCount: tradeSize != null ? 1 : 0,
+        isFinal: false
+      });
+    } else if (!current) {
+      this.forming.set(interval, {
+        openTime,
+        o: price,
+        h: price,
+        l: price,
+        c: price,
+        v: tradeSize != null ? tradeSize : 0,
+        tradeCount: tradeSize != null ? 1 : 0,
+        isFinal: false
+      });
+    } else {
+      current.h = Math.max(current.h, price);
+      current.l = Math.min(current.l, price);
+      current.c = price;
+      if (tradeSize != null) {
+        current.v += tradeSize;
+        current.tradeCount += 1;
+      }
+    }
+  }
+  markDirty() {
+    this.dirty = true;
+    if (this.scheduled) return;
+    this.scheduled = true;
+    const tick = typeof requestAnimationFrame === "function" ? requestAnimationFrame : (fn) => setTimeout(fn, 16);
+    tick(() => {
+      this.scheduled = false;
+      if (this.dirty) {
+        this.dirty = false;
+        this.listeners.forEach((l) => l());
+      }
+    });
+  }
+};
+
+// src/market-aggregator.ts
+function mergeCandles(candles) {
+  const valid = candles.filter((c2) => c2 != null);
+  if (valid.length === 0) return null;
+  if (valid.length === 1) return __spreadValues({}, valid[0]);
+  const totalVolume = valid.reduce((sum, c2) => sum + c2.v, 0);
+  let o;
+  let c;
+  if (totalVolume > 0) {
+    o = valid.reduce((sum, candle) => sum + candle.o * candle.v, 0) / totalVolume;
+    c = valid.reduce((sum, candle) => sum + candle.c * candle.v, 0) / totalVolume;
+  } else {
+    o = valid.reduce((sum, candle) => sum + candle.o, 0) / valid.length;
+    c = valid.reduce((sum, candle) => sum + candle.c, 0) / valid.length;
+  }
+  return {
+    openTime: valid[0].openTime,
+    o,
+    h: Math.max(...valid.map((candle) => candle.h)),
+    l: Math.min(...valid.map((candle) => candle.l)),
+    c,
+    v: totalVolume,
+    tradeCount: valid.reduce((sum, candle) => sum + candle.tradeCount, 0),
+    isFinal: valid.every((candle) => candle.isFinal)
+  };
+}
+function mergeClosedCandles(candleArrays) {
+  const byTime = /* @__PURE__ */ new Map();
+  for (const arr of candleArrays) {
+    for (const candle of arr) {
+      const group = byTime.get(candle.openTime);
+      if (group) {
+        group.push(candle);
+      } else {
+        byTime.set(candle.openTime, [candle]);
+      }
+    }
+  }
+  const merged = [];
+  for (const [, group] of byTime) {
+    const result = mergeCandles(group);
+    if (result) merged.push(result);
+  }
+  merged.sort((a, b) => a.openTime - b.openTime);
+  return merged;
+}
+function aggregateMidpoint(midpoints) {
+  const valid = midpoints.filter((m) => m != null && Number.isFinite(m));
+  if (valid.length === 0) return null;
+  return valid.reduce((sum, m) => sum + m, 0) / valid.length;
+}
+
+// src/index.ts
+function createAggClient(options) {
+  return new AggClient(options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccountProvider,
+  AccountType,
+  AggClient,
+  AggWebSocket,
+  CONFIRMED_MATCH_STATUSES,
+  CandleBuilder,
+  Chain,
+  IMAGE_SIZES,
+  ImageSize,
+  MarketStatus,
+  MatchStatus,
+  MatchType,
+  OrderStatus,
+  TradeSide,
+  TurnstileChallengeError,
+  VENUES,
+  Venue,
+  aggregateMidpoint,
+  applyOrderbookDelta,
+  computeBestSplitsByAmount,
+  computeChecksum,
+  createAggClient,
+  enumGuard,
+  formatMarketQuestion,
+  formatOutcomeLabel,
+  getWalletAddressFromUserProfile,
+  hasShape,
+  isEmail,
+  isEnum,
+  isFiniteNonNeg,
+  isNonEmptyString,
+  mergeCandles,
+  mergeClosedCandles,
+  normalizeVenueMarketCluster,
+  optimizedImageUrl,
+  parse,
+  parseEmail,
+  parseEmailStrict,
+  safeParse,
+  snapshotToOrderbook,
+  sortVenues
+});