@agg-build/sdk 4.17.4 → 4.18.0

package/dist/chunk-QXBVA5TW.mjs

@@ -0,0 +1,2073 @@
+import {
+  __async,
+  __objRest,
+  __spreadProps,
+  __spreadValues
+} from "./chunk-WNQUEZJF.mjs";
+
+// src/market-data/history-decoder.ts
+function decodeChartHistory(payload) {
+  if (payload.length > 1048576) throw new Error("Chart history exceeds decode budget");
+  const body = JSON.parse(payload);
+  if (!body || !Array.isArray(body.data) || body.data.length > 5e3 || typeof body.venueMarketOutcomeId !== "string" || typeof body.venue !== "string" || !["1m", "5m", "1h", "1d"].includes(body.resolution) || !body.meta)
+    throw new Error("Invalid chart history response");
+  const price = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+  for (const bar of body.data) {
+    if (!Number.isSafeInteger(bar.t) || bar.t < 0 || ![bar.o, bar.h, bar.l, bar.c].every(price) || bar.l > Math.min(bar.o, bar.c) || bar.h < Math.max(bar.o, bar.c) || bar.v !== null && (!Number.isFinite(bar.v) || bar.v < 0) || bar.mean !== void 0 && !price(bar.mean))
+      throw new Error("Invalid chart history candle");
+  }
+  const data = [...body.data].sort((a, b) => a.t - b.t);
+  if (data.some((bar, index) => index > 0 && data[index - 1].t === bar.t))
+    throw new Error("Duplicate chart history timestamp");
+  return __spreadProps(__spreadValues({}, body), { data });
+}
+function readChartHistoryText(response) {
+  return __async(this, null, function* () {
+    var _a, _b;
+    const maxBytes = 1048576;
+    if (Number(response.headers.get("content-length")) > maxBytes) {
+      yield (_a = response.body) == null ? void 0 : _a.cancel();
+      throw new Error("Chart history exceeds decode budget");
+    }
+    if (!((_b = response.body) == null ? void 0 : _b.getReader)) {
+      const text2 = yield response.text();
+      if (new TextEncoder().encode(text2).byteLength > maxBytes)
+        throw new Error("Chart history exceeds decode budget");
+      return text2;
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let size = 0;
+    let text = "";
+    try {
+      while (true) {
+        const { value, done } = yield reader.read();
+        if (done) return text + decoder.decode();
+        size += value.byteLength;
+        if (size > maxBytes) {
+          yield reader.cancel();
+          throw new Error("Chart history exceeds decode budget");
+        }
+        text += decoder.decode(value, { stream: true });
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  });
+}
+
+// src/market-history.ts
+function readBoundedBody(response, signal) {
+  return __async(this, null, function* () {
+    var _a, _b;
+    if (!response.body) throw new Error("Missing history body");
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
+    const abort = () => {
+      void reader.cancel(signal.reason).catch(() => void 0);
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    try {
+      while (true) {
+        if (signal.aborted) throw (_a = signal.reason) != null ? _a : new Error("History request aborted");
+        const { done, value } = yield reader.read();
+        if (signal.aborted) throw (_b = signal.reason) != null ? _b : new Error("History request aborted");
+        if (done) break;
+        size += value.byteLength;
+        if (size > 262144) {
+          yield reader.cancel();
+          throw new Error("Oversized history object");
+        }
+        chunks.push(value);
+      }
+      const bytes = new Uint8Array(size);
+      let offset = 0;
+      for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+      }
+      return bytes;
+    } finally {
+      signal.removeEventListener("abort", abort);
+      reader.releaseLock();
+    }
+  });
+}
+function loadImmutableHistory(_0) {
+  return __async(this, arguments, function* ({
+    manifest,
+    fetch: fetcher = globalThis.fetch,
+    signal,
+    digest
+  }) {
+    if (manifest.version !== 1 || !["venue-ohlcv-v1", "polymarket-price-samples-v1", "kalshi-ohlcv-quote-fallback-v2"].includes(
+      manifest.semantics
+    ) || manifest.chunks.length > 8 || manifest.chunks.reduce((n, c) => n + c.points, 0) > 4096 || !manifest.meta.complete) {
+      throw new Error("History manifest is incomplete or unsupported");
+    }
+    const hash = digest != null ? digest : ((bytes) => __async(null, null, function* () {
+      var _a;
+      if (!((_a = globalThis.crypto) == null ? void 0 : _a.subtle))
+        throw new Error(
+          "History integrity requires WebCrypto or an injected SHA-256 implementation"
+        );
+      const value = yield globalThis.crypto.subtle.digest("SHA-256", bytes);
+      return Array.from(new Uint8Array(value), (b) => b.toString(16).padStart(2, "0")).join("");
+    }));
+    const results = new Array(manifest.chunks.length);
+    let next = 0;
+    const controller = new AbortController();
+    const deadline = setTimeout(
+      () => controller.abort(new Error("History download budget exhausted")),
+      2e3
+    );
+    const abort = () => controller.abort(signal == null ? void 0 : signal.reason);
+    signal == null ? void 0 : signal.addEventListener("abort", abort, { once: true });
+    if (signal == null ? void 0 : signal.aborted) abort();
+    try {
+      yield Promise.all(
+        Array.from({ length: Math.min(2, manifest.chunks.length) }, () => __async(null, null, function* () {
+          var _a;
+          while (next < manifest.chunks.length) {
+            if (controller.signal.aborted)
+              throw (_a = controller.signal.reason) != null ? _a : new Error("History request aborted");
+            const index = next++;
+            const chunk = manifest.chunks[index];
+            if (chunk.points < 0 || chunk.points > 512 || chunk.from >= chunk.to || new URL(chunk.url).protocol !== "https:")
+              throw new Error("Invalid history reference");
+            const response = yield fetcher(chunk.url, {
+              signal: controller.signal,
+              credentials: "omit"
+            });
+            if (!response.ok) throw new Error(`History download failed (${response.status})`);
+            if (Number(response.headers.get("content-length")) > 262144)
+              throw new Error("Oversized history object");
+            const bytes = yield readBoundedBody(response, controller.signal);
+            if (bytes.byteLength > 262144 || (yield hash(bytes)) !== chunk.sha256)
+              throw new Error("History integrity mismatch");
+            const object2 = JSON.parse(new TextDecoder().decode(bytes));
+            if (object2.version !== 1 || object2.venueMarketOutcomeId !== manifest.venueMarketOutcomeId || object2.venue !== manifest.venue || object2.resolution !== manifest.resolution || object2.semantics !== manifest.semantics || object2.from !== chunk.from || object2.to !== chunk.to || !Array.isArray(object2.data) || object2.data.length !== chunk.points) {
+              throw new Error("History identity mismatch");
+            }
+            let previous = -Infinity;
+            for (const bar of object2.data) {
+              if (!Number.isSafeInteger(bar.t) || bar.t <= previous || bar.t < chunk.from || bar.t >= chunk.to || ![bar.o, bar.h, bar.l, bar.c].every((v) => Number.isFinite(v) && v >= 0 && v <= 1) || bar.l > Math.min(bar.o, bar.c) || bar.h < Math.max(bar.o, bar.c) || bar.v !== null && (!Number.isFinite(bar.v) || bar.v < 0) || bar.mean !== void 0 && (!Number.isFinite(bar.mean) || bar.mean < 0 || bar.mean > 1))
+                throw new Error("Invalid history candle");
+              previous = bar.t;
+            }
+            results[index] = object2.data;
+          }
+        }))
+      );
+      const bars = results.flat().filter((b) => b.t >= manifest.from && b.t < manifest.to).sort((a, b) => a.t - b.t);
+      if (bars.some((b, i) => i > 0 && bars[i - 1].t === b.t))
+        throw new Error("Overlapping history chunks");
+      return bars;
+    } catch (error) {
+      controller.abort(error);
+      throw error;
+    } finally {
+      clearTimeout(deadline);
+      signal == null ? void 0 : signal.removeEventListener("abort", abort);
+    }
+  });
+}
+
+// ../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["pred"] = "pred";
+  Venue2["tiprun"] = "tiprun";
+  Venue2["probable"] = "probable";
+  Venue2["myriad"] = "myriad";
+  Venue2["hyperliquid"] = "hyperliquid";
+  Venue2["novig"] = "novig";
+  Venue2["prophetx"] = "prophetx";
+  Venue2["betdex"] = "betdex";
+  return Venue2;
+})(Venue || {});
+var VENUES = [
+  "kalshi" /* kalshi */,
+  "polymarket" /* polymarket */,
+  "limitless" /* limitless */,
+  "opinion" /* opinion */,
+  "predict" /* predict */,
+  "pred" /* pred */,
+  "tiprun" /* tiprun */,
+  "probable" /* probable */,
+  "myriad" /* myriad */,
+  "hyperliquid" /* hyperliquid */,
+  "novig" /* novig */,
+  "prophetx" /* prophetx */,
+  "betdex" /* betdex */
+];
+var VENUE_CHAIN_IDS = {
+  ["kalshi" /* kalshi */]: 792703809,
+  ["polymarket" /* polymarket */]: 137,
+  ["limitless" /* limitless */]: 8453,
+  ["predict" /* predict */]: 56,
+  ["pred" /* pred */]: 8453,
+  ["tiprun" /* tiprun */]: 42161,
+  ["myriad" /* myriad */]: 56,
+  ["hyperliquid" /* hyperliquid */]: 1337,
+  ["novig" /* novig */]: 792703809,
+  ["prophetx" /* prophetx */]: 792703809
+};
+var ACTIVE_VENUES = [
+  "kalshi" /* kalshi */,
+  "polymarket" /* polymarket */,
+  "limitless" /* limitless */,
+  "opinion" /* opinion */,
+  "predict" /* predict */,
+  "pred" /* pred */,
+  "tiprun" /* tiprun */,
+  "probable" /* probable */,
+  "myriad" /* myriad */,
+  "hyperliquid" /* hyperliquid */,
+  "novig" /* novig */,
+  "prophetx" /* prophetx */,
+  "betdex" /* betdex */
+];
+var INACTIVE_VENUES = [];
+var DEFAULT_DISABLED_VENUES = [
+  "pred" /* pred */,
+  "tiprun" /* tiprun */,
+  "novig" /* novig */,
+  "prophetx" /* prophetx */,
+  "betdex" /* betdex */
+];
+var ACTIVE_VENUE_SET = new Set(ACTIVE_VENUES);
+var INACTIVE_VENUE_SET = new Set(INACTIVE_VENUES);
+function normalizeVenue(venue) {
+  return venue.trim().toLowerCase();
+}
+function isVenueActive(venue) {
+  if (ACTIVE_VENUE_SET.has(venue)) return true;
+  if (INACTIVE_VENUE_SET.has(venue)) return false;
+  return ACTIVE_VENUE_SET.has(normalizeVenue(venue));
+}
+function isVenueInactive(venue) {
+  if (INACTIVE_VENUE_SET.has(venue)) return true;
+  if (ACTIVE_VENUE_SET.has(venue)) return false;
+  return INACTIVE_VENUE_SET.has(normalizeVenue(venue));
+}
+function isVenueDataVisible(venue, dataVisibleOverride = []) {
+  if (isVenueActive(venue)) return true;
+  const n = normalizeVenue(venue);
+  return dataVisibleOverride.some((v) => normalizeVenue(v) === n);
+}
+function getEffectiveDisabledVenues(disabledVenues, dataVisibleVenues = []) {
+  if (disabledVenues === void 0) {
+    const disabled2 = new Set(DEFAULT_DISABLED_VENUES);
+    for (const venue of dataVisibleVenues) disabled2.delete(normalizeVenue(venue));
+    return VENUES.filter((venue) => disabled2.has(venue));
+  }
+  const disabled = new Set(disabledVenues.map(normalizeVenue));
+  return VENUES.filter((venue) => disabled.has(venue));
+}
+
+// ../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["xl"] = 80] = "xl";
+  ImageSize2[ImageSize2["xxl"] = 96] = "xxl";
+  ImageSize2[ImageSize2["xxxl"] = 120] = "xxxl";
+  ImageSize2[ImageSize2["original"] = 0] = "original";
+  return ImageSize2;
+})(ImageSize || {});
+var IMAGE_SIZES = [
+  44 /* sm */,
+  48 /* md */,
+  60 /* lg */,
+  80 /* xl */,
+  96 /* xxl */,
+  120 /* xxxl */
+];
+var RETINA_IMAGE_SIZES = [80 /* xl */, 96 /* xxl */, 120 /* xxxl */];
+
+// ../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__ */ ((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/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["open"] = "open";
+  OrderStatus2["partially_filled_open"] = "partially_filled_open";
+  OrderStatus2["cancel_pending"] = "cancel_pending";
+  OrderStatus2["filled"] = "filled";
+  OrderStatus2["partial_fill"] = "partial_fill";
+  OrderStatus2["failed"] = "failed";
+  OrderStatus2["expired"] = "expired";
+  OrderStatus2["cancelled"] = "cancelled";
+  return OrderStatus2;
+})(OrderStatus || {});
+var TradeSide = /* @__PURE__ */ ((TradeSide2) => {
+  TradeSide2["Buy"] = "buy";
+  TradeSide2["Sell"] = "sell";
+  return TradeSide2;
+})(TradeSide || {});
+var OrderType = /* @__PURE__ */ ((OrderType2) => {
+  OrderType2["Market"] = "market";
+  OrderType2["Limit"] = "limit";
+  return OrderType2;
+})(OrderType || {});
+var TimeInForce = /* @__PURE__ */ ((TimeInForce2) => {
+  TimeInForce2["GTC"] = "GTC";
+  TimeInForce2["GTD"] = "GTD";
+  TimeInForce2["FOK"] = "FOK";
+  TimeInForce2["FAK"] = "FAK";
+  TimeInForce2["IOC"] = "IOC";
+  TimeInForce2["ALO"] = "ALO";
+  return TimeInForce2;
+})(TimeInForce || {});
+
+// ../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();
+}
+function formatOutcomeTitle(_venue, outcome, market) {
+  var _a, _b;
+  const outcomes = (_a = market.venueMarketOutcomes) != null ? _a : [];
+  if (outcomes.length >= 2) {
+    const normalized = outcomes.map((o) => {
+      var _a2, _b2;
+      return (_b2 = (_a2 = o.title) == null ? void 0 : _a2.trim()) != null ? _b2 : "";
+    });
+    const hasAnyTitle = normalized.some((t) => t.length > 0);
+    if (hasAnyTitle && normalized.every((t) => t === normalized[0])) return null;
+  }
+  const title = (_b = outcome.title) == null ? void 0 : _b.trim();
+  if (title) return title;
+  return deriveOverUnderTitle(outcome.label, market.question);
+}
+var OVER_UNDER_QUESTION = /\bO\/U\s+\d/i;
+function deriveOverUnderTitle(label, question) {
+  if (!question || !OVER_UNDER_QUESTION.test(question)) return null;
+  const normalized = label.trim().toLowerCase();
+  if (normalized === "yes") return "Over";
+  if (normalized === "no") return "Under";
+  return null;
+}
+
+// ../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/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}`);
+}
+function retinaImageUrl(url, maxPx) {
+  if (!url) return void 0;
+  if (!VARIANT_RE.test(url)) return void 0;
+  const variant = RETINA_IMAGE_SIZES.find((size) => size >= maxPx * 2);
+  if (variant == null) return void 0;
+  return url.replace(VARIANT_RE, `/${variant}.webp`);
+}
+
+// ../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 */,
+  "hyperliquid" /* hyperliquid */,
+  "predict" /* predict */,
+  "prophetx" /* prophetx */,
+  "betdex" /* betdex */,
+  "kalshi" /* kalshi */,
+  "limitless" /* limitless */,
+  "myriad" /* myriad */,
+  "pred" /* pred */,
+  "tiprun" /* tiprun */,
+  "probable" /* probable */,
+  "novig" /* novig */,
+  "opinion" /* opinion */
+];
+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));
+
+// ../common/src/utils/venue-url.ts
+function buildVenueUrl(venue, opts) {
+  switch (venue) {
+    case "kalshi": {
+      const series = opts.seriesExternalId;
+      const event = opts.eventExternalId;
+      if (series && event) {
+        return `https://kalshi.com/markets/${series.toLowerCase()}/${event.toLowerCase()}`;
+      }
+      return null;
+    }
+    case "polymarket": {
+      if (opts.eventSlug) return `https://polymarket.com/event/${opts.eventSlug}`;
+      if (opts.conditionId) return `https://polymarket.com/market/${opts.conditionId}`;
+      return null;
+    }
+    case "predict": {
+      if (opts.eventSlug) return `https://predict.fun/market/${opts.eventSlug}`;
+      return null;
+    }
+    case "pred": {
+      if (opts.eventSlug) return `https://www.pred.app/trade/${opts.eventSlug}`;
+      return null;
+    }
+    case "limitless": {
+      if (opts.eventSlug) return `https://limitless.exchange/markets/${opts.eventSlug}`;
+      return null;
+    }
+    case "opinion": {
+      if (opts.eventSlug) return `https://www.opinion.trade/market/${opts.eventSlug}`;
+      return null;
+    }
+    case "myriad": {
+      if (opts.eventSlug) return `https://myriad.markets/markets/${opts.eventSlug}`;
+      return null;
+    }
+    case "hyperliquid": {
+      if (opts.eventSlug) return `https://app.hyperliquid.xyz/trade/${opts.eventSlug}`;
+      return null;
+    }
+    case "probable": {
+      if (opts.eventSlug) return `https://probable.markets/event/${opts.eventSlug}`;
+      return null;
+    }
+    case "novig": {
+      if (opts.outcomeExternalId && opts.partnerId) {
+        return opts.platform === "native" ? `novigapp://events/${opts.outcomeExternalId}/${opts.partnerId}` : `https://novig.com/events/${opts.outcomeExternalId}/${opts.partnerId}`;
+      }
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+
+// ../common/src/utils/limit-price-ticks.ts
+var LIMIT_PRICE_RAW_SCALE = BigInt(1e6);
+var resolveTickSizeRaw = (tickSize) => {
+  const scaledTick = tickSize * Number(LIMIT_PRICE_RAW_SCALE);
+  const roundedTick = Math.round(scaledTick);
+  if (!Number.isFinite(scaledTick) || roundedTick <= 0 || Math.abs(scaledTick - roundedTick) > 1e-6) {
+    throw new RangeError(`Unsupported limit-order tick size: ${tickSize}`);
+  }
+  return BigInt(roundedTick);
+};
+var adjustLimitPriceRawToTick = ({
+  limitPriceRaw,
+  side,
+  tickSize
+}) => {
+  const originalPrice = BigInt(limitPriceRaw);
+  const originalPriceRaw = originalPrice.toString();
+  if (tickSize == null) {
+    return {
+      adjusted: false,
+      adjustedPriceRaw: originalPriceRaw,
+      originalPriceRaw,
+      tickSizeRaw: null
+    };
+  }
+  const tickSizeRaw = resolveTickSizeRaw(tickSize);
+  const remainder = originalPrice % tickSizeRaw;
+  if (remainder === BigInt(0)) {
+    return {
+      adjusted: false,
+      adjustedPriceRaw: originalPriceRaw,
+      originalPriceRaw,
+      tickSizeRaw: tickSizeRaw.toString()
+    };
+  }
+  const adjustedPrice = side === "buy" ? originalPrice - remainder : originalPrice + (tickSizeRaw - remainder);
+  return {
+    adjusted: true,
+    adjustedPriceRaw: adjustedPrice.toString(),
+    originalPriceRaw,
+    tickSizeRaw: tickSizeRaw.toString()
+  };
+};
+
+// ../common/src/utils/balance-refill.ts
+var DEFAULT_BALANCE_REFILL_DAILY_CAP_RAW = "1002000000";
+var DEFAULT_BALANCE_REFILL_MAX_FEE_RAW = "2000000";
+var getBalanceRefillMaximumRaw = (dailyCapRaw, maxFeeRaw) => {
+  const dailyCap = BigInt(dailyCapRaw);
+  const maximumFee = BigInt(maxFeeRaw);
+  if (dailyCap <= maximumFee) return "0";
+  return (dailyCap - maximumFee).toString();
+};
+var isBalanceRefillWithinDailyCap = (minimumRaw, refillAmountRaw, dailyCapRaw, maxFeeRaw) => {
+  const maximum = BigInt(getBalanceRefillMaximumRaw(dailyCapRaw, maxFeeRaw));
+  return BigInt(minimumRaw) <= maximum && BigInt(refillAmountRaw) <= maximum;
+};
+
+// ../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 levels2 = [];
+  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 levels2.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 levels2.push({
+            venue,
+            venueMarketOutcomeId,
+            outcomeExternalIdentifier,
+            price: 1 - l.price,
+            size: l.size,
+            negRisk: (_a2 = o.orderbook.negRisk) != null ? _a2 : false
+          });
+        }
+      );
+    }
+  }
+  levels2.sort((a, b) => a.price - b.price);
+  let totalCost = 0;
+  const fills = [];
+  for (const l of levels2) {
+    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/orderbook-checksum.ts
+function orderbookCrc32(value) {
+  let crc = 4294967295;
+  for (let i = 0; i < value.length; i++) {
+    crc ^= value.charCodeAt(i);
+    for (let bit = 0; bit < 8; bit++) crc = crc >>> 1 ^ (crc & 1 ? 3988292384 : 0);
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function projectedOrderbookChecksum(book) {
+  let result = 0;
+  for (const level of book.bids) result ^= orderbookCrc32(`B${level.price}:${level.size}`);
+  for (const level of book.asks) result ^= orderbookCrc32(`A${level.price}:${level.size}`);
+  return result >>> 0;
+}
+
+// src/orderbook-utils.ts
+var PRICE_KEY_SCALE = 1e9;
+function computeChecksum(book) {
+  return projectedOrderbookChecksum(book);
+}
+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(levels2, changes, sort) {
+  const levelsByPrice = new Map(levels2.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 : {})
+    });
+  }
+  levels2 = [...levelsByPrice.values()];
+  levels2.sort(sort === "desc" ? (a, b) => b.price - a.price : (a, b) => a.price - b.price);
+  return levels2;
+}
+function applyVenueChanges(levels2, changes, sort) {
+  const levelsByPrice = new Map(levels2.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 });
+  }
+  levels2 = [...levelsByPrice.values()];
+  levels2.sort(sort === "desc" ? (a, b) => b.price - a.price : (a, b) => a.price - b.price);
+  return levels2;
+}
+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;
+}
+var IndexedOrderbook = class {
+  constructor(state) {
+    this.venueBooks = /* @__PURE__ */ new Map();
+    this.bids = new Map(state.bids.map((level) => [toPriceKey(level.price), level]));
+    this.asks = new Map(state.asks.map((level) => [toPriceKey(level.price), level]));
+    for (const [venue, book] of Object.entries(state.venueOrderbooks)) {
+      this.venueBooks.set(venue, {
+        bids: new Map(book.bids.map((level) => [toPriceKey(level.price), level])),
+        asks: new Map(book.asks.map((level) => [toPriceKey(level.price), level]))
+      });
+    }
+    const _a = state, { bids: _bids, asks: _asks, venueOrderbooks: _venueBooks } = _a, metadata = __objRest(_a, ["bids", "asks", "venueOrderbooks"]);
+    this.metadata = metadata;
+    this.cached = state;
+    this.checksumValue = computeChecksum(state);
+  }
+  get seq() {
+    return this.metadata.seq;
+  }
+  get checksum() {
+    return this.checksumValue;
+  }
+  /** Verify before committing, including duplicate-price changes within a frame. */
+  apply(delta) {
+    var _a;
+    let checksum = this.checksumValue;
+    for (const [levels2, changes, side] of [
+      [this.bids, delta.bidChanges, "B"],
+      [this.asks, delta.askChanges, "A"]
+    ]) {
+      const changed = /* @__PURE__ */ new Map();
+      for (const [price, size, venues] of changes) {
+        const key = toPriceKey(price);
+        const previous = changed.has(key) ? changed.get(key) : levels2.get(key);
+        if (previous) checksum ^= orderbookCrc32(`${side}${previous.price}:${previous.size}`);
+        if (size !== 0) checksum ^= orderbookCrc32(`${side}${price}:${size}`);
+        changed.set(key, size === 0 ? void 0 : { price, size, venues: __spreadValues({}, venues) });
+      }
+    }
+    checksum >>>= 0;
+    if (checksum !== delta.checksum) return checksum;
+    const previousBids = delta.bidChanges.flatMap(
+      ([price]) => {
+        var _a2;
+        return (_a2 = this.bids.get(toPriceKey(price))) != null ? _a2 : [];
+      }
+    );
+    const previousAsks = delta.askChanges.flatMap(
+      ([price]) => {
+        var _a2;
+        return (_a2 = this.asks.get(toPriceKey(price))) != null ? _a2 : [];
+      }
+    );
+    const impliedBids = deriveVenueChangesFromAttributedChanges(previousBids, delta.bidChanges);
+    const impliedAsks = deriveVenueChangesFromAttributedChanges(previousAsks, delta.askChanges);
+    for (const venue of /* @__PURE__ */ new Set([
+      ...Object.keys(delta.venueDeltaBooks),
+      ...Object.keys(impliedBids),
+      ...Object.keys(impliedAsks)
+    ])) {
+      let book = this.venueBooks.get(venue);
+      if (!book) {
+        book = { bids: /* @__PURE__ */ new Map(), asks: /* @__PURE__ */ new Map() };
+        this.venueBooks.set(venue, book);
+      }
+      const explicit = delta.venueDeltaBooks[venue];
+      for (const [levels2, changes] of [
+        [book.bids, mergeVenueLevelChanges(explicit == null ? void 0 : explicit.bidChanges, impliedBids[venue])],
+        [book.asks, mergeVenueLevelChanges(explicit == null ? void 0 : explicit.askChanges, impliedAsks[venue])]
+      ]) {
+        for (const [price, size] of changes) {
+          if (size === 0) levels2.delete(toPriceKey(price));
+          else levels2.set(toPriceKey(price), { price, size });
+        }
+      }
+    }
+    for (const [levels2, changes] of [
+      [this.bids, delta.bidChanges],
+      [this.asks, delta.askChanges]
+    ]) {
+      for (const [price, size, venues] of changes) {
+        if (size === 0) levels2.delete(toPriceKey(price));
+        else levels2.set(toPriceKey(price), { price, size, venues: __spreadValues({}, venues) });
+      }
+    }
+    this.metadata = __spreadProps(__spreadValues({}, this.metadata), {
+      outcomeId: (_a = this.metadata.outcomeId) != null ? _a : delta.outcomeId,
+      venues: __spreadValues(__spreadValues({}, this.metadata.venues), delta.venues),
+      midpoint: delta.midpoint,
+      spread: delta.spread,
+      seq: delta.seq,
+      checksum: delta.checksum,
+      timestamp: delta.timestamp
+    });
+    this.checksumValue = checksum;
+    this.cached = null;
+    return checksum;
+  }
+  view() {
+    if (this.cached) return this.cached;
+    const bids = (levels2) => [...levels2.values()].sort((a, b) => b.price - a.price);
+    const asks = (levels2) => [...levels2.values()].sort((a, b) => a.price - b.price);
+    this.cached = __spreadProps(__spreadValues({}, this.metadata), {
+      bids: bids(this.bids),
+      asks: asks(this.asks),
+      venueOrderbooks: Object.fromEntries(
+        [...this.venueBooks].map(([venue, book]) => [
+          venue,
+          { bids: bids(book.bids), asks: asks(book.asks) }
+        ])
+      )
+    });
+    return this.cached;
+  }
+};
+
+// src/market-data/validate.ts
+var object = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var finite = (value) => typeof value === "number" && Number.isFinite(value);
+var nullable = (value) => value === null || finite(value);
+var levels = (value, attributed) => Array.isArray(value) && value.length <= 1e4 && value.every(
+  (level) => Array.isArray(level) && finite(level[0]) && level[0] >= 0 && finite(level[1]) && level[1] >= 0 && (!attributed || object(level[2]) && Object.values(level[2]).every((size) => finite(size) && size >= 0))
+);
+function validMarketFrame(frame) {
+  if (typeof frame.outcomeId !== "string" || !frame.outcomeId || !finite(frame.timestamp) || frame.timestamp < 0)
+    return false;
+  if (frame.type === "trade")
+    return finite(frame.price) && frame.price >= 0 && finite(frame.size) && frame.size >= 0 && typeof frame.venue === "string" && (frame.side === "buy" || frame.side === "sell");
+  if (!Number.isSafeInteger(frame.seq) || frame.seq < 0 || !Number.isInteger(frame.checksum) || frame.checksum < 0 || frame.checksum > 4294967295 || !nullable(frame.midpoint) || !nullable(frame.spread) || !object(frame.venues))
+    return false;
+  for (const info of Object.values(frame.venues))
+    if (!object(info) || !nullable(info.bestBid) || !nullable(info.bestAsk)) return false;
+  const snapshot = frame.type === "orderbook_snapshot";
+  if (!levels(frame[snapshot ? "bids" : "bidChanges"], true) || !levels(frame[snapshot ? "asks" : "askChanges"], true))
+    return false;
+  const books = frame[snapshot ? "venueOrderbooks" : "venueDeltaBooks"];
+  return object(books) && Object.values(books).every(
+    (book) => object(book) && levels(book[snapshot ? "bids" : "bidChanges"], false) && levels(book[snapshot ? "asks" : "askChanges"], false)
+  );
+}
+
+// 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.pendingFlushArbSubs = /* @__PURE__ */ new Set();
+    this.pendingFlushArbUnsubs = /* @__PURE__ */ new Set();
+    this.flushScheduled = false;
+    // ── Arb subscriptions ──
+    this.arbSubs = /* @__PURE__ */ new Map();
+    this.arbFeedCbs = /* @__PURE__ */ new Set();
+    /** Latest arb market update per marketId (last-value-wins, loss-tolerant). */
+    this.latestArb = /* @__PURE__ */ new Map();
+    // ── 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;
+    this.historyControllers = /* @__PURE__ */ new Set();
+    var _a, _b, _c;
+    this.deferBookViews = (_a = options.deferBookViews) != null ? _a : false;
+    this.url = options.url;
+    this.callbacks = (_b = options.callbacks) != null ? _b : {};
+    this.initialToken = options.initialToken;
+    this.enableLogs = (_c = options.enableLogs) != null ? _c : false;
+  }
+  // ── Public API ──
+  get connected() {
+    return this._connected;
+  }
+  /** Decode dynamic authenticated REST bytes in the same processing environment as live data. */
+  decodeHistory(payload) {
+    return __async(this, null, function* () {
+      return decodeChartHistory(payload);
+    });
+  }
+  /** Immutable history decoder. Browser adapters execute this inside their Worker. */
+  loadHistory(manifest, options) {
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      if (this.destroyed) throw new Error("Market-data client disposed");
+      const controller = new AbortController();
+      const abort = () => {
+        var _a2;
+        return controller.abort((_a2 = options == null ? void 0 : options.signal) == null ? void 0 : _a2.reason);
+      };
+      (_a = options == null ? void 0 : options.signal) == null ? void 0 : _a.addEventListener("abort", abort, { once: true });
+      if ((_b = options == null ? void 0 : options.signal) == null ? void 0 : _b.aborted) abort();
+      this.historyControllers.add(controller);
+      try {
+        controller.signal.throwIfAborted();
+        const result = yield loadImmutableHistory({ manifest, signal: controller.signal });
+        controller.signal.throwIfAborted();
+        return result;
+      } finally {
+        this.historyControllers.delete(controller);
+        (_c = options == null ? void 0 : options.signal) == null ? void 0 : _c.removeEventListener("abort", abort);
+      }
+    });
+  }
+  /** Optional framework-independent host diagnostics, cleared on disposal. */
+  setHostDiagnostics(provider) {
+    this.hostDiagnostics = provider;
+  }
+  /** On-demand ownership diagnostics; contains no credentials or user/account data. */
+  getDiagnostics() {
+    var _a;
+    return {
+      connected: this.connected,
+      host: (_a = this.hostDiagnostics) == null ? void 0 : _a.call(this),
+      transport: this.destroyed ? "disposed" : "direct",
+      orderbookOutcomeIds: this.activeOrderbookMarkets(),
+      tradeOutcomeIds: this.activeTradeMarkets(),
+      arbMarketIds: this.activeArbMarkets(),
+      arbFeedSubscribers: this.arbFeedCbs.size,
+      cachedBooks: this.books.size,
+      cachedArb: this.latestArb.size,
+      resyncingBooks: this.resyncing.size,
+      pendingResnapshots: this.pendingResnapshots.size,
+      pendingHistoryRequests: this.historyControllers.size
+    };
+  }
+  /** Get the current orderbook state for an outcome (or null if no snapshot received yet). */
+  getBook(outcomeId) {
+    var _a, _b;
+    return (_b = (_a = this.books.get(outcomeId)) == null ? void 0 : _a.view()) != null ? _b : null;
+  }
+  /** Whether an outcome is currently resyncing (waiting for fresh snapshot). */
+  isResyncing(outcomeId) {
+    return this.resyncing.has(outcomeId);
+  }
+  /** Get the latest arb update for a market (or null if none received yet). */
+  getArb(marketId) {
+    var _a;
+    return (_a = this.latestArb.get(marketId)) != null ? _a : null;
+  }
+  /**
+   * Subscribe to per-market arb updates for a given marketId.
+   * Ref-counted: multiple callers for the same marketId share one server subscription.
+   * Returns an unsubscribe function.
+   */
+  subscribeArb(marketId, cb) {
+    let entry = this.arbSubs.get(marketId);
+    if (!entry) {
+      entry = { refCount: 0, cbs: /* @__PURE__ */ new Set() };
+      this.arbSubs.set(marketId, entry);
+      this.ensureConnected();
+      if (this._connected) {
+        this.pendingFlushArbUnsubs.delete(marketId);
+        this.pendingFlushArbSubs.add(marketId);
+        this.scheduleFlush();
+      }
+    }
+    entry.cbs.add(cb);
+    entry.refCount++;
+    return () => {
+      const e = this.arbSubs.get(marketId);
+      if (!e) return;
+      e.cbs.delete(cb);
+      e.refCount--;
+      if (e.refCount <= 0) {
+        this.arbSubs.delete(marketId);
+        if (this._connected) {
+          if (this.pendingFlushArbSubs.has(marketId)) {
+            this.pendingFlushArbSubs.delete(marketId);
+          } else {
+            this.pendingFlushArbUnsubs.add(marketId);
+            this.scheduleFlush();
+          }
+        }
+      }
+    };
+  }
+  /**
+   * Subscribe to the global arb-feed batches.
+   * Only one server subscription is maintained regardless of how many callers.
+   * Returns an unsubscribe function.
+   */
+  subscribeArbFeed(cb) {
+    const wasEmpty = this.arbFeedCbs.size === 0;
+    this.arbFeedCbs.add(cb);
+    if (wasEmpty) {
+      this.ensureConnected();
+      if (this._connected) {
+        this.send({ action: "subscribe", channel: "arb-feed" });
+      }
+    }
+    return () => {
+      this.arbFeedCbs.delete(cb);
+      if (this.arbFeedCbs.size === 0 && this._connected) {
+        this.send({ action: "unsubscribe", channel: "arb-feed" });
+      }
+    };
+  }
+  /**
+   * 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);
+    }
+    if (sub.refCount === 0) {
+      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++;
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      const s = this.subs.get(outcomeId);
+      if (!s) return;
+      s.refCount--;
+      if (s.refCount <= 0) {
+        s.refCount = 0;
+        if (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++;
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      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);
+          this.books.delete(outcomeId);
+          this.resyncing.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;
+    for (const controller of this.historyControllers)
+      controller.abort(new Error("Market-data client disposed"));
+    this.historyControllers.clear();
+    this.disconnect();
+    this.hostDiagnostics = void 0;
+    this.callbacks = {};
+    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.arbSubs.clear();
+    this.arbFeedCbs.clear();
+    this.latestArb.clear();
+    this.pendingFlushArbSubs.clear();
+    this.pendingFlushArbUnsubs.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 = () => {
+      if (this.destroyed || this.ws !== ws) return;
+      this.connecting = false;
+      this.reconnectAttempts = 0;
+      this.resetStaleTimer();
+      if (this.initialToken) {
+        this.send({ action: "authenticate", token: this.initialToken });
+      }
+    };
+    ws.onmessage = (event) => {
+      var _a, _b;
+      if (this.destroyed || this.ws !== ws) return;
+      this.lastMessageTime = Date.now();
+      (_b = (_a = this.callbacks).onFrameReceived) == null ? void 0 : _b.call(_a, this.lastMessageTime);
+      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.arbSubs.size > 0 || this.arbFeedCbs.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, _k, _l, _m, _n, _o, _p, _q, _r;
+    const type = raw.type;
+    if (["orderbook_snapshot", "orderbook_delta", "trade"].includes(type) && !validMarketFrame(raw)) {
+      (_b = (_a = this.callbacks).onError) == null ? void 0 : _b.call(_a, { type: "error", message: "Invalid market-data frame" });
+      if (typeof raw.outcomeId === "string" && this.subs.has(raw.outcomeId))
+        this.requestResnapshot(raw.outcomeId);
+      return;
+    }
+    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":
+        (_d = (_c = this.callbacks).onSubscribed) == null ? void 0 : _d.call(_c, raw);
+        break;
+      case "unsubscribed":
+        (_f = (_e = this.callbacks).onUnsubscribed) == null ? void 0 : _f.call(_e, raw);
+        break;
+      case "connected":
+        this.handleConnected(raw);
+        break;
+      case "authenticated":
+        (_h = (_g = this.callbacks).onAuthenticated) == null ? void 0 : _h.call(_g, raw);
+        break;
+      case "market_resolved":
+        this.handleMarketResolved(raw);
+        break;
+      case "error":
+        (_j = (_i = this.callbacks).onError) == null ? void 0 : _j.call(_i, raw);
+        break;
+      case "order_submitted":
+        this.handleOrderSubmitted(raw);
+        break;
+      case "balance_update":
+        this.handleBalanceUpdate(raw);
+        break;
+      case "order_event":
+        (_l = (_k = this.callbacks).onOrderEvent) == null ? void 0 : _l.call(_k, raw);
+        break;
+      case "redeem_event":
+        this.handleRedeemEvent(raw);
+        break;
+      case "withdrawal_lifecycle":
+        (_n = (_m = this.callbacks).onWithdrawalLifecycle) == null ? void 0 : _n.call(_m, raw);
+        break;
+      case "arb_market_update": {
+        const arbMsg = raw;
+        this.latestArb.set(arbMsg.marketId, arbMsg);
+        const arbEntry = this.arbSubs.get(arbMsg.marketId);
+        if (arbEntry) {
+          for (const cb of arbEntry.cbs) cb(arbMsg);
+        }
+        (_p = (_o = this.callbacks).onArbMarket) == null ? void 0 : _p.call(_o, arbMsg);
+        break;
+      }
+      case "arb_feed_batch": {
+        const feedMsg = raw;
+        for (const cb of this.arbFeedCbs) cb(feedMsg);
+        (_r = (_q = this.callbacks).onArbFeed) == null ? void 0 : _r.call(_q, feedMsg);
+        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();
+    const arbSet = new Set(this.activeArbMarkets());
+    this.pendingFlushArbSubs.forEach((id) => arbSet.add(id));
+    const arbIds = Array.from(arbSet);
+    if (arbIds.length > 0) {
+      this.send({ action: "subscribe", channel: "arb", marketIds: arbIds });
+    }
+    this.pendingFlushArbSubs.clear();
+    this.pendingFlushArbUnsubs.clear();
+    if (this.arbFeedCbs.size > 0) {
+      this.send({ action: "subscribe", channel: "arb-feed" });
+    }
+  }
+  handleSnapshot(raw) {
+    var _a, _b, _c, _d;
+    if (!this.subs.has(raw.outcomeId)) return;
+    const msg = __spreadProps(__spreadValues({}, raw), { timestamp: raw.timestamp / 1e3 });
+    const book = snapshotToOrderbook(msg);
+    this.books.set(msg.outcomeId, new IndexedOrderbook(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).onBookTick) == null ? void 0 : _b.call(_a, msg.outcomeId, {
+      midpoint: msg.midpoint,
+      timestamp: msg.timestamp,
+      source: "snapshot"
+    });
+    if (!this.deferBookViews) (_d = (_c = this.callbacks).onSnapshot) == null ? void 0 : _d.call(_c, msg.outcomeId, book);
+  }
+  handleDelta(raw) {
+    var _a, _b, _c, _d;
+    if (!this.subs.has(raw.outcomeId)) return;
+    const outcomeId = raw.outcomeId;
+    const current = this.books.get(outcomeId);
+    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 computed = current.apply(msg);
+    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;
+    }
+    (_b = (_a = this.callbacks).onBookTick) == null ? void 0 : _b.call(_a, outcomeId, {
+      midpoint: msg.midpoint,
+      timestamp: msg.timestamp,
+      source: "delta"
+    });
+    if (!this.deferBookViews) (_d = (_c = this.callbacks).onDelta) == null ? void 0 : _d.call(_c, outcomeId, current.view());
+  }
+  handleTrade(raw) {
+    var _a, _b;
+    if (!this.subs.has(raw.outcomeId)) return;
+    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();
+        this.pendingFlushArbSubs.clear();
+        this.pendingFlushArbUnsubs.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();
+    }
+    for (const id of [...this.pendingFlushArbSubs]) {
+      if (this.pendingFlushArbUnsubs.has(id)) {
+        this.pendingFlushArbSubs.delete(id);
+        this.pendingFlushArbUnsubs.delete(id);
+      }
+    }
+    if (this.pendingFlushArbSubs.size > 0) {
+      this.send({
+        action: "subscribe",
+        channel: "arb",
+        marketIds: Array.from(this.pendingFlushArbSubs)
+      });
+      this.pendingFlushArbSubs.clear();
+    }
+    if (this.pendingFlushArbUnsubs.size > 0) {
+      this.send({
+        action: "unsubscribe",
+        channel: "arb",
+        marketIds: Array.from(this.pendingFlushArbUnsubs)
+      });
+      this.pendingFlushArbUnsubs.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;
+  }
+  activeArbMarkets() {
+    return Array.from(this.arbSubs.keys());
+  }
+  emitDiagnostic(event) {
+    var _a, _b;
+    (_b = (_a = this.callbacks).onDiagnostics) == null ? void 0 : _b.call(_a, event);
+  }
+  summarizeTopLevels(levels2) {
+    return levels2.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;
+  }
+};
+
+export {
+  decodeChartHistory,
+  readChartHistoryText,
+  loadImmutableHistory,
+  Venue,
+  VENUES,
+  VENUE_CHAIN_IDS,
+  ACTIVE_VENUES,
+  INACTIVE_VENUES,
+  isVenueActive,
+  isVenueInactive,
+  isVenueDataVisible,
+  getEffectiveDisabledVenues,
+  ImageSize,
+  IMAGE_SIZES,
+  RETINA_IMAGE_SIZES,
+  AccountType,
+  AccountProvider,
+  Chain,
+  MatchStatus,
+  MatchType,
+  CONFIRMED_MATCH_STATUSES,
+  MarketStatus,
+  OrderStatus,
+  TradeSide,
+  OrderType,
+  TimeInForce,
+  formatOutcomeLabel,
+  formatMarketQuestion,
+  formatOutcomeTitle,
+  getWalletAddressFromUserProfile,
+  safeParse,
+  parse,
+  isEnum,
+  enumGuard,
+  isFiniteNonNeg,
+  isNonEmptyString,
+  hasShape,
+  isEmail,
+  parseEmail,
+  parseEmailStrict,
+  computeBestSplitsByAmount,
+  optimizedImageUrl,
+  retinaImageUrl,
+  normalizeVenueMarketCluster,
+  sortVenues,
+  buildVenueUrl,
+  LIMIT_PRICE_RAW_SCALE,
+  adjustLimitPriceRawToTick,
+  DEFAULT_BALANCE_REFILL_DAILY_CAP_RAW,
+  DEFAULT_BALANCE_REFILL_MAX_FEE_RAW,
+  getBalanceRefillMaximumRaw,
+  isBalanceRefillWithinDailyCap,
+  orderbookCrc32,
+  projectedOrderbookChecksum,
+  computeChecksum,
+  snapshotToOrderbook,
+  applyOrderbookDelta,
+  AggWebSocket
+};