@agg-build/sdk 4.25.0 → 4.27.0

package/dist/agg-websocket-DJbIfxKb.js

@@ -0,0 +1,1478 @@
+//#region ../common/src/orderbook-checksum.ts
+/** IEEE CRC32 used by the existing orderbook protocol. */
+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;
+}
+/** Checksum of exactly the supplied levels, independent of depth/venue attribution. */
+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;
+}
+//#endregion
+//#region src/market-data/history-decoder.ts
+/** Decode bounded dynamic history where processing lives; retain milliseconds and optional mean. */
+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 {
+		...body,
+		data
+	};
+}
+/** Bound received bytes before JSON parsing, including chunked responses without Content-Length. */
+async function readChartHistoryText(response) {
+	const maxBytes = 1048576;
+	if (Number(response.headers.get("content-length")) > maxBytes) {
+		await response.body?.cancel();
+		throw new Error("Chart history exceeds decode budget");
+	}
+	if (!response.body?.getReader) {
+		const text = await response.text();
+		if (new TextEncoder().encode(text).byteLength > maxBytes) throw new Error("Chart history exceeds decode budget");
+		return text;
+	}
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let size = 0;
+	let text = "";
+	try {
+		while (true) {
+			const { value, done } = await reader.read();
+			if (done) return text + decoder.decode();
+			size += value.byteLength;
+			if (size > maxBytes) {
+				await reader.cancel();
+				throw new Error("Chart history exceeds decode budget");
+			}
+			text += decoder.decode(value, { stream: true });
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+//#endregion
+//#region src/market-data/validate.ts
+/** Bounds work before processing untrusted market frames. Protocol semantics remain in AggWebSocket. */
+const object = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+const finite = (value) => typeof value === "number" && Number.isFinite(value);
+const nullable = (value) => value === null || finite(value);
+const 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));
+}
+//#endregion
+//#region src/market-history.ts
+async function readBoundedBody(response, signal) {
+	if (!response.body) throw new Error("Missing history body");
+	const reader = response.body.getReader();
+	const chunks = [];
+	let size = 0;
+	const abort = () => {
+		reader.cancel(signal.reason).catch(() => void 0);
+	};
+	signal.addEventListener("abort", abort, { once: true });
+	try {
+		while (true) {
+			if (signal.aborted) throw signal.reason ?? /* @__PURE__ */ new Error("History request aborted");
+			const { done, value } = await reader.read();
+			if (signal.aborted) throw signal.reason ?? /* @__PURE__ */ new Error("History request aborted");
+			if (done) break;
+			size += value.byteLength;
+			if (size > 262144) {
+				await 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();
+	}
+}
+/** Download immutable CDN objects directly. Safe to run in the browser Worker or Node. */
+async function loadImmutableHistory({ 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 ?? (async (bytes) => {
+		if (!globalThis.crypto?.subtle) throw new Error("History integrity requires WebCrypto or an injected SHA-256 implementation");
+		const value = await 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(/* @__PURE__ */ new Error("History download budget exhausted")), 2e3);
+	const abort = () => controller.abort(signal?.reason);
+	signal?.addEventListener("abort", abort, { once: true });
+	if (signal?.aborted) abort();
+	try {
+		await Promise.all(Array.from({ length: Math.min(2, manifest.chunks.length) }, async () => {
+			while (next < manifest.chunks.length) {
+				if (controller.signal.aborted) throw controller.signal.reason ?? /* @__PURE__ */ 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 = await 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 = await readBoundedBody(response, controller.signal);
+				if (bytes.byteLength > 262144 || await hash(bytes) !== chunk.sha256) throw new Error("History integrity mismatch");
+				const object = JSON.parse(new TextDecoder().decode(bytes));
+				if (object.version !== 1 || object.venueMarketOutcomeId !== manifest.venueMarketOutcomeId || object.venue !== manifest.venue || object.resolution !== manifest.resolution || object.semantics !== manifest.semantics || object.from !== chunk.from || object.to !== chunk.to || !Array.isArray(object.data) || object.data.length !== chunk.points) throw new Error("History identity mismatch");
+				let previous = -Infinity;
+				for (const bar of object.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] = object.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?.removeEventListener("abort", abort);
+	}
+}
+//#endregion
+//#region src/orderbook-utils.ts
+const PRICE_KEY_SCALE = 1e9;
+/**
+* Compute the XOR-based checksum of an orderbook.
+* Matches the Rust engine's checksum: XOR of crc32("B{price}:{size}") for each
+* bid and crc32("A{price}:{size}") for each ask, independently hashed then XOR'd.
+*/
+function computeChecksum(book) {
+	return projectedOrderbookChecksum(book);
+}
+function attributedToLevel(wire) {
+	return {
+		price: wire[0],
+		size: wire[1],
+		venues: { ...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;
+}
+/**
+* Convert a WS snapshot message into local OrderbookState.
+* Timestamp is expected to already be in seconds (converted by AggWebSocket).
+*/
+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: { ...snapshot.venues },
+		midpoint: snapshot.midpoint,
+		spread: snapshot.spread,
+		seq: snapshot.seq,
+		checksum: snapshot.checksum,
+		timestamp: snapshot.timestamp
+	};
+}
+/**
+* Apply a WS delta to an existing OrderbookState, returning a new state.
+* Bids sorted descending, asks ascending (maintained invariant).
+*/
+function applyOrderbookDelta(state, delta) {
+	const bids = applyChanges([...state.bids], delta.bidChanges, "desc");
+	const asks = applyChanges([...state.asks], delta.askChanges, "asc");
+	const impliedBidChangesByVenue = deriveVenueChangesFromAttributedChanges(state.bids, delta.bidChanges);
+	const impliedAskChangesByVenue = deriveVenueChangesFromAttributedChanges(state.asks, delta.askChanges);
+	const venueOrderbooks = { ...state.venueOrderbooks };
+	const venuesWithDelta = /* @__PURE__ */ new Set([
+		...Object.keys(delta.venueDeltaBooks),
+		...Object.keys(impliedBidChangesByVenue),
+		...Object.keys(impliedAskChangesByVenue)
+	]);
+	for (const venue of venuesWithDelta) {
+		const explicitChanges = delta.venueDeltaBooks[venue];
+		const bidChanges = mergeVenueLevelChanges(explicitChanges?.bidChanges, impliedBidChangesByVenue[venue]);
+		const askChanges = mergeVenueLevelChanges(explicitChanges?.askChanges, impliedAskChangesByVenue[venue]);
+		if (bidChanges.length === 0 && askChanges.length === 0) continue;
+		const existing = venueOrderbooks[venue] ?? {
+			bids: [],
+			asks: []
+		};
+		venueOrderbooks[venue] = {
+			bids: applyVenueChanges([...existing.bids], bidChanges, "desc"),
+			asks: applyVenueChanges([...existing.asks], askChanges, "asc")
+		};
+	}
+	return {
+		marketId: state.marketId,
+		outcomeId: state.outcomeId ?? delta.outcomeId,
+		bids,
+		asks,
+		venueOrderbooks,
+		venues: {
+			...state.venues,
+			...delta.venues
+		},
+		midpoint: delta.midpoint,
+		spread: delta.spread,
+		seq: delta.seq,
+		checksum: delta.checksum,
+		timestamp: delta.timestamp
+	};
+}
+function toPriceKey(price) {
+	return String(Math.round(price * PRICE_KEY_SCALE));
+}
+function applyChanges(levels, changes, sort) {
+	const levelsByPrice = new Map(levels.map((level) => [toPriceKey(level.price), level]));
+	for (const [price, size, venues] of changes) {
+		const key = toPriceKey(price);
+		if (size === 0) {
+			levelsByPrice.delete(key);
+			continue;
+		}
+		levelsByPrice.set(key, {
+			price,
+			size,
+			venues: { ...venues ?? {} }
+		});
+	}
+	levels = [...levelsByPrice.values()];
+	levels.sort(sort === "desc" ? (a, b) => b.price - a.price : (a, b) => a.price - b.price);
+	return levels;
+}
+function applyVenueChanges(levels, changes, sort) {
+	const levelsByPrice = new Map(levels.map((level) => [toPriceKey(level.price), level]));
+	for (const [price, size] of changes) {
+		const key = toPriceKey(price);
+		if (size === 0) {
+			levelsByPrice.delete(key);
+			continue;
+		}
+		levelsByPrice.set(key, {
+			price,
+			size
+		});
+	}
+	levels = [...levelsByPrice.values()];
+	levels.sort(sort === "desc" ? (a, b) => b.price - a.price : (a, b) => a.price - b.price);
+	return levels;
+}
+function mergeVenueLevelChanges(primary, fallback) {
+	if (!primary?.length) return fallback ? [...fallback] : [];
+	if (!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) {
+	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 previousVenues = previousLevelsByPrice.get(key)?.venues ?? {};
+		const nextVenues = nextVenuesRaw ?? {};
+		const affectedVenues = /* @__PURE__ */ new Set([...Object.keys(previousVenues), ...Object.keys(nextVenues)]);
+		for (const venue of affectedVenues) {
+			const nextSize = Number(nextVenues[venue] ?? 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: { ...nextVenues }
+		});
+	}
+	return venueChanges;
+}
+/** Private mutable representation for ordered feeds; immutable views are built only on demand. */
+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 { bids: _bids, asks: _asks, venueOrderbooks: _venueBooks, ...metadata } = state;
+		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) {
+		let checksum = this.checksumValue;
+		for (const [levels, 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) : levels.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: { ...venues }
+				});
+			}
+		}
+		checksum >>>= 0;
+		if (checksum !== delta.checksum) return checksum;
+		const previousBids = delta.bidChanges.flatMap(([price]) => this.bids.get(toPriceKey(price)) ?? []);
+		const previousAsks = delta.askChanges.flatMap(([price]) => this.asks.get(toPriceKey(price)) ?? []);
+		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 [levels, changes] of [[book.bids, mergeVenueLevelChanges(explicit?.bidChanges, impliedBids[venue])], [book.asks, mergeVenueLevelChanges(explicit?.askChanges, impliedAsks[venue])]]) for (const [price, size] of changes) if (size === 0) levels.delete(toPriceKey(price));
+			else levels.set(toPriceKey(price), {
+				price,
+				size
+			});
+		}
+		for (const [levels, changes] of [[this.bids, delta.bidChanges], [this.asks, delta.askChanges]]) for (const [price, size, venues] of changes) if (size === 0) levels.delete(toPriceKey(price));
+		else levels.set(toPriceKey(price), {
+			price,
+			size,
+			venues: { ...venues }
+		});
+		this.metadata = {
+			...this.metadata,
+			outcomeId: this.metadata.outcomeId ?? delta.outcomeId,
+			venues: {
+				...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 = (levels) => [...levels.values()].sort((a, b) => b.price - a.price);
+		const asks = (levels) => [...levels.values()].sort((a, b) => a.price - b.price);
+		this.cached = {
+			...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;
+	}
+};
+//#endregion
+//#region src/agg-websocket.ts
+/**
+* Agg platform WebSocket client.
+*
+* Single connection, refcounted subscriptions. Orderbook/trades subscriptions
+* are keyed by venueMarketOutcomeId (the `outcomes[].id` on REST market
+* responses — NOT a venueMarketId); arb subscriptions are keyed by marketId.
+* Maintains in-memory orderbook state per subscribed outcome id.
+* All timestamps converted from server ms to seconds before invoking callbacks.
+*
+* Recovery: seq gap or checksum mismatch → resnapshot request.
+* Stale delta guard: deltas with seq <= current book seq are silently dropped.
+* Liveness: no message for 45s → reconnect (server sends heartbeat every 30s).
+* Book watchdog (optional): books silent for 5 min are checked against REST
+* `seq`; a mismatch triggers a resnapshot, a repeat mismatch a resubscribe.
+*/
+const RECONNECT_BASE_MS = 1e3;
+const RECONNECT_MAX_MS = 3e4;
+const STALE_TIMEOUT_MS = 45e3;
+const ORDERBOOK_DEBUG_TOP_LEVELS = 5;
+const WATCHDOG_SILENCE_MS = 3e5;
+const WATCHDOG_CHECK_INTERVAL_MS = 6e4;
+/** `GET /orderbooks/outcomes` accepts at most 100 ids per call. */
+const WATCHDOG_BATCH_MAX = 100;
+/** A watchdog REST check that takes longer than this is abandoned. */
+const WATCHDOG_REQUEST_TIMEOUT_MS = 15e3;
+/**
+* Agg WebSocket client. Single WS connection with refcounted market subscriptions.
+*/
+var AggWebSocket = class {
+	constructor(options) {
+		this.ws = null;
+		this.subs = /* @__PURE__ */ new Map();
+		this.pendingSubs = /* @__PURE__ */ new Set();
+		this.pendingTradeSubs = /* @__PURE__ */ new Set();
+		this.pendingResnapshots = /* @__PURE__ */ new Set();
+		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;
+		this.arbSubs = /* @__PURE__ */ new Map();
+		this.arbFeedCbs = /* @__PURE__ */ new Set();
+		this.latestArb = /* @__PURE__ */ new Map();
+		this.books = /* @__PURE__ */ new Map();
+		this.resyncing = /* @__PURE__ */ new Set();
+		this.bookCheckedAt = /* @__PURE__ */ new Map();
+		this.watchdogResnapshotted = /* @__PURE__ */ new Set();
+		this.watchdogTimer = null;
+		this.watchdogAbort = null;
+		this.watchdogPausedUntil = 0;
+		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();
+		this.deferBookViews = options.deferBookViews ?? false;
+		this.url = options.url;
+		this.callbacks = options.callbacks ?? {};
+		this.initialToken = options.initialToken;
+		this.enableLogs = options.enableLogs ?? false;
+		this.bookWatchdog = options.bookWatchdog;
+	}
+	get connected() {
+		return this._connected;
+	}
+	/** Decode dynamic authenticated REST bytes in the same processing environment as live data. */
+	async decodeHistory(payload) {
+		return decodeChartHistory(payload);
+	}
+	/** Immutable history decoder. Browser adapters execute this inside their Worker. */
+	async loadHistory(manifest, options) {
+		if (this.destroyed) throw new Error("Market-data client disposed");
+		const controller = new AbortController();
+		const abort = () => controller.abort(options?.signal?.reason);
+		options?.signal?.addEventListener("abort", abort, { once: true });
+		if (options?.signal?.aborted) abort();
+		this.historyControllers.add(controller);
+		try {
+			controller.signal.throwIfAborted();
+			const result = await loadImmutableHistory({
+				manifest,
+				signal: controller.signal
+			});
+			controller.signal.throwIfAborted();
+			return result;
+		} finally {
+			this.historyControllers.delete(controller);
+			options?.signal?.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() {
+		return {
+			connected: this.connected,
+			host: this.hostDiagnostics?.(),
+			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) {
+		return this.books.get(outcomeId)?.view() ?? 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) {
+		return this.latestArb.get(marketId) ?? 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.bookCheckedAt.set(outcomeId, Date.now());
+			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);
+				this.bookCheckedAt.delete(outcomeId);
+				this.watchdogResnapshotted.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) {
+		this.initialToken = token;
+		if (this._connected) this.send({
+			action: "authenticate",
+			token
+		});
+	}
+	/** Request a fresh snapshot for one or more subscribed outcomes. */
+	resnapshot(outcomeIdOrIds) {
+		(Array.isArray(outcomeIdOrIds) ? outcomeIdOrIds : [outcomeIdOrIds]).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() {
+		this.cancelReconnect();
+		this.cancelStaleTimer();
+		this._connected = false;
+		this.connecting = false;
+		if (this.ws) {
+			this.ws.onclose = null;
+			this.ws.close();
+			this.ws = null;
+		}
+		this.callbacks.onConnectionStateChange?.(false);
+	}
+	/** Permanently destroy. Cannot reconnect after this. */
+	destroy() {
+		this.destroyed = true;
+		for (const controller of this.historyControllers) controller.abort(/* @__PURE__ */ 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();
+		if (this.watchdogTimer) clearInterval(this.watchdogTimer);
+		this.watchdogTimer = null;
+		this.watchdogAbort?.abort();
+		this.watchdogAbort = null;
+		this.bookCheckedAt.clear();
+		this.watchdogResnapshotted.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;
+	}
+	ensureConnected() {
+		if (this.destroyed) return;
+		if (this.ws?.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) => {
+			if (this.destroyed || this.ws !== ws) return;
+			this.lastMessageTime = Date.now();
+			this.callbacks.onFrameReceived?.(this.lastMessageTime);
+			this.resetStaleTimer();
+			try {
+				const raw = JSON.parse(event.data);
+				this.handleMessage(raw);
+			} catch {}
+		};
+		ws.onclose = () => {
+			this.ws = null;
+			this.connecting = false;
+			const wasConnected = this._connected;
+			this._connected = false;
+			this.cancelStaleTimer();
+			if (wasConnected) this.callbacks.onConnectionStateChange?.(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;
+		}
+	}
+	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;
+		}
+	}
+	handleMessage(raw) {
+		const type = raw.type;
+		if ([
+			"orderbook_snapshot",
+			"orderbook_delta",
+			"trade"
+		].includes(type) && !validMarketFrame(raw)) {
+			this.callbacks.onError?.({
+				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":
+				this.callbacks.onSubscribed?.(raw);
+				break;
+			case "unsubscribed":
+				this.callbacks.onUnsubscribed?.(raw);
+				break;
+			case "connected":
+				this.handleConnected(raw);
+				break;
+			case "authenticated":
+				this.callbacks.onAuthenticated?.(raw);
+				break;
+			case "market_resolved":
+				this.handleMarketResolved(raw);
+				break;
+			case "error":
+				this.callbacks.onError?.(raw);
+				break;
+			case "order_submitted":
+				this.handleOrderSubmitted(raw);
+				break;
+			case "balance_update":
+				this.handleBalanceUpdate(raw);
+				break;
+			case "order_event":
+				if (this.callbacks.onOrderEventReceipt) {
+					const receivedAtMs = Date.now();
+					const serverTimestampMs = typeof raw.timestamp === "number" && Number.isFinite(raw.timestamp) && raw.timestamp > 0 ? raw.timestamp : null;
+					try {
+						this.callbacks.onOrderEventReceipt({
+							orderId: String(raw.orderId ?? ""),
+							event: raw.event,
+							serverTimestampMs,
+							receivedAtMs,
+							deliveryDelayMs: serverTimestampMs !== null && receivedAtMs >= serverTimestampMs ? receivedAtMs - serverTimestampMs : null
+						});
+					} catch {}
+				}
+				this.callbacks.onOrderEvent?.(raw);
+				break;
+			case "redeem_event":
+				this.handleRedeemEvent(raw);
+				break;
+			case "withdrawal_lifecycle":
+				this.callbacks.onWithdrawalLifecycle?.(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);
+				this.callbacks.onArbMarket?.(arbMsg);
+				break;
+			}
+			case "arb_feed_batch": {
+				const feedMsg = raw;
+				for (const cb of this.arbFeedCbs) cb(feedMsg);
+				this.callbacks.onArbFeed?.(feedMsg);
+				break;
+			}
+		}
+	}
+	/**
+	* Server confirmed the connection — gateway has validated our appId and is
+	* ready to accept subscriptions. Now flush all pending subs.
+	*/
+	handleConnected(msg) {
+		this._connected = true;
+		if (this.bookWatchdog && !this.watchdogTimer && !this.destroyed) this.watchdogTimer = setInterval(() => void this.checkSilentBooks(), this.bookWatchdog.checkIntervalMs ?? WATCHDOG_CHECK_INTERVAL_MS);
+		this.callbacks.onConnectionStateChange?.(true);
+		this.callbacks.onConnected?.(msg);
+		const orderbookSet = new Set(this.activeOrderbookMarkets());
+		const reconnectedAt = Date.now();
+		for (const id of orderbookSet) if (this.bookCheckedAt.has(id)) this.bookCheckedAt.set(id, reconnectedAt);
+		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) {
+		if (!this.subs.has(raw.outcomeId)) return;
+		const msg = {
+			...raw,
+			timestamp: raw.timestamp / 1e3
+		};
+		const book = snapshotToOrderbook(msg);
+		this.books.set(msg.outcomeId, new IndexedOrderbook(book));
+		this.bookCheckedAt.set(msg.outcomeId, Date.now());
+		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)
+		});
+		this.callbacks.onBookTick?.(msg.outcomeId, {
+			midpoint: msg.midpoint,
+			timestamp: msg.timestamp,
+			source: "snapshot"
+		});
+		if (!this.deferBookViews) this.callbacks.onSnapshot?.(msg.outcomeId, book);
+	}
+	handleDelta(raw) {
+		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 = {
+			...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;
+		}
+		this.bookCheckedAt.set(outcomeId, Date.now());
+		this.watchdogResnapshotted.delete(outcomeId);
+		this.callbacks.onBookTick?.(outcomeId, {
+			midpoint: msg.midpoint,
+			timestamp: msg.timestamp,
+			source: "delta"
+		});
+		if (!this.deferBookViews) this.callbacks.onDelta?.(outcomeId, current.view());
+	}
+	handleTrade(raw) {
+		if (!this.subs.has(raw.outcomeId)) return;
+		const msg = {
+			...raw,
+			timestamp: raw.timestamp / 1e3
+		};
+		this.callbacks.onTrade?.(msg);
+	}
+	handleHeartbeat(raw) {
+		const msg = {
+			...raw,
+			ts: raw.ts / 1e3
+		};
+		this.callbacks.onHeartbeat?.(msg);
+	}
+	handleMarketResolved(raw) {
+		const msg = {
+			...raw,
+			timestamp: raw.timestamp / 1e3
+		};
+		this.books.delete(msg.outcomeId);
+		this.bookCheckedAt.delete(msg.outcomeId);
+		this.watchdogResnapshotted.delete(msg.outcomeId);
+		this.pendingResnapshots.delete(msg.outcomeId);
+		this.resyncing.delete(msg.outcomeId);
+		this.callbacks.onMarketResolved?.(msg);
+	}
+	handleOrderSubmitted(raw) {
+		const msg = {
+			...raw,
+			timestamp: raw.timestamp / 1e3
+		};
+		this.callbacks.onOrderSubmitted?.(msg);
+	}
+	handleBalanceUpdate(raw) {
+		const msg = {
+			...raw,
+			timestamp: raw.timestamp / 1e3
+		};
+		this.callbacks.onBalanceUpdate?.(msg);
+	}
+	handleRedeemEvent(raw) {
+		const msg = {
+			...raw,
+			timestamp: raw.timestamp / 1e3
+		};
+		this.callbacks.onRedeemEvent?.(msg);
+	}
+	/**
+	* Heartbeats prove the socket, not each stream. Every subscribed outcome
+	* with no progress for `silenceMs` is checked against the REST `seq`:
+	*
+	* - book present, not resyncing, same `seq` → the market is just quiet;
+	* - different `seq`, no book (snapshot never arrived, or a resubscribe's
+	*   snapshot was lost), or stuck resyncing (any recovery whose snapshot
+	*   was lost) → resnapshot, then resubscribe on the next overdue check;
+	* - REST can't serve it (`null`) → counted as an attempt, so the next
+	*   batch moves on to other outcomes instead of retrying the same 100.
+	*/
+	async checkSilentBooks() {
+		const opts = this.bookWatchdog;
+		if (!opts || !this._connected || this.watchdogAbort) return;
+		const now = Date.now();
+		if (now < this.watchdogPausedUntil) return;
+		const silenceMs = opts.silenceMs ?? WATCHDOG_SILENCE_MS;
+		const silent = this.activeOrderbookMarkets().filter((id) => this.bookCheckedAt.has(id)).filter((id) => now - this.bookCheckedAt.get(id) >= silenceMs).sort((a, b) => this.bookCheckedAt.get(a) - this.bookCheckedAt.get(b)).slice(0, WATCHDOG_BATCH_MAX);
+		if (silent.length === 0) return;
+		const checkedAt = new Map(silent.map((id) => [id, this.bookCheckedAt.get(id)]));
+		const abort = new AbortController();
+		this.watchdogAbort = abort;
+		const timeout = setTimeout(() => abort.abort(), WATCHDOG_REQUEST_TIMEOUT_MS);
+		try {
+			const url = new URL(`${opts.baseUrl.replace(/\/$/, "")}/orderbooks/outcomes`);
+			url.searchParams.set("venueMarketOutcomeIds", silent.join(","));
+			url.searchParams.set("depth", "1");
+			const response = await fetch(url, {
+				headers: opts.headers,
+				signal: abort.signal
+			});
+			if (!response.ok) {
+				const retryAfterS = Number(response.headers.get("retry-after"));
+				if (response.status === 429 && retryAfterS > 0) this.watchdogPausedUntil = Date.now() + retryAfterS * 1e3;
+				this.emitDiagnostic({
+					type: "book_watchdog_error",
+					status: response.status
+				});
+				return;
+			}
+			const body = await response.json();
+			if (this.destroyed) return;
+			silent.forEach((outcomeId, i) => {
+				if (this.bookCheckedAt.get(outcomeId) !== checkedAt.get(outcomeId)) return;
+				const server = body.data?.[i];
+				if (!server) {
+					this.bookCheckedAt.set(outcomeId, Date.now());
+					return;
+				}
+				const book = this.books.get(outcomeId);
+				if (book && !this.resyncing.has(outcomeId) && server.seq === book.seq) {
+					this.bookCheckedAt.set(outcomeId, Date.now());
+					this.watchdogResnapshotted.delete(outcomeId);
+					return;
+				}
+				const action = this.watchdogResnapshotted.has(outcomeId) ? "resubscribe" : "resnapshot";
+				this.emitDiagnostic({
+					type: "book_watchdog_resync",
+					outcomeId,
+					localSeq: book?.seq ?? null,
+					serverSeq: server.seq,
+					action
+				});
+				this.bookCheckedAt.set(outcomeId, Date.now());
+				if (action === "resubscribe") {
+					this.watchdogResnapshotted.delete(outcomeId);
+					this.books.delete(outcomeId);
+					this.resyncing.add(outcomeId);
+					this.send({
+						action: "unsubscribe",
+						channel: "orderbook",
+						outcomeIds: [outcomeId]
+					});
+					this.sendSubscribe([outcomeId]);
+				} else {
+					this.watchdogResnapshotted.add(outcomeId);
+					this.requestResnapshot(outcomeId, true);
+				}
+			});
+		} catch {
+			if (!this.destroyed) this.emitDiagnostic({
+				type: "book_watchdog_error",
+				status: null
+			});
+		} finally {
+			clearTimeout(timeout);
+			if (this.watchdogAbort === abort) this.watchdogAbort = null;
+		}
+	}
+	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();
+	}
+	/**
+	* 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) {
+		if (this.ws?.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) {
+		this.callbacks.onDiagnostics?.(event);
+	}
+	summarizeTopLevels(levels) {
+		return levels.slice(0, ORDERBOOK_DEBUG_TOP_LEVELS).map((level) => ({
+			price: level.price,
+			size: level.size
+		}));
+	}
+	debugOrderbook(event, payload) {
+		if (!this.isOrderbookDebugEnabled()) return;
+		console.debug(`[AggWebSocket][orderbook] ${event}`, payload);
+	}
+	isOrderbookDebugEnabled() {
+		return this.enableLogs;
+	}
+};
+//#endregion
+Object.defineProperty(exports, "AggWebSocket", {
+	enumerable: true,
+	get: function() {
+		return AggWebSocket;
+	}
+});
+Object.defineProperty(exports, "applyOrderbookDelta", {
+	enumerable: true,
+	get: function() {
+		return applyOrderbookDelta;
+	}
+});
+Object.defineProperty(exports, "computeChecksum", {
+	enumerable: true,
+	get: function() {
+		return computeChecksum;
+	}
+});
+Object.defineProperty(exports, "decodeChartHistory", {
+	enumerable: true,
+	get: function() {
+		return decodeChartHistory;
+	}
+});
+Object.defineProperty(exports, "loadImmutableHistory", {
+	enumerable: true,
+	get: function() {
+		return loadImmutableHistory;
+	}
+});
+Object.defineProperty(exports, "orderbookCrc32", {
+	enumerable: true,
+	get: function() {
+		return orderbookCrc32;
+	}
+});
+Object.defineProperty(exports, "projectedOrderbookChecksum", {
+	enumerable: true,
+	get: function() {
+		return projectedOrderbookChecksum;
+	}
+});
+Object.defineProperty(exports, "readChartHistoryText", {
+	enumerable: true,
+	get: function() {
+		return readChartHistoryText;
+	}
+});
+Object.defineProperty(exports, "snapshotToOrderbook", {
+	enumerable: true,
+	get: function() {
+		return snapshotToOrderbook;
+	}
+});