@mrdoge/node 0.1.0

package/dist/index.js

@@ -0,0 +1,1000 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AbortError: () => AbortError,
+  ConnectionError: () => ConnectionError,
+  ConnectionLimitError: () => ConnectionLimitError,
+  DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
+  DisconnectedError: () => DisconnectedError,
+  ForbiddenError: () => ForbiddenError,
+  InternalError: () => InternalError,
+  MrDoge: () => MrDoge,
+  MrDogeError: () => MrDogeError,
+  NotFoundError: () => NotFoundError,
+  ProtocolError: () => ProtocolError,
+  RateLimitError: () => RateLimitError,
+  Subscription: () => Subscription,
+  SubscriptionLimitError: () => SubscriptionLimitError,
+  TimeoutError: () => TimeoutError,
+  UnauthorizedError: () => UnauthorizedError,
+  UnavailableError: () => UnavailableError,
+  ValidationError: () => ValidationError
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_http = require("@mrdoge/http");
+
+// src/connection.ts
+var import_ws = __toESM(require("ws"));
+var import_protocol = require("@mrdoge/protocol");
+
+// src/errors.ts
+var MrDogeError = class extends Error {
+  code;
+  data;
+  constructor(code, message, data) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code;
+    this.data = data;
+  }
+};
+var UnauthorizedError = class extends MrDogeError {
+  constructor(message, data) {
+    super("unauthorized", message, data);
+  }
+};
+var ForbiddenError = class extends MrDogeError {
+  constructor(message, data) {
+    super("forbidden", message, data);
+  }
+};
+var NotFoundError = class extends MrDogeError {
+  constructor(message, data) {
+    super("not_found", message, data);
+  }
+};
+var ValidationError = class extends MrDogeError {
+  constructor(message, data) {
+    super("invalid_params", message, data);
+  }
+};
+var RateLimitError = class extends MrDogeError {
+  retryAfterMs;
+  limit;
+  remaining;
+  resetAt;
+  constructor(message, data) {
+    super("rate_limited", message, data);
+    const d = data ?? {};
+    this.retryAfterMs = d.retryAfterMs ?? 0;
+    this.limit = d.limit;
+    this.remaining = d.remaining;
+    this.resetAt = d.resetAt ? new Date(d.resetAt) : void 0;
+  }
+};
+var SubscriptionLimitError = class extends MrDogeError {
+  constructor(message, data) {
+    super("subscription_limit_exceeded", message, data);
+  }
+};
+var ConnectionLimitError = class extends MrDogeError {
+  current;
+  max;
+  constructor(message, data) {
+    super("connection_limit_exceeded", message, data);
+    const d = data ?? {};
+    this.current = d.current;
+    this.max = d.max;
+  }
+};
+var UnavailableError = class extends MrDogeError {
+  constructor(message, data) {
+    super("unavailable", message, data);
+  }
+};
+var InternalError = class extends MrDogeError {
+  constructor(message, data) {
+    super("internal_error", message, data);
+  }
+};
+var ProtocolError = class extends MrDogeError {
+  constructor(message, data) {
+    super("protocol_error", message, data);
+  }
+};
+var ConnectionError = class extends MrDogeError {
+  constructor(message, data) {
+    super("connection_error", message, data);
+  }
+};
+var DisconnectedError = class extends MrDogeError {
+  constructor(message = "Connection dropped before response", data) {
+    super("disconnected", message, data);
+  }
+};
+var TimeoutError = class extends MrDogeError {
+  constructor(message, data) {
+    super("timeout", message, data);
+  }
+};
+var AbortError = class extends MrDogeError {
+  constructor(message = "Request aborted") {
+    super("aborted", message);
+  }
+};
+var CODE_MAP = {
+  invalid_request: ProtocolError,
+  invalid_params: ValidationError,
+  method_not_found: ProtocolError,
+  unauthorized: UnauthorizedError,
+  forbidden: ForbiddenError,
+  not_found: NotFoundError,
+  rate_limited: RateLimitError,
+  subscription_limit_exceeded: SubscriptionLimitError,
+  connection_limit_exceeded: ConnectionLimitError,
+  unavailable: UnavailableError,
+  internal_error: InternalError,
+  protocol_error: ProtocolError
+};
+function rpcErrorToTyped(err) {
+  const Ctor = CODE_MAP[err.code];
+  if (!Ctor) return new MrDogeError("unknown", err.message, err.data);
+  return new Ctor(err.message, err.data);
+}
+
+// src/internal/emitter.ts
+var Emitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, fn) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(fn);
+    return () => set.delete(fn);
+  }
+  off(event, fn) {
+    this.listeners.get(event)?.delete(fn);
+  }
+  emit(event, payload) {
+    const set = this.listeners.get(event);
+    if (!set || set.size === 0) return;
+    for (const fn of [...set]) {
+      try {
+        fn(payload);
+      } catch (err) {
+        queueMicrotask(() => {
+          throw err;
+        });
+      }
+    }
+  }
+  clear() {
+    this.listeners.clear();
+  }
+};
+
+// src/internal/backoff.ts
+var DEFAULT_BACKOFF = {
+  minMs: 1e3,
+  maxMs: 3e4,
+  jitter: 0.2
+};
+function nextDelay(attempt, cfg = DEFAULT_BACKOFF) {
+  const exp = Math.min(cfg.maxMs, cfg.minMs * 2 ** (attempt - 1));
+  const jitter = exp * cfg.jitter * (Math.random() * 2 - 1);
+  return Math.max(0, Math.round(exp + jitter));
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new Error("aborted"));
+      return;
+    }
+    const t = setTimeout(resolve, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(t);
+      reject(new Error("aborted"));
+    });
+  });
+}
+
+// src/connection.ts
+var TERMINAL_CLOSE_CODES = /* @__PURE__ */ new Set([4001, 4002, 4003, 4029]);
+var DEFAULT_CONFIG = {
+  requestTimeoutMs: 1e4,
+  maxReconnectAttempts: Infinity,
+  reconnectBackoff: DEFAULT_BACKOFF,
+  compression: true,
+  authTimeoutMs: 1e4
+};
+var Connection = class {
+  emitter = new Emitter();
+  config;
+  ws = null;
+  nextRequestId = 1;
+  pending = /* @__PURE__ */ new Map();
+  subscriptions = /* @__PURE__ */ new Map();
+  connectingPromise = null;
+  welcome = null;
+  closed = false;
+  reconnectAttempt = 0;
+  reconnectAbort = null;
+  constructor(config) {
+    this.config = config;
+  }
+  on = this.emitter.on.bind(this.emitter);
+  off = this.emitter.off.bind(this.emitter);
+  get isConnected() {
+    return this.ws?.readyState === import_ws.default.OPEN && this.welcome !== null;
+  }
+  /**
+   * Idempotent. Returns the welcome payload once connected + authed.
+   */
+  async connect() {
+    if (this.closed) throw new ConnectionError("Connection is closed");
+    if (this.welcome && this.ws?.readyState === import_ws.default.OPEN) return this.welcome;
+    if (this.connectingPromise) return this.connectingPromise;
+    this.connectingPromise = this.openAndAuth().finally(() => {
+      this.connectingPromise = null;
+    });
+    return this.connectingPromise;
+  }
+  async call(method, params, options) {
+    await this.connect();
+    return this.send(method, params, options);
+  }
+  /**
+   * Registers a subscription with the connection. The connection sends the
+   * subscribe call, stores the registration for reconnect, and routes incoming
+   * push events to the handler.
+   */
+  async registerSubscription(method, params, handlers, options) {
+    await this.connect();
+    const result = await this.send(method, params, options);
+    const registration = {
+      subId: result.sub,
+      method,
+      params,
+      onEvent: handlers.onEvent,
+      onClosed: handlers.onClosed,
+      onSnapshot: handlers.onSnapshot
+    };
+    this.subscriptions.set(result.sub, registration);
+    return { subId: result.sub, snapshot: result.snapshot };
+  }
+  /**
+   * Cancels a subscription server-side and removes the registration locally.
+   */
+  async cancelSubscription(subId) {
+    const reg = this.subscriptions.get(subId);
+    if (!reg) return;
+    this.subscriptions.delete(subId);
+    if (this.ws?.readyState === import_ws.default.OPEN) {
+      try {
+        await this.send("subscription.cancel", { sub: subId });
+      } catch {
+      }
+    }
+  }
+  async close() {
+    this.closed = true;
+    this.reconnectAbort?.abort();
+    this.reconnectAbort = null;
+    for (const [, p] of this.pending) {
+      clearTimeout(p.timer);
+      p.reject(new DisconnectedError("Connection closed by client"));
+    }
+    this.pending.clear();
+    this.subscriptions.clear();
+    if (this.ws && this.ws.readyState <= import_ws.default.OPEN) {
+      this.ws.close(1e3, "client_close");
+    }
+    this.ws = null;
+    this.welcome = null;
+  }
+  // -------------------------------------------------------------------------
+  // Internals
+  // -------------------------------------------------------------------------
+  async openAndAuth() {
+    const ws = new import_ws.default(this.config.baseUrl, [import_protocol.SUBPROTOCOL], {
+      perMessageDeflate: this.config.compression ? { threshold: 1024 } : false,
+      handshakeTimeout: 15e3
+    });
+    this.ws = ws;
+    this.welcome = null;
+    await new Promise((resolve, reject) => {
+      const onOpen = () => {
+        cleanup();
+        resolve();
+      };
+      const onError = (err) => {
+        cleanup();
+        reject(new ConnectionError(`Failed to open WebSocket: ${err.message}`));
+      };
+      const onClose = (code, reason) => {
+        cleanup();
+        reject(new ConnectionError(`WebSocket closed before open (${code}): ${reason.toString()}`));
+      };
+      const cleanup = () => {
+        ws.off("open", onOpen);
+        ws.off("error", onError);
+        ws.off("close", onClose);
+      };
+      ws.once("open", onOpen);
+      ws.once("error", onError);
+      ws.once("close", onClose);
+    });
+    ws.on("message", (data) => this.handleMessage(data));
+    ws.on("close", (code, reason) => this.handleClose(code, reason.toString()));
+    ws.on("error", (err) => this.handleSocketError(err));
+    const welcome = await this.performAuth();
+    this.welcome = welcome;
+    this.reconnectAttempt = 0;
+    this.emitter.emit("connected", { welcome });
+    if (this.subscriptions.size > 0) {
+      await this.resubscribeAll();
+    }
+    return welcome;
+  }
+  async performAuth() {
+    const welcomePromise = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new TimeoutError("Auth timed out waiting for welcome"));
+      }, this.config.authTimeoutMs);
+      this.pendingWelcome = {
+        resolve,
+        reject,
+        timer
+      };
+    });
+    const authAck = this.send("auth", { apiKey: this.config.apiKey }).catch(
+      (err) => {
+        if (err instanceof MrDogeError) throw err;
+        throw new UnauthorizedError(`Authentication failed: ${err.message}`);
+      }
+    );
+    await authAck;
+    return welcomePromise;
+  }
+  /**
+   * Set during `performAuth` so we can resolve when the `welcome` notification arrives.
+   */
+  pendingWelcome = null;
+  send(method, params, options) {
+    if (options?.signal?.aborted) {
+      return Promise.reject(new AbortError());
+    }
+    const ws = this.ws;
+    if (!ws || ws.readyState !== import_ws.default.OPEN) {
+      return Promise.reject(new DisconnectedError("Socket not open"));
+    }
+    const id = String(this.nextRequestId++);
+    const frame = {
+      jsonrpc: "2.0",
+      id,
+      method,
+      params
+    };
+    return new Promise((resolve, reject) => {
+      const onAbort = () => {
+        this.pending.delete(id);
+        clearTimeout(timer);
+        options.signal.removeEventListener("abort", onAbort);
+        reject(new AbortError());
+      };
+      const detachSignal = () => {
+        options?.signal?.removeEventListener("abort", onAbort);
+      };
+      const wrappedResolve = (val) => {
+        detachSignal();
+        resolve(val);
+      };
+      const wrappedReject = (err) => {
+        detachSignal();
+        reject(err);
+      };
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        detachSignal();
+        reject(new TimeoutError(`Request "${method}" timed out after ${this.config.requestTimeoutMs}ms`));
+      }, this.config.requestTimeoutMs);
+      this.pending.set(id, { resolve: wrappedResolve, reject: wrappedReject, timer });
+      options?.signal?.addEventListener("abort", onAbort);
+      try {
+        ws.send(JSON.stringify(frame));
+      } catch (err) {
+        this.pending.delete(id);
+        clearTimeout(timer);
+        detachSignal();
+        reject(new ConnectionError(`Failed to send frame: ${err.message}`));
+      }
+    });
+  }
+  handleMessage(raw) {
+    let text;
+    if (typeof raw === "string") text = raw;
+    else if (Buffer.isBuffer(raw)) text = raw.toString("utf8");
+    else if (raw instanceof ArrayBuffer) text = Buffer.from(raw).toString("utf8");
+    else text = Buffer.concat(raw).toString("utf8");
+    let frame;
+    try {
+      frame = JSON.parse(text);
+    } catch {
+      return;
+    }
+    if (frame.jsonrpc !== "2.0") return;
+    if (typeof frame.id === "string") {
+      const p = this.pending.get(frame.id);
+      if (!p) return;
+      this.pending.delete(frame.id);
+      clearTimeout(p.timer);
+      if (frame.error) {
+        p.reject(rpcErrorToTyped(frame.error));
+      } else {
+        p.resolve(frame.result);
+      }
+      return;
+    }
+    if (typeof frame.method === "string") {
+      this.handleNotification(frame.method, frame.params);
+    }
+  }
+  handleNotification(method, params) {
+    if (method === "welcome") {
+      const pending = this.pendingWelcome;
+      this.pendingWelcome = null;
+      if (pending) {
+        clearTimeout(pending.timer);
+        pending.resolve(params);
+      }
+      return;
+    }
+    if (method === "subscription.event") {
+      const p = params;
+      const reg = this.subscriptions.get(p.sub);
+      reg?.onEvent(p);
+      return;
+    }
+    if (method === "subscription.closed") {
+      const p = params;
+      const reg = this.subscriptions.get(p.sub);
+      if (reg) {
+        this.subscriptions.delete(p.sub);
+        reg.onClosed(p);
+      }
+      return;
+    }
+  }
+  handleClose(code, reason) {
+    const wasConnected = this.welcome !== null;
+    this.welcome = null;
+    this.ws = null;
+    for (const [, p] of this.pending) {
+      clearTimeout(p.timer);
+      p.reject(new DisconnectedError(`Connection closed (${code}): ${reason}`));
+    }
+    this.pending.clear();
+    if (this.pendingWelcome) {
+      clearTimeout(this.pendingWelcome.timer);
+      this.pendingWelcome.reject(new DisconnectedError(`Connection closed during auth (${code})`));
+      this.pendingWelcome = null;
+    }
+    if (this.closed) return;
+    this.emitter.emit("disconnected", { code, reason });
+    if (TERMINAL_CLOSE_CODES.has(code)) {
+      this.closed = true;
+      return;
+    }
+    if (wasConnected || this.subscriptions.size > 0) {
+      this.scheduleReconnect();
+    }
+  }
+  handleSocketError(_err) {
+  }
+  async scheduleReconnect() {
+    if (this.closed) return;
+    if (this.reconnectAbort) return;
+    this.reconnectAbort = new AbortController();
+    const signal = this.reconnectAbort.signal;
+    while (!this.closed && this.reconnectAttempt < this.config.maxReconnectAttempts) {
+      this.reconnectAttempt += 1;
+      const delayMs = nextDelay(this.reconnectAttempt, this.config.reconnectBackoff);
+      this.emitter.emit("reconnecting", { attempt: this.reconnectAttempt, delayMs });
+      try {
+        await sleep(delayMs, signal);
+      } catch {
+        return;
+      }
+      if (this.closed) return;
+      try {
+        await this.openAndAuth();
+        this.reconnectAbort = null;
+        return;
+      } catch (err) {
+        if (err instanceof UnauthorizedError) {
+          this.closed = true;
+          this.reconnectAbort = null;
+          return;
+        }
+      }
+    }
+    this.reconnectAbort = null;
+  }
+  async resubscribeAll() {
+    const olds = Array.from(this.subscriptions.values());
+    this.subscriptions.clear();
+    for (const old of olds) {
+      try {
+        const result = await this.send(old.method, old.params);
+        old.subId = result.sub;
+        this.subscriptions.set(result.sub, old);
+        old.onSnapshot(result.sub, result.snapshot);
+      } catch (err) {
+        old.onClosed({
+          sub: old.subId,
+          reason: "internal_error",
+          message: err instanceof Error ? `Resubscribe failed: ${err.message}` : "Resubscribe failed"
+        });
+      }
+    }
+  }
+};
+
+// src/resources/regions.ts
+var Regions = class {
+  constructor(conn, defaults) {
+    this.conn = conn;
+    this.defaults = defaults;
+  }
+  conn;
+  defaults;
+  list(params = {}, options) {
+    return this.conn.call(
+      "regions.list",
+      { locale: this.defaults.locale, ...params },
+      options
+    );
+  }
+};
+
+// src/resources/competitions.ts
+var Competitions = class {
+  constructor(conn, defaults) {
+    this.conn = conn;
+    this.defaults = defaults;
+  }
+  conn;
+  defaults;
+  list(params = {}, options) {
+    return this.conn.call(
+      "competitions.list",
+      { locale: this.defaults.locale, ...params },
+      options
+    );
+  }
+};
+
+// src/resources/teams.ts
+var Teams = class {
+  constructor(conn, defaults) {
+    this.conn = conn;
+    this.defaults = defaults;
+  }
+  conn;
+  defaults;
+  list(params = {}, options) {
+    return this.conn.call(
+      "teams.list",
+      { locale: this.defaults.locale, ...params },
+      options
+    );
+  }
+  get(params, options) {
+    return this.conn.call(
+      "teams.get",
+      { locale: this.defaults.locale, ...params },
+      options
+    );
+  }
+  form(params, options) {
+    return this.conn.call(
+      "teams.form",
+      { locale: this.defaults.locale, ...params },
+      options
+    );
+  }
+};
+
+// src/subscription.ts
+var PENDING_SUB_ID = "__pending_ws__";
+var Subscription = class {
+  emitter = new Emitter();
+  connection;
+  internalSubId;
+  currentSnapshot;
+  cancelled = false;
+  /**
+   * True when `cancel()` was called before the WS subscribe arrived (subId
+   * still pending). Once WS resolves, `_deliverSnapshot` issues the
+   * server-side cancel so we don't leak a registered subscription.
+   */
+  pendingCancel = false;
+  /** @internal — constructed by the SDK, not by user code. */
+  constructor(connection, subId, initialSnapshot) {
+    this.connection = connection;
+    this.internalSubId = subId;
+    this.currentSnapshot = initialSnapshot;
+  }
+  /** The latest snapshot the server has emitted (initial, or post-reconnect). */
+  get snapshot() {
+    return this.currentSnapshot;
+  }
+  /** Current server-issued subscription id. Changes on reconnect. */
+  get id() {
+    return this.internalSubId;
+  }
+  /**
+   * Listen for a push event from this subscription. Returns an unsubscribe
+   * function that removes only this listener.
+   *
+   * In addition to protocol push events, two synthetic events fire:
+   * - `snapshot` — when a reconnect produced a fresh snapshot
+   * - `closed`   — when the server terminates the subscription (or cancel)
+   */
+  on(event, fn) {
+    return this.emitter.on(event, fn);
+  }
+  /**
+   * Cancel the subscription server-side. Idempotent — calling twice is safe.
+   */
+  async cancel() {
+    if (this.cancelled) return;
+    this.cancelled = true;
+    if (this.internalSubId === PENDING_SUB_ID) {
+      this.pendingCancel = true;
+      this.emitter.clear();
+      return;
+    }
+    await this.connection.cancelSubscription(this.internalSubId);
+    this.emitter.clear();
+  }
+  // ---------------------------------------------------------------------
+  // Internal — invoked by Connection's routing layer.
+  // ---------------------------------------------------------------------
+  /** @internal */
+  _deliverEvent(params) {
+    if (this.cancelled) return;
+    this.emitter.emit(
+      params.event,
+      params.data
+    );
+  }
+  /** @internal */
+  _deliverSnapshot(newSubId, snapshot) {
+    this.internalSubId = newSubId;
+    if (this.pendingCancel) {
+      this.pendingCancel = false;
+      this.connection.cancelSubscription(newSubId).catch(() => void 0);
+      return;
+    }
+    if (this.cancelled) return;
+    this.currentSnapshot = snapshot;
+    this.emitter.emit("snapshot", snapshot);
+  }
+  /** @internal */
+  _deliverClosed(reason, message) {
+    if (this.cancelled) return;
+    this.cancelled = true;
+    this.emitter.emit(
+      "closed",
+      { reason, message }
+    );
+    this.emitter.clear();
+  }
+};
+
+// src/resources/matches.ts
+var Matches = class {
+  constructor(conn, defaults, http) {
+    this.conn = conn;
+    this.defaults = defaults;
+    this.http = http;
+  }
+  conn;
+  defaults;
+  http;
+  list(params = {}, options) {
+    return this.conn.call(
+      "matches.list",
+      {
+        locale: this.defaults.locale,
+        timezone: this.defaults.timezone,
+        ...params
+      },
+      options
+    );
+  }
+  get(params, options) {
+    return this.conn.call(
+      "matches.get",
+      { locale: this.defaults.locale, ...params },
+      options
+    );
+  }
+  trending(params = {}, options) {
+    return this.conn.call(
+      "matches.trending",
+      {
+        locale: this.defaults.locale,
+        timezone: this.defaults.timezone,
+        ...params
+      },
+      options
+    );
+  }
+  search(params, options) {
+    return this.conn.call(
+      "matches.search",
+      { locale: this.defaults.locale, ...params },
+      options
+    );
+  }
+  async subscribeLive(params = {}, options) {
+    const merged = { locale: this.defaults.locale, ...params };
+    let handle;
+    const wsPromise = this.conn.registerSubscription(
+      "matches.subscribeLive",
+      merged,
+      {
+        onEvent: (event) => handle?._deliverEvent(event),
+        onClosed: (p) => handle?._deliverClosed(p.reason, p.message),
+        onSnapshot: (newSubId, newSnap) => handle?._deliverSnapshot(newSubId, newSnap)
+      },
+      options
+    );
+    const httpPromise = this.http.call(
+      "matches.getLive",
+      merged,
+      options
+    ).then((snapshot) => ({ kind: "http", snapshot }));
+    const wsRace = wsPromise.then((r) => ({
+      kind: "ws",
+      subId: r.subId,
+      snapshot: r.snapshot
+    }));
+    let winner;
+    try {
+      winner = await Promise.race([httpPromise, wsRace]);
+    } catch {
+      const ws = await wsPromise;
+      handle = new Subscription(
+        this.conn,
+        ws.subId,
+        ws.snapshot
+      );
+      return handle;
+    }
+    if (winner.kind === "ws") {
+      handle = new Subscription(
+        this.conn,
+        winner.subId,
+        winner.snapshot
+      );
+      return handle;
+    }
+    handle = new Subscription(
+      this.conn,
+      PENDING_SUB_ID,
+      winner.snapshot
+    );
+    wsPromise.then((r) => {
+      handle._deliverSnapshot(r.subId, r.snapshot);
+    }).catch((err) => {
+      handle._deliverClosed(
+        "internal_error",
+        err instanceof Error ? err.message : String(err)
+      );
+    });
+    return handle;
+  }
+  async subscribe(params, options) {
+    const merged = { locale: this.defaults.locale, ...params };
+    let handle;
+    const { subId, snapshot } = await this.conn.registerSubscription(
+      "matches.subscribe",
+      merged,
+      {
+        onEvent: (event) => handle?._deliverEvent(event),
+        onClosed: (p) => handle?._deliverClosed(p.reason, p.message),
+        onSnapshot: (newSubId, newSnap) => handle?._deliverSnapshot(newSubId, newSnap)
+      },
+      options
+    );
+    handle = new Subscription(this.conn, subId, snapshot);
+    return handle;
+  }
+};
+
+// src/resources/ai.ts
+var Picks = class {
+  constructor(conn, defaults) {
+    this.conn = conn;
+    this.defaults = defaults;
+  }
+  conn;
+  defaults;
+  list(params = {}, options) {
+    return this.conn.call(
+      "ai.picks.list",
+      { locale: this.defaults.locale, ...params },
+      options
+    );
+  }
+};
+var Recommendations = class {
+  constructor(conn, defaults) {
+    this.conn = conn;
+    this.defaults = defaults;
+  }
+  conn;
+  defaults;
+  list(params = {}, options) {
+    return this.conn.call(
+      "ai.recommendations.list",
+      { locale: this.defaults.locale, ...params },
+      options
+    );
+  }
+};
+var Ai = class {
+  picks;
+  recommendations;
+  constructor(conn, defaults) {
+    this.picks = new Picks(conn, defaults);
+    this.recommendations = new Recommendations(conn, defaults);
+  }
+};
+
+// src/resources/tokens.ts
+var Tokens = class {
+  constructor(conn) {
+    this.conn = conn;
+  }
+  conn;
+  /**
+   * Mint a short-lived JWT auth token.
+   *
+   * @param params.ttl  Token lifetime in seconds. Default 600 (10 min).
+   *                    Server-enforced bounds: min 60, max 86400 (24h).
+   * @returns { token, expiresAt } — `token` is opaque to the customer; pass
+   *          it to `@mrdoge/client`. `expiresAt` is ISO-8601.
+   */
+  create(params = {}, options) {
+    return this.conn.call("tokens.create", params, options);
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "wss://api.mrdoge.co/sdk/v1";
+function wsToHttp(url) {
+  if (url.startsWith("wss://")) return "https://" + url.slice("wss://".length);
+  if (url.startsWith("ws://")) return "http://" + url.slice("ws://".length);
+  return url;
+}
+var MrDoge = class {
+  regions;
+  competitions;
+  teams;
+  matches;
+  ai;
+  tokens;
+  connection;
+  http;
+  constructor(options) {
+    if (!options?.apiKey) throw new Error("MrDoge: `apiKey` is required");
+    const config = {
+      ...DEFAULT_CONFIG,
+      baseUrl: options.baseUrl ?? DEFAULT_BASE_URL,
+      apiKey: options.apiKey,
+      locale: options.locale,
+      timezone: options.timezone,
+      requestTimeoutMs: options.requestTimeoutMs ?? DEFAULT_CONFIG.requestTimeoutMs,
+      maxReconnectAttempts: options.maxReconnectAttempts ?? DEFAULT_CONFIG.maxReconnectAttempts,
+      reconnectBackoff: {
+        ...DEFAULT_CONFIG.reconnectBackoff,
+        ...options.reconnectBackoff
+      },
+      compression: options.compression ?? DEFAULT_CONFIG.compression
+    };
+    this.connection = new Connection(config);
+    this.http = (0, import_http.createHttpClient)({
+      apiKey: options.apiKey,
+      baseUrl: wsToHttp(config.baseUrl),
+      locale: options.locale,
+      timezone: options.timezone,
+      requestTimeoutMs: config.requestTimeoutMs
+    });
+    const defaults = { locale: options.locale, timezone: options.timezone };
+    this.regions = new Regions(this.connection, defaults);
+    this.competitions = new Competitions(this.connection, defaults);
+    this.teams = new Teams(this.connection, defaults);
+    this.matches = new Matches(this.connection, defaults, this.http);
+    this.ai = new Ai(this.connection, defaults);
+    this.tokens = new Tokens(this.connection);
+  }
+  /**
+   * Listen to connection lifecycle events.
+   */
+  on(event, fn) {
+    return this.connection.on(event, fn);
+  }
+  /**
+   * Force-open the connection now instead of waiting for the first call.
+   * Returns the welcome payload from the server.
+   */
+  async connect() {
+    return this.connection.connect();
+  }
+  /**
+   * Close the connection and cancel every active subscription. The client is
+   * unusable after `close()`.
+   */
+  async close() {
+    await this.connection.close();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AbortError,
+  ConnectionError,
+  ConnectionLimitError,
+  DEFAULT_BASE_URL,
+  DisconnectedError,
+  ForbiddenError,
+  InternalError,
+  MrDoge,
+  MrDogeError,
+  NotFoundError,
+  ProtocolError,
+  RateLimitError,
+  Subscription,
+  SubscriptionLimitError,
+  TimeoutError,
+  UnauthorizedError,
+  UnavailableError,
+  ValidationError
+});
+//# sourceMappingURL=index.js.map