@kkkermit/trading212.js 0.1.0 → 0.1.2

package/dist/chunk-K766TWIM.cjs

@@ -0,0 +1,2700 @@
+'use strict';
+
+// src/cache.ts
+function isList(value) {
+  return Array.isArray(value);
+}
+var MemoryCache = class {
+  #entries = /* @__PURE__ */ new Map();
+  get(key) {
+    const entry = this.#entries.get(key);
+    if (!entry) return void 0;
+    if (Date.now() >= entry.expiresAt) {
+      this.#entries.delete(key);
+      return void 0;
+    }
+    return entry.value;
+  }
+  set(key, value, ttlMs) {
+    this.#entries.set(key, { value, expiresAt: Date.now() + ttlMs });
+  }
+  delete(key) {
+    this.#entries.delete(key);
+  }
+  clear() {
+    this.#entries.clear();
+  }
+};
+var CachedLoader = class {
+  #store;
+  #onError;
+  #inFlight = /* @__PURE__ */ new Map();
+  constructor(store, onError = () => void 0) {
+    this.#store = store;
+    this.#onError = onError;
+  }
+  /**
+   * The shared load is started without any caller's signal, so one caller giving up never fails the others; each
+   * caller stops waiting when its own `signal` aborts.
+   */
+  async load(key, options, loader) {
+    const { ttlMs, refresh = false, signal, accept } = options;
+    if (signal?.aborted) throw signal.reason;
+    if (!refresh) {
+      let cached;
+      try {
+        cached = await this.#store.get(key);
+      } catch (error) {
+        this.#onError(error, key);
+      }
+      if (cached !== void 0 && cached !== null) {
+        if (!accept || accept(cached)) return cached;
+        this.#onError(new TypeError("The cache store returned a value of the wrong shape."), key);
+      }
+    }
+    const pending = this.#inFlight.get(key);
+    if (pending) return untilAborted(pending, signal);
+    const promise = (async () => {
+      try {
+        const value = await loader();
+        try {
+          await this.#store.set(key, value, ttlMs);
+        } catch (error) {
+          this.#onError(error, key);
+        }
+        return value;
+      } finally {
+        this.#inFlight.delete(key);
+      }
+    })();
+    this.#inFlight.set(key, promise);
+    return untilAborted(promise, signal);
+  }
+};
+function untilAborted(promise, signal) {
+  if (!signal) return promise;
+  if (signal.aborted) return Promise.reject(signal.reason);
+  let onAbort = () => void 0;
+  const aborted = new Promise((_resolve, reject) => {
+    onAbort = () => {
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+  return Promise.race([promise, aborted]).finally(() => {
+    signal.removeEventListener("abort", onAbort);
+  });
+}
+
+// src/environment.ts
+var BASE_URLS = {
+  demo: "https://demo.trading212.com",
+  live: "https://live.trading212.com"
+};
+function isEnvironment(value) {
+  return value === "demo" || value === "live";
+}
+
+// src/errors/errors.ts
+var BRAND = /* @__PURE__ */ Symbol.for("trading212.js/error");
+function kindsOf(constructor) {
+  const kinds = [];
+  let current = constructor;
+  while (current && Object.hasOwn(current, "kind")) {
+    kinds.push(String(current.kind));
+    current = Object.getPrototypeOf(current);
+  }
+  return kinds;
+}
+function brandOf(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const kinds = value[BRAND];
+  return Array.isArray(kinds) ? kinds : void 0;
+}
+var Trading212Error = class extends Error {
+  static kind = "Trading212Error";
+  code;
+  /** What to do about it, in plain English. */
+  hint;
+  status;
+  request;
+  rateLimit;
+  body;
+  apiCode;
+  /** Trading 212's reference for the failed request, worth quoting if you contact its support. */
+  traceId;
+  /** Set when a paginated read failed part-way: pass it as `cursor` to carry on from where it stopped. */
+  resumeCursor;
+  constructor(message, code, details = {}) {
+    super(message, details.cause === void 0 ? void 0 : { cause: details.cause });
+    const kinds = kindsOf(new.target);
+    this.name = kinds[0] ?? "Trading212Error";
+    this.code = code;
+    this.hint = details.hint;
+    this.status = details.status;
+    this.request = details.request;
+    this.rateLimit = details.rateLimit;
+    this.body = details.body;
+    this.apiCode = details.apiCode;
+    this.traceId = details.traceId;
+    this.resumeCursor = void 0;
+    Object.defineProperty(this, BRAND, { value: kinds, enumerable: false });
+  }
+  static [Symbol.hasInstance](value) {
+    const kinds = brandOf(value);
+    if (kinds) return kinds.includes(this.kind);
+    return Function.prototype[Symbol.hasInstance].call(this, value);
+  }
+  /** A plain, redacted object for structured logs: every field that has a value, plus the cause's message. */
+  toLog() {
+    const fields = { name: this.name, message: this.message };
+    for (const [key, value] of Object.entries(this)) {
+      if (value !== void 0) fields[key] = value;
+    }
+    if (this.cause !== void 0) {
+      const cause = this.cause;
+      fields.cause = cause instanceof Error ? `${cause.name}: ${cause.message}` : typeof cause === "string" ? cause : "[non-error cause]";
+    }
+    return fields;
+  }
+  toJSON() {
+    return this.toLog();
+  }
+};
+function isTrading212Error(value) {
+  return brandOf(value) !== void 0;
+}
+var ConfigurationError = class extends Trading212Error {
+  static kind = "ConfigurationError";
+  /** The option at fault, such as `apiKey`. */
+  field;
+  constructor(message, details = {}) {
+    super(message, "configuration", details);
+    this.field = details.field;
+  }
+};
+var AuthenticationError = class extends Trading212Error {
+  static kind = "AuthenticationError";
+  environment;
+  constructor(message, details) {
+    super(message, "authentication", details);
+    this.environment = details.environment;
+  }
+};
+var MissingScopeError = class extends Trading212Error {
+  static kind = "MissingScopeError";
+  /** The permission the key lacks, such as `orders:execute`. */
+  scope;
+  constructor(message, details) {
+    super(message, "missing_scope", details);
+    this.scope = details.scope;
+  }
+};
+var NotAvailableInDemoError = class extends Trading212Error {
+  static kind = "NotAvailableInDemoError";
+  constructor(message, details = {}) {
+    super(message, "not_available_in_demo", details);
+  }
+};
+var PermissionError = class extends Trading212Error {
+  static kind = "PermissionError";
+  constructor(message, details = {}) {
+    super(message, "permission", details);
+  }
+};
+var ValidationError = class extends Trading212Error {
+  static kind = "ValidationError";
+  issues;
+  constructor(message, details = {}, code) {
+    super(message, code ?? "validation", details);
+    this.issues = details.issues ?? [];
+  }
+};
+var OrderRejectedError = class extends ValidationError {
+  static kind = "OrderRejectedError";
+  reason;
+  /** The smallest quantity Trading 212 accepts for this order, read from a `min-quantity-exceeded` refusal. */
+  minQuantity;
+  /** The largest quantity it accepts in one order, read from a `max-quantity-exceeded` refusal. */
+  maxQuantity;
+  /** The most decimal places a quantity may have, read from a `quantity-precision-mismatch` refusal. */
+  maxDecimals;
+  /** How many shares Trading 212 says the account owns, read from a `selling-equity-not-owned` refusal. */
+  ownedQuantity;
+  constructor(message, details) {
+    super(message, details, "order_rejected");
+    this.reason = details.reason;
+    this.minQuantity = details.minQuantity;
+    this.maxQuantity = details.maxQuantity;
+    this.maxDecimals = details.maxDecimals;
+    this.ownedQuantity = details.ownedQuantity;
+  }
+};
+var NotFoundError = class extends Trading212Error {
+  static kind = "NotFoundError";
+  constructor(message, details = {}, code) {
+    super(message, code ?? "not_found", details);
+  }
+};
+var InstrumentNotFoundError = class extends NotFoundError {
+  static kind = "InstrumentNotFoundError";
+  query;
+  suggestions;
+  constructor(message, details) {
+    super(message, details, "instrument_not_found");
+    this.query = details.query;
+    this.suggestions = details.suggestions;
+  }
+};
+var RateLimitError = class extends Trading212Error {
+  static kind = "RateLimitError";
+  /** How long to wait before the next try. */
+  retryAfterMs;
+  /** When the budget resets. */
+  resetAt;
+  constructor(message, details) {
+    super(message, "rate_limited", details);
+    this.retryAfterMs = details.retryAfterMs;
+    this.resetAt = details.resetAt === void 0 ? void 0 : new Date(details.resetAt);
+  }
+};
+var TimeoutError = class extends Trading212Error {
+  static kind = "TimeoutError";
+  constructor(message, details = {}) {
+    super(message, "timeout", details);
+  }
+};
+var OrderOutcomeUnknownError = class extends Trading212Error {
+  static kind = "OrderOutcomeUnknownError";
+  /** What was sent, so it can be looked for. */
+  sent;
+  constructor(message, details) {
+    super(message, "outcome_unknown", details);
+    this.sent = details.sent;
+  }
+};
+var TradingDisabledError = class extends Trading212Error {
+  static kind = "TradingDisabledError";
+  constructor(message, details = {}) {
+    super(message, "trading_disabled", details);
+  }
+};
+var NetworkError = class extends Trading212Error {
+  static kind = "NetworkError";
+  sent;
+  constructor(message, details) {
+    super(message, "network", details);
+    this.sent = details.sent;
+  }
+};
+var ServerError = class extends Trading212Error {
+  static kind = "ServerError";
+  constructor(message, details = {}) {
+    super(message, "server", details);
+  }
+};
+var HttpError = class extends Trading212Error {
+  static kind = "HttpError";
+  constructor(message, details = {}) {
+    super(message, "http_error", details);
+  }
+};
+var UnexpectedResponseError = class extends Trading212Error {
+  static kind = "UnexpectedResponseError";
+  constructor(message, details = {}) {
+    super(message, "unexpected_response", details);
+  }
+};
+
+// src/http/endpoint.ts
+function freezeEndpoints(definitions) {
+  for (const definition of Object.values(definitions)) {
+    Object.freeze(definition.rateLimit);
+    Object.freeze(definition);
+  }
+  return Object.freeze(definitions);
+}
+
+// src/http/endpoints.generated.ts
+var SPEC_VERSION = "v0";
+var DEFINITIONS = {
+  cancelOrder: {
+    id: "cancelOrder",
+    method: "DELETE",
+    path: "/api/v0/equity/orders/{id}",
+    scope: "orders:execute",
+    rateLimit: { requests: 50, periodMs: 6e4 },
+    kind: "trade",
+    deprecated: false,
+    summary: "Cancel a pending order"
+  },
+  createPie: {
+    id: "createPie",
+    method: "POST",
+    path: "/api/v0/equity/pies",
+    scope: "pies:write",
+    rateLimit: { requests: 1, periodMs: 5e3 },
+    kind: "trade",
+    deprecated: true,
+    summary: "Create pie"
+  },
+  deletePie: {
+    id: "deletePie",
+    method: "DELETE",
+    path: "/api/v0/equity/pies/{id}",
+    scope: "pies:write",
+    rateLimit: { requests: 1, periodMs: 5e3 },
+    kind: "trade",
+    deprecated: true,
+    summary: "Delete pie"
+  },
+  duplicatePie: {
+    id: "duplicatePie",
+    method: "POST",
+    path: "/api/v0/equity/pies/{id}/duplicate",
+    scope: "pies:write",
+    rateLimit: { requests: 1, periodMs: 5e3 },
+    kind: "trade",
+    deprecated: true,
+    summary: "Duplicate pie"
+  },
+  getAccountSummary: {
+    id: "getAccountSummary",
+    method: "GET",
+    path: "/api/v0/equity/account/summary",
+    scope: "account",
+    rateLimit: { requests: 1, periodMs: 5e3 },
+    kind: "read",
+    deprecated: false,
+    summary: "Get account summary"
+  },
+  getOrder: {
+    id: "getOrder",
+    method: "GET",
+    path: "/api/v0/equity/orders/{id}",
+    scope: "orders:read",
+    rateLimit: { requests: 1, periodMs: 1e3 },
+    kind: "read",
+    deprecated: false,
+    summary: "Get a pending order by ID"
+  },
+  getPie: {
+    id: "getPie",
+    method: "GET",
+    path: "/api/v0/equity/pies/{id}",
+    scope: "pies:read",
+    rateLimit: { requests: 1, periodMs: 5e3 },
+    kind: "read",
+    deprecated: true,
+    summary: "Fetch a pie"
+  },
+  listDividends: {
+    id: "listDividends",
+    method: "GET",
+    path: "/api/v0/equity/history/dividends",
+    scope: "history:dividends",
+    rateLimit: { requests: 20, periodMs: 6e4 },
+    kind: "read",
+    deprecated: false,
+    summary: "Get paid out dividends"
+  },
+  listExchanges: {
+    id: "listExchanges",
+    method: "GET",
+    path: "/api/v0/equity/metadata/exchanges",
+    scope: "metadata",
+    rateLimit: { requests: 1, periodMs: 3e4 },
+    kind: "read",
+    deprecated: false,
+    summary: "Get exchanges metadata"
+  },
+  listHistoricalOrders: {
+    id: "listHistoricalOrders",
+    method: "GET",
+    path: "/api/v0/equity/history/orders",
+    scope: "history:orders",
+    rateLimit: { requests: 20, periodMs: 6e4 },
+    kind: "read",
+    deprecated: false,
+    summary: "Get historical orders data"
+  },
+  listInstruments: {
+    id: "listInstruments",
+    method: "GET",
+    path: "/api/v0/equity/metadata/instruments",
+    scope: "metadata",
+    rateLimit: { requests: 1, periodMs: 5e4 },
+    kind: "read",
+    deprecated: false,
+    summary: "Get all available instruments"
+  },
+  listOrders: {
+    id: "listOrders",
+    method: "GET",
+    path: "/api/v0/equity/orders",
+    scope: "orders:read",
+    rateLimit: { requests: 1, periodMs: 5e3 },
+    kind: "read",
+    deprecated: false,
+    summary: "Get all pending orders"
+  },
+  listPies: {
+    id: "listPies",
+    method: "GET",
+    path: "/api/v0/equity/pies",
+    scope: "pies:read",
+    rateLimit: { requests: 1, periodMs: 3e4 },
+    kind: "read",
+    deprecated: true,
+    summary: "Fetch all pies"
+  },
+  listPositions: {
+    id: "listPositions",
+    method: "GET",
+    path: "/api/v0/equity/positions",
+    scope: "portfolio",
+    rateLimit: { requests: 1, periodMs: 1e3 },
+    kind: "read",
+    deprecated: false,
+    summary: "Fetch all open positions"
+  },
+  listReports: {
+    id: "listReports",
+    method: "GET",
+    path: "/api/v0/equity/history/exports",
+    scope: null,
+    rateLimit: { requests: 1, periodMs: 6e4 },
+    kind: "read",
+    deprecated: false,
+    summary: "List generated reports"
+  },
+  listTransactions: {
+    id: "listTransactions",
+    method: "GET",
+    path: "/api/v0/equity/history/transactions",
+    scope: "history:transactions",
+    rateLimit: { requests: 20, periodMs: 6e4 },
+    kind: "read",
+    deprecated: false,
+    summary: "Get transactions"
+  },
+  placeLimitOrder: {
+    id: "placeLimitOrder",
+    method: "POST",
+    path: "/api/v0/equity/orders/limit",
+    scope: "orders:execute",
+    rateLimit: { requests: 1, periodMs: 2e3 },
+    kind: "trade",
+    deprecated: false,
+    summary: "Place a Limit order"
+  },
+  placeMarketOrder: {
+    id: "placeMarketOrder",
+    method: "POST",
+    path: "/api/v0/equity/orders/market",
+    scope: "orders:execute",
+    rateLimit: { requests: 50, periodMs: 6e4 },
+    kind: "trade",
+    deprecated: false,
+    summary: "Place a Market order"
+  },
+  placeStopLimitOrder: {
+    id: "placeStopLimitOrder",
+    method: "POST",
+    path: "/api/v0/equity/orders/stop_limit",
+    scope: "orders:execute",
+    rateLimit: { requests: 1, periodMs: 2e3 },
+    kind: "trade",
+    deprecated: false,
+    summary: "Place a StopLimit order"
+  },
+  placeStopOrder: {
+    id: "placeStopOrder",
+    method: "POST",
+    path: "/api/v0/equity/orders/stop",
+    scope: "orders:execute",
+    rateLimit: { requests: 1, periodMs: 2e3 },
+    kind: "trade",
+    deprecated: false,
+    summary: "Place a Stop order"
+  },
+  requestReport: {
+    id: "requestReport",
+    method: "POST",
+    path: "/api/v0/equity/history/exports",
+    scope: null,
+    rateLimit: { requests: 1, periodMs: 3e4 },
+    kind: "write",
+    deprecated: false,
+    summary: "Request a CSV report"
+  },
+  updatePie: {
+    id: "updatePie",
+    method: "POST",
+    path: "/api/v0/equity/pies/{id}",
+    scope: "pies:write",
+    rateLimit: { requests: 1, periodMs: 5e3 },
+    kind: "trade",
+    deprecated: true,
+    summary: "Update pie"
+  }
+};
+var ENDPOINTS = freezeEndpoints(DEFINITIONS);
+
+// src/orders/quantity.ts
+var QUANTITY_DECIMALS = 4;
+function toPlainDecimal(value) {
+  const text = Math.abs(value).toString();
+  const sign = value < 0 ? "-" : "";
+  const match = /^(\d+)(?:\.(\d+))?e([+-]\d+)$/.exec(text);
+  if (!match) return sign + text;
+  const [, whole = "", fraction = "", exponentText = "0"] = match;
+  const exponent = Number(exponentText);
+  const digits = whole + fraction;
+  const point = whole.length + exponent;
+  if (point <= 0) return `${sign}0.${"0".repeat(-point)}${digits}`;
+  if (point >= digits.length) return sign + digits + "0".repeat(point - digits.length);
+  return `${sign}${digits.slice(0, point)}.${digits.slice(point)}`;
+}
+function decimalPlaces(value) {
+  if (!Number.isFinite(value)) return Number.NaN;
+  const fraction = toPlainDecimal(value).split(".")[1];
+  return fraction ? fraction.replace(/0+$/, "").length : 0;
+}
+function truncateQuantity(value, decimals = QUANTITY_DECIMALS) {
+  if (!Number.isFinite(value)) throw new RangeError("Cannot truncate a quantity that is not a finite number.");
+  if (!Number.isInteger(decimals) || decimals < 0 || decimals > 20) throw new RangeError("decimals must be 0 to 20.");
+  const [whole = "0", fraction = ""] = toPlainDecimal(value).split(".");
+  const kept = fraction.slice(0, decimals);
+  const result = Number(kept ? `${whole}.${kept}` : whole);
+  return Object.is(result, -0) ? 0 : result;
+}
+function isValidQuantity(value) {
+  return Number.isFinite(value) && value !== 0 && decimalPlaces(value) <= QUANTITY_DECIMALS;
+}
+
+// src/errors/hints.ts
+var HINTS = {
+  authentication: (environment) => `Trading 212 refused the key and secret. Check both were copied exactly, with no spaces. A key works in one environment only: this client is set to ${environment}, so the key must have been made while the app was in ${environment === "demo" ? "practice (demo)" : "real-money (live)"} mode.`,
+  missingScope: (scope) => `This API key does not have the "${scope}" permission. In the Trading 212 app, go to Settings > API (Beta) and create a key with "${scope}" ticked.`,
+  notAvailableInDemo: "Trading 212 does not offer this in the demo environment. It works on live only (CSV exports are one example).",
+  permission: "The key is not allowed to do this. If the key is restricted to IP addresses, check that this machine's public address is on its list.",
+  validation: "Trading 212 rejected the request as invalid. `error.body` holds its explanation, and `error.issues` any field problems found before sending.",
+  invalidOrder: "Trading 212 could not accept the fields of this order. The client checks them before sending, so if one of its methods sent it, Trading 212 may have changed its rules: please open an issue with `error.traceId`.",
+  timeout: (kind) => kind === "read" ? "Trading 212 did not answer in time. Reads are retried automatically; this one ran out of attempts." : "Trading 212 did not answer in time. Requests that change something are never retried automatically.",
+  outcomeUnknown: "The request may or may not have gone through. Do not resend it blindly: check `orders.list()` and `history.orders.list()` first.",
+  rateLimited: (endpoint, resetAt) => `Wait${resetAt === void 0 ? " a moment" : ` until ${new Date(resetAt).toISOString()}`} before calling ${endpoint ?? "this endpoint"} again. Limits apply per account, so every program using the same account shares them.`,
+  server: (kind) => kind === "read" ? "Trading 212 had a problem of its own. Reads are retried automatically; this one ran out of attempts." : "Trading 212 had a problem of its own. Requests that change something are never retried automatically.",
+  tradingDisabled: 'Trading is off for this client, which is the default on live and behind a custom baseUrl, so nothing was sent. Pass `trading: "enabled"` to place orders, or `{ dryRun: true }` to preview one.',
+  network: (sent, kind) => {
+    if (!sent) return "Could not reach Trading 212 at all: check the network, DNS and any proxy. Nothing was sent.";
+    return kind === "read" ? "The connection broke while waiting for Trading 212. Reads are retried automatically; this one ran out of attempts." : "The connection broke while waiting for Trading 212. Requests that change something are never retried automatically.";
+  }
+};
+var ORDER_REJECTION_HINTS = {
+  "min-quantity-exceeded": "The order is too small. Raise the quantity to at least `error.minQuantity`, the smallest Trading 212 accepts for it.",
+  "max-quantity-exceeded": "The order is too large for one order. Split it into orders of at most `error.maxQuantity` each.",
+  "insufficient-free-for-stocks-buy": "Not enough free cash for this buy. Check `cash.availableToTrade` in `account.summary()`; cash reserved for pending orders or held in pies does not count.",
+  "selling-equity-not-owned": "You are selling more than is available. Shares held in pies or reserved by pending orders do not count: check `quantityAvailableForTrading` on the position, or use `orders.sellAll(ticker)`.",
+  "market-closed": "The market for this instrument is closed. `exchanges.status(ticker)` shows its current session and when it next opens.",
+  "quantity-precision-mismatch": "Quantities allow at most 4 decimal places. Use `truncateQuantity(quantity)` to round down safely."
+};
+var NOT_FOUND_HINTS = {
+  getOrder: "The order is not pending any more: it may have filled, been cancelled or never existed. Filled and cancelled orders are in `history.orders.list()`.",
+  cancelOrder: "The order is not pending any more, so there is nothing to cancel: it may already have filled or been cancelled.",
+  getPie: "No pie has that ID. `pies.list()` shows the ones that exist.",
+  deletePie: "No pie has that ID. `pies.list()` shows the ones that exist.",
+  updatePie: "No pie has that ID. `pies.list()` shows the ones that exist.",
+  duplicatePie: "No pie has that ID. `pies.list()` shows the ones that exist."
+};
+function notFoundHint(endpoint) {
+  return (endpoint && NOT_FOUND_HINTS[endpoint]) ?? "Trading 212 has nothing at that address.";
+}
+
+// src/errors/fromResponse.ts
+var MAX_MESSAGE = 500;
+var JAVA_OPTIONAL = /\bOptional\[([^\]]*)\]/g;
+function lastSegment(type) {
+  if (type === "about:blank") return void 0;
+  return type.split(/[/#]/).filter(Boolean).pop();
+}
+function parseErrorBody(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return {};
+  let json;
+  try {
+    json = JSON.parse(trimmed);
+  } catch {
+    return { message: trimmed.slice(0, MAX_MESSAGE), body: trimmed };
+  }
+  if (typeof json !== "object" || json === null || Array.isArray(json)) {
+    return typeof json === "string" ? { message: json.slice(0, MAX_MESSAGE), body: json } : { body: json };
+  }
+  const record = json;
+  const stringField = (key) => {
+    const value = record[key];
+    return typeof value === "string" && value.trim() ? value.trim() : void 0;
+  };
+  const type = stringField("type");
+  const traceId = stringField("traceId");
+  const code = stringField("code");
+  const context = record.context;
+  const contextType = typeof context === "object" && context !== null ? context.type : void 0;
+  const apiCode = (code === "BusinessException" && typeof contextType === "string" && contextType.trim() ? contextType.trim() : code) ?? stringField("errorCode") ?? (type ? lastSegment(type) : void 0);
+  const message = stringField("detail") ?? stringField("clarification") ?? stringField("message") ?? stringField("errorMessage") ?? stringField("error") ?? stringField("title");
+  return {
+    ...apiCode !== void 0 && { apiCode },
+    ...message !== void 0 && { message: message.replace(JAVA_OPTIONAL, "$1").slice(0, MAX_MESSAGE) },
+    ...traceId !== void 0 && { traceId },
+    body: json
+  };
+}
+var SCOPE = /Scope\(\s*([\w:.-]+)\s*\)/i;
+var normalise = (value) => value.toLowerCase().replace(/[^a-z0-9]/g, "");
+var DEMO_ONLY = normalise("not-available-in-demo-account");
+var KNOWN_REJECTIONS = Object.keys(ORDER_REJECTION_HINTS).map(
+  (reason) => [reason, normalise(reason)]
+);
+function findRejection(haystack) {
+  return KNOWN_REJECTIONS.find(([, needle]) => haystack.includes(needle))?.[0];
+}
+var FACTS = {
+  "min-quantity-exceeded": ["minQuantity", /at least\s+(\d+(?:\.\d+)?)/i],
+  "max-quantity-exceeded": ["maxQuantity", /\bis\s+(\d+(?:\.\d+)?)\s*$/i],
+  "quantity-precision-mismatch": ["maxDecimals", /precision\s+(\d+)/i],
+  "selling-equity-not-owned": ["ownedQuantity", /owned:\s*(\d+(?:\.\d+)?)/i]
+};
+function factsOf(reason, message) {
+  const fact = FACTS[reason];
+  const match = fact && message ? fact[1].exec(message) : null;
+  return fact && match?.[1] ? { [fact[0]]: Number(match[1]) } : {};
+}
+function sentOrder(sent) {
+  if (typeof sent !== "object" || sent === null) return {};
+  const { ticker, quantity, limitPrice, stopPrice } = sent;
+  const price = typeof limitPrice === "number" ? limitPrice : typeof stopPrice === "number" ? stopPrice : void 0;
+  return {
+    ...typeof ticker === "string" && { ticker },
+    ...typeof quantity === "number" && Number.isFinite(quantity) && { quantity: Math.abs(quantity) },
+    ...price !== void 0 && { price }
+  };
+}
+function rejectionSentence(reason, facts, order) {
+  const quantity = order.quantity === void 0 ? "the quantity" : `a quantity of ${String(order.quantity)}`;
+  const instrument = order.ticker ?? "this instrument";
+  const shares = order.quantity === void 0 ? instrument : `${String(order.quantity)} ${instrument}`;
+  const named = (value, words) => value === void 0 ? `the ${words}` : `the ${words}, ${String(value)}`;
+  switch (reason) {
+    case "min-quantity-exceeded":
+      return `${quantity} is below ${named(facts.minQuantity, "smallest Trading 212 accepts for this order")}.`;
+    case "max-quantity-exceeded":
+      return `${quantity} is above ${named(facts.maxQuantity, "largest Trading 212 accepts in one order")}.`;
+    case "quantity-precision-mismatch":
+      return `${quantity} has more decimal places than the ${String(facts.maxDecimals ?? QUANTITY_DECIMALS)} Trading 212 allows.`;
+    case "selling-equity-not-owned":
+      return facts.ownedQuantity === void 0 ? `it sells ${shares}, more than the account owns.` : `it sells ${shares}, but the account owns ${String(facts.ownedQuantity)}.`;
+    case "insufficient-free-for-stocks-buy":
+      return `there is not enough free cash to buy ${shares}${order.price === void 0 ? "" : ` at ${String(order.price)} each`}.`;
+    case "market-closed":
+      return `the market for ${instrument} is closed.`;
+  }
+}
+var sentence = (text) => /[.!?]$/.test(text) ? text : `${text}.`;
+function errorFromResponse(context) {
+  const { status, request, kind, environment, rateLimit } = context;
+  const parsed = parseErrorBody(context.text);
+  const where = `${request.method} ${request.path}`;
+  const answered = `${status}${context.statusText ? ` ${context.statusText}` : ""}`;
+  const said = parsed.message ? `: ${sentence(parsed.message)}` : ".";
+  const searchable = normalise(`${parsed.apiCode ?? ""} ${parsed.message ?? ""} ${context.text}`);
+  const details = {
+    status,
+    request,
+    ...rateLimit && { rateLimit },
+    ...parsed.body !== void 0 && { body: parsed.body },
+    ...parsed.apiCode !== void 0 && { apiCode: parsed.apiCode },
+    ...parsed.traceId !== void 0 && { traceId: parsed.traceId }
+  };
+  if (kind === "trade" && (status === 408 || status >= 500)) {
+    return new OrderOutcomeUnknownError(
+      `${where} may or may not have gone through: Trading 212 answered ${answered}${parsed.message ? `: ${parsed.message}` : ""}.`,
+      { ...details, hint: HINTS.outcomeUnknown, sent: context.sent }
+    );
+  }
+  switch (status) {
+    case 400: {
+      const rejection = kind === "trade" ? findRejection(searchable) : void 0;
+      if (rejection) {
+        const facts = factsOf(rejection, parsed.message);
+        return new OrderRejectedError(
+          `${where} was refused: ${rejectionSentence(rejection, facts, sentOrder(context.sent))}`,
+          { ...details, ...facts, reason: rejection, hint: ORDER_REJECTION_HINTS[rejection] }
+        );
+      }
+      if (parsed.apiCode && kind === "trade" && parsed.apiCode !== "invalid-request") {
+        return new OrderRejectedError(`${where} was refused (${parsed.apiCode})${said}`, {
+          ...details,
+          reason: parsed.apiCode,
+          hint: HINTS.validation
+        });
+      }
+      const invalid = parsed.message === "Invalid payload" ? `: Trading 212 could not accept the fields sent ("Invalid payload").` : said;
+      return new ValidationError(`${where} was refused as invalid${invalid}`, {
+        ...details,
+        hint: kind === "trade" ? HINTS.invalidOrder : HINTS.validation
+      });
+    }
+    case 401:
+      return new AuthenticationError(`${where} was refused: Trading 212 did not accept the API key and secret.`, {
+        ...details,
+        environment,
+        hint: HINTS.authentication(environment)
+      });
+    case 403: {
+      const scope = SCOPE.exec(`${parsed.message ?? ""} ${context.text}`)?.[1];
+      if (scope) {
+        return new MissingScopeError(`${where} was refused: the API key does not have the "${scope}" permission.`, {
+          ...details,
+          scope,
+          hint: HINTS.missingScope(scope)
+        });
+      }
+      if (searchable.includes(DEMO_ONLY)) {
+        return new NotAvailableInDemoError(`${where} was refused: Trading 212 does not allow this on a demo account.`, {
+          ...details,
+          hint: HINTS.notAvailableInDemo
+        });
+      }
+      return new PermissionError(`${where} was refused${said}`, { ...details, hint: HINTS.permission });
+    }
+    case 404:
+      return new NotFoundError(
+        `${where} failed: ${parsed.message ? sentence(parsed.message) : "Trading 212 has nothing at that address."}`,
+        {
+          ...details,
+          hint: notFoundHint(request.endpoint)
+        }
+      );
+    case 408:
+      return new TimeoutError(`${where} failed with ${answered}${said}`, { ...details, hint: HINTS.timeout(kind) });
+    case 429: {
+      const resetAt = rateLimit?.resetAt;
+      const retryAfterMs = resetAt === void 0 ? void 0 : Math.max(0, resetAt - context.now);
+      const budget = rateLimit?.limit !== void 0 && rateLimit.periodMs !== void 0 ? ` (the limit is ${String(rateLimit.limit)} per ${String(rateLimit.periodMs / 1e3)} s)` : "";
+      return new RateLimitError(`${where} was refused: too many requests${budget}.`, {
+        ...details,
+        ...resetAt !== void 0 && { resetAt },
+        ...retryAfterMs !== void 0 && { retryAfterMs },
+        hint: HINTS.rateLimited(request.endpoint, resetAt)
+      });
+    }
+    default: {
+      const message = `${where} failed with ${answered}${said}`;
+      if (status >= 500) return new ServerError(message, { ...details, hint: HINTS.server(kind) });
+      return new HttpError(message, details);
+    }
+  }
+}
+
+// src/logging/logger.ts
+var LEVELS = { debug: 10, info: 20, warn: 30, error: 40 };
+var noop = () => void 0;
+var silentLogger = { debug: noop, info: noop, warn: noop, error: noop };
+function formatFields(fields) {
+  return Object.entries(fields).filter(([, value]) => value !== void 0).map(([key, value]) => {
+    const bare = typeof value === "string" && /^[^\s"=]+$/.test(value);
+    return `${key}=${bare ? value : JSON.stringify(value)}`;
+  }).join(" ");
+}
+function consoleLogger(options = {}) {
+  const threshold = LEVELS[options.level ?? "info"];
+  const target = options.console ?? console;
+  const write = (level) => (message, fields) => {
+    if (LEVELS[level] < threshold) return;
+    const extra = fields ? formatFields(fields) : "";
+    target[level](`[trading212] ${level.toUpperCase().padEnd(5)} ${message}${extra ? ` ${extra}` : ""}`);
+  };
+  return { debug: write("debug"), info: write("info"), warn: write("warn"), error: write("error") };
+}
+function fieldsFirst(target) {
+  return {
+    debug: (message, fields = {}) => {
+      target.debug(fields, message);
+    },
+    info: (message, fields = {}) => {
+      target.info(fields, message);
+    },
+    warn: (message, fields = {}) => {
+      target.warn(fields, message);
+    },
+    error: (message, fields = {}) => {
+      target.error(fields, message);
+    }
+  };
+}
+function safeLogger(logger, redact) {
+  const call = (level) => (message, fields) => {
+    try {
+      logger[level](redact(message), fields ? redact(fields) : void 0);
+    } catch {
+    }
+  };
+  return { debug: call("debug"), info: call("info"), warn: call("warn"), error: call("error") };
+}
+
+// src/resources/exchanges.ts
+var SESSION_AFTER = {
+  OPEN: "regular",
+  BREAK_END: "regular",
+  PRE_MARKET_OPEN: "preMarket",
+  AFTER_HOURS_OPEN: "afterHours",
+  OVERNIGHT_OPEN: "overnight",
+  CLOSE: "closed",
+  BREAK_START: "closed",
+  AFTER_HOURS_CLOSE: "closed"
+};
+var eventOrder = (type) => SESSION_AFTER[type] === "closed" ? 0 : 1;
+function sortedEvents(events) {
+  return events.flatMap((event) => {
+    const at = event.date ? new Date(event.date) : void 0;
+    return event.type && at && !Number.isNaN(at.getTime()) ? [{ type: event.type, at }] : [];
+  }).sort((a, b) => a.at.getTime() - b.at.getTime() || eventOrder(a.type) - eventOrder(b.type));
+}
+function sessionAt(events, at) {
+  const sorted = sortedEvents(events);
+  const time = at.getTime();
+  const previous = sorted.filter((event) => event.at.getTime() <= time).pop();
+  const upcoming = sorted.filter((event) => event.at.getTime() > time);
+  const next = upcoming[0];
+  return {
+    session: previous ? SESSION_AFTER[previous.type] ?? "unknown" : "unknown",
+    since: previous?.at,
+    next: next && { event: next.type, at: next.at },
+    nextOpen: upcoming.find((event) => SESSION_AFTER[event.type] === "regular")?.at
+  };
+}
+var ExchangesResource = class {
+  #context;
+  #instruments;
+  constructor(context, instruments) {
+    this.#context = context;
+    this.#instruments = instruments;
+  }
+  /**
+   * Every exchange and its working schedules, cached like the instrument list.
+   *
+   * Scope `metadata` · 1 request / 30 s.
+   */
+  async list(options = {}) {
+    const { refresh = false, signal } = options;
+    const { cache, cacheNamespace, metadataTtlMs, transport } = this.#context;
+    return cache.load(
+      `${cacheNamespace}:exchanges`,
+      { ttlMs: metadataTtlMs, refresh, signal, accept: isList },
+      async () => {
+        const { data } = await transport.request(ENDPOINTS.listExchanges);
+        return Array.isArray(data) ? data : [];
+      }
+    );
+  }
+  /**
+   * Whether an instrument's market is open, read from Trading 212's working schedules, so you can check before an
+   * order is refused with `market-closed`. The schedules cover a limited window ahead, so `nextOpen` can be undefined.
+   *
+   * @example
+   * const { open, next } = await t212.exchanges.status("AAPL_US_EQ");
+   */
+  async status(ticker, at = /* @__PURE__ */ new Date(), options = {}) {
+    const instrument = typeof ticker === "string" ? await this.#instruments.find(ticker, options) : ticker;
+    const name = typeof ticker === "string" ? ticker : ticker.ticker ?? "";
+    if (!instrument) {
+      throw new InstrumentNotFoundError(`No instrument has the ticker "${name}".`, {
+        query: name,
+        suggestions: [],
+        hint: "Use instruments.resolve() to turn a symbol or name into a Trading 212 ticker."
+      });
+    }
+    const exchanges = await this.list(options);
+    for (const exchange of exchanges) {
+      const schedule = exchange.workingSchedules?.find((candidate) => candidate.id === instrument.workingScheduleId);
+      if (schedule) {
+        const state = sessionAt(schedule.timeEvents ?? [], at);
+        return {
+          ticker: name,
+          exchange: exchange.name ?? void 0,
+          ...state,
+          open: state.session === "regular",
+          extendedHours: ["preMarket", "afterHours", "overnight"].includes(state.session)
+        };
+      }
+    }
+    return {
+      ticker: name,
+      exchange: void 0,
+      session: "unknown",
+      open: false,
+      extendedHours: false,
+      since: void 0,
+      next: void 0,
+      nextOpen: void 0
+    };
+  }
+};
+
+// src/orders/validate.ts
+var TIME_VALIDITIES = ["DAY", "GOOD_TILL_CANCEL"];
+var REQUIRED = {
+  market: [],
+  limit: ["limitPrice", "timeValidity"],
+  stop: ["stopPrice", "timeValidity"],
+  stopLimit: ["stopPrice", "limitPrice", "timeValidity"]
+};
+var ALLOWED = {
+  market: /* @__PURE__ */ new Set(["ticker", "quantity", "extendedHours"]),
+  limit: /* @__PURE__ */ new Set(["ticker", "quantity", "limitPrice", "timeValidity"]),
+  stop: /* @__PURE__ */ new Set(["ticker", "quantity", "stopPrice", "timeValidity"]),
+  stopLimit: /* @__PURE__ */ new Set(["ticker", "quantity", "stopPrice", "limitPrice", "timeValidity"])
+};
+function issuesFor(type, fields, signed) {
+  const issues = [];
+  const add = (field, message) => {
+    issues.push({ field, message });
+  };
+  if (typeof fields.ticker !== "string" || fields.ticker.trim() === "") add("ticker", "is required");
+  else if (/\s/.test(fields.ticker))
+    add("ticker", "must not contain spaces; use the Trading 212 ticker, such as AAPL_US_EQ");
+  const quantity = fields.quantity;
+  if (typeof quantity !== "number" || !Number.isFinite(quantity)) add("quantity", "must be a finite number");
+  else if (quantity === 0) add("quantity", "must not be zero");
+  else if (signed === "positive" && quantity < 0)
+    add("quantity", "must be positive; buy() and sell() set the sign themselves");
+  else if (decimalPlaces(quantity) > QUANTITY_DECIMALS) {
+    add("quantity", `has more than ${QUANTITY_DECIMALS} decimal places; use truncateQuantity()`);
+  }
+  for (const field of REQUIRED[type]) {
+    if (fields[field] === void 0) add(field, `is required for a ${type} order`);
+  }
+  for (const field of ["limitPrice", "stopPrice"]) {
+    const price = fields[field];
+    if (price !== void 0 && (typeof price !== "number" || !Number.isFinite(price) || price <= 0)) {
+      add(field, "must be a positive number");
+    }
+  }
+  if (fields.timeValidity !== void 0 && !TIME_VALIDITIES.includes(fields.timeValidity)) {
+    add("timeValidity", 'must be "DAY" or "GOOD_TILL_CANCEL"');
+  }
+  if (fields.extendedHours !== void 0 && typeof fields.extendedHours !== "boolean") {
+    add("extendedHours", "must be true or false");
+  }
+  for (const [field, value] of Object.entries(fields)) {
+    if (value !== void 0 && !ALLOWED[type].has(field)) {
+      add(field, field === "extendedHours" ? "is only allowed on market orders" : `is not used by a ${type} order`);
+    }
+  }
+  return issues;
+}
+var ORDER_TYPES = /* @__PURE__ */ new Set(["market", "limit", "stop", "stopLimit"]);
+function validateOrder(type, fields, signed = "any") {
+  if (!ORDER_TYPES.has(type)) {
+    throw new ValidationError(`"${type}" is not an order type.`, {
+      issues: [{ field: "type", message: 'must be "market", "limit", "stop" or "stopLimit"' }],
+      hint: "Nothing was sent."
+    });
+  }
+  const issues = issuesFor(type, fields, signed);
+  if (issues.length === 0) return;
+  const summary = issues.map((issue) => `${issue.field} ${issue.message}`).join("; ");
+  throw new ValidationError(`The ${type} order is invalid: ${summary}.`, {
+    issues,
+    hint: "Nothing was sent. Fix the fields listed in `error.issues`."
+  });
+}
+
+// src/internal/duration.ts
+var MAX_TIMER_MS = 2147483647;
+function durationOption(value, field) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0 || value > MAX_TIMER_MS) {
+    throw new ValidationError(`${field} must be a positive number of milliseconds.`, {
+      issues: [{ field, message: "must be a positive number of milliseconds" }],
+      hint: "Nothing was sent."
+    });
+  }
+  return Math.ceil(value);
+}
+
+// src/internal/sleep.ts
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    if (ms <= 0) {
+      resolve();
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason);
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/resources/orders.ts
+var ENDPOINT_FOR = {
+  market: ENDPOINTS.placeMarketOrder,
+  limit: ENDPOINTS.placeLimitOrder,
+  stop: ENDPOINTS.placeStopOrder,
+  stopLimit: ENDPOINTS.placeStopLimitOrder
+};
+var FINAL_ORDER_STATUSES = /* @__PURE__ */ new Set(["FILLED", "CANCELLED", "REJECTED", "REPLACED"]);
+function checkOrderId(id) {
+  if (typeof id !== "number" || !Number.isSafeInteger(id) || id <= 0) {
+    throw new ValidationError("An order ID must be a positive whole number.", {
+      issues: [{ field: "id", message: "is not a valid order ID" }]
+    });
+  }
+  return id;
+}
+function requestBody(input) {
+  const body = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (key !== "type" && value !== void 0) body[key] = value;
+  }
+  return body;
+}
+var OrdersResource = class {
+  #context;
+  #positions;
+  #history;
+  constructor(context, positions, history) {
+    this.#context = context;
+    this.#positions = positions;
+    this.#history = history;
+  }
+  /**
+   * Orders that are still working: not yet filled, cancelled or expired.
+   *
+   * Scope `orders:read` · 1 request / 5 s.
+   */
+  async list(options = {}) {
+    const { data } = await this.#context.transport.request(ENDPOINTS.listOrders, options);
+    return Array.isArray(data) ? data : [];
+  }
+  /**
+   * One pending order. Throws `NotFoundError` once it has filled or been cancelled.
+   *
+   * Scope `orders:read` · 1 request / 1 s.
+   */
+  async get(id, options = {}) {
+    const { data } = await this.#context.transport.request(ENDPOINTS.getOrder, {
+      ...options,
+      params: { id: checkOrderId(id) }
+    });
+    return data;
+  }
+  /**
+   * Asks Trading 212 to cancel a pending order. Success means the request was accepted; the order may still fill
+   * first. Never retried.
+   *
+   * Scope `orders:execute` · 50 requests / minute.
+   */
+  async cancel(id, options = {}) {
+    await this.#context.transport.request(ENDPOINTS.cancelOrder, { ...options, params: { id: checkOrderId(id) } });
+  }
+  /**
+   * Trades at the next available price. A negative quantity sells. Never retried.
+   *
+   * Scope `orders:execute` · 50 requests / minute.
+   */
+  async market(request, options) {
+    return this.#place("market", request, options);
+  }
+  /**
+   * Trades at `limitPrice` or better. A negative quantity sells. Never retried.
+   *
+   * Scope `orders:execute` · 1 request / 2 s.
+   */
+  async limit(request, options) {
+    return this.#place("limit", request, options);
+  }
+  /**
+   * Places a market order once the price reaches `stopPrice`: a negative quantity makes a stop-loss. Never retried.
+   *
+   * Scope `orders:execute` · 1 request / 2 s.
+   */
+  async stop(request, options) {
+    return this.#place("stop", request, options);
+  }
+  /**
+   * Places a limit order at `limitPrice` once the price reaches `stopPrice`. Never retried.
+   *
+   * Scope `orders:execute` · 1 request / 2 s.
+   */
+  async stopLimit(request, options) {
+    return this.#place("stopLimit", request, options);
+  }
+  /**
+   * Buys. The quantity is positive; `type` defaults to `market`.
+   *
+   * @example
+   * await t212.orders.buy({ ticker: "AAPL_US_EQ", quantity: 0.5 });
+   * await t212.orders.buy({ type: "limit", ticker: "AAPL_US_EQ", quantity: 1, limitPrice: 180, timeValidity: "DAY" });
+   */
+  async buy(input, options) {
+    const { type = "market", ...fields } = input;
+    validateOrder(type, fields, "positive");
+    return this.#place(type, fields, options);
+  }
+  /**
+   * Sells. The quantity is positive and the sign is set for you, so a slip cannot turn a sale into a purchase.
+   *
+   * @example
+   * await t212.orders.sell({ type: "stop", ticker: "AAPL_US_EQ", quantity: 1, stopPrice: 150, timeValidity: "GOOD_TILL_CANCEL" });
+   */
+  async sell(input, options) {
+    const { type = "market", ...fields } = input;
+    validateOrder(type, fields, "positive");
+    return this.#place(type, { ...fields, quantity: -fields.quantity }, options);
+  }
+  /**
+   * Sells everything you can of one holding at market: `quantityAvailableForTrading`, cut to 4 decimal places so it
+   * never exceeds what you own. Shares held in pies or reserved by pending orders are left alone.
+   */
+  async sellAll(ticker, options) {
+    const { extendedHours, dryRun, ...call } = options ?? {};
+    const position = await this.#positions.get(ticker, call);
+    if (!position) {
+      throw new ValidationError(`You hold no ${ticker}, so there is nothing to sell.`, {
+        issues: [{ field: "ticker", message: "not held" }]
+      });
+    }
+    const available = position.quantityAvailableForTrading;
+    if (typeof available !== "number") {
+      throw new ValidationError(`Trading 212 did not say how much of your ${ticker} is available to sell.`, {
+        issues: [{ field: "quantityAvailableForTrading", message: "is missing from the position" }],
+        hint: "Sell an explicit quantity with orders.sell() instead."
+      });
+    }
+    const quantity = truncateQuantity(available);
+    if (quantity <= 0) {
+      throw new ValidationError(`None of your ${ticker} is available to sell.`, {
+        issues: [{ field: "quantity", message: `${available} available` }],
+        hint: "Shares held in pies or reserved by pending orders cannot be sold until they are released."
+      });
+    }
+    const request = {
+      ticker,
+      quantity: -quantity,
+      ...extendedHours !== void 0 && { extendedHours }
+    };
+    return this.#place("market", request, { ...call, ...dryRun !== void 0 && { dryRun } });
+  }
+  /**
+   * Waits until an order is filled, cancelled or rejected, and returns it in its final state. It polls the pending
+   * order, and once that is gone looks the order up in the history, so the key needs `history:orders` as well.
+   * `timeoutMs` bounds the whole wait, including any wait for rate-limit budget.
+   */
+  async waitFor(order, options = {}) {
+    const { signal } = options;
+    const timeoutMs = durationOption(options.timeoutMs, "timeoutMs") ?? 6e4;
+    const intervalMs = durationOption(options.intervalMs, "intervalMs") ?? 1e3;
+    const id = checkOrderId(typeof order === "number" ? order : order.id);
+    let ticker = typeof order === "number" ? void 0 : order.ticker ?? order.instrument?.ticker ?? void 0;
+    let last = typeof order === "number" ? void 0 : order;
+    let gone = false;
+    const deadline = Date.now() + timeoutMs;
+    const expiry = AbortSignal.timeout(timeoutMs);
+    const call = { signal: signal ? AbortSignal.any([signal, expiry]) : expiry };
+    const timedOut = () => new TimeoutError(`Order ${id} had not settled after ${timeoutMs} ms (last seen ${last?.status ?? "pending"}).`, {
+      hint: "It may still fill. Check it again with orders.get() or history.orders.list()."
+    });
+    try {
+      for (; ; ) {
+        if (!gone) {
+          try {
+            const current = await this.get(id, call);
+            last = current;
+            ticker ??= current.ticker ?? current.instrument?.ticker ?? void 0;
+            if (current.status && FINAL_ORDER_STATUSES.has(current.status)) return current;
+          } catch (error) {
+            if (!(error instanceof NotFoundError)) throw error;
+            gone = true;
+          }
+        }
+        if (gone) {
+          const settled = await this.#fromHistory(id, ticker, call);
+          if (settled) return settled;
+        }
+        if (Date.now() + intervalMs > deadline) throw timedOut();
+        await sleep(intervalMs, call.signal);
+      }
+    } catch (error) {
+      if (expiry.aborted && !signal?.aborted) throw timedOut();
+      throw error;
+    }
+  }
+  async #fromHistory(id, ticker, call) {
+    const page = await this.#history.list({ ...call, limit: 50, ...ticker && { ticker } });
+    return page.items.find((item) => item.order?.id === id)?.order ?? void 0;
+  }
+  async #place(type, request, options) {
+    const { dryRun = false, ...call } = options ?? {};
+    const body = requestBody(request);
+    validateOrder(type, body);
+    const endpoint = ENDPOINT_FOR[type];
+    const { transport } = this.#context;
+    if (dryRun) {
+      const { url } = transport.describe(endpoint);
+      const result = {
+        dryRun: true,
+        method: "POST",
+        url,
+        endpoint: endpoint.id,
+        body,
+        wouldSend: transport.tradingEnabled
+      };
+      return result;
+    }
+    const { data } = await transport.request(endpoint, { ...call, body, expectBody: true });
+    return data;
+  }
+};
+
+// src/resources/portfolio.ts
+var numberOrZero = (value) => typeof value === "number" && Number.isFinite(value) ? value : 0;
+function buildPortfolioSnapshot(summary, positions, takenAt = /* @__PURE__ */ new Date()) {
+  const holdings = positions.map((position) => {
+    const value = numberOrZero(position.walletImpact?.currentValue);
+    const cost = numberOrZero(position.walletImpact?.totalCost);
+    const profitLoss = numberOrZero(position.walletImpact?.unrealizedProfitLoss);
+    return {
+      ticker: position.instrument?.ticker ?? "",
+      name: position.instrument?.name ?? void 0,
+      quantity: numberOrZero(position.quantity),
+      value,
+      cost,
+      profitLoss,
+      profitLossRatio: cost === 0 ? void 0 : profitLoss / cost
+    };
+  });
+  const invested = holdings.reduce((total, holding) => total + holding.value, 0);
+  return {
+    currency: summary.currency ?? void 0,
+    totalValue: numberOrZero(summary.totalValue),
+    cash: numberOrZero(summary.cash?.availableToTrade),
+    invested,
+    unrealisedProfitLoss: numberOrZero(summary.investments?.unrealizedProfitLoss),
+    realisedProfitLoss: numberOrZero(summary.investments?.realizedProfitLoss),
+    holdings: holdings.map((holding) => ({ ...holding, weight: invested === 0 ? 0 : holding.value / invested })).sort((a, b) => b.value - a.value),
+    takenAt
+  };
+}
+var PortfolioResource = class {
+  #account;
+  #positions;
+  constructor(account, positions) {
+    this.#account = account;
+    this.#positions = positions;
+  }
+  /**
+   * The account's totals and every holding's value, profit and weight, from two requests.
+   *
+   * @example
+   * const { totalValue, holdings } = await t212.portfolio.snapshot();
+   */
+  async snapshot(options = {}) {
+    const [summary, positions] = await Promise.all([this.#account.summary(options), this.#positions.list(options)]);
+    return buildPortfolioSnapshot(summary, positions);
+  }
+};
+
+// src/version.ts
+var VERSION = "0.1.2" ;
+
+// src/http/retry.ts
+var DEFAULT_RETRY = { maxAttempts: 3, baseDelayMs: 500, maxDelayMs: 1e4 };
+function isRetryable(error) {
+  return error instanceof TimeoutError || error instanceof ServerError || error instanceof RateLimitError || error instanceof NetworkError;
+}
+function retryDelay(attempt, retry, error, random = Math.random) {
+  if (error instanceof RateLimitError && error.retryAfterMs !== void 0) {
+    return error.retryAfterMs + Math.floor(random() * 250);
+  }
+  const ceiling = Math.min(retry.maxDelayMs, retry.baseDelayMs * 2 ** (attempt - 1));
+  return Math.floor(random() * ceiling);
+}
+
+// src/config.ts
+var ONE_HOUR = 60 * 60 * 1e3;
+function fail(field, message, hint) {
+  throw new ConfigurationError(message, { field, ...hint && { hint } });
+}
+function checkCredential(field, value) {
+  const label = field === "apiKey" ? "API key" : "API secret";
+  if (typeof value !== "string" || value.length === 0) {
+    fail(field, `The ${label} is missing.`, "Create a key in the Trading 212 app under Settings > API (Beta).");
+  }
+  if (value.trim() !== value) {
+    fail(field, `The ${label} starts or ends with whitespace.`, "This is usually a copy-paste slip: trim it.");
+  }
+  if (/\s/.test(value)) fail(field, `The ${label} contains whitespace.`, "Copy it again from the Trading 212 app.");
+  return value;
+}
+function positiveMs(field, value, fallback, max) {
+  if (value === void 0) return fallback;
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0 || value > max) {
+    fail(field, `${field} must be a positive number of milliseconds no greater than ${max}.`);
+  }
+  return Math.ceil(value);
+}
+var LOCAL_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
+function resolveOrigin(baseUrl, environment) {
+  const official = BASE_URLS[environment];
+  if (baseUrl === void 0) return { origin: official, official: true };
+  let url;
+  try {
+    url = new URL(baseUrl);
+  } catch {
+    fail("baseUrl", "baseUrl is not a valid URL.");
+  }
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && LOCAL_HOSTS.has(url.hostname))) {
+    fail(
+      "baseUrl",
+      "baseUrl must use https://, so your key is never sent in the clear.",
+      "Only http://localhost is allowed without TLS."
+    );
+  }
+  if (url.username || url.password) fail("baseUrl", "baseUrl must not contain a username or password.");
+  if (url.search || url.hash || url.pathname !== "/" && url.pathname !== "") {
+    fail("baseUrl", "baseUrl must be an origin only, such as https://demo.trading212.com, with no path.");
+  }
+  const other = environment === "demo" ? "live" : "demo";
+  if (url.origin === BASE_URLS[other]) {
+    fail(
+      "baseUrl",
+      `baseUrl is Trading 212's ${other} host, but environment is "${environment}".`,
+      `Set environment to "${other}" instead of pointing baseUrl at it.`
+    );
+  }
+  return { origin: url.origin, official: url.origin === official };
+}
+var ENVIRONMENT_ALIASES = /* @__PURE__ */ new Map([
+  ["prod", "live"],
+  ["production", "live"],
+  ["real", "live"],
+  ["paper", "demo"],
+  ["practice", "demo"],
+  ["sandbox", "demo"],
+  ["test", "demo"]
+]);
+function environmentHint(value, field) {
+  const alias = typeof value === "string" ? ENVIRONMENT_ALIASES.get(value.trim().toLowerCase()) : void 0;
+  if (alias) return `Trading 212 calls that environment "${alias}": set ${field} to ${alias}.`;
+  return `Set ${field} to demo or live. There is deliberately no default, because live trades real money.`;
+}
+function isBrowser() {
+  const scope = globalThis;
+  return typeof scope.document === "object" && typeof scope.window === "object";
+}
+function resolveOptions(options) {
+  if (typeof options !== "object" || options === null) fail("options", "Pass an options object.");
+  if (!isEnvironment(options.environment)) {
+    fail("environment", 'environment must be "demo" or "live".', environmentHint(options.environment, "environment"));
+  }
+  if (isBrowser() && !options.dangerouslyAllowBrowser) {
+    fail(
+      "dangerouslyAllowBrowser",
+      "trading212.js refuses to run in a browser.",
+      "Trading 212 rejects requests from web pages, and any key you ship to a browser is public. Call the API from a server instead."
+    );
+  }
+  const apiKey = checkCredential("apiKey", options.apiKey);
+  const apiSecret = checkCredential("apiSecret", options.apiSecret);
+  if (apiKey === apiSecret) {
+    fail("apiSecret", "The API secret is the same as the API key.", "Paste the secret, not the key, into apiSecret.");
+  }
+  if (apiKey.includes(":")) fail("apiKey", "The API key contains a colon, which no Trading 212 key has.");
+  const trading = options.trading;
+  if (trading !== void 0 && trading !== "enabled" && trading !== "disabled") {
+    fail("trading", 'trading must be "enabled" or "disabled".');
+  }
+  if (options.rateLimit !== void 0 && !["pace", "burst", "off"].includes(options.rateLimit)) {
+    fail("rateLimit", 'rateLimit must be "pace", "burst" or "off".');
+  }
+  let retry = DEFAULT_RETRY;
+  if (options.retry === false) retry = null;
+  else if (options.retry) {
+    const maxAttempts = options.retry.maxAttempts ?? DEFAULT_RETRY.maxAttempts;
+    if (!Number.isInteger(maxAttempts) || maxAttempts < 1 || maxAttempts > 10) {
+      fail("retry.maxAttempts", "retry.maxAttempts must be a whole number from 1 to 10.");
+    }
+    retry = {
+      maxAttempts,
+      baseDelayMs: positiveMs("retry.baseDelayMs", options.retry.baseDelayMs, DEFAULT_RETRY.baseDelayMs, 6e4),
+      maxDelayMs: positiveMs("retry.maxDelayMs", options.retry.maxDelayMs, DEFAULT_RETRY.maxDelayMs, 3e5)
+    };
+  }
+  const { origin: resolvedOrigin, official } = resolveOrigin(options.baseUrl, options.environment);
+  return {
+    environment: options.environment,
+    apiKey,
+    apiSecret,
+    // Only Trading 212's own demo host may trade by default: a proxy could forward anywhere, including live.
+    trading: options.trading ?? (options.environment === "demo" && official ? "enabled" : "disabled"),
+    timeoutMs: positiveMs("timeoutMs", options.timeoutMs, 15e3, 6e5),
+    retry,
+    rateLimit: options.rateLimit ?? "pace",
+    maxRateLimitWaitMs: positiveMs("maxRateLimitWaitMs", options.maxRateLimitWaitMs, 6e4, 36e5),
+    metadataTtlMs: positiveMs("metadataTtlMs", options.metadataTtlMs, ONE_HOUR, 7 * 24 * ONE_HOUR),
+    origin: resolvedOrigin,
+    officialOrigin: official
+  };
+}
+function optionsFromEnv(env) {
+  const source = env ?? globalThis.process?.env ?? {};
+  const environment = source.T212_ENV?.trim().toLowerCase();
+  if (!isEnvironment(environment)) {
+    fail(
+      "T212_ENV",
+      environment ? `T212_ENV is "${environment}", which is neither demo nor live.` : "T212_ENV is not set.",
+      environmentHint(environment, "T212_ENV")
+    );
+  }
+  const prefix = environment === "demo" ? "T212_DEMO" : "T212_LIVE";
+  const read = (name) => source[name] === "" ? void 0 : source[name];
+  const apiKey = read("T212_API_KEY") ?? read(`${prefix}_API_KEY`);
+  const apiSecret = read("T212_API_SECRET") ?? read(`${prefix}_API_SECRET`);
+  if (!apiKey) fail("T212_API_KEY", `Neither T212_API_KEY nor ${prefix}_API_KEY is set.`);
+  if (!apiSecret) fail("T212_API_SECRET", `Neither T212_API_SECRET nor ${prefix}_API_SECRET is set.`);
+  return { environment, apiKey, apiSecret };
+}
+function basicAuthorization(apiKey, apiSecret) {
+  const bytes = new TextEncoder().encode(`${apiKey}:${apiSecret}`);
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return `Basic ${btoa(binary)}`;
+}
+
+// src/http/rateLimiter.ts
+function planPaced(bucket, now) {
+  const slot = Math.max(now, bucket.nextSlotAt, bucket.blockedUntil);
+  return { waitMs: slot - now, next: { nextSlotAt: slot + bucket.periodMs / bucket.limit } };
+}
+function planBurst(bucket, now) {
+  let { windowStartsAt, windowEndsAt, remaining } = bucket;
+  if (bucket.blockedUntil > now && windowStartsAt < bucket.blockedUntil) {
+    windowStartsAt = bucket.blockedUntil;
+    windowEndsAt = bucket.blockedUntil + bucket.periodMs;
+    remaining = bucket.limit;
+  }
+  if (now >= windowEndsAt) {
+    windowStartsAt = now;
+    windowEndsAt = now + bucket.periodMs;
+    remaining = bucket.limit;
+  }
+  if (remaining > 0) {
+    return {
+      waitMs: Math.max(0, windowStartsAt - now),
+      next: { windowStartsAt, windowEndsAt, remaining: remaining - 1 }
+    };
+  }
+  return {
+    waitMs: windowEndsAt - now,
+    next: { windowStartsAt: windowEndsAt, windowEndsAt: windowEndsAt + bucket.periodMs, remaining: bucket.limit - 1 }
+  };
+}
+var REGISTRY = /* @__PURE__ */ Symbol.for("trading212.js/rate-limits");
+function registry() {
+  const holder = globalThis;
+  holder[REGISTRY] ??= /* @__PURE__ */ new Map();
+  return holder[REGISTRY];
+}
+var RateLimiter = class {
+  #buckets;
+  #mode;
+  constructor(accountKey, mode) {
+    const shared = registry();
+    let buckets = shared.get(accountKey);
+    if (!buckets) {
+      buckets = /* @__PURE__ */ new Map();
+      shared.set(accountKey, buckets);
+    }
+    this.#buckets = buckets;
+    this.#mode = mode;
+  }
+  #bucket(endpoint) {
+    let bucket = this.#buckets.get(endpoint.id);
+    if (!bucket) {
+      bucket = {
+        limit: endpoint.rateLimit.requests,
+        periodMs: endpoint.rateLimit.periodMs,
+        nextSlotAt: 0,
+        remaining: endpoint.rateLimit.requests,
+        windowStartsAt: 0,
+        windowEndsAt: 0,
+        blockedUntil: 0,
+        lastSeen: void 0
+      };
+      this.#buckets.set(endpoint.id, bucket);
+    }
+    return bucket;
+  }
+  /**
+   * Books the next slot for a call. When the wait would be longer than `maxWaitMs`, nothing is booked, so a refused
+   * call never delays the ones after it.
+   */
+  reserve(endpoint, now, maxWaitMs = Number.POSITIVE_INFINITY) {
+    const bucket = this.#bucket(endpoint);
+    if (this.#mode === "off") return { waitMs: 0, booked: true };
+    const plan = this.#mode === "pace" ? planPaced(bucket, now) : planBurst(bucket, now);
+    if (plan.waitMs > maxWaitMs) return { waitMs: plan.waitMs, booked: false };
+    Object.assign(bucket, plan.next);
+    return { waitMs: plan.waitMs, booked: true };
+  }
+  /** Corrects the budget from what Trading 212's headers said, which beats the documented figures. */
+  update(endpoint, info, now) {
+    const bucket = this.#bucket(endpoint);
+    bucket.lastSeen = info;
+    if (info.limit !== void 0 && info.limit > 0) bucket.limit = info.limit;
+    if (info.periodMs !== void 0 && info.periodMs > 0) bucket.periodMs = info.periodMs;
+    if (info.resetAt !== void 0 && info.resetAt > now) {
+      if (info.remaining === 0) bucket.blockedUntil = Math.max(bucket.blockedUntil, info.resetAt);
+      if (info.remaining !== void 0 && bucket.windowStartsAt <= now && now < bucket.windowEndsAt) {
+        bucket.remaining = Math.min(bucket.remaining, info.remaining);
+      }
+    }
+  }
+  /** How long the endpoint is closed for after a 429 or an empty budget, in milliseconds. */
+  blockedFor(endpoint, now) {
+    if (this.#mode === "off") return 0;
+    return Math.max(0, this.#bucket(endpoint).blockedUntil - now);
+  }
+  /** Records a 429: nothing more is sent to the endpoint until the reset. */
+  markLimited(endpoint, resetAt, now) {
+    const bucket = this.#bucket(endpoint);
+    bucket.blockedUntil = Math.max(bucket.blockedUntil, resetAt ?? now + bucket.periodMs);
+  }
+  snapshot(endpoints) {
+    const out = {};
+    for (const endpoint of endpoints) {
+      const bucket = this.#bucket(endpoint);
+      out[endpoint.id] = {
+        limit: bucket.limit,
+        periodMs: bucket.periodMs,
+        remaining: bucket.lastSeen?.remaining,
+        resetAt: bucket.lastSeen?.resetAt === void 0 ? void 0 : new Date(bucket.lastSeen.resetAt)
+      };
+    }
+    return out;
+  }
+};
+
+// src/http/rateLimitHeaders.ts
+function numberHeader(headers, name) {
+  const raw = headers.get(name);
+  if (raw === null || raw.trim() === "") return void 0;
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : void 0;
+}
+function retryAfter(headers, now) {
+  const raw = headers.get("retry-after")?.trim();
+  if (!raw) return void 0;
+  if (/^\d+$/.test(raw)) return now + Number(raw) * 1e3;
+  const date = Date.parse(raw);
+  return Number.isNaN(date) ? void 0 : date;
+}
+function parseRateLimitHeaders(headers, now = Date.now()) {
+  const limit = numberHeader(headers, "x-ratelimit-limit");
+  const period = numberHeader(headers, "x-ratelimit-period");
+  const remaining = numberHeader(headers, "x-ratelimit-remaining");
+  const used = numberHeader(headers, "x-ratelimit-used");
+  const resetHeader = numberHeader(headers, "x-ratelimit-reset");
+  const reset = resetHeader === void 0 ? retryAfter(headers, now) : resetHeader > 1e12 ? resetHeader : resetHeader * 1e3;
+  if ([limit, period, remaining, used, reset].every((value) => value === void 0)) return void 0;
+  return {
+    ...limit !== void 0 && { limit },
+    ...period !== void 0 && { periodMs: period * 1e3 },
+    ...remaining !== void 0 && { remaining },
+    ...used !== void 0 && { used },
+    ...reset !== void 0 && { resetAt: reset }
+  };
+}
+
+// src/http/transport.ts
+var MAX_ERROR_BODY = 64 * 1024;
+var NOT_SENT = /* @__PURE__ */ new Set([
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "ECONNREFUSED",
+  "ENETUNREACH",
+  "EHOSTUNREACH",
+  "UND_ERR_CONNECT_TIMEOUT",
+  "CERT_HAS_EXPIRED",
+  "DEPTH_ZERO_SELF_SIGNED_CERT",
+  "SELF_SIGNED_CERT_IN_CHAIN",
+  "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+  "ERR_TLS_CERT_ALTNAME_INVALID"
+]);
+function errorCode(error) {
+  let current = error;
+  for (let depth = 0; depth < 4 && current; depth++) {
+    const code = current.code;
+    if (typeof code === "string") return code;
+    current = current.cause;
+  }
+  return void 0;
+}
+function buildPath(template, params = {}) {
+  return template.replace(/\{(\w+)\}/g, (_, name) => {
+    const value = params[name];
+    if (value === void 0 || value === "") {
+      throw new ValidationError(`Missing the "${name}" for ${template}.`, {
+        issues: [{ field: name, message: "is required" }]
+      });
+    }
+    return encodeURIComponent(String(value));
+  });
+}
+function encodeQuery(query) {
+  if (!query) return "";
+  const search = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== void 0) search.set(key, String(value));
+  }
+  return search.toString();
+}
+var Transport = class {
+  #config;
+  #warnedDeprecated = /* @__PURE__ */ new Set();
+  constructor(config) {
+    this.#config = config;
+  }
+  get origin() {
+    return this.#config.origin;
+  }
+  get tradingEnabled() {
+    return this.#config.trading === "enabled";
+  }
+  rateLimitSnapshot() {
+    return this.#config.rateLimiter.snapshot(Object.values(ENDPOINTS));
+  }
+  /** Builds a request's URL and description without sending it. */
+  describe(endpoint, options = {}) {
+    const path = buildPath(endpoint.path, options.params);
+    const query = options.rawQuery ?? encodeQuery(options.query);
+    return {
+      method: endpoint.method,
+      path,
+      endpoint: endpoint.id,
+      url: `${this.#config.origin}${path}${query ? `?${query}` : ""}`
+    };
+  }
+  async request(endpoint, given = {}) {
+    const { url, ...description } = this.describe(endpoint, given);
+    const config = this.#config;
+    const options = { ...given, timeoutMs: durationOption(given.timeoutMs, "timeoutMs") ?? config.timeoutMs };
+    if (endpoint.kind === "trade" && !this.tradingEnabled) {
+      throw new TradingDisabledError(`Refused to send ${description.method} ${description.path}: trading is off.`, {
+        request: description,
+        hint: HINTS.tradingDisabled
+      });
+    }
+    if (endpoint.deprecated && !this.#warnedDeprecated.has(endpoint.id)) {
+      this.#warnedDeprecated.add(endpoint.id);
+      config.logger.warn(`${endpoint.id} uses a deprecated Trading 212 endpoint that may be removed.`, {
+        endpoint: endpoint.id
+      });
+    }
+    const maxAttempts = endpoint.kind === "read" && config.retry ? config.retry.maxAttempts : 1;
+    for (let attempt = 1; ; attempt++) {
+      try {
+        return await this.#attempt(endpoint, url, description, options, attempt);
+      } catch (error) {
+        const { retry } = config;
+        const delayMs = retry && attempt < maxAttempts && isRetryable(error) ? retryDelay(attempt, retry, error) : Number.POSITIVE_INFINITY;
+        if (delayMs > config.maxRateLimitWaitMs) {
+          this.#logFailure(endpoint, description, error);
+          throw error;
+        }
+        const event = { ...this.#event(description, attempt), delayMs, error };
+        config.logger.warn(`Retrying ${description.method} ${description.path} in ${delayMs} ms.`, {
+          endpoint: endpoint.id,
+          attempt,
+          delayMs,
+          code: error.code
+        });
+        this.#hook(() => config.hooks.onRetry?.(event));
+        await sleep(delayMs, options.signal);
+      }
+    }
+  }
+  // Anything that changes the account is logged at info, so a default logger keeps a record of every order.
+  #logFailure(endpoint, description, error) {
+    const where = `${description.method} ${description.path}`;
+    const known = isTrading212Error(error);
+    const fields = {
+      endpoint: endpoint.id,
+      ...known && {
+        code: error.code,
+        status: error.status,
+        apiCode: error.apiCode,
+        traceId: error.traceId,
+        hint: error.hint
+      }
+    };
+    if (error instanceof OrderOutcomeUnknownError) {
+      this.#config.logger.warn(
+        `${where} may or may not have gone through. Check orders.list() before sending it again.`,
+        fields
+      );
+      return;
+    }
+    const message = known ? error.message : `${where} failed: ${error instanceof Error ? error.message : String(error)}`;
+    this.#config.logger[endpoint.kind === "read" ? "debug" : "info"](message, fields);
+  }
+  #event(description, attempt) {
+    return {
+      endpoint: description.endpoint ?? "",
+      method: description.method,
+      path: description.path,
+      attempt
+    };
+  }
+  #hook(call) {
+    try {
+      call();
+    } catch {
+    }
+  }
+  async #waitForBudget(endpoint, description, signal) {
+    const config = this.#config;
+    const deadline = Date.now() + config.maxRateLimitWaitMs;
+    for (; ; ) {
+      if (signal?.aborted) throw signal.reason;
+      const now = Date.now();
+      const { waitMs, booked } = config.rateLimiter.reserve(endpoint, now, deadline - now);
+      if (!booked) {
+        throw new RateLimitError(
+          `${description.method} ${description.path} would have to wait ${Math.ceil(waitMs / 1e3)} s for rate-limit budget, longer than maxRateLimitWaitMs.`,
+          {
+            request: description,
+            retryAfterMs: waitMs,
+            resetAt: now + waitMs,
+            hint: HINTS.rateLimited(endpoint.id, now + waitMs)
+          }
+        );
+      }
+      if (waitMs > 0) {
+        const message = `Waiting ${waitMs} ms for ${endpoint.id}'s rate limit.`;
+        if (waitMs >= 5e3) config.logger.warn(message, { endpoint: endpoint.id, waitMs });
+        else config.logger.debug(message, { endpoint: endpoint.id, waitMs });
+        this.#hook(() => config.hooks.onRateLimitWait?.({ endpoint: endpoint.id, waitMs }));
+        await sleep(waitMs, signal);
+      }
+      if (config.rateLimiter.blockedFor(endpoint, Date.now()) <= 0) return;
+    }
+  }
+  async #attempt(endpoint, url, description, options, attempt) {
+    const config = this.#config;
+    await this.#waitForBudget(endpoint, description, options.signal);
+    if (options.signal?.aborted) throw options.signal.reason;
+    const headers = { Authorization: config.authorization, Accept: "application/json" };
+    if (options.body !== void 0) headers["Content-Type"] = "application/json";
+    if (config.userAgent) headers["User-Agent"] = config.userAgent;
+    const timeoutMs = options.timeoutMs ?? config.timeoutMs;
+    const timeout = AbortSignal.timeout(timeoutMs);
+    const signal = options.signal ? AbortSignal.any([options.signal, timeout]) : timeout;
+    const event = this.#event(description, attempt);
+    const level = endpoint.kind === "read" ? "debug" : "info";
+    config.logger[level](`Sending ${description.method} ${description.path}`, { endpoint: endpoint.id, attempt });
+    this.#hook(() => config.hooks.onRequest?.(event));
+    const started = Date.now();
+    let response;
+    let text;
+    try {
+      response = await config.fetch(url, {
+        method: endpoint.method,
+        headers,
+        ...options.body !== void 0 && { body: JSON.stringify(options.body) },
+        signal,
+        redirect: "manual"
+      });
+    } catch (error) {
+      throw this.#requestFailure(error, endpoint, description, options, timeout, timeoutMs, true);
+    }
+    const rateLimit = parseRateLimitHeaders(response.headers);
+    if (rateLimit) config.rateLimiter.update(endpoint, rateLimit, Date.now());
+    try {
+      const raw = await response.text();
+      text = response.ok ? config.removeSecrets(raw) : config.redact(raw);
+    } catch (error) {
+      const mayHaveRun = response.status < 400 || response.status === 408 || response.status >= 500;
+      throw this.#requestFailure(error, endpoint, description, options, timeout, timeoutMs, mayHaveRun);
+    }
+    const durationMs = Date.now() - started;
+    config.logger[level](`${description.method} ${description.path} returned ${response.status} in ${durationMs} ms`, {
+      endpoint: endpoint.id,
+      status: response.status,
+      durationMs,
+      rateLimitRemaining: rateLimit?.remaining
+    });
+    this.#hook(() => config.hooks.onResponse?.({ ...event, status: response.status, durationMs, rateLimit }));
+    if (response.type === "opaqueredirect" || response.status >= 300 && response.status < 400) {
+      const message = `${description.method} ${description.path} answered with a redirect, which is never followed with your credentials.`;
+      const details = { status: response.status, request: description, ...rateLimit && { rateLimit } };
+      if (endpoint.kind === "trade") {
+        throw new OrderOutcomeUnknownError(message, { ...details, sent: options.body, hint: HINTS.outcomeUnknown });
+      }
+      throw new UnexpectedResponseError(message, details);
+    }
+    if (!response.ok) {
+      if (response.status === 429) config.rateLimiter.markLimited(endpoint, rateLimit?.resetAt, Date.now());
+      throw errorFromResponse({
+        status: response.status,
+        statusText: response.statusText,
+        text: text.slice(0, MAX_ERROR_BODY),
+        request: description,
+        kind: endpoint.kind,
+        environment: config.environment,
+        rateLimit,
+        sent: options.body,
+        now: Date.now()
+      });
+    }
+    return {
+      data: this.#parse(text, endpoint, description, options, response.status),
+      status: response.status,
+      rateLimit
+    };
+  }
+  #parse(text, endpoint, description, options, status) {
+    const where = `${description.method} ${description.path}`;
+    const unreadable = (message, cause) => endpoint.kind === "trade" ? new OrderOutcomeUnknownError(`${where} succeeded (${status}) but ${message}.`, {
+      status,
+      request: description,
+      sent: options.body,
+      body: this.#config.redact(text.slice(0, 2e3)),
+      hint: HINTS.outcomeUnknown,
+      cause
+    }) : new UnexpectedResponseError(`${where} ${message}.`, {
+      status,
+      request: description,
+      body: this.#config.redact(text.slice(0, 2e3)),
+      cause
+    });
+    if (!text.trim()) {
+      if (options.expectBody) throw unreadable("returned an empty body");
+      return void 0;
+    }
+    try {
+      return JSON.parse(text);
+    } catch (error) {
+      throw unreadable("returned a body that is not JSON", error);
+    }
+  }
+  #requestFailure(error, endpoint, description, options, timeout, timeoutMs, mayHaveRun) {
+    const trade = endpoint.kind === "trade";
+    const where = `${description.method} ${description.path}`;
+    if (options.signal?.aborted) {
+      if (trade && mayHaveRun) {
+        return new OrderOutcomeUnknownError(`${where} was aborted after it was sent.`, {
+          request: description,
+          sent: options.body,
+          hint: HINTS.outcomeUnknown,
+          cause: options.signal.reason
+        });
+      }
+      return options.signal.reason;
+    }
+    if (timeout.aborted) {
+      if (trade && mayHaveRun) {
+        return new OrderOutcomeUnknownError(`${where} did not answer within ${timeoutMs} ms.`, {
+          request: description,
+          sent: options.body,
+          hint: HINTS.outcomeUnknown
+        });
+      }
+      return new TimeoutError(`${where} did not answer within ${timeoutMs} ms.`, {
+        request: description,
+        hint: HINTS.timeout(endpoint.kind)
+      });
+    }
+    const code = errorCode(error);
+    const sent = !(code !== void 0 && NOT_SENT.has(code));
+    if (trade && sent && mayHaveRun) {
+      return new OrderOutcomeUnknownError(`${where} lost its connection${code ? ` (${code})` : ""}.`, {
+        request: description,
+        sent: options.body,
+        hint: HINTS.outcomeUnknown,
+        cause: error
+      });
+    }
+    const failure = sent ? "the connection broke" : "could not connect";
+    return new NetworkError(`${where} failed: ${failure}${code ? ` (${code})` : ""}.`, {
+      request: description,
+      sent,
+      hint: HINTS.network(sent, endpoint.kind),
+      cause: error
+    });
+  }
+};
+
+// src/internal/hash.ts
+function fingerprint(value) {
+  let a = 2166136261;
+  let b = 16777619;
+  for (let index = 0; index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    a = Math.imul(a ^ code, 16777619);
+    b = Math.imul(b ^ code, 1540483477) ^ b >>> 15;
+  }
+  return (a >>> 0).toString(16).padStart(8, "0") + (b >>> 0).toString(16).padStart(8, "0");
+}
+
+// src/logging/redact.ts
+var REDACTED = "[REDACTED]";
+var SENSITIVE_KEY = /authorization|secret|password|api[-_]?key|token|cookie|credential/i;
+var BASIC_HEADER = /Basic\s+[A-Za-z0-9+/=]{8,}/g;
+var MAX_DEPTH = 8;
+function createRedactor(secrets) {
+  const removeSecrets = createSecretFilter(secrets);
+  const redactString = (text) => removeSecrets(text.replace(BASIC_HEADER, `Basic ${REDACTED}`));
+  const visit = (value, depth, seen) => {
+    if (typeof value === "string") return redactString(value);
+    if (value === null || typeof value !== "object") return value;
+    if (seen.has(value)) return "[Circular]";
+    if (depth >= MAX_DEPTH) return "[Truncated]";
+    seen.add(value);
+    if (Array.isArray(value)) return value.map((item) => visit(item, depth + 1, seen));
+    const out = {};
+    for (const [key, inner] of Object.entries(value)) {
+      let safe;
+      if (SENSITIVE_KEY.test(key)) safe = REDACTED;
+      else if (key === "downloadLink" && typeof inner === "string") safe = stripQuery(redactString(inner));
+      else safe = visit(inner, depth + 1, seen);
+      Object.defineProperty(out, key, { value: safe, enumerable: true, writable: true, configurable: true });
+    }
+    return out;
+  };
+  return (value) => visit(value, 0, /* @__PURE__ */ new WeakSet());
+}
+function createSecretFilter(secrets) {
+  const needles = [...new Set(secrets.filter((secret) => secret.length >= 4))].sort((a, b) => b.length - a.length);
+  return (text) => {
+    let out = text;
+    for (const needle of needles) out = out.split(needle).join(REDACTED);
+    return out;
+  };
+}
+function stripQuery(url) {
+  const index = url.search(/[?#]/);
+  return index === -1 ? url : `${url.slice(0, index)}?${REDACTED}`;
+}
+
+// src/resources/account.ts
+var AccountResource = class {
+  #context;
+  constructor(context) {
+    this.#context = context;
+  }
+  /**
+   * Cash, invested capital, profit and loss, and total value, in the account's primary currency.
+   *
+   * Scope `account` · 1 request / 5 s.
+   *
+   * @example
+   * const { totalValue, currency } = await t212.account.summary();
+   */
+  async summary(options = {}) {
+    const { data } = await this.#context.transport.request(ENDPOINTS.getAccountSummary, options);
+    return data;
+  }
+};
+
+// src/pagination.ts
+var MAX_LIMIT = 50;
+function checkLimit(limit, field = "limit") {
+  if (limit === void 0) return;
+  if (!Number.isInteger(limit) || limit < 1 || limit > MAX_LIMIT) {
+    throw new ValidationError(`${field} must be a whole number from 1 to ${MAX_LIMIT}.`, {
+      issues: [{ field, message: `must be 1 to ${MAX_LIMIT}` }]
+    });
+  }
+}
+function nextPageQuery(nextPagePath, endpoint, origin) {
+  if (nextPagePath === null || nextPagePath === void 0) return null;
+  const raw = nextPagePath.trim();
+  if (raw === "" || raw === "null" || raw.startsWith("null&") || raw.startsWith("null?")) return null;
+  const absolute = raw.startsWith("/") || /^[a-z][a-z\d+.-]*:/i.test(raw);
+  const relative = absolute ? raw : `${endpoint.path}?${raw.replace(/^\?/, "")}`;
+  let url;
+  try {
+    url = new URL(relative, origin);
+  } catch {
+    throw unsafeNextPage(endpoint);
+  }
+  if (url.origin !== origin || url.pathname !== endpoint.path || raw.startsWith("//") || raw.includes("\\")) {
+    throw unsafeNextPage(endpoint);
+  }
+  const query = url.search.replace(/^\?/, "");
+  return query === "" ? null : query;
+}
+function unsafeNextPage(endpoint) {
+  return new UnexpectedResponseError(
+    `Trading 212 returned a nextPagePath for ${endpoint.id} that points somewhere else; it was not followed.`,
+    { request: { method: endpoint.method, path: endpoint.path, endpoint: endpoint.id } }
+  );
+}
+function cursorQuery(cursor, endpoint, origin) {
+  const query = nextPageQuery(cursor, endpoint, origin);
+  if (query === null || cursor.startsWith("/")) {
+    throw new ValidationError("cursor must be a nextCursor returned by an earlier page.", {
+      issues: [{ field: "cursor", message: "is not a cursor this library produced" }]
+    });
+  }
+  return query;
+}
+var PagedList = class {
+  #transport;
+  #endpoint;
+  constructor(transport, endpoint) {
+    this.#transport = transport;
+    this.#endpoint = endpoint;
+  }
+  async list(options = {}) {
+    const { limit, cursor, signal, timeoutMs, ...filters } = options;
+    checkLimit(limit);
+    const call = { ...signal && { signal }, ...timeoutMs !== void 0 && { timeoutMs } };
+    if (cursor !== void 0) {
+      return this.#fetch(cursorQuery(cursor, this.#endpoint, this.#transport.origin), call);
+    }
+    const query = new URLSearchParams();
+    for (const [key, value] of Object.entries(filters)) {
+      if (value instanceof Date) query.set(key, value.toISOString());
+      else if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+        query.set(key, String(value));
+    }
+    if (limit !== void 0) query.set("limit", String(limit));
+    return this.#fetch(query.toString(), call);
+  }
+  async #fetch(rawQuery, call) {
+    const { data } = await this.#transport.request(this.#endpoint, { ...call, rawQuery });
+    const items = Array.isArray(data?.items) ? data.items : [];
+    const following = nextPageQuery(data?.nextPagePath, this.#endpoint, this.#transport.origin);
+    return {
+      items,
+      nextCursor: following,
+      hasMore: following !== null,
+      next: (options = {}) => following === null ? Promise.resolve(null) : this.#fetch(following, options)
+    };
+  }
+  /**
+   * Every item, newest first, fetching pages as the loop asks for them. If a request fails part-way, the error's
+   * `resumeCursor` says where to carry on.
+   */
+  async *all(options = {}) {
+    const { pageSize = MAX_LIMIT, maxPages, maxItems, ...rest } = options;
+    checkLimit(pageSize, "pageSize");
+    let pages = 0;
+    let yielded = 0;
+    let cursor = rest.cursor;
+    const seen = /* @__PURE__ */ new Set();
+    const call = {
+      ...rest.signal && { signal: rest.signal },
+      ...rest.timeoutMs !== void 0 && { timeoutMs: rest.timeoutMs }
+    };
+    let page;
+    try {
+      page = await this.list({ ...rest, limit: pageSize });
+    } catch (error) {
+      throw attachCursor(error, cursor);
+    }
+    while (page) {
+      pages++;
+      for (const item of page.items) {
+        if (maxItems !== void 0 && yielded >= maxItems) return;
+        yield item;
+        yielded++;
+      }
+      const full = maxPages !== void 0 && pages >= maxPages || maxItems !== void 0 && yielded >= maxItems;
+      if (!page.hasMore || full) return;
+      cursor = page.nextCursor ?? void 0;
+      if (cursor !== void 0) {
+        if (seen.has(cursor)) {
+          throw new UnexpectedResponseError(
+            `Trading 212 returned the same next page of ${this.#endpoint.id} twice; stopped rather than loop.`,
+            { request: { method: this.#endpoint.method, path: this.#endpoint.path, endpoint: this.#endpoint.id } }
+          );
+        }
+        seen.add(cursor);
+      }
+      try {
+        page = await page.next(call);
+      } catch (error) {
+        throw attachCursor(error, cursor);
+      }
+    }
+  }
+};
+function attachCursor(error, cursor) {
+  if (error instanceof Trading212Error && cursor !== void 0) error.resumeCursor = cursor;
+  return error;
+}
+
+// src/resources/history.ts
+var HistoryResource = class {
+  /**
+   * Orders that have finished, with their fills.
+   *
+   * Scope `history:orders` · 20 requests / minute.
+   *
+   * @example
+   * for await (const { order, fill } of t212.history.orders.all({ ticker: "AAPL_US_EQ" })) console.log(order?.status, fill?.price);
+   */
+  orders;
+  /**
+   * Dividends paid out.
+   *
+   * Scope `history:dividends` · 20 requests / minute.
+   */
+  dividends;
+  /**
+   * Deposits, withdrawals, fees, transfers and interest. `time` starts the list from that moment.
+   *
+   * Scope `history:transactions` · 20 requests / minute.
+   */
+  transactions;
+  constructor(context) {
+    this.orders = new PagedList(context.transport, ENDPOINTS.listHistoricalOrders);
+    this.dividends = new PagedList(context.transport, ENDPOINTS.listDividends);
+    this.transactions = new PagedList(context.transport, ENDPOINTS.listTransactions);
+  }
+};
+
+// src/resources/instruments.ts
+function matchScore(instrument, query) {
+  const q = query.toLowerCase();
+  const ticker = instrument.ticker.toLowerCase();
+  const short = instrument.shortName?.toLowerCase() ?? "";
+  const name = instrument.name?.toLowerCase() ?? "";
+  const isin = instrument.isin?.toLowerCase() ?? "";
+  if (ticker === q) return 100;
+  if (isin === q) return 95;
+  if (short === q) return 90;
+  if (ticker.startsWith(`${q}_`)) return 85;
+  if (name === q) return 80;
+  if (name.startsWith(q)) return 60;
+  if (new RegExp(`\\b${q.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`).test(name)) return 50;
+  if (short.startsWith(q) || ticker.startsWith(q)) return 40;
+  if (name.includes(q)) return 30;
+  return 0;
+}
+function hasTicker(instrument) {
+  return typeof instrument.ticker === "string" && instrument.ticker !== "";
+}
+function passesFilters(instrument, options) {
+  if (options.type && instrument.type?.toUpperCase() !== options.type.toUpperCase()) return false;
+  if (options.currency && instrument.currencyCode?.toUpperCase() !== options.currency.toUpperCase()) return false;
+  return true;
+}
+var InstrumentsResource = class {
+  #context;
+  constructor(context) {
+    this.#context = context;
+  }
+  /**
+   * Every instrument the account can trade: about 5 MB, so it is cached (one hour by default) and concurrent callers
+   * share one download.
+   *
+   * Scope `metadata` · 1 request / 50 s.
+   */
+  async list(options = {}) {
+    const { refresh = false, signal } = options;
+    const { cache, cacheNamespace, metadataTtlMs, transport } = this.#context;
+    return cache.load(
+      `${cacheNamespace}:instruments`,
+      { ttlMs: metadataTtlMs, refresh, signal, accept: isList },
+      async () => {
+        const { data } = await transport.request(ENDPOINTS.listInstruments);
+        return Array.isArray(data) ? data.filter(hasTicker) : [];
+      }
+    );
+  }
+  /**
+   * Finds instruments by ticker, ISIN, short name or name, best match first. Searches the cached list, so it costs
+   * no request after the first.
+   *
+   * @example
+   * const [apple] = await t212.instruments.search("Apple", { currency: "USD" });
+   */
+  async search(query, options = {}) {
+    const { limit = 10, type, currency, ...list } = options;
+    const trimmed = query.trim();
+    if (!trimmed)
+      throw new ValidationError("Search for something: the query is empty.", {
+        issues: [{ field: "query", message: "is empty" }]
+      });
+    const filters = { ...type && { type }, ...currency && { currency } };
+    return (await this.list(list)).filter((instrument) => passesFilters(instrument, filters)).map((instrument) => ({ instrument, score: matchScore(instrument, trimmed) })).filter((entry) => entry.score > 0).sort((a, b) => b.score - a.score || a.instrument.ticker.localeCompare(b.instrument.ticker)).slice(0, limit).map((entry) => entry.instrument);
+  }
+  /** The instrument with exactly this Trading 212 ticker, or `undefined`. */
+  async find(ticker, options = {}) {
+    return (await this.list(options)).find((instrument) => instrument.ticker === ticker);
+  }
+  /**
+   * Turns what a person would type (`AAPL`, `Apple`, an ISIN) into exactly one instrument, or throws
+   * `InstrumentNotFoundError` listing the closest matches when none or several fit.
+   *
+   * @example
+   * const apple = await t212.instruments.resolve("AAPL", { currency: "USD" }); // AAPL_US_EQ
+   */
+  async resolve(query, options = {}) {
+    const { type, currency, ...list } = options;
+    const ranked = await this.search(query, {
+      ...list,
+      limit: 10,
+      ...type && { type },
+      ...currency && { currency }
+    });
+    const best = ranked[0];
+    const top = best ? matchScore(best, query.trim()) : 0;
+    const tied = ranked.filter((instrument) => matchScore(instrument, query.trim()) === top);
+    if (best && top >= 80 && tied.length === 1) return best;
+    const suggestions = ranked.slice(0, 5).map((instrument) => ({ ticker: instrument.ticker, name: instrument.name ?? void 0 }));
+    const why = ranked.length === 0 ? "nothing matched" : tied.length > 1 ? `${tied.length} instruments match equally well` : "no instrument matched exactly";
+    throw new InstrumentNotFoundError(`Could not resolve "${query}" to one instrument: ${why}.`, {
+      query,
+      suggestions,
+      hint: suggestions.length > 0 ? `Did you mean ${suggestions.map((suggestion) => suggestion.ticker).join(", ")}? Narrow it with { currency } or { type }, or pass the exact ticker.` : "Check the spelling, or search with instruments.search()."
+    });
+  }
+};
+
+// src/resources/pies.ts
+function checkPieId(id) {
+  if (typeof id !== "number" || !Number.isSafeInteger(id) || id <= 0) {
+    throw new ValidationError("A pie ID must be a positive whole number.", {
+      issues: [{ field: "id", message: "is not a valid pie ID" }]
+    });
+  }
+  return id;
+}
+var PiesResource = class {
+  #context;
+  constructor(context) {
+    this.#context = context;
+  }
+  /** Every pie, with its progress. Scope `pies:read` · 1 request / 30 s. */
+  async list(options = {}) {
+    const { data } = await this.#context.transport.request(
+      ENDPOINTS.listPies,
+      options
+    );
+    return Array.isArray(data) ? data : [];
+  }
+  /** One pie with its instruments and settings. Scope `pies:read` · 1 request / 5 s. */
+  async get(id, options = {}) {
+    const { data } = await this.#context.transport.request(ENDPOINTS.getPie, {
+      ...options,
+      params: { id: checkPieId(id) }
+    });
+    return data;
+  }
+  /** Creates a pie. Scope `pies:write` · 1 request / 5 s. */
+  async create(pie, options = {}) {
+    const { data } = await this.#context.transport.request(
+      ENDPOINTS.createPie,
+      {
+        ...options,
+        body: pie
+      }
+    );
+    return data;
+  }
+  /** Changes a pie's settings or instruments. Scope `pies:write` · 1 request / 5 s. */
+  async update(id, pie, options = {}) {
+    const { data } = await this.#context.transport.request(
+      ENDPOINTS.updatePie,
+      {
+        ...options,
+        params: { id: checkPieId(id) },
+        body: pie
+      }
+    );
+    return data;
+  }
+  /** Deletes a pie. Scope `pies:write` · 1 request / 5 s. */
+  async delete(id, options = {}) {
+    await this.#context.transport.request(ENDPOINTS.deletePie, { ...options, params: { id: checkPieId(id) } });
+  }
+  /** Copies a pie under a new name. Scope `pies:write` · 1 request / 5 s. */
+  async duplicate(id, copy = {}, options = {}) {
+    const { data } = await this.#context.transport.request(
+      ENDPOINTS.duplicatePie,
+      {
+        ...options,
+        params: { id: checkPieId(id) },
+        body: copy
+      }
+    );
+    return data;
+  }
+};
+
+// src/resources/positions.ts
+var PositionsResource = class {
+  #context;
+  constructor(context) {
+    this.#context = context;
+  }
+  /**
+   * Every open position, or just one ticker's.
+   *
+   * Scope `portfolio` · 1 request / 1 s.
+   */
+  async list(options = {}) {
+    const { ticker, ...call } = options;
+    const { data } = await this.#context.transport.request(ENDPOINTS.listPositions, {
+      ...call,
+      query: { ticker }
+    });
+    return Array.isArray(data) ? data : [];
+  }
+  /** One ticker's position, or `undefined` when you hold none. */
+  async get(ticker, options = {}) {
+    const positions = await this.list({ ...options, ticker });
+    return positions.find((position) => position.instrument?.ticker === ticker);
+  }
+};
+
+// src/resources/reports.ts
+var FAILED = /* @__PURE__ */ new Set(["Failed", "Canceled"]);
+function isoDate(value, field) {
+  const date = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    throw new ValidationError(`${field} is not a valid date.`, { issues: [{ field, message: "is not a valid date" }] });
+  }
+  return date.toISOString();
+}
+var ReportsResource = class {
+  #context;
+  constructor(context) {
+    this.#context = context;
+  }
+  /**
+   * Every report you have asked for, with its status and, once finished, its download link.
+   *
+   * 1 request / minute.
+   */
+  async list(options = {}) {
+    const { data } = await this.#context.transport.request(
+      ENDPOINTS.listReports,
+      options
+    );
+    return Array.isArray(data) ? data : [];
+  }
+  /**
+   * Asks Trading 212 to build a CSV report, and returns its ID.
+   *
+   * 1 request / 30 s.
+   */
+  async request(request, options = {}) {
+    const timeFrom = isoDate(request.from, "from");
+    const timeTo = isoDate(request.to, "to");
+    if (timeFrom >= timeTo) {
+      throw new ValidationError("from must be before to.", {
+        issues: [{ field: "from", message: "is not before to" }]
+      });
+    }
+    const include = request.include ?? {};
+    const body = {
+      timeFrom,
+      timeTo,
+      dataIncluded: {
+        includeDividends: include.dividends ?? true,
+        includeInterest: include.interest ?? true,
+        includeOrders: include.orders ?? true,
+        includeTransactions: include.transactions ?? true
+      }
+    };
+    const { data } = await this.#context.transport.request(
+      ENDPOINTS.requestReport,
+      {
+        ...options,
+        body
+      }
+    );
+    if (typeof data?.reportId !== "number") {
+      throw new UnexpectedResponseError("Trading 212 accepted the report request but returned no reportId.", {
+        body: data
+      });
+    }
+    return data.reportId;
+  }
+  /** Checks a report until it is finished, and returns it. Throws if it failed or was cancelled. */
+  async waitFor(reportId, options = {}) {
+    const { timeoutMs: wait, intervalMs: interval, onStatus, ...call } = options;
+    const timeoutMs = durationOption(wait, "timeoutMs") ?? 10 * 6e4;
+    const intervalMs = durationOption(interval, "intervalMs") ?? 6e4;
+    const deadline = Date.now() + timeoutMs;
+    for (; ; ) {
+      const report = (await this.list(call)).find((candidate) => candidate.reportId === reportId);
+      if (report) {
+        onStatus?.(report);
+        if (report.status === "Finished" && report.downloadLink) return report;
+        if (report.status && FAILED.has(report.status)) {
+          throw new UnexpectedResponseError(
+            `Report ${reportId} ${report.status === "Failed" ? "failed" : "was cancelled"}.`,
+            {
+              body: report,
+              hint: "Request it again with reports.request()."
+            }
+          );
+        }
+      }
+      if (Date.now() + intervalMs > deadline) {
+        throw new TimeoutError(`Report ${reportId} was not ready after ${Math.round(timeoutMs / 1e3)} s.`, {
+          hint: "Large reports take a while. Call reports.waitFor() again later; the report keeps building."
+        });
+      }
+      await sleep(intervalMs, call.signal);
+    }
+  }
+  /**
+   * Downloads a finished report's CSV. The link is signed, so your API credentials are never sent with it.
+   */
+  async download(report, options = {}) {
+    const link = typeof report === "string" ? report : report.downloadLink;
+    if (!link)
+      throw new ValidationError("The report has no download link yet.", {
+        issues: [{ field: "downloadLink", message: "is missing" }]
+      });
+    let url;
+    try {
+      url = new URL(link);
+    } catch {
+      throw new ValidationError("The download link is not a valid URL.", {
+        issues: [{ field: "downloadLink", message: "is invalid" }]
+      });
+    }
+    if (url.protocol !== "https:") {
+      throw new ValidationError("The download link is not https.", {
+        issues: [{ field: "downloadLink", message: "must be https" }]
+      });
+    }
+    const timeoutMs = durationOption(options.timeoutMs, "timeoutMs") ?? Math.max(this.#context.timeoutMs, 12e4);
+    const timeout = AbortSignal.timeout(timeoutMs);
+    const signal = options.signal ? AbortSignal.any([options.signal, timeout]) : timeout;
+    const where = stripQuery(url.toString());
+    const failed = (error) => {
+      if (options.signal?.aborted) return options.signal.reason;
+      const name = error instanceof Error ? error.name : "Error";
+      if (timeout.aborted)
+        return new TimeoutError(`Downloading the report from ${where} took longer than ${timeoutMs} ms.`);
+      return new NetworkError(`Could not download the report from ${where} (${name}).`, {
+        sent: true,
+        hint: "Try again: downloading does not change anything."
+      });
+    };
+    let response;
+    try {
+      response = await this.#context.fetch(url.toString(), { method: "GET", signal });
+    } catch (error) {
+      throw failed(error);
+    }
+    if (!response.ok) {
+      throw new UnexpectedResponseError(`Downloading the report from ${where} failed with ${response.status}.`, {
+        status: response.status,
+        hint: "Signed links expire. Fetch a fresh one with reports.list()."
+      });
+    }
+    try {
+      return await response.text();
+    } catch (error) {
+      throw failed(error);
+    }
+  }
+  /**
+   * Requests a report, waits for it and downloads it, in one call. Waiting respects the one-request-a-minute limit,
+   * so expect at least a minute.
+   *
+   * @example
+   * const { csv } = await t212.reports.export({ from: "2026-01-01", to: "2026-06-30" });
+   */
+  async export(request, options = {}) {
+    const call = options.signal ? { signal: options.signal } : {};
+    const reportId = await this.request(request, call);
+    const report = await this.waitFor(reportId, options);
+    return { report, csv: await this.download(report, call) };
+  }
+};
+
+// src/client.ts
+var INSPECT = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+var Trading212 = class _Trading212 {
+  environment;
+  /** Cash and totals. */
+  account;
+  /** Open positions. */
+  positions;
+  /** Everything you can trade, cached, with search and ticker lookup. */
+  instruments;
+  /** Exchanges, their schedules, and whether a market is open. */
+  exchanges;
+  /** Place, inspect, cancel and wait for orders. */
+  orders;
+  /** Past orders, dividends and transactions, paginated. */
+  history;
+  /** CSV exports. */
+  reports;
+  /** The account summary and positions combined. */
+  portfolio;
+  /**
+   * Pies.
+   *
+   * @deprecated Trading 212 has deprecated the pies endpoints; they may be removed.
+   */
+  pies;
+  #transport;
+  constructor(options) {
+    const resolved = resolveOptions(options);
+    const authorization = basicAuthorization(resolved.apiKey, resolved.apiSecret);
+    const secrets = [resolved.apiKey, resolved.apiSecret, authorization.slice("Basic ".length)];
+    const redact = createRedactor(secrets);
+    const logger = safeLogger(options.logger ?? silentLogger, redact);
+    const fetchImpl = options.fetch ?? globalThis.fetch?.bind(globalThis);
+    if (!fetchImpl) {
+      throw new ConfigurationError("No fetch implementation is available.", {
+        field: "fetch",
+        hint: "Use Node 22 or later, Bun or Deno, or pass one as the fetch option."
+      });
+    }
+    if (!resolved.officialOrigin) {
+      logger.warn(`Requests go to ${resolved.origin}, which is not Trading 212's ${resolved.environment} host.`, {
+        origin: resolved.origin
+      });
+    }
+    const accountKey = fingerprint(`${resolved.environment}\0${resolved.origin}\0${resolved.apiKey}`);
+    this.environment = resolved.environment;
+    this.#transport = new Transport({
+      environment: resolved.environment,
+      origin: resolved.origin,
+      authorization,
+      fetch: fetchImpl,
+      timeoutMs: resolved.timeoutMs,
+      retry: resolved.retry,
+      rateLimiter: new RateLimiter(accountKey, resolved.rateLimit),
+      maxRateLimitWaitMs: resolved.maxRateLimitWaitMs,
+      logger,
+      hooks: options.hooks ?? {},
+      redact,
+      removeSecrets: createSecretFilter(secrets),
+      userAgent: `trading212.js/${VERSION}${options.userAgent ? ` ${options.userAgent}` : ""}`,
+      trading: resolved.trading
+    });
+    const context = {
+      transport: this.#transport,
+      cache: new CachedLoader(options.cache ?? new MemoryCache(), (error, key) => {
+        logger.warn(`The cache store failed for the ${key.split(":").pop() ?? "metadata"} list, so it was bypassed.`, {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }),
+      cacheNamespace: accountKey,
+      metadataTtlMs: resolved.metadataTtlMs,
+      fetch: fetchImpl,
+      timeoutMs: resolved.timeoutMs
+    };
+    this.account = new AccountResource(context);
+    this.positions = new PositionsResource(context);
+    this.instruments = new InstrumentsResource(context);
+    this.exchanges = new ExchangesResource(context, this.instruments);
+    this.history = new HistoryResource(context);
+    this.orders = new OrdersResource(context, this.positions, this.history.orders);
+    this.reports = new ReportsResource(context);
+    this.portfolio = new PortfolioResource(this.account, this.positions);
+    this.pies = new PiesResource(context);
+  }
+  /**
+   * Builds a client from `T212_ENV`, `T212_API_KEY` and `T212_API_SECRET` (or `T212_DEMO_*` / `T212_LIVE_*`).
+   * `overrides` sets any other option.
+   *
+   * @example
+   * const t212 = Trading212.fromEnv({ logger: consoleLogger() });
+   */
+  static fromEnv(overrides = {}, env) {
+    return new _Trading212({ ...optionsFromEnv(env), ...overrides });
+  }
+  /** Whether this client may place or cancel orders and change pies. */
+  get trading() {
+    return this.#transport.tradingEnabled ? "enabled" : "disabled";
+  }
+  /**
+   * Checks the key works, with one request, and says which account it belongs to. A wrong key or environment fails
+   * here with an `AuthenticationError` that explains which.
+   */
+  async verify(options = {}) {
+    const summary = await this.account.summary(options);
+    return {
+      environment: this.environment,
+      accountId: summary.id ?? void 0,
+      currency: summary.currency ?? void 0,
+      trading: this.trading
+    };
+  }
+  /** What is known about every endpoint's rate-limit budget, shared by every client using this key. */
+  rateLimits() {
+    return this.#transport.rateLimitSnapshot();
+  }
+  toJSON() {
+    return { environment: this.environment, trading: this.trading, origin: this.#transport.origin };
+  }
+  [INSPECT]() {
+    return `Trading212 { environment: '${this.environment}', trading: '${this.trading}' }`;
+  }
+};
+
+exports.AuthenticationError = AuthenticationError;
+exports.BASE_URLS = BASE_URLS;
+exports.ConfigurationError = ConfigurationError;
+exports.ENDPOINTS = ENDPOINTS;
+exports.FINAL_ORDER_STATUSES = FINAL_ORDER_STATUSES;
+exports.HttpError = HttpError;
+exports.InstrumentNotFoundError = InstrumentNotFoundError;
+exports.MemoryCache = MemoryCache;
+exports.MissingScopeError = MissingScopeError;
+exports.NetworkError = NetworkError;
+exports.NotAvailableInDemoError = NotAvailableInDemoError;
+exports.NotFoundError = NotFoundError;
+exports.OrderOutcomeUnknownError = OrderOutcomeUnknownError;
+exports.OrderRejectedError = OrderRejectedError;
+exports.PermissionError = PermissionError;
+exports.QUANTITY_DECIMALS = QUANTITY_DECIMALS;
+exports.REDACTED = REDACTED;
+exports.RateLimitError = RateLimitError;
+exports.SPEC_VERSION = SPEC_VERSION;
+exports.ServerError = ServerError;
+exports.TIME_VALIDITIES = TIME_VALIDITIES;
+exports.TimeoutError = TimeoutError;
+exports.Trading212 = Trading212;
+exports.Trading212Error = Trading212Error;
+exports.TradingDisabledError = TradingDisabledError;
+exports.UnexpectedResponseError = UnexpectedResponseError;
+exports.VERSION = VERSION;
+exports.ValidationError = ValidationError;
+exports.buildPortfolioSnapshot = buildPortfolioSnapshot;
+exports.consoleLogger = consoleLogger;
+exports.decimalPlaces = decimalPlaces;
+exports.fieldsFirst = fieldsFirst;
+exports.isTrading212Error = isTrading212Error;
+exports.isValidQuantity = isValidQuantity;
+exports.parseErrorBody = parseErrorBody;
+exports.sessionAt = sessionAt;
+exports.silentLogger = silentLogger;
+exports.truncateQuantity = truncateQuantity;