@agg-build/sdk 4.17.4 → 4.19.0

package/dist/browser.js

@@ -0,0 +1,2049 @@
+"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/browser.ts
+var browser_exports = {};
+__export(browser_exports, {
+  WorkerAggWebSocket: () => WorkerAggWebSocket,
+  createWorkerWebSocket: () => createWorkerWebSocket
+});
+module.exports = __toCommonJS(browser_exports);
+
+// ../../node_modules/.pnpm/comlink@4.4.2/node_modules/comlink/dist/esm/comlink.mjs
+var proxyMarker = /* @__PURE__ */ Symbol("Comlink.proxy");
+var createEndpoint = /* @__PURE__ */ Symbol("Comlink.endpoint");
+var releaseProxy = /* @__PURE__ */ Symbol("Comlink.releaseProxy");
+var finalizer = /* @__PURE__ */ Symbol("Comlink.finalizer");
+var throwMarker = /* @__PURE__ */ Symbol("Comlink.thrown");
+var isObject = (val) => typeof val === "object" && val !== null || typeof val === "function";
+var proxyTransferHandler = {
+  canHandle: (val) => isObject(val) && val[proxyMarker],
+  serialize(obj) {
+    const { port1, port2 } = new MessageChannel();
+    expose(obj, port1);
+    return [port2, [port2]];
+  },
+  deserialize(port) {
+    port.start();
+    return wrap(port);
+  }
+};
+var throwTransferHandler = {
+  canHandle: (value) => isObject(value) && throwMarker in value,
+  serialize({ value }) {
+    let serialized;
+    if (value instanceof Error) {
+      serialized = {
+        isError: true,
+        value: {
+          message: value.message,
+          name: value.name,
+          stack: value.stack
+        }
+      };
+    } else {
+      serialized = { isError: false, value };
+    }
+    return [serialized, []];
+  },
+  deserialize(serialized) {
+    if (serialized.isError) {
+      throw Object.assign(new Error(serialized.value.message), serialized.value);
+    }
+    throw serialized.value;
+  }
+};
+var transferHandlers = /* @__PURE__ */ new Map([
+  ["proxy", proxyTransferHandler],
+  ["throw", throwTransferHandler]
+]);
+function isAllowedOrigin(allowedOrigins, origin) {
+  for (const allowedOrigin of allowedOrigins) {
+    if (origin === allowedOrigin || allowedOrigin === "*") {
+      return true;
+    }
+    if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) {
+      return true;
+    }
+  }
+  return false;
+}
+function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
+  ep.addEventListener("message", function callback(ev) {
+    if (!ev || !ev.data) {
+      return;
+    }
+    if (!isAllowedOrigin(allowedOrigins, ev.origin)) {
+      console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);
+      return;
+    }
+    const { id, type, path } = Object.assign({ path: [] }, ev.data);
+    const argumentList = (ev.data.argumentList || []).map(fromWireValue);
+    let returnValue;
+    try {
+      const parent = path.slice(0, -1).reduce((obj2, prop) => obj2[prop], obj);
+      const rawValue = path.reduce((obj2, prop) => obj2[prop], obj);
+      switch (type) {
+        case "GET":
+          {
+            returnValue = rawValue;
+          }
+          break;
+        case "SET":
+          {
+            parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);
+            returnValue = true;
+          }
+          break;
+        case "APPLY":
+          {
+            returnValue = rawValue.apply(parent, argumentList);
+          }
+          break;
+        case "CONSTRUCT":
+          {
+            const value = new rawValue(...argumentList);
+            returnValue = proxy(value);
+          }
+          break;
+        case "ENDPOINT":
+          {
+            const { port1, port2 } = new MessageChannel();
+            expose(obj, port2);
+            returnValue = transfer(port1, [port1]);
+          }
+          break;
+        case "RELEASE":
+          {
+            returnValue = void 0;
+          }
+          break;
+        default:
+          return;
+      }
+    } catch (value) {
+      returnValue = { value, [throwMarker]: 0 };
+    }
+    Promise.resolve(returnValue).catch((value) => {
+      return { value, [throwMarker]: 0 };
+    }).then((returnValue2) => {
+      const [wireValue, transferables] = toWireValue(returnValue2);
+      ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+      if (type === "RELEASE") {
+        ep.removeEventListener("message", callback);
+        closeEndPoint(ep);
+        if (finalizer in obj && typeof obj[finalizer] === "function") {
+          obj[finalizer]();
+        }
+      }
+    }).catch((error) => {
+      const [wireValue, transferables] = toWireValue({
+        value: new TypeError("Unserializable return value"),
+        [throwMarker]: 0
+      });
+      ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+    });
+  });
+  if (ep.start) {
+    ep.start();
+  }
+}
+function isMessagePort(endpoint) {
+  return endpoint.constructor.name === "MessagePort";
+}
+function closeEndPoint(endpoint) {
+  if (isMessagePort(endpoint))
+    endpoint.close();
+}
+function wrap(ep, target) {
+  const pendingListeners = /* @__PURE__ */ new Map();
+  ep.addEventListener("message", function handleMessage(ev) {
+    const { data } = ev;
+    if (!data || !data.id) {
+      return;
+    }
+    const resolver = pendingListeners.get(data.id);
+    if (!resolver) {
+      return;
+    }
+    try {
+      resolver(data);
+    } finally {
+      pendingListeners.delete(data.id);
+    }
+  });
+  return createProxy(ep, pendingListeners, [], target);
+}
+function throwIfProxyReleased(isReleased) {
+  if (isReleased) {
+    throw new Error("Proxy has been released and is not useable");
+  }
+}
+function releaseEndpoint(ep) {
+  return requestResponseMessage(ep, /* @__PURE__ */ new Map(), {
+    type: "RELEASE"
+  }).then(() => {
+    closeEndPoint(ep);
+  });
+}
+var proxyCounter = /* @__PURE__ */ new WeakMap();
+var proxyFinalizers = "FinalizationRegistry" in globalThis && new FinalizationRegistry((ep) => {
+  const newCount = (proxyCounter.get(ep) || 0) - 1;
+  proxyCounter.set(ep, newCount);
+  if (newCount === 0) {
+    releaseEndpoint(ep);
+  }
+});
+function registerProxy(proxy2, ep) {
+  const newCount = (proxyCounter.get(ep) || 0) + 1;
+  proxyCounter.set(ep, newCount);
+  if (proxyFinalizers) {
+    proxyFinalizers.register(proxy2, ep, proxy2);
+  }
+}
+function unregisterProxy(proxy2) {
+  if (proxyFinalizers) {
+    proxyFinalizers.unregister(proxy2);
+  }
+}
+function createProxy(ep, pendingListeners, path = [], target = function() {
+}) {
+  let isProxyReleased = false;
+  const proxy2 = new Proxy(target, {
+    get(_target, prop) {
+      throwIfProxyReleased(isProxyReleased);
+      if (prop === releaseProxy) {
+        return () => {
+          unregisterProxy(proxy2);
+          releaseEndpoint(ep);
+          pendingListeners.clear();
+          isProxyReleased = true;
+        };
+      }
+      if (prop === "then") {
+        if (path.length === 0) {
+          return { then: () => proxy2 };
+        }
+        const r = requestResponseMessage(ep, pendingListeners, {
+          type: "GET",
+          path: path.map((p) => p.toString())
+        }).then(fromWireValue);
+        return r.then.bind(r);
+      }
+      return createProxy(ep, pendingListeners, [...path, prop]);
+    },
+    set(_target, prop, rawValue) {
+      throwIfProxyReleased(isProxyReleased);
+      const [value, transferables] = toWireValue(rawValue);
+      return requestResponseMessage(ep, pendingListeners, {
+        type: "SET",
+        path: [...path, prop].map((p) => p.toString()),
+        value
+      }, transferables).then(fromWireValue);
+    },
+    apply(_target, _thisArg, rawArgumentList) {
+      throwIfProxyReleased(isProxyReleased);
+      const last = path[path.length - 1];
+      if (last === createEndpoint) {
+        return requestResponseMessage(ep, pendingListeners, {
+          type: "ENDPOINT"
+        }).then(fromWireValue);
+      }
+      if (last === "bind") {
+        return createProxy(ep, pendingListeners, path.slice(0, -1));
+      }
+      const [argumentList, transferables] = processArguments(rawArgumentList);
+      return requestResponseMessage(ep, pendingListeners, {
+        type: "APPLY",
+        path: path.map((p) => p.toString()),
+        argumentList
+      }, transferables).then(fromWireValue);
+    },
+    construct(_target, rawArgumentList) {
+      throwIfProxyReleased(isProxyReleased);
+      const [argumentList, transferables] = processArguments(rawArgumentList);
+      return requestResponseMessage(ep, pendingListeners, {
+        type: "CONSTRUCT",
+        path: path.map((p) => p.toString()),
+        argumentList
+      }, transferables).then(fromWireValue);
+    }
+  });
+  registerProxy(proxy2, ep);
+  return proxy2;
+}
+function myFlat(arr) {
+  return Array.prototype.concat.apply([], arr);
+}
+function processArguments(argumentList) {
+  const processed = argumentList.map(toWireValue);
+  return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];
+}
+var transferCache = /* @__PURE__ */ new WeakMap();
+function transfer(obj, transfers) {
+  transferCache.set(obj, transfers);
+  return obj;
+}
+function proxy(obj) {
+  return Object.assign(obj, { [proxyMarker]: true });
+}
+function toWireValue(value) {
+  for (const [name, handler] of transferHandlers) {
+    if (handler.canHandle(value)) {
+      const [serializedValue, transferables] = handler.serialize(value);
+      return [
+        {
+          type: "HANDLER",
+          name,
+          value: serializedValue
+        },
+        transferables
+      ];
+    }
+  }
+  return [
+    {
+      type: "RAW",
+      value
+    },
+    transferCache.get(value) || []
+  ];
+}
+function fromWireValue(value) {
+  switch (value.type) {
+    case "HANDLER":
+      return transferHandlers.get(value.name).deserialize(value.value);
+    case "RAW":
+      return value.value;
+  }
+}
+function requestResponseMessage(ep, pendingListeners, msg, transfers) {
+  return new Promise((resolve) => {
+    const id = generateUUID();
+    pendingListeners.set(id, resolve);
+    if (ep.start) {
+      ep.start();
+    }
+    ep.postMessage(Object.assign({ id }, msg), transfers);
+  });
+}
+function generateUUID() {
+  return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
+}
+
+// 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 });
+}
+
+// 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/market-data/worker-adapter.ts
+var WorkerAggWebSocket = class extends AggWebSocket {
+  constructor(config, factory) {
+    var _a, _b;
+    super(config);
+    this.config = config;
+    this.endpointListeners = /* @__PURE__ */ new Map();
+    this.historyOperations = 0;
+    this.currentBooks = /* @__PURE__ */ new Map();
+    this.recovering = /* @__PURE__ */ new Set();
+    this.diagnosticRevisions = /* @__PURE__ */ new Map();
+    this.deliveredRevisions = /* @__PURE__ */ new Map();
+    this.resolvedRevisions = /* @__PURE__ */ new Map();
+    this.refs = /* @__PURE__ */ new Map();
+    this.arbListeners = /* @__PURE__ */ new Map();
+    this.feedListeners = /* @__PURE__ */ new Set();
+    this.latest = /* @__PURE__ */ new Map();
+    this.generation = 0;
+    this.online = false;
+    this.stopped = false;
+    this.queued = false;
+    this.historyFailures = /* @__PURE__ */ new Set();
+    this.fallback = null;
+    this.fallbackUnsubs = /* @__PURE__ */ new Map();
+    this.historyGeneration = 0;
+    this.visibility = () => {
+      if (document.visibilityState === "visible")
+        this.resnapshot(
+          [...this.refs.values()].filter((entry) => entry.sub.channel === "orderbook").map((entry) => entry.sub.id)
+        );
+    };
+    this.fail = () => {
+      var _a, _b, _c;
+      if (this.stopped || this.fallback) return;
+      this.releaseWorker();
+      this.currentBooks.clear();
+      this.latest.clear();
+      this.recovering.clear();
+      this.diagnosticRevisions.clear();
+      this.deliveredRevisions.clear();
+      this.resolvedRevisions.clear();
+      this.online = false;
+      (_b = (_a = this.handlers).onConnectionStateChange) == null ? void 0 : _b.call(_a, false);
+      this.fallback = new AggWebSocket(__spreadProps(__spreadValues({}, this.config), { callbacks: this.fallbackCallbacks() }));
+      for (const reject of this.historyFailures) reject(new Error("Market-data worker failed"));
+      this.historyFailures.clear();
+      (_c = this.resolveFailure) == null ? void 0 : _c.call(this);
+      this.syncFallback();
+    };
+    if (((_a = config.callbacks) == null ? void 0 : _a.onTrade) && !config.callbacks.onMarketView)
+      throw new Error(
+        "Raw trade callbacks require AggWebSocket; Worker views require onMarketView opt-in"
+      );
+    this.handlers = (_b = config.callbacks) != null ? _b : {};
+    this.worker = factory();
+    const worker = this.worker;
+    const endpoint = {
+      postMessage: worker.postMessage.bind(worker),
+      addEventListener: (type, listener) => {
+        this.endpointListeners.set(listener, type);
+        worker.addEventListener(type, listener);
+      },
+      removeEventListener: (type, listener) => {
+        this.endpointListeners.delete(listener);
+        worker.removeEventListener(type, listener);
+      }
+    };
+    this.remote = wrap(endpoint);
+    this.worker.addEventListener("error", this.fail);
+    this.worker.addEventListener("messageerror", this.fail);
+    const _c = config, { callbacks: _callbacks } = _c, options = __objRest(_c, ["callbacks"]);
+    const startup = this.remote.start(
+      options,
+      proxy((event) => {
+        if (!this.fallback) this.event(event.name, event.args, event.revision);
+      })
+    ).then(() => {
+      if (this.stopped || this.fallback || !this.remote) return;
+      return this.remote.observeViews(
+        proxy((batch) => {
+          var _a2, _b2, _c2, _d, _e, _f, _g, _h, _i, _j;
+          if (batch.generation < this.generation || this.stopped || this.fallback) return;
+          for (const view of batch.views) {
+            if (!this.refs.has(`orderbook:${view.outcomeId}`) && !this.refs.has(`trades:${view.outcomeId}`))
+              continue;
+            if (((_a2 = this.resolvedRevisions.get(view.outcomeId)) != null ? _a2 : -1) >= view.revision) continue;
+            const integrity = ((_b2 = this.diagnosticRevisions.get(view.outcomeId)) != null ? _b2 : -1) > view.revision ? "resyncing" : view.integrity;
+            this.deliveredRevisions.set(view.outcomeId, view.revision);
+            (_d = (_c2 = this.handlers).onMarketView) == null ? void 0 : _d.call(_c2, __spreadProps(__spreadValues({}, view), { integrity }));
+            if (view.book) {
+              this.currentBooks.set(view.outcomeId, view.book);
+              if (integrity === "ok") {
+                this.recovering.delete(view.outcomeId);
+                this.diagnosticRevisions.delete(view.outcomeId);
+              } else this.recovering.add(view.outcomeId);
+              if (view.snapshot) (_f = (_e = this.handlers).onSnapshot) == null ? void 0 : _f.call(_e, view.outcomeId, view.book);
+              else (_h = (_g = this.handlers).onDelta) == null ? void 0 : _h.call(_g, view.outcomeId, view.book);
+            }
+            for (const trade of [...view.trades].reverse()) (_j = (_i = this.handlers).onTrade) == null ? void 0 : _j.call(_i, trade);
+          }
+        })
+      );
+    }).catch(this.fail);
+    const failed = new Promise((resolve) => {
+      this.resolveFailure = resolve;
+    });
+    this.ready = Promise.race([startup, failed]);
+    const startupTimeout = setTimeout(this.fail, 3e3);
+    void this.ready.then(() => clearTimeout(startupTimeout));
+    if (typeof document !== "undefined")
+      document.addEventListener("visibilitychange", this.visibility);
+  }
+  get processesCandles() {
+    return !this.fallback;
+  }
+  decodeHistory(payload) {
+    return __async(this, null, function* () {
+      this.historyOperations++;
+      try {
+        return yield this.decodeHistoryRequest(payload);
+      } finally {
+        this.historyOperations--;
+      }
+    });
+  }
+  decodeHistoryRequest(payload) {
+    return __async(this, null, function* () {
+      if (this.stopped) throw new Error("Market-data worker disposed");
+      yield this.ready;
+      if (this.stopped) throw new Error("Market-data worker disposed");
+      if (this.fallback) return this.fallback.decodeHistory(payload);
+      const remote = this.remote;
+      if (!remote) throw new Error("Market-data worker unavailable");
+      let rejectFailure;
+      const failed = new Promise((_resolve, reject) => {
+        rejectFailure = reject;
+        this.historyFailures.add(reject);
+      });
+      try {
+        return yield Promise.race([remote.decodeHistory(payload), failed]);
+      } finally {
+        this.historyFailures.delete(rejectFailure);
+      }
+    });
+  }
+  loadHistory(manifest, options) {
+    return __async(this, null, function* () {
+      this.historyOperations++;
+      try {
+        return yield this.loadHistoryRequest(manifest, options);
+      } finally {
+        this.historyOperations--;
+      }
+    });
+  }
+  loadHistoryRequest(manifest, options) {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d, _e;
+      if (this.stopped) throw new Error("Market-data worker disposed");
+      if (this.fallback) return this.fallback.loadHistory(manifest, options);
+      const generation = ++this.historyGeneration;
+      const key = `${manifest.venueMarketOutcomeId}:${manifest.resolution}:${manifest.from}:${manifest.to}`;
+      (_a = options == null ? void 0 : options.signal) == null ? void 0 : _a.throwIfAborted();
+      yield this.ready;
+      if (this.stopped) throw new Error("Market-data worker disposed");
+      (_b = options == null ? void 0 : options.signal) == null ? void 0 : _b.throwIfAborted();
+      const fallbackAfterStartup = this.fallback;
+      if (fallbackAfterStartup) return fallbackAfterStartup.loadHistory(manifest, options);
+      const remote = this.remote;
+      if (!remote) throw new Error("Market-data worker unavailable");
+      let rejectFailure;
+      const failed = new Promise((_resolve, reject) => {
+        rejectFailure = reject;
+        this.historyFailures.add(reject);
+      });
+      const abort = () => {
+        var _a2;
+        void ((_a2 = this.remote) == null ? void 0 : _a2.cancelHistoryRange(key, generation));
+      };
+      (_c = options == null ? void 0 : options.signal) == null ? void 0 : _c.addEventListener("abort", abort, { once: true });
+      try {
+        const result = yield Promise.race([
+          remote.loadImmutableRange(key, generation, manifest),
+          failed
+        ]);
+        (_d = options == null ? void 0 : options.signal) == null ? void 0 : _d.throwIfAborted();
+        return result;
+      } finally {
+        (_e = options == null ? void 0 : options.signal) == null ? void 0 : _e.removeEventListener("abort", abort);
+        this.historyFailures.delete(rejectFailure);
+      }
+    });
+  }
+  setHostDiagnostics(provider) {
+    this.hostProvider = provider;
+  }
+  getDiagnostics() {
+    var _a, _b;
+    const subscriptions = [...this.refs.values()].map((entry) => entry.sub);
+    return this.fallback ? __spreadProps(__spreadValues({}, this.fallback.getDiagnostics()), {
+      host: (_a = this.hostProvider) == null ? void 0 : _a.call(this),
+      pendingHistoryRequests: this.historyOperations,
+      workerAttached: false,
+      bridgeListeners: this.endpointListeners.size
+    }) : {
+      connected: this.connected,
+      host: (_b = this.hostProvider) == null ? void 0 : _b.call(this),
+      transport: this.stopped ? "disposed" : "worker",
+      orderbookOutcomeIds: subscriptions.filter((sub) => sub.channel === "orderbook").map((sub) => sub.id),
+      tradeOutcomeIds: subscriptions.filter((sub) => sub.channel === "trades").map((sub) => sub.id),
+      arbMarketIds: [...this.arbListeners.keys()],
+      arbFeedSubscribers: this.feedListeners.size,
+      cachedBooks: this.currentBooks.size,
+      cachedArb: this.latest.size,
+      resyncingBooks: this.recovering.size,
+      pendingResnapshots: 0,
+      pendingHistoryRequests: this.historyOperations,
+      workerAttached: this.worker !== null,
+      bridgeListeners: this.endpointListeners.size
+    };
+  }
+  getWorkerDiagnostics() {
+    return __async(this, null, function* () {
+      yield this.ready;
+      const remote = this.remote;
+      if (this.stopped || !remote || this.fallback) return null;
+      let rejectFailure;
+      const failed = new Promise((_resolve, reject) => {
+        rejectFailure = reject;
+        this.historyFailures.add(reject);
+      });
+      try {
+        return yield Promise.race([remote.getMeasurements(), failed]);
+      } catch (e) {
+        return null;
+      } finally {
+        this.historyFailures.delete(rejectFailure);
+      }
+    });
+  }
+  get connected() {
+    var _a, _b;
+    return !this.stopped && ((_b = (_a = this.fallback) == null ? void 0 : _a.connected) != null ? _b : this.online);
+  }
+  getBook(id) {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = this.fallback) == null ? void 0 : _a.getBook(id)) != null ? _b : this.currentBooks.get(id)) != null ? _c : null;
+  }
+  isResyncing(id) {
+    var _a, _b;
+    return (_b = (_a = this.fallback) == null ? void 0 : _a.isResyncing(id)) != null ? _b : this.recovering.has(id);
+  }
+  getArb(id) {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = this.fallback) == null ? void 0 : _a.getArb(id)) != null ? _b : this.latest.get(id)) != null ? _c : null;
+  }
+  subscribe(id, channel = "orderbook") {
+    return this.ref({ id, channel });
+  }
+  subscribeTrades(id) {
+    return this.subscribe(id, "trades");
+  }
+  subscribeArb(id, cb) {
+    var _a;
+    const listeners = (_a = this.arbListeners.get(id)) != null ? _a : /* @__PURE__ */ new Set();
+    listeners.add(cb);
+    this.arbListeners.set(id, listeners);
+    const unsubscribe = this.ref({ id, channel: "arb" });
+    return () => {
+      unsubscribe();
+      listeners.delete(cb);
+      if (!listeners.size) this.arbListeners.delete(id);
+    };
+  }
+  subscribeArbFeed(cb) {
+    this.feedListeners.add(cb);
+    const unsubscribe = this.ref({ id: "*", channel: "arb-feed" });
+    return () => {
+      unsubscribe();
+      this.feedListeners.delete(cb);
+    };
+  }
+  setCallbacks(callbacks) {
+    var _a;
+    this.handlers = callbacks;
+    if (callbacks.onTrade && !callbacks.onMarketView && !this.fallback) this.fail();
+    (_a = this.fallback) == null ? void 0 : _a.setCallbacks(this.fallbackCallbacks());
+  }
+  authenticate(token) {
+    this.config.initialToken = token;
+    this.run((engine) => engine.authenticate(token));
+  }
+  connect() {
+    this.run((engine) => engine.connect());
+  }
+  disconnect() {
+    this.run((engine) => engine.disconnect());
+  }
+  resnapshot(id) {
+    const ids = Array.isArray(id) ? id : [id];
+    this.run((engine) => engine.resnapshot(ids));
+  }
+  destroy() {
+    var _a, _b;
+    if (this.stopped) return;
+    this.stopped = true;
+    this.online = false;
+    (_a = this.resolveFailure) == null ? void 0 : _a.call(this);
+    for (const reject of this.historyFailures) reject(new Error("Market-data worker disposed"));
+    this.historyFailures.clear();
+    this.refs.clear();
+    this.currentBooks.clear();
+    this.latest.clear();
+    this.arbListeners.clear();
+    this.feedListeners.clear();
+    this.recovering.clear();
+    this.diagnosticRevisions.clear();
+    this.deliveredRevisions.clear();
+    this.resolvedRevisions.clear();
+    (_b = this.fallback) == null ? void 0 : _b.destroy();
+    this.fallbackUnsubs.clear();
+    this.hostProvider = void 0;
+    this.handlers = {};
+    if (typeof document !== "undefined")
+      document.removeEventListener("visibilitychange", this.visibility);
+    this.releaseWorker();
+  }
+  releaseWorker() {
+    const worker = this.worker;
+    const remote = this.remote;
+    this.remote = null;
+    this.worker = null;
+    if (remote) remote[releaseProxy]();
+    if (!worker) return;
+    for (const [listener, type] of this.endpointListeners)
+      worker.removeEventListener(type, listener);
+    this.endpointListeners.clear();
+    worker.removeEventListener("error", this.fail);
+    worker.removeEventListener("messageerror", this.fail);
+    worker.terminate();
+  }
+  event(name, args, revision = 0) {
+    var _a, _b, _c, _d;
+    if (this.stopped) return;
+    if (name === "onConnectionStateChange") this.online = args[0];
+    if (name === "onDiagnostics") {
+      const diagnostic = args[0];
+      if (diagnostic.outcomeId && revision < ((_a = this.deliveredRevisions.get(diagnostic.outcomeId)) != null ? _a : -1))
+        return;
+      if (diagnostic.outcomeId && (this.refs.has(`orderbook:${diagnostic.outcomeId}`) || this.refs.has(`trades:${diagnostic.outcomeId}`)) && ["seq_gap", "checksum_mismatch"].includes(diagnostic.type)) {
+        this.recovering.add(diagnostic.outcomeId);
+        this.diagnosticRevisions.set(diagnostic.outcomeId, revision);
+      }
+    }
+    if (name === "onMarketResolved") {
+      const id = args[0].outcomeId;
+      if (this.refs.has(`orderbook:${id}`) || this.refs.has(`trades:${id}`))
+        this.resolvedRevisions.set(id, revision);
+      this.currentBooks.delete(id);
+    }
+    if (name === "onArbMarket") {
+      const msg = args[0];
+      this.latest.set(msg.marketId, msg);
+      for (const cb of (_b = this.arbListeners.get(msg.marketId)) != null ? _b : []) cb(msg);
+    }
+    if (name === "onArbFeed") for (const cb of this.feedListeners) cb(args[0]);
+    (_d = (_c = this.handlers)[name]) == null ? void 0 : _d.call(_c, ...args);
+  }
+  ref(sub) {
+    var _a;
+    const key = `${sub.channel}:${sub.id}`;
+    const entry = (_a = this.refs.get(key)) != null ? _a : { sub, count: 0 };
+    entry.count++;
+    this.refs.set(key, entry);
+    this.sync();
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      if (--entry.count === 0) {
+        this.refs.delete(key);
+        if (sub.channel === "orderbook") this.recovering.delete(sub.id);
+        if (!this.refs.has(`orderbook:${sub.id}`) && !this.refs.has(`trades:${sub.id}`)) {
+          this.currentBooks.delete(sub.id);
+          this.recovering.delete(sub.id);
+          this.diagnosticRevisions.delete(sub.id);
+          this.deliveredRevisions.delete(sub.id);
+          this.resolvedRevisions.delete(sub.id);
+        }
+      }
+      this.sync();
+    };
+  }
+  sync() {
+    if (this.queued || this.stopped) return;
+    this.queued = true;
+    queueMicrotask(() => {
+      this.queued = false;
+      if (this.stopped) return;
+      if (this.fallback) {
+        this.syncFallback();
+        return;
+      }
+      const generation = ++this.generation;
+      const subscriptions = [...this.refs.values()].map((entry) => entry.sub);
+      void this.ready.then(() => {
+        var _a;
+        if (!this.stopped && !this.fallback)
+          return (_a = this.remote) == null ? void 0 : _a.setSubscriptions(subscriptions, generation);
+      }).catch(this.fail);
+    });
+  }
+  run(action) {
+    if (this.stopped) return;
+    if (this.fallback) {
+      action(this.fallback);
+      return;
+    }
+    void this.ready.then(() => {
+      var _a;
+      if (this.stopped) return;
+      const engine = (_a = this.fallback) != null ? _a : this.remote;
+      if (engine) return action(engine);
+    }).catch(this.fail);
+  }
+  fallbackCallbacks() {
+    return __spreadProps(__spreadValues({}, this.handlers), {
+      onArbMarket: (msg) => this.event("onArbMarket", [msg]),
+      onArbFeed: (msg) => this.event("onArbFeed", [msg])
+    });
+  }
+  syncFallback() {
+    for (const [key, unsubscribe] of this.fallbackUnsubs) {
+      if (!this.refs.has(key)) {
+        unsubscribe();
+        this.fallbackUnsubs.delete(key);
+      }
+    }
+    for (const [key, { sub }] of this.refs) {
+      if (this.fallbackUnsubs.has(key)) continue;
+      this.fallbackUnsubs.set(
+        key,
+        sub.channel === "arb" ? this.fallback.subscribeArb(sub.id, () => {
+        }) : sub.channel === "arb-feed" ? this.fallback.subscribeArbFeed(() => {
+        }) : this.fallback.subscribe(sub.id, sub.channel)
+      );
+    }
+  }
+};
+function createWorkerWebSocket(options, factory) {
+  var _a;
+  if (((_a = options.callbacks) == null ? void 0 : _a.onTrade) && !options.callbacks.onMarketView)
+    return new AggWebSocket(options);
+  try {
+    return new WorkerAggWebSocket(options, factory);
+  } catch (e) {
+    return new AggWebSocket(options);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WorkerAggWebSocket,
+  createWorkerWebSocket
+});
+/*! Bundled license information:
+
+comlink/dist/esm/comlink.mjs:
+  (**
+   * @license
+   * Copyright 2019 Google LLC
+   * SPDX-License-Identifier: Apache-2.0
+   *)
+*/