perp-cli 0.14.2 → 0.15.0

package/dist/ws/node.js

@@ -0,0 +1,4366 @@
+import { createRequire } from 'node:module';
+
+// src/ws/node.ts
+
+// src/ws/errors.ts
+var WS_ERROR_CODES = {
+  WS_PROTOCOL_ERROR: { status: 502, retryable: false },
+  WS_AUTH_FAILED: { status: 401, retryable: false },
+  SUBSCRIPTION_LIMIT: { status: 400, retryable: false },
+  STREAM_OVERFLOW: { status: 507, retryable: false },
+  CAPABILITY_UNSUPPORTED: { status: 400, retryable: false },
+  EXCHANGE_UNREACHABLE: { status: 503, retryable: true },
+  INVALID_PARAMS: { status: 400, retryable: false },
+  RATE_LIMITED: { status: 429, retryable: true },
+  EXCHANGE_ERROR: { status: 502, retryable: true },
+  SYMBOL_NOT_FOUND: { status: 404, retryable: false }
+};
+var WsError = class extends Error {
+  constructor(code, message, opts) {
+    super(message);
+    this.name = "WsError";
+    this.structured = {
+      code,
+      message,
+      status: WS_ERROR_CODES[code].status,
+      retryable: WS_ERROR_CODES[code].retryable,
+      ...opts?.exchange !== void 0 ? { exchange: opts.exchange } : {},
+      ...opts?.remediation !== void 0 ? { remediation: opts.remediation } : {},
+      ...opts?.details !== void 0 ? { details: opts.details } : {}
+    };
+  }
+};
+function isPerpError(e) {
+  if (e === null || typeof e !== "object") return false;
+  const s = e.structured;
+  if (s === null || typeof s !== "object") return false;
+  return typeof s.code === "string" && typeof s.message === "string";
+}
+
+// src/ws/canonical.ts
+var USD_LIKE_QUOTES = /* @__PURE__ */ new Set(["USDT", "USD1", "USDC", "USD", "USDG"]);
+var defaultCanonicalize = (_venue, m) => {
+  const base = m.base.toUpperCase();
+  if (m.dex !== null && m.dex !== "") return `${m.dex}:${base}`;
+  if (m.quote === null) return null;
+  return USD_LIKE_QUOTES.has(m.quote.toUpperCase()) ? base : null;
+};
+
+// src/ws/transport.ts
+function resolveTransport(opts, venue) {
+  if (opts.transport !== void 0) return opts.transport;
+  const Ctor = globalThis.WebSocket;
+  if (typeof Ctor !== "function") {
+    throw new WsError("INVALID_PARAMS", "No global WebSocket in this runtime (Node 20 has none)", {
+      exchange: venue,
+      remediation: "import from the /node entry (perp-cli/ws/node or @hypurrquant/perp-ws/node) or pass transport"
+    });
+  }
+  return (url) => {
+    const ws = new Ctor(url);
+    ws.binaryType = "arraybuffer";
+    return ws;
+  };
+}
+function resolveFetch(opts, venue) {
+  if (opts.fetch !== void 0) return opts.fetch;
+  const f = globalThis.fetch;
+  if (typeof f !== "function") {
+    throw new WsError("INVALID_PARAMS", "No global fetch in this runtime (needed for the market directory bootstrap)", {
+      exchange: venue,
+      remediation: "pass opts.fetch"
+    });
+  }
+  return (input, init) => f(input, init);
+}
+function frameText(data2) {
+  if (typeof data2 === "string") return data2;
+  const TD = globalThis.TextDecoder;
+  if (TD === void 0) return null;
+  if (data2 instanceof ArrayBuffer) return new TD().decode(data2);
+  if (ArrayBuffer.isView(data2)) return new TD().decode(new Uint8Array(data2.buffer, data2.byteOffset, data2.byteLength));
+  return null;
+}
+function defaultVisibility() {
+  const doc = globalThis.document;
+  if (doc === void 0 || typeof doc.visibilityState !== "string" || typeof doc.addEventListener !== "function") return null;
+  return {
+    hidden: () => doc.visibilityState === "hidden",
+    onChange: (cb) => {
+      doc.addEventListener?.("visibilitychange", cb);
+      return () => doc.removeEventListener?.("visibilitychange", cb);
+    }
+  };
+}
+
+// src/ws/connection.ts
+var HANDSHAKE_REMEDIATION = "connection refused before open \u2014 network, venue outage, or Origin/CORS block (see capability matrix: browser)";
+var MAX_PAYLOAD_REMEDIATION = "Raise the cap: createVenueStream(codec, { transport: createNodeTransport({ maxPayload: bytes }) }) from the /node entry";
+function isMaxPayloadError(e) {
+  return e !== null && typeof e === "object" && e.code === "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH";
+}
+var STALE_TICK_MS = 1e3;
+var Connection = class {
+  constructor(o, h) {
+    this.o = o;
+    this.h = h;
+    this.state = { status: "idle" };
+    this.ws = null;
+    this.opened = false;
+    /** Consecutive failed attempts. Reset by the first data frame (markHealthy), not by open: a venue
+     * that accepts and then drops the socket must still exhaust reconnect.maxAttempts. */
+    this.attempt = 0;
+    this.sendTimes = [];
+    this.sendQueue = [];
+    this.sendTimer = null;
+    this.reconnectTimer = null;
+    this.staleTimer = null;
+    this.pingTimer = null;
+    this.awaitingPongSince = null;
+    this.visibilityOff = null;
+    this.terminal = false;
+    if (o.visibility !== null) {
+      const vis = o.visibility;
+      this.visibilityOff = vis.onChange(() => {
+        if (!vis.hidden()) this.onVisible();
+      });
+    }
+  }
+  get isOpen() {
+    return this.ws !== null && this.opened;
+  }
+  /** Open the socket when idle (lazily, on the first wire subscription). */
+  ensureOpen() {
+    if (this.terminal) return;
+    if (this.state.status === "idle") this.connectWithBudget();
+  }
+  send(msg) {
+    if (!this.isOpen) return;
+    this.sendQueue.push(msg);
+    this.flush();
+  }
+  /** A data frame arrived on this socket: the connection works, reset the failure count. */
+  markHealthy() {
+    if (this.isOpen) this.attempt = 0;
+  }
+  notePong() {
+    this.awaitingPongSince = null;
+  }
+  /** Re-check staleness now (also called when a stale channel receives a frame). */
+  evaluate() {
+    if (!this.isOpen) return;
+    const now = this.o.clock();
+    let worst = null;
+    for (const w of this.h.liveness()) {
+      if (w.staleAfterMs === null) continue;
+      const silent = now - w.lastAt;
+      const ratio = silent / w.staleAfterMs;
+      if (worst === null || ratio > worst.ratio) worst = { key: w.key, silent, ratio, stale: w.staleAfterMs };
+    }
+    if (worst !== null && worst.ratio > 2) {
+      this.forceReconnect({
+        code: "EXCHANGE_UNREACHABLE",
+        message: `No message on ${worst.key} for ${worst.silent} ms (> 2 \xD7 staleAfterMs ${worst.stale})`,
+        wsCode: null,
+        remediation: "Reconnecting automatically; check the network or venue status if it persists"
+      });
+      return;
+    }
+    if (worst !== null && worst.ratio > 1) {
+      if (this.state.status !== "stale" || this.state.channel !== worst.key) {
+        this.setState({ status: "stale", since: now - worst.silent + worst.stale, silentMs: worst.silent, channel: worst.key });
+      }
+      return;
+    }
+    if (this.state.status === "stale") this.setState({ status: "live", since: now, sockets: 1 });
+  }
+  /** Idle, with a connect deferred by the new-connection budget (ensureOpen while the budget was spent). */
+  get waiting() {
+    return !this.terminal && this.state.status === "idle" && this.reconnectTimer !== null;
+  }
+  /** Close the socket because no wire subscription is left; state → idle. Idle with a deferred
+   * connect (waiting): the connect is cancelled, so no socket opens without channels. */
+  closeIdle() {
+    if (this.terminal) return;
+    if (this.state.status === "idle") {
+      if (this.reconnectTimer !== null) {
+        clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+      }
+      return;
+    }
+    this.teardown(1e3, "idle");
+    this.attempt = 0;
+    this.setState({ status: "idle" });
+  }
+  close() {
+    if (this.terminal) return;
+    this.terminal = true;
+    this.teardown(1e3, "client close");
+    if (this.visibilityOff !== null) {
+      this.visibilityOff();
+      this.visibilityOff = null;
+    }
+    this.setState({ status: "closed", reason: { code: "CLIENT_CLOSE", message: "closed by the client", wsCode: null, remediation: null } });
+  }
+  /** A fatal stop that is not a client close (e.g. reconnect attempts exhausted). */
+  fail(reason) {
+    if (this.terminal) return;
+    this.terminal = true;
+    this.teardown(1e3, "fatal");
+    if (this.visibilityOff !== null) {
+      this.visibilityOff();
+      this.visibilityOff = null;
+    }
+    this.setState({ status: "closed", reason });
+  }
+  // ── internals ──
+  setState(s) {
+    this.state = s;
+    this.h.log(
+      s.status === "closed" && s.reason.code !== "CLIENT_CLOSE" ? "error" : s.status === "reconnecting" || s.status === "stale" ? "warn" : "info",
+      "state",
+      `state \u2192 ${s.status}`,
+      stateDetails(s)
+    );
+    this.h.onState(s);
+  }
+  budgetDelay(now) {
+    const log = this.o.connectLog;
+    while (log.length > 0 && now - log[0] >= 6e4) log.shift();
+    if (log.length < this.o.newConnectionsPerMin) return 0;
+    return log[0] + 6e4 - now;
+  }
+  connectWithBudget() {
+    const now = this.o.clock();
+    const wait = this.budgetDelay(now);
+    if (wait > 0) {
+      this.h.log("warn", "connection-budget", `new-connection budget (${this.o.newConnectionsPerMin}/min) reached; delaying ${wait} ms`);
+      this.scheduleConnect(wait);
+      return;
+    }
+    this.connect();
+  }
+  scheduleConnect(ms) {
+    if (this.reconnectTimer !== null) clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      if (this.terminal) return;
+      this.connectWithBudget();
+    }, ms);
+  }
+  connect() {
+    this.o.connectLog.push(this.o.clock());
+    this.setState({ status: "connecting", attempt: this.attempt + 1 });
+    this.opened = false;
+    let ws;
+    try {
+      ws = this.o.transport(this.o.url);
+    } catch (e) {
+      if (isPerpError(e) && e.structured.retryable === false) {
+        const st = e.structured;
+        const code = st.code in WS_ERROR_CODES ? st.code : "INVALID_PARAMS";
+        this.fail({
+          code,
+          message: this.o.redact(`WebSocket transport failed: ${st.message}`),
+          wsCode: null,
+          remediation: typeof st.remediation === "string" ? this.o.redact(st.remediation) : null
+        });
+        return;
+      }
+      this.handleClose({
+        code: "EXCHANGE_UNREACHABLE",
+        message: this.o.redact(`WebSocket constructor failed: ${e instanceof Error ? e.message : String(e)}`),
+        wsCode: null,
+        remediation: HANDSHAKE_REMEDIATION
+      });
+      return;
+    }
+    this.ws = ws;
+    let socketError = null;
+    ws.onopen = () => {
+      if (this.ws !== ws) return;
+      this.opened = true;
+      this.awaitingPongSince = null;
+      this.setState({ status: "live", since: this.o.clock(), sockets: 1 });
+      this.startTimers();
+      this.h.onOpen();
+    };
+    ws.onmessage = (ev) => {
+      if (this.ws !== ws) return;
+      const recvTs = this.o.clock();
+      const text = frameText(ev.data);
+      if (text === null) this.h.onUnreadableFrame(recvTs);
+      else this.h.onText(text, recvTs);
+    };
+    ws.onerror = (ev) => {
+      if (this.ws !== ws) return;
+      socketError = ev;
+      this.h.log("warn", "socket-error", isMaxPayloadError(ev) ? "inbound message exceeded the transport's maxPayload (WS_ERR_UNSUPPORTED_MESSAGE_LENGTH); a close follows" : "socket error event (a close follows)");
+    };
+    ws.onclose = (ev) => {
+      if (this.ws !== ws) return;
+      const wasOpen = this.opened;
+      this.detach();
+      const tooLarge = isMaxPayloadError(socketError);
+      const reason = tooLarge ? {
+        code: "WS_PROTOCOL_ERROR",
+        message: `Socket closed: an inbound message exceeded the transport's maxPayload (WS_ERR_UNSUPPORTED_MESSAGE_LENGTH, sent close 1009)`,
+        wsCode: 1009,
+        remediation: MAX_PAYLOAD_REMEDIATION
+      } : wasOpen ? {
+        code: "EXCHANGE_UNREACHABLE",
+        message: this.o.redact(`Socket closed by the venue (code ${ev.code}${ev.reason ? `, ${ev.reason}` : ""})`),
+        wsCode: ev.code,
+        remediation: "Reconnecting automatically"
+      } : {
+        code: "EXCHANGE_UNREACHABLE",
+        message: this.o.redact(`Handshake failed before open (code ${ev.code}${ev.reason ? `, ${ev.reason}` : ""})`),
+        wsCode: ev.code,
+        remediation: HANDSHAKE_REMEDIATION
+      };
+      if (this.h.onUnexpectedClose(reason, wasOpen, tooLarge)) return;
+      this.handleClose(reason);
+    };
+  }
+  handleClose(reason) {
+    if (this.terminal) return;
+    if (this.state.status === "idle") return;
+    this.attempt++;
+    const max = this.o.reconnect.maxAttempts;
+    if (max !== null && this.attempt > max) {
+      this.fail({ ...reason, message: `${reason.message}; reconnect attempts exhausted (${max})` });
+      return;
+    }
+    const exp = Math.min(this.o.reconnect.maxMs, this.o.reconnect.baseMs * Math.pow(2, this.attempt - 1));
+    const backoff = Math.round(exp / 2 + this.o.random() * (exp / 2));
+    const inMs = Math.max(backoff, this.budgetDelay(this.o.clock()));
+    this.setState({ status: "reconnecting", attempt: this.attempt, inMs, reason });
+    this.scheduleConnect(inMs);
+  }
+  /** Stale / missed pong: drop the socket ourselves (HL never answers a client close) and reconnect. */
+  forceReconnect(reason) {
+    if (this.terminal || this.ws === null) return;
+    this.h.log("warn", "force-reconnect", reason.message);
+    this.teardown(4e3, "stale");
+    this.handleClose(reason);
+  }
+  startTimers() {
+    this.staleTimer = setInterval(() => this.evaluate(), STALE_TICK_MS);
+    const ping = this.o.ping;
+    if (ping !== null) {
+      this.pingTimer = setInterval(() => this.pingTick(), ping.everyMs);
+    }
+  }
+  pingTick() {
+    if (!this.isOpen || this.o.ping === null) return;
+    if (this.awaitingPongSince !== null) {
+      this.forceReconnect({
+        code: "EXCHANGE_UNREACHABLE",
+        message: `No pong within ${this.o.ping.everyMs} ms`,
+        wsCode: null,
+        remediation: "Reconnecting automatically"
+      });
+      return;
+    }
+    this.awaitingPongSince = this.o.clock();
+    this.send(this.o.ping.message);
+  }
+  onVisible() {
+    if (!this.isOpen) return;
+    this.h.log("info", "visible", "tab visible: re-evaluating staleness");
+    this.evaluate();
+    if (this.isOpen && this.o.ping !== null && this.awaitingPongSince === null) {
+      this.awaitingPongSince = this.o.clock();
+      this.send(this.o.ping.message);
+    }
+  }
+  flush() {
+    if (this.sendTimer !== null) return;
+    const ws = this.ws;
+    while (this.sendQueue.length > 0 && ws !== null && this.opened) {
+      const now = this.o.clock();
+      this.sendTimes = this.sendTimes.filter((t) => now - t < 6e4);
+      if (this.sendTimes.length >= this.o.outboundPerMin) {
+        const wait = this.sendTimes[0] + 6e4 - now;
+        this.h.log("warn", "outbound-limit", `outbound limit (${this.o.outboundPerMin}/min) reached; ${this.sendQueue.length} queued for ${wait} ms`);
+        this.sendTimer = setTimeout(() => {
+          this.sendTimer = null;
+          this.flush();
+        }, wait);
+        return;
+      }
+      const msg = this.sendQueue.shift();
+      this.sendTimes.push(now);
+      try {
+        ws.send(msg);
+      } catch (e) {
+        this.h.log("warn", "send-failed", this.o.redact(`send failed: ${e instanceof Error ? e.message : String(e)}`));
+      }
+    }
+  }
+  detach() {
+    const ws = this.ws;
+    if (ws !== null) {
+      ws.onopen = null;
+      ws.onmessage = null;
+      ws.onerror = null;
+      ws.onclose = null;
+    }
+    const wasSocket = ws !== null;
+    this.ws = null;
+    this.opened = false;
+    this.awaitingPongSince = null;
+    this.sendQueue = [];
+    if (this.sendTimer !== null) {
+      clearTimeout(this.sendTimer);
+      this.sendTimer = null;
+    }
+    if (this.staleTimer !== null) {
+      clearInterval(this.staleTimer);
+      this.staleTimer = null;
+    }
+    if (this.pingTimer !== null) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+    if (wasSocket) this.h.onSocketDown();
+  }
+  teardown(code, reason) {
+    if (this.reconnectTimer !== null) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    const ws = this.ws;
+    this.detach();
+    if (ws !== null) {
+      try {
+        ws.close(code, reason);
+      } catch {
+      }
+    }
+  }
+};
+function stateDetails(s) {
+  const { status: _status, ...rest } = s;
+  return rest;
+}
+function closedError(venue) {
+  return new WsError("INVALID_PARAMS", `${venue} stream is closed`, { exchange: venue, remediation: "Create a new stream" });
+}
+
+// src/ws/ids.ts
+var VENUE_IDS = [
+  "pacifica",
+  "hyperliquid",
+  "lighter",
+  "aster",
+  "lighter-rh",
+  "ondo",
+  "arcus",
+  "qfex"
+];
+
+// src/ws/market-state.ts
+var PATCH_FIELDS = [
+  "mark",
+  "index",
+  "bestBid",
+  "bestAsk",
+  "last",
+  "rate",
+  "predictedRate",
+  "nextFundingTime",
+  "openInterest",
+  "volume24hNotional"
+];
+var MarketStore = class {
+  constructor(codec, dir) {
+    this.codec = codec;
+    this.dir = dir;
+    this.rows = /* @__PURE__ */ new Map();
+    this.bySymbol = new Map(dir.entries.map((e) => [e.symbol, e]));
+  }
+  entry(symbol) {
+    return this.bySymbol.get(symbol);
+  }
+  /** Apply one patch; undefined when the symbol is not in the directory (caller reports it). */
+  apply(patch, recvTs, source) {
+    const entry = this.bySymbol.get(patch.symbol);
+    if (entry === void 0) return void 0;
+    let row = this.rows.get(patch.symbol);
+    if (row === void 0) {
+      row = {
+        entry,
+        values: {
+          mark: null,
+          index: null,
+          bestBid: null,
+          bestAsk: null,
+          last: null,
+          rate: null,
+          predictedRate: null,
+          nextFundingTime: null,
+          openInterest: null,
+          volume24hNotional: null
+        },
+        intervalKey: null,
+        venueTs: null,
+        asOf: {}
+      };
+      this.rows.set(patch.symbol, row);
+    }
+    const changed = [];
+    for (const f of PATCH_FIELDS) {
+      if (!(f in patch)) continue;
+      const v2 = patch[f];
+      if (v2 === void 0) continue;
+      if (row.values[f] !== v2) changed.push(f);
+      row.values[f] = v2;
+      row.asOf[f] = recvTs;
+    }
+    const meta = this.codec.fundingMeta(entry, this.dir);
+    const intervalKey = `${meta.rateIntervalHours}|${meta.settlementIntervalHours}|${meta.intervalSource}`;
+    if (meta.intervalAsOf !== null) row.asOf.fundingInterval = meta.intervalAsOf;
+    if (row.intervalKey !== intervalKey) {
+      if (row.intervalKey !== null || meta.rateIntervalHours !== null) changed.push("fundingInterval");
+      row.intervalKey = intervalKey;
+    }
+    if (patch.venueTs !== null) row.venueTs = patch.venueTs;
+    const v = row.values;
+    return {
+      type: "market",
+      schema: 1,
+      venue: entry.venue,
+      dex: entry.dex,
+      symbol: entry.symbol,
+      venueSymbol: entry.venueSymbol,
+      quote: entry.quote,
+      canonical: entry.canonical,
+      mark: v.mark,
+      index: v.index,
+      bestBid: v.bestBid,
+      bestAsk: v.bestAsk,
+      last: v.last,
+      funding: {
+        rate: v.rate,
+        rateKind: meta.rateKind,
+        rateSource: meta.rateSource,
+        rateIntervalHours: meta.rateIntervalHours,
+        settlementIntervalHours: meta.settlementIntervalHours,
+        intervalSource: meta.intervalSource,
+        nextFundingTime: v.nextFundingTime,
+        predictedRate: v.predictedRate,
+        marketClosed: meta.marketClosed
+      },
+      openInterest: {
+        value: v.openInterest,
+        unit: this.codec.openInterest.unit,
+        sides: this.codec.openInterest.sides
+      },
+      volume24hNotional: v.volume24hNotional,
+      venueTs: row.venueTs,
+      recvTs,
+      source,
+      changed,
+      asOf: { ...row.asOf }
+    };
+  }
+};
+
+// src/ws/redact.ts
+var BASE_SECRET_KEYS = [
+  "auth",
+  "authorization",
+  "token",
+  "authToken",
+  "auth-token",
+  "auth_token",
+  "access-token",
+  "access_token",
+  "accessToken",
+  "listenKey",
+  "listen-key",
+  "signature",
+  "sig",
+  "hmac",
+  "apiKey",
+  "api_key",
+  "api-key",
+  "x-api-key",
+  "secret",
+  "secretKey",
+  "secret_key",
+  "secret-key",
+  "privateKey",
+  "private_key",
+  "private-key",
+  "password",
+  "passphrase"
+];
+var REDACTED = "<redacted>";
+var RAW_EXCERPT_MAX = 200;
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function createRedactor(secretKeys, urlPatterns = []) {
+  const keys = Array.from(/* @__PURE__ */ new Set([...BASE_SECRET_KEYS, ...secretKeys])).map(escapeRe).join("|");
+  const K = `(?<![A-Za-z0-9_])(?:${keys})(?![A-Za-z0-9_])`;
+  const nested = `\\[(?:[^\\[\\]]|\\[[^\\[\\]]*\\])*\\]|\\{(?:[^{}]|\\{[^{}]*\\})*\\}`;
+  const json = new RegExp(`("(?:${keys})"\\s*:\\s*)("(?:[^"\\\\]|\\\\.)*"|${nested}|-?\\d[\\d.eE+-]*|true|false)`, "gi");
+  const escaped = new RegExp(`((\\\\+)"(?:${keys})\\\\+"\\s*:\\s*)(?:\\\\+"(?:(?!\\\\+").)*\\\\+"|\\[[^\\]]*\\]|\\{[^}]*\\}|-?\\d[\\d.eE+-]*|true|false)`, "gi");
+  const query = new RegExp(`([?&]${K}=)[^&#\\s"'\\\\]*`, "gi");
+  const encoded = new RegExp(`(${K}%3D)(?:[A-Za-z0-9._~+/-]|%(?!26)[0-9A-Fa-f]{2})*`, "gi");
+  const quotedText = new RegExp(`(${K}\\s*[=:]\\s*)(\\\\*["'])(?:(?!\\2).)*\\2`, "gi");
+  const text = new RegExp(`(${K}\\s*[=:]\\s*)(?![\\s"'\\\\<])[^\\s,;&"'}\\]\\\\]+`, "gi");
+  const bearer = /\b(Bearer|Basic)\s+[A-Za-z0-9._~+/=-]+/gi;
+  return (s) => {
+    let out = s.replace(json, `$1"${REDACTED}"`).replace(escaped, (_m, prefix, slashes) => `${prefix}${slashes}"${REDACTED}${slashes}"`).replace(query, `$1${REDACTED}`).replace(encoded, `$1${REDACTED}`).replace(bearer, `$1 ${REDACTED}`).replace(quotedText, `$1$2${REDACTED}$2`).replace(text, `$1${REDACTED}`);
+    for (const p of urlPatterns) out = out.replace(p, REDACTED);
+    return out;
+  };
+}
+function excerpt(redact, s) {
+  const r = redact(s);
+  return r.length <= RAW_EXCERPT_MAX ? r : `${r.slice(0, RAW_EXCERPT_MAX - 1)}\u2026`;
+}
+
+// src/ws/subscription.ts
+function coalesceKey(e) {
+  switch (e.type) {
+    case "market": {
+      const m = e;
+      return `market|${m.dex === null ? "" : m.dex}|${m.symbol}`;
+    }
+    case "bbo": {
+      const b = e;
+      return `bbo|${b.dex === null ? "" : b.dex}|${b.symbol}`;
+    }
+    case "account": {
+      const a = e;
+      return `account|${a.dex === null ? "" : a.dex}`;
+    }
+    case "positions":
+      return "positions";
+    case "orders":
+      return "orders";
+    default:
+      return null;
+  }
+}
+function evictable(e) {
+  if (e.type === "state") return true;
+  if (e.type !== "error") return false;
+  const c = e;
+  return !c.fatal && c.code !== "SYMBOL_NOT_FOUND";
+}
+function merge(prev, next) {
+  if (next.type === "market") {
+    const p = prev;
+    const n = next;
+    const changed = Array.from(/* @__PURE__ */ new Set([...p.changed, ...n.changed]));
+    const source = p.source === "snapshot" || n.source === "snapshot" ? "snapshot" : n.source;
+    const merged = { ...n, changed, source };
+    return merged;
+  }
+  if (next.type === "positions" || next.type === "orders") {
+    const p = prev;
+    const n = next;
+    const snapshot = p.snapshot || n.snapshot;
+    const merged = { ...n, snapshot, source: snapshot ? "snapshot" : n.source };
+    return merged;
+  }
+  return next;
+}
+var SubscriptionImpl = class {
+  constructor(venue, bufferSize, onUnsubscribe, onListenerError, onOverflow) {
+    this.venue = venue;
+    this.bufferSize = bufferSize;
+    this.onUnsubscribe = onUnsubscribe;
+    this.onListenerError = onListenerError;
+    this.onOverflow = onOverflow;
+    this.status = "pending";
+    this.listeners = /* @__PURE__ */ new Set();
+    this.iterating = false;
+    this.buffering = true;
+    this.queue = [];
+    this.keyed = /* @__PURE__ */ new Map();
+    // coalesce key → queued box
+    this.controlsQueued = 0;
+    /** Control events discarded from the pre-iterator ring. */
+    this.droppedBeforeIterator = 0;
+    this.waiters = [];
+    this.ready = new Promise((resolve, reject) => {
+      this.resolveReady = resolve;
+      this.rejectReady = reject;
+    });
+    this.ready.catch(() => void 0);
+  }
+  markActive() {
+    if (this.status !== "pending") return;
+    this.status = "active";
+    this.resolveReady();
+  }
+  /** Reject `ready` (if pending), emit a fatal error event and end the subscription. */
+  fail(err) {
+    if (this.status === "closed" || this.status === "rejected") return;
+    const wasPending = this.status === "pending";
+    this.deliver({
+      type: "error",
+      venue: this.venue,
+      code: err.structured.code,
+      message: err.message,
+      remediation: err.structured.remediation === void 0 ? null : err.structured.remediation,
+      raw: null,
+      fatal: true
+    }, true);
+    this.status = wasPending ? "rejected" : "closed";
+    if (wasPending) this.rejectReady(err);
+    this.finish();
+  }
+  /** End without error (client unsubscribe / stream close). */
+  end() {
+    if (this.status === "closed" || this.status === "rejected") return;
+    const wasPending = this.status === "pending";
+    this.status = "closed";
+    if (wasPending) this.rejectReady(new WsError("INVALID_PARAMS", "Subscription closed before it became ready", { exchange: this.venue }));
+    this.finish();
+  }
+  get closed() {
+    return this.status === "closed" || this.status === "rejected";
+  }
+  emit(e) {
+    this.deliver(e, false);
+  }
+  /** `force`: a terminal error event is queued even when the buffer is full. */
+  deliver(e, force) {
+    if (this.closed) return;
+    for (const l of this.listeners) {
+      try {
+        l(e);
+      } catch (err) {
+        this.onListenerError(err);
+      }
+    }
+    if (!this.buffering) return;
+    const w = this.waiters.shift();
+    if (w !== void 0) {
+      w({ value: e, done: false });
+      return;
+    }
+    const key = coalesceKey(e);
+    if (key !== null) {
+      const box = this.keyed.get(key);
+      if (box !== void 0) {
+        box.v = merge(box.v, e);
+        return;
+      }
+      const nb = { v: e, key };
+      this.keyed.set(key, nb);
+      this.queue.push(nb);
+      return;
+    }
+    if (!force && !this.iterating && this.controlsQueued >= this.bufferSize) {
+      const oldest = this.queue.findIndex((b) => b.key === null && evictable(b.v));
+      if (oldest >= 0) {
+        this.queue.splice(oldest, 1);
+        this.controlsQueued--;
+        this.droppedBeforeIterator++;
+      }
+    }
+    if (!force && this.controlsQueued >= this.bufferSize) {
+      this.onOverflow(this, new WsError("STREAM_OVERFLOW", `Subscription buffer full (${this.bufferSize} events not consumed)`, {
+        exchange: this.venue,
+        remediation: "Consume the iterator faster, use on() callbacks, or raise opts.buffer.size"
+      }));
+      return;
+    }
+    this.controlsQueued++;
+    this.queue.push({ v: e, key: null });
+  }
+  on(cb) {
+    if (!this.iterating) this.clearBuffer(false);
+    this.listeners.add(cb);
+    return () => {
+      this.listeners.delete(cb);
+    };
+  }
+  unsubscribe() {
+    if (this.closed) return Promise.resolve();
+    return this.onUnsubscribe(this);
+  }
+  [Symbol.asyncIterator]() {
+    if (!this.iterating && this.droppedBeforeIterator > 0) {
+      const oldest = this.queue.findIndex((b) => b.key === null && evictable(b.v));
+      if (this.controlsQueued >= this.bufferSize && oldest >= 0) {
+        this.queue.splice(oldest, 1);
+        this.controlsQueued--;
+        this.droppedBeforeIterator++;
+      }
+      const n = this.droppedBeforeIterator;
+      this.droppedBeforeIterator = 0;
+      this.queue.unshift({
+        v: {
+          type: "error",
+          venue: this.venue,
+          code: "STREAM_OVERFLOW",
+          message: `${n} older control event(s) were discarded before an iterator attached (latest ${this.bufferSize} kept)`,
+          remediation: "Create the iterator (or attach on()) right after subscribe()",
+          raw: null,
+          fatal: false
+        },
+        key: null
+      });
+      this.controlsQueued++;
+    }
+    this.iterating = true;
+    this.buffering = true;
+    const stop = async () => {
+      this.clearBuffer(true);
+      await this.unsubscribe();
+      return { value: void 0, done: true };
+    };
+    return {
+      next: () => {
+        const box = this.queue.shift();
+        if (box !== void 0) {
+          if (box.key === null) this.controlsQueued--;
+          else this.keyed.delete(box.key);
+          return Promise.resolve({ value: box.v, done: false });
+        }
+        if (this.closed) return Promise.resolve({ value: void 0, done: true });
+        return new Promise((resolve) => this.waiters.push(resolve));
+      },
+      return: stop,
+      throw: async (err) => {
+        await stop();
+        throw err;
+      }
+    };
+  }
+  clearBuffer(keepBuffering) {
+    this.queue = [];
+    this.keyed.clear();
+    this.controlsQueued = 0;
+    this.droppedBeforeIterator = 0;
+    this.buffering = keepBuffering;
+  }
+  finish() {
+    for (const w of this.waiters.splice(0)) w({ value: void 0, done: true });
+  }
+};
+
+// src/ws/user-state.ts
+var FILL_DEDUPE_WINDOW = 2e4;
+var UserStore = class {
+  constructor(venue) {
+    this.venue = venue;
+    this.positions = /* @__PURE__ */ new Map();
+    this.orders = /* @__PURE__ */ new Map();
+    /** Order scopes that received a venue snapshot since they were (re)created. */
+    this.ordersComplete = /* @__PURE__ */ new Set();
+    this.seenFills = /* @__PURE__ */ new Map();
+  }
+  apply(d, recvTs) {
+    const source = d.kind !== "fills" && d.snapshot ? "snapshot" : "ws";
+    switch (d.kind) {
+      case "account":
+        return {
+          fillsGap: false,
+          updates: [{
+            type: "account",
+            schema: 1,
+            venue: this.venue,
+            dex: d.dex,
+            equity: d.equity === void 0 ? null : d.equity,
+            available: d.available === void 0 ? null : d.available,
+            marginUsed: d.marginUsed === void 0 ? null : d.marginUsed,
+            unrealizedPnl: d.unrealizedPnl === void 0 ? null : d.unrealizedPnl,
+            venueTs: d.venueTs,
+            source,
+            recvTs
+          }]
+        };
+      case "positions":
+        mergeScope(this.positions, d.scope, d.snapshot, d.rows.map((r) => [posKey(r), r]), d.remove);
+        return { fillsGap: false, updates: [{ type: "positions", schema: 1, venue: this.venue, snapshot: d.snapshot, positions: flatten(this.positions), source, recvTs }] };
+      case "orders":
+        mergeScope(this.orders, d.scope, d.snapshot, d.rows.map((r) => [r.orderId, r]), d.remove);
+        if (d.snapshot) this.ordersComplete.add(d.scope);
+        return { fillsGap: false, updates: [this.ordersEvent(d.snapshot, recvTs)] };
+      case "fills":
+        return this.applyFills(d.snapshot, d.fills, recvTs);
+    }
+  }
+  /** A non-replayable order channel had a gap: forget its (now unknown) open orders. */
+  clearOrders(recvTs) {
+    this.orders.clear();
+    this.ordersComplete.clear();
+    return this.ordersEvent(false, recvTs);
+  }
+  currentOrders(recvTs) {
+    return this.ordersEvent(false, recvTs);
+  }
+  ordersEvent(snapshot, recvTs) {
+    const scopes = Array.from(this.orders.keys());
+    const complete = scopes.length > 0 && scopes.every((s) => this.ordersComplete.has(s));
+    return { type: "orders", schema: 1, venue: this.venue, snapshot, complete, orders: flatten(this.orders), source: snapshot ? "snapshot" : "ws", recvTs };
+  }
+  applyFills(snapshot, fills, recvTs) {
+    const hadHistory = this.seenFills.size > 0;
+    const fresh = [];
+    let oldest = null;
+    for (const f of fills) {
+      if (oldest === null || f.time !== null && (oldest.time === null || f.time < oldest.time)) oldest = f;
+    }
+    const oldestUnseen = oldest !== null && !this.seenFills.has(fillKey(oldest));
+    for (const f of fills) {
+      const k = fillKey(f);
+      if (this.seenFills.has(k)) continue;
+      this.remember(k);
+      fresh.push(f);
+    }
+    const fillsGap = snapshot && hadHistory && oldestUnseen;
+    if (fresh.length === 0) return { fillsGap, updates: [] };
+    if (snapshot) {
+      return { fillsGap, updates: [{ type: "fills", schema: 1, venue: this.venue, snapshot: true, fills: fresh, source: "snapshot", recvTs }] };
+    }
+    return {
+      fillsGap,
+      updates: fresh.map((fill) => ({ type: "fill", schema: 1, venue: this.venue, snapshot: false, fillId: fill.fillId, fill, source: "ws", recvTs }))
+    };
+  }
+  remember(k) {
+    this.seenFills.set(k, true);
+    if (this.seenFills.size > FILL_DEDUPE_WINDOW) {
+      const first = this.seenFills.keys().next();
+      if (first.done !== true) this.seenFills.delete(first.value);
+    }
+  }
+};
+function fillKey(f) {
+  return `${f.fillId}|${f.side === null ? "" : f.side}|${f.orderId === null ? "" : f.orderId}`;
+}
+function posKey(r) {
+  return `${r.dex === null ? "" : r.dex}|${r.symbol}`;
+}
+function mergeScope(all, scope, snapshot, rows, remove) {
+  let m = all.get(scope);
+  if (m === void 0 || snapshot) {
+    m = /* @__PURE__ */ new Map();
+    all.set(scope, m);
+  }
+  for (const k of remove) {
+    for (const key of Array.from(m.keys())) if (key === k || key.endsWith(`|${k}`)) m.delete(key);
+  }
+  for (const [k, v] of rows) m.set(k, v);
+}
+function flatten(all) {
+  const out = [];
+  for (const m of all.values()) for (const v of m.values()) out.push(v);
+  return out;
+}
+
+// src/ws/stream.ts
+var USER_CHANNELS = ["account", "positions", "orders", "fills"];
+var MARKET_CHANNELS = ["market", "bbo", "book", "trades"];
+var LATER_CHANNELS = ["book", "trades"];
+var NETWORKS = ["mainnet", "testnet"];
+var MAX_PAYLOAD_CLOSES = 3;
+var MAX_PAYLOAD_WINDOW_MS = 10 * 6e4;
+var CODEC_REMEDIATION = "Pass a codec export, e.g. import { hyperliquid } from '@hypurrquant/perp-ws' (or 'perp-cli/ws')";
+function checkCodec(codec) {
+  const c = codec;
+  const problem = c === null || typeof c !== "object" ? `got ${c === null ? "null" : typeof codec}${typeof codec === "string" ? ` ${JSON.stringify(codec)}` : ""}` : typeof c.venue !== "string" || !VENUE_IDS.includes(c.venue) ? `unknown venue ${JSON.stringify(c.venue)}` : !Array.isArray(c.secretKeys) || !Array.isArray(c.secretUrlPatterns) || typeof c.url !== "function" || typeof c.restUrl !== "function" || typeof c.loadDirectory !== "function" || typeof c.wiresFor !== "function" || c.capabilities === null || typeof c.capabilities !== "object" ? `${String(c.venue)} codec is missing required members` : null;
+  if (problem !== null) {
+    throw new WsError("INVALID_PARAMS", `createVenueStream: first argument must be a venue codec (${problem})`, { remediation: CODEC_REMEDIATION });
+  }
+}
+function suggestCanonicals(missing, entries) {
+  const m = missing.toUpperCase();
+  const out = entries.filter((e) => e.canonical !== null && (e.canonical.toUpperCase() === m || e.base.toUpperCase() === m || e.canonical.toUpperCase().endsWith(`:${m}`))).map((e) => e.canonical);
+  return Array.from(new Set(out)).slice(0, 5);
+}
+function suggestSymbols(missing, entries) {
+  const m = missing.toUpperCase();
+  const out = entries.filter((e) => e.symbol.toUpperCase() === m || e.canonical !== null && e.canonical.toUpperCase() === m || e.base.toUpperCase() === m).map((e) => e.symbol);
+  return Array.from(new Set(out)).slice(0, 5);
+}
+var EVENT_CHANNEL = { account: "account", positions: "positions", orders: "orders", fill: "fills", fills: "fills" };
+var TOKEN_REDACT_MARGIN_MS = 15 * 6e4;
+var TOKEN_RETRY_BASE_MS = 1e3;
+var TOKEN_RETRY_MAX_MS = 3e4;
+var TOKEN_RETRIES_WITHOUT_VALID = 5;
+var BAD_SUBSCRIBE_WINDOW_MS = 1500;
+var DEFAULT_BUFFER = 1024;
+var EVM_ADDRESS = /^0x[0-9a-fA-F]{40}$/;
+function userRefProblem(venue, ref) {
+  if (ref === null || typeof ref !== "object") return "not an object";
+  if (ref.venue !== venue) return `venue is "${String(ref.venue)}", expected "${venue}"`;
+  switch (ref.venue) {
+    case "hyperliquid":
+      return EVM_ADDRESS.test(ref.address) ? null : "address is not a 0x EVM address";
+    case "pacifica":
+      return typeof ref.account === "string" && /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(ref.account) ? null : "account is not a base58 Solana address";
+    case "lighter":
+    case "lighter-rh":
+      return Number.isInteger(ref.accountIndex) && ref.accountIndex >= 0 ? null : "accountIndex is not a non-negative integer";
+    case "arcus":
+      if (!EVM_ADDRESS.test(ref.address)) return "address is not a 0x EVM address";
+      return ref.subaccount === null || Number.isInteger(ref.subaccount) && ref.subaccount >= 0 ? null : "subaccount is not null or a non-negative integer";
+    default:
+      return null;
+  }
+}
+function isBrowserLike() {
+  const g = globalThis;
+  return g.window !== void 0 && g.document !== void 0;
+}
+function createVenueStream(codec, opts = {}) {
+  checkCodec(codec);
+  const venue = codec.venue;
+  if (opts === null || typeof opts !== "object") {
+    throw new WsError("INVALID_PARAMS", `${venue}: options must be an object (got ${opts === null ? "null" : typeof opts})`, { exchange: venue });
+  }
+  if (opts.network !== void 0 && !NETWORKS.includes(opts.network)) {
+    throw new WsError("INVALID_PARAMS", `${venue}: unknown network ${JSON.stringify(opts.network)}`, {
+      exchange: venue,
+      remediation: `Use network ${NETWORKS.map((n) => `"${n}"`).join(" or ")} (or omit it for mainnet)`
+    });
+  }
+  const network = opts.network === void 0 ? "mainnet" : opts.network;
+  const transport = resolveTransport(opts, venue);
+  const fetchFn = resolveFetch(opts, venue);
+  const clock = opts.clock === void 0 ? () => Date.now() : opts.clock;
+  const baseRedact = createRedactor(codec.secretKeys, codec.secretUrlPatterns);
+  const liveSecrets = [];
+  const redact = (s) => {
+    let out = baseRedact(s);
+    for (const { secret } of liveSecrets) if (out.includes(secret)) out = out.split(secret).join(REDACTED);
+    return out;
+  };
+  const bufferSize = opts.buffer === void 0 ? DEFAULT_BUFFER : opts.buffer.size;
+  if (!Number.isInteger(bufferSize) || bufferSize < 1) {
+    throw new WsError("INVALID_PARAMS", `${venue}: buffer.size must be a positive integer (got ${String(bufferSize)})`, {
+      exchange: venue,
+      remediation: "Pass buffer: { size: n } with n \u2265 1, or omit it (default 1024)"
+    });
+  }
+  const url = codec.url(network);
+  const restUrl = codec.restUrl(network);
+  const subs = /* @__PURE__ */ new Map();
+  const wires = /* @__PURE__ */ new Map();
+  const stateListeners = /* @__PURE__ */ new Set();
+  const reportedUnknown = /* @__PURE__ */ new Set();
+  let nextReqId = 1;
+  let closed = false;
+  let directory = null;
+  let dir = null;
+  let store = null;
+  let refreshTimer = null;
+  let directoryWarnings = [];
+  const userStore = new UserStore(venue);
+  let userRef = null;
+  const tokens = /* @__PURE__ */ new Map();
+  const tokenFetches = /* @__PURE__ */ new Map();
+  const tokenRetryTimers = /* @__PURE__ */ new Set();
+  const tokenLoops = /* @__PURE__ */ new Map();
+  function log(level2, event, message, details) {
+    if (opts.logger === void 0) return;
+    const entry = { ts: clock(), venue, level: level2, event, message: redact(message) };
+    if (details !== void 0) entry.details = JSON.parse(redact(JSON.stringify(details)));
+    try {
+      opts.logger(entry);
+    } catch {
+    }
+  }
+  function errorEvent(code, message, remediation, raw, fatal, details) {
+    return {
+      type: "error",
+      venue,
+      code,
+      message: redact(message),
+      remediation: remediation === null ? null : redact(remediation),
+      raw: raw === null ? null : excerpt(redact, raw),
+      fatal,
+      ...details === void 0 ? {} : { details }
+    };
+  }
+  function wsError(code, message, remediation, details) {
+    return new WsError(code, redact(message), {
+      exchange: venue,
+      ...remediation !== void 0 ? { remediation: redact(remediation) } : {},
+      ...details !== void 0 ? { details } : {}
+    });
+  }
+  const shards = [];
+  const connectLog = [];
+  let terminalReason = null;
+  let lastState = null;
+  const maxSockets = Math.min(
+    codec.limits.maxSockets === void 0 ? 1 : codec.limits.maxSockets,
+    opts.budget?.maxSockets === void 0 ? Infinity : opts.budget.maxSockets
+  );
+  function wiresOn(shard) {
+    return Array.from(shard.wires);
+  }
+  function newShard() {
+    const shard = { id: shards.length, wires: /* @__PURE__ */ new Set(), fresh: true, payloadCloses: [] };
+    shard.conn = new Connection({
+      venue,
+      url,
+      transport,
+      clock,
+      redact,
+      ping: codec.ping,
+      reconnect: opts.reconnect === void 0 ? { maxAttempts: null, baseMs: 1e3, maxMs: 3e4 } : opts.reconnect,
+      newConnectionsPerMin: Math.min(codec.limits.newConnectionsPerMin, opts.budget?.newConnectionsPerMin === void 0 ? Infinity : opts.budget.newConnectionsPerMin),
+      connectLog,
+      outboundPerMin: codec.limits.outboundPerMin,
+      visibility: opts.visibility === void 0 ? defaultVisibility() : opts.visibility,
+      random: Math.random
+    }, {
+      onOpen: () => {
+        const now = clock();
+        shard.fresh = false;
+        for (const w of wiresOn(shard)) {
+          const g = w.wire.gaps?.onReconnect;
+          if (w.everAcked && g !== void 0) {
+            for (const ch of g) {
+              emitGap(w, ch, "reconnected; the venue does not replay this channel");
+              if (ch === "orders") dispatchUser(w, userStore.clearOrders(now));
+            }
+          }
+          w.firstFrameSeen = false;
+          w.lastAt = null;
+          if (w.suspect) {
+            w.sentAt = null;
+            continue;
+          }
+          sendSubscribe(w, now, false);
+        }
+        probeNextSuspect(shard);
+      },
+      // Ack timers belong to one socket: a reconnect delay must not fail a pending subscription.
+      onSocketDown: () => {
+        for (const w of wiresOn(shard)) clearAckTimer(w);
+      },
+      onText: (text, recvTs) => onText(shard, text, recvTs),
+      onUnreadableFrame: () => {
+        const ev = errorEvent("WS_PROTOCOL_ERROR", "Unreadable (non-text) frame", null, null, false);
+        log("warn", "protocol-error", ev.type === "error" ? ev.message : "");
+        broadcast(ev);
+      },
+      onState: (s) => {
+        if (s.status === "idle") shard.fresh = true;
+        onShardState(s);
+      },
+      onUnexpectedClose: (reason, opened, maxPayloadExceeded) => maxPayloadExceeded ? handleMaxPayloadClose(shard, reason) : handleBadSubscribeClose(shard, reason, opened),
+      liveness: () => {
+        const out = [];
+        for (const w of wiresOn(shard)) {
+          if (w.sentAt === null) continue;
+          out.push({ key: w.wire.key, staleAfterMs: w.wire.staleAfterMs, lastAt: Math.max(w.sentAt, w.lastAt === null ? 0 : w.lastAt) });
+        }
+        return out;
+      },
+      log
+    });
+    shards.push(shard);
+    return shard;
+  }
+  if (url !== null) newShard();
+  function shardState(sh) {
+    return sh.conn.waiting && sh.wires.size > 0 ? { status: "connecting", attempt: 1 } : sh.conn.state;
+  }
+  function aggregateState() {
+    if (shards.length === 1) return shardState(shards[0]);
+    const active = shards.map((sh) => ({ sh, st: shardState(sh) })).filter((x) => x.st.status !== "idle");
+    const closedHit = active.find((x) => x.st.status === "closed");
+    if (closedHit !== void 0) return closedHit.st;
+    for (const status of ["reconnecting", "stale"]) {
+      const hit = active.find((x) => x.st.status === status && !(status === "reconnecting" && x.sh.fresh));
+      if (hit !== void 0) return hit.st;
+    }
+    const down = active.find((x) => x.st.status === "connecting" && !x.sh.fresh);
+    if (down !== void 0) return down.st;
+    const live = active.filter((x) => x.st.status === "live");
+    const opening = active.filter((x) => x.sh.fresh && (x.st.status === "connecting" || x.st.status === "reconnecting"));
+    if (live.length > 0) {
+      const since = Math.max(...live.map((x) => x.st.status === "live" ? x.st.since : 0));
+      return { status: "live", since, sockets: live.length, pending: opening.length };
+    }
+    return opening.length > 0 ? opening[0].st : { status: "idle" };
+  }
+  function reportState() {
+    const agg = aggregateState();
+    const key = JSON.stringify(agg);
+    if (key === lastState) return;
+    lastState = key;
+    for (const l of stateListeners) {
+      try {
+        l(agg);
+      } catch (e) {
+        log("warn", "listener-error", `onState listener threw: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+    broadcast({ type: "state", venue, state: agg });
+  }
+  function onShardState(s) {
+    const failed = s.status === "closed" && s.reason.code !== "CLIENT_CLOSE" && terminalReason === null;
+    if (failed) terminalReason = s.reason;
+    reportState();
+    if (failed && s.status === "closed" && s.reason.code !== "CLIENT_CLOSE") {
+      for (const sh of shards) sh.conn.fail(s.reason);
+      const err = wsError(
+        s.reason.code,
+        s.reason.message,
+        s.reason.remediation === null ? void 0 : s.reason.remediation
+      );
+      for (const sub of Array.from(subs.keys())) dropSub(sub, err);
+    }
+  }
+  function broadcast(e) {
+    for (const sub of subs.keys()) sub.emit(e);
+  }
+  function ctx() {
+    return {
+      network,
+      fetch: fetchFn,
+      restUrl,
+      hip3Dexes: opts.hip3Dexes === void 0 ? [] : opts.hip3Dexes,
+      canonicalize: opts.canonicalize === void 0 ? defaultCanonicalize : opts.canonicalize,
+      clock
+    };
+  }
+  function loadDirectory() {
+    if (directory !== null) return directory;
+    if (restUrl === null) {
+      return Promise.reject(wsError("CAPABILITY_UNSUPPORTED", `${venue} has no REST host on ${network} for the market directory`));
+    }
+    const p = codec.loadDirectory(ctx()).then((d) => {
+      dir = d;
+      store = new MarketStore(codec, d);
+      directoryWarnings = d.warnings === void 0 ? [] : d.warnings;
+      log("info", "directory", `market directory loaded (${d.entries.length} markets)`);
+      for (const w of directoryWarnings) log("warn", "directory-warning", w);
+      if (!closed) startRefresh();
+      return d;
+    });
+    directory = p;
+    p.catch((e) => {
+      directory = null;
+      log("error", "directory-failed", e instanceof Error ? e.message : String(e));
+    });
+    return p;
+  }
+  function startRefresh() {
+    const r = codec.refresh;
+    if (r === null || refreshTimer !== null || closed) return;
+    refreshTimer = setInterval(() => {
+      if (dir === null || closed) return;
+      const d = dir;
+      r.run(ctx(), d).then(
+        (warnings) => {
+          log("info", "labelled-refresh", `${r.source} refreshed`);
+          for (const w of warnings) {
+            log("warn", "labelled-refresh-warning", w);
+            broadcast(errorEvent("EXCHANGE_ERROR", w, "The venue REST response had malformed rows; affected markets keep a null interval", null, false));
+          }
+        },
+        (e) => {
+          const msg = `${r.source} refresh failed: ${e instanceof Error ? e.message : String(e)}; interval values keep their previous asOf`;
+          log("warn", "labelled-refresh-failed", msg);
+          broadcast(errorEvent(e instanceof WsError ? e.structured.code : "EXCHANGE_ERROR", msg, "Retried on the next refresh", null, false));
+        }
+      );
+    }, r.everyMs);
+  }
+  function sendSubscribe(w, now, probe) {
+    const connection = w.shard.conn;
+    if (!connection.isOpen) return;
+    let auth = null;
+    const need = w.wire.auth;
+    if (need !== void 0) {
+      const t = tokens.get(need.purpose);
+      if (t === void 0 || clock() >= t.expiresAt) {
+        clearAckTimer(w);
+        w.acked = false;
+        w.sentAt = null;
+        w.lastSeq = null;
+        acquireToken(
+          need,
+          () => {
+            if (!closed && wires.get(w.wire.key) === w && connection.isOpen && w.sentAt === null) sendSubscribe(w, clock(), probe);
+          },
+          (err) => failWire(w, err)
+        );
+        return;
+      }
+      auth = t.token;
+      if (clock() >= t.refreshAt && t.timer === null) Promise.resolve().then(() => refreshToken(need));
+    }
+    w.lastSeq = null;
+    w.reqId = nextReqId++;
+    w.sentAt = now;
+    w.acked = false;
+    w.probe = probe;
+    connection.send(codec.encodeSubscribe(w.wire, w.reqId, auth));
+    armAckTimeout(w);
+  }
+  function failWire(w, err) {
+    if (w.refs.size === 0) return;
+    log("error", "wire-failed", err.message, { wire: w.wire.key });
+    for (const sub of Array.from(w.refs)) dropSub(sub, err);
+  }
+  function dispatchUser(w, u, only) {
+    const ch = EVENT_CHANNEL[u.type];
+    for (const sub of only === void 0 ? w.refs : [only]) {
+      const meta = subs.get(sub);
+      if (meta !== void 0 && meta.userChannels !== null && meta.userChannels.has(ch)) sub.emit(u);
+    }
+  }
+  function emitGap(w, channel, why) {
+    log("warn", "gap", `${w.wire.key}: ${channel} ${why} \u2192 refetch-required`);
+    for (const sub of w.refs) {
+      const meta = subs.get(sub);
+      if (meta === void 0 || meta.userChannels === null || !meta.userChannels.has(channel)) continue;
+      sub.emit({ type: "gap", venue, channel, symbol: null, expected: null, got: null, action: "refetch-required" });
+    }
+  }
+  function toAuthError(e) {
+    if (e instanceof WsError && e.structured.code === "WS_AUTH_FAILED") return e;
+    const definite = isPerpError(e) && e.structured.retryable === false;
+    return wsError(
+      "WS_AUTH_FAILED",
+      `${venue} authToken() failed: ${e instanceof Error ? e.message : String(e)}`,
+      "Check the credential provider (token for the right account / API key; a read-only ro: token in browsers)",
+      definite ? void 0 : { transient: true }
+    );
+  }
+  function usesPurpose(purpose) {
+    for (const w of wires.values()) if (w.wire.auth !== void 0 && w.wire.auth.purpose === purpose) return true;
+    return false;
+  }
+  function acquireToken(need, onOk, onFail) {
+    const waiting = tokenLoops.get(need.purpose);
+    if (waiting !== void 0) {
+      waiting.push({ onOk, onFail });
+      return;
+    }
+    tokenLoops.set(need.purpose, [{ onOk, onFail }]);
+    const settle = (f) => {
+      const list = tokenLoops.get(need.purpose);
+      tokenLoops.delete(need.purpose);
+      if (list !== void 0) for (const cb of list) f(cb);
+    };
+    const attempt = (n) => {
+      getToken(need).then((t) => settle((cb) => cb.onOk(t)), (e) => {
+        const err = toAuthError(e);
+        if (closed) {
+          tokenLoops.delete(need.purpose);
+          return;
+        }
+        const delay = Math.min(TOKEN_RETRY_MAX_MS, TOKEN_RETRY_BASE_MS * Math.pow(2, n));
+        const cur = tokens.get(need.purpose);
+        const stillValid = cur !== void 0 && clock() + delay < cur.expiresAt;
+        const transient = err.structured.details?.transient === true;
+        if (!transient || !(stillValid || n < TOKEN_RETRIES_WITHOUT_VALID)) {
+          settle((cb) => cb.onFail(err));
+          return;
+        }
+        const msg = `${err.message}; retrying in ${delay} ms${stillValid ? " (current token still valid)" : ""}`;
+        log("warn", "auth-token-retry", msg);
+        for (const w of wires.values()) {
+          if (w.wire.auth === void 0 || w.wire.auth.purpose !== need.purpose) continue;
+          for (const sub of w.refs) sub.emit(errorEvent("WS_AUTH_FAILED", msg, "Retried automatically; fails once the token expires", null, false));
+        }
+        const timer = setTimeout(() => {
+          tokenRetryTimers.delete(timer);
+          if (closed) return;
+          if (!usesPurpose(need.purpose)) {
+            tokenLoops.delete(need.purpose);
+            log("info", "auth-token-retry-stopped", `${need.purpose}: no channel uses this token any more`);
+            return;
+          }
+          attempt(n + 1);
+        }, delay);
+        tokenRetryTimers.add(timer);
+      });
+    };
+    attempt(0);
+  }
+  function getToken(need) {
+    const have = tokens.get(need.purpose);
+    if (have !== void 0 && clock() < have.refreshAt) return Promise.resolve(have);
+    const inflight = tokenFetches.get(need.purpose);
+    if (inflight !== void 0) return inflight;
+    const p = (async () => {
+      const provider = opts.credentials;
+      if (provider === void 0 || provider.authToken === void 0) {
+        throw wsError(
+          "WS_AUTH_FAILED",
+          `${need.purpose} needs an auth token but the credential provider has no authToken()`,
+          "Pass credentials.authToken (Lighter: a read-only ro: token is recommended in browsers)"
+        );
+      }
+      let r;
+      try {
+        r = await provider.authToken({ purpose: need.purpose, maxTtlSec: need.maxTtlSec });
+      } catch (e) {
+        throw toAuthError(e);
+      }
+      const now = clock();
+      if (r === null || typeof r !== "object" || typeof r.token !== "string" || r.token === "" || typeof r.expiresAt !== "number" || !(r.expiresAt > now)) {
+        throw wsError("WS_AUTH_FAILED", `${venue} authToken() returned no usable token (need { token, expiresAt: epoch ms in the future })`);
+      }
+      for (let i = liveSecrets.length - 1; i >= 0; i--) if (liveSecrets[i].until < now) liveSecrets.splice(i, 1);
+      liveSecrets.push({ secret: r.token, until: r.expiresAt + TOKEN_REDACT_MARGIN_MS });
+      const old = tokens.get(need.purpose);
+      if (old !== void 0 && old.timer !== null) clearTimeout(old.timer);
+      const refreshAt = now + Math.floor(0.8 * (r.expiresAt - now));
+      const st = { token: r.token, expiresAt: r.expiresAt, refreshAt, timer: null };
+      if (!closed) st.timer = setTimeout(() => {
+        st.timer = null;
+        refreshToken(need);
+      }, refreshAt - now);
+      tokens.set(need.purpose, st);
+      log("info", "auth-token", `${need.purpose} token obtained (refresh in ${refreshAt - now} ms)`);
+      return st;
+    })();
+    tokenFetches.set(need.purpose, p);
+    p.then(() => tokenFetches.delete(need.purpose), () => tokenFetches.delete(need.purpose));
+    return p;
+  }
+  function refreshToken(need) {
+    if (closed) return;
+    const users = () => Array.from(wires.values()).filter((w) => w.wire.auth !== void 0 && w.wire.auth.purpose === need.purpose);
+    if (users().length === 0) {
+      tokens.delete(need.purpose);
+      return;
+    }
+    if (!users().some((w) => w.shard.conn.isOpen)) return;
+    if (tokenLoops.has(need.purpose)) return;
+    acquireToken(
+      need,
+      () => {
+        for (const w of users()) {
+          if (!w.shard.conn.isOpen || w.sentAt === null) continue;
+          w.shard.conn.send(codec.encodeUnsubscribe(w.wire, nextReqId++));
+          w.firstFrameSeen = false;
+          sendSubscribe(w, clock(), false);
+        }
+        log("info", "auth-token-refreshed", `${need.purpose}: resubscribed with a fresh token`);
+      },
+      (err) => {
+        for (const w of users()) failWire(w, err);
+      }
+    );
+  }
+  function armAckTimeout(w) {
+    clearAckTimer(w);
+    const reqId = w.reqId;
+    const ms = w.wire.staleAfterMs === null ? codec.staleAfterMs : w.wire.staleAfterMs;
+    w.ackTimer = setTimeout(() => {
+      w.ackTimer = null;
+      if (closed || !w.shard.conn.isOpen || wires.get(w.wire.key) !== w || w.reqId !== reqId || w.acked) return;
+      const msg = `${venue}: no acknowledgement or data for ${w.wire.key} within ${ms} ms of subscribing`;
+      log("error", "ack-timeout", msg);
+      const err = wsError("WS_PROTOCOL_ERROR", msg, "The venue ignored the subscription; check the channel/symbol or retry later");
+      const wasSuspect = w.suspect;
+      w.suspect = false;
+      for (const sub of Array.from(w.refs)) {
+        if (sub.status === "pending") dropSub(sub, err);
+        else sub.emit(errorEvent("WS_PROTOCOL_ERROR", msg, null, null, false));
+      }
+      if (wasSuspect) probeNextSuspect(w.shard);
+    }, ms);
+  }
+  function clearAckTimer(w) {
+    if (w.ackTimer !== null) {
+      clearTimeout(w.ackTimer);
+      w.ackTimer = null;
+    }
+  }
+  function maybeReady(sub) {
+    const meta = subs.get(sub);
+    if (meta === void 0 || sub.status !== "pending") return;
+    if (meta.wires.every((k) => wires.get(k)?.acked === true)) sub.markActive();
+  }
+  function markAcked(w) {
+    if (w.acked) return;
+    w.acked = true;
+    w.everAcked = true;
+    w.probe = false;
+    clearAckTimer(w);
+    if (w.suspect) {
+      w.suspect = false;
+      probeNextSuspect(w.shard);
+    }
+    for (const sub of w.refs) maybeReady(sub);
+  }
+  function wireOn(shard, key) {
+    const w = wires.get(key);
+    if (w === void 0) log("info", "late-frame", `frame for ${key} after its unsubscribe (in flight)`);
+    else if (w.shard !== shard) log("info", "late-frame", `frame for ${key} on socket ${shard.id}; it lives on socket ${w.shard.id}`);
+    else return w;
+    return void 0;
+  }
+  function findWire(ev) {
+    if (ev.wire !== null) return wires.get(ev.wire);
+    if (ev.reqId !== null) {
+      for (const w of wires.values()) if (w.reqId === ev.reqId) return w;
+    }
+    return void 0;
+  }
+  function onText(shard, text, recvTs) {
+    if (dir === null || store === null) {
+      broadcast(errorEvent("WS_PROTOCOL_ERROR", "Frame received before the market directory loaded", null, text, false));
+      return;
+    }
+    let events;
+    try {
+      events = codec.decode(text, dir, recvTs);
+    } catch (e) {
+      events = [{ t: "error", code: "WS_PROTOCOL_ERROR", message: `Codec failed: ${e instanceof Error ? e.message : String(e)}`, wire: null, fatal: false, remediation: null }];
+    }
+    for (const ev of events) handleEvent(shard, ev, text, recvTs);
+  }
+  function handleEvent(shard, ev, text, recvTs) {
+    const connection = shard.conn;
+    switch (ev.t) {
+      case "pong":
+        connection.notePong();
+        return;
+      case "ignore":
+        return;
+      case "ack": {
+        if (ev.unsubscribe) return;
+        const w = findWire(ev);
+        if (w === void 0 || w.shard !== shard) {
+          log("info", "late-ack", w === void 0 ? "ack for a channel that is no longer subscribed" : `ack for ${w.wire.key} on socket ${shard.id}; it lives on socket ${w.shard.id}`, { wire: ev.wire, reqId: ev.reqId });
+          return;
+        }
+        markAcked(w);
+        return;
+      }
+      case "error": {
+        const w = ev.wire !== null ? wires.get(ev.wire) : ev.reqId !== void 0 ? findWire({ wire: null, reqId: ev.reqId }) : void 0;
+        if (w !== void 0 && w.shard !== shard) {
+          log("info", "late-frame", `error for ${w.wire.key} on socket ${shard.id}; it lives on socket ${w.shard.id}`, { code: ev.code, fatal: ev.fatal });
+          return;
+        }
+        const e = errorEvent(ev.code, ev.message, ev.remediation, text, ev.fatal);
+        log(ev.fatal ? "error" : "warn", "protocol-error", e.type === "error" ? e.message : "", { wire: ev.wire });
+        if (w === void 0) {
+          broadcast(e.type === "error" && e.fatal ? { ...e, fatal: false } : e);
+          return;
+        }
+        if (ev.fatal) {
+          const err = wsError(ev.code, ev.message, ev.remediation === null ? void 0 : ev.remediation);
+          for (const sub of Array.from(w.refs)) dropSub(sub, err);
+        } else {
+          for (const sub of w.refs) sub.emit(e);
+        }
+        return;
+      }
+      case "user": {
+        const w = wireOn(shard, ev.wire);
+        if (w === void 0) return;
+        w.lastAt = recvTs;
+        markAcked(w);
+        connection.markHealthy();
+        if (ev.seq !== void 0 && ev.seq !== null) {
+          if (w.lastSeq !== null && ev.seq < w.lastSeq) {
+            log("info", "stale-snapshot", `${w.wire.key}: frame seq ${ev.seq} is older than ${w.lastSeq}; dropped`);
+            return;
+          }
+          w.lastSeq = ev.seq;
+        }
+        for (const d of ev.deltas) {
+          const r = userStore.apply(d, recvTs);
+          if (r.fillsGap) emitGap(w, "fills", "replayed snapshot does not overlap the fills seen before (outage longer than the replay window)");
+          for (const u of r.updates) dispatchUser(w, u);
+        }
+        return;
+      }
+      case "bbo": {
+        const w = wireOn(shard, ev.wire);
+        if (w === void 0) return;
+        w.lastAt = recvTs;
+        markAcked(w);
+        connection.markHealthy();
+        if (ev.seq !== null) {
+          if (w.lastSeq !== null && ev.seq <= w.lastSeq) return;
+          w.lastSeq = ev.seq;
+        }
+        const entry = store.entry(ev.symbol);
+        if (entry === void 0) {
+          for (const sub of w.refs) sub.emit(errorEvent("WS_PROTOCOL_ERROR", `bbo for ${ev.symbol} which is not in the market directory`, null, null, false));
+          return;
+        }
+        const u = {
+          type: "bbo",
+          schema: 1,
+          venue,
+          dex: entry.dex,
+          symbol: entry.symbol,
+          bid: ev.bid,
+          bidSize: ev.bidSize,
+          ask: ev.ask,
+          askSize: ev.askSize,
+          venueTs: ev.venueTs,
+          recvTs
+        };
+        for (const sub of w.refs) sub.emit(u);
+        return;
+      }
+      case "market": {
+        const w = wireOn(shard, ev.wire);
+        if (w === void 0) return;
+        const s = store;
+        w.lastAt = recvTs;
+        markAcked(w);
+        connection.markHealthy();
+        const source = w.firstFrameSeen ? "ws" : "snapshot";
+        w.firstFrameSeen = true;
+        const unknown = [];
+        for (const patch of ev.patches) {
+          const u = s.apply(patch, recvTs, source);
+          if (u === void 0) {
+            if (!reportedUnknown.has(patch.symbol)) {
+              reportedUnknown.add(patch.symbol);
+              unknown.push(patch.symbol);
+            }
+            continue;
+          }
+          for (const sub of w.refs) {
+            const meta = subs.get(sub);
+            if (meta !== void 0 && (meta.symbols === null || meta.symbols.has(u.symbol))) sub.emit(u);
+          }
+        }
+        if (unknown.length > 0) {
+          const msg = `${unknown.length} market(s) on ${ev.wire} are not in the market directory (new listing?): ${unknown.slice(0, 10).join(", ")}${unknown.length > 10 ? ", \u2026" : ""}`;
+          const e = errorEvent("WS_PROTOCOL_ERROR", msg, "Recreate the stream to reload the market directory", null, false);
+          log("warn", "unknown-market", msg);
+          for (const sub of w.refs) sub.emit(e);
+        }
+        if (connection.state.status === "stale") connection.evaluate();
+        return;
+      }
+    }
+  }
+  function handleMaxPayloadClose(shard, reason) {
+    const now = clock();
+    const closes = shard.payloadCloses;
+    while (closes.length > 0 && now - closes[0] > MAX_PAYLOAD_WINDOW_MS) closes.shift();
+    closes.push(now);
+    log("warn", "max-payload", reason.message, { count: closes.length, limit: MAX_PAYLOAD_CLOSES, socket: shard.id });
+    if (closes.length < MAX_PAYLOAD_CLOSES) return false;
+    closes.length = 0;
+    const err = wsError(
+      "WS_PROTOCOL_ERROR",
+      `${venue}: inbound messages exceeded the transport's maxPayload ${MAX_PAYLOAD_CLOSES} times (WS_ERR_UNSUPPORTED_MESSAGE_LENGTH); stopped reconnecting`,
+      reason.remediation === null ? void 0 : reason.remediation,
+      { wsCode: 1009 }
+    );
+    log("error", "max-payload-repeated", err.message);
+    const onShard = new Set(wiresOn(shard).flatMap((w) => Array.from(w.refs)));
+    for (const sub of onShard) dropSub(sub, err);
+    return wiresOn(shard).length === 0;
+  }
+  function handleBadSubscribeClose(shard, reason, opened) {
+    if (!codec.closesOnBadSubscribe || !opened) return false;
+    const now = clock();
+    const suspects = wiresOn(shard).filter((w2) => w2.probe && !w2.acked && w2.sentAt !== null && now - w2.sentAt <= BAD_SUBSCRIBE_WINDOW_MS);
+    if (suspects.length > 1) {
+      for (const w2 of suspects) w2.suspect = true;
+      log(
+        "warn",
+        "bad-subscribe-ambiguous",
+        `${venue} dropped the socket with ${suspects.length} new channels pending; probing them one at a time`,
+        { channels: suspects.map((w2) => w2.wire.key) }
+      );
+      return false;
+    }
+    if (suspects.length !== 1) return false;
+    const w = suspects[0];
+    const err = wsError(
+      "INVALID_PARAMS",
+      `${venue} closed the socket right after subscribing to ${w.wire.key} (the venue drops the socket on an invalid subscription)`,
+      "Check the symbol against stream.markets(); the other subscriptions reconnect"
+    );
+    log("error", "bad-subscribe", err.message, { wsCode: reason.wsCode });
+    for (const sub of Array.from(w.refs)) dropSub(sub, err);
+    return wiresOn(shard).length === 0;
+  }
+  function probeNextSuspect(shard) {
+    if (!shard.conn.isOpen) return;
+    const held = wiresOn(shard).filter((w) => w.suspect);
+    if (held.length === 0 || held.some((w) => w.sentAt !== null)) return;
+    sendSubscribe(held[0], clock(), true);
+  }
+  function releaseWires(sub) {
+    const meta = subs.get(sub);
+    subs.delete(sub);
+    if (meta === void 0) return;
+    const touched = /* @__PURE__ */ new Set();
+    const releasedSuspect = /* @__PURE__ */ new Set();
+    for (const key of meta.wires) {
+      const w = wires.get(key);
+      if (w === void 0) continue;
+      w.refs.delete(sub);
+      if (w.refs.size > 0) continue;
+      clearAckTimer(w);
+      wires.delete(key);
+      w.shard.wires.delete(w);
+      touched.add(w.shard);
+      if (w.suspect) releasedSuspect.add(w.shard);
+      if (w.shard.conn.isOpen && w.sentAt !== null) {
+        w.shard.conn.send(codec.encodeUnsubscribe(w.wire, nextReqId++));
+      }
+    }
+    for (const sh of touched) {
+      if (sh.wires.size === 0 && !closed && sh.conn.state.status !== "closed") sh.conn.closeIdle();
+    }
+    for (const sh of releasedSuspect) probeNextSuspect(sh);
+    if (!closed && touched.size > 0) reportState();
+  }
+  function dropSub(sub, err) {
+    releaseWires(sub);
+    sub.fail(err);
+  }
+  async function activate(sub, target) {
+    if (closed) throw closedError(venue);
+    terminalCheck();
+    if (url === null) {
+      throw wsError(
+        "CAPABILITY_UNSUPPORTED",
+        `${venue} has no WebSocket on ${network}`,
+        codec.capabilities.notes[`network:${network}`] === void 0 ? void 0 : codec.capabilities.notes[`network:${network}`]
+      );
+    }
+    if (target.kind === "market") {
+      const channels = target.channels;
+      const valid = `Use channels ${MARKET_CHANNELS.map((c) => `"${c}"`).join(" / ")} (book and trades arrive in 0.15.1)`;
+      if (!Array.isArray(channels) || channels.length === 0) {
+        throw wsError("INVALID_PARAMS", 'kind "market" needs at least one channel', valid);
+      }
+      const unknown = channels.filter((c) => typeof c !== "string" || !MARKET_CHANNELS.includes(c));
+      if (unknown.length > 0) throw wsError("INVALID_PARAMS", `${venue}: unknown channel(s) ${unknown.map((c) => JSON.stringify(c)).join(", ")}`, valid);
+      const later = target.channels.filter((c) => LATER_CHANNELS.includes(c));
+      if (later.length > 0) {
+        throw wsError(
+          "CAPABILITY_UNSUPPORTED",
+          `${venue} channel(s) ${later.join(", ")} are not available in this release`,
+          'Use channels "market" / "bbo" (book and trades arrive in 0.15.1)'
+        );
+      }
+      if (target.channels.includes("bbo") && !codec.capabilities.channels.bbo) {
+        throw wsError("CAPABILITY_UNSUPPORTED", `${venue} has no bbo channel`, 'Use channel "market"');
+      }
+    }
+    if (target.kind === "allMarkets") checkAllMarketsTarget(target);
+    if (target.kind === "user") checkUserTarget(target.channels);
+    const d = await loadDirectory();
+    if (closed) throw closedError(venue);
+    terminalCheck();
+    if (sub.closed) return;
+    let list;
+    let wanted = null;
+    let canonicalWarning = null;
+    if (target.kind === "user") {
+      const ref = await resolveUser();
+      list = codec.user.wires(ref, target.channels, d);
+      for (const w of list) if (w.auth !== void 0) await getToken(w.auth);
+      if (closed) throw closedError(venue);
+      if (sub.closed) return;
+    } else {
+      const known = new Set(d.entries.map((e) => e.symbol));
+      if (target.kind === "allMarkets" && target.canonicals !== void 0) {
+        const r = symbolsForCanonicals(target.canonicals, d.entries);
+        wanted = r.symbols;
+        canonicalWarning = r.warning;
+      } else {
+        wanted = target.kind === "allMarkets" ? target.symbols === void 0 ? null : target.symbols : [target.symbol];
+      }
+      if (wanted !== null) {
+        const missing = wanted.filter((s) => !known.has(s));
+        if (missing.length > 0) {
+          const hints = missing.slice(0, 20).map((s) => ({ s, c: suggestSymbols(s, d.entries) })).filter((h) => h.c.length > 0);
+          const hint = hints.length === 0 ? "" : ` (did you mean ${hints.map((h) => `${h.c.join(" / ")} for ${h.s}`).join("; ")}?)`;
+          const base = "Symbols are this venue's directory symbols (case-sensitive): use stream.markets(), MarketUpdate.symbol or FundingLeg.symbol";
+          throw wsError(
+            "INVALID_PARAMS",
+            `${venue}: unknown symbol(s) ${missing.slice(0, 20).join(", ")}${hint}`,
+            venue === "hyperliquid" ? `${base}; HIP-3 markets need opts.hip3Dexes` : base,
+            hints.length === 0 ? void 0 : { suggestions: Object.fromEntries(hints.map((h) => [h.s, h.c])) }
+          );
+        }
+      }
+      list = codec.wiresFor(target, d, opts.staleAfterMs === void 0 ? null : opts.staleAfterMs);
+    }
+    const fresh = list.filter((w) => !wires.has(w.key));
+    if (opts.budget?.maxSockets !== void 0 && opts.budget.maxSockets < 1) {
+      throw wsError("SUBSCRIPTION_LIMIT", `${venue} needs 1 socket; budget.maxSockets is ${opts.budget.maxSockets}`, "Raise budget.maxSockets", { needed: 1, allowed: opts.budget.maxSockets });
+    }
+    const allowed = Math.min(codec.limits.subscriptionsPerSocket * maxSockets, opts.budget?.maxSubscriptions === void 0 ? Infinity : opts.budget.maxSubscriptions);
+    if (wires.size + fresh.length > allowed) {
+      throw wsError(
+        "SUBSCRIPTION_LIMIT",
+        `${venue}: ${wires.size + fresh.length} wire subscriptions needed, ${allowed} allowed`,
+        "Unsubscribe something, narrow the symbols, or raise budget.maxSubscriptions (\u2264 the venue limit)",
+        { needed: wires.size + fresh.length, allowed }
+      );
+    }
+    const placement = placeWires(fresh);
+    subs.set(sub, {
+      symbols: wanted === null ? null : new Set(wanted),
+      wires: list.map((w) => w.key),
+      userChannels: target.kind === "user" ? new Set(target.channels) : null
+    });
+    const now = clock();
+    for (const w of list) {
+      let st = wires.get(w.key);
+      if (st === void 0) {
+        const slot = placement.get(w.key);
+        st = {
+          wire: w,
+          shard: slot < shards.length ? shards[slot] : newShard(),
+          refs: /* @__PURE__ */ new Set(),
+          reqId: 0,
+          sentAt: null,
+          lastAt: null,
+          acked: false,
+          firstFrameSeen: false,
+          probe: false,
+          suspect: false,
+          ackTimer: null,
+          everAcked: false,
+          lastSeq: null
+        };
+        wires.set(w.key, st);
+        st.shard.wires.add(st);
+        sendSubscribe(st, now, true);
+      }
+      st.refs.add(sub);
+    }
+    for (const w of directoryWarnings) sub.emit(errorEvent("EXCHANGE_ERROR", w, null, null, false));
+    if (canonicalWarning !== null && canonicalWarning.type === "error") {
+      log("warn", "canonicals-missing", canonicalWarning.message, { missing: canonicalWarning.details?.missing });
+      sub.emit(canonicalWarning);
+    }
+    if (target.kind === "user") {
+      for (const w of list) {
+        const g = w.gaps?.onSubscribe;
+        if (g === void 0) continue;
+        for (const ch of g) {
+          if (!target.channels.includes(ch)) continue;
+          sub.emit({ type: "gap", venue, channel: ch, symbol: null, expected: null, got: null, action: "refetch-required" });
+          const st = wires.get(w.key);
+          if (ch === "orders" && st !== void 0) dispatchUser(st, userStore.currentOrders(clock()), sub);
+        }
+      }
+    }
+    maybeReady(sub);
+    for (const sh of new Set(list.map((w) => wires.get(w.key).shard))) sh.conn.ensureOpen();
+    reportState();
+  }
+  function placeWires(fresh) {
+    const perGroup = codec.limits.perGroup === void 0 ? {} : codec.limits.perGroup;
+    const inGroup = (groups, g) => {
+      const n = groups.get(g);
+      return n === void 0 ? 0 : n;
+    };
+    const load = shards.map((sh) => {
+      const on = wiresOn(sh);
+      const groups = /* @__PURE__ */ new Map();
+      for (const w of on) if (w.wire.group !== void 0) groups.set(w.wire.group, inGroup(groups, w.wire.group) + 1);
+      return { total: on.length, groups };
+    });
+    const out = /* @__PURE__ */ new Map();
+    for (const w of fresh) {
+      const cap = w.group === void 0 ? void 0 : perGroup[w.group];
+      const fits = (l) => l.total < codec.limits.subscriptionsPerSocket && (cap === void 0 || inGroup(l.groups, w.group) < cap);
+      let i = load.findIndex(fits);
+      if (i === -1 && load.length < maxSockets) {
+        load.push({ total: 0, groups: /* @__PURE__ */ new Map() });
+        i = load.length - 1;
+      }
+      if (i === -1) {
+        if (cap !== void 0) {
+          const needed = Array.from(wires.values()).filter((x) => x.wire.group === w.group).length + fresh.filter((x) => x.group === w.group).length;
+          const max = cap * maxSockets;
+          throw wsError(
+            "SUBSCRIPTION_LIMIT",
+            `${venue}: ${needed} "${w.group}" channels needed, ${cap} per connection \xD7 ${maxSockets} connection(s) = ${max} allowed`,
+            `Unsubscribe some ${w.group} channels${maxSockets < (codec.limits.maxSockets === void 0 ? 1 : codec.limits.maxSockets) ? ", or raise budget.maxSockets (\u2264 the venue limit)" : ""}`,
+            { needed, allowed: max }
+          );
+        }
+        throw wsError(
+          "SUBSCRIPTION_LIMIT",
+          `${venue}: no connection has room for ${w.key} (${codec.limits.subscriptionsPerSocket} per connection \xD7 ${maxSockets} connection(s))`,
+          "Unsubscribe something or narrow the symbols",
+          { needed: wires.size + fresh.length, allowed: codec.limits.subscriptionsPerSocket * maxSockets }
+        );
+      }
+      load[i].total++;
+      if (w.group !== void 0) load[i].groups.set(w.group, inGroup(load[i].groups, w.group) + 1);
+      out.set(w.key, i);
+    }
+    return out;
+  }
+  function checkAllMarketsTarget(t) {
+    const listOf = (v) => Array.isArray(v) && v.every((x) => typeof x === "string");
+    if (t.symbols !== void 0 && t.canonicals !== void 0) {
+      throw wsError(
+        "INVALID_PARAMS",
+        'kind "allMarkets": pass either symbols or canonicals, not both',
+        "canonicals for the same markets on several venues; symbols for this venue's exact directory symbols"
+      );
+    }
+    for (const k of ["symbols", "canonicals"]) {
+      const v = t[k];
+      if (v !== void 0 && (!listOf(v) || v.length === 0)) {
+        throw wsError("INVALID_PARAMS", `kind "allMarkets": ${k} must be a non-empty array of strings`, `Omit ${k} for every market`);
+      }
+    }
+  }
+  function symbolsForCanonicals(canonicals, entries) {
+    const want = new Set(canonicals);
+    const symbols = entries.filter((e) => e.canonical !== null && want.has(e.canonical)).map((e) => e.symbol);
+    const missing = Array.from(new Set(canonicals.filter((c) => !entries.some((e) => e.canonical === c))));
+    if (missing.length === 0) return { symbols, warning: null };
+    const pairs = missing.map((c) => ({ c, s: suggestCanonicals(c, entries) }));
+    const suggestions = Object.fromEntries(pairs.map((p) => [p.c, p.s]));
+    const withHints = pairs.filter((p) => p.s.length > 0);
+    const hint = withHints.length === 0 ? "" : ` (did you mean ${withHints.slice(0, 20).map((p) => `${p.s.join(" / ")} for ${p.c}`).join("; ")}?)`;
+    const remediation = `Canonicals are "<BASE>" (USD-like quotes) or "<dex>:<BASE>" (HIP-3${venue === "hyperliquid" ? ", needs opts.hip3Dexes" : ""}); see MarketDirectoryEntry.canonical in stream.markets()`;
+    const list = missing.slice(0, 20).join(", ");
+    if (symbols.length === 0) {
+      throw wsError(
+        "INVALID_PARAMS",
+        `${venue}: no market with canonical(s) ${list}${hint}`,
+        remediation,
+        withHints.length === 0 ? void 0 : { suggestions: Object.fromEntries(withHints.map((p) => [p.c, p.s])) }
+      );
+    }
+    const message = `${venue}: no market with canonical(s) ${list}${hint}; subscribed to the other ${canonicals.length - missing.length}`;
+    return { symbols, warning: errorEvent("SYMBOL_NOT_FOUND", message, remediation, null, false, { missing, suggestions }) };
+  }
+  function checkUserTarget(channels) {
+    if (codec.user === null) {
+      const note = codec.capabilities.notes.user;
+      throw wsError("CAPABILITY_UNSUPPORTED", `${venue} user channels are not available in this release`, note === void 0 ? void 0 : note);
+    }
+    if (codec.user.inPageSecrets && isBrowserLike() && opts.allowInPageSecrets !== true) {
+      throw wsError(
+        "CAPABILITY_UNSUPPORTED",
+        `${venue} user channels need a signing secret in the page`,
+        "Pass allowInPageSecrets: true to accept that trade-off, or run the stream server-side (the /node entry)"
+      );
+    }
+    if (!Array.isArray(channels)) throw wsError("INVALID_PARAMS", 'kind "user" needs a channels array', `Use ${USER_CHANNELS.join(" / ")}`);
+    const bad = channels.filter((c) => !USER_CHANNELS.includes(c));
+    if (channels.length === 0 || bad.length > 0) {
+      throw wsError(
+        "INVALID_PARAMS",
+        channels.length === 0 ? 'kind "user" needs at least one channel' : `unknown user channel(s) ${bad.join(", ")}`,
+        `Use ${USER_CHANNELS.join(" / ")}`
+      );
+    }
+    if (opts.credentials === void 0) {
+      throw wsError(
+        "WS_AUTH_FAILED",
+        `${venue} user channels need opts.credentials (CredentialProvider.user())`,
+        "Pass credentials: { user: async () => ({ venue, \u2026 }) }; the library never holds keys"
+      );
+    }
+  }
+  async function resolveUser() {
+    if (userRef !== null) return userRef;
+    const provider = opts.credentials;
+    if (provider === void 0) throw wsError("WS_AUTH_FAILED", `${venue}: no credential provider`);
+    let ref;
+    try {
+      ref = await provider.user();
+    } catch (e) {
+      throw toAuthError(e);
+    }
+    const problem = userRefProblem(venue, ref);
+    if (problem !== null) throw wsError("INVALID_PARAMS", `${venue} credentials.user(): ${problem}`, "Return the UserRef shape documented for this venue");
+    if (userRef === null) userRef = ref;
+    return userRef;
+  }
+  function terminalCheck() {
+    if (url === null) return;
+    const agg = aggregateState();
+    if (agg.status !== "closed") return;
+    const r = agg.reason;
+    if (r.code === "CLIENT_CLOSE") throw closedError(venue);
+    throw wsError(r.code, `${venue} stream is closed: ${r.message}`, r.remediation === null ? "Create a new stream" : r.remediation);
+  }
+  function subscribe(target) {
+    const sub = new SubscriptionImpl(
+      venue,
+      bufferSize,
+      async (s) => {
+        releaseWires(s);
+        s.end();
+      },
+      (e) => log("warn", "listener-error", `subscription listener threw: ${e instanceof Error ? e.message : String(e)}`),
+      (s, err) => {
+        log("error", "overflow", err.message);
+        dropSub(s, err);
+      }
+    );
+    activate(sub, target).catch((e) => {
+      const err = e instanceof WsError ? e : wsError("EXCHANGE_ERROR", e instanceof Error ? e.message : String(e));
+      log("warn", "subscribe-rejected", err.message, { code: err.structured.code });
+      dropSub(sub, err);
+    });
+    return sub;
+  }
+  const stream = {
+    venue,
+    network,
+    capabilities: codec.capabilities,
+    staleAfterMs: opts.staleAfterMs === void 0 ? codec.staleAfterMs : opts.staleAfterMs,
+    get state() {
+      if (url === null) {
+        return { status: "closed", reason: { code: "CAPABILITY_UNSUPPORTED", message: `${venue} has no WebSocket on ${network}`, wsCode: null, remediation: null } };
+      }
+      return aggregateState();
+    },
+    subscribe,
+    onState(cb) {
+      stateListeners.add(cb);
+      return () => {
+        stateListeners.delete(cb);
+      };
+    },
+    async markets() {
+      const d = await loadDirectory();
+      return d.entries.slice();
+    },
+    async close() {
+      if (closed) return;
+      closed = true;
+      if (refreshTimer !== null) {
+        clearInterval(refreshTimer);
+        refreshTimer = null;
+      }
+      for (const t of tokens.values()) if (t.timer !== null) {
+        clearTimeout(t.timer);
+        t.timer = null;
+      }
+      for (const t of tokenRetryTimers) clearTimeout(t);
+      tokenRetryTimers.clear();
+      tokenLoops.clear();
+      for (const w of wires.values()) clearAckTimer(w);
+      wires.clear();
+      for (const sh of shards) sh.wires.clear();
+      for (const sh of shards) sh.conn.close();
+      for (const sub of Array.from(subs.keys())) {
+        subs.delete(sub);
+        sub.end();
+      }
+      stateListeners.clear();
+    }
+  };
+  return stream;
+}
+
+// src/ws/venue-static.ts
+var VENUE_STATIC = {
+  hyperliquid: {
+    wsUrl: { mainnet: "wss://api.hyperliquid.xyz/ws", testnet: "wss://api.hyperliquid-testnet.xyz/ws" },
+    restUrl: { mainnet: "https://api.hyperliquid.xyz", testnet: "https://api.hyperliquid-testnet.xyz" },
+    rateIntervalHours: 1,
+    settlementIntervalHours: 1,
+    fundingVerified: true,
+    // Idle limit 60 s (Phase 0: closed at 60.1 s, no close frame).
+    ping: { message: JSON.stringify({ method: "ping" }), everyMs: 2e4 },
+    // allDexsAssetCtxs cadence ~11–15 s (Phase 0) → 30 s; per-coin activeAssetCtx uses 10 s.
+    staleAfterMs: 3e4,
+    // Per IP: 1000 subs, 10 conns, 30 new conns/min, 2000 msgs/min.
+    limits: { subscriptionsPerSocket: 1e3, newConnectionsPerMin: 30, outboundPerMin: 2e3 }
+  },
+  pacifica: {
+    wsUrl: { mainnet: "wss://ws.pacifica.fi/ws", testnet: "wss://test-ws.pacifica.fi/ws" },
+    restUrl: { mainnet: "https://api.pacifica.fi/api/v1", testnet: "https://test-api.pacifica.fi/api/v1" },
+    rateIntervalHours: 1,
+    settlementIntervalHours: 1,
+    fundingVerified: true,
+    ping: { message: JSON.stringify({ method: "ping" }), everyMs: 2e4 },
+    staleAfterMs: 1e4,
+    // `prices` every 3 s
+    // docs.pacifica.fi/api-documentation/api/rate-limits: max 100 concurrent connections per IP, max
+    // 20 subscriptions per channel per connection → perGroup (one group per channel `source`) and up
+    // to 50 sockets per stream (half the per-IP cap: other streams / processes share the IP). The
+    // server closes a socket after 60 s without a client message (ping every 20 s) and at 24 h
+    // (reconnect + resubscribe). No documented total per socket, new-connection rate or outbound
+    // rate: those are library self-limits, not venue values.
+    limits: {
+      subscriptionsPerSocket: 100,
+      newConnectionsPerMin: 60,
+      outboundPerMin: 1e3,
+      maxSockets: 50,
+      perGroup: { prices: 20, bbo: 20, account_info: 20, account_positions: 20, account_order_updates: 20, account_trades: 20 }
+    }
+  },
+  lighter: {
+    wsUrl: { mainnet: "wss://mainnet.zklighter.elliot.ai/stream", testnet: "wss://testnet.zklighter.elliot.ai/stream" },
+    restUrl: { mainnet: "https://mainnet.zklighter.elliot.ai", testnet: "https://testnet.zklighter.elliot.ai" },
+    // WS funding_rate / current_funding_rate are PERCENT per 1 h (Phase 0); the CLI REST basis
+    // (perHours 8) applies to REST /api/v1/funding-rates only.
+    rateIntervalHours: 1,
+    settlementIntervalHours: 1,
+    fundingVerified: true,
+    ping: { message: JSON.stringify({ type: "ping" }), everyMs: 3e4 },
+    // idle limit 120 s
+    staleAfterMs: 1e4,
+    // market_stats/all updates ~1 s
+    limits: { subscriptionsPerSocket: 500, newConnectionsPerMin: 255, outboundPerMin: 200 }
+  },
+  "lighter-rh": {
+    // Testnet WS answers HTTP 403 (CloudFront, Phase 0) → unsupported.
+    wsUrl: { mainnet: "wss://api.rh.lighter.xyz/stream", testnet: null },
+    restUrl: { mainnet: "https://api.rh.lighter.xyz", testnet: "https://api.rh-testnet.lighter.xyz" },
+    rateIntervalHours: 1,
+    settlementIntervalHours: 1,
+    fundingVerified: true,
+    ping: { message: JSON.stringify({ type: "ping" }), everyMs: 3e4 },
+    staleAfterMs: 1e4,
+    limits: { subscriptionsPerSocket: 500, newConnectionsPerMin: 255, outboundPerMin: 200 }
+  },
+  aster: {
+    wsUrl: { mainnet: "wss://fstream.asterdex.com", testnet: "wss://fstream.asterdex-testnet.com" },
+    restUrl: { mainnet: "https://fapi.asterdex.com", testnet: "https://fapi.asterdex-testnet.com" },
+    rateIntervalHours: "perMarket",
+    // rest:/fapi/v3/fundingInfo
+    settlementIntervalHours: "perMarket",
+    fundingVerified: true,
+    ping: null,
+    // server protocol pings, answered by the runtime
+    staleAfterMs: 5e3,
+    // markPrice@1s
+    // 200 streams/conn, 10 client→server msgs/s. No documented new-connection rate: a library self-limit.
+    limits: { subscriptionsPerSocket: 200, newConnectionsPerMin: 60, outboundPerMin: 600 }
+  },
+  arcus: {
+    wsUrl: { mainnet: "wss://api.arcus.xyz/v1/ws", testnet: "wss://api.testnet.arcus.xyz/v1/ws" },
+    restUrl: { mainnet: "https://api.arcus.xyz", testnet: "https://api.testnet.arcus.xyz" },
+    rateIntervalHours: 1,
+    settlementIntervalHours: 1,
+    fundingVerified: true,
+    ping: { message: JSON.stringify({ type: "ping" }), everyMs: 3e4 },
+    staleAfterMs: 15e3,
+    // `markets` every ~5 s
+    limits: { subscriptionsPerSocket: 100, newConnectionsPerMin: 50, outboundPerMin: 1e3 }
+  }
+};
+
+// src/ws/funding.ts
+var COMPARATOR_KINDS = ["current", "next", "predicted", "lastSettled", "accruing"];
+function toHourly(rate, rateIntervalHours) {
+  if (rate === null || rateIntervalHours === null || !(rateIntervalHours > 0)) return null;
+  const n = Number(rate);
+  return Number.isFinite(n) ? n / rateIntervalHours : null;
+}
+function toApr(rate, rateIntervalHours) {
+  const h = toHourly(rate, rateIntervalHours);
+  return h === null ? null : h * 24 * 365;
+}
+function pick(u, kind, predictedPublished) {
+  const f = u.funding;
+  const predicted = () => {
+    if (f.rateKind === "predicted") return { rate: f.rate, rateKind: "predicted", field: "rate", unavailable: false };
+    return predictedPublished ? { rate: f.predictedRate, rateKind: "predicted", field: "predictedRate", unavailable: false } : { rate: null, rateKind: null, field: "predictedRate", unavailable: true };
+  };
+  switch (kind) {
+    case "current":
+      return { rate: f.rate, rateKind: f.rateKind, field: "rate", unavailable: false };
+    case "predicted":
+      return predicted();
+    case "lastSettled":
+    case "accruing":
+      return f.rateKind === kind ? { rate: f.rate, rateKind: kind, field: "rate", unavailable: false } : { rate: null, rateKind: null, field: "rate", unavailable: true };
+    case "next":
+      if (f.rateKind === "accruing") return { rate: f.rate, rateKind: "accruing", field: "rate", unavailable: false };
+      return predicted();
+  }
+}
+function checkOptions(opts) {
+  const bad = (message, remediation) => {
+    throw new WsError("INVALID_PARAMS", `createFundingComparator: ${message}`, { remediation });
+  };
+  if (opts === null || typeof opts !== "object") bad("options must be an object", "Pass { streams: [...] }");
+  if (!Array.isArray(opts.streams) || opts.streams.some((s) => s === null || typeof s !== "object" || typeof s.subscribe !== "function" || typeof s.markets !== "function")) {
+    bad("streams must be an array of VenueStream", "Pass streams created with createVenueStream()");
+  }
+  if (opts.kind !== void 0 && !COMPARATOR_KINDS.includes(opts.kind)) {
+    bad(`unknown kind ${JSON.stringify(opts.kind)}`, `Use kind ${COMPARATOR_KINDS.map((k) => `"${k}"`).join(" / ")}`);
+  }
+  if (opts.minVenues !== void 0 && !(Number.isInteger(opts.minVenues) && opts.minVenues >= 1)) {
+    bad(`minVenues must be a positive integer (got ${String(opts.minVenues)})`, "Pass minVenues \u2265 1, or omit it (default 2)");
+  }
+  if (opts.include !== void 0 && !(Array.isArray(opts.include) && opts.include.every((c) => typeof c === "string"))) {
+    bad("include must be an array of canonical symbols", 'Pass e.g. include: ["BTC", "ETH"], or omit it');
+  }
+  if (opts.staleAfterMs !== void 0 && !(typeof opts.staleAfterMs === "number" && Number.isFinite(opts.staleAfterMs) && opts.staleAfterMs > 0)) {
+    bad(`staleAfterMs must be a positive number (got ${String(opts.staleAfterMs)})`, "Pass milliseconds > 0, or omit it (venue default)");
+  }
+  for (const k of ["canonicalize", "onControl", "clock"]) {
+    if (opts[k] !== void 0 && typeof opts[k] !== "function") bad(`${k} must be a function`, `Pass a function or omit ${k}`);
+  }
+}
+function createFundingComparator(opts) {
+  checkOptions(opts);
+  const kind = opts.kind === void 0 ? "current" : opts.kind;
+  const minVenues = opts.minVenues === void 0 ? 2 : opts.minVenues;
+  const include = opts.include === void 0 ? null : new Set(opts.include);
+  const clock = opts.clock === void 0 ? () => Date.now() : opts.clock;
+  const latest = /* @__PURE__ */ new Map();
+  const dirs = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  const subs = [];
+  const pending = /* @__PURE__ */ new Set();
+  let scheduled = false;
+  let closed = false;
+  function canonicalOf(stream, u) {
+    if (opts.canonicalize === void 0) return u.canonical;
+    const e = dirs.get(stream)?.get(u.symbol);
+    if (e === void 0) return null;
+    return opts.canonicalize(u.venue, { venueSymbol: u.venueSymbol, dex: u.dex, base: e.base, quote: u.quote });
+  }
+  function threshold(stream) {
+    if (opts.staleAfterMs !== void 0) return opts.staleAfterMs;
+    return (stream.venue === "arcus" ? 3 : 2) * stream.staleAfterMs;
+  }
+  function leg(stream, u, now) {
+    const p = pick(u, kind, stream.capabilities.fields.predictedRate);
+    const at = u.asOf[p.field];
+    const asOf = at === void 0 ? null : at;
+    const st = VENUE_STATIC[u.venue];
+    return {
+      venue: u.venue,
+      dex: u.dex,
+      symbol: u.symbol,
+      quote: u.quote,
+      mark: u.mark,
+      rate: p.rate,
+      rateKind: p.rateKind,
+      kindUnavailable: p.unavailable,
+      funding: u.funding,
+      fundingVerified: st === void 0 ? false : st.fundingVerified,
+      asOf,
+      stale: stream.state.status !== "live" || asOf === null || now - asOf > threshold(stream)
+    };
+  }
+  function rows() {
+    const now = clock();
+    const groups = /* @__PURE__ */ new Map();
+    for (const { stream, u } of latest.values()) {
+      const c = canonicalOf(stream, u);
+      if (c === null || include !== null && !include.has(c)) continue;
+      let g = groups.get(c);
+      if (g === void 0) {
+        g = [];
+        groups.set(c, g);
+      }
+      g.push(leg(stream, u, now));
+    }
+    const out = [];
+    for (const [canonical, legs] of groups) {
+      const withRate = legs.filter((l) => l.rate !== null);
+      if (new Set(withRate.map((l) => l.venue)).size < minVenues) continue;
+      const kinds = new Set(withRate.map((l) => l.rateKind));
+      legs.sort((a, b) => a.venue < b.venue ? -1 : a.venue > b.venue ? 1 : a.symbol < b.symbol ? -1 : 1);
+      out.push({ canonical, mixedKinds: kinds.size > 1, legs });
+    }
+    out.sort((a, b) => a.canonical < b.canonical ? -1 : a.canonical > b.canonical ? 1 : 0);
+    return out;
+  }
+  function schedule(changed) {
+    pending.add(changed);
+    if (scheduled || listeners.size === 0) return;
+    scheduled = true;
+    Promise.resolve().then(() => {
+      scheduled = false;
+      if (closed) return;
+      const ch = Array.from(pending);
+      pending.clear();
+      const r = rows();
+      for (const l of listeners) {
+        try {
+          l(r, ch);
+        } catch (e) {
+          const message = `funding comparator listener threw: ${e instanceof Error ? e.message : String(e)}`;
+          if (opts.onControl !== void 0) {
+            try {
+              opts.onControl({ type: "listener-error", message });
+            } catch {
+            }
+          }
+        }
+      }
+    });
+  }
+  for (const stream of opts.streams) {
+    stream.markets().then(
+      (entries) => {
+        dirs.set(stream, new Map(entries.map((e) => [e.symbol, e])));
+      },
+      () => void 0
+      // the subscription below reports the same failure as an error control
+    );
+    const sub = stream.subscribe({ kind: "allMarkets" });
+    subs.push(sub);
+    sub.on((e) => {
+      if (e.type === "market") {
+        latest.set(`${e.venue}|${e.symbol}`, { stream, u: e });
+        const c = canonicalOf(stream, e);
+        if (c !== null) schedule(c);
+        return;
+      }
+      if (opts.onControl !== void 0) opts.onControl(e);
+      if (e.type === "state") {
+        for (const { stream: s, u } of latest.values()) {
+          if (s !== stream) continue;
+          const c = canonicalOf(s, u);
+          if (c !== null) schedule(c);
+        }
+      }
+    });
+  }
+  return {
+    rows,
+    subscribe(cb) {
+      listeners.add(cb);
+      return () => {
+        listeners.delete(cb);
+      };
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      listeners.clear();
+      for (const s of subs) void s.unsubscribe();
+    }
+  };
+}
+
+// src/ws/directory.ts
+async function fetchJson(fetch, venue, url, init) {
+  let res;
+  try {
+    res = await fetch(url, init);
+  } catch (e) {
+    throw new WsError("EXCHANGE_UNREACHABLE", `${venue} REST ${pathOf(url)} unreachable: ${e instanceof Error ? e.message : String(e)}`, {
+      exchange: venue,
+      remediation: "Check network access to the venue REST host (and CORS in a browser), then subscribe again"
+    });
+  }
+  if (!res.ok) {
+    throw new WsError(res.status === 429 ? "RATE_LIMITED" : "EXCHANGE_ERROR", `${venue} REST ${pathOf(url)} returned HTTP ${res.status}`, {
+      exchange: venue,
+      remediation: res.status === 429 ? "Wait and subscribe again (REST rate limit)" : "Retry later; the venue REST endpoint failed"
+    });
+  }
+  try {
+    return await res.json();
+  } catch {
+    throw new WsError("EXCHANGE_ERROR", `${venue} REST ${pathOf(url)} returned a non-JSON body`, { exchange: venue });
+  }
+}
+function badShape(venue, what) {
+  return new WsError("EXCHANGE_ERROR", `${venue} ${what}`, {
+    exchange: venue,
+    remediation: "The venue response shape changed; report it (perp-cli/ws cannot build the market directory)"
+  });
+}
+function pathOf(url) {
+  const m = /^[a-z]+:\/\/[^/]+(\/[^?#]*)?/i.exec(url);
+  return m !== null && m[1] !== void 0 ? m[1] : url;
+}
+
+// src/ws/dec.ts
+var DECIMAL_RE = /^([+-]?)(\d*)(?:\.(\d*))?(?:[eE]([+-]?\d+))?$/;
+function toDec(v) {
+  if (v === null || v === void 0) return null;
+  if (typeof v === "string") {
+    const m = DECIMAL_RE.exec(v);
+    return m !== null && (m[2] !== "" || m[3] !== void 0 && m[3] !== "") ? v : void 0;
+  }
+  if (typeof v === "number") return Number.isFinite(v) ? String(v) : void 0;
+  return void 0;
+}
+function shiftDecimal(s, places) {
+  const m = DECIMAL_RE.exec(s);
+  if (m === null || m[2] === "" && (m[3] === void 0 || m[3] === "")) return void 0;
+  const sign = m[1] === "-" ? "-" : "";
+  const intPart = m[2];
+  const fracPart = m[3] === void 0 ? "" : m[3];
+  const exp = (m[4] === void 0 ? 0 : parseInt(m[4], 10)) + places;
+  let digits = intPart + fracPart;
+  let point = intPart.length + exp;
+  if (point <= 0) {
+    digits = "0".repeat(1 - point) + digits;
+    point = 1;
+  }
+  if (point > digits.length) digits = digits + "0".repeat(point - digits.length);
+  let int = digits.slice(0, point).replace(/^0+(?=\d)/, "");
+  const frac = digits.slice(point).replace(/0+$/, "");
+  if (int === "") int = "0";
+  const out = frac === "" ? int : `${int}.${frac}`;
+  return /^0(\.0*)?$/.test(out) ? "0" : sign + out;
+}
+function mulDecimalInt(s, n, shift) {
+  if (!Number.isInteger(n)) return void 0;
+  const m = DECIMAL_RE.exec(s);
+  if (m === null || m[4] !== void 0 || m[2] === "" && (m[3] === void 0 || m[3] === "")) return void 0;
+  const frac = m[3] === void 0 ? "" : m[3];
+  const digits = `${m[2]}${frac}`.replace(/^0+(?=\d)/, "");
+  const product = BigInt(digits === "" ? "0" : digits) * BigInt(n) * (m[1] === "-" ? -1n : 1n);
+  const neg = product < 0n;
+  const abs2 = (neg ? -product : product).toString();
+  return shiftDecimal(`${neg ? "-" : ""}${abs2}`, shift - frac.length);
+}
+
+// src/ws/codecs/common.ts
+function isObj(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function parseFrame(text) {
+  try {
+    return { ok: true, v: JSON.parse(text) };
+  } catch {
+    return { ok: false, ev: protocolError("Frame is not valid JSON") };
+  }
+}
+function protocolError(message, wire = null) {
+  return { t: "error", code: "WS_PROTOCOL_ERROR", message, wire, fatal: false, remediation: null };
+}
+function venueError(code, message, wire, fatal, remediation) {
+  return { t: "error", code, message, wire, fatal, remediation };
+}
+function unrecognised(venue) {
+  return protocolError(`Unrecognised ${venue} frame`);
+}
+function readDec(o, key, bad) {
+  if (!(key in o)) return void 0;
+  const d = toDec(o[key]);
+  if (d === void 0) bad.push(key);
+  return d;
+}
+function readTs(o, key, bad, scale = 1) {
+  if (!(key in o)) return void 0;
+  const v = o[key];
+  if (v === null) return null;
+  if (typeof v === "number" && Number.isFinite(v)) return v * scale;
+  bad.push(key);
+  return void 0;
+}
+function compact(o) {
+  for (const k of Object.keys(o)) if (o[k] === void 0) delete o[k];
+  return o;
+}
+function badFieldsError(venue, wire, bad) {
+  const list = bad.slice(0, 5).map((b) => `${b.symbol}: ${b.fields.join("/")}`).join("; ");
+  return protocolError(`${venue} ${wire}: unparseable field value(s) left unchanged (${list}${bad.length > 5 ? "; \u2026" : ""})`, wire);
+}
+function level(o, bad, name) {
+  if (o === null || o === void 0) return [null, null];
+  if (!isObj(o)) {
+    bad.push(name);
+    return [null, null];
+  }
+  const p = readDec(o, "price", bad);
+  const s = readDec(o, "size", bad);
+  return [p === void 0 ? null : p, s === void 0 ? null : s];
+}
+function pick2(m, v) {
+  return typeof v === "string" && Object.prototype.hasOwnProperty.call(m, v) ? m[v] : null;
+}
+function idOf(v) {
+  if (typeof v === "string" && v !== "") return v;
+  if (typeof v === "number" && Number.isFinite(v)) return String(v);
+  return null;
+}
+function dec(o, key, bad) {
+  const v = readDec(o, key, bad);
+  return v === void 0 ? null : v;
+}
+function ts(o, key, bad, scale = 1) {
+  const v = readTs(o, key, bad, scale);
+  return v === void 0 || v === null ? null : Math.floor(v);
+}
+function nextHour(ts2) {
+  return Math.floor(ts2 / 36e5) * 36e5 + 36e5;
+}
+function capabilities(p) {
+  return {
+    browser: true,
+    // Phase 0: no WS server checks Origin; REST CORS is `*`
+    networks: { mainnet: true, testnet: p.testnet },
+    channels: { allMarkets: true, market: true, bbo: true, book: false, trades: false, user: p.user },
+    fields: p.fields,
+    notes: {
+      book: "Not in this release (0.15.1)",
+      trades: "Not in this release (0.15.1)",
+      ...p.user ? {} : { user: "Not in this release (0.15.1)" },
+      ...p.notes
+    }
+  };
+}
+
+// src/ws/codecs/hyperliquid.ts
+var S = VENUE_STATIC.hyperliquid;
+var ALL = "allDexsAssetCtxs";
+var PER_COIN_STALE_MS = 1e4;
+function data(dir) {
+  return dir.data;
+}
+function universeOf(v, dex) {
+  if (!isObj(v) || !Array.isArray(v.universe)) throw badShape("hyperliquid", `meta${dex ? `{dex:${dex}}` : ""} has no universe array`);
+  const out = v.universe.map((u) => {
+    if (!isObj(u) || typeof u.name !== "string") throw badShape("hyperliquid", `meta${dex ? `{dex:${dex}}` : ""} universe entry has no name`);
+    return { name: u.name, delisted: u.isDelisted === true };
+  });
+  return Object.assign(out, { collateralToken: v.collateralToken });
+}
+function patchFromCtx(symbol, ctx, recvTs, bad) {
+  return compact({
+    symbol,
+    venueTs: null,
+    // ctx frames carry no timestamp
+    mark: readDec(ctx, "markPx", bad),
+    index: readDec(ctx, "oraclePx", bad),
+    rate: readDec(ctx, "funding", bad),
+    openInterest: readDec(ctx, "openInterest", bad),
+    volume24hNotional: readDec(ctx, "dayNtlVlm", bad),
+    nextFundingTime: nextHour(recvTs)
+    // hourly settlement (venue-definition)
+  });
+}
+function subscriptionKey(sub) {
+  if (!isObj(sub)) return null;
+  if (sub.type === ALL) return ALL;
+  if (sub.type === "activeAssetCtx" && typeof sub.coin === "string") return `activeAssetCtx:${sub.coin}`;
+  if (sub.type === "bbo" && typeof sub.coin === "string") return `bbo:${sub.coin}`;
+  if (sub.type === "clearinghouseState" || sub.type === "openOrders") return `${sub.type}:${typeof sub.dex === "string" ? sub.dex : ""}`;
+  if (sub.type === "orderUpdates" || sub.type === "userFills") return sub.type;
+  return null;
+}
+var hyperliquid = {
+  venue: "hyperliquid",
+  capabilities: capabilities({
+    testnet: true,
+    user: true,
+    fields: {
+      mark: true,
+      index: true,
+      bestBid: false,
+      bestAsk: false,
+      last: false,
+      predictedRate: false,
+      nextFundingTime: true,
+      fundingInterval: true,
+      openInterest: true,
+      volume24hNotional: true
+    },
+    notes: {
+      bestBid: "Not in asset ctxs; use the bbo channel (Phase 2)",
+      bestAsk: "Not in asset ctxs; use the bbo channel (Phase 2)",
+      last: "Not in asset ctxs",
+      predictedRate: "HL publishes no predicted rate; `rate` (ctx.funding) is the accruing current-hour rate",
+      nextFundingTime: "Hourly settlement rule (venue-definition)",
+      openInterest: "Base units, one side",
+      user: "By address, no auth. clearinghouseState/openOrders per selected dex (opts.hip3Dexes); userFills is replayable (deduped by tid)",
+      clientId: "orders: cloid (null when the order has none). fills: cloid only when the frame carries it (WsFill documents none) \u2014 else null; join OrderRow.clientId by orderId",
+      liquidationPrice: "liquidationPx (null when the venue sends null, e.g. no liquidation risk)",
+      fee: "fee in feeToken (negative = rebate)",
+      bbo: "bbo{coin}: full top of book per frame, no sequence"
+    }
+  }),
+  url: (n) => S.wsUrl[n],
+  restUrl: (n) => S.restUrl[n],
+  secretKeys: [],
+  secretUrlPatterns: [],
+  ping: S.ping,
+  limits: S.limits,
+  closesOnBadSubscribe: true,
+  staleAfterMs: S.staleAfterMs,
+  openInterest: { unit: "base", sides: "one" },
+  refresh: null,
+  async loadDirectory(ctx) {
+    const info = (body) => fetchJson(ctx.fetch, "hyperliquid", `${ctx.restUrl}/info`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    let hip3 = [];
+    if (ctx.hip3Dexes === "all" || ctx.hip3Dexes.length > 0) {
+      const raw = await info({ type: "perpDexs" });
+      if (!Array.isArray(raw)) throw badShape("hyperliquid", "perpDexs is not an array");
+      const names = raw.filter(isObj).map((d) => d.name).filter((n) => typeof n === "string");
+      if (ctx.hip3Dexes === "all") hip3 = names;
+      else {
+        const unknown = ctx.hip3Dexes.filter((d) => !names.includes(d));
+        if (unknown.length > 0) {
+          throw new WsError("INVALID_PARAMS", `hyperliquid: unknown HIP-3 dex(es) ${unknown.join(", ")}`, {
+            exchange: "hyperliquid",
+            remediation: `Known dexes: ${names.join(", ")}`
+          });
+        }
+        hip3 = ctx.hip3Dexes.slice();
+      }
+    }
+    const [spot, ...metas] = await Promise.all([
+      info({ type: "spotMeta" }),
+      info({ type: "meta" }),
+      ...hip3.map((dex) => info({ type: "meta", dex }))
+    ]);
+    const tokens = /* @__PURE__ */ new Map();
+    if (isObj(spot) && Array.isArray(spot.tokens)) {
+      for (const t of spot.tokens) if (isObj(t) && typeof t.index === "number" && typeof t.name === "string") tokens.set(t.index, t.name);
+    }
+    const dexes = /* @__PURE__ */ new Map();
+    const entries = [];
+    ["", ...hip3].forEach((dex, i) => {
+      const uni = universeOf(metas[i], dex);
+      const ct = uni.collateralToken;
+      const quoteName = typeof ct === "number" ? tokens.get(ct) : void 0;
+      const quote = quoteName === void 0 ? null : quoteName;
+      dexes.set(dex, { names: uni.map((u) => u.delisted ? null : u.name) });
+      for (const u of uni) {
+        if (u.delisted) continue;
+        const base = dex === "" ? u.name : u.name.slice(u.name.indexOf(":") + 1);
+        const d = dex === "" ? null : dex;
+        entries.push({
+          venue: "hyperliquid",
+          dex: d,
+          symbol: u.name,
+          venueSymbol: u.name,
+          base,
+          quote,
+          canonical: ctx.canonicalize("hyperliquid", { venueSymbol: u.name, dex: d, base, quote }),
+          rateIntervalHours: 1,
+          settlementIntervalHours: 1,
+          source: "rest:/info"
+        });
+      }
+    });
+    return { entries, data: { dexes } };
+  },
+  fundingMeta: () => ({
+    rateKind: "accruing",
+    rateSource: "ws",
+    rateIntervalHours: 1,
+    settlementIntervalHours: 1,
+    intervalSource: "venue-definition",
+    intervalAsOf: null,
+    marketClosed: null
+  }),
+  wiresFor(target, _dir, staleOverrideMs) {
+    if (target.kind === "allMarkets") {
+      return [{ key: ALL, staleAfterMs: staleOverrideMs === null ? S.staleAfterMs : staleOverrideMs, params: { type: ALL } }];
+    }
+    const out = [];
+    if (target.channels.includes("market")) {
+      out.push({
+        key: `activeAssetCtx:${target.symbol}`,
+        staleAfterMs: staleOverrideMs === null ? PER_COIN_STALE_MS : staleOverrideMs,
+        params: { type: "activeAssetCtx", coin: target.symbol }
+      });
+    }
+    if (target.channels.includes("bbo")) out.push({ key: `bbo:${target.symbol}`, staleAfterMs: null, params: { type: "bbo", coin: target.symbol } });
+    return out;
+  },
+  user: {
+    inPageSecrets: false,
+    wires(ref, channels, dir) {
+      if (ref.venue !== "hyperliquid") return [];
+      const user = ref.address;
+      const dexes = Array.from(data(dir).dexes.keys());
+      const dexParam = (dex) => dex === "" ? {} : { dex };
+      const out = [];
+      if (channels.includes("account") || channels.includes("positions")) {
+        for (const dex of dexes) out.push({ key: `clearinghouseState:${dex}`, staleAfterMs: null, params: { type: "clearinghouseState", user, ...dexParam(dex) } });
+      }
+      if (channels.includes("orders")) {
+        for (const dex of dexes) out.push({ key: `openOrders:${dex}`, staleAfterMs: null, params: { type: "openOrders", user, ...dexParam(dex) } });
+        out.push({ key: "orderUpdates", staleAfterMs: null, params: { type: "orderUpdates", user } });
+      }
+      if (channels.includes("fills")) out.push({ key: "userFills", staleAfterMs: null, params: { type: "userFills", user } });
+      return out;
+    }
+  },
+  encodeSubscribe: (w) => JSON.stringify({ method: "subscribe", subscription: w.params }),
+  encodeUnsubscribe: (w) => JSON.stringify({ method: "unsubscribe", subscription: w.params }),
+  decode(text, dir, recvTs) {
+    const p = parseFrame(text);
+    if (!p.ok) return [p.ev];
+    const f = p.v;
+    if (!isObj(f) || typeof f.channel !== "string") return [unrecognised("hyperliquid")];
+    switch (f.channel) {
+      case "pong":
+        return [{ t: "pong" }];
+      case "subscriptionResponse": {
+        if (!isObj(f.data)) return [unrecognised("hyperliquid")];
+        return [{ t: "ack", wire: subscriptionKey(f.data.subscription), reqId: null, unsubscribe: f.data.method === "unsubscribe" }];
+      }
+      case "error": {
+        const text2 = typeof f.data === "string" ? f.data : JSON.stringify(f.data);
+        const wire = rejectedWire(text2);
+        return [{ t: "error", code: "WS_PROTOCOL_ERROR", message: `hyperliquid error: ${text2}`, wire, fatal: wire !== null, remediation: null }];
+      }
+      case ALL:
+        return decodeAll(f, data(dir), recvTs);
+      case "clearinghouseState":
+        return decodeClearinghouse(f.data);
+      case "openOrders":
+        return decodeOpenOrders(f.data);
+      case "orderUpdates":
+        return decodeOrderUpdates(f.data, data(dir));
+      case "userFills":
+        return decodeFills(f.data);
+      case "bbo":
+        return decodeBbo(f.data);
+      case "activeAssetCtx": {
+        if (!isObj(f.data) || typeof f.data.coin !== "string" || !isObj(f.data.ctx)) return [protocolError("hyperliquid activeAssetCtx frame without coin/ctx")];
+        const wire = `activeAssetCtx:${f.data.coin}`;
+        const bad = [];
+        const out = [{ t: "market", wire, patches: [patchFromCtx(f.data.coin, f.data.ctx, recvTs, bad)] }];
+        if (bad.length > 0) out.push(badFieldsError("hyperliquid", wire, [{ symbol: f.data.coin, fields: bad }]));
+        return out;
+      }
+      default:
+        return [unrecognised("hyperliquid")];
+    }
+  }
+};
+function dexOf(coin) {
+  const i = coin.indexOf(":");
+  return i < 0 ? null : coin.slice(0, i);
+}
+var SIDE = { B: "buy", A: "sell" };
+function abs(d) {
+  return d === null ? null : d.replace(/^-/, "");
+}
+function decodeClearinghouse(d) {
+  if (!isObj(d) || typeof d.dex !== "string" || !isObj(d.clearinghouseState)) return [protocolError("hyperliquid clearinghouseState frame without dex/clearinghouseState")];
+  const wire = `clearinghouseState:${d.dex}`;
+  const cs = d.clearinghouseState;
+  const bad = [];
+  const ms = isObj(cs.marginSummary) ? cs.marginSummary : null;
+  if (ms === null) bad.push("marginSummary");
+  const venueTs = ts(cs, "time", bad);
+  const rows = [];
+  if (!Array.isArray(cs.assetPositions)) bad.push("assetPositions");
+  else for (const ap of cs.assetPositions) {
+    const p = isObj(ap) && isObj(ap.position) ? ap.position : null;
+    if (p === null || typeof p.coin !== "string") {
+      bad.push("assetPositions[]");
+      continue;
+    }
+    const szi = dec(p, "szi", bad);
+    const lev = isObj(p.leverage) ? dec(p.leverage, "value", bad) : null;
+    rows.push({
+      symbol: p.coin,
+      dex: dexOf(p.coin),
+      side: szi === null ? null : szi.startsWith("-") ? "short" : "long",
+      size: abs(szi),
+      entryPrice: dec(p, "entryPx", bad),
+      markPrice: null,
+      positionValue: dec(p, "positionValue", bad),
+      unrealizedPnl: dec(p, "unrealizedPnl", bad),
+      liquidationPrice: dec(p, "liquidationPx", bad),
+      marginUsed: dec(p, "marginUsed", bad),
+      leverage: lev,
+      venueTs
+    });
+  }
+  const deltas = [
+    {
+      kind: "account",
+      snapshot: true,
+      dex: d.dex === "" ? null : d.dex,
+      venueTs,
+      equity: ms === null ? null : dec(ms, "accountValue", bad),
+      available: dec(cs, "withdrawable", bad),
+      marginUsed: ms === null ? null : dec(ms, "totalMarginUsed", bad),
+      unrealizedPnl: null
+      // not in clearinghouseState (per-position only)
+    },
+    { kind: "positions", snapshot: true, scope: d.dex, rows, remove: [] }
+  ];
+  const out = [{ t: "user", wire, deltas }];
+  if (bad.length > 0) out.push(badFieldsError("hyperliquid", wire, [{ symbol: "account", fields: bad }]));
+  return out;
+}
+function orderRow(o, bad, status) {
+  const id = idOf(o.oid);
+  if (id === null || typeof o.coin !== "string") {
+    bad.push("oid/coin");
+    return null;
+  }
+  const sz = dec(o, "sz", bad);
+  const orig = dec(o, "origSz", bad);
+  return {
+    orderId: id,
+    clientId: typeof o.cloid === "string" ? o.cloid : null,
+    symbol: o.coin,
+    dex: dexOf(o.coin),
+    side: pick2(SIDE, o.side),
+    type: typeof o.orderType === "string" ? o.orderType : null,
+    status,
+    price: dec(o, "limitPx", bad),
+    size: orig,
+    filled: null,
+    remaining: sz,
+    reduceOnly: typeof o.reduceOnly === "boolean" ? o.reduceOnly : null,
+    createdAt: ts(o, "timestamp", bad),
+    updatedAt: null
+  };
+}
+function decodeOpenOrders(d) {
+  if (!isObj(d) || typeof d.dex !== "string" || !Array.isArray(d.orders)) return [protocolError("hyperliquid openOrders frame without dex/orders")];
+  const wire = `openOrders:${d.dex}`;
+  const bad = [];
+  const rows = d.orders.map((o) => isObj(o) ? orderRow(o, bad, "open") : null).filter((r) => r !== null);
+  const out = [{ t: "user", wire, deltas: [{ kind: "orders", snapshot: true, scope: d.dex, rows, remove: [] }] }];
+  if (bad.length > 0) out.push(badFieldsError("hyperliquid", wire, [{ symbol: "orders", fields: bad }]));
+  return out;
+}
+function decodeOrderUpdates(d, hl) {
+  if (!Array.isArray(d)) return [protocolError("hyperliquid orderUpdates data is not an array", "orderUpdates")];
+  const bad = [];
+  const byScope = /* @__PURE__ */ new Map();
+  for (const u of d) {
+    if (!isObj(u) || !isObj(u.order) || typeof u.status !== "string") {
+      bad.push("update");
+      continue;
+    }
+    const row = orderRow(u.order, bad, u.status);
+    if (row === null) continue;
+    const scope = row.dex === null ? "" : row.dex;
+    if (!hl.dexes.has(scope)) continue;
+    let g = byScope.get(scope);
+    if (g === void 0) {
+      g = { rows: [], remove: [] };
+      byScope.set(scope, g);
+    }
+    if (u.status === "open") g.rows.push({ ...row, updatedAt: ts(u, "statusTimestamp", bad) });
+    else g.remove.push(row.orderId);
+  }
+  const deltas = Array.from(byScope, ([scope, g]) => ({ kind: "orders", snapshot: false, scope, rows: g.rows, remove: g.remove }));
+  const out = [{ t: "user", wire: "orderUpdates", deltas }];
+  if (bad.length > 0) out.push(badFieldsError("hyperliquid", "orderUpdates", [{ symbol: "orders", fields: bad }]));
+  return out;
+}
+function decodeFills(d) {
+  if (!isObj(d) || !Array.isArray(d.fills)) return [protocolError("hyperliquid userFills frame without fills", "userFills")];
+  const bad = [];
+  const fills = [];
+  for (const f of d.fills) {
+    const id = isObj(f) ? idOf(f.tid) : null;
+    if (!isObj(f) || id === null || typeof f.coin !== "string") {
+      bad.push("tid/coin");
+      continue;
+    }
+    fills.push({
+      // WsFill documents no cloid; read it when the frame carries one (join OrderRow.clientId by orderId otherwise).
+      fillId: id,
+      clientId: typeof f.cloid === "string" ? f.cloid : null,
+      symbol: f.coin,
+      dex: dexOf(f.coin),
+      side: pick2(SIDE, f.side),
+      price: dec(f, "px", bad),
+      size: dec(f, "sz", bad),
+      fee: dec(f, "fee", bad),
+      feeToken: typeof f.feeToken === "string" ? f.feeToken : null,
+      closedPnl: dec(f, "closedPnl", bad),
+      orderId: idOf(f.oid),
+      liquidity: typeof f.crossed === "boolean" ? f.crossed ? "taker" : "maker" : null,
+      time: ts(f, "time", bad)
+    });
+  }
+  const out = [{ t: "user", wire: "userFills", deltas: [{ kind: "fills", snapshot: d.isSnapshot === true, fills }] }];
+  if (bad.length > 0) out.push(badFieldsError("hyperliquid", "userFills", [{ symbol: "fills", fields: bad }]));
+  return out;
+}
+function decodeBbo(d) {
+  if (!isObj(d) || typeof d.coin !== "string" || !Array.isArray(d.bbo) || d.bbo.length !== 2) return [protocolError("hyperliquid bbo frame without coin/bbo[2]")];
+  const wire = `bbo:${d.coin}`;
+  const bad = [];
+  const side = (l) => {
+    if (l === null) return [null, null];
+    if (!isObj(l)) {
+      bad.push("level");
+      return [null, null];
+    }
+    return [dec(l, "px", bad), dec(l, "sz", bad)];
+  };
+  const [bid, bidSize] = side(d.bbo[0]);
+  const [ask, askSize] = side(d.bbo[1]);
+  const out = [{ t: "bbo", wire, symbol: d.coin, seq: null, bid, bidSize, ask, askSize, venueTs: ts(d, "time", bad) }];
+  if (bad.length > 0) out.push(badFieldsError("hyperliquid", wire, [{ symbol: d.coin, fields: bad }]));
+  return out;
+}
+function rejectedWire(text) {
+  const at = text.indexOf("{");
+  if (at < 0) return null;
+  try {
+    const req = JSON.parse(text.slice(at));
+    return isObj(req) && req.method === "subscribe" ? subscriptionKey(req.subscription) : null;
+  } catch {
+    return null;
+  }
+}
+function decodeAll(f, d, recvTs) {
+  if (!isObj(f.data) || !Array.isArray(f.data.ctxs)) return [protocolError(`hyperliquid ${ALL} frame without data.ctxs`, ALL)];
+  const out = [];
+  const patches = [];
+  const badRows = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pair of f.data.ctxs) {
+    if (!Array.isArray(pair) || pair.length !== 2 || typeof pair[0] !== "string" || !Array.isArray(pair[1])) {
+      out.push(protocolError(`hyperliquid ${ALL}: malformed [dex, ctxs] entry`, ALL));
+      continue;
+    }
+    const dex = pair[0];
+    const sel = d.dexes.get(dex);
+    if (sel === void 0) continue;
+    seen.add(dex);
+    const ctxs = pair[1];
+    if (ctxs.length !== sel.names.length) {
+      out.push(protocolError(
+        `hyperliquid ${ALL}: dex "${dex}" has ${ctxs.length} ctxs but the directory has ${sel.names.length} markets \u2014 not assigned (recreate the stream to reload meta)`,
+        ALL
+      ));
+      continue;
+    }
+    ctxs.forEach((ctx, i) => {
+      const name = sel.names[i];
+      if (name === null) return;
+      if (!isObj(ctx)) {
+        badRows.push({ symbol: name, fields: ["ctx"] });
+        return;
+      }
+      const bad = [];
+      patches.push(patchFromCtx(name, ctx, recvTs, bad));
+      if (bad.length > 0) badRows.push({ symbol: name, fields: bad });
+    });
+  }
+  for (const dex of d.dexes.keys()) {
+    if (!seen.has(dex)) out.push(protocolError(`hyperliquid ${ALL}: selected dex "${dex}" missing from the frame`, ALL));
+  }
+  if (badRows.length > 0) out.push(badFieldsError("hyperliquid", ALL, badRows));
+  return [{ t: "market", wire: ALL, patches }, ...out];
+}
+
+// src/ws/pacifica-instrument.ts
+function isPacificaPerpetual(row) {
+  return row.instrument_type === "perpetual";
+}
+
+// src/ws/codecs/pacifica.ts
+var S2 = VENUE_STATIC.pacifica;
+var PRICES = "prices";
+function sourceKey(d) {
+  if (!isObj(d) || typeof d.source !== "string") return null;
+  return typeof d.symbol === "string" ? `${d.source}:${d.symbol}` : d.source;
+}
+var pacifica = {
+  venue: "pacifica",
+  capabilities: capabilities({
+    testnet: true,
+    user: true,
+    fields: {
+      mark: true,
+      index: true,
+      bestBid: false,
+      bestAsk: false,
+      last: false,
+      predictedRate: true,
+      nextFundingTime: false,
+      fundingInterval: true,
+      openInterest: true,
+      volume24hNotional: true
+    },
+    notes: {
+      bestBid: "`prices` has no bid/ask; use the bbo channel (Phase 2)",
+      bestAsk: "`prices` has no bid/ask; use the bbo channel (Phase 2)",
+      last: "Not in `prices`",
+      nextFundingTime: "Not in `prices`",
+      openInterest: "Base units",
+      user: "By account (Solana address), no auth. account_order_updates / account_trades send no snapshot \u2192 gap refetch-required for orders (at subscribe and after a reconnect) and fills (after a reconnect)",
+      bbo: "bbo{symbol} \u2264 20 per connection (more are spread over further sockets); `li` orders frames (non-contiguous)",
+      positions: "account_positions envelope `li` orders snapshots: an older one than the last applied is dropped",
+      clientId: "orders and fills: `I` (client order id; null when the order has none)",
+      liquidationPrice: "`l` (null when not applicable, per the venue)",
+      fee: "trade `f`; feeToken not stated \u2192 null"
+    }
+  }),
+  url: (n) => S2.wsUrl[n],
+  restUrl: (n) => S2.restUrl[n],
+  secretKeys: [],
+  secretUrlPatterns: [/PF-API-KEY=[^&\s"']+/gi],
+  ping: S2.ping,
+  limits: S2.limits,
+  closesOnBadSubscribe: false,
+  staleAfterMs: S2.staleAfterMs,
+  openInterest: { unit: "base", sides: null },
+  refresh: null,
+  async loadDirectory(ctx) {
+    const raw = await fetchJson(ctx.fetch, "pacifica", `${ctx.restUrl}/info`);
+    if (!isObj(raw) || !Array.isArray(raw.data)) throw badShape("pacifica", "GET /info has no data array");
+    const entries = [];
+    const nonPerp = /* @__PURE__ */ new Set();
+    const unclassified = [];
+    for (const m of raw.data) {
+      if (!isObj(m) || typeof m.symbol !== "string") throw badShape("pacifica", "GET /info market without symbol");
+      if (typeof m.instrument_type !== "string") {
+        unclassified.push(m.symbol);
+        nonPerp.add(m.symbol);
+        continue;
+      }
+      if (!isPacificaPerpetual(m)) {
+        nonPerp.add(m.symbol);
+        continue;
+      }
+      const base = m.symbol;
+      const quote = "USDC";
+      entries.push({
+        venue: "pacifica",
+        dex: null,
+        symbol: m.symbol,
+        venueSymbol: m.symbol,
+        base,
+        quote,
+        canonical: ctx.canonicalize("pacifica", { venueSymbol: m.symbol, dex: null, base, quote }),
+        rateIntervalHours: 1,
+        settlementIntervalHours: 1,
+        source: "rest:/api/v1/info"
+      });
+    }
+    const warnings = unclassified.length === 0 ? [] : [
+      `pacifica GET /info: ${unclassified.length} market(s) without instrument_type left out (cannot tell perp from spot): ${unclassified.slice(0, 10).join(", ")}${unclassified.length > 10 ? ", \u2026" : ""}`
+    ];
+    return { entries, data: { nonPerp }, warnings };
+  },
+  fundingMeta: () => ({
+    rateKind: "lastSettled",
+    rateSource: "ws",
+    rateIntervalHours: 1,
+    settlementIntervalHours: 1,
+    intervalSource: "venue-definition",
+    intervalAsOf: null,
+    marketClosed: null
+  }),
+  wiresFor(target, _dir, staleOverrideMs) {
+    const prices = { key: PRICES, staleAfterMs: staleOverrideMs === null ? S2.staleAfterMs : staleOverrideMs, group: PRICES, params: { source: PRICES } };
+    if (target.kind === "allMarkets") return [prices];
+    const out = [];
+    if (target.channels.includes("market")) out.push(prices);
+    if (target.channels.includes("bbo")) out.push({ key: `bbo:${target.symbol}`, staleAfterMs: null, group: "bbo", params: { source: "bbo", symbol: target.symbol } });
+    return out;
+  },
+  user: {
+    inPageSecrets: false,
+    wires(ref, channels) {
+      if (ref.venue !== "pacifica") return [];
+      const w = (source, gaps) => ({ key: source, staleAfterMs: null, group: source, params: { source, account: ref.account }, ...gaps === void 0 ? {} : { gaps } });
+      const out = [];
+      if (channels.includes("account")) out.push(w("account_info"));
+      if (channels.includes("positions")) out.push(w("account_positions"));
+      if (channels.includes("orders")) out.push(w("account_order_updates", { onReconnect: ["orders"], onSubscribe: ["orders"] }));
+      if (channels.includes("fills")) out.push(w("account_trades", { onReconnect: ["fills"] }));
+      return out;
+    }
+  },
+  encodeSubscribe: (w) => JSON.stringify({ method: "subscribe", params: w.params }),
+  encodeUnsubscribe: (w) => JSON.stringify({ method: "unsubscribe", params: w.params }),
+  decode(text, dir) {
+    const p = parseFrame(text);
+    if (!p.ok) return [p.ev];
+    const f = p.v;
+    if (!isObj(f) || typeof f.channel !== "string") return [unrecognised("pacifica")];
+    switch (f.channel) {
+      case "pong":
+        return [{ t: "pong" }];
+      case "subscribe":
+      case "unsubscribe":
+        return [{ t: "ack", wire: sourceKey(f.data), reqId: null, unsubscribe: f.channel === "unsubscribe" }];
+      case "account_info":
+        return decodeAccount(f.data);
+      case "account_positions":
+        return decodePositions(f.data, f.li);
+      case "account_order_updates":
+        return decodeOrders(f.data);
+      case "account_trades":
+        return decodeTrades(f.data);
+      case "bbo":
+        return decodeBbo2(f.data);
+      case PRICES: {
+        if (!Array.isArray(f.data)) return [unrecognised("pacifica")];
+        const patches = [];
+        const badRows = [];
+        const out = [];
+        const nonPerp = dir.data.nonPerp;
+        for (const r of f.data) {
+          if (!isObj(r) || typeof r.symbol !== "string") {
+            badRows.push({ symbol: "?", fields: ["symbol"] });
+            continue;
+          }
+          if (nonPerp.has(r.symbol)) continue;
+          const bad = [];
+          patches.push(compact({
+            symbol: r.symbol,
+            venueTs: (() => {
+              const t = readTs(r, "timestamp", bad);
+              return t === void 0 ? null : t;
+            })(),
+            mark: readDec(r, "mark", bad),
+            index: readDec(r, "oracle", bad),
+            rate: readDec(r, "funding", bad),
+            predictedRate: readDec(r, "next_funding", bad),
+            openInterest: readDec(r, "open_interest", bad),
+            volume24hNotional: readDec(r, "volume_24h", bad)
+          }));
+          if (bad.length > 0) badRows.push({ symbol: r.symbol, fields: bad });
+        }
+        if (badRows.length > 0) out.push(badFieldsError("pacifica", PRICES, badRows));
+        return [{ t: "market", wire: PRICES, patches }, ...out];
+      }
+      default:
+        return [unrecognised("pacifica")];
+    }
+  }
+};
+var BOOK_SIDE = { bid: "buy", ask: "sell" };
+var TRADE_SIDE = { open_long: "buy", close_short: "buy", open_short: "sell", close_long: "sell" };
+var OPEN_STATUSES = /* @__PURE__ */ new Set(["open", "partially_filled"]);
+function decodeAccount(d) {
+  if (!isObj(d)) return [protocolError("pacifica account_info frame without data", "account_info")];
+  const bad = [];
+  const out = [{
+    t: "user",
+    wire: "account_info",
+    deltas: [{
+      kind: "account",
+      snapshot: true,
+      dex: null,
+      venueTs: ts(d, "t", bad),
+      // every frame carries the full account
+      equity: dec(d, "ae", bad),
+      available: dec(d, "as", bad),
+      marginUsed: dec(d, "mu", bad),
+      unrealizedPnl: null
+      // not in account_info
+    }]
+  }];
+  if (bad.length > 0) out.push(badFieldsError("pacifica", "account_info", [{ symbol: "account", fields: bad }]));
+  return out;
+}
+function decodePositions(d, li) {
+  if (!Array.isArray(d)) return [protocolError("pacifica account_positions data is not an array", "account_positions")];
+  const bad = [];
+  const rows = [];
+  for (const p of d) {
+    if (!isObj(p) || typeof p.s !== "string") {
+      bad.push("position");
+      continue;
+    }
+    const side = pick2(BOOK_SIDE, p.d);
+    rows.push({
+      symbol: p.s,
+      dex: null,
+      side: side === null ? null : side === "buy" ? "long" : "short",
+      size: dec(p, "a", bad),
+      entryPrice: dec(p, "p", bad),
+      markPrice: null,
+      positionValue: null,
+      unrealizedPnl: null,
+      liquidationPrice: dec(p, "l", bad),
+      marginUsed: dec(p, "m", bad),
+      leverage: null,
+      venueTs: ts(p, "t", bad)
+    });
+  }
+  const out = [{
+    t: "user",
+    wire: "account_positions",
+    seq: typeof li === "number" ? li : null,
+    deltas: [{ kind: "positions", snapshot: true, scope: "", rows, remove: [] }]
+  }];
+  if (bad.length > 0) out.push(badFieldsError("pacifica", "account_positions", [{ symbol: "positions", fields: bad }]));
+  return out;
+}
+function decodeOrders(d) {
+  if (!Array.isArray(d)) return [protocolError("pacifica account_order_updates data is not an array", "account_order_updates")];
+  const bad = [];
+  const rows = [];
+  const remove = [];
+  for (const o of d) {
+    const id = isObj(o) ? idOf(o.i) : null;
+    if (!isObj(o) || id === null || typeof o.s !== "string") {
+      bad.push("order");
+      continue;
+    }
+    if (!OPEN_STATUSES.has(String(o.os))) {
+      remove.push(id);
+      continue;
+    }
+    const size = dec(o, "a", bad);
+    const filled = dec(o, "f", bad);
+    rows.push({
+      orderId: id,
+      clientId: typeof o.I === "string" ? o.I : null,
+      symbol: o.s,
+      dex: null,
+      side: pick2(BOOK_SIDE, o.d),
+      type: typeof o.ot === "string" ? o.ot : null,
+      status: typeof o.os === "string" ? o.os : null,
+      price: dec(o, "ip", bad),
+      size,
+      filled,
+      remaining: null,
+      reduceOnly: typeof o.r === "boolean" ? o.r : null,
+      createdAt: ts(o, "ct", bad),
+      updatedAt: ts(o, "ut", bad)
+    });
+  }
+  const out = [{ t: "user", wire: "account_order_updates", deltas: [{ kind: "orders", snapshot: false, scope: "", rows, remove }] }];
+  if (bad.length > 0) out.push(badFieldsError("pacifica", "account_order_updates", [{ symbol: "orders", fields: bad }]));
+  return out;
+}
+function decodeTrades(d) {
+  if (!Array.isArray(d)) return [protocolError("pacifica account_trades data is not an array", "account_trades")];
+  const bad = [];
+  const fills = [];
+  for (const t of d) {
+    const h = isObj(t) ? idOf(t.h) : null;
+    const i = isObj(t) ? idOf(t.i) : null;
+    if (!isObj(t) || h === null || typeof t.s !== "string") {
+      bad.push("h/s");
+      continue;
+    }
+    fills.push({
+      fillId: i === null ? h : `${h}:${i}`,
+      clientId: typeof t.I === "string" ? t.I : null,
+      symbol: t.s,
+      dex: null,
+      side: pick2(TRADE_SIDE, t.ts),
+      price: dec(t, "p", bad),
+      size: dec(t, "a", bad),
+      fee: dec(t, "f", bad),
+      feeToken: null,
+      closedPnl: dec(t, "n", bad),
+      orderId: i,
+      liquidity: t.te === "fulfill_maker" ? "maker" : t.te === "fulfill_taker" ? "taker" : null,
+      time: ts(t, "t", bad)
+    });
+  }
+  const out = [{ t: "user", wire: "account_trades", deltas: [{ kind: "fills", snapshot: false, fills }] }];
+  if (bad.length > 0) out.push(badFieldsError("pacifica", "account_trades", [{ symbol: "fills", fields: bad }]));
+  return out;
+}
+function decodeBbo2(d) {
+  if (!isObj(d) || typeof d.s !== "string") return [protocolError("pacifica bbo frame without symbol")];
+  const wire = `bbo:${d.s}`;
+  const bad = [];
+  const out = [{
+    t: "bbo",
+    wire,
+    symbol: d.s,
+    seq: typeof d.li === "number" ? d.li : null,
+    bid: dec(d, "b", bad),
+    bidSize: dec(d, "B", bad),
+    ask: dec(d, "a", bad),
+    askSize: dec(d, "A", bad),
+    venueTs: ts(d, "t", bad)
+  }];
+  if (bad.length > 0) out.push(badFieldsError("pacifica", wire, [{ symbol: d.s, fields: bad }]));
+  return out;
+}
+
+// src/ws/codecs/lighter.ts
+var ALL2 = "market_stats/all";
+var ORDERS_TOKEN_TTL_SEC = 3600;
+var OPEN_ORDER = /* @__PURE__ */ new Set(["open", "pending", "in-progress"]);
+var ZERO = /^-?0*(\.0*)?$/;
+function bookSide(o, key, bad) {
+  return o[key] === "" ? null : readDec(o, key, bad);
+}
+function percentToFraction(o, key, bad) {
+  const v = readDec(o, key, bad);
+  if (v === void 0 || v === null) return v;
+  const f = shiftDecimal(v, -2);
+  if (f === void 0) {
+    bad.push(key);
+    return void 0;
+  }
+  return f;
+}
+function makeLighter(venue, quote) {
+  const S5 = VENUE_STATIC[venue];
+  return {
+    venue,
+    capabilities: capabilities({
+      testnet: S5.wsUrl.testnet !== null,
+      user: true,
+      fields: {
+        mark: true,
+        index: true,
+        bestBid: true,
+        bestAsk: true,
+        last: true,
+        predictedRate: true,
+        nextFundingTime: true,
+        fundingInterval: true,
+        openInterest: true,
+        volume24hNotional: true
+      },
+      notes: {
+        rate: "WS funding is PERCENT per 1 h on the wire; emitted as a fraction per 1 h",
+        nextFundingTime: "Hourly settlement rule (venue-definition)",
+        openInterest: "USD notional (Phase 0), sides not stated by the venue",
+        user: "By accountIndex. user_stats / account_all_positions / account_all_trades need no auth; account_all_orders needs CredentialProvider.authToken (re-called at 80 % TTL). account_all_trades does not replay \u2192 gap refetch-required for fills after a reconnect",
+        clientId: "orders: client_order_id; fills: ask_/bid_client_id_str of our side; 0 = no client id \u2192 null",
+        liquidationPrice: 'liquidation_price; "0" (no liquidation price, e.g. well-covered cross margin) \u2192 null, as in the CLI REST path',
+        fee: "taker_fee / maker_fee are a rate in 1e-6 of usd_amount (omitted when 0): fee = usd_amount \xD7 rate \xD7 1e-6 in the collateral token",
+        bbo: "ticker/{market_id}; `nonce` orders frames (non-contiguous)",
+        ...S5.wsUrl.testnet === null ? { "network:testnet": "Testnet WS answers HTTP 403 (CloudFront)" } : {}
+      }
+    }),
+    url: (n) => S5.wsUrl[n],
+    restUrl: (n) => S5.restUrl[n],
+    secretKeys: ["auth"],
+    secretUrlPatterns: [],
+    ping: S5.ping,
+    limits: S5.limits,
+    closesOnBadSubscribe: false,
+    staleAfterMs: S5.staleAfterMs,
+    openInterest: { unit: "usd", sides: null },
+    refresh: null,
+    async loadDirectory(ctx) {
+      const raw = await fetchJson(ctx.fetch, venue, `${ctx.restUrl}/api/v1/orderBooks`);
+      if (!isObj(raw) || !Array.isArray(raw.order_books)) throw badShape(venue, "GET /api/v1/orderBooks has no order_books array");
+      const entries = [];
+      const idToSymbol = /* @__PURE__ */ new Map();
+      const nonPerp = /* @__PURE__ */ new Set();
+      for (const m of raw.order_books) {
+        if (!isObj(m) || typeof m.symbol !== "string" || typeof m.market_id !== "number") {
+          throw badShape(venue, "orderBooks entry without symbol/market_id");
+        }
+        const id = String(m.market_id);
+        if (m.market_type !== "perp") {
+          nonPerp.add(id);
+          continue;
+        }
+        idToSymbol.set(id, m.symbol);
+        entries.push({
+          venue,
+          dex: null,
+          symbol: m.symbol,
+          venueSymbol: m.symbol,
+          base: m.symbol,
+          quote,
+          canonical: ctx.canonicalize(venue, { venueSymbol: m.symbol, dex: null, base: m.symbol, quote }),
+          rateIntervalHours: 1,
+          settlementIntervalHours: 1,
+          source: "rest:/api/v1/orderBooks"
+        });
+      }
+      const symbolToId = new Map(Array.from(idToSymbol, ([id, sym]) => [sym, id]));
+      return { entries, data: { idToSymbol, nonPerp, symbolToId } };
+    },
+    fundingMeta: () => ({
+      rateKind: "lastSettled",
+      rateSource: "ws",
+      rateIntervalHours: 1,
+      settlementIntervalHours: 1,
+      intervalSource: "venue-definition",
+      intervalAsOf: null,
+      marketClosed: null
+    }),
+    wiresFor(target, dir, staleOverrideMs) {
+      const all = { key: ALL2, staleAfterMs: staleOverrideMs === null ? S5.staleAfterMs : staleOverrideMs, params: { channel: ALL2 } };
+      if (target.kind === "allMarkets") return [all];
+      const out = [];
+      if (target.channels.includes("market")) out.push(all);
+      if (target.channels.includes("bbo")) {
+        const id = dir.data.symbolToId.get(target.symbol);
+        out.push({ key: `ticker/${id}`, staleAfterMs: null, params: { channel: `ticker/${id}` } });
+      }
+      return out;
+    },
+    user: {
+      inPageSecrets: false,
+      wires(ref, channels) {
+        if (ref.venue !== venue) return [];
+        const a = ref.accountIndex;
+        const w = (ch, extra = {}) => ({ key: `${ch}/${a}`, staleAfterMs: null, params: { channel: `${ch}/${a}` }, ...extra });
+        const out = [];
+        if (channels.includes("account")) out.push(w("user_stats"));
+        if (channels.includes("positions")) out.push(w("account_all_positions"));
+        if (channels.includes("orders")) out.push(w("account_all_orders", { auth: { purpose: `${venue}:account_all_orders`, maxTtlSec: ORDERS_TOKEN_TTL_SEC } }));
+        if (channels.includes("fills")) out.push(w("account_all_trades", { gaps: { onReconnect: ["fills"] } }));
+        return out;
+      }
+    },
+    encodeSubscribe: (w, _reqId, auth) => JSON.stringify({ type: "subscribe", channel: w.params.channel, ...auth === null ? {} : { auth } }),
+    encodeUnsubscribe: (w) => JSON.stringify({ type: "unsubscribe", channel: w.params.channel }),
+    decode(text, dir, recvTs) {
+      const p = parseFrame(text);
+      if (!p.ok) return [p.ev];
+      const f = p.v;
+      if (!isObj(f)) return [unrecognised(venue)];
+      if (isObj(f.error)) return [decodeError(venue, f.error)];
+      switch (f.type) {
+        case "connected":
+          return [{ t: "ignore", what: "connected" }];
+        case "pong":
+          return [{ t: "pong" }];
+        case "unsubscribed":
+          return [{ t: "ack", wire: channelToWire(f.channel), reqId: null, unsubscribe: true }];
+        case "subscribed/market_stats":
+        case "update/market_stats":
+          if (f.channel !== "market_stats:all") return [unrecognised(venue)];
+          return decodeStats(venue, f, dir.data, recvTs);
+        default: {
+          const ty = typeof f.type === "string" ? /^(subscribed|update)\/(user_stats|account_all_positions|account_all_orders|account_all_trades|ticker)$/.exec(f.type) : null;
+          const wire = channelToWire(f.channel);
+          if (ty === null || wire === null) return [unrecognised(venue)];
+          const snapshot = ty[1] === "subscribed";
+          const d = dir.data;
+          switch (ty[2]) {
+            case "user_stats":
+              return decodeUserStats(venue, wire, f, snapshot);
+            case "account_all_positions":
+              return decodePositions2(venue, wire, f, d, snapshot);
+            case "account_all_orders":
+              return decodeOrders2(venue, wire, f, d, snapshot);
+            case "account_all_trades":
+              return decodeTrades2(venue, wire, f, d, snapshot, quote);
+            default:
+              return decodeTicker(venue, wire, f, d);
+          }
+        }
+      }
+    }
+  };
+}
+function channelToWire(ch) {
+  if (typeof ch !== "string") return null;
+  const m = /^(market_stats|user_stats|account_all_positions|account_all_orders|account_all_trades|ticker):(\w+)$/.exec(ch);
+  return m === null ? null : `${m[1]}/${m[2]}`;
+}
+function decodeError(venue, e) {
+  const code = typeof e.code === "number" ? e.code : null;
+  const message = typeof e.message === "string" ? e.message : JSON.stringify(e);
+  const m = /(market_stats|user_stats|account_all_positions|account_all_orders|account_all_trades|ticker)[:/](\w+)/.exec(message);
+  const wire = m === null ? null : `${m[1]}/${m[2]}`;
+  if (code === 20001) {
+    return venueError(
+      "WS_AUTH_FAILED",
+      `${venue} error 20001: ${message}`,
+      wire,
+      wire !== null,
+      "account_all_orders needs a valid auth token from CredentialProvider.authToken (expired, wrong account, or wrong API key)"
+    );
+  }
+  if (code === 30005) return venueError("INVALID_PARAMS", `${venue} error 30005: ${message}`, wire, wire !== null, null);
+  return protocolError(`${venue} error ${code === null ? "?" : code}: ${message}`, wire);
+}
+function decodeStats(venue, f, d, recvTs) {
+  if (!isObj(f.market_stats)) return [protocolError(`${venue} ${ALL2} frame without market_stats`, ALL2)];
+  const venueTs = typeof f.timestamp === "number" ? f.timestamp : null;
+  const patches = [];
+  const badRows = [];
+  for (const [id, r] of Object.entries(f.market_stats)) {
+    if (d.nonPerp.has(id)) continue;
+    if (!isObj(r)) {
+      badRows.push({ symbol: `#${id}`, fields: ["entry"] });
+      continue;
+    }
+    const known = d.idToSymbol.get(id);
+    const symbol = known !== void 0 ? known : typeof r.symbol === "string" ? r.symbol : `#${id}`;
+    const bad = [];
+    patches.push(compact({
+      symbol,
+      venueTs,
+      mark: readDec(r, "mark_price", bad),
+      index: readDec(r, "index_price", bad),
+      bestBid: bookSide(r, "best_bid_price", bad),
+      bestAsk: bookSide(r, "best_ask_price", bad),
+      last: readDec(r, "last_trade_price", bad),
+      rate: percentToFraction(r, "funding_rate", bad),
+      predictedRate: percentToFraction(r, "current_funding_rate", bad),
+      openInterest: readDec(r, "open_interest", bad),
+      volume24hNotional: readDec(r, "daily_quote_token_volume", bad),
+      nextFundingTime: nextHour(recvTs)
+      // hourly settlement (venue-definition)
+    }));
+    if (bad.length > 0) badRows.push({ symbol, fields: bad });
+  }
+  const out = [{ t: "market", wire: ALL2, patches }];
+  if (badRows.length > 0) out.push(badFieldsError(venue, ALL2, badRows));
+  return out;
+}
+var lighter = makeLighter("lighter", "USDC");
+var lighterRh = makeLighter("lighter-rh", "USDG");
+function accountOf(wire) {
+  return wire.slice(wire.indexOf("/") + 1);
+}
+function positivePrice(v) {
+  return v !== null && Number(v) > 0 ? v : null;
+}
+function clientIdOf(str, num) {
+  const id = idOf(str) === null ? idOf(num) : idOf(str);
+  return id === null || /^0+$/.test(id) ? null : id;
+}
+function decodeUserStats(venue, wire, f, snapshot) {
+  if (!isObj(f.stats)) return [protocolError(`${venue} ${wire} frame without stats`, wire)];
+  const bad = [];
+  const out = [{
+    t: "user",
+    wire,
+    deltas: [{
+      kind: "account",
+      snapshot,
+      dex: null,
+      venueTs: ts(f, "timestamp", bad),
+      equity: dec(f.stats, "portfolio_value", bad),
+      available: dec(f.stats, "available_balance", bad),
+      marginUsed: null,
+      // margin_usage is a ratio, not an amount
+      unrealizedPnl: null
+    }]
+  }];
+  if (bad.length > 0) out.push(badFieldsError(venue, wire, [{ symbol: "account", fields: bad }]));
+  return out;
+}
+function decodePositions2(venue, wire, f, d, snapshot) {
+  if (!isObj(f.positions)) return [protocolError(`${venue} ${wire} frame without positions`, wire)];
+  const bad = [];
+  const rows = [];
+  const remove = [];
+  const venueTs = ts(f, "transaction_time", bad, 1e-3);
+  for (const [id, p] of Object.entries(f.positions)) {
+    if (!isObj(p)) {
+      bad.push(`#${id}`);
+      continue;
+    }
+    const known = d.idToSymbol.get(id);
+    const symbol = known !== void 0 ? known : typeof p.symbol === "string" ? p.symbol : `#${id}`;
+    const size = dec(p, "position", bad);
+    if (size === null || ZERO.test(size)) {
+      remove.push(symbol);
+      continue;
+    }
+    rows.push({
+      symbol,
+      dex: null,
+      side: p.sign === 1 ? "long" : p.sign === -1 ? "short" : null,
+      size: size.replace(/^-/, ""),
+      entryPrice: dec(p, "avg_entry_price", bad),
+      markPrice: null,
+      positionValue: dec(p, "position_value", bad),
+      unrealizedPnl: dec(p, "unrealized_pnl", bad),
+      liquidationPrice: positivePrice(dec(p, "liquidation_price", bad)),
+      marginUsed: dec(p, "allocated_margin", bad),
+      leverage: null,
+      venueTs
+    });
+  }
+  const out = [{ t: "user", wire, deltas: [{ kind: "positions", snapshot, scope: "", rows, remove: snapshot ? [] : remove }] }];
+  if (bad.length > 0) out.push(badFieldsError(venue, wire, [{ symbol: "positions", fields: bad }]));
+  return out;
+}
+function decodeOrders2(venue, wire, f, d, snapshot) {
+  if (!isObj(f.orders)) return [protocolError(`${venue} ${wire} frame without orders`, wire)];
+  const bad = [];
+  const rows = [];
+  const remove = [];
+  for (const [mkt, list] of Object.entries(f.orders)) {
+    if (!Array.isArray(list)) {
+      bad.push(`orders[${mkt}]`);
+      continue;
+    }
+    for (const o of list) {
+      const id = isObj(o) ? idOf(o.order_id) === null ? idOf(o.order_index) : idOf(o.order_id) : null;
+      if (!isObj(o) || id === null) {
+        bad.push("order_id");
+        continue;
+      }
+      if (!OPEN_ORDER.has(String(o.status))) {
+        remove.push(id);
+        continue;
+      }
+      const known = d.idToSymbol.get(String(o.market_index));
+      rows.push({
+        orderId: id,
+        clientId: clientIdOf(o.client_order_id, o.client_order_index),
+        symbol: known !== void 0 ? known : `#${String(o.market_index)}`,
+        dex: null,
+        side: typeof o.is_ask === "boolean" ? o.is_ask ? "sell" : "buy" : null,
+        type: typeof o.type === "string" ? o.type : null,
+        status: typeof o.status === "string" ? o.status : null,
+        price: dec(o, "price", bad),
+        size: dec(o, "initial_base_amount", bad),
+        filled: dec(o, "filled_base_amount", bad),
+        remaining: dec(o, "remaining_base_amount", bad),
+        reduceOnly: typeof o.reduce_only === "boolean" ? o.reduce_only : null,
+        createdAt: ts(o, "created_at", bad),
+        updatedAt: ts(o, "updated_at", bad)
+      });
+    }
+  }
+  const out = [{ t: "user", wire, deltas: [{ kind: "orders", snapshot, scope: "", rows, remove: snapshot ? [] : remove }] }];
+  if (bad.length > 0) out.push(badFieldsError(venue, wire, [{ symbol: "orders", fields: bad }]));
+  return out;
+}
+function feeOf(t, maker, bad) {
+  if (maker === null) return null;
+  const rate = maker ? t.maker_fee : t.taker_fee;
+  if (rate !== void 0 && (typeof rate !== "number" || !Number.isInteger(rate))) {
+    bad.push(maker ? "maker_fee" : "taker_fee");
+    return null;
+  }
+  const usd = dec(t, "usd_amount", bad);
+  if (usd === null) return null;
+  const fee = mulDecimalInt(usd, rate === void 0 ? 0 : rate, -6);
+  if (fee === void 0) {
+    bad.push("usd_amount");
+    return null;
+  }
+  return fee;
+}
+function decodeTrades2(venue, wire, f, d, snapshot, quote) {
+  const groups = Array.isArray(f.trades) ? [f.trades] : isObj(f.trades) ? Object.values(f.trades) : [];
+  if (!Array.isArray(f.trades) && !isObj(f.trades)) return [protocolError(`${venue} ${wire} frame without trades`, wire)];
+  const acct = accountOf(wire);
+  const bad = [];
+  const fills = [];
+  for (const g of groups) {
+    if (!Array.isArray(g)) {
+      bad.push("trades[]");
+      continue;
+    }
+    for (const t of g) {
+      const id = isObj(t) ? idOf(t.trade_id_str) === null ? idOf(t.trade_id) : idOf(t.trade_id_str) : null;
+      if (!isObj(t) || id === null) {
+        bad.push("trade_id");
+        continue;
+      }
+      const isAsk = String(t.ask_account_id) === acct;
+      const isBid = String(t.bid_account_id) === acct;
+      const known = d.idToSymbol.get(String(t.market_id));
+      const base = {
+        fillId: id,
+        symbol: known !== void 0 ? known : `#${String(t.market_id)}`,
+        dex: null,
+        price: dec(t, "price", bad),
+        size: dec(t, "size", bad),
+        closedPnl: null,
+        time: ts(t, "timestamp", bad)
+      };
+      const leg = (ask) => {
+        const maker = typeof t.is_maker_ask === "boolean" ? t.is_maker_ask === ask : null;
+        const fee = feeOf(t, maker, bad);
+        return {
+          ...base,
+          side: ask ? "sell" : "buy",
+          orderId: ask ? idOf(t.ask_id_str) === null ? idOf(t.ask_id) : idOf(t.ask_id_str) : idOf(t.bid_id_str) === null ? idOf(t.bid_id) : idOf(t.bid_id_str),
+          clientId: ask ? clientIdOf(t.ask_client_id_str, t.ask_client_id) : clientIdOf(t.bid_client_id_str, t.bid_client_id),
+          liquidity: maker === null ? null : maker ? "maker" : "taker",
+          fee,
+          feeToken: fee === null ? null : quote
+        };
+      };
+      if (isAsk) fills.push(leg(true));
+      if (isBid) fills.push(leg(false));
+      if (!isAsk && !isBid) fills.push({ ...base, side: null, orderId: null, clientId: null, liquidity: null, fee: null, feeToken: null });
+    }
+  }
+  const out = [{ t: "user", wire, deltas: [{ kind: "fills", snapshot, fills }] }];
+  if (bad.length > 0) out.push(badFieldsError(venue, wire, [{ symbol: "fills", fields: bad }]));
+  return out;
+}
+function decodeTicker(venue, wire, f, d) {
+  if (!isObj(f.ticker)) return [protocolError(`${venue} ${wire} frame without ticker`, wire)];
+  const id = accountOf(wire);
+  const known = d.idToSymbol.get(id);
+  const bad = [];
+  const [ask, askSize] = level(f.ticker.a, bad, "a");
+  const [bid, bidSize] = level(f.ticker.b, bad, "b");
+  const out = [{
+    t: "bbo",
+    wire,
+    symbol: known !== void 0 ? known : `#${id}`,
+    seq: typeof f.nonce === "number" ? f.nonce : null,
+    bid,
+    bidSize,
+    ask,
+    askSize,
+    venueTs: ts(f, "timestamp", bad)
+  }];
+  if (bad.length > 0) out.push(badFieldsError(venue, wire, [{ symbol: known !== void 0 ? known : id, fields: bad }]));
+  return out;
+}
+
+// src/ws/codecs/aster.ts
+var S3 = VENUE_STATIC.aster;
+var MARK = "!markPrice@arr@1s";
+var TICKER = "!ticker@arr";
+var TICKER_STALE_MS = 15e3;
+var FUNDING_INFO = "rest:/fapi/v3/fundingInfo";
+async function fetchIntervals(ctx) {
+  const raw = await fetchJson(ctx.fetch, "aster", `${ctx.restUrl}/fapi/v3/fundingInfo`);
+  if (!Array.isArray(raw)) throw badShape("aster", "GET /fapi/v3/fundingInfo is not an array");
+  const m = /* @__PURE__ */ new Map();
+  const bad = [];
+  for (const r of raw) {
+    if (isObj(r) && typeof r.symbol === "string" && typeof r.fundingIntervalHours === "number" && r.fundingIntervalHours > 0) {
+      m.set(r.symbol, r.fundingIntervalHours);
+    } else {
+      bad.push(isObj(r) && typeof r.symbol === "string" ? r.symbol : "?");
+    }
+  }
+  const warnings = bad.length === 0 ? [] : [
+    `aster ${FUNDING_INFO}: ${bad.length} malformed row(s) (${bad.slice(0, 5).join(", ")}${bad.length > 5 ? ", \u2026" : ""}); their funding interval is null`
+  ];
+  return { intervals: m, warnings };
+}
+var aster = {
+  venue: "aster",
+  capabilities: capabilities({
+    testnet: true,
+    user: false,
+    fields: {
+      mark: true,
+      index: true,
+      bestBid: false,
+      bestAsk: false,
+      last: true,
+      predictedRate: false,
+      nextFundingTime: true,
+      fundingInterval: true,
+      openInterest: false,
+      volume24hNotional: true
+    },
+    notes: {
+      bestBid: "Use the bookTicker bbo channel (Phase 2)",
+      bestAsk: "Use the bookTicker bbo channel (Phase 2)",
+      predictedRate: "Not published; `rate` (r) is the accruing current-period rate",
+      openInterest: "Not on WS (REST only)",
+      fundingInterval: `Labelled REST source ${FUNDING_INFO}, refreshed hourly; missing \u2192 null`,
+      volume24hNotional: "!ticker@arr q (quote-asset volume)",
+      user: 'KNOWN GAP in 0.15.0: no Aster user channels (signed USER_STREAM listenKey) \u2014 kind:"user" rejects CAPABILITY_UNSUPPORTED; arrives in 0.15.1',
+      bbo: "<symbol>@bookTicker; `u` orders frames (non-contiguous)"
+    }
+  }),
+  url: (n) => `${S3.wsUrl[n]}/stream`,
+  restUrl: (n) => S3.restUrl[n],
+  secretKeys: ["listenKey"],
+  // A user-data stream URL ends in the listenKey (/ws/<listenKey>).
+  secretUrlPatterns: [/(?<=asterdex(?:-testnet)?\.com\/(?:ws|stream)\/)[A-Za-z0-9]{20,}/g],
+  ping: S3.ping,
+  limits: S3.limits,
+  closesOnBadSubscribe: false,
+  staleAfterMs: S3.staleAfterMs,
+  openInterest: { unit: null, sides: null },
+  refresh: {
+    source: FUNDING_INFO,
+    everyMs: 36e5,
+    async run(ctx, dir) {
+      const d = dir.data;
+      const r = await fetchIntervals(ctx);
+      d.intervals = r.intervals;
+      d.intervalsAt = ctx.clock();
+      return r.warnings;
+    }
+  },
+  async loadDirectory(ctx) {
+    const [info, fi, premium] = await Promise.all([
+      fetchJson(ctx.fetch, "aster", `${ctx.restUrl}/fapi/v3/exchangeInfo`),
+      fetchIntervals(ctx),
+      fetchJson(ctx.fetch, "aster", `${ctx.restUrl}/fapi/v3/premiumIndex`)
+    ]);
+    if (!isObj(info) || !Array.isArray(info.symbols)) throw badShape("aster", "GET /fapi/v3/exchangeInfo has no symbols array");
+    if (!Array.isArray(premium)) throw badShape("aster", "GET /fapi/v3/premiumIndex is not an array");
+    const intervals = fi.intervals;
+    const entries = [];
+    const listed = /* @__PURE__ */ new Set();
+    for (const s of info.symbols) {
+      if (!isObj(s) || typeof s.symbol !== "string" || typeof s.baseAsset !== "string") {
+        throw badShape("aster", "exchangeInfo symbol without symbol/baseAsset");
+      }
+      const quote = typeof s.quoteAsset === "string" && s.quoteAsset !== "" ? s.quoteAsset : null;
+      listed.add(s.symbol);
+      const hours = intervals.get(s.symbol);
+      entries.push({
+        venue: "aster",
+        dex: null,
+        symbol: s.symbol,
+        venueSymbol: s.symbol,
+        base: s.baseAsset,
+        quote,
+        canonical: ctx.canonicalize("aster", { venueSymbol: s.symbol, dex: null, base: s.baseAsset, quote }),
+        rateIntervalHours: hours === void 0 ? null : hours,
+        settlementIntervalHours: hours === void 0 ? null : hours,
+        source: "rest:/fapi/v3/exchangeInfo"
+      });
+    }
+    const unlisted = /* @__PURE__ */ new Set();
+    for (const p of premium) if (isObj(p) && typeof p.symbol === "string" && !listed.has(p.symbol)) unlisted.add(p.symbol);
+    return { entries, data: { intervals, intervalsAt: ctx.clock(), unlisted }, warnings: fi.warnings };
+  },
+  fundingMeta(entry, dir) {
+    const d = dir.data;
+    const h = d.intervals.get(entry.symbol);
+    return {
+      rateKind: "accruing",
+      rateSource: "ws",
+      rateIntervalHours: h === void 0 ? null : h,
+      settlementIntervalHours: h === void 0 ? null : h,
+      intervalSource: h === void 0 ? null : FUNDING_INFO,
+      intervalAsOf: h === void 0 ? null : d.intervalsAt,
+      marketClosed: null
+    };
+  },
+  wiresFor(target, _dir, staleOverrideMs) {
+    const all = [
+      { key: MARK, staleAfterMs: staleOverrideMs === null ? S3.staleAfterMs : staleOverrideMs, params: {} },
+      { key: TICKER, staleAfterMs: staleOverrideMs === null ? TICKER_STALE_MS : staleOverrideMs, params: {} }
+    ];
+    if (target.kind === "allMarkets") return all;
+    const out = target.channels.includes("market") ? all : [];
+    if (target.channels.includes("bbo")) out.push({ key: `${target.symbol.toLowerCase()}@bookTicker`, staleAfterMs: null, params: { symbol: target.symbol } });
+    return out;
+  },
+  user: null,
+  encodeSubscribe: (w, reqId) => JSON.stringify({ method: "SUBSCRIBE", params: [w.key], id: reqId }),
+  encodeUnsubscribe: (w, reqId) => JSON.stringify({ method: "UNSUBSCRIBE", params: [w.key], id: reqId }),
+  decode(text, dir) {
+    const p = parseFrame(text);
+    if (!p.ok) return [p.ev];
+    const f = p.v;
+    if (!isObj(f)) return [unrecognised("aster")];
+    if ("result" in f && typeof f.id === "number") {
+      return f.result === null ? [{ t: "ack", wire: null, reqId: f.id, unsubscribe: false }] : [{ t: "ignore", what: "list-subscriptions" }];
+    }
+    if (isObj(f.error)) {
+      const msg = typeof f.error.msg === "string" ? f.error.msg : JSON.stringify(f.error);
+      const message = `aster error${typeof f.error.code === "number" ? ` ${f.error.code}` : ""}: ${msg}`;
+      if (typeof f.id === "number") return [{ ...protocolError(message), fatal: true, reqId: f.id }];
+      return [protocolError(message)];
+    }
+    if (typeof f.stream !== "string") return [unrecognised("aster")];
+    const d = dir.data;
+    if (f.stream === MARK) return decodeArr(MARK, f.data, d, markPatch);
+    if (f.stream === TICKER) return decodeArr(TICKER, f.data, d, tickerPatch);
+    if (f.stream.endsWith("@bookTicker")) return decodeBookTicker(f.stream, f.data);
+    return [unrecognised("aster")];
+  }
+};
+function decodeBookTicker(wire, d) {
+  if (!isObj(d) || d.e !== "bookTicker" || typeof d.s !== "string") return [protocolError(`aster ${wire} frame without bookTicker data`, wire)];
+  const bad = [];
+  const out = [{
+    t: "bbo",
+    wire,
+    symbol: d.s,
+    seq: typeof d.u === "number" ? d.u : null,
+    bid: dec(d, "b", bad),
+    bidSize: dec(d, "B", bad),
+    ask: dec(d, "a", bad),
+    askSize: dec(d, "A", bad),
+    venueTs: ts(d, "E", bad)
+  }];
+  if (bad.length > 0) out.push(badFieldsError("aster", wire, [{ symbol: d.s, fields: bad }]));
+  return out;
+}
+function markPatch(r, bad) {
+  if (r.e !== "markPriceUpdate" || typeof r.s !== "string") return null;
+  const venueTs = readTs(r, "E", bad);
+  return compact({
+    symbol: r.s,
+    venueTs: venueTs === void 0 ? null : venueTs,
+    mark: readDec(r, "p", bad),
+    index: readDec(r, "i", bad),
+    rate: readDec(r, "r", bad),
+    nextFundingTime: readTs(r, "T", bad)
+  });
+}
+function tickerPatch(r, bad) {
+  if (r.e !== "24hrTicker" || typeof r.s !== "string") return null;
+  const venueTs = readTs(r, "E", bad);
+  return compact({
+    symbol: r.s,
+    venueTs: venueTs === void 0 ? null : venueTs,
+    last: readDec(r, "c", bad),
+    volume24hNotional: readDec(r, "q", bad)
+  });
+}
+function decodeArr(wire, data2, d, fn) {
+  if (!Array.isArray(data2)) return [protocolError(`aster ${wire} data is not an array`, wire)];
+  const patches = [];
+  const badRows = [];
+  let unrecognisedRows = 0;
+  for (const r of data2) {
+    if (!isObj(r)) {
+      unrecognisedRows++;
+      continue;
+    }
+    const bad = [];
+    const patch = fn(r, bad);
+    if (patch === null) {
+      unrecognisedRows++;
+      continue;
+    }
+    if (d.unlisted.has(patch.symbol)) continue;
+    patches.push(patch);
+    if (bad.length > 0) badRows.push({ symbol: patch.symbol, fields: bad });
+  }
+  const out = [{ t: "market", wire, patches }];
+  if (unrecognisedRows > 0) out.push(protocolError(`aster ${wire}: ${unrecognisedRows} unrecognised row(s)`, wire));
+  if (badRows.length > 0) out.push(badFieldsError("aster", wire, badRows));
+  return out;
+}
+
+// src/ws/codecs/arcus.ts
+var S4 = VENUE_STATIC.arcus;
+var MARKETS = "markets";
+var arcus = {
+  venue: "arcus",
+  capabilities: capabilities({
+    testnet: true,
+    user: true,
+    fields: {
+      mark: true,
+      index: true,
+      bestBid: false,
+      bestAsk: false,
+      last: true,
+      predictedRate: true,
+      nextFundingTime: true,
+      fundingInterval: true,
+      openInterest: true,
+      volume24hNotional: true
+    },
+    notes: {
+      bestBid: "Not in `markets`; use the bbo channel (Phase 2)",
+      bestAsk: "Not in `markets`; use the bbo channel (Phase 2)",
+      openInterest: "Base units, one side (~60 s venue cadence)",
+      user: "By address, no auth (subaccount \u2192 accountIndex). account re-snapshots every 5 s; userFills replays on resubscribe (deduped by tradeId). Streaming `account` order events carry no balances and are not emitted",
+      bbo: "bbo{market}; lastSequenceId orders frames (non-contiguous)",
+      clientId: "orders and fills: clientId (omitted by the venue when the order had none \u2192 null)",
+      liquidationPrice: "not published (WS or REST) \u2192 always null",
+      fee: "fill `fee`; feeToken not stated \u2192 null"
+    }
+  }),
+  url: (n) => S4.wsUrl[n],
+  restUrl: (n) => S4.restUrl[n],
+  secretKeys: [],
+  secretUrlPatterns: [],
+  ping: S4.ping,
+  limits: S4.limits,
+  closesOnBadSubscribe: false,
+  staleAfterMs: S4.staleAfterMs,
+  openInterest: { unit: "base", sides: "one" },
+  refresh: null,
+  async loadDirectory(ctx) {
+    const raw = await fetchJson(ctx.fetch, "arcus", `${ctx.restUrl}/v1/markets`);
+    if (!isObj(raw) || !Array.isArray(raw.markets)) throw badShape("arcus", "GET /v1/markets has no markets array");
+    const entries = [];
+    const idToSymbol = /* @__PURE__ */ new Map();
+    for (const m of raw.markets) {
+      if (!isObj(m) || typeof m.marketDisplayName !== "string" || typeof m.marketId !== "number" || typeof m.baseAsset !== "string") {
+        throw badShape("arcus", "market without marketDisplayName/marketId/baseAsset");
+      }
+      const quote = typeof m.quoteAsset === "string" ? m.quoteAsset : null;
+      idToSymbol.set(String(m.marketId), m.marketDisplayName);
+      entries.push({
+        venue: "arcus",
+        dex: null,
+        symbol: m.marketDisplayName,
+        venueSymbol: m.marketDisplayName,
+        base: m.baseAsset,
+        quote,
+        canonical: ctx.canonicalize("arcus", { venueSymbol: m.marketDisplayName, dex: null, base: m.baseAsset, quote }),
+        rateIntervalHours: 1,
+        settlementIntervalHours: 1,
+        source: "rest:/v1/markets"
+      });
+    }
+    return { entries, data: { idToSymbol } };
+  },
+  fundingMeta: () => ({
+    rateKind: "lastSettled",
+    rateSource: "ws",
+    rateIntervalHours: 1,
+    settlementIntervalHours: 1,
+    intervalSource: "venue-definition",
+    intervalAsOf: null,
+    marketClosed: null
+  }),
+  wiresFor(target, _dir, staleOverrideMs) {
+    const markets = { key: MARKETS, staleAfterMs: staleOverrideMs === null ? S4.staleAfterMs : staleOverrideMs, params: { channel: MARKETS } };
+    if (target.kind === "allMarkets") return [markets];
+    const out = [];
+    if (target.channels.includes("market")) out.push(markets);
+    if (target.channels.includes("bbo")) out.push({ key: `bbo:${target.symbol}`, staleAfterMs: null, params: { channel: "bbo", id: target.symbol } });
+    return out;
+  },
+  user: {
+    inPageSecrets: false,
+    wires(ref, channels) {
+      if (ref.venue !== "arcus") return [];
+      const w = (channel) => ({
+        key: channel,
+        staleAfterMs: null,
+        params: { channel, id: ref.address, ...ref.subaccount === null ? {} : { accountIndex: ref.subaccount } }
+      });
+      const out = [];
+      if (channels.includes("account")) out.push(w("account"));
+      if (channels.includes("positions")) out.push(w("positions"));
+      if (channels.includes("orders")) out.push(w("orders"));
+      if (channels.includes("fills")) out.push(w("userFills"));
+      return out;
+    }
+  },
+  encodeSubscribe: (w) => JSON.stringify({ type: "subscribe", ...w.params }),
+  encodeUnsubscribe: (w) => JSON.stringify({ type: "unsubscribe", ...w.params }),
+  decode(text, dir) {
+    const p = parseFrame(text);
+    if (!p.ok) return [p.ev];
+    const f = p.v;
+    if (!isObj(f) || typeof f.type !== "string") return [unrecognised("arcus")];
+    switch (f.type) {
+      case "connected":
+        return [{ t: "ignore", what: "connected" }];
+      case "pong":
+        return [{ t: "pong" }];
+      case "unsubscribed":
+        return [{ t: "ack", wire: wireOf(f), reqId: null, unsubscribe: true }];
+      case "error":
+        return [protocolError(`arcus error: ${typeof f.message === "string" ? f.message : JSON.stringify(f)}`)];
+      case "subscribed":
+      case "channel_data": {
+        const d = dir.data;
+        switch (f.channel) {
+          case MARKETS:
+            return decodeMarkets(f, d);
+          case "bbo":
+            return decodeBbo3(f);
+          case "account":
+            return decodeAccount2(f);
+          case "positions":
+            return decodePositions3(f, d);
+          case "orders":
+            return decodeOrders3(f, d);
+          case "userFills":
+            return decodeFills2(f, d);
+          default:
+            return [unrecognised("arcus")];
+        }
+      }
+      default:
+        return [unrecognised("arcus")];
+    }
+  }
+};
+function decodeMarkets(f, d) {
+  if (!isObj(f.contents) || !isObj(f.contents.markets)) return [protocolError("arcus markets frame without contents.markets", MARKETS)];
+  const patches = [];
+  const badRows = [];
+  for (const [id, m] of Object.entries(f.contents.markets)) {
+    if (!isObj(m)) {
+      badRows.push({ symbol: `#${id}`, fields: ["entry"] });
+      continue;
+    }
+    const known = d.idToSymbol.get(id);
+    const symbol = known !== void 0 ? known : typeof m.marketDisplayName === "string" ? m.marketDisplayName : `#${id}`;
+    const bad = [];
+    patches.push(compact({
+      symbol,
+      venueTs: null,
+      // `markets` carries no frame timestamp
+      mark: readDec(m, "markPrice", bad),
+      index: readDec(m, "oraclePrice", bad),
+      last: readDec(m, "lastTradePrice", bad),
+      rate: readDec(m, "fundingRate", bad),
+      predictedRate: readDec(m, "nextFundingRate", bad),
+      nextFundingTime: readTs(m, "nextFundingAt", bad, 1e3),
+      openInterest: readDec(m, "openInterest", bad),
+      volume24hNotional: readDec(m, "volume24hNotional", bad)
+    }));
+    if (bad.length > 0) badRows.push({ symbol, fields: bad });
+  }
+  const out = [{ t: "market", wire: MARKETS, patches }];
+  if (badRows.length > 0) out.push(badFieldsError("arcus", MARKETS, badRows));
+  return out;
+}
+function wireOf(f) {
+  if (f.channel === MARKETS) return MARKETS;
+  if (f.channel === "bbo" && typeof f.id === "string") return `bbo:${f.id}`;
+  if (f.channel === "account" || f.channel === "positions" || f.channel === "orders" || f.channel === "userFills") return f.channel;
+  return null;
+}
+var SIDE2 = { BUY: "buy", SELL: "sell" };
+var POS_SIDE = { LONG: "long", SHORT: "short" };
+var OPEN_STATUS = /* @__PURE__ */ new Set(["OPEN", "TPSL_PLACED"]);
+var ZERO2 = /^-?0*(\.0*)?$/;
+function symbolOf(o, d) {
+  if (typeof o.marketId === "number") {
+    const s = d.idToSymbol.get(String(o.marketId));
+    if (s !== void 0) return s;
+  }
+  if (typeof o.marketDisplayName === "string") return o.marketDisplayName;
+  if (typeof o.market === "string") return o.market;
+  return null;
+}
+function decodeBbo3(f) {
+  if (typeof f.id !== "string" || !isObj(f.contents)) return [protocolError("arcus bbo frame without id/contents")];
+  const wire = `bbo:${f.id}`;
+  const c = f.contents;
+  const bad = [];
+  const [bid, bidSize] = level(c.bestBid, bad, "bestBid");
+  const [ask, askSize] = level(c.bestAsk, bad, "bestAsk");
+  const out = [{
+    t: "bbo",
+    wire,
+    symbol: f.id,
+    seq: typeof c.lastSequenceId === "number" ? c.lastSequenceId : null,
+    bid,
+    bidSize,
+    ask,
+    askSize,
+    venueTs: ts(c, "timestamp", bad, 1e-3)
+    // µs
+  }];
+  if (bad.length > 0) out.push(badFieldsError("arcus", wire, [{ symbol: f.id, fields: bad }]));
+  return out;
+}
+function decodeAccount2(f) {
+  if (!isObj(f.contents)) return [protocolError("arcus account frame without contents", "account")];
+  const c = f.contents;
+  if (c.isSnapshot !== true) return [{ t: "ignore", what: "account order event" }];
+  if (c.noActivity === true) return [{ t: "ack", wire: "account", reqId: null, unsubscribe: false }];
+  const bad = [];
+  const out = [{
+    t: "user",
+    wire: "account",
+    deltas: [{
+      kind: "account",
+      snapshot: true,
+      dex: null,
+      venueTs: null,
+      equity: dec(c, "accountEquity", bad),
+      available: dec(c, "freeCollateral", bad),
+      marginUsed: null,
+      unrealizedPnl: null
+    }]
+  }];
+  if (bad.length > 0) out.push(badFieldsError("arcus", "account", [{ symbol: "account", fields: bad }]));
+  return out;
+}
+function positionRow(p, d, bad) {
+  const symbol = symbolOf(p, d);
+  if (symbol === null) {
+    bad.push("market");
+    return null;
+  }
+  const size = dec(p, "size", bad);
+  return {
+    symbol,
+    dex: null,
+    side: pick2(POS_SIDE, p.side),
+    size: size === null ? null : size.replace(/^-/, ""),
+    entryPrice: dec(p, "averageEntryPrice", bad),
+    markPrice: dec(p, "markPx", bad),
+    positionValue: dec(p, "positionValueNotional", bad),
+    unrealizedPnl: dec(p, "unrealizedPnl", bad),
+    liquidationPrice: null,
+    // Arcus publishes no liquidation price (REST GET /v1/positions has none either)
+    marginUsed: dec(p, "marginUsed", bad),
+    leverage: null,
+    venueTs: null
+  };
+}
+function decodePositions3(f, d) {
+  if (!isObj(f.contents)) return [protocolError("arcus positions frame without contents", "positions")];
+  const c = f.contents;
+  const bad = [];
+  let delta;
+  if (c.isSnapshot === true) {
+    if (!isObj(c.positions)) return [protocolError("arcus positions snapshot without positions", "positions")];
+    const rows = Object.values(c.positions).map((p) => isObj(p) ? positionRow(p, d, bad) : null).filter((r) => r !== null);
+    delta = { kind: "positions", snapshot: true, scope: "", rows, remove: [] };
+  } else {
+    const row = positionRow(c, d, bad);
+    if (row === null) return [badFieldsError("arcus", "positions", [{ symbol: "position", fields: bad }])];
+    const flat = c.side === "FLAT" || row.size === null || ZERO2.test(row.size);
+    delta = { kind: "positions", snapshot: false, scope: "", rows: flat ? [] : [row], remove: flat ? [row.symbol] : [] };
+  }
+  const out = [{ t: "user", wire: "positions", deltas: [delta] }];
+  if (bad.length > 0) out.push(badFieldsError("arcus", "positions", [{ symbol: "positions", fields: bad }]));
+  return out;
+}
+function orderRow2(o, d, bad) {
+  const id = idOf(o.orderId);
+  const symbol = symbolOf(o, d);
+  if (id === null || symbol === null) {
+    bad.push("orderId/market");
+    return null;
+  }
+  const size = dec(o, "originalSize", bad);
+  return {
+    orderId: id,
+    clientId: idOf(o.clientId),
+    symbol,
+    dex: null,
+    side: pick2(SIDE2, o.side),
+    type: typeof o.type === "string" ? o.type : null,
+    status: typeof o.status === "string" ? o.status : null,
+    price: dec(o, "price", bad),
+    size,
+    filled: dec(o, "filledSize", bad),
+    remaining: dec(o, "remainingSize", bad),
+    reduceOnly: typeof o.reduceOnly === "boolean" ? o.reduceOnly : null,
+    createdAt: ts(o, "createdAt", bad, 1e-3),
+    updatedAt: ts(o, "updatedAt", bad, 1e-3)
+    // µs
+  };
+}
+function decodeOrders3(f, d) {
+  if (!isObj(f.contents)) return [protocolError("arcus orders frame without contents", "orders")];
+  const c = f.contents;
+  const bad = [];
+  let delta;
+  if (c.isSnapshot === true) {
+    if (!Array.isArray(c.openOrders)) return [protocolError("arcus orders snapshot without openOrders", "orders")];
+    const rows = c.openOrders.map((o) => isObj(o) ? orderRow2(o, d, bad) : null).filter((r) => r !== null);
+    delta = { kind: "orders", snapshot: true, scope: "", rows, remove: [] };
+  } else {
+    const row = orderRow2(c, d, bad);
+    if (row === null) return [badFieldsError("arcus", "orders", [{ symbol: "order", fields: bad }])];
+    const open = row.status !== null && OPEN_STATUS.has(row.status);
+    delta = { kind: "orders", snapshot: false, scope: "", rows: open ? [row] : [], remove: open ? [] : [row.orderId] };
+  }
+  const out = [{ t: "user", wire: "orders", deltas: [delta] }];
+  if (bad.length > 0) out.push(badFieldsError("arcus", "orders", [{ symbol: "orders", fields: bad }]));
+  return out;
+}
+function fillRow(x, d, bad) {
+  const id = idOf(x.tradeId);
+  const symbol = symbolOf(x, d);
+  if (id === null || symbol === null) {
+    bad.push("tradeId/market");
+    return null;
+  }
+  const price = "price" in x ? dec(x, "price", bad) : dec(x, "fillPrice", bad);
+  const size = "size" in x ? dec(x, "size", bad) : dec(x, "fillSize", bad);
+  return {
+    fillId: id,
+    clientId: idOf(x.clientId),
+    symbol,
+    dex: null,
+    side: pick2(SIDE2, x.side),
+    price,
+    size,
+    fee: dec(x, "fee", bad),
+    feeToken: null,
+    closedPnl: dec(x, "closedPnl", bad),
+    orderId: idOf(x.orderId),
+    liquidity: x.role === "MAKER" ? "maker" : x.role === "TAKER" ? "taker" : null,
+    time: ts(x, "createdAt", bad, 1e-3)
+    // µs
+  };
+}
+function decodeFills2(f, d) {
+  if (!isObj(f.contents)) return [protocolError("arcus userFills frame without contents", "userFills")];
+  const c = f.contents;
+  const bad = [];
+  const list = c.isSnapshot === true ? Array.isArray(c.fills) ? c.fills : null : [c];
+  if (list === null) return [protocolError("arcus userFills snapshot without fills", "userFills")];
+  const fills = list.map((x) => isObj(x) ? fillRow(x, d, bad) : null).filter((r) => r !== null);
+  const out = [{ t: "user", wire: "userFills", deltas: [{ kind: "fills", snapshot: c.isSnapshot === true, fills }] }];
+  if (bad.length > 0) out.push(badFieldsError("arcus", "userFills", [{ symbol: "fills", fields: bad }]));
+  return out;
+}
+
+// src/ws/node.ts
+var wsModule = null;
+function isWsNotFound(e) {
+  if (e === null || typeof e !== "object" || e.code !== "MODULE_NOT_FOUND") return false;
+  const first = String(e.message).split("\n")[0];
+  if (!/^Cannot find module 'ws'$/.test(first)) return false;
+  const stack = e.requireStack;
+  return !Array.isArray(stack) || !stack.some((p) => typeof p === "string" && /[\\/]node_modules[\\/]ws[\\/]/.test(p));
+}
+function loadWs() {
+  if (wsModule !== null) return wsModule;
+  try {
+    wsModule = createRequire(import.meta.url)("ws");
+  } catch (e) {
+    if (isWsNotFound(e)) {
+      throw new WsError("INVALID_PARAMS", "The /node entry needs the `ws` package (an optional peer dependency), and it is not installed", {
+        remediation: "npm install ws@^8.21.0 \u2014 or, on Node \u2265 22 / in a browser, import the browser entry (global WebSocket) or pass opts.transport"
+      });
+    }
+    const err = new Error(`The /node entry could not load the \`ws\` package: ${e instanceof Error ? e.message : String(e)}`);
+    err.cause = e;
+    throw err;
+  }
+  return wsModule;
+}
+var DEFAULT_MAX_PAYLOAD = 16 * 1024 * 1024;
+function createNodeTransport(opts = {}) {
+  const maxPayload = opts.maxPayload ?? DEFAULT_MAX_PAYLOAD;
+  if (!Number.isSafeInteger(maxPayload) || maxPayload <= 0) {
+    throw new RangeError(`createNodeTransport: maxPayload must be a positive integer (got ${String(opts.maxPayload)})`);
+  }
+  const WebSocket = loadWs();
+  return (url) => {
+    const ws = new WebSocket(url, { maxPayload });
+    ws.on("error", () => void 0);
+    const like = {
+      get readyState() {
+        return ws.readyState;
+      },
+      send: (data2) => ws.send(data2),
+      close: (code, reason) => ws.close(code, reason),
+      onopen: null,
+      onmessage: null,
+      onclose: null,
+      onerror: null
+    };
+    ws.on("open", () => like.onopen?.());
+    ws.on("message", (data2, isBinary) => {
+      const text = isBinary ? null : Array.isArray(data2) ? Buffer.concat(data2).toString("utf8") : Buffer.from(data2).toString("utf8");
+      like.onmessage?.({ data: text === null ? data2 : text });
+    });
+    ws.on("close", (code, reason) => like.onclose?.({ code, reason: reason.toString("utf8"), wasClean: code === 1e3 }));
+    ws.on("error", (err) => like.onerror?.(err));
+    return like;
+  };
+}
+var defaultTransport = null;
+var nodeTransport = (url) => {
+  if (defaultTransport === null) defaultTransport = createNodeTransport();
+  return defaultTransport(url);
+};
+function createVenueStream2(codec, opts = {}) {
+  const useDefault = opts.transport === void 0 || opts.transport === nodeTransport;
+  if (useDefault) loadWs();
+  return createVenueStream(codec, opts.transport === void 0 ? { ...opts, transport: nodeTransport } : opts);
+}
+
+export { DEFAULT_MAX_PAYLOAD, USD_LIKE_QUOTES, VENUE_IDS, WS_ERROR_CODES, WsError, arcus, aster, createFundingComparator, createNodeTransport, createVenueStream2 as createVenueStream, defaultCanonicalize, hyperliquid, isPerpError, lighter, lighterRh, nodeTransport, pacifica, toApr, toHourly };