@liberfi.io/react-predict 0.3.70 → 0.3.72

package/dist/index.js

@@ -7,6 +7,21 @@ var reactQuery = require('@tanstack/react-query');
 var clobClientV2 = require('@polymarket/clob-client-v2');
 
 // src/client/client.ts
+
+// src/client/types.ts
+var MARKET_STRUCTURE_MEDIA_TYPE_V1 = "application/vnd.liberfi.market-structure+json;v=1";
+
+// src/client/client.ts
+var MarketDataHttpError = class extends Error {
+  constructor(message, status, code, retryAfter, body) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.retryAfter = retryAfter;
+    this.body = body;
+  }
+  name = "MarketDataHttpError";
+};
 function buildQuery(params) {
   const qs = new URLSearchParams();
   for (const [key, value] of Object.entries(params)) {
@@ -33,6 +48,26 @@ var PredictClient = class {
       }
     };
   }
+  async marketDataRequest(path, options) {
+    const response = await fetch(
+      `${this.endpoint}${path}`,
+      this.requestOptions(options)
+    );
+    if (response.ok) {
+      return await response.json();
+    }
+    const body = await parseMarketDataResponseBody(response);
+    const record = isRecord(body) ? body : void 0;
+    const code = typeof record?.error === "string" ? record.error : typeof record?.code === "string" ? record.code : void 0;
+    const message = typeof record?.message === "string" ? record.message : code ?? response.statusText ?? `HTTP ${response.status}`;
+    throw new MarketDataHttpError(
+      message,
+      response.status,
+      code,
+      response.headers.get("Retry-After") ?? void 0,
+      body
+    );
+  }
   // -------------------------------------------------------------------------
   // Events
   // -------------------------------------------------------------------------
@@ -167,6 +202,85 @@ var PredictClient = class {
   // -------------------------------------------------------------------------
   // Markets
   // -------------------------------------------------------------------------
+  /** Register or refresh the complete provider-neutral market-data demand set. */
+  async watchMarketData(request) {
+    return await this.marketDataRequest(
+      "/api/v1/market-data/watch",
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(request)
+      }
+    );
+  }
+  /** Read cache-only quote snapshots for at most 500 provider-neutral keys. */
+  async getMarketDataQuotes(markets) {
+    if (markets.length > 500) {
+      throw new RangeError(
+        "market data quote request accepts at most 500 markets"
+      );
+    }
+    return await this.marketDataRequest(
+      "/api/v1/markets/quotes",
+      {
+        method: "POST",
+        cache: "no-store",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ markets })
+      }
+    );
+  }
+  /** Read all cached Top20 outcome books for one provider-neutral market. */
+  async getMarketDataOrderbooks(slug, source) {
+    const path = `/api/v1/markets/${encodeURIComponent(slug)}/orderbooks` + buildQuery({ source });
+    return await this.marketDataRequest(path, {
+      method: "GET",
+      cache: "no-store"
+    });
+  }
+  /**
+   * Revalidate a page's allowlist-only structure representation.
+   *
+   * The path must remain inside the prediction API so callers cannot turn a
+   * configured authenticated client into a cross-origin request primitive.
+   */
+  async getMarketStructure(path, ifNoneMatch) {
+    if (!path.startsWith("/api/v1/")) {
+      throw new TypeError("market structure path must start with /api/v1/");
+    }
+    const response = await fetch(
+      `${this.endpoint}${path}`,
+      this.requestOptions({
+        method: "GET",
+        cache: "no-store",
+        headers: {
+          Accept: MARKET_STRUCTURE_MEDIA_TYPE_V1,
+          ...ifNoneMatch ? { "If-None-Match": ifNoneMatch } : {}
+        }
+      })
+    );
+    const etag = response.headers.get("ETag") ?? "";
+    if (response.status === 304) {
+      return { status: 304, etag };
+    }
+    if (response.ok) {
+      return {
+        status: 200,
+        etag,
+        body: await response.json()
+      };
+    }
+    const body = await parseMarketDataResponseBody(response);
+    const record = isRecord(body) ? body : void 0;
+    const code = typeof record?.error === "string" ? record.error : void 0;
+    throw new MarketDataHttpError(
+      typeof record?.message === "string" ? record.message : code ?? response.statusText,
+      response.status,
+      code,
+      response.headers.get("Retry-After") ?? void 0,
+      body
+    );
+  }
   /**
    * Fetch a single prediction market by its slug.
    *
@@ -636,6 +750,18 @@ var PredictClient = class {
 function createPredictClient(endpoint, options) {
   return new PredictClient(endpoint, options);
 }
+async function parseMarketDataResponseBody(response) {
+  const text = await response.text().catch(() => "");
+  if (!text) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 
 // src/client/ws.ts
 var DEFAULT_RECONNECT_BASE = 1e3;
@@ -949,19 +1075,19 @@ var PredictWsClient = class {
       JSON.stringify({ type, channels, market_slugs: [] })
     );
     const budget = MAX_SUBSCRIPTION_FRAME_BYTES - envelopeBytes;
-    let chunk = [];
+    let chunk2 = [];
     let chunkBytes = 0;
     const flush = () => {
-      if (chunk.length > 0) {
-        this.send({ type, channels, market_slugs: chunk });
-        chunk = [];
+      if (chunk2.length > 0) {
+        this.send({ type, channels, market_slugs: chunk2 });
+        chunk2 = [];
         chunkBytes = 0;
       }
     };
     for (const slug of marketSlugs) {
       const slugBytes = byteLength(JSON.stringify(slug)) + 1;
-      if (chunk.length > 0 && chunkBytes + slugBytes > budget) flush();
-      chunk.push(slug);
+      if (chunk2.length > 0 && chunkBytes + slugBytes > budget) flush();
+      chunk2.push(slug);
       chunkBytes += slugBytes;
     }
     flush();
@@ -1004,6 +1130,1258 @@ var PredictWsClient = class {
 function createPredictWsClient(config) {
   return new PredictWsClient(config);
 }
+
+// src/market-data/contract.ts
+var MARKET_DATA_BACKEND_CONTRACT_COMMIT = "0d0bab5c38dda76658890395bd992de84477267a";
+var MARKET_DATA_CONTRACT_MANIFEST_SHA256 = "81c503ed6f1bb5b6f8f20ff9f448549d0b89553b36dbc422d09c3e4a898e4aaf";
+
+// src/market-data/initialQuote.ts
+function parseInitialQuotes(input, structure) {
+  if (input === void 0) return { kind: "missing" };
+  try {
+    validateInitialQuotes(input, structure);
+    return { kind: "valid", value: input };
+  } catch (error) {
+    return {
+      kind: "malformed",
+      reason: error instanceof Error ? error.message : "invalid initial_quotes"
+    };
+  }
+}
+function validateInitialQuotes(input, structure) {
+  const root = requireRecord(input, "initial_quotes");
+  if (root.schema_version !== 1) {
+    throw new Error("initial_quotes schema_version must be 1");
+  }
+  const markets = requireArray(root.markets, "initial_quotes markets");
+  if (markets.length !== structure.length) {
+    throw new Error("initial_quotes markets must match structural markets");
+  }
+  const structuralMarkets = new Map(
+    structure.map((market) => [
+      marketIdentity(market.source, market.market_slug),
+      market
+    ])
+  );
+  if (structuralMarkets.size !== structure.length) {
+    throw new Error("structural markets must have unique identities");
+  }
+  const seenMarkets = /* @__PURE__ */ new Set();
+  markets.forEach((marketValue, marketIndex) => {
+    const market = requireRecord(
+      marketValue,
+      `initial_quotes market ${marketIndex}`
+    );
+    if (typeof market.source !== "string" || typeof market.market_slug !== "string") {
+      throw new Error(
+        `initial_quotes market ${marketIndex} requires source and market_slug`
+      );
+    }
+    const identity = marketIdentity(market.source, market.market_slug);
+    const structuralMarket = structuralMarkets.get(identity);
+    if (!structuralMarket || seenMarkets.has(identity)) {
+      throw new Error(
+        `initial_quotes market ${marketIndex} must match structural market`
+      );
+    }
+    seenMarkets.add(identity);
+    if (typeof market.realtime_supported !== "boolean") {
+      throw new Error(
+        `initial_quotes market ${marketIndex} requires realtime_supported`
+      );
+    }
+    const outcomes = requireArray(
+      market.outcomes,
+      `initial_quotes market ${marketIndex} outcomes`
+    );
+    if (outcomes.length !== structuralMarket.outcomes.length) {
+      throw new Error(
+        `initial_quotes market ${marketIndex} outcomes must match structure`
+      );
+    }
+    const structuralOutcomes = new Set(structuralMarket.outcomes);
+    if (structuralOutcomes.size !== structuralMarket.outcomes.length) {
+      throw new Error(
+        `structural market ${marketIndex} outcomes must have unique identities`
+      );
+    }
+    const seenOutcomes = /* @__PURE__ */ new Set();
+    outcomes.forEach((outcomeValue, outcomeIndex) => {
+      const outcome = requireRecord(
+        outcomeValue,
+        `initial_quotes market ${marketIndex} outcome ${outcomeIndex}`
+      );
+      if (outcome.source !== structuralMarket.source || outcome.market_slug !== structuralMarket.market_slug || typeof outcome.outcome !== "string" || !structuralOutcomes.has(outcome.outcome) || seenOutcomes.has(outcome.outcome)) {
+        throw new Error(
+          `initial_quotes market ${marketIndex} outcome ${outcomeIndex} must match structure`
+        );
+      }
+      seenOutcomes.add(outcome.outcome);
+      assertMarketDataBBAComponent(
+        outcome.bba,
+        `initial_quotes market ${marketIndex} outcome ${outcomeIndex} bba`
+      );
+      assertMarketDataValueComponent(
+        outcome.last_trade,
+        `initial_quotes market ${marketIndex} outcome ${outcomeIndex} last_trade`,
+        false
+      );
+      assertMarketDataValueComponent(
+        outcome.tick_size,
+        `initial_quotes market ${marketIndex} outcome ${outcomeIndex} tick_size`,
+        true
+      );
+      if (!market.realtime_supported && (outcome.bba.available || outcome.last_trade.available || outcome.tick_size.available)) {
+        throw new Error(
+          `unsupported initial_quotes market ${marketIndex} must be unavailable`
+        );
+      }
+    });
+  });
+}
+function marketIdentity(source, marketSlug) {
+  return `${source}\0${marketSlug}`;
+}
+function assertMarketDataBBAComponent(input, name) {
+  const component = requireRecord(input, name);
+  if (typeof component.available !== "boolean" || typeof component.empty !== "boolean") {
+    throw new Error(`${name} requires available and empty`);
+  }
+  validateTimestampFields(component, name);
+  if (!component.available) {
+    if (component.empty || component.best_bid !== void 0 || component.best_ask !== void 0 || component.midpoint !== void 0) {
+      throw new Error(`${name} unavailable component must omit quote values`);
+    }
+    return;
+  }
+  requireObservedAt(component, name);
+  if (component.empty) {
+    if (component.best_bid !== void 0 || component.best_ask !== void 0 || component.midpoint !== void 0) {
+      throw new Error(`${name} empty component must omit quote values`);
+    }
+    return;
+  }
+  const bid = optionalProbability(component.best_bid, `${name} best_bid`);
+  const ask = optionalProbability(component.best_ask, `${name} best_ask`);
+  const midpoint = optionalProbability(component.midpoint, `${name} midpoint`);
+  if (bid === void 0 && ask === void 0) {
+    throw new Error(`${name} non-empty component requires a bid or ask`);
+  }
+  if (bid !== void 0 && ask !== void 0) {
+    if (bid >= ask) throw new Error(`${name} best bid must be lower than ask`);
+    if (midpoint === void 0 || Math.abs(midpoint - (bid + ask) / 2) > 1e-12) {
+      throw new Error(`${name} midpoint must match bid and ask`);
+    }
+  } else if (midpoint !== void 0) {
+    throw new Error(`${name} midpoint requires bid and ask`);
+  }
+}
+function assertMarketDataValueComponent(input, name, positive) {
+  const component = requireRecord(input, name);
+  if (typeof component.available !== "boolean") {
+    throw new Error(`${name} requires available`);
+  }
+  validateTimestampFields(component, name);
+  if (!component.available) {
+    if (component.value !== void 0) {
+      throw new Error(`${name} unavailable component must omit value`);
+    }
+    return;
+  }
+  const value = optionalProbability(component.value, `${name} value`);
+  if (value === void 0) throw new Error(`${name} requires value`);
+  if (positive && value === 0) throw new Error(`${name} must be positive`);
+  requireObservedAt(component, name);
+}
+function validateTimestampFields(component, name) {
+  if (component.provider_timestamp !== void 0 && !isRFC3339(component.provider_timestamp)) {
+    throw new Error(`${name} provider_timestamp must be RFC3339`);
+  }
+  if (component.observed_at !== void 0 && !isRFC3339(component.observed_at)) {
+    throw new Error(`${name} observed_at must be RFC3339`);
+  }
+  if (component.provider_timestamp !== void 0 && component.observed_at === void 0) {
+    throw new Error(`${name} provider_timestamp requires observed_at`);
+  }
+}
+function requireObservedAt(component, name) {
+  if (!isRFC3339(component.observed_at)) {
+    throw new Error(`${name} available component requires observed_at`);
+  }
+}
+function optionalProbability(value, name) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) {
+    throw new Error(`${name} must be a finite probability`);
+  }
+  return value;
+}
+function isRFC3339(value) {
+  return typeof value === "string" && value.length > 0 && Number.isFinite(Date.parse(value));
+}
+function requireRecord(value, name) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(`${name} must be an object`);
+  }
+  return value;
+}
+function requireArray(value, name) {
+  if (!Array.isArray(value)) throw new Error(`${name} must be an array`);
+  return value;
+}
+
+// src/market-data/protocol.ts
+function comparePublicationCursor(candidate, current) {
+  if (candidate.generation < current.generation) return "older";
+  if (candidate.generation > current.generation) return "newer_generation";
+  if (candidate.epoch !== current.epoch) return "epoch_changed";
+  if (candidate.offset < current.offset) return "older";
+  if (candidate.offset > current.offset) return "newer";
+  return "same";
+}
+function decodeItemEnvelope(input) {
+  const root = asRecord(input);
+  if (root?.schema_version !== 1) {
+    return failure("incompatible_schema", "item schema_version must be 1");
+  }
+  try {
+    const changes = root.changes === void 0 ? void 0 : requireArray2(root.changes, "changes").map(decodeItemChange);
+    const invalidation = root.resource_invalidated === void 0 ? void 0 : decodeInvalidation(root.resource_invalidated);
+    if ((!changes || changes.length === 0) && !invalidation) {
+      throw new Error("item envelope requires changes or invalidation");
+    }
+    return {
+      ok: true,
+      value: {
+        schema_version: 1,
+        ...changes ? { changes } : {},
+        ...invalidation ? { resource_invalidated: invalidation } : {}
+      }
+    };
+  } catch (error) {
+    return failure(
+      "malformed",
+      error instanceof Error ? error.message : "malformed item envelope"
+    );
+  }
+}
+function decodeBookEnvelope(input) {
+  const root = asRecord(input);
+  if (root?.schema_version !== 1) {
+    return failure("incompatible_schema", "book schema_version must be 1");
+  }
+  try {
+    const source = requireSource(root.source);
+    const marketSlug = requireIdentity(root.market_slug, "market_slug");
+    const outcome = requireIdentity(root.outcome, "outcome");
+    const observedAt = requireTimestamp(root.observed_at, "observed_at");
+    if (typeof root.available !== "boolean") {
+      throw new Error("book available must be boolean");
+    }
+    const providerTimestamp = root.provider_timestamp === void 0 ? void 0 : requireTimestamp(root.provider_timestamp, "provider_timestamp");
+    if (!root.available) {
+      if (root.bids !== void 0 || root.asks !== void 0) {
+        throw new Error("unavailable book must omit levels");
+      }
+      return {
+        ok: true,
+        value: {
+          schema_version: 1,
+          available: false,
+          source,
+          market_slug: marketSlug,
+          outcome,
+          observed_at: observedAt,
+          ...providerTimestamp ? { provider_timestamp: providerTimestamp } : {}
+        }
+      };
+    }
+    const bids = decodeBookLevels(root.bids, "bids");
+    const asks = decodeBookLevels(root.asks, "asks");
+    return {
+      ok: true,
+      value: {
+        schema_version: 1,
+        available: true,
+        source,
+        market_slug: marketSlug,
+        outcome,
+        observed_at: observedAt,
+        bids,
+        asks,
+        ...providerTimestamp ? { provider_timestamp: providerTimestamp } : {}
+      }
+    };
+  } catch (error) {
+    return failure(
+      "malformed",
+      error instanceof Error ? error.message : "malformed book envelope"
+    );
+  }
+}
+function decodeItemChange(value) {
+  const change = requireRecord2(value, "change");
+  const source = requireSource(change.source);
+  const marketSlug = requireIdentity(change.market_slug, "market_slug");
+  const outcome = requireIdentity(change.outcome, "outcome");
+  const decoded = {
+    source,
+    market_slug: marketSlug,
+    outcome
+  };
+  if (change.bba !== void 0) {
+    assertMarketDataBBAComponent(change.bba, "bba");
+    decoded.bba = change.bba;
+  }
+  if (change.last_trade !== void 0) {
+    assertMarketDataValueComponent(change.last_trade, "last_trade", false);
+    decoded.last_trade = change.last_trade;
+  }
+  if (change.tick_size !== void 0) {
+    assertMarketDataValueComponent(change.tick_size, "tick_size", true);
+    decoded.tick_size = change.tick_size;
+  }
+  if (change.market_status !== void 0) {
+    decoded.market_status = decodeStatus(change.market_status);
+  }
+  if (decoded.bba === void 0 && decoded.last_trade === void 0 && decoded.tick_size === void 0 && decoded.market_status === void 0) {
+    throw new Error("item change requires a component replacement");
+  }
+  return decoded;
+}
+function decodeStatus(value) {
+  const status = requireRecord2(value, "market_status");
+  if (status.value !== "pending" && status.value !== "open" && status.value !== "closed" && status.value !== "voided") {
+    throw new Error("unsupported market_status");
+  }
+  return {
+    value: status.value,
+    observed_at: requireTimestamp(
+      status.observed_at,
+      "market_status observed_at"
+    )
+  };
+}
+function decodeInvalidation(value) {
+  const invalidation = requireRecord2(value, "resource_invalidated");
+  if (invalidation.reason !== "market_membership_changed") {
+    throw new Error("unsupported invalidation reason");
+  }
+  return {
+    reason: invalidation.reason,
+    observed_at: requireTimestamp(
+      invalidation.observed_at,
+      "resource_invalidated observed_at"
+    )
+  };
+}
+function decodeBookLevels(value, name) {
+  return requireArray2(value, name).map((levelValue, index) => {
+    const level = requireRecord2(levelValue, `${name} ${index}`);
+    if (typeof level.price !== "string" || !isDecimal(level.price) || typeof level.size !== "string" || !isDecimal(level.size)) {
+      throw new Error(
+        `${name} ${index} requires decimal string price and size`
+      );
+    }
+    return { price: level.price, size: level.size };
+  });
+}
+function requireSource(value) {
+  if (value !== "polymarket" && value !== "kalshi") {
+    throw new Error("unsupported source");
+  }
+  return value;
+}
+function requireIdentity(value, name) {
+  if (typeof value !== "string" || value.trim() === "" || /[\u0000-\u001f]/.test(value)) {
+    throw new Error(`${name} must be a non-empty identity`);
+  }
+  return value;
+}
+function requireTimestamp(value, name) {
+  if (typeof value !== "string" || value.length === 0 || !Number.isFinite(Date.parse(value))) {
+    throw new Error(`${name} must be RFC3339`);
+  }
+  return value;
+}
+function isDecimal(value) {
+  return /^(?:0|[1-9]\d*)(?:\.\d+)?$/.test(value);
+}
+function requireRecord2(value, name) {
+  const record = asRecord(value);
+  if (!record) throw new Error(`${name} must be an object`);
+  return record;
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function requireArray2(value, name) {
+  if (!Array.isArray(value)) throw new Error(`${name} must be an array`);
+  return value;
+}
+function failure(reason, message) {
+  return { ok: false, reason, message };
+}
+
+// src/market-data/recoveryBarrier.ts
+var RecoveryBarrier = class {
+  generation;
+  maxBufferedPublications;
+  commitValue;
+  buffered = [];
+  currentCursor;
+  currentEpoch;
+  state = "buffering";
+  constructor(options) {
+    if (options.maxBufferedPublications < 1) {
+      throw new RangeError("maxBufferedPublications must be positive");
+    }
+    this.generation = options.generation;
+    this.maxBufferedPublications = options.maxBufferedPublications;
+    this.commitValue = options.commit;
+  }
+  acknowledge(input) {
+    if (this.state === "invalidated") return this.state;
+    if (input.epoch.length === 0) {
+      return this.requireRecovery();
+    }
+    this.currentEpoch = input.epoch;
+    this.currentCursor = void 0;
+    this.state = "catching_up";
+    return this.state;
+  }
+  completeCatchUp(cursor) {
+    if (this.state !== "catching_up" || cursor.generation !== this.generation || cursor.epoch !== this.currentEpoch) {
+      return this.requireRecovery();
+    }
+    this.currentCursor = cursor;
+    const pending = this.buffered;
+    this.buffered = [];
+    let recoveryRequired = false;
+    for (const publication of pending) {
+      if (this.commitIfNewer(publication) === "recovery_required") {
+        recoveryRequired = true;
+        break;
+      }
+    }
+    if (!recoveryRequired) this.state = "live";
+    return this.state;
+  }
+  push(value, cursor) {
+    if (this.state === "invalidated" || cursor.generation < this.generation) {
+      return "ignored";
+    }
+    if (cursor.generation > this.generation) {
+      this.requireRecovery();
+      return "recovery_required";
+    }
+    if (this.state === "live") {
+      return this.commitIfNewer({ value, cursor });
+    }
+    if (this.state === "recovery_required") return "recovery_required";
+    if (this.buffered.length >= this.maxBufferedPublications) {
+      this.requireRecovery();
+      return "recovery_required";
+    }
+    this.buffered.push({ value, cursor });
+    return "buffered";
+  }
+  invalidate() {
+    this.buffered = [];
+    this.currentCursor = void 0;
+    this.state = "invalidated";
+  }
+  commitIfNewer(publication) {
+    if (!this.currentCursor) {
+      this.requireRecovery();
+      return "recovery_required";
+    }
+    const order = comparePublicationCursor(
+      publication.cursor,
+      this.currentCursor
+    );
+    if (order === "older" || order === "same") return "ignored";
+    if (order === "epoch_changed" || order === "newer_generation") {
+      this.requireRecovery();
+      return "recovery_required";
+    }
+    this.commitValue(publication.value, publication.cursor);
+    this.currentCursor = publication.cursor;
+    return "committed";
+  }
+  requireRecovery() {
+    this.buffered = [];
+    this.currentCursor = void 0;
+    this.state = "recovery_required";
+    return this.state;
+  }
+};
+
+// src/market-data/watchScheduler.ts
+function chunkWatchRequest(request, maxRawQuoteSelectors) {
+  if (maxRawQuoteSelectors < 1) {
+    throw new RangeError("maxRawQuoteSelectors must be positive");
+  }
+  const selectors = [
+    ...(request.quote_events ?? []).map((value) => ({
+      kind: "event",
+      value
+    })),
+    ...(request.quote_markets ?? []).map((value) => ({
+      kind: "market",
+      value
+    }))
+  ];
+  if (selectors.length === 0) {
+    return request.orderbook_market ? [{ ...request }] : [];
+  }
+  const chunks = [];
+  for (let index = 0; index < selectors.length; index += maxRawQuoteSelectors) {
+    const chunk2 = selectors.slice(index, index + maxRawQuoteSelectors);
+    const quoteEvents = chunk2.filter(
+      (selector) => selector.kind === "event"
+    ).map((selector) => selector.value);
+    const quoteMarkets = chunk2.filter(
+      (selector) => selector.kind === "market"
+    ).map((selector) => selector.value);
+    chunks.push({
+      ...quoteEvents.length ? { quote_events: quoteEvents } : {},
+      ...quoteMarkets.length ? { quote_markets: quoteMarkets } : {},
+      ...request.orderbook_market ? { orderbook_market: request.orderbook_market } : {}
+    });
+  }
+  return chunks;
+}
+var MarketDataWatchScheduler = class {
+  touch;
+  maxRawQuoteSelectors;
+  onTouchSuccess;
+  onTouchError;
+  timer;
+  revision = 0;
+  retryAttempt = 0;
+  current;
+  disposed = false;
+  constructor(options) {
+    this.touch = options.touch;
+    this.maxRawQuoteSelectors = options.maxRawQuoteSelectors;
+    this.onTouchSuccess = options.onTouchSuccess;
+    this.onTouchError = options.onTouchError;
+  }
+  async replace(request) {
+    if (this.disposed) throw new Error("watch scheduler is disposed");
+    if (chunkWatchRequest(request, this.maxRawQuoteSelectors).length === 0) {
+      this.clear();
+      return;
+    }
+    this.current = request;
+    const revision = ++this.revision;
+    this.retryAttempt = 0;
+    this.clearTimer();
+    try {
+      await this.touchCurrent(revision);
+    } catch (error) {
+      if (isRetryableWatchError(error)) {
+        this.scheduleRetry(revision, error);
+      }
+      throw error;
+    }
+  }
+  dispose() {
+    this.disposed = true;
+    this.clear();
+  }
+  clear() {
+    this.current = void 0;
+    this.revision++;
+    this.retryAttempt = 0;
+    this.clearTimer();
+  }
+  async touchCurrent(revision) {
+    if (!this.current || revision !== this.revision || this.disposed) return;
+    const chunks = chunkWatchRequest(this.current, this.maxRawQuoteSelectors);
+    if (chunks.length === 0) throw new Error("watch request must not be empty");
+    const responses = [];
+    try {
+      for (const chunk2 of chunks) {
+        responses.push(await this.touch(chunk2));
+      }
+    } catch (error) {
+      if (this.current && revision === this.revision && !this.disposed) {
+        this.onTouchError?.(error);
+      }
+      throw error;
+    }
+    if (!this.current || revision !== this.revision || this.disposed) return;
+    const refreshAfterMS = Math.min(
+      ...responses.map((response) => response.refresh_after_ms)
+    );
+    if (!Number.isFinite(refreshAfterMS) || refreshAfterMS <= 0) {
+      throw new Error("refresh_after_ms must be positive");
+    }
+    this.retryAttempt = 0;
+    this.onTouchSuccess?.();
+    this.timer = setTimeout(() => {
+      void this.touchCurrent(revision).catch((error) => {
+        if (isRetryableWatchError(error)) {
+          this.scheduleRetry(revision, error);
+        }
+      });
+    }, refreshAfterMS);
+  }
+  scheduleRetry(revision, error) {
+    if (!this.current || revision !== this.revision || this.disposed) return;
+    this.clearTimer();
+    const retryAfterMS = retryAfterMilliseconds(error);
+    const delay = retryAfterMS ?? Math.min(3e4, 1e3 * 2 ** Math.min(this.retryAttempt, 5));
+    this.retryAttempt++;
+    this.timer = setTimeout(() => {
+      void this.touchCurrent(revision).catch((nextError) => {
+        if (isRetryableWatchError(nextError)) {
+          this.scheduleRetry(revision, nextError);
+        }
+      });
+    }, delay);
+  }
+  clearTimer() {
+    if (this.timer !== void 0) clearTimeout(this.timer);
+    this.timer = void 0;
+  }
+};
+function isRetryableWatchError(error) {
+  if (typeof error !== "object" || error === null || !("status" in error) || typeof error.status !== "number") {
+    return true;
+  }
+  return error.status === 408 || error.status === 429 || error.status >= 500;
+}
+function retryAfterMilliseconds(error) {
+  if (typeof error !== "object" || error === null || !("retryAfter" in error) || typeof error.retryAfter !== "string") {
+    return void 0;
+  }
+  const seconds = Number(error.retryAfter);
+  return Number.isFinite(seconds) && seconds >= 0 ? seconds * 1e3 : void 0;
+}
+
+// src/market-data/marketDataRuntime.ts
+var MarketDataRuntime = class {
+  enabled;
+  client;
+  store;
+  transportFactory;
+  resources = /* @__PURE__ */ new Map();
+  transport;
+  watchScheduler;
+  disposing = false;
+  constructor(options) {
+    this.enabled = options.enabled;
+    this.client = options.client;
+    this.store = options.store;
+    this.transportFactory = options.transportFactory;
+  }
+  mount(input) {
+    if (!this.enabled) return () => void 0;
+    if (!this.transportFactory) {
+      throw new Error(
+        "market data transportFactory is required when capability is enabled"
+      );
+    }
+    this.release(input.key);
+    const started = this.store.begin(input.key, input.structureETag);
+    this.store.update(input.key, started.generation, {
+      phase: "buffering",
+      initialQuotes: input.initialQuotes
+    });
+    const resource = {
+      generation: started.generation,
+      input,
+      subscriptions: [],
+      barriers: /* @__PURE__ */ new Map(),
+      acknowledgements: /* @__PURE__ */ new Map(),
+      initialQuotes: input.initialQuotes,
+      bootstrapStarted: false,
+      catchUpInFlight: false,
+      bookRetryAttempt: 0,
+      released: false
+    };
+    this.resources.set(input.key, resource);
+    if (Boolean(input.bookChannel) !== Boolean(input.watch.orderbook_market)) {
+      this.fail(
+        resource,
+        "incomplete_book_target",
+        "book channel and orderbook watch selector must be provided together"
+      );
+      return () => this.releaseGeneration(input.key, resource.generation);
+    }
+    const channels = new Set(
+      input.structure.items.map((item) => item.item_channel).filter((channel) => Boolean(channel))
+    );
+    if (input.bookChannel) {
+      const declared = input.structure.items.some(
+        (item) => item.markets.some(
+          (market) => market.outcomes.some(
+            (outcome) => outcome.book_channel === input.bookChannel
+          )
+        )
+      );
+      if (!declared) {
+        this.fail(
+          resource,
+          "unknown_book_channel",
+          "book channel is absent from structure"
+        );
+        return () => this.releaseGeneration(input.key, resource.generation);
+      }
+      channels.add(input.bookChannel);
+    }
+    if (channels.size === 0) {
+      this.fail(resource, "missing_channel", "structure has no channel target");
+      return () => this.releaseGeneration(input.key, resource.generation);
+    }
+    for (const channel of channels) this.subscribe(resource, channel);
+    return () => this.releaseGeneration(input.key, resource.generation);
+  }
+  dispose() {
+    this.disposing = true;
+    for (const key of [...this.resources.keys()]) this.release(key);
+    this.watchScheduler?.dispose();
+    this.watchScheduler = void 0;
+    this.transport?.close?.();
+    this.transport = void 0;
+  }
+  subscribe(resource, channel) {
+    const barrier = new RecoveryBarrier({
+      generation: resource.generation,
+      maxBufferedPublications: 1e3,
+      commit: (value) => this.commitPublication(resource, channel, value)
+    });
+    resource.barriers.set(channel, barrier);
+    const subscription = this.getTransport().subscribe(channel, {
+      onPublication: (publication) => this.onPublication(resource, channel, publication),
+      onSubscribed: (ack) => this.onSubscribed(resource, channel, ack),
+      onError: (error) => this.store.update(resource.input.key, resource.generation, {
+        phase: channel === resource.input.bookChannel ? "degraded_book" : "degraded_quote",
+        ...channel === resource.input.bookChannel ? { bookError: error } : { quoteError: error }
+      })
+    });
+    resource.subscriptions.push(subscription);
+  }
+  onPublication(resource, channel, publication) {
+    if (resource.released) return;
+    const result = resource.barriers.get(channel)?.push(publication.data, {
+      generation: resource.generation,
+      epoch: publication.epoch,
+      offset: publication.offset
+    });
+    const acknowledged = resource.acknowledgements.get(channel);
+    if (result === "recovery_required" && acknowledged?.epoch === publication.epoch) {
+      this.restartCatchUp(resource);
+    }
+  }
+  onSubscribed(resource, channel, ack) {
+    if (resource.released) return;
+    const barrier = resource.barriers.get(channel);
+    const previousState = barrier?.state;
+    if (resource.bootstrapStarted && (previousState === "live" || previousState === "recovery_required")) {
+      resource.bootstrapStarted = false;
+      resource.acknowledgements.clear();
+      this.store.update(resource.input.key, resource.generation, {
+        phase: "buffering"
+      });
+    }
+    const state = barrier?.acknowledge(ack);
+    if (state === "recovery_required") {
+      this.fail(
+        resource,
+        "recovery_required",
+        "subscription was not recovered"
+      );
+      return;
+    }
+    resource.acknowledgements.set(channel, ack);
+    if (resource.acknowledgements.size === resource.barriers.size && !resource.bootstrapStarted) {
+      resource.bootstrapStarted = true;
+      void this.bootstrap(resource);
+    }
+  }
+  async bootstrap(resource) {
+    if (resource.catchUpInFlight || resource.released) return;
+    resource.catchUpInFlight = true;
+    this.store.update(resource.input.key, resource.generation, {
+      phase: "catching_up"
+    });
+    try {
+      const structure = await this.client.getMarketStructure(
+        resource.input.structurePath,
+        resource.input.structureETag
+      );
+      if (resource.released) return;
+      if (structure.status === 200 || structure.etag !== resource.input.structureETag) {
+        this.fail(
+          resource,
+          "structure_changed",
+          "resource structure changed during recovery"
+        );
+        return;
+      }
+      const keys = realtimeMarketKeys(resource.input);
+      const quoteChunks = chunk(keys, 500);
+      let initialQuotes = resource.initialQuotes;
+      for (const quoteChunk of quoteChunks) {
+        const response = await this.client.getMarketDataQuotes(quoteChunk);
+        if (resource.released) return;
+        const parsed = parseInitialQuotes(
+          response,
+          structuralMarketsForKeys(resource.input, quoteChunk)
+        );
+        if (parsed.kind !== "valid") {
+          throw new Error(
+            parsed.kind === "malformed" ? parsed.reason : "quote catch-up response is missing"
+          );
+        }
+        initialQuotes = mergeQuoteCatchUp(initialQuotes, parsed.value);
+      }
+      resource.initialQuotes = initialQuotes;
+      let bookError;
+      if (resource.input.watch.orderbook_market) {
+        const key = resource.input.watch.orderbook_market;
+        try {
+          const orderbooks = await this.client.getMarketDataOrderbooks(
+            key.market_slug,
+            key.source
+          );
+          if (resource.released) return;
+          this.store.update(resource.input.key, resource.generation, {
+            orderbooks,
+            bookError: void 0
+          });
+        } catch (error) {
+          bookError = error;
+          if (this.handleBookError(resource, error)) return;
+        }
+      }
+      if (resource.released) return;
+      await this.getWatchScheduler().replace(this.combinedWatchRequest());
+      if (resource.released) return;
+      for (const [channel, barrier] of resource.barriers) {
+        const ack = resource.acknowledgements.get(channel);
+        if (!ack) throw new Error(`missing subscription ack for ${channel}`);
+        if (barrier.completeCatchUp({
+          generation: resource.generation,
+          epoch: ack.epoch,
+          offset: ack.offset
+        }) === "recovery_required") {
+          throw new Error(`recovery fence failed for ${channel}`);
+        }
+      }
+      this.store.update(resource.input.key, resource.generation, {
+        phase: bookError ? "degraded_book" : "live",
+        initialQuotes: resource.initialQuotes,
+        quoteError: void 0
+      });
+    } catch (error) {
+      const state = this.store.get(resource.input.key);
+      if (state.generation === resource.generation && (state.phase === "terminal" || state.phase === "degraded_book" && resource.watchFailure === "book" || resource.watchFailure === "rate_limit")) {
+        return;
+      }
+      this.store.update(resource.input.key, resource.generation, {
+        phase: "degraded_quote",
+        initialQuotes: resource.initialQuotes,
+        quoteError: error
+      });
+    } finally {
+      resource.catchUpInFlight = false;
+    }
+  }
+  restartCatchUp(resource) {
+    if (resource.released || resource.catchUpInFlight) return;
+    resource.bootstrapStarted = true;
+    for (const [channel, barrier] of resource.barriers) {
+      const ack = resource.acknowledgements.get(channel);
+      if (!ack) {
+        resource.bootstrapStarted = false;
+        return;
+      }
+      barrier.acknowledge({ ...ack, recovered: false });
+    }
+    void this.bootstrap(resource);
+  }
+  commitPublication(resource, channel, value) {
+    if (channel === resource.input.bookChannel) {
+      const decoded2 = decodeBookEnvelope(value);
+      if (!decoded2.ok) {
+        this.store.update(resource.input.key, resource.generation, {
+          phase: "degraded_book",
+          bookError: decoded2
+        });
+      } else {
+        this.store.update(resource.input.key, resource.generation, {
+          phase: "live",
+          liveBook: decoded2.value,
+          bookError: void 0
+        });
+      }
+      return;
+    }
+    const decoded = decodeItemEnvelope(value);
+    if (!decoded.ok) {
+      this.store.update(resource.input.key, resource.generation, {
+        phase: "degraded_quote",
+        quoteError: decoded
+      });
+      return;
+    }
+    if (decoded.value.resource_invalidated) {
+      this.fail(
+        resource,
+        "structure_invalidated",
+        "resource membership was invalidated"
+      );
+      return;
+    }
+    if (decoded.value.changes && resource.initialQuotes) {
+      resource.initialQuotes = mergeItemChanges(
+        resource.initialQuotes,
+        decoded.value.changes
+      );
+      this.store.update(resource.input.key, resource.generation, {
+        initialQuotes: resource.initialQuotes
+      });
+    }
+  }
+  getTransport() {
+    if (!this.transport) this.transport = this.transportFactory();
+    return this.transport;
+  }
+  getWatchScheduler() {
+    if (!this.watchScheduler) {
+      this.watchScheduler = new MarketDataWatchScheduler({
+        touch: (request) => this.client.watchMarketData(request),
+        maxRawQuoteSelectors: 500,
+        onTouchSuccess: () => this.onWatchTouchSuccess(),
+        onTouchError: (error) => this.onWatchTouchError(error)
+      });
+    }
+    return this.watchScheduler;
+  }
+  onWatchTouchSuccess() {
+    for (const resource of this.resources.values()) {
+      if (resource.released || !resource.watchFailure) continue;
+      const state = this.store.get(resource.input.key);
+      if (state.generation !== resource.generation) continue;
+      const watchError = resource.watchError;
+      const quoteError = state.quoteError === watchError ? void 0 : state.quoteError;
+      const bookError = state.bookError === watchError ? void 0 : state.bookError;
+      resource.watchFailure = void 0;
+      resource.watchError = void 0;
+      this.store.update(resource.input.key, resource.generation, {
+        phase: quoteError ? "degraded_quote" : bookError ? "degraded_book" : "live",
+        quoteError,
+        bookError
+      });
+    }
+  }
+  onWatchTouchError(error) {
+    const status = httpStatus(error);
+    for (const resource of this.resources.values()) {
+      if (resource.released) continue;
+      if (status === 401 || status === 403 || status === 404 || status === 422) {
+        this.fail(
+          resource,
+          status === 404 ? "structure_invalidated" : "watch_terminal",
+          error instanceof Error ? error.message : "Watch request failed"
+        );
+        this.store.update(resource.input.key, resource.generation, {
+          quoteError: error
+        });
+        continue;
+      }
+      if (status === 429) {
+        resource.watchFailure = resource.input.watch.orderbook_market ? "book" : "rate_limit";
+        resource.watchError = error;
+        this.store.update(resource.input.key, resource.generation, {
+          phase: resource.input.watch.orderbook_market ? "degraded_book" : "live",
+          initialQuotes: resource.initialQuotes,
+          quoteError: void 0,
+          ...resource.input.watch.orderbook_market ? { bookError: error } : {}
+        });
+        continue;
+      }
+      resource.watchFailure = "quote";
+      resource.watchError = error;
+      this.store.update(resource.input.key, resource.generation, {
+        phase: "degraded_quote",
+        initialQuotes: resource.initialQuotes,
+        quoteError: error
+      });
+    }
+  }
+  handleBookError(resource, error) {
+    if (resource.released) return false;
+    const status = httpStatus(error);
+    if (status === 401 || status === 403 || status === 404 || status === 422) {
+      this.fail(
+        resource,
+        status === 404 ? "structure_invalidated" : "book_terminal",
+        error instanceof Error ? error.message : "Book request failed"
+      );
+      this.store.update(resource.input.key, resource.generation, {
+        bookError: error
+      });
+      return true;
+    }
+    this.store.update(resource.input.key, resource.generation, {
+      phase: "degraded_book",
+      bookError: error
+    });
+    if (!isRetryableBookError(error)) return false;
+    if (resource.bookRetryTimer !== void 0) {
+      clearTimeout(resource.bookRetryTimer);
+    }
+    const delay = retryAfterMilliseconds2(error) ?? Math.min(3e4, 1e3 * 2 ** Math.min(resource.bookRetryAttempt, 5));
+    resource.bookRetryAttempt++;
+    resource.bookRetryTimer = setTimeout(() => {
+      resource.bookRetryTimer = void 0;
+      void this.retryBookCatchUp(resource);
+    }, delay);
+    return false;
+  }
+  async retryBookCatchUp(resource) {
+    const key = resource.input.watch.orderbook_market;
+    if (resource.released || !key) return;
+    try {
+      const orderbooks = await this.client.getMarketDataOrderbooks(
+        key.market_slug,
+        key.source
+      );
+      resource.bookRetryAttempt = 0;
+      const state = this.store.get(resource.input.key);
+      this.store.update(resource.input.key, resource.generation, {
+        phase: state.quoteError ? "degraded_quote" : "live",
+        orderbooks,
+        bookError: void 0
+      });
+    } catch (error) {
+      this.handleBookError(resource, error);
+    }
+  }
+  combinedWatchRequest() {
+    const quoteEvents = /* @__PURE__ */ new Map();
+    const quoteMarkets = /* @__PURE__ */ new Map();
+    const orderbookMarkets = /* @__PURE__ */ new Map();
+    for (const resource of this.resources.values()) {
+      if (resource.released) continue;
+      for (const event of resource.input.watch.quote_events ?? []) {
+        quoteEvents.set(
+          `${event.source}\0${event.event_slug}\0${event.market_view}`,
+          event
+        );
+      }
+      for (const market of resource.input.watch.quote_markets ?? []) {
+        quoteMarkets.set(`${market.source}\0${market.market_slug}`, market);
+      }
+      const book = resource.input.watch.orderbook_market;
+      if (book) {
+        orderbookMarkets.set(`${book.source}\0${book.market_slug}`, book);
+      }
+    }
+    if (orderbookMarkets.size > 1) {
+      throw new Error("only one active orderbook market is supported");
+    }
+    return {
+      ...quoteEvents.size ? { quote_events: [...quoteEvents.values()] } : {},
+      ...quoteMarkets.size ? { quote_markets: [...quoteMarkets.values()] } : {},
+      ...orderbookMarkets.size ? { orderbook_market: [...orderbookMarkets.values()][0] } : {}
+    };
+  }
+  fail(resource, code, message) {
+    for (const barrier of resource.barriers.values()) barrier.invalidate();
+    this.store.update(resource.input.key, resource.generation, {
+      phase: "terminal",
+      structureInvalidated: code === "structure_invalidated" || code === "structure_changed",
+      quoteError: { code, message }
+    });
+  }
+  release(key) {
+    const resource = this.resources.get(key);
+    if (resource) this.releaseGeneration(key, resource.generation);
+  }
+  releaseGeneration(key, generation) {
+    const resource = this.resources.get(key);
+    if (!resource || resource.generation !== generation) return;
+    resource.released = true;
+    if (resource.bookRetryTimer !== void 0) {
+      clearTimeout(resource.bookRetryTimer);
+      resource.bookRetryTimer = void 0;
+    }
+    for (const subscription of resource.subscriptions) {
+      subscription.unsubscribe();
+    }
+    for (const barrier of resource.barriers.values()) barrier.invalidate();
+    this.resources.delete(key);
+    this.store.remove(key, generation);
+    if (!this.disposing) this.refreshWatchDemand();
+  }
+  refreshWatchDemand() {
+    if (!this.watchScheduler) return;
+    const request = this.combinedWatchRequest();
+    if (!(request.quote_events?.length ?? 0) && !(request.quote_markets?.length ?? 0) && !request.orderbook_market) {
+      this.watchScheduler.clear();
+      return;
+    }
+    void this.watchScheduler.replace(request).catch(() => void 0);
+  }
+};
+function realtimeMarketKeys(input) {
+  return input.structure.items.flatMap(
+    (item) => item.markets.filter((market) => market.realtime_supported).map((market) => ({
+      source: market.source,
+      market_slug: market.market_slug
+    }))
+  );
+}
+function structuralMarketsForKeys(input, keys) {
+  return keys.map((key) => {
+    const market = input.structure.items.flatMap((item) => item.markets).find(
+      (candidate) => candidate.source === key.source && candidate.market_slug === key.market_slug
+    );
+    if (!market) throw new Error("quote catch-up key is absent from structure");
+    return {
+      source: market.source,
+      market_slug: market.market_slug,
+      outcomes: market.outcomes.map((outcome) => outcome.key)
+    };
+  });
+}
+function chunk(values, size) {
+  const chunks = [];
+  for (let index = 0; index < values.length; index += size) {
+    chunks.push(values.slice(index, index + size));
+  }
+  return chunks;
+}
+function httpStatus(error) {
+  return typeof error === "object" && error !== null && "status" in error && typeof error.status === "number" ? error.status : void 0;
+}
+function isRetryableBookError(error) {
+  const status = httpStatus(error);
+  return status === void 0 || status === 408 || status === 409 || status === 429 || status >= 500;
+}
+function retryAfterMilliseconds2(error) {
+  if (typeof error !== "object" || error === null || !("retryAfter" in error) || typeof error.retryAfter !== "string") {
+    return void 0;
+  }
+  const seconds = Number(error.retryAfter);
+  return Number.isFinite(seconds) && seconds >= 0 ? seconds * 1e3 : void 0;
+}
+function mergeItemChanges(current, changes) {
+  return {
+    ...current,
+    markets: current.markets.map((market) => ({
+      ...market,
+      outcomes: market.outcomes.map((outcome) => {
+        const change = changes.find(
+          (candidate) => candidate.source === outcome.source && candidate.market_slug === outcome.market_slug && candidate.outcome === outcome.outcome
+        );
+        if (!change) return outcome;
+        return {
+          ...outcome,
+          ...change.bba ? { bba: change.bba } : {},
+          ...change.last_trade ? { last_trade: change.last_trade } : {},
+          ...change.tick_size ? { tick_size: change.tick_size } : {}
+        };
+      })
+    }))
+  };
+}
+function mergeQuoteCatchUp(current, catchUp) {
+  if (!current) return catchUp;
+  const identity = (source, slug) => `${source}\0${slug}`;
+  const catchUpByMarket = new Map(
+    catchUp.markets.map((market) => [
+      identity(market.source, market.market_slug),
+      market
+    ])
+  );
+  const merged = current.markets.map(
+    (market) => catchUpByMarket.get(identity(market.source, market.market_slug)) ?? market
+  );
+  const existing = new Set(
+    current.markets.map(
+      (market) => identity(market.source, market.market_slug)
+    )
+  );
+  for (const market of catchUp.markets) {
+    if (!existing.has(identity(market.source, market.market_slug))) {
+      merged.push(market);
+    }
+  }
+  return { schema_version: 1, markets: merged };
+}
+
+// src/market-data/marketDataStore.ts
+var legacyState = (key) => ({
+  key,
+  generation: 0,
+  phase: "legacy"
+});
+var MarketDataStore = class {
+  resources = /* @__PURE__ */ new Map();
+  generations = /* @__PURE__ */ new Map();
+  legacyStates = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Map();
+  get(key) {
+    const existing = this.resources.get(key);
+    if (existing) return existing;
+    let fallback = this.legacyStates.get(key);
+    if (!fallback) {
+      fallback = legacyState(key);
+      this.legacyStates.set(key, fallback);
+    }
+    return fallback;
+  }
+  begin(key, structureETag) {
+    const generation = (this.generations.get(key) ?? 0) + 1;
+    this.generations.set(key, generation);
+    const state = {
+      key,
+      generation,
+      phase: "initializing",
+      structureETag
+    };
+    this.resources.set(key, state);
+    this.emit(key);
+    return state;
+  }
+  update(key, generation, patch) {
+    const current = this.resources.get(key);
+    if (!current || current.generation !== generation) return false;
+    this.resources.set(key, { ...current, ...patch });
+    this.emit(key);
+    return true;
+  }
+  remove(key, generation) {
+    const current = this.resources.get(key);
+    if (!current || current.generation !== generation) return false;
+    this.resources.delete(key);
+    this.emit(key);
+    return true;
+  }
+  subscribe(key, listener) {
+    let listeners = this.listeners.get(key);
+    if (!listeners) {
+      listeners = /* @__PURE__ */ new Set();
+      this.listeners.set(key, listeners);
+    }
+    listeners.add(listener);
+    return () => {
+      listeners?.delete(listener);
+      if (listeners?.size === 0) this.listeners.delete(key);
+    };
+  }
+  emit(key) {
+    for (const listener of this.listeners.get(key) ?? []) listener();
+  }
+};
 var PredictContext = react.createContext(null);
 function PredictProvider({
   client,
@@ -1015,6 +2393,43 @@ function PredictProvider({
   return /* @__PURE__ */ jsxRuntime.jsx(PredictContext.Provider, { value, children });
 }
 
+// src/market-data/adapters/create-client-market-venue-adapter.ts
+function createClientMarketVenueAdapter(client) {
+  return {
+    watchMarketData: (request) => client.watchMarketData(request),
+    getMarketDataQuotes: (markets) => client.getMarketDataQuotes(markets),
+    getMarketDataOrderbooks: (slug, source) => client.getMarketDataOrderbooks(slug, source),
+    getMarketStructure: (path, ifNoneMatch) => client.getMarketStructure(path, ifNoneMatch)
+  };
+}
+var MarketDataContext = react.createContext(
+  null
+);
+function MarketDataProvider({
+  capability,
+  client,
+  transportFactory,
+  children
+}) {
+  const store = react.useMemo(() => new MarketDataStore(), []);
+  const venue = react.useMemo(() => createClientMarketVenueAdapter(client), [client]);
+  const runtime = react.useMemo(
+    () => new MarketDataRuntime({
+      enabled: capability.enabled,
+      client: venue,
+      store,
+      transportFactory
+    }),
+    [capability.enabled, venue, store, transportFactory]
+  );
+  react.useEffect(() => () => runtime.dispose(), [runtime]);
+  const value = react.useMemo(
+    () => ({ capability, client, store, runtime }),
+    [capability, client, store, runtime]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(MarketDataContext.Provider, { value, children });
+}
+
 // src/utils/polymarket-hmac.ts
 function encode(str) {
   return new TextEncoder().encode(str);
@@ -1200,6 +2615,47 @@ function usePredictClient() {
   }
   return context.client;
 }
+function useMarketDataCapability() {
+  const context = react.useContext(MarketDataContext);
+  if (!context) {
+    throw new Error(
+      "useMarketDataCapability must be used within a MarketDataProvider"
+    );
+  }
+  return context.capability;
+}
+function useMarketDataResource(input) {
+  const context = react.useContext(MarketDataContext);
+  if (!context) {
+    throw new Error(
+      "useMarketDataResource must be used within a MarketDataProvider"
+    );
+  }
+  const key = typeof input === "string" ? input : input.key;
+  react.useEffect(() => {
+    if (typeof input === "string" || !context.capability.enabled) return;
+    return context.runtime.mount(input);
+  }, [context.capability.enabled, context.runtime, input]);
+  const subscribe = react.useCallback(
+    (listener) => context.store.subscribe(key, listener),
+    [context.store, key]
+  );
+  const getSnapshot = react.useCallback(
+    () => context.store.get(key),
+    [context.store, key]
+  );
+  return react.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}
+
+// src/hooks/predict/useMarketDataOrderbooks.ts
+function useMarketDataOrderbooks(resourceKey) {
+  const resource = useMarketDataResource(resourceKey);
+  return {
+    snapshot: resource.orderbooks,
+    live: resource.liveBook,
+    error: resource.bookError
+  };
+}
 function eventsQueryKey(params) {
   return ["predict", "events", params ?? {}];
 }
@@ -1592,6 +3048,7 @@ function useRealtimeOrderbook(params, queryOptions = {}) {
   const { wsClient } = usePredictWsClient();
   const queryClient = reactQuery.useQueryClient();
   const outcome = params.outcome ?? "yes";
+  const enabled = queryOptions.enabled !== false && Boolean(params.slug);
   const handleUpdate = react.useCallback(
     (msg) => {
       if (msg.data.market_slug !== params.slug) return;
@@ -1613,7 +3070,7 @@ function useRealtimeOrderbook(params, queryOptions = {}) {
   const subParams = {
     wsClient,
     slug: params.slug,
-    enabled: Boolean(params.slug),
+    enabled,
     outcome,
     onUpdate: handleUpdate
   };
@@ -2797,7 +4254,7 @@ function useRunPolymarketSetup(walletAddress) {
     mutationFn: (address) => client.runPolymarketSetup(address),
     onSuccess: () => {
       if (walletAddress) {
-        queryClient.invalidateQueries({
+        void queryClient.invalidateQueries({
           queryKey: polymarketSetupQueryKey(walletAddress)
         });
       }
@@ -2811,7 +4268,7 @@ function useDeployPolymarketDepositWallet(walletAddress) {
     mutationFn: (address) => client.deployPolymarketDepositWallet(address),
     onSuccess: () => {
       if (walletAddress) {
-        queryClient.invalidateQueries({
+        void queryClient.invalidateQueries({
           queryKey: polymarketSetupQueryKey(walletAddress)
         });
       }
@@ -2831,8 +4288,8 @@ function useWithdrawSubmitMutation(mutationOptions = {}) {
   return reactQuery.useMutation({
     mutationFn: (body) => client.withdrawSubmit(body),
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["predict", "balance"] });
-      queryClient.invalidateQueries({ queryKey: ["predict", "positions"] });
+      void queryClient.invalidateQueries({ queryKey: ["predict", "balance"] });
+      void queryClient.invalidateQueries({ queryKey: ["predict", "positions"] });
     },
     ...mutationOptions
   });
@@ -2897,7 +4354,7 @@ function usePolymarketDeposit(mutationOptions = {}) {
       };
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["predict", "balance"] });
+      void queryClient.invalidateQueries({ queryKey: ["predict", "balance"] });
     },
     ...mutationOptions
   });
@@ -3102,11 +4559,12 @@ function usePricesSubscription({
     onUpdateRef.current?.(msg);
   }, []);
   react.useEffect(() => {
-    if (!wsClient || !enabled || slugs.length === 0) {
+    const slugList = slugsKey.length === 0 ? [] : slugsKey.split(",");
+    if (!wsClient || !enabled || slugList.length === 0) {
       setIsSubscribed(false);
       return;
     }
-    const unsub = wsClient.subscribePrices(slugs, handleUpdate);
+    const unsub = wsClient.subscribePrices(slugList, handleUpdate);
     setIsSubscribed(true);
     return () => {
       unsub();
@@ -3676,11 +5134,146 @@ function walkOrderbook({
   };
 }
 
+// src/utils/order-intent-runtime.ts
+var PredictionOrderRejectedError = class extends Error {
+  constructor(message = "prediction order rejected") {
+    super(message);
+    this.name = "PredictionOrderRejectedError";
+  }
+};
+function createPredictionOrderRuntime(options) {
+  let current = { status: "idle" };
+  const accepted = /* @__PURE__ */ new Set();
+  const confirmTimeoutMs = options.confirmTimeoutMs ?? 3e4;
+  const clock = options.clock ?? { now: () => Date.now() };
+  const set = (next) => {
+    current = next;
+    options.onChange?.(next);
+    return next;
+  };
+  return {
+    snapshot() {
+      return current;
+    },
+    cancel() {
+      if (current.status === "succeeded" || current.status === "confirming" || current.status === "submitting") {
+        return current;
+      }
+      return set({ status: "cancelled", intent: current.intent });
+    },
+    async submit(intent) {
+      if (accepted.has(intent.id)) {
+        return current.status === "idle" ? set({ status: "succeeded", intent, acceptedId: intent.id }) : current;
+      }
+      if (current.intent?.id === intent.id && (current.status === "submitting" || current.status === "confirming" || current.status === "succeeded")) {
+        return current;
+      }
+      set({ status: "validating", intent });
+      if (intent.venue === "kalshi") {
+        const verified = options.kyc ? await options.kyc.verified() : false;
+        if (!verified) {
+          return set({ status: "needs-kyc", intent });
+        }
+      }
+      if (intent.venue === "polymarket") {
+        const verified = options.setup ? await options.setup.verified() : false;
+        if (!verified) {
+          return set({ status: "needs-setup", intent });
+        }
+      }
+      if (!options.signer) {
+        return set({
+          status: "failed",
+          intent,
+          error: new PredictionOrderRejectedError("missing signer")
+        });
+      }
+      set({ status: "signing", intent });
+      let signed;
+      try {
+        signed = await options.signer.sign(intent);
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        return set({ status: "failed", intent, error: err });
+      }
+      set({ status: "submitting", intent });
+      let acceptedId;
+      try {
+        const result = await options.execution.submit(intent, signed);
+        if (!result.accepted) {
+          return set({
+            status: "failed",
+            intent,
+            error: new PredictionOrderRejectedError()
+          });
+        }
+        acceptedId = result.id ?? intent.id;
+        accepted.add(intent.id);
+        accepted.add(acceptedId);
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        return set({ status: "failed", intent, error: err });
+      }
+      set({ status: "confirming", intent, acceptedId });
+      if (!options.confirmation) {
+        return set({ status: "succeeded", intent, acceptedId });
+      }
+      const deadline = clock.now() + confirmTimeoutMs;
+      const outcome = await options.confirmation.wait(acceptedId, {
+        timedOut: () => clock.now() >= deadline
+      });
+      if (outcome === "timed-out") {
+        return set({ status: "timed-out", intent, acceptedId });
+      }
+      return set({ status: "succeeded", intent, acceptedId });
+    }
+  };
+}
+
+// src/utils/in-memory-order-ports.ts
+function createInMemoryOrderPorts(options = {}) {
+  let submits = 0;
+  return {
+    signer: {
+      async sign(intent) {
+        if (options.signError) throw options.signError;
+        return { signed: intent.id };
+      }
+    },
+    execution: {
+      async submit(intent) {
+        submits += 1;
+        return {
+          accepted: options.accept !== false,
+          id: intent.id
+        };
+      }
+    },
+    confirmation: {
+      async wait(_acceptedId, signal) {
+        if (signal.timedOut() || options.confirm === "timed-out") {
+          return "timed-out";
+        }
+        return "confirmed";
+      }
+    },
+    submitCount: () => submits
+  };
+}
+
 exports.CLOB_AUTH_DOMAIN = CLOB_AUTH_DOMAIN;
 exports.CLOB_AUTH_TYPES = CLOB_AUTH_TYPES;
 exports.CTF_EXCHANGE_ADDRESS = CTF_EXCHANGE_ADDRESS;
 exports.CTF_ORDER_TYPES = CTF_ORDER_TYPES;
 exports.ChartRange = ChartRange;
+exports.MARKET_DATA_BACKEND_CONTRACT_COMMIT = MARKET_DATA_BACKEND_CONTRACT_COMMIT;
+exports.MARKET_DATA_CONTRACT_MANIFEST_SHA256 = MARKET_DATA_CONTRACT_MANIFEST_SHA256;
+exports.MARKET_STRUCTURE_MEDIA_TYPE_V1 = MARKET_STRUCTURE_MEDIA_TYPE_V1;
+exports.MarketDataHttpError = MarketDataHttpError;
+exports.MarketDataProvider = MarketDataProvider;
+exports.MarketDataRuntime = MarketDataRuntime;
+exports.MarketDataStore = MarketDataStore;
+exports.MarketDataWatchScheduler = MarketDataWatchScheduler;
 exports.NEG_RISK_CTF_EXCHANGE_ADDRESS = NEG_RISK_CTF_EXCHANGE_ADDRESS;
 exports.ORDER_TYPE = ORDER_TYPE;
 exports.POLYGON_CHAIN_ID = POLYGON_CHAIN_ID;
@@ -3690,8 +5283,12 @@ exports.PredictClient = PredictClient;
 exports.PredictContext = PredictContext;
 exports.PredictProvider = PredictProvider;
 exports.PredictWsClient = PredictWsClient;
+exports.PredictionOrderRejectedError = PredictionOrderRejectedError;
+exports.RecoveryBarrier = RecoveryBarrier;
 exports.SIDE = SIDE;
 exports.USDC_ADDRESS = USDC_ADDRESS;
+exports.assertMarketDataBBAComponent = assertMarketDataBBAComponent;
+exports.assertMarketDataValueComponent = assertMarketDataValueComponent;
 exports.availableSharesQueryKey = availableSharesQueryKey;
 exports.balanceQueryKey = balanceQueryKey;
 exports.buildClobAuthMessage = buildClobAuthMessage;
@@ -3702,8 +5299,14 @@ exports.buildPolymarketL2Headers = buildPolymarketL2Headers;
 exports.buildSignedOrder = buildSignedOrder;
 exports.buildSignedV2OrderPayload = buildSignedV2OrderPayload;
 exports.candlesticksQueryKey = candlesticksQueryKey;
+exports.chunkWatchRequest = chunkWatchRequest;
+exports.comparePublicationCursor = comparePublicationCursor;
+exports.createInMemoryOrderPorts = createInMemoryOrderPorts;
 exports.createPredictClient = createPredictClient;
 exports.createPredictWsClient = createPredictWsClient;
+exports.createPredictionOrderRuntime = createPredictionOrderRuntime;
+exports.decodeBookEnvelope = decodeBookEnvelope;
+exports.decodeItemEnvelope = decodeItemEnvelope;
 exports.derivePolymarketApiKey = derivePolymarketApiKey;
 exports.dflowKYCQueryKey = dflowKYCQueryKey;
 exports.dflowQuoteQueryKey = dflowQuoteQueryKey;
@@ -3746,6 +5349,7 @@ exports.orderQueryKey = orderQueryKey;
 exports.orderbookQueryKey = orderbookQueryKey;
 exports.ordersMultiQueryKey = ordersMultiQueryKey;
 exports.ordersQueryKey = ordersQueryKey;
+exports.parseInitialQuotes = parseInitialQuotes;
 exports.pickBestAsk = pickBestAsk;
 exports.pickBestBid = pickBestBid;
 exports.polymarketDepositAddressesQueryKey = polymarketDepositAddressesQueryKey;
@@ -3795,6 +5399,9 @@ exports.useInfinitePredictSearch = useInfinitePredictSearch;
 exports.useInfiniteTrades = useInfiniteTrades;
 exports.useInfiniteTradesMulti = useInfiniteTradesMulti;
 exports.useMarket = useMarket;
+exports.useMarketDataCapability = useMarketDataCapability;
+exports.useMarketDataOrderbooks = useMarketDataOrderbooks;
+exports.useMarketDataResource = useMarketDataResource;
 exports.useMarketHistory = useMarketHistory;
 exports.useMarketTrades = useMarketTrades;
 exports.useMatch = useMatch;