@agg-build/sdk 4.17.4 → 4.19.0

package/dist/market-data.js

@@ -0,0 +1,1776 @@
+"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 __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __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/market-data.ts
+var market_data_exports = {};
+__export(market_data_exports, {
+  MarketDataEngine: () => MarketDataEngine,
+  decodeChartHistory: () => decodeChartHistory
+});
+module.exports = __toCommonJS(market_data_exports);
+
+// 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-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/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/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 toPriceKey(price) {
+  return String(Math.round(price * PRICE_KEY_SCALE));
+}
+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/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;
+  }
+};
+
+// 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 : [];
+  }
+  /** Apply a bounded Worker view without recomputing candles from presentation samples. */
+  replaceTail(tail) {
+    var _a, _b;
+    for (const interval of ALL_INTERVALS) {
+      const view = tail[interval];
+      if (view.forming) this.forming.set(interval, __spreadValues({}, view.forming));
+      else this.forming.delete(interval);
+      if (!view.closed.length) continue;
+      const closed = new Map(this.getClosed(interval).map((candle) => [candle.openTime, candle]));
+      for (const candle of view.closed) closed.set(candle.openTime, __spreadValues({}, candle));
+      this.closedMap.set(
+        interval,
+        [...closed.values()].sort((a, b) => a.openTime - b.openTime).slice(-MAX_CLOSED)
+      );
+    }
+    this._midpoint = (_b = (_a = tail["1m"].forming) == null ? void 0 : _a.c) != null ? _b : null;
+    this.markDirty();
+  }
+  /** 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-data/engine.ts
+var intervals = ["1m", "5m", "1h", "1d"];
+var MarketDataEngine = class {
+  constructor() {
+    this.socket = null;
+    this.generation = 0;
+    this.receivedAtMs = 0;
+    this.revision = 0;
+    this.deliveredClosed = /* @__PURE__ */ new Map();
+    this.subscriptions = /* @__PURE__ */ new Map();
+    this.builders = /* @__PURE__ */ new Map();
+    this.dirty = /* @__PURE__ */ new Map();
+    this.inFlight = false;
+    this.deliveryToken = null;
+    this.disposed = false;
+    this.history = /* @__PURE__ */ new Map();
+    this.measurements = {
+      received: 0,
+      published: 0,
+      coalesced: 0,
+      maxPendingOutcomes: 0,
+      maxInFlight: 0
+    };
+  }
+  start(options, event) {
+    this.dispose();
+    this.disposed = false;
+    this.generation = 0;
+    this.revision = 0;
+    const callbacks = {};
+    const names = [
+      "onConnected",
+      "onAuthenticated",
+      "onHeartbeat",
+      "onSubscribed",
+      "onUnsubscribed",
+      "onMarketResolved",
+      "onError",
+      "onOrderSubmitted",
+      "onBalanceUpdate",
+      "onOrderEvent",
+      "onRedeemEvent",
+      "onWithdrawalLifecycle",
+      "onArbMarket",
+      "onArbFeed",
+      "onDiagnostics",
+      "onConnectionStateChange"
+    ];
+    for (const name of names) {
+      Object.assign(callbacks, {
+        [name]: (...args) => {
+          var _a;
+          if (name === "onConnectionStateChange" && args[0] === false) {
+            for (const builder of this.builders.values()) builder.reset();
+            this.dirty.clear();
+            this.deliveredClosed.clear();
+          }
+          if (name === "onMarketResolved") {
+            const id = args[0].outcomeId;
+            (_a = this.builders.get(id)) == null ? void 0 : _a.dispose();
+            this.builders.delete(id);
+            this.dirty.delete(id);
+          }
+          if (name === "onDiagnostics") {
+            const diagnostic = args[0];
+            if (diagnostic.outcomeId && ["seq_gap", "checksum_mismatch"].includes(diagnostic.type))
+              this.mark(diagnostic.outcomeId, false);
+          }
+          event({ name, args, revision: this.revision });
+        }
+      });
+    }
+    callbacks.onFrameReceived = (receivedAtMs) => {
+      this.receivedAtMs = receivedAtMs;
+      this.revision++;
+    };
+    callbacks.onBookTick = (id, tick) => {
+      if (tick.midpoint != null) this.builder(id).addMidpoint(tick.midpoint, tick.timestamp);
+      this.mark(id, tick.source === "snapshot");
+    };
+    callbacks.onTrade = (trade) => {
+      this.builder(trade.outcomeId).addTrade(trade.price, trade.size, trade.timestamp);
+      this.mark(trade.outcomeId, false, trade);
+    };
+    this.socket = new AggWebSocket(__spreadProps(__spreadValues({}, options), { callbacks, deferBookViews: true }));
+  }
+  observeViews(observer) {
+    this.observer = observer;
+  }
+  setSubscriptions(subscriptions, generation) {
+    var _a;
+    if (generation < this.generation) return;
+    this.generation = generation;
+    const desired = new Map(subscriptions.map((sub) => [`${sub.channel}:${sub.id}`, sub]));
+    for (const [key, unsubscribe] of this.subscriptions) {
+      if (!desired.has(key)) {
+        unsubscribe();
+        this.subscriptions.delete(key);
+      }
+    }
+    for (const [key, sub] of desired) {
+      if (this.subscriptions.has(key) || !this.socket) continue;
+      const unsubscribe = sub.channel === "arb" ? this.socket.subscribeArb(sub.id, () => {
+      }) : sub.channel === "arb-feed" ? this.socket.subscribeArbFeed(() => {
+      }) : this.socket.subscribe(sub.id, sub.channel);
+      this.subscriptions.set(key, unsubscribe);
+    }
+    for (const sub of subscriptions)
+      if (sub.channel === "orderbook" && ((_a = this.socket) == null ? void 0 : _a.getBook(sub.id))) this.mark(sub.id, false);
+    const outcomes = new Set(
+      subscriptions.filter((sub) => sub.channel === "orderbook" || sub.channel === "trades").map((sub) => sub.id)
+    );
+    for (const id of this.dirty.keys()) if (!outcomes.has(id)) this.dirty.delete(id);
+    for (const id of this.deliveredClosed.keys())
+      if (!outcomes.has(id)) this.deliveredClosed.delete(id);
+    for (const [id, builder] of this.builders)
+      if (!outcomes.has(id)) {
+        builder.dispose();
+        this.builders.delete(id);
+        this.dirty.delete(id);
+        this.deliveredClosed.delete(id);
+      }
+  }
+  authenticate(token) {
+    var _a;
+    (_a = this.socket) == null ? void 0 : _a.authenticate(token);
+  }
+  resnapshot(ids) {
+    var _a;
+    (_a = this.socket) == null ? void 0 : _a.resnapshot(ids);
+  }
+  connect() {
+    var _a;
+    (_a = this.socket) == null ? void 0 : _a.connect();
+  }
+  disconnect() {
+    var _a;
+    (_a = this.socket) == null ? void 0 : _a.disconnect();
+  }
+  resume() {
+    var _a;
+    (_a = this.socket) == null ? void 0 : _a.resnapshot([...this.builders.keys()]);
+  }
+  getMeasurements() {
+    var _a, _b, _c, _d, _e;
+    const socket = (_b = (_a = this.socket) == null ? void 0 : _a.getDiagnostics()) != null ? _b : null;
+    return __spreadProps(__spreadValues({}, this.measurements), {
+      activeSubscriptions: this.subscriptions.size,
+      activeOutcomes: (/* @__PURE__ */ new Set([
+        ...(_c = socket == null ? void 0 : socket.orderbookOutcomeIds) != null ? _c : [],
+        ...(_d = socket == null ? void 0 : socket.tradeOutcomeIds) != null ? _d : []
+      ])).size,
+      cachedBooks: (_e = socket == null ? void 0 : socket.cachedBooks) != null ? _e : 0,
+      builders: this.builders.size,
+      historyTasks: this.history.size,
+      pendingOutcomes: this.dirty.size,
+      inFlightDeliveries: this.inFlight ? 1 : 0,
+      retainedCandleOutcomes: this.deliveredClosed.size,
+      socket
+    });
+  }
+  decodeHistory(payload) {
+    return decodeChartHistory(payload);
+  }
+  /** Fetch/decode on the processing side; newer range generations abort obsolete fetches. */
+  loadHistoryRange(request) {
+    return __async(this, null, function* () {
+      const previous = this.history.get(request.key);
+      if (previous && previous.generation > request.generation) return null;
+      previous == null ? void 0 : previous.controller.abort();
+      const controller = new AbortController();
+      const entry = { generation: request.generation, controller };
+      this.history.set(request.key, entry);
+      const timeout = setTimeout(() => controller.abort(), 1e4);
+      try {
+        const response = yield fetch(request.url, {
+          headers: request.headers,
+          signal: controller.signal
+        });
+        if (!response.ok) throw new Error(`History request failed (${response.status})`);
+        const body = decodeChartHistory(yield readChartHistoryText(response));
+        if (body.data.length > 4096) throw new Error("Invalid or unbounded history response");
+        if (this.history.get(request.key) !== entry || this.disposed) return null;
+        return __spreadProps(__spreadValues({}, body), { data: [...body.data].sort((a, b) => a.t - b.t) });
+      } finally {
+        clearTimeout(timeout);
+        if (this.history.get(request.key) === entry) this.history.delete(request.key);
+      }
+    });
+  }
+  loadImmutableRange(key, generation, manifest) {
+    return __async(this, null, function* () {
+      const previous = this.history.get(key);
+      if (previous && previous.generation > generation) throw new Error("Obsolete history range");
+      previous == null ? void 0 : previous.controller.abort();
+      const entry = { generation, controller: new AbortController() };
+      this.history.set(key, entry);
+      const timer = setTimeout(() => entry.controller.abort(), 1e4);
+      try {
+        const data = yield loadImmutableHistory({ manifest, signal: entry.controller.signal });
+        if (this.history.get(key) !== entry || this.disposed)
+          throw new Error("Obsolete history range");
+        return data;
+      } finally {
+        clearTimeout(timer);
+        if (this.history.get(key) === entry) this.history.delete(key);
+      }
+    });
+  }
+  cancelHistoryRange(key, generation) {
+    const entry = this.history.get(key);
+    if (!entry || generation !== void 0 && entry.generation !== generation) return;
+    entry.controller.abort();
+    this.history.delete(key);
+  }
+  dispose() {
+    var _a, _b;
+    this.disposed = true;
+    (_a = this.cancelDelivery) == null ? void 0 : _a.call(this);
+    this.cancelDelivery = void 0;
+    this.deliveryToken = null;
+    this.inFlight = false;
+    this.observer = void 0;
+    (_b = this.socket) == null ? void 0 : _b.destroy();
+    this.socket = null;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = void 0;
+    this.subscriptions.clear();
+    this.dirty.clear();
+    this.deliveredClosed.clear();
+    for (const builder of this.builders.values()) builder.dispose();
+    this.builders.clear();
+    for (const request of this.history.values()) request.controller.abort();
+    this.history.clear();
+  }
+  builder(id) {
+    let builder = this.builders.get(id);
+    if (!builder) {
+      builder = new CandleBuilder();
+      this.builders.set(id, builder);
+    }
+    return builder;
+  }
+  mark(id, snapshot, trade) {
+    var _a, _b, _c;
+    const previous = this.dirty.get(id);
+    this.measurements.received++;
+    if (previous) this.measurements.coalesced++;
+    this.dirty.set(id, {
+      snapshot: snapshot || !!(previous == null ? void 0 : previous.snapshot),
+      receivedAtMs: (_a = previous == null ? void 0 : previous.receivedAtMs) != null ? _a : this.receivedAtMs || Date.now(),
+      trades: trade ? [trade, ...(_b = previous == null ? void 0 : previous.trades) != null ? _b : []].slice(0, 50) : (_c = previous == null ? void 0 : previous.trades) != null ? _c : []
+    });
+    this.measurements.maxPendingOutcomes = Math.max(
+      this.measurements.maxPendingOutcomes,
+      this.dirty.size
+    );
+    this.schedule();
+  }
+  schedule() {
+    if (this.timer || this.inFlight || this.disposed || !this.observer) return;
+    this.timer = setTimeout(() => {
+      this.timer = void 0;
+      void this.publish();
+    }, 50);
+  }
+  publish() {
+    return __async(this, null, function* () {
+      var _a, _b;
+      if (this.inFlight || this.disposed || !this.observer || !this.dirty.size) return;
+      const views = [...this.dirty].map(([outcomeId, dirty]) => {
+        var _a2, _b2, _c;
+        const builder = this.builder(outcomeId);
+        return __spreadProps(__spreadValues({
+          outcomeId,
+          revision: this.revision,
+          integrity: ((_a2 = this.socket) == null ? void 0 : _a2.isResyncing(outcomeId)) ? "resyncing" : "ok",
+          book: (_c = (_b2 = this.socket) == null ? void 0 : _b2.getBook(outcomeId)) != null ? _c : null
+        }, dirty), {
+          candles: Object.fromEntries(
+            intervals.map((interval) => [
+              interval,
+              {
+                forming: builder.getForming(interval) ? __spreadValues({}, builder.getForming(interval)) : null,
+                // Bounded recovery tail. Full historical ranges never travel per tick.
+                closed: builder.getClosed(interval).filter(
+                  (candle) => {
+                    var _a3, _b3;
+                    return candle.openTime > ((_b3 = (_a3 = this.deliveredClosed.get(outcomeId)) == null ? void 0 : _a3[interval]) != null ? _b3 : -Infinity);
+                  }
+                ).map((candle) => __spreadValues({}, candle))
+              }
+            ])
+          )
+        });
+      });
+      const generation = this.generation;
+      this.dirty.clear();
+      this.inFlight = true;
+      const token = {};
+      this.deliveryToken = token;
+      const cancelled = new Promise((resolve) => {
+        this.cancelDelivery = resolve;
+      });
+      this.measurements.maxInFlight = 1;
+      try {
+        yield Promise.race([
+          this.observer({ generation, views, publishedAtMs: Date.now() }),
+          cancelled
+        ]);
+        if (this.disposed || this.deliveryToken !== token) return;
+        for (const view of generation === this.generation ? views : []) {
+          const delivered = (_a = this.deliveredClosed.get(view.outcomeId)) != null ? _a : {};
+          for (const interval of intervals) {
+            const last = view.candles[interval].closed.at(-1);
+            if (last) delivered[interval] = last.openTime;
+          }
+          this.deliveredClosed.set(view.outcomeId, delivered);
+        }
+        this.measurements.published++;
+      } catch (e) {
+        if (!this.disposed && this.deliveryToken === token) (_b = this.socket) == null ? void 0 : _b.disconnect();
+      } finally {
+        if (this.deliveryToken === token) {
+          this.deliveryToken = null;
+          this.cancelDelivery = void 0;
+          this.inFlight = false;
+          if (this.dirty.size) this.schedule();
+        }
+      }
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MarketDataEngine,
+  decodeChartHistory
+});