@danielgroen/dxtrade-api 1.0.24 → 1.0.26

package/dist/index.js

@@ -35,6 +35,9 @@ __export(index_exports, {
   DxtradeClient: () => DxtradeClient,
   DxtradeError: () => DxtradeError,
   ERROR: () => ERROR,
+  MESSAGE_CATEGORY: () => MESSAGE_CATEGORY,
+  MESSAGE_TYPE: () => MESSAGE_TYPE,
+  ORDER_STATUS: () => ORDER_STATUS,
   ORDER_TYPE: () => ORDER_TYPE,
   SIDE: () => SIDE,
   TIF: () => TIF,
@@ -115,7 +118,9 @@ var ERROR = /* @__PURE__ */ ((ERROR2) => {
   ERROR2["ORDERS_TIMEOUT"] = "ORDERS_TIMEOUT";
   ERROR2["ORDERS_ERROR"] = "ORDERS_ERROR";
   ERROR2["CANCEL_ORDER_ERROR"] = "CANCEL_ORDER_ERROR";
+  ERROR2["POSITION_NOT_FOUND"] = "POSITION_NOT_FOUND";
   ERROR2["POSITION_CLOSE_ERROR"] = "POSITION_CLOSE_ERROR";
+  ERROR2["POSITION_CLOSE_TIMEOUT"] = "POSITION_CLOSE_TIMEOUT";
   ERROR2["POSITION_METRICS_TIMEOUT"] = "POSITION_METRICS_TIMEOUT";
   ERROR2["POSITION_METRICS_ERROR"] = "POSITION_METRICS_ERROR";
   ERROR2["ACCOUNT_METRICS_TIMEOUT"] = "ACCOUNT_METRICS_TIMEOUT";
@@ -130,6 +135,22 @@ var ERROR = /* @__PURE__ */ ((ERROR2) => {
   ERROR2["STREAM_REQUIRES_CONNECT"] = "STREAM_REQUIRES_CONNECT";
   return ERROR2;
 })(ERROR || {});
+var MESSAGE_CATEGORY = /* @__PURE__ */ ((MESSAGE_CATEGORY2) => {
+  MESSAGE_CATEGORY2["TRADE_LOG"] = "TRADE_LOG";
+  MESSAGE_CATEGORY2["NOTIFICATION"] = "NOTIFICATION";
+  return MESSAGE_CATEGORY2;
+})(MESSAGE_CATEGORY || {});
+var MESSAGE_TYPE = /* @__PURE__ */ ((MESSAGE_TYPE2) => {
+  MESSAGE_TYPE2["ORDER"] = "ORDER";
+  MESSAGE_TYPE2["INSTRUMENT_ACTIVATED"] = "INSTRUMENT_ACTIVATED";
+  return MESSAGE_TYPE2;
+})(MESSAGE_TYPE || {});
+var ORDER_STATUS = /* @__PURE__ */ ((ORDER_STATUS2) => {
+  ORDER_STATUS2["PLACED"] = "PLACED";
+  ORDER_STATUS2["FILLED"] = "FILLED";
+  ORDER_STATUS2["REJECTED"] = "REJECTED";
+  return ORDER_STATUS2;
+})(ORDER_STATUS || {});
 var WS_MESSAGE = /* @__PURE__ */ ((WS_MESSAGE2) => {
   WS_MESSAGE2["ACCOUNT_METRICS"] = "ACCOUNT_METRICS";
   WS_MESSAGE2["ACCOUNTS"] = "ACCOUNTS";
@@ -152,6 +173,7 @@ var WS_MESSAGE = /* @__PURE__ */ ((WS_MESSAGE2) => {
   let SUBTOPIC;
   ((SUBTOPIC2) => {
     SUBTOPIC2["BIG_CHART_COMPONENT"] = "BigChartComponentPresenter-4";
+    SUBTOPIC2["OHLC_STREAM"] = "OHLCStreamPresenter-0";
   })(SUBTOPIC = WS_MESSAGE2.SUBTOPIC || (WS_MESSAGE2.SUBTOPIC = {}));
 })(WS_MESSAGE || (WS_MESSAGE = {}));
 
@@ -194,7 +216,10 @@ var Cookies = class {
 function baseHeaders() {
   return {
     "Content-Type": "application/json; charset=UTF-8",
-    "Accept-Language": "en-US,en;q=0.9"
+    Accept: "*/*",
+    "Accept-Language": "en-US,en;q=0.9",
+    "Accept-Encoding": "gzip, deflate, br, zstd",
+    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:147.0) Gecko/20100101 Firefox/147.0"
   };
 }
 function authHeaders(csrf, cookieStr) {
@@ -220,7 +245,11 @@ async function retryRequest(config, retries = 3) {
       const message = error instanceof Error ? error.message : "Unknown error";
       console.warn(`[dxtrade-api] Attempt ${attempt} failed: ${message}`, config.url);
       if ((0, import_axios.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 new DxtradeError("RATE_LIMITED" /* RATE_LIMITED */, "Rate limited (429). Too many requests \u2014 try again later.");
+        }
+        await new Promise((res) => setTimeout(res, 3e3 * attempt));
+        continue;
       }
       if (attempt === retries) throw error;
       await new Promise((res) => setTimeout(res, 1e3 * attempt));
@@ -253,6 +282,11 @@ function parseAtmosphereId(data) {
   }
   return null;
 }
+function checkWsRateLimit(error) {
+  if (error.message.includes("429")) {
+    throw new DxtradeError("RATE_LIMITED" /* RATE_LIMITED */, "Rate limited (429). Too many requests \u2014 try again later.");
+  }
+}
 function parseWsData(data) {
   const raw = data.toString();
   const pipeIndex = raw.indexOf("|");
@@ -286,10 +320,12 @@ var WsManager = class extends import_events.EventEmitter {
         this.emit(payload.type, payload.body);
       });
       ws.on("error", (error) => {
+        checkWsRateLimit(error);
+        const err = new Error(`WebSocket manager error: ${error.message}`);
         if (!this._ws) {
-          return reject(error);
+          return reject(err);
         }
-        this.emit("error", error);
+        this.emit("error", err);
       });
       ws.on("close", () => {
         this._ws = null;
@@ -331,258 +367,395 @@ var WsManager = class extends import_events.EventEmitter {
 };
 
 // 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;
+var AccountDomain = class {
+  constructor(_ctx) {
+    this._ctx = _ctx;
   }
-  const wsUrl = endpoints.websocket(ctx.broker, ctx.atmosphereId);
-  const cookieStr = Cookies.serialize(ctx.cookies);
-  return new Promise((resolve, reject) => {
-    const ws = new import_ws2.default(wsUrl, { headers: { Cookie: cookieStr } });
-    const timer = setTimeout(() => {
-      ws.close();
-      reject(new DxtradeError("ACCOUNT_METRICS_TIMEOUT" /* ACCOUNT_METRICS_TIMEOUT */, "Account metrics timed out"));
-    }, timeout);
-    ws.on("message", (data) => {
-      const msg = parseWsData(data);
-      if (shouldLog(msg, ctx.debug)) debugLog(msg);
-      if (typeof msg === "string") return;
-      if (msg.type === "ACCOUNT_METRICS" /* ACCOUNT_METRICS */) {
+  /** Get account metrics including equity, balance, margin, and open P&L. */
+  async metrics(timeout = 3e4) {
+    this._ctx.ensureSession();
+    if (this._ctx.wsManager) {
+      const body = await this._ctx.wsManager.waitFor(
+        "ACCOUNT_METRICS" /* ACCOUNT_METRICS */,
+        timeout
+      );
+      return body.allMetrics;
+    }
+    const wsUrl = endpoints.websocket(this._ctx.broker, this._ctx.atmosphereId);
+    const cookieStr = Cookies.serialize(this._ctx.cookies);
+    return new Promise((resolve, reject) => {
+      const ws = new import_ws2.default(wsUrl, { headers: { Cookie: cookieStr } });
+      const timer = setTimeout(() => {
+        ws.close();
+        reject(new DxtradeError("ACCOUNT_METRICS_TIMEOUT" /* ACCOUNT_METRICS_TIMEOUT */, "Account metrics timed out"));
+      }, timeout);
+      ws.on("message", (data) => {
+        const msg = parseWsData(data);
+        if (shouldLog(msg, this._ctx.debug)) debugLog(msg);
+        if (typeof msg === "string") return;
+        if (msg.type === "ACCOUNT_METRICS" /* ACCOUNT_METRICS */) {
+          clearTimeout(timer);
+          ws.close();
+          const body = msg.body;
+          resolve(body.allMetrics);
+        }
+      });
+      ws.on("error", (error) => {
         clearTimeout(timer);
         ws.close();
-        const body = msg.body;
-        resolve(body.allMetrics);
-      }
-    });
-    ws.on("error", (error) => {
-      clearTimeout(timer);
-      ws.close();
-      reject(new DxtradeError("ACCOUNT_METRICS_ERROR" /* ACCOUNT_METRICS_ERROR */, `Account metrics error: ${error.message}`));
+        checkWsRateLimit(error);
+        reject(new DxtradeError("ACCOUNT_METRICS_ERROR" /* ACCOUNT_METRICS_ERROR */, `Account metrics error: ${error.message}`));
+      });
     });
-  });
-}
-async function getTradeHistory(ctx, params) {
-  ctx.ensureSession();
-  try {
-    const response = await retryRequest(
-      {
-        method: "POST",
-        url: endpoints.tradeHistory(ctx.broker, params),
-        headers: authHeaders(ctx.csrf, Cookies.serialize(ctx.cookies))
-      },
-      ctx.retries
-    );
-    if (response.status === 200) {
-      const setCookies = response.headers["set-cookie"] ?? [];
-      const incoming = Cookies.parse(setCookies);
-      ctx.cookies = Cookies.merge(ctx.cookies, incoming);
-      return response.data;
-    } else {
-      ctx.throwError("TRADE_HISTORY_ERROR" /* TRADE_HISTORY_ERROR */, `Trade history failed: ${response.status}`);
+  }
+  /**
+   * Fetch trade history for a date range.
+   * @param params.from - Start timestamp (Unix ms)
+   * @param params.to - End timestamp (Unix ms)
+   */
+  async tradeHistory(params) {
+    this._ctx.ensureSession();
+    try {
+      const response = await retryRequest(
+        {
+          method: "POST",
+          url: endpoints.tradeHistory(this._ctx.broker, params),
+          headers: authHeaders(this._ctx.csrf, Cookies.serialize(this._ctx.cookies))
+        },
+        this._ctx.retries
+      );
+      if (response.status === 200) {
+        const setCookies = response.headers["set-cookie"] ?? [];
+        const incoming = Cookies.parse(setCookies);
+        this._ctx.cookies = Cookies.merge(this._ctx.cookies, incoming);
+        return response.data;
+      } else {
+        this._ctx.throwError("TRADE_HISTORY_ERROR" /* TRADE_HISTORY_ERROR */, `Trade history failed: ${response.status}`);
+      }
+    } catch (error) {
+      if (error instanceof DxtradeError) throw error;
+      const message = error instanceof Error ? error.message : "Unknown error";
+      this._ctx.throwError("TRADE_HISTORY_ERROR" /* TRADE_HISTORY_ERROR */, `Trade history error: ${message}`);
     }
-  } catch (error) {
-    if (error instanceof DxtradeError) throw error;
-    const message = error instanceof Error ? error.message : "Unknown error";
-    ctx.throwError("TRADE_HISTORY_ERROR" /* TRADE_HISTORY_ERROR */, `Trade history error: ${message}`);
   }
-}
-async function getTradeJournal(ctx, params) {
-  ctx.ensureSession();
-  try {
-    const cookieStr = Cookies.serialize(ctx.cookies);
-    const response = await retryRequest(
-      {
-        method: "GET",
-        url: endpoints.tradeJournal(ctx.broker, params),
-        headers: { ...baseHeaders(), Cookie: cookieStr }
-      },
-      ctx.retries
-    );
-    if (response.status === 200) {
-      const setCookies = response.headers["set-cookie"] ?? [];
-      const incoming = Cookies.parse(setCookies);
-      ctx.cookies = Cookies.merge(ctx.cookies, incoming);
-      return response.data;
-    } else {
-      ctx.throwError("TRADE_JOURNAL_ERROR" /* TRADE_JOURNAL_ERROR */, `Login failed: ${response.status}`);
+  /**
+   * Fetch trade journal entries for a date range.
+   * @param params.from - Start timestamp (Unix ms)
+   * @param params.to - End timestamp (Unix ms)
+   */
+  async tradeJournal(params) {
+    this._ctx.ensureSession();
+    try {
+      const cookieStr = Cookies.serialize(this._ctx.cookies);
+      const response = await retryRequest(
+        {
+          method: "GET",
+          url: endpoints.tradeJournal(this._ctx.broker, params),
+          headers: { ...baseHeaders(), Cookie: cookieStr }
+        },
+        this._ctx.retries
+      );
+      if (response.status === 200) {
+        const setCookies = response.headers["set-cookie"] ?? [];
+        const incoming = Cookies.parse(setCookies);
+        this._ctx.cookies = Cookies.merge(this._ctx.cookies, incoming);
+        return response.data;
+      } else {
+        this._ctx.throwError("TRADE_JOURNAL_ERROR" /* TRADE_JOURNAL_ERROR */, `Login failed: ${response.status}`);
+      }
+    } catch (error) {
+      if (error instanceof DxtradeError) throw error;
+      const message = error instanceof Error ? error.message : "Unknown error";
+      this._ctx.throwError("TRADE_JOURNAL_ERROR" /* TRADE_JOURNAL_ERROR */, `Trade journal error: ${message}`);
     }
-  } catch (error) {
-    if (error instanceof DxtradeError) throw error;
-    const message = error instanceof Error ? error.message : "Unknown error";
-    ctx.throwError("TRADE_JOURNAL_ERROR" /* TRADE_JOURNAL_ERROR */, `Trade journal error: ${message}`);
   }
-}
+};
 
 // src/domains/assessments/assessments.ts
-async function getAssessments(ctx, params) {
-  ctx.ensureSession();
-  try {
-    const response = await retryRequest(
-      {
-        method: "POST",
-        url: endpoints.assessments(ctx.broker),
-        data: {
-          from: params.from,
-          instrument: params.instrument,
-          subtype: params.subtype ?? null,
-          to: params.to
+var AssessmentsDomain = class {
+  constructor(_ctx) {
+    this._ctx = _ctx;
+  }
+  /** Fetch PnL assessments for an instrument within a date range. */
+  async get(params) {
+    this._ctx.ensureSession();
+    try {
+      const response = await retryRequest(
+        {
+          method: "POST",
+          url: endpoints.assessments(this._ctx.broker),
+          data: {
+            from: params.from,
+            instrument: params.instrument,
+            subtype: params.subtype ?? null,
+            to: params.to
+          },
+          headers: authHeaders(this._ctx.csrf, Cookies.serialize(this._ctx.cookies))
         },
-        headers: authHeaders(ctx.csrf, Cookies.serialize(ctx.cookies))
-      },
-      ctx.retries
-    );
-    return response.data;
-  } catch (error) {
-    if (error instanceof DxtradeError) throw error;
-    const message = error instanceof Error ? error.message : "Unknown error";
-    ctx.throwError("ASSESSMENTS_ERROR" /* ASSESSMENTS_ERROR */, `Error fetching assessments: ${message}`);
+        this._ctx.retries
+      );
+      return response.data;
+    } catch (error) {
+      if (error instanceof DxtradeError) throw error;
+      const message = error instanceof Error ? error.message : "Unknown error";
+      this._ctx.throwError("ASSESSMENTS_ERROR" /* ASSESSMENTS_ERROR */, `Error fetching assessments: ${message}`);
+    }
   }
-}
+};
 
 // src/domains/instrument/instrument.ts
 var import_ws3 = __toESM(require("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 import_ws3.default(wsUrl, { headers: { Cookie: cookieStr } });
-    const timer = setTimeout(() => {
-      ws.close();
-      reject(new DxtradeError("INSTRUMENTS_TIMEOUT" /* INSTRUMENTS_TIMEOUT */, "Instruments request timed out"));
-    }, timeout);
-    let instruments = [];
-    let settleTimer = null;
-    ws.on("message", (data) => {
-      const msg = parseWsData(data);
-      if (shouldLog(msg, ctx.debug)) debugLog(msg);
-      if (typeof msg === "string") return;
-      if (msg.type === "INSTRUMENTS" /* INSTRUMENTS */) {
-        instruments.push(...msg.body);
-        if (settleTimer) clearTimeout(settleTimer);
-        settleTimer = setTimeout(() => {
-          clearTimeout(timer);
-          ws.close();
-          resolve(
-            instruments.filter((instrument) => {
-              for (const key in params) {
-                if (params[key] !== instrument[key]) {
-                  return false;
+var InstrumentsDomain = class {
+  constructor(_ctx) {
+    this._ctx = _ctx;
+  }
+  /** Get all available instruments, optionally filtered by partial match (e.g. `{ type: "FOREX" }`). */
+  async get(params = {}, timeout = 3e4) {
+    this._ctx.ensureSession();
+    const wsUrl = endpoints.websocket(this._ctx.broker, this._ctx.atmosphereId);
+    const cookieStr = Cookies.serialize(this._ctx.cookies);
+    return new Promise((resolve, reject) => {
+      const ws = new import_ws3.default(wsUrl, { headers: { Cookie: cookieStr } });
+      const timer = setTimeout(() => {
+        ws.close();
+        reject(new DxtradeError("INSTRUMENTS_TIMEOUT" /* INSTRUMENTS_TIMEOUT */, "Instruments request timed out"));
+      }, timeout);
+      let instruments = [];
+      let settleTimer = null;
+      ws.on("message", (data) => {
+        const msg = parseWsData(data);
+        if (shouldLog(msg, this._ctx.debug)) debugLog(msg);
+        if (typeof msg === "string") return;
+        if (msg.type === "INSTRUMENTS" /* INSTRUMENTS */) {
+          instruments.push(...msg.body);
+          if (settleTimer) clearTimeout(settleTimer);
+          settleTimer = setTimeout(() => {
+            clearTimeout(timer);
+            ws.close();
+            resolve(
+              instruments.filter((instrument) => {
+                for (const key in params) {
+                  if (params[key] !== instrument[key]) {
+                    return false;
+                  }
                 }
-              }
-              return true;
-            })
-          );
-        }, 200);
-      }
-    });
-    ws.on("error", (error) => {
-      clearTimeout(timer);
-      ws.close();
-      reject(new DxtradeError("INSTRUMENTS_ERROR" /* INSTRUMENTS_ERROR */, `Instruments error: ${error.message}`));
+                return true;
+              })
+            );
+          }, 200);
+        }
+      });
+      ws.on("error", (error) => {
+        clearTimeout(timer);
+        ws.close();
+        checkWsRateLimit(error);
+        reject(new DxtradeError("INSTRUMENTS_ERROR" /* INSTRUMENTS_ERROR */, `Instruments error: ${error.message}`));
+      });
     });
-  });
-}
+  }
+};
 
 // src/domains/ohlc/ohlc.ts
 var import_ws4 = __toESM(require("ws"));
-async function getOHLC(ctx, params, timeout = 3e4) {
-  ctx.ensureSession();
-  const { symbol, resolution = 60, range = 432e3, maxBars = 3500, priceField = "bid" } = params;
-  const wsUrl = endpoints.websocket(ctx.broker, ctx.atmosphereId);
-  const cookieStr = Cookies.serialize(ctx.cookies);
-  const headers = authHeaders(ctx.csrf, cookieStr);
-  return new Promise((resolve, reject) => {
-    const ws = new import_ws4.default(wsUrl, { headers: { Cookie: cookieStr } });
-    const bars = [];
-    let putsSent = false;
-    let initSettleTimer = null;
-    let barSettleTimer = null;
-    const timer = setTimeout(() => {
-      ws.close();
-      reject(new DxtradeError("OHLC_TIMEOUT" /* OHLC_TIMEOUT */, "OHLC data timed out"));
-    }, timeout);
-    function cleanup() {
-      clearTimeout(timer);
-      if (initSettleTimer) clearTimeout(initSettleTimer);
-      if (barSettleTimer) clearTimeout(barSettleTimer);
-      ws.close();
+var OhlcDomain = class {
+  constructor(_ctx) {
+    this._ctx = _ctx;
+  }
+  /** Stream real-time OHLC bar updates. Requires connect(). Returns unsubscribe function. */
+  async stream(params, callback) {
+    if (!this._ctx.wsManager) {
+      this._ctx.throwError(
+        "STREAM_REQUIRES_CONNECT" /* STREAM_REQUIRES_CONNECT */,
+        "Streaming requires a persistent WebSocket. Use connect() instead of auth()."
+      );
     }
-    async function sendPuts() {
-      putsSent = true;
-      try {
-        await retryRequest(
-          {
-            method: "PUT",
-            url: endpoints.subscribeInstruments(ctx.broker),
-            data: { instruments: [symbol] },
-            headers
-          },
-          ctx.retries
-        );
-        await retryRequest(
-          {
-            method: "PUT",
-            url: endpoints.charts(ctx.broker),
-            data: {
-              chartIds: [],
-              requests: [
-                {
-                  aggregationPeriodSeconds: resolution,
-                  extendedSession: true,
-                  forexPriceField: priceField,
-                  id: 0,
-                  maxBarsCount: maxBars,
-                  range,
-                  studySubscription: [],
-                  subtopic: WS_MESSAGE.SUBTOPIC.BIG_CHART_COMPONENT,
-                  symbol
-                }
-              ]
-            },
-            headers
-          },
-          ctx.retries
-        );
-      } catch (error) {
-        cleanup();
-        const message = error instanceof Error ? error.message : "Unknown error";
-        reject(new DxtradeError("OHLC_ERROR" /* OHLC_ERROR */, `Error fetching OHLC data: ${message}`));
+    const { symbol, resolution = 60, range = 432e3, maxBars = 3500, priceField = "bid" } = params;
+    const subtopic = WS_MESSAGE.SUBTOPIC.OHLC_STREAM;
+    const headers = authHeaders(this._ctx.csrf, Cookies.serialize(this._ctx.cookies));
+    const snapshotBars = [];
+    let snapshotDone = false;
+    let resolveSnapshot = null;
+    const onChartFeed = (body) => {
+      if (body?.subtopic !== subtopic) return;
+      const data = body.data;
+      if (!Array.isArray(data)) return;
+      if (!snapshotDone) {
+        snapshotBars.push(...data);
+        if (body.snapshotEnd) {
+          snapshotDone = true;
+          callback([...snapshotBars]);
+          resolveSnapshot?.();
+        }
+      } else {
+        callback(data);
       }
+    };
+    this._ctx.wsManager.on("chartFeedSubtopic" /* CHART_FEED_SUBTOPIC */, onChartFeed);
+    try {
+      await retryRequest(
+        {
+          method: "PUT",
+          url: endpoints.subscribeInstruments(this._ctx.broker),
+          data: { instruments: [symbol] },
+          headers
+        },
+        this._ctx.retries
+      );
+      await retryRequest(
+        {
+          method: "PUT",
+          url: endpoints.charts(this._ctx.broker),
+          data: {
+            chartIds: [],
+            requests: [
+              {
+                aggregationPeriodSeconds: resolution,
+                extendedSession: true,
+                forexPriceField: priceField,
+                id: 0,
+                maxBarsCount: maxBars,
+                range,
+                studySubscription: [],
+                subtopic,
+                symbol
+              }
+            ]
+          },
+          headers
+        },
+        this._ctx.retries
+      );
+    } catch (error) {
+      this._ctx.wsManager.removeListener("chartFeedSubtopic" /* CHART_FEED_SUBTOPIC */, onChartFeed);
+      const message = error instanceof Error ? error.message : "Unknown error";
+      this._ctx.throwError("OHLC_ERROR" /* OHLC_ERROR */, `OHLC stream subscription error: ${message}`);
     }
-    ws.on("message", (data) => {
-      const msg = parseWsData(data);
-      if (shouldLog(msg, ctx.debug)) debugLog(msg);
-      if (typeof msg === "string") return;
-      if (!putsSent) {
+    await new Promise((resolve, reject) => {
+      if (snapshotDone) return resolve();
+      const timer = setTimeout(() => {
+        if (snapshotBars.length > 0) {
+          snapshotDone = true;
+          callback([...snapshotBars]);
+          resolve();
+        } else {
+          this._ctx.wsManager?.removeListener("chartFeedSubtopic" /* CHART_FEED_SUBTOPIC */, onChartFeed);
+          reject(new DxtradeError("OHLC_TIMEOUT" /* OHLC_TIMEOUT */, "OHLC stream snapshot timed out"));
+        }
+      }, 3e4);
+      resolveSnapshot = () => {
+        clearTimeout(timer);
+        resolve();
+      };
+    });
+    return () => {
+      this._ctx.wsManager?.removeListener("chartFeedSubtopic" /* CHART_FEED_SUBTOPIC */, onChartFeed);
+    };
+  }
+  /**
+   * Fetch OHLC price bars for a symbol.
+   * @param params.symbol - Instrument symbol (e.g. "EURUSD")
+   * @param params.resolution - Bar period in seconds (default: 60 = 1 min)
+   * @param params.range - Lookback window in seconds (default: 432000 = 5 days)
+   * @param params.maxBars - Maximum bars to return (default: 3500)
+   * @param params.priceField - "bid" or "ask" (default: "bid")
+   */
+  async get(params, timeout = 3e4) {
+    this._ctx.ensureSession();
+    const { symbol, resolution = 60, range = 432e3, maxBars = 3500, priceField = "bid" } = params;
+    const wsUrl = endpoints.websocket(this._ctx.broker, this._ctx.atmosphereId);
+    const cookieStr = Cookies.serialize(this._ctx.cookies);
+    const headers = authHeaders(this._ctx.csrf, cookieStr);
+    return new Promise((resolve, reject) => {
+      const ws = new import_ws4.default(wsUrl, { headers: { Cookie: cookieStr } });
+      const bars = [];
+      let putsSent = false;
+      let initSettleTimer = null;
+      let barSettleTimer = null;
+      const timer = setTimeout(() => {
+        ws.close();
+        reject(new DxtradeError("OHLC_TIMEOUT" /* OHLC_TIMEOUT */, "OHLC data timed out"));
+      }, timeout);
+      function cleanup() {
+        clearTimeout(timer);
         if (initSettleTimer) clearTimeout(initSettleTimer);
-        initSettleTimer = setTimeout(() => sendPuts(), 1e3);
-        return;
-      }
-      const body = msg.body;
-      if (body?.subtopic !== WS_MESSAGE.SUBTOPIC.BIG_CHART_COMPONENT) return;
-      if (Array.isArray(body.data)) {
-        bars.push(...body.data);
+        if (barSettleTimer) clearTimeout(barSettleTimer);
+        ws.close();
       }
-      if (barSettleTimer) clearTimeout(barSettleTimer);
-      if (body.snapshotEnd) {
-        cleanup();
-        resolve(bars);
-      } else {
-        barSettleTimer = setTimeout(() => {
+      const sendPuts = async () => {
+        putsSent = true;
+        try {
+          await retryRequest(
+            {
+              method: "PUT",
+              url: endpoints.subscribeInstruments(this._ctx.broker),
+              data: { instruments: [symbol] },
+              headers
+            },
+            this._ctx.retries
+          );
+          await retryRequest(
+            {
+              method: "PUT",
+              url: endpoints.charts(this._ctx.broker),
+              data: {
+                chartIds: [],
+                requests: [
+                  {
+                    aggregationPeriodSeconds: resolution,
+                    extendedSession: true,
+                    forexPriceField: priceField,
+                    id: 0,
+                    maxBarsCount: maxBars,
+                    range,
+                    studySubscription: [],
+                    subtopic: WS_MESSAGE.SUBTOPIC.BIG_CHART_COMPONENT,
+                    symbol
+                  }
+                ]
+              },
+              headers
+            },
+            this._ctx.retries
+          );
+        } catch (error) {
+          cleanup();
+          const message = error instanceof Error ? error.message : "Unknown error";
+          reject(new DxtradeError("OHLC_ERROR" /* OHLC_ERROR */, `Error fetching OHLC data: ${message}`));
+        }
+      };
+      ws.on("message", (data) => {
+        const msg = parseWsData(data);
+        if (shouldLog(msg, this._ctx.debug)) debugLog(msg);
+        if (typeof msg === "string") return;
+        if (!putsSent) {
+          if (initSettleTimer) clearTimeout(initSettleTimer);
+          initSettleTimer = setTimeout(() => sendPuts(), 1e3);
+          return;
+        }
+        const body = msg.body;
+        if (body?.subtopic !== WS_MESSAGE.SUBTOPIC.BIG_CHART_COMPONENT) return;
+        if (Array.isArray(body.data)) {
+          bars.push(...body.data);
+        }
+        if (barSettleTimer) clearTimeout(barSettleTimer);
+        if (body.snapshotEnd) {
           cleanup();
           resolve(bars);
-        }, 2e3);
-      }
-    });
-    ws.on("error", (error) => {
-      cleanup();
-      reject(new DxtradeError("OHLC_ERROR" /* OHLC_ERROR */, `OHLC WebSocket error: ${error.message}`));
+        } else {
+          barSettleTimer = setTimeout(() => {
+            cleanup();
+            resolve(bars);
+          }, 2e3);
+        }
+      });
+      ws.on("error", (error) => {
+        cleanup();
+        checkWsRateLimit(error);
+        reject(new DxtradeError("OHLC_ERROR" /* OHLC_ERROR */, `OHLC WebSocket error: ${error.message}`));
+      });
     });
-  });
-}
+  }
+};
 
 // src/domains/order/order.ts
 var import_crypto = __toESM(require("crypto"));
@@ -590,88 +763,97 @@ var import_ws6 = __toESM(require("ws"));
 
 // src/domains/symbol/symbol.ts
 var import_ws5 = __toESM(require("ws"));
-async function getSymbolSuggestions(ctx, text) {
-  ctx.ensureSession();
-  try {
-    const cookieStr = Cookies.serialize(ctx.cookies);
-    const response = await retryRequest(
-      {
-        method: "GET",
-        url: endpoints.suggest(ctx.broker, text),
-        headers: { ...baseHeaders(), Cookie: cookieStr }
-      },
-      ctx.retries
-    );
-    const suggests = response.data?.suggests;
-    if (!suggests?.length) {
-      ctx.throwError("NO_SUGGESTIONS" /* NO_SUGGESTIONS */, "No symbol suggestions found");
-    }
-    return suggests;
-  } catch (error) {
-    if (error instanceof DxtradeError) throw error;
-    const message = error instanceof Error ? error.message : "Unknown error";
-    ctx.throwError("SUGGEST_ERROR" /* SUGGEST_ERROR */, `Error getting symbol suggestions: ${message}`);
+var SymbolsDomain = class {
+  constructor(_ctx) {
+    this._ctx = _ctx;
   }
-}
-async function getSymbolInfo(ctx, symbol) {
-  ctx.ensureSession();
-  try {
-    const offsetMinutes = Math.abs((/* @__PURE__ */ new Date()).getTimezoneOffset());
-    const cookieStr = Cookies.serialize(ctx.cookies);
-    const response = await retryRequest(
-      {
-        method: "GET",
-        url: endpoints.instrumentInfo(ctx.broker, symbol, offsetMinutes),
-        headers: { ...baseHeaders(), Cookie: cookieStr }
-      },
-      ctx.retries
-    );
-    if (!response.data) {
-      ctx.throwError("NO_SYMBOL_INFO" /* NO_SYMBOL_INFO */, "No symbol info returned");
+  /** Search for symbols matching the given text (e.g. "EURUSD", "BTC"). */
+  async search(text) {
+    this._ctx.ensureSession();
+    try {
+      const cookieStr = Cookies.serialize(this._ctx.cookies);
+      const response = await retryRequest(
+        {
+          method: "GET",
+          url: endpoints.suggest(this._ctx.broker, text),
+          headers: { ...baseHeaders(), Cookie: cookieStr }
+        },
+        this._ctx.retries
+      );
+      const suggests = response.data?.suggests;
+      if (!suggests?.length) {
+        this._ctx.throwError("NO_SUGGESTIONS" /* NO_SUGGESTIONS */, "No symbol suggestions found");
+      }
+      return suggests;
+    } catch (error) {
+      if (error instanceof DxtradeError) throw error;
+      const message = error instanceof Error ? error.message : "Unknown error";
+      this._ctx.throwError("SUGGEST_ERROR" /* SUGGEST_ERROR */, `Error getting symbol suggestions: ${message}`);
     }
-    return response.data;
-  } catch (error) {
-    if (error instanceof DxtradeError) throw error;
-    const message = error instanceof Error ? error.message : "Unknown error";
-    ctx.throwError("SYMBOL_INFO_ERROR" /* SYMBOL_INFO_ERROR */, `Error getting symbol info: ${message}`);
   }
-}
-async function getSymbolLimits(ctx, 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 import_ws5.default(wsUrl, { headers: { Cookie: cookieStr } });
-    const timer = setTimeout(() => {
-      ws.close();
-      reject(new DxtradeError("LIMITS_TIMEOUT" /* LIMITS_TIMEOUT */, "Symbol limits request timed out"));
-    }, timeout);
-    let limits = [];
-    let settleTimer = null;
-    ws.on("message", (data) => {
-      const msg = parseWsData(data);
-      if (shouldLog(msg, ctx.debug)) debugLog(msg);
-      if (typeof msg === "string") return;
-      if (msg.type === "LIMITS" /* LIMITS */) {
-        const batch = msg.body;
-        if (batch.length === 0) return;
-        limits.push(...batch);
-        if (settleTimer) clearTimeout(settleTimer);
-        settleTimer = setTimeout(() => {
-          clearTimeout(timer);
-          ws.close();
-          resolve(limits);
-        }, 200);
+  /** Get detailed instrument info for a symbol, including volume limits and lot size. */
+  async info(symbol) {
+    this._ctx.ensureSession();
+    try {
+      const offsetMinutes = Math.abs((/* @__PURE__ */ new Date()).getTimezoneOffset());
+      const cookieStr = Cookies.serialize(this._ctx.cookies);
+      const response = await retryRequest(
+        {
+          method: "GET",
+          url: endpoints.instrumentInfo(this._ctx.broker, symbol, offsetMinutes),
+          headers: { ...baseHeaders(), Cookie: cookieStr }
+        },
+        this._ctx.retries
+      );
+      if (!response.data) {
+        this._ctx.throwError("NO_SYMBOL_INFO" /* NO_SYMBOL_INFO */, "No symbol info returned");
       }
-    });
-    ws.on("error", (error) => {
-      clearTimeout(timer);
-      ws.close();
-      reject(new DxtradeError("LIMITS_ERROR" /* LIMITS_ERROR */, `Symbol limits error: ${error.message}`));
-    });
-  });
-}
-
+      return response.data;
+    } catch (error) {
+      if (error instanceof DxtradeError) throw error;
+      const message = error instanceof Error ? error.message : "Unknown error";
+      this._ctx.throwError("SYMBOL_INFO_ERROR" /* SYMBOL_INFO_ERROR */, `Error getting symbol info: ${message}`);
+    }
+  }
+  /** Get order size limits and stop/limit distances for all symbols. */
+  async limits(timeout = 3e4) {
+    this._ctx.ensureSession();
+    const wsUrl = endpoints.websocket(this._ctx.broker, this._ctx.atmosphereId);
+    const cookieStr = Cookies.serialize(this._ctx.cookies);
+    return new Promise((resolve, reject) => {
+      const ws = new import_ws5.default(wsUrl, { headers: { Cookie: cookieStr } });
+      const timer = setTimeout(() => {
+        ws.close();
+        reject(new DxtradeError("LIMITS_TIMEOUT" /* LIMITS_TIMEOUT */, "Symbol limits request timed out"));
+      }, timeout);
+      let limits = [];
+      let settleTimer = null;
+      ws.on("message", (data) => {
+        const msg = parseWsData(data);
+        if (shouldLog(msg, this._ctx.debug)) debugLog(msg);
+        if (typeof msg === "string") return;
+        if (msg.type === "LIMITS" /* LIMITS */) {
+          const batch = msg.body;
+          if (batch.length === 0) return;
+          limits.push(...batch);
+          if (settleTimer) clearTimeout(settleTimer);
+          settleTimer = setTimeout(() => {
+            clearTimeout(timer);
+            ws.close();
+            resolve(limits);
+          }, 200);
+        }
+      });
+      ws.on("error", (error) => {
+        clearTimeout(timer);
+        ws.close();
+        checkWsRateLimit(error);
+        reject(new DxtradeError("LIMITS_ERROR" /* LIMITS_ERROR */, `Symbol limits error: ${error.message}`));
+      });
+    });
+  }
+};
+
 // src/domains/order/order.ts
 function createOrderListener(wsUrl, cookieStr, timeout = 3e4, debug = false) {
   const ws = new import_ws6.default(wsUrl, { headers: { Cookie: cookieStr } });
@@ -701,20 +883,21 @@ function createOrderListener(wsUrl, cookieStr, timeout = 3e4, debug = false) {
       if (msg.type === "MESSAGE" /* MESSAGE */) {
         const messages = msg.body;
         const orderMsg = messages?.findLast?.(
-          (m) => m.messageCategory === "TRADE_LOG" && m.messageType === "ORDER" && !m.historyMessage
+          (m) => m.messageCategory === "TRADE_LOG" /* TRADE_LOG */ && m.messageType === "ORDER" /* ORDER */ && !m.historyMessage
         );
         if (!orderMsg) return;
         const params = orderMsg.parametersTO;
-        if (params.orderStatus === "REJECTED") {
+        if (params.orderStatus === "REJECTED" /* REJECTED */) {
           const reason = params.rejectReason?.key ?? "Unknown reason";
           done(new Error(`[dxtrade-api] Order rejected: ${reason}`));
-        } else if (params.orderStatus === "FILLED") {
+        } else if (params.orderStatus === "FILLED" /* FILLED */) {
           done(null, {
             orderId: params.orderKey,
             status: params.orderStatus,
             symbol: params.symbol,
             filledQuantity: params.filledQuantity,
-            filledPrice: params.filledPrice
+            filledPrice: params.filledPrice,
+            positionCode: params.positionCode
           });
         }
         return;
@@ -722,9 +905,9 @@ function createOrderListener(wsUrl, cookieStr, timeout = 3e4, debug = false) {
       if (msg.type === "ORDERS" /* ORDERS */) {
         const body = msg.body?.[0];
         if (!body?.orderId) return;
-        if (body.status === "REJECTED") {
+        if (body.status === "REJECTED" /* REJECTED */) {
           done(new Error(`[dxtrade-api] Order rejected: ${body.statusDescription ?? "Unknown reason"}`));
-        } else if (body.status === "FILLED") {
+        } else if (body.status === "FILLED" /* FILLED */) {
           done(null, body);
         }
       }
@@ -734,279 +917,489 @@ function createOrderListener(wsUrl, cookieStr, timeout = 3e4, debug = false) {
       settled = true;
       clearTimeout(timer);
       ws.close();
-      reject(new Error(`[dxtrade-api] WebSocket order listener error: ${error.message}`));
+      checkWsRateLimit(error);
+      reject(new DxtradeError("ORDER_ERROR" /* ORDER_ERROR */, `WebSocket order listener error: ${error.message}`));
     });
   });
   return { promise, ready };
 }
-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);
+function createWsManagerOrderListener(ctx, timeout = 3e4) {
   return new Promise((resolve, reject) => {
-    const ws = new import_ws6.default(wsUrl, { headers: { Cookie: cookieStr } });
+    let settled = false;
     const timer = setTimeout(() => {
-      ws.close();
-      reject(new DxtradeError("ORDERS_TIMEOUT" /* ORDERS_TIMEOUT */, "Orders request timed out"));
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(new Error("[dxtrade-api] Order update timed out"));
     }, timeout);
-    ws.on("message", (data) => {
-      const msg = parseWsData(data);
-      if (shouldLog(msg, ctx.debug)) debugLog(msg);
-      if (typeof msg === "string") return;
-      if (msg.type === "ORDERS" /* ORDERS */) {
-        clearTimeout(timer);
-        ws.close();
-        resolve(msg.body);
-      }
-    });
-    ws.on("error", (error) => {
+    function done(err, result) {
+      if (settled) return;
+      settled = true;
       clearTimeout(timer);
-      ws.close();
-      reject(new DxtradeError("ORDERS_ERROR" /* ORDERS_ERROR */, `Orders error: ${error.message}`));
-    });
+      cleanup();
+      if (err) reject(err);
+      else resolve(result);
+    }
+    function onMessage(body) {
+      const messages = body;
+      const orderMsg = messages?.findLast?.(
+        (m) => m.messageCategory === "TRADE_LOG" /* TRADE_LOG */ && m.messageType === "ORDER" /* ORDER */ && !m.historyMessage
+      );
+      if (!orderMsg) return;
+      const params = orderMsg.parametersTO;
+      if (params.orderStatus === "REJECTED" /* REJECTED */) {
+        const reason = params.rejectReason?.key ?? "Unknown reason";
+        done(new Error(`[dxtrade-api] Order rejected: ${reason}`));
+      } else if (params.orderStatus === "FILLED" /* FILLED */) {
+        done(null, {
+          orderId: params.orderKey,
+          status: params.orderStatus,
+          symbol: params.symbol,
+          filledQuantity: params.filledQuantity,
+          filledPrice: params.filledPrice,
+          positionCode: params.positionCode
+        });
+      }
+    }
+    function onOrders(body) {
+      const order = body?.[0];
+      if (!order?.orderId) return;
+      if (order.status === "REJECTED" /* REJECTED */) {
+        done(new Error(`[dxtrade-api] Order rejected: ${order.statusDescription ?? "Unknown reason"}`));
+      } else if (order.status === "FILLED" /* FILLED */) {
+        done(null, order);
+      }
+    }
+    function cleanup() {
+      ctx.wsManager?.removeListener("MESSAGE" /* MESSAGE */, onMessage);
+      ctx.wsManager?.removeListener("ORDERS" /* ORDERS */, onOrders);
+    }
+    ctx.wsManager.on("MESSAGE" /* MESSAGE */, onMessage);
+    ctx.wsManager.on("ORDERS" /* ORDERS */, onOrders);
   });
 }
-async function cancelOrder(ctx, orderChainId) {
-  ctx.ensureSession();
-  const accountId = ctx.accountId ?? ctx.config.accountId;
-  if (!accountId) {
-    ctx.throwError("CANCEL_ORDER_ERROR" /* CANCEL_ORDER_ERROR */, "accountId is required to cancel an order");
-  }
-  try {
-    await retryRequest(
-      {
-        method: "DELETE",
-        url: endpoints.cancelOrder(ctx.broker, accountId, orderChainId),
-        headers: authHeaders(ctx.csrf, Cookies.serialize(ctx.cookies))
-      },
-      ctx.retries
-    );
-  } catch (error) {
-    if (error instanceof DxtradeError) throw error;
-    const message = error instanceof Error ? error.response?.data?.message ?? error.message : "Unknown error";
-    ctx.throwError("CANCEL_ORDER_ERROR" /* CANCEL_ORDER_ERROR */, `Cancel order error: ${message}`);
+var OrdersDomain = class {
+  constructor(_ctx) {
+    this._ctx = _ctx;
   }
-}
-async function cancelAllOrders(ctx) {
-  const orders = await getOrders(ctx);
-  const pending = orders.filter((o) => !o.finalStatus);
-  for (const order of pending) {
-    await cancelOrder(ctx, order.orderId);
+  /** Get all pending/open orders via WebSocket. */
+  async get(timeout = 3e4) {
+    this._ctx.ensureSession();
+    if (this._ctx.wsManager) {
+      return this._ctx.wsManager.waitFor("ORDERS" /* ORDERS */, timeout);
+    }
+    const wsUrl = endpoints.websocket(this._ctx.broker, this._ctx.atmosphereId);
+    const cookieStr = Cookies.serialize(this._ctx.cookies);
+    return new Promise((resolve, reject) => {
+      const ws = new import_ws6.default(wsUrl, { headers: { Cookie: cookieStr } });
+      const timer = setTimeout(() => {
+        ws.close();
+        reject(new DxtradeError("ORDERS_TIMEOUT" /* ORDERS_TIMEOUT */, "Orders request timed out"));
+      }, timeout);
+      ws.on("message", (data) => {
+        const msg = parseWsData(data);
+        if (shouldLog(msg, this._ctx.debug)) debugLog(msg);
+        if (typeof msg === "string") return;
+        if (msg.type === "ORDERS" /* ORDERS */) {
+          clearTimeout(timer);
+          ws.close();
+          resolve(msg.body);
+        }
+      });
+      ws.on("error", (error) => {
+        clearTimeout(timer);
+        ws.close();
+        checkWsRateLimit(error);
+        reject(new DxtradeError("ORDERS_ERROR" /* ORDERS_ERROR */, `Orders error: ${error.message}`));
+      });
+    });
   }
-}
-async function submitOrder(ctx, params) {
-  ctx.ensureSession();
-  const {
-    symbol,
-    side,
-    quantity,
-    orderType,
-    orderCode,
-    price,
-    instrumentId,
-    stopLoss,
-    takeProfit,
-    positionEffect = "OPENING" /* OPENING */,
-    positionCode,
-    tif = "GTC",
-    expireDate,
-    metadata
-  } = params;
-  const info = await getSymbolInfo(ctx, symbol);
-  const units = Math.round(quantity * info.lotSize);
-  const qty = side === "BUY" /* BUY */ ? units : -units;
-  const priceParam = orderType === "STOP" /* STOP */ ? "stopPrice" : "limitPrice";
-  const orderData = {
-    directExchange: false,
-    legs: [
-      {
-        ...instrumentId != null && { instrumentId },
-        ...positionCode != null && { positionCode },
-        positionEffect,
-        ratioQuantity: 1,
-        symbol
-      }
-    ],
-    orderSide: side,
-    orderType,
-    quantity: qty,
-    requestId: orderCode ?? `gwt-uid-931-${import_crypto.default.randomUUID()}`,
-    timeInForce: tif,
-    ...expireDate != null && { expireDate },
-    ...metadata != null && { metadata }
-  };
-  if (price != null && orderType !== "MARKET" /* MARKET */) {
-    orderData[priceParam] = price;
+  /** Cancel a single pending order by its order chain ID. */
+  async cancel(orderChainId) {
+    this._ctx.ensureSession();
+    const accountId = this._ctx.accountId ?? this._ctx.config.accountId;
+    if (!accountId) {
+      this._ctx.throwError("CANCEL_ORDER_ERROR" /* CANCEL_ORDER_ERROR */, "accountId is required to cancel an order");
+    }
+    try {
+      await retryRequest(
+        {
+          method: "DELETE",
+          url: endpoints.cancelOrder(this._ctx.broker, accountId, orderChainId),
+          headers: authHeaders(this._ctx.csrf, Cookies.serialize(this._ctx.cookies))
+        },
+        this._ctx.retries
+      );
+    } catch (error) {
+      if (error instanceof DxtradeError) throw error;
+      const message = error instanceof Error ? error.response?.data?.message ?? error.message : "Unknown error";
+      this._ctx.throwError("CANCEL_ORDER_ERROR" /* CANCEL_ORDER_ERROR */, `Cancel order error: ${message}`);
+    }
   }
-  if (stopLoss) {
-    orderData.stopLoss = {
-      ...stopLoss.offset != null && { fixedOffset: stopLoss.offset },
-      ...stopLoss.price != null && { fixedPrice: stopLoss.price },
-      priceFixed: stopLoss.price != null,
-      orderChainId: 0,
-      orderId: 0,
-      orderType: "STOP" /* STOP */,
-      quantityForProtection: qty,
-      removed: false
-    };
+  /** Cancel all pending orders. */
+  async cancelAll() {
+    const orders = await this.get();
+    const pending = orders.filter((o) => !o.finalStatus);
+    for (const order of pending) {
+      await this.cancel(order.orderId);
+    }
   }
-  if (takeProfit) {
-    orderData.takeProfit = {
-      ...takeProfit.offset != null && { fixedOffset: takeProfit.offset },
-      ...takeProfit.price != null && { fixedPrice: takeProfit.price },
-      priceFixed: takeProfit.price != null,
-      orderChainId: 0,
-      orderId: 0,
-      orderType: "LIMIT" /* LIMIT */,
-      quantityForProtection: qty,
-      removed: false
+  /**
+   * Submit a trading order and wait for WebSocket confirmation.
+   * Supports market, limit, and stop orders with optional stop loss and take profit.
+   */
+  async submit(params) {
+    this._ctx.ensureSession();
+    const {
+      symbol,
+      side,
+      quantity,
+      orderType,
+      orderCode,
+      price,
+      instrumentId,
+      stopLoss,
+      takeProfit,
+      positionEffect = "OPENING" /* OPENING */,
+      positionCode,
+      tif = "GTC",
+      expireDate,
+      metadata
+    } = params;
+    const info = await new SymbolsDomain(this._ctx).info(symbol);
+    const units = quantity * info.lotSize;
+    const qty = side === "BUY" /* BUY */ ? units : -units;
+    const priceParam = orderType === "STOP" /* STOP */ ? "stopPrice" : "limitPrice";
+    const orderData = {
+      directExchange: false,
+      legs: [
+        {
+          ...instrumentId != null && { instrumentId },
+          ...positionCode != null && { positionCode },
+          positionEffect,
+          ratioQuantity: 1,
+          symbol
+        }
+      ],
+      orderSide: side,
+      orderType,
+      quantity: qty,
+      requestId: orderCode ?? `gwt-uid-931-${import_crypto.default.randomUUID()}`,
+      timeInForce: tif,
+      ...expireDate != null && { expireDate },
+      ...metadata != null && { metadata }
     };
+    if (price != null) {
+      orderData[priceParam] = price;
+    }
+    if (stopLoss) {
+      orderData.stopLoss = {
+        ...stopLoss.offset != null && { fixedOffset: stopLoss.offset },
+        ...stopLoss.price != null && { fixedPrice: stopLoss.price },
+        priceFixed: stopLoss.price != null,
+        orderChainId: 0,
+        orderId: 0,
+        orderType: "STOP" /* STOP */,
+        quantityForProtection: qty,
+        removed: false
+      };
+    }
+    if (takeProfit) {
+      orderData.takeProfit = {
+        ...takeProfit.offset != null && { fixedOffset: takeProfit.offset },
+        ...takeProfit.price != null && { fixedPrice: takeProfit.price },
+        priceFixed: takeProfit.price != null,
+        orderChainId: 0,
+        orderId: 0,
+        orderType: "LIMIT" /* LIMIT */,
+        quantityForProtection: qty,
+        removed: false
+      };
+    }
+    try {
+      let listenerPromise;
+      if (this._ctx.wsManager) {
+        listenerPromise = createWsManagerOrderListener(this._ctx, 3e4);
+      } else {
+        const wsUrl = endpoints.websocket(this._ctx.broker, this._ctx.atmosphereId);
+        const cookieStr = Cookies.serialize(this._ctx.cookies);
+        const listener = createOrderListener(wsUrl, cookieStr, 3e4, this._ctx.debug);
+        await listener.ready;
+        listenerPromise = listener.promise;
+      }
+      const response = await retryRequest(
+        {
+          method: "POST",
+          url: endpoints.submitOrder(this._ctx.broker),
+          data: orderData,
+          headers: authHeaders(this._ctx.csrf, Cookies.serialize(this._ctx.cookies))
+        },
+        this._ctx.retries
+      );
+      this._ctx.callbacks.onOrderPlaced?.(response.data);
+      const orderUpdate = await listenerPromise;
+      this._ctx.callbacks.onOrderUpdate?.(orderUpdate);
+      return orderUpdate;
+    } catch (error) {
+      if (error instanceof DxtradeError) throw error;
+      const message = error instanceof Error ? error.response?.data?.message ?? error.message : "Unknown error";
+      this._ctx.throwError("ORDER_ERROR" /* ORDER_ERROR */, `Error submitting order: ${message}`);
+    }
   }
-  try {
-    const wsUrl = endpoints.websocket(ctx.broker, ctx.atmosphereId);
-    const cookieStr = Cookies.serialize(ctx.cookies);
-    const listener = createOrderListener(wsUrl, cookieStr, 3e4, ctx.debug);
-    await listener.ready;
-    const response = await retryRequest(
-      {
-        method: "POST",
-        url: endpoints.submitOrder(ctx.broker),
-        data: orderData,
-        headers: authHeaders(ctx.csrf, Cookies.serialize(ctx.cookies))
-      },
-      ctx.retries
-    );
-    ctx.callbacks.onOrderPlaced?.(response.data);
-    const orderUpdate = await listener.promise;
-    ctx.callbacks.onOrderUpdate?.(orderUpdate);
-    return orderUpdate;
-  } catch (error) {
-    if (error instanceof DxtradeError) throw error;
-    const message = error instanceof Error ? error.response?.data?.message ?? error.message : "Unknown error";
-    ctx.throwError("ORDER_ERROR" /* ORDER_ERROR */, `Error submitting order: ${message}`);
-  }
-}
+};
 
 // src/domains/position/position.ts
 var import_ws7 = __toESM(require("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);
-  };
+function mergePositionsWithMetrics(positions, metrics) {
+  const metricsMap = new Map(metrics.map((m) => [m.uid, m]));
+  return positions.map((pos) => {
+    const m = metricsMap.get(pos.uid);
+    return {
+      ...pos,
+      margin: m?.margin ?? 0,
+      plOpen: m?.plOpen ?? 0,
+      plClosed: m?.plClosed ?? 0,
+      totalCommissions: m?.totalCommissions ?? 0,
+      totalFinancing: m?.totalFinancing ?? 0,
+      plRate: m?.plRate ?? 0,
+      averagePrice: m?.averagePrice ?? 0,
+      marketValue: m?.marketValue ?? 0
+    };
+  });
 }
-async function getPositions(ctx) {
-  ctx.ensureSession();
-  if (ctx.wsManager) {
-    return ctx.wsManager.waitFor("POSITIONS" /* POSITIONS */);
+var PositionsDomain = class {
+  constructor(_ctx) {
+    this._ctx = _ctx;
   }
-  const wsUrl = endpoints.websocket(ctx.broker, ctx.atmosphereId);
-  const cookieStr = Cookies.serialize(ctx.cookies);
-  return new Promise((resolve, reject) => {
-    const ws = new import_ws7.default(wsUrl, { headers: { Cookie: cookieStr } });
-    const timer = setTimeout(() => {
-      ws.close();
-      reject(new DxtradeError("ACCOUNT_POSITIONS_TIMEOUT" /* ACCOUNT_POSITIONS_TIMEOUT */, "Account positions timed out"));
-    }, 3e4);
-    ws.on("message", (data) => {
-      const msg = parseWsData(data);
-      if (shouldLog(msg, ctx.debug)) debugLog(msg);
-      if (typeof msg === "string") return;
-      if (msg.type === "POSITIONS" /* POSITIONS */) {
-        clearTimeout(timer);
-        ws.close();
-        resolve(msg.body);
+  /** Stream real-time position updates with P&L metrics. Requires connect(). Returns unsubscribe function. */
+  stream(callback) {
+    if (!this._ctx.wsManager) {
+      this._ctx.throwError(
+        "STREAM_REQUIRES_CONNECT" /* STREAM_REQUIRES_CONNECT */,
+        "Streaming requires a persistent WebSocket. Use connect() instead of auth()."
+      );
+    }
+    const emit = () => {
+      const positions = this._ctx.wsManager.getCached("POSITIONS" /* POSITIONS */);
+      const metrics = this._ctx.wsManager.getCached("POSITION_METRICS" /* POSITION_METRICS */);
+      if (positions && metrics) {
+        callback(mergePositionsWithMetrics(positions, metrics));
       }
-    });
-    ws.on("error", (error) => {
-      clearTimeout(timer);
-      ws.close();
-      reject(new DxtradeError("ACCOUNT_POSITIONS_ERROR" /* ACCOUNT_POSITIONS_ERROR */, `Account positions error: ${error.message}`));
-    });
-  });
-}
-async function getPositionMetrics(ctx, timeout = 3e4) {
-  ctx.ensureSession();
-  if (ctx.wsManager) {
-    return ctx.wsManager.waitFor("POSITION_METRICS" /* POSITION_METRICS */, timeout);
+    };
+    const onPositions = () => emit();
+    const onMetrics = () => emit();
+    this._ctx.wsManager.on("POSITIONS" /* POSITIONS */, onPositions);
+    this._ctx.wsManager.on("POSITION_METRICS" /* POSITION_METRICS */, onMetrics);
+    emit();
+    return () => {
+      this._ctx.wsManager?.removeListener("POSITIONS" /* POSITIONS */, onPositions);
+      this._ctx.wsManager?.removeListener("POSITION_METRICS" /* POSITION_METRICS */, onMetrics);
+    };
   }
-  const wsUrl = endpoints.websocket(ctx.broker, ctx.atmosphereId);
-  const cookieStr = Cookies.serialize(ctx.cookies);
-  return new Promise((resolve, reject) => {
-    const ws = new import_ws7.default(wsUrl, { headers: { Cookie: cookieStr } });
-    const timer = setTimeout(() => {
-      ws.close();
-      reject(new DxtradeError("POSITION_METRICS_TIMEOUT" /* POSITION_METRICS_TIMEOUT */, "Position metrics timed out"));
-    }, timeout);
-    ws.on("message", (data) => {
-      const msg = parseWsData(data);
-      if (shouldLog(msg, ctx.debug)) debugLog(msg);
-      if (typeof msg === "string") return;
-      if (msg.type === "POSITION_METRICS" /* POSITION_METRICS */) {
+  /** Get all open positions with P&L metrics merged. */
+  async get() {
+    this._ctx.ensureSession();
+    if (this._ctx.wsManager) {
+      const [positions, metrics] = await Promise.all([
+        this._ctx.wsManager.waitFor("POSITIONS" /* POSITIONS */),
+        this._ctx.wsManager.waitFor("POSITION_METRICS" /* POSITION_METRICS */)
+      ]);
+      return mergePositionsWithMetrics(positions, metrics);
+    }
+    const wsUrl = endpoints.websocket(this._ctx.broker, this._ctx.atmosphereId);
+    const cookieStr = Cookies.serialize(this._ctx.cookies);
+    return new Promise((resolve, reject) => {
+      const ws = new import_ws7.default(wsUrl, { headers: { Cookie: cookieStr } });
+      let positions = null;
+      let metrics = null;
+      const timer = setTimeout(() => {
+        ws.close();
+        reject(new DxtradeError("ACCOUNT_POSITIONS_TIMEOUT" /* ACCOUNT_POSITIONS_TIMEOUT */, "Account positions timed out"));
+      }, 3e4);
+      ws.on("message", (data) => {
+        const msg = parseWsData(data);
+        if (shouldLog(msg, this._ctx.debug)) debugLog(msg);
+        if (typeof msg === "string") return;
+        if (msg.type === "POSITIONS" /* POSITIONS */) {
+          positions = msg.body;
+        }
+        if (msg.type === "POSITION_METRICS" /* POSITION_METRICS */) {
+          metrics = msg.body;
+        }
+        if (positions && metrics) {
+          clearTimeout(timer);
+          ws.close();
+          resolve(mergePositionsWithMetrics(positions, metrics));
+        }
+      });
+      ws.on("error", (error) => {
         clearTimeout(timer);
         ws.close();
-        resolve(msg.body);
-      }
-    });
-    ws.on("error", (error) => {
-      clearTimeout(timer);
-      ws.close();
-      reject(new DxtradeError("POSITION_METRICS_ERROR" /* POSITION_METRICS_ERROR */, `Position metrics error: ${error.message}`));
+        checkWsRateLimit(error);
+        reject(new DxtradeError("ACCOUNT_POSITIONS_ERROR" /* ACCOUNT_POSITIONS_ERROR */, `Account positions error: ${error.message}`));
+      });
     });
-  });
-}
-async function closeAllPositions(ctx) {
-  const positions = await getPositions(ctx);
-  for (const pos of positions) {
+  }
+  /** Close all open positions with market orders. */
+  async closeAll() {
+    const positions = await this.get();
+    for (const pos of positions) {
+      const closeData = {
+        legs: [
+          {
+            instrumentId: pos.positionKey.instrumentId,
+            positionCode: pos.positionKey.positionCode,
+            positionEffect: "CLOSING",
+            ratioQuantity: 1,
+            symbol: pos.positionKey.positionCode
+          }
+        ],
+        limitPrice: 0,
+        orderType: "MARKET",
+        quantity: -pos.quantity,
+        timeInForce: "GTC"
+      };
+      await this._sendCloseRequest(closeData);
+    }
+  }
+  /** Close a position by its position code. Returns the position with P&L metrics. Optionally wait for close confirmation via `waitForClose: "stream" | "poll"`. */
+  async close(positionCode, options) {
+    const positions = await this.get();
+    const position = positions.find((p) => p.positionKey.positionCode === positionCode);
+    if (!position) {
+      this._ctx.throwError("POSITION_NOT_FOUND" /* POSITION_NOT_FOUND */, `Position with code "${positionCode}" not found`);
+    }
     const closeData = {
       legs: [
         {
-          instrumentId: pos.positionKey.instrumentId,
-          positionCode: pos.positionKey.positionCode,
+          instrumentId: position.positionKey.instrumentId,
+          positionCode: position.positionKey.positionCode,
           positionEffect: "CLOSING",
           ratioQuantity: 1,
-          symbol: pos.positionKey.positionCode
+          symbol: position.positionKey.positionCode
         }
       ],
       limitPrice: 0,
       orderType: "MARKET",
-      quantity: -pos.quantity,
+      quantity: -position.quantity,
       timeInForce: "GTC"
     };
-    await closePosition(ctx, closeData);
+    if (options?.waitForClose === "stream") {
+      return this._waitForCloseStream(positionCode, position, closeData, options.timeout ?? 3e4);
+    }
+    await this._sendCloseRequest(closeData);
+    if (options?.waitForClose === "poll") {
+      return this._waitForClosePoll(positionCode, position, options.timeout ?? 3e4, options.pollInterval ?? 1e3);
+    }
+    return position;
+  }
+  _waitForCloseStream(positionCode, lastSnapshot, closeData, timeout) {
+    if (!this._ctx.wsManager) {
+      this._ctx.throwError(
+        "STREAM_REQUIRES_CONNECT" /* STREAM_REQUIRES_CONNECT */,
+        'waitForClose: "stream" requires a persistent WebSocket. Use connect() instead of auth(), or use "poll" mode.'
+      );
+    }
+    return new Promise(async (resolve, reject) => {
+      let settled = false;
+      const result = lastSnapshot;
+      const timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        reject(
+          new DxtradeError("POSITION_CLOSE_TIMEOUT" /* POSITION_CLOSE_TIMEOUT */, `Position close confirmation timed out after ${timeout}ms`)
+        );
+      }, timeout);
+      function done(err, res) {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        cleanup();
+        if (err) reject(err);
+        else resolve(res);
+      }
+      function onMessage(body) {
+        const messages = body;
+        const orderMsg = messages?.findLast?.(
+          (m) => m.messageCategory === "TRADE_LOG" /* TRADE_LOG */ && m.messageType === "ORDER" /* ORDER */ && !m.historyMessage
+        );
+        if (!orderMsg) return;
+        const params = orderMsg.parametersTO;
+        if (params.positionCode !== positionCode) return;
+        if (params.orderStatus === "REJECTED" /* REJECTED */) {
+          done(
+            new DxtradeError(
+              "POSITION_CLOSE_ERROR" /* POSITION_CLOSE_ERROR */,
+              `Close order rejected: ${params.rejectReason?.key ?? "Unknown reason"}`
+            )
+          );
+        } else if (params.orderStatus === "FILLED" /* FILLED */) {
+          done(null, result);
+        }
+      }
+      function onOrders(body) {
+        const orders = body;
+        const order = orders?.[0];
+        if (!order?.orderId) return;
+        if (order.status === "REJECTED" /* REJECTED */) {
+          done(
+            new DxtradeError(
+              "POSITION_CLOSE_ERROR" /* POSITION_CLOSE_ERROR */,
+              `Close order rejected: ${order.statusDescription ?? "Unknown reason"}`
+            )
+          );
+        } else if (order.status === "FILLED" /* FILLED */) {
+          done(null, result);
+        }
+      }
+      const wsManager = this._ctx.wsManager;
+      function cleanup() {
+        wsManager.removeListener("MESSAGE" /* MESSAGE */, onMessage);
+        wsManager.removeListener("ORDERS" /* ORDERS */, onOrders);
+      }
+      wsManager.on("MESSAGE" /* MESSAGE */, onMessage);
+      wsManager.on("ORDERS" /* ORDERS */, onOrders);
+      try {
+        await this._sendCloseRequest(closeData);
+      } catch (error) {
+        done(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
   }
-}
-async function closePosition(ctx, data) {
-  try {
-    await retryRequest(
-      {
-        method: "POST",
-        url: endpoints.closePosition(ctx.broker),
-        data,
-        headers: authHeaders(ctx.csrf, Cookies.serialize(ctx.cookies))
-      },
-      ctx.retries
-    );
-  } catch (error) {
-    if (error instanceof DxtradeError) throw error;
-    const message = error instanceof Error ? error.response?.data?.message ?? error.message : "Unknown error";
-    ctx.throwError("POSITION_CLOSE_ERROR" /* POSITION_CLOSE_ERROR */, `Position close error: ${message}`);
+  async _waitForClosePoll(positionCode, lastSnapshot, timeout, interval) {
+    const deadline = Date.now() + timeout;
+    let result = lastSnapshot;
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, interval));
+      const positions = await this.get();
+      const match = positions.find((p) => p.positionKey.positionCode === positionCode);
+      if (match) {
+        result = match;
+      } else {
+        return result;
+      }
+    }
+    this._ctx.throwError("POSITION_CLOSE_TIMEOUT" /* POSITION_CLOSE_TIMEOUT */, `Position close confirmation timed out after ${timeout}ms`);
   }
-}
+  async _sendCloseRequest(data) {
+    try {
+      await retryRequest(
+        {
+          method: "POST",
+          url: endpoints.closePosition(this._ctx.broker),
+          data,
+          headers: authHeaders(this._ctx.csrf, Cookies.serialize(this._ctx.cookies))
+        },
+        this._ctx.retries
+      );
+    } catch (error) {
+      if (error instanceof DxtradeError) throw error;
+      const message = error instanceof Error ? error.response?.data?.message ?? error.message : "Unknown error";
+      this._ctx.throwError("POSITION_CLOSE_ERROR" /* POSITION_CLOSE_ERROR */, `Position close error: ${message}`);
+    }
+  }
+};
 
 // src/domains/session/session.ts
 var import_ws8 = __toESM(require("ws"));
@@ -1034,247 +1427,161 @@ function waitForHandshake(wsUrl, cookieStr, timeout = 3e4, debug = false) {
     ws.on("error", (error) => {
       clearTimeout(timer);
       ws.close();
+      checkWsRateLimit(error);
       reject(new Error(`[dxtrade-api] WebSocket handshake error: ${error.message}`));
     });
   });
 }
-async function login(ctx) {
-  try {
-    const response = await retryRequest(
-      {
-        method: "POST",
-        url: endpoints.login(ctx.broker),
-        data: {
-          username: ctx.config.username,
-          password: ctx.config.password,
-          // 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::
+var SessionDomain = class {
+  constructor(_ctx) {
+    this._ctx = _ctx;
+  }
+  /** Authenticate with the broker using username and password. */
+  async login() {
+    try {
+      const response = await retryRequest(
+        {
+          method: "POST",
+          url: endpoints.login(this._ctx.broker),
+          data: {
+            username: this._ctx.config.username,
+            password: this._ctx.config.password,
+            // 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: this._ctx.config.broker,
+            vendor: this._ctx.config.broker
+            // END TODO::
+          },
+          headers: {
+            ...baseHeaders(),
+            Origin: this._ctx.broker,
+            Referer: this._ctx.broker + "/",
+            Cookie: Cookies.serialize(this._ctx.cookies)
+          }
         },
-        headers: { "Content-Type": "application/json" }
-      },
-      ctx.retries
-    );
-    if (response.status === 200) {
+        this._ctx.retries
+      );
+      if (response.status === 200) {
+        const setCookies = response.headers["set-cookie"] ?? [];
+        const incoming = Cookies.parse(setCookies);
+        this._ctx.cookies = Cookies.merge(this._ctx.cookies, incoming);
+        this._ctx.callbacks.onLogin?.();
+      } else {
+        this._ctx.throwError("LOGIN_FAILED" /* LOGIN_FAILED */, `Login failed: ${response.status}`);
+      }
+    } catch (error) {
+      if (error instanceof DxtradeError) throw error;
+      const message = error instanceof Error ? error.message : "Unknown error";
+      this._ctx.throwError("LOGIN_ERROR" /* LOGIN_ERROR */, `Login error: ${message}`);
+    }
+  }
+  /** Fetch the CSRF token required for authenticated requests. */
+  async fetchCsrf() {
+    try {
+      const cookieStr = Cookies.serialize(this._ctx.cookies);
+      const response = await retryRequest(
+        {
+          method: "GET",
+          url: this._ctx.broker,
+          headers: { ...cookieOnlyHeaders(cookieStr), Referer: this._ctx.broker }
+        },
+        this._ctx.retries
+      );
       const setCookies = response.headers["set-cookie"] ?? [];
       const incoming = Cookies.parse(setCookies);
-      ctx.cookies = Cookies.merge(ctx.cookies, incoming);
-      ctx.callbacks.onLogin?.();
-    } else {
-      ctx.throwError("LOGIN_FAILED" /* LOGIN_FAILED */, `Login failed: ${response.status}`);
+      this._ctx.cookies = Cookies.merge(this._ctx.cookies, incoming);
+      const csrfMatch = response.data?.match(/name="csrf" content="([^"]+)"/);
+      if (csrfMatch) {
+        this._ctx.csrf = csrfMatch[1];
+      } else {
+        this._ctx.throwError("CSRF_NOT_FOUND" /* CSRF_NOT_FOUND */, "CSRF token not found");
+      }
+    } catch (error) {
+      if (error instanceof DxtradeError) throw error;
+      const message = error instanceof Error ? error.message : "Unknown error";
+      this._ctx.throwError("CSRF_ERROR" /* CSRF_ERROR */, `CSRF fetch error: ${message}`);
     }
-  } catch (error) {
-    if (error instanceof DxtradeError) throw error;
-    const message = error instanceof Error ? error.message : "Unknown error";
-    ctx.throwError("LOGIN_ERROR" /* LOGIN_ERROR */, `Login error: ${message}`);
   }
-}
-async function fetchCsrf(ctx) {
-  try {
-    const cookieStr = Cookies.serialize(ctx.cookies);
-    const response = await retryRequest(
-      {
-        method: "GET",
-        url: ctx.broker,
-        headers: { ...cookieOnlyHeaders(cookieStr), Referer: ctx.broker }
-      },
-      ctx.retries
-    );
-    const csrfMatch = response.data?.match(/name="csrf" content="([^"]+)"/);
-    if (csrfMatch) {
-      ctx.csrf = csrfMatch[1];
-    } else {
-      ctx.throwError("CSRF_NOT_FOUND" /* CSRF_NOT_FOUND */, "CSRF token not found");
+  /** Switch to a specific trading account by ID. */
+  async switchAccount(accountId) {
+    this._ctx.ensureSession();
+    try {
+      await retryRequest(
+        {
+          method: "POST",
+          url: endpoints.switchAccount(this._ctx.broker, accountId),
+          headers: authHeaders(this._ctx.csrf, Cookies.serialize(this._ctx.cookies))
+        },
+        this._ctx.retries
+      );
+      this._ctx.callbacks.onAccountSwitch?.(accountId);
+    } catch (error) {
+      if (error instanceof DxtradeError) throw error;
+      const message = error instanceof Error ? error.message : "Unknown error";
+      this._ctx.throwError("ACCOUNT_SWITCH_ERROR" /* ACCOUNT_SWITCH_ERROR */, `Error switching account: ${message}`);
     }
-  } catch (error) {
-    if (error instanceof DxtradeError) throw error;
-    const message = error instanceof Error ? error.message : "Unknown error";
-    ctx.throwError("CSRF_ERROR" /* CSRF_ERROR */, `CSRF fetch error: ${message}`);
-  }
-}
-async function switchAccount(ctx, accountId) {
-  ctx.ensureSession();
-  try {
-    await retryRequest(
-      {
-        method: "POST",
-        url: endpoints.switchAccount(ctx.broker, accountId),
-        headers: authHeaders(ctx.csrf, Cookies.serialize(ctx.cookies))
-      },
-      ctx.retries
-    );
-    ctx.callbacks.onAccountSwitch?.(accountId);
-  } catch (error) {
-    if (error instanceof DxtradeError) throw error;
-    const message = error instanceof Error ? error.message : "Unknown error";
-    ctx.throwError("ACCOUNT_SWITCH_ERROR" /* ACCOUNT_SWITCH_ERROR */, `Error switching account: ${message}`);
-  }
-}
-async function auth(ctx) {
-  await login(ctx);
-  await fetchCsrf(ctx);
-  if (ctx.debug) clearDebugLog();
-  const cookieStr = Cookies.serialize(ctx.cookies);
-  const handshake = await waitForHandshake(endpoints.websocket(ctx.broker), cookieStr, 3e4, ctx.debug);
-  ctx.atmosphereId = handshake.atmosphereId;
-  ctx.accountId = handshake.accountId;
-  if (ctx.config.accountId) {
-    await switchAccount(ctx, ctx.config.accountId);
-    const reconnect = await waitForHandshake(
-      endpoints.websocket(ctx.broker, ctx.atmosphereId),
-      Cookies.serialize(ctx.cookies),
-      3e4,
-      ctx.debug
-    );
-    ctx.atmosphereId = reconnect.atmosphereId;
-    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 PositionsDomain = class {
-  constructor(_ctx) {
-    this._ctx = _ctx;
-  }
-  /** Get all open positions via WebSocket. */
-  get() {
-    return getPositions(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);
-  }
-  /** Close all open positions with market orders. */
-  closeAll() {
-    return closeAllPositions(this._ctx);
-  }
-  /** Get position-level P&L metrics via WebSocket. */
-  metrics() {
-    return getPositionMetrics(this._ctx);
-  }
-  /** Stream real-time position updates. Requires connect(). Returns unsubscribe function. */
-  stream(callback) {
-    return streamPositions(this._ctx, callback);
-  }
-};
-var OrdersDomain = class {
-  constructor(_ctx) {
-    this._ctx = _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.
-   */
-  submit(params) {
-    return submitOrder(this._ctx, params);
-  }
-  /** Cancel a single pending order by its order chain ID. */
-  cancel(orderChainId) {
-    return cancelOrder(this._ctx, orderChainId);
-  }
-  /** Cancel all pending orders. */
-  cancelAll() {
-    return cancelAllOrders(this._ctx);
-  }
-};
-var AccountDomain = class {
-  constructor(_ctx) {
-    this._ctx = _ctx;
-  }
-  /** Get account metrics including equity, balance, margin, and open P&L. */
-  metrics() {
-    return getAccountMetrics(this._ctx);
-  }
-  /**
-   * Fetch trade journal entries for a date range.
-   * @param params.from - Start timestamp (Unix ms)
-   * @param params.to - End timestamp (Unix ms)
-   */
-  tradeJournal(params) {
-    return getTradeJournal(this._ctx, params);
-  }
-  /**
-   * Fetch trade history for a date range.
-   * @param params.from - Start timestamp (Unix ms)
-   * @param params.to - End timestamp (Unix ms)
-   */
-  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" }`). */
-  get(params = {}) {
-    return getInstruments(this._ctx, params);
-  }
-};
-var OhlcDomain = class {
-  constructor(_ctx) {
-    this._ctx = _ctx;
+  /** Hit the broker page to collect Cloudflare cookies before making API calls. */
+  async _preflight() {
+    try {
+      const response = await retryRequest(
+        {
+          method: "GET",
+          url: this._ctx.broker,
+          headers: { ...baseHeaders(), Referer: this._ctx.broker }
+        },
+        this._ctx.retries
+      );
+      const setCookies = response.headers["set-cookie"] ?? [];
+      const incoming = Cookies.parse(setCookies);
+      this._ctx.cookies = Cookies.merge(this._ctx.cookies, incoming);
+    } catch {
+    }
   }
-  /**
-   * Fetch OHLC price bars for a symbol.
-   * @param params.symbol - Instrument symbol (e.g. "EURUSD")
-   * @param params.resolution - Bar period in seconds (default: 60 = 1 min)
-   * @param params.range - Lookback window in seconds (default: 432000 = 5 days)
-   * @param params.maxBars - Maximum bars to return (default: 3500)
-   * @param params.priceField - "bid" or "ask" (default: "bid")
-   */
-  get(params) {
-    return getOHLC(this._ctx, params);
+  /** Authenticate and establish a session: login, fetch CSRF, WebSocket handshake, and optional account switch. */
+  async auth() {
+    await this._preflight();
+    await this.login();
+    await this.fetchCsrf();
+    if (this._ctx.debug) clearDebugLog();
+    const cookieStr = Cookies.serialize(this._ctx.cookies);
+    const handshake = await waitForHandshake(endpoints.websocket(this._ctx.broker), cookieStr, 3e4, this._ctx.debug);
+    this._ctx.atmosphereId = handshake.atmosphereId;
+    this._ctx.accountId = handshake.accountId;
+    if (this._ctx.config.accountId) {
+      await this.switchAccount(this._ctx.config.accountId);
+      const reconnect = await waitForHandshake(
+        endpoints.websocket(this._ctx.broker, this._ctx.atmosphereId),
+        Cookies.serialize(this._ctx.cookies),
+        3e4,
+        this._ctx.debug
+      );
+      this._ctx.atmosphereId = reconnect.atmosphereId;
+      this._ctx.accountId = reconnect.accountId;
+    }
   }
-};
-var AssessmentsDomain = class {
-  constructor(_ctx) {
-    this._ctx = _ctx;
+  /** Connect to the broker with a persistent WebSocket: auth + persistent WS for data reuse and streaming. */
+  async connect() {
+    await this.auth();
+    const wsManager = new WsManager();
+    const wsUrl = endpoints.websocket(this._ctx.broker, this._ctx.atmosphereId);
+    const cookieStr = Cookies.serialize(this._ctx.cookies);
+    await wsManager.connect(wsUrl, cookieStr, this._ctx.debug);
+    this._ctx.wsManager = wsManager;
   }
-  /** Fetch PnL assessments for an instrument within a date range. */
-  get(params) {
-    return getAssessments(this._ctx, params);
+  /** Close the persistent WebSocket connection. */
+  disconnect() {
+    if (this._ctx.wsManager) {
+      this._ctx.wsManager.close();
+      this._ctx.wsManager = null;
+    }
   }
 };
+
+// src/client.ts
 var DxtradeClient = class {
   _ctx;
+  _session;
   /** Position operations: get, close, metrics, streaming. */
   positions;
   /** Order operations: get, submit, cancel. */
@@ -1285,7 +1592,7 @@ var DxtradeClient = class {
   symbols;
   /** Instrument operations: get (with optional filtering). */
   instruments;
-  /** OHLC price bar operations: get. */
+  /** OHLC price bar operations: get, stream. */
   ohlc;
   /** PnL assessment operations: get. */
   assessments;
@@ -1313,6 +1620,7 @@ var DxtradeClient = class {
         throw error;
       }
     };
+    this._session = new SessionDomain(this._ctx);
     this.positions = new PositionsDomain(this._ctx);
     this.orders = new OrdersDomain(this._ctx);
     this.account = new AccountDomain(this._ctx);
@@ -1323,27 +1631,27 @@ var DxtradeClient = class {
   }
   /** Authenticate with the broker using username and password. */
   async login() {
-    return login(this._ctx);
+    return this._session.login();
   }
   /** Fetch the CSRF token required for authenticated requests. */
   async fetchCsrf() {
-    return fetchCsrf(this._ctx);
+    return this._session.fetchCsrf();
   }
   /** Switch to a specific trading account by ID. */
   async switchAccount(accountId) {
-    return switchAccount(this._ctx, accountId);
+    return this._session.switchAccount(accountId);
   }
   /** Authenticate and establish a session: login, fetch CSRF, WebSocket handshake, and optional account switch. */
   async auth() {
-    return auth(this._ctx);
+    return this._session.auth();
   }
   /** Connect to the broker with a persistent WebSocket: auth + persistent WS for data reuse and streaming. */
   async connect() {
-    return connect(this._ctx);
+    return this._session.connect();
   }
   /** Close the persistent WebSocket connection. */
   disconnect() {
-    return disconnect(this._ctx);
+    return this._session.disconnect();
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
@@ -1353,6 +1661,9 @@ var DxtradeClient = class {
   DxtradeClient,
   DxtradeError,
   ERROR,
+  MESSAGE_CATEGORY,
+  MESSAGE_TYPE,
+  ORDER_STATUS,
   ORDER_TYPE,
   SIDE,
   TIF,