@danielgroen/dxtrade-api 1.0.22 → 1.0.24

package/dist/index.mjs

@@ -21,7 +21,7 @@ var endpoints = {
   assessments: (base) => `${base}/api/assessments`,
   websocket: (base, atmosphereId) => `wss://${base.split("//")[1]}/client/connector` + websocketQuery(atmosphereId),
   tradeJournal: (base, params) => `${base}/api/tradejournal?from=${params.from}&to=${params.to}`,
-  tradeHistory: (base, params) => `${base}/api/history?from=${params.from}&to=${params.to}&orderId=`,
+  tradeHistory: (base, params) => `${base}/api/history?from=${params.from}&to=${params.to}`,
   subscribeInstruments: (base) => `${base}/api/instruments/subscribeInstrumentSymbols`,
   charts: (base) => `${base}/api/charts`
 };
@@ -80,6 +80,9 @@ var ERROR = /* @__PURE__ */ ((ERROR2) => {
   ERROR2["TRADE_JOURNAL_ERROR"] = "TRADE_JOURNAL_ERROR";
   ERROR2["TRADE_HISTORY_ERROR"] = "TRADE_HISTORY_ERROR";
   ERROR2["ASSESSMENTS_ERROR"] = "ASSESSMENTS_ERROR";
+  ERROR2["RATE_LIMITED"] = "RATE_LIMITED";
+  ERROR2["WS_MANAGER_ERROR"] = "WS_MANAGER_ERROR";
+  ERROR2["STREAM_REQUIRES_CONNECT"] = "STREAM_REQUIRES_CONNECT";
   return ERROR2;
 })(ERROR || {});
 var WS_MESSAGE = /* @__PURE__ */ ((WS_MESSAGE2) => {
@@ -118,7 +121,7 @@ var DxtradeError = class extends Error {
 };
 
 // src/domains/account/account.ts
-import WebSocket from "ws";
+import WebSocket2 from "ws";
 
 // src/utils/cookies.ts
 var Cookies = class {
@@ -163,14 +166,17 @@ function cookieOnlyHeaders(cookieStr) {
 }
 
 // src/utils/retry.ts
-import axios from "axios";
+import axios, { isAxiosError } from "axios";
 async function retryRequest(config, retries = 3) {
   for (let attempt = 1; attempt <= retries; attempt++) {
     try {
       return await axios(config);
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
-      console.warn(`[dxtrade-api] Attempt ${attempt} failed: ${message}`);
+      console.warn(`[dxtrade-api] Attempt ${attempt} failed: ${message}`, config.url);
+      if (isAxiosError(error) && error.response?.status === 429) {
+        throw new DxtradeError("RATE_LIMITED" /* RATE_LIMITED */, "Rate limited (429). Too many requests \u2014 try again later.");
+      }
       if (attempt === retries) throw error;
       await new Promise((res) => setTimeout(res, 1e3 * attempt));
     }
@@ -213,13 +219,83 @@ function parseWsData(data) {
   }
 }
 
+// src/utils/ws-manager.ts
+import { EventEmitter } from "events";
+import WebSocket from "ws";
+var WsManager = class extends EventEmitter {
+  _ws = null;
+  _cache = /* @__PURE__ */ new Map();
+  connect(wsUrl, cookieStr, debug = false) {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(wsUrl, { headers: { Cookie: cookieStr } });
+      ws.on("open", () => {
+        this._ws = ws;
+        resolve();
+      });
+      ws.on("message", (data) => {
+        const msg = parseWsData(data);
+        if (shouldLog(msg, debug)) debugLog(msg);
+        if (typeof msg === "string") return;
+        const payload = msg;
+        this._cache.set(payload.type, payload.body);
+        this.emit(payload.type, payload.body);
+      });
+      ws.on("error", (error) => {
+        if (!this._ws) {
+          return reject(error);
+        }
+        this.emit("error", error);
+      });
+      ws.on("close", () => {
+        this._ws = null;
+        this.emit("close");
+      });
+    });
+  }
+  waitFor(type, timeout = 3e4) {
+    const cached = this._cache.get(type);
+    if (cached !== void 0) {
+      return Promise.resolve(cached);
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.removeListener(type, onMessage);
+        reject(new Error(`WsManager: timed out waiting for ${type}`));
+      }, timeout);
+      const onMessage = (body) => {
+        clearTimeout(timer);
+        resolve(body);
+      };
+      this.once(type, onMessage);
+    });
+  }
+  getCached(type) {
+    return this._cache.get(type);
+  }
+  close() {
+    if (this._ws) {
+      this._ws.close();
+      this._ws = null;
+    }
+    this._cache.clear();
+    this.removeAllListeners();
+  }
+  get isConnected() {
+    return this._ws !== null && this._ws.readyState === WebSocket.OPEN;
+  }
+};
+
 // src/domains/account/account.ts
 async function getAccountMetrics(ctx, timeout = 3e4) {
   ctx.ensureSession();
+  if (ctx.wsManager) {
+    const body = await ctx.wsManager.waitFor("ACCOUNT_METRICS" /* ACCOUNT_METRICS */, timeout);
+    return body.allMetrics;
+  }
   const wsUrl = endpoints.websocket(ctx.broker, ctx.atmosphereId);
   const cookieStr = Cookies.serialize(ctx.cookies);
   return new Promise((resolve, reject) => {
-    const ws = new WebSocket(wsUrl, { headers: { Cookie: cookieStr } });
+    const ws = new WebSocket2(wsUrl, { headers: { Cookie: cookieStr } });
     const timer = setTimeout(() => {
       ws.close();
       reject(new DxtradeError("ACCOUNT_METRICS_TIMEOUT" /* ACCOUNT_METRICS_TIMEOUT */, "Account metrics timed out"));
@@ -245,12 +321,11 @@ async function getAccountMetrics(ctx, timeout = 3e4) {
 async function getTradeHistory(ctx, params) {
   ctx.ensureSession();
   try {
-    const cookieStr = Cookies.serialize(ctx.cookies);
     const response = await retryRequest(
       {
-        method: "GET",
+        method: "POST",
         url: endpoints.tradeHistory(ctx.broker, params),
-        headers: { ...baseHeaders(), Cookie: cookieStr }
+        headers: authHeaders(ctx.csrf, Cookies.serialize(ctx.cookies))
       },
       ctx.retries
     );
@@ -322,13 +397,13 @@ async function getAssessments(ctx, params) {
 }
 
 // src/domains/instrument/instrument.ts
-import WebSocket2 from "ws";
+import WebSocket3 from "ws";
 async function getInstruments(ctx, params = {}, timeout = 3e4) {
   ctx.ensureSession();
   const wsUrl = endpoints.websocket(ctx.broker, ctx.atmosphereId);
   const cookieStr = Cookies.serialize(ctx.cookies);
   return new Promise((resolve, reject) => {
-    const ws = new WebSocket2(wsUrl, { headers: { Cookie: cookieStr } });
+    const ws = new WebSocket3(wsUrl, { headers: { Cookie: cookieStr } });
     const timer = setTimeout(() => {
       ws.close();
       reject(new DxtradeError("INSTRUMENTS_TIMEOUT" /* INSTRUMENTS_TIMEOUT */, "Instruments request timed out"));
@@ -355,7 +430,7 @@ async function getInstruments(ctx, params = {}, timeout = 3e4) {
               return true;
             })
           );
-        }, 0);
+        }, 200);
       }
     });
     ws.on("error", (error) => {
@@ -367,7 +442,7 @@ async function getInstruments(ctx, params = {}, timeout = 3e4) {
 }
 
 // src/domains/ohlc/ohlc.ts
-import WebSocket3 from "ws";
+import WebSocket4 from "ws";
 async function getOHLC(ctx, params, timeout = 3e4) {
   ctx.ensureSession();
   const { symbol, resolution = 60, range = 432e3, maxBars = 3500, priceField = "bid" } = params;
@@ -375,7 +450,7 @@ async function getOHLC(ctx, params, timeout = 3e4) {
   const cookieStr = Cookies.serialize(ctx.cookies);
   const headers = authHeaders(ctx.csrf, cookieStr);
   return new Promise((resolve, reject) => {
-    const ws = new WebSocket3(wsUrl, { headers: { Cookie: cookieStr } });
+    const ws = new WebSocket4(wsUrl, { headers: { Cookie: cookieStr } });
     const bars = [];
     let putsSent = false;
     let initSettleTimer = null;
@@ -466,10 +541,10 @@ async function getOHLC(ctx, params, timeout = 3e4) {
 
 // src/domains/order/order.ts
 import crypto from "crypto";
-import WebSocket5 from "ws";
+import WebSocket6 from "ws";
 
 // src/domains/symbol/symbol.ts
-import WebSocket4 from "ws";
+import WebSocket5 from "ws";
 async function getSymbolSuggestions(ctx, text) {
   ctx.ensureSession();
   try {
@@ -521,7 +596,7 @@ async function getSymbolLimits(ctx, timeout = 3e4) {
   const wsUrl = endpoints.websocket(ctx.broker, ctx.atmosphereId);
   const cookieStr = Cookies.serialize(ctx.cookies);
   return new Promise((resolve, reject) => {
-    const ws = new WebSocket4(wsUrl, { headers: { Cookie: cookieStr } });
+    const ws = new WebSocket5(wsUrl, { headers: { Cookie: cookieStr } });
     const timer = setTimeout(() => {
       ws.close();
       reject(new DxtradeError("LIMITS_TIMEOUT" /* LIMITS_TIMEOUT */, "Symbol limits request timed out"));
@@ -541,7 +616,7 @@ async function getSymbolLimits(ctx, timeout = 3e4) {
           clearTimeout(timer);
           ws.close();
           resolve(limits);
-        }, 0);
+        }, 200);
       }
     });
     ws.on("error", (error) => {
@@ -554,7 +629,7 @@ async function getSymbolLimits(ctx, timeout = 3e4) {
 
 // src/domains/order/order.ts
 function createOrderListener(wsUrl, cookieStr, timeout = 3e4, debug = false) {
-  const ws = new WebSocket5(wsUrl, { headers: { Cookie: cookieStr } });
+  const ws = new WebSocket6(wsUrl, { headers: { Cookie: cookieStr } });
   let settled = false;
   const ready = new Promise((resolve) => {
     ws.on("open", resolve);
@@ -621,10 +696,13 @@ function createOrderListener(wsUrl, cookieStr, timeout = 3e4, debug = false) {
 }
 async function getOrders(ctx, timeout = 3e4) {
   ctx.ensureSession();
+  if (ctx.wsManager) {
+    return ctx.wsManager.waitFor("ORDERS" /* ORDERS */, timeout);
+  }
   const wsUrl = endpoints.websocket(ctx.broker, ctx.atmosphereId);
   const cookieStr = Cookies.serialize(ctx.cookies);
   return new Promise((resolve, reject) => {
-    const ws = new WebSocket5(wsUrl, { headers: { Cookie: cookieStr } });
+    const ws = new WebSocket6(wsUrl, { headers: { Cookie: cookieStr } });
     const timer = setTimeout(() => {
       ws.close();
       reject(new DxtradeError("ORDERS_TIMEOUT" /* ORDERS_TIMEOUT */, "Orders request timed out"));
@@ -768,13 +846,33 @@ async function submitOrder(ctx, params) {
 }
 
 // src/domains/position/position.ts
-import WebSocket6 from "ws";
+import WebSocket7 from "ws";
+function streamPositions(ctx, callback) {
+  if (!ctx.wsManager) {
+    ctx.throwError(
+      "STREAM_REQUIRES_CONNECT" /* STREAM_REQUIRES_CONNECT */,
+      "Streaming requires a persistent WebSocket. Use connect() instead of auth()."
+    );
+  }
+  const listener = (body) => callback(body);
+  ctx.wsManager.on("POSITIONS" /* POSITIONS */, listener);
+  const cached = ctx.wsManager.getCached("POSITIONS" /* POSITIONS */);
+  if (cached !== void 0) {
+    callback(cached);
+  }
+  return () => {
+    ctx.wsManager?.removeListener("POSITIONS" /* POSITIONS */, listener);
+  };
+}
 async function getPositions(ctx) {
   ctx.ensureSession();
+  if (ctx.wsManager) {
+    return ctx.wsManager.waitFor("POSITIONS" /* POSITIONS */);
+  }
   const wsUrl = endpoints.websocket(ctx.broker, ctx.atmosphereId);
   const cookieStr = Cookies.serialize(ctx.cookies);
   return new Promise((resolve, reject) => {
-    const ws = new WebSocket6(wsUrl, { headers: { Cookie: cookieStr } });
+    const ws = new WebSocket7(wsUrl, { headers: { Cookie: cookieStr } });
     const timer = setTimeout(() => {
       ws.close();
       reject(new DxtradeError("ACCOUNT_POSITIONS_TIMEOUT" /* ACCOUNT_POSITIONS_TIMEOUT */, "Account positions timed out"));
@@ -798,10 +896,13 @@ async function getPositions(ctx) {
 }
 async function getPositionMetrics(ctx, timeout = 3e4) {
   ctx.ensureSession();
+  if (ctx.wsManager) {
+    return ctx.wsManager.waitFor("POSITION_METRICS" /* POSITION_METRICS */, timeout);
+  }
   const wsUrl = endpoints.websocket(ctx.broker, ctx.atmosphereId);
   const cookieStr = Cookies.serialize(ctx.cookies);
   return new Promise((resolve, reject) => {
-    const ws = new WebSocket6(wsUrl, { headers: { Cookie: cookieStr } });
+    const ws = new WebSocket7(wsUrl, { headers: { Cookie: cookieStr } });
     const timer = setTimeout(() => {
       ws.close();
       reject(new DxtradeError("POSITION_METRICS_TIMEOUT" /* POSITION_METRICS_TIMEOUT */, "Position metrics timed out"));
@@ -863,10 +964,10 @@ async function closePosition(ctx, data) {
 }
 
 // src/domains/session/session.ts
-import WebSocket7 from "ws";
+import WebSocket8 from "ws";
 function waitForHandshake(wsUrl, cookieStr, timeout = 3e4, debug = false) {
   return new Promise((resolve, reject) => {
-    const ws = new WebSocket7(wsUrl, { headers: { Cookie: cookieStr } });
+    const ws = new WebSocket8(wsUrl, { headers: { Cookie: cookieStr } });
     let atmosphereId = null;
     const timer = setTimeout(() => {
       ws.close();
@@ -901,7 +1002,11 @@ async function login(ctx) {
         data: {
           username: ctx.config.username,
           password: ctx.config.password,
-          domain: ctx.config.broker
+          // TODO:: take a look at this below, domain nor vendor seems required. it works if i comment out both.
+          // however i still use it since i see brokers use it as well in the login endpoint.
+          // domain: ctx.config.broker,
+          vendor: ctx.config.broker
+          // END TODO::
         },
         headers: { "Content-Type": "application/json" }
       },
@@ -962,7 +1067,7 @@ async function switchAccount(ctx, accountId) {
     ctx.throwError("ACCOUNT_SWITCH_ERROR" /* ACCOUNT_SWITCH_ERROR */, `Error switching account: ${message}`);
   }
 }
-async function connect(ctx) {
+async function auth(ctx) {
   await login(ctx);
   await fetchCsrf(ctx);
   if (ctx.debug) clearDebugLog();
@@ -982,112 +1087,85 @@ async function connect(ctx) {
     ctx.accountId = reconnect.accountId;
   }
 }
+async function connect(ctx) {
+  await auth(ctx);
+  const wsManager = new WsManager();
+  const wsUrl = endpoints.websocket(ctx.broker, ctx.atmosphereId);
+  const cookieStr = Cookies.serialize(ctx.cookies);
+  await wsManager.connect(wsUrl, cookieStr, ctx.debug);
+  ctx.wsManager = wsManager;
+}
+function disconnect(ctx) {
+  if (ctx.wsManager) {
+    ctx.wsManager.close();
+    ctx.wsManager = null;
+  }
+}
 
 // src/client.ts
-var DxtradeClient = class {
-  _ctx;
-  constructor(config) {
-    const callbacks = config.callbacks ?? {};
-    this._ctx = {
-      config,
-      callbacks,
-      cookies: {},
-      csrf: null,
-      accountId: config.accountId ?? null,
-      atmosphereId: null,
-      broker: config.broker,
-      retries: config.retries ?? 3,
-      debug: config.debug ?? false,
-      ensureSession() {
-        if (!this.csrf) {
-          throw new DxtradeError(
-            "NO_SESSION" /* NO_SESSION */,
-            "No active session. Call login() and fetchCsrf() or connect() first."
-          );
-        }
-      },
-      throwError(code, message) {
-        const error = new DxtradeError(code, message);
-        callbacks.onError?.(error);
-        throw error;
-      }
-    };
+var PositionsDomain = class {
+  constructor(_ctx) {
+    this._ctx = _ctx;
   }
-  /** Authenticate with the broker using username and password. */
-  async login() {
-    return login(this._ctx);
+  /** Get all open positions via WebSocket. */
+  get() {
+    return getPositions(this._ctx);
   }
-  /** Fetch the CSRF token required for authenticated requests. */
-  async fetchCsrf() {
-    return fetchCsrf(this._ctx);
+  /** Close a position. Supports partial closes by specifying a quantity smaller than the full position size. */
+  close(params) {
+    return closePosition(this._ctx, params);
   }
-  /** Switch to a specific trading account by ID. */
-  async switchAccount(accountId) {
-    return switchAccount(this._ctx, accountId);
+  /** Close all open positions with market orders. */
+  closeAll() {
+    return closeAllPositions(this._ctx);
   }
-  /** Connect to the broker: login, fetch CSRF, WebSocket handshake, and optional account switch. */
-  async connect() {
-    return connect(this._ctx);
+  /** Get position-level P&L metrics via WebSocket. */
+  metrics() {
+    return getPositionMetrics(this._ctx);
   }
-  /** Search for symbols matching the given text (e.g. "EURUSD", "BTC"). */
-  async getSymbolSuggestions(text) {
-    return getSymbolSuggestions(this._ctx, text);
+  /** Stream real-time position updates. Requires connect(). Returns unsubscribe function. */
+  stream(callback) {
+    return streamPositions(this._ctx, callback);
   }
-  /** Get detailed instrument info for a symbol, including volume limits and lot size. */
-  async getSymbolInfo(symbol) {
-    return getSymbolInfo(this._ctx, symbol);
+};
+var OrdersDomain = class {
+  constructor(_ctx) {
+    this._ctx = _ctx;
   }
-  /** Get order size limits and stop/limit distances for all symbols. */
-  async getSymbolLimits() {
-    return getSymbolLimits(this._ctx);
+  /** Get all pending/open orders via WebSocket. */
+  get() {
+    return getOrders(this._ctx);
   }
   /**
    * Submit a trading order and wait for WebSocket confirmation.
    * Supports market, limit, and stop orders with optional stop loss and take profit.
    */
-  async submitOrder(params) {
+  submit(params) {
     return submitOrder(this._ctx, params);
   }
-  /** Get all pending/open orders via WebSocket. */
-  async getOrders() {
-    return getOrders(this._ctx);
-  }
   /** Cancel a single pending order by its order chain ID. */
-  async cancelOrder(orderChainId) {
+  cancel(orderChainId) {
     return cancelOrder(this._ctx, orderChainId);
   }
   /** Cancel all pending orders. */
-  async cancelAllOrders() {
+  cancelAll() {
     return cancelAllOrders(this._ctx);
   }
+};
+var AccountDomain = class {
+  constructor(_ctx) {
+    this._ctx = _ctx;
+  }
   /** Get account metrics including equity, balance, margin, and open P&L. */
-  async getAccountMetrics() {
+  metrics() {
     return getAccountMetrics(this._ctx);
   }
-  /** Get all open positions via WebSocket. */
-  async getPositions() {
-    return getPositions(this._ctx);
-  }
-  /**
-   * Close a position. Supports partial closes by specifying a quantity smaller than the full position size.
-   */
-  async closePosition(position) {
-    return closePosition(this._ctx, position);
-  }
-  /** Close all open positions with market orders. */
-  async closeAllPositions() {
-    return closeAllPositions(this._ctx);
-  }
-  /** Get position-level P&L metrics via WebSocket. */
-  async getPositionMetrics() {
-    return getPositionMetrics(this._ctx);
-  }
   /**
    * Fetch trade journal entries for a date range.
    * @param params.from - Start timestamp (Unix ms)
    * @param params.to - End timestamp (Unix ms)
    */
-  async getTradeJournal(params) {
+  tradeJournal(params) {
     return getTradeJournal(this._ctx, params);
   }
   /**
@@ -1095,16 +1173,39 @@ var DxtradeClient = class {
    * @param params.from - Start timestamp (Unix ms)
    * @param params.to - End timestamp (Unix ms)
    */
-  async getTradeHistory(params) {
+  tradeHistory(params) {
     return getTradeHistory(this._ctx, params);
   }
+};
+var SymbolsDomain = class {
+  constructor(_ctx) {
+    this._ctx = _ctx;
+  }
+  /** Search for symbols matching the given text (e.g. "EURUSD", "BTC"). */
+  search(text) {
+    return getSymbolSuggestions(this._ctx, text);
+  }
+  /** Get detailed instrument info for a symbol, including volume limits and lot size. */
+  info(symbol) {
+    return getSymbolInfo(this._ctx, symbol);
+  }
+  /** Get order size limits and stop/limit distances for all symbols. */
+  limits() {
+    return getSymbolLimits(this._ctx);
+  }
+};
+var InstrumentsDomain = class {
+  constructor(_ctx) {
+    this._ctx = _ctx;
+  }
   /** Get all available instruments, optionally filtered by partial match (e.g. `{ type: "FOREX" }`). */
-  async getInstruments(params = {}) {
+  get(params = {}) {
     return getInstruments(this._ctx, params);
   }
-  /** Fetch PnL assessments for an instrument within a date range. */
-  async getAssessments(params) {
-    return getAssessments(this._ctx, params);
+};
+var OhlcDomain = class {
+  constructor(_ctx) {
+    this._ctx = _ctx;
   }
   /**
    * Fetch OHLC price bars for a symbol.
@@ -1114,10 +1215,92 @@ var DxtradeClient = class {
    * @param params.maxBars - Maximum bars to return (default: 3500)
    * @param params.priceField - "bid" or "ask" (default: "bid")
    */
-  async getOHLC(params) {
+  get(params) {
     return getOHLC(this._ctx, params);
   }
 };
+var AssessmentsDomain = class {
+  constructor(_ctx) {
+    this._ctx = _ctx;
+  }
+  /** Fetch PnL assessments for an instrument within a date range. */
+  get(params) {
+    return getAssessments(this._ctx, params);
+  }
+};
+var DxtradeClient = class {
+  _ctx;
+  /** Position operations: get, close, metrics, streaming. */
+  positions;
+  /** Order operations: get, submit, cancel. */
+  orders;
+  /** Account operations: metrics, trade journal, trade history. */
+  account;
+  /** Symbol operations: search, info, limits. */
+  symbols;
+  /** Instrument operations: get (with optional filtering). */
+  instruments;
+  /** OHLC price bar operations: get. */
+  ohlc;
+  /** PnL assessment operations: get. */
+  assessments;
+  constructor(config) {
+    const callbacks = config.callbacks ?? {};
+    this._ctx = {
+      config,
+      callbacks,
+      cookies: {},
+      csrf: null,
+      accountId: config.accountId ?? null,
+      atmosphereId: null,
+      wsManager: null,
+      broker: config.broker,
+      retries: config.retries ?? 3,
+      debug: config.debug ?? false,
+      ensureSession() {
+        if (!this.csrf) {
+          throw new DxtradeError("NO_SESSION" /* NO_SESSION */, "No active session. Call auth() or connect() first.");
+        }
+      },
+      throwError(code, message) {
+        const error = new DxtradeError(code, message);
+        callbacks.onError?.(error);
+        throw error;
+      }
+    };
+    this.positions = new PositionsDomain(this._ctx);
+    this.orders = new OrdersDomain(this._ctx);
+    this.account = new AccountDomain(this._ctx);
+    this.symbols = new SymbolsDomain(this._ctx);
+    this.instruments = new InstrumentsDomain(this._ctx);
+    this.ohlc = new OhlcDomain(this._ctx);
+    this.assessments = new AssessmentsDomain(this._ctx);
+  }
+  /** Authenticate with the broker using username and password. */
+  async login() {
+    return login(this._ctx);
+  }
+  /** Fetch the CSRF token required for authenticated requests. */
+  async fetchCsrf() {
+    return fetchCsrf(this._ctx);
+  }
+  /** Switch to a specific trading account by ID. */
+  async switchAccount(accountId) {
+    return switchAccount(this._ctx, accountId);
+  }
+  /** Authenticate and establish a session: login, fetch CSRF, WebSocket handshake, and optional account switch. */
+  async auth() {
+    return auth(this._ctx);
+  }
+  /** Connect to the broker with a persistent WebSocket: auth + persistent WS for data reuse and streaming. */
+  async connect() {
+    return connect(this._ctx);
+  }
+  /** Close the persistent WebSocket connection. */
+  disconnect() {
+    return disconnect(this._ctx);
+  }
+};
 export {
   ACTION,
   BROKER,