gloomberb 0.5.0 → 0.6.0

package/src/architecture/import-boundaries.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, test } from "bun:test";
+import { readdir } from "fs/promises";
+import { join, relative } from "path";
+
+const SOURCE_ROOT = join(process.cwd(), "src");
+const RUNTIME_EXTENSIONS = new Set([".ts", ".tsx"]);
+const IMPORT_PATTERN = /\b(?:import|export)\s+(?:[^'"]*?\s+from\s+)?["']([^"']+)["']|import\(["']([^"']+)["']\)/g;
+const OPENTUI_JSX_PATTERN = /<\s*\/?\s*(box|text|scrollbox|input|textarea|span|strong|u)(?=[\s>/])/g;
+
+function isRuntimeSource(path: string): boolean {
+  if (path.includes(".test.")) return false;
+  if (path.includes("test-helpers.")) return false;
+  if (path.includes("__snapshots__")) return false;
+  for (const extension of RUNTIME_EXTENSIONS) {
+    if (path.endsWith(extension)) return true;
+  }
+  return false;
+}
+
+async function collectSourceFiles(dir: string, result: string[] = []): Promise<string[]> {
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const path = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await collectSourceFiles(path, result);
+      continue;
+    }
+    if (entry.isFile() && isRuntimeSource(path)) {
+      result.push(path);
+    }
+  }
+  return result;
+}
+
+async function collectImports(): Promise<Array<{ file: string; specifier: string }>> {
+  const files = await collectSourceFiles(SOURCE_ROOT);
+  const imports: Array<{ file: string; specifier: string }> = [];
+  for (const file of files) {
+    const source = await Bun.file(file).text();
+    for (const match of source.matchAll(IMPORT_PATTERN)) {
+      imports.push({
+        file: relative(process.cwd(), file),
+        specifier: match[1] ?? match[2] ?? "",
+      });
+    }
+  }
+  return imports;
+}
+
+describe("import boundaries", () => {
+  test("external renderer packages stay in renderer adapters", async () => {
+    const imports = await collectImports();
+    const violations = imports.filter(({ file, specifier }) => {
+      if (specifier.startsWith("@opentui/") || specifier.startsWith("@opentui-ui/")) {
+        return !file.startsWith("src/renderers/opentui/");
+      }
+      if (specifier.startsWith("#opentui/")) {
+        return true;
+      }
+      if (specifier.startsWith("electrobun/")) {
+        return !file.startsWith("src/renderers/electrobun/");
+      }
+      if (specifier === "react-dom" || specifier.startsWith("react-dom/")) {
+        return !file.startsWith("src/renderers/electrobun/");
+      }
+      return false;
+    });
+
+    expect(violations).toEqual([]);
+  });
+
+  test("core and shared react layers do not import renderer packages directly", async () => {
+    const imports = await collectImports();
+    const violations = imports.filter(({ file, specifier }) => {
+      if (!file.startsWith("src/core/") && !file.startsWith("src/react/")) return false;
+      return (
+        specifier.startsWith("@opentui/")
+        || specifier.startsWith("@opentui-ui/")
+        || specifier.startsWith("#opentui/")
+        || specifier.startsWith("electrobun/")
+        || specifier === "react-dom"
+        || specifier.startsWith("react-dom/")
+      );
+    });
+
+    expect(violations).toEqual([]);
+  });
+
+  test("core state stays out of React app context", async () => {
+    const imports = await collectImports();
+    const violations = imports.filter(({ file, specifier }) => {
+      if (!file.startsWith("src/core/")) return false;
+      return specifier === "react"
+        || specifier.startsWith("react/")
+        || specifier.includes("/state/app-context")
+        || specifier.endsWith("/state/app-context");
+    });
+
+    expect(violations).toEqual([]);
+  });
+
+  test("shared runtime code uses Gloom UI components instead of OpenTUI intrinsic tags", async () => {
+    const files = await collectSourceFiles(SOURCE_ROOT);
+    const violations: Array<{ file: string; tag: string }> = [];
+
+    for (const file of files) {
+      const relativeFile = relative(process.cwd(), file);
+      if (relativeFile.startsWith("src/renderers/")) continue;
+
+      const source = await Bun.file(file).text();
+      for (const match of source.matchAll(OPENTUI_JSX_PATTERN)) {
+        violations.push({ file: relativeFile, tag: match[1] ?? "" });
+      }
+    }
+
+    expect(violations).toEqual([]);
+  });
+});

package/src/assets/gloomberb-logo.svg

@@ -0,0 +1,73 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="512" height="512" viewBox="0 0 512 512" role="img" aria-labelledby="title desc">
+  <title id="title">Gloomberb candlestick logo</title>
+  <desc id="desc">Three rounded candlesticks on a dark square background.</desc>
+  <defs>
+    <linearGradient id="greenBody" x1="143.5" y1="173" x2="206.5" y2="323" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#bdff34"/>
+      <stop offset="0.58" stop-color="#8ff014"/>
+      <stop offset="1" stop-color="#5fd60d"/>
+    </linearGradient>
+    <linearGradient id="greenWick" x1="168" y1="130" x2="182" y2="366" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#c8ff3f"/>
+      <stop offset="1" stop-color="#67df12"/>
+    </linearGradient>
+    <linearGradient id="whiteBody" x1="220.9" y1="149" x2="291.1" y2="347" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#ffffff"/>
+      <stop offset="0.62" stop-color="#f3f3f0"/>
+      <stop offset="1" stop-color="#dfdfda"/>
+    </linearGradient>
+    <linearGradient id="whiteWick" x1="249" y1="106" x2="263" y2="390" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#ffffff"/>
+      <stop offset="1" stop-color="#e5e5e1"/>
+    </linearGradient>
+    <linearGradient id="redBody" x1="305.5" y1="173" x2="368.5" y2="323" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#ff5f66"/>
+      <stop offset="0.55" stop-color="#ff2631"/>
+      <stop offset="1" stop-color="#ff1421"/>
+    </linearGradient>
+    <linearGradient id="redWick" x1="330" y1="130" x2="344" y2="366" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#ff686e"/>
+      <stop offset="1" stop-color="#ff1421"/>
+    </linearGradient>
+  </defs>
+
+  <rect width="512" height="512" fill="#252628"/>
+
+  <g transform="translate(256 248) scale(1.15) translate(-256 -248)">
+    <g fill="#000000">
+      <g opacity="0.035">
+        <rect x="173" y="140" width="22" height="246" rx="11"/>
+        <rect x="146.2" y="181" width="75.6" height="164" rx="13"/>
+        <rect x="254" y="116" width="22" height="294" rx="11"/>
+        <rect x="223.6" y="157" width="82.8" height="212" rx="13"/>
+        <rect x="335" y="140" width="22" height="246" rx="11"/>
+        <rect x="308.2" y="181" width="75.6" height="164" rx="13"/>
+      </g>
+      <g opacity="0.06">
+        <rect x="173" y="138" width="18" height="242" rx="9"/>
+        <rect x="146.9" y="180" width="70.2" height="160" rx="11"/>
+        <rect x="254" y="114" width="18" height="290" rx="9"/>
+        <rect x="224.3" y="156" width="77.4" height="206" rx="11"/>
+        <rect x="335" y="138" width="18" height="242" rx="9"/>
+        <rect x="308.9" y="180" width="70.2" height="160" rx="11"/>
+      </g>
+      <g opacity="0.08">
+        <rect x="172" y="137" width="14" height="236" rx="7"/>
+        <rect x="147.5" y="180" width="63" height="150" rx="8"/>
+        <rect x="253" y="113" width="14" height="284" rx="7"/>
+        <rect x="224.9" y="156" width="70.2" height="198" rx="8"/>
+        <rect x="334" y="137" width="14" height="236" rx="7"/>
+        <rect x="309.5" y="180" width="63" height="150" rx="8"/>
+      </g>
+    </g>
+
+    <g>
+      <rect x="168" y="130" width="14" height="236" rx="7" fill="url(#greenWick)"/>
+      <rect x="143.5" y="173" width="63" height="150" rx="8" fill="url(#greenBody)"/>
+      <rect x="249" y="106" width="14" height="284" rx="7" fill="url(#whiteWick)"/>
+      <rect x="220.9" y="149" width="70.2" height="198" rx="8" fill="url(#whiteBody)"/>
+      <rect x="330" y="130" width="14" height="236" rx="7" fill="url(#redWick)"/>
+      <rect x="305.5" y="173" width="63" height="150" rx="8" fill="url(#redBody)"/>
+    </g>
+  </g>
+</svg>

package/src/brokers/account-cache.ts

@@ -0,0 +1,157 @@
+import type { ResourceStore } from "../data/resource-store";
+import type { BrokerAdapter } from "../types/broker";
+import type { BrokerInstanceConfig } from "../types/config";
+import type { CachePolicy } from "../types/persistence";
+import type { BrokerAccount } from "../types/trading";
+
+const BROKER_ACCOUNT_SNAPSHOT_KIND = "account-snapshot";
+const BROKER_ACCOUNT_SNAPSHOT_SCHEMA_VERSION = 1;
+const DEFAULT_BROKER_ACCOUNT_CACHE_POLICY = {
+  staleMs: 6 * 60 * 60 * 1000,
+  expireMs: 30 * 24 * 60 * 60 * 1000,
+} as const satisfies CachePolicy;
+
+interface PersistedBrokerAccountSnapshot {
+  accounts: BrokerAccount[];
+  brokerType?: string;
+}
+
+function hashString(input: string): string {
+  let hash = 0x811c9dc5;
+  for (let index = 0; index < input.length; index += 1) {
+    hash ^= input.charCodeAt(index);
+    hash = Math.imul(hash, 0x01000193);
+  }
+  return `fnv1a:${(hash >>> 0).toString(16).padStart(8, "0")}`;
+}
+
+function brokerAccountNamespace(instance: BrokerInstanceConfig): string {
+  return `plugin:${instance.brokerType}`;
+}
+
+export function getBrokerAccountCacheSourceKey(
+  instance: BrokerInstanceConfig,
+  broker?: BrokerAdapter | null,
+): string {
+  if (broker?.getAccountCacheSourceKey) {
+    return broker.getAccountCacheSourceKey(instance);
+  }
+  return hashString(JSON.stringify({
+    brokerType: instance.brokerType,
+    config: broker?.toConfigValues?.(instance) ?? instance.config,
+  }));
+}
+
+function getBrokerAccountCachePolicy(
+  instance: BrokerInstanceConfig,
+  broker?: BrokerAdapter | null,
+): CachePolicy {
+  return broker?.getAccountCachePolicy?.(instance) ?? DEFAULT_BROKER_ACCOUNT_CACHE_POLICY;
+}
+
+function pruneMismatchedSnapshots(
+  resources: ResourceStore,
+  instance: BrokerInstanceConfig,
+  sourceKey: string,
+): void {
+  const records = resources.list<PersistedBrokerAccountSnapshot>({
+    namespace: brokerAccountNamespace(instance),
+    kind: BROKER_ACCOUNT_SNAPSHOT_KIND,
+    entityKey: instance.id,
+  }, {
+    schemaVersion: BROKER_ACCOUNT_SNAPSHOT_SCHEMA_VERSION,
+    allowExpired: true,
+  });
+
+  for (const record of records) {
+    if (record.sourceKey === sourceKey) continue;
+    resources.delete({
+      namespace: brokerAccountNamespace(instance),
+      kind: BROKER_ACCOUNT_SNAPSHOT_KIND,
+      entityKey: instance.id,
+      sourceKey: record.sourceKey,
+    });
+  }
+}
+
+export function loadPersistedBrokerAccounts(
+  resources: ResourceStore,
+  instance: BrokerInstanceConfig,
+  broker?: BrokerAdapter | null,
+): BrokerAccount[] | null {
+  const sourceKey = getBrokerAccountCacheSourceKey(instance, broker);
+  pruneMismatchedSnapshots(resources, instance, sourceKey);
+
+  return resources.get<PersistedBrokerAccountSnapshot>({
+    namespace: brokerAccountNamespace(instance),
+    kind: BROKER_ACCOUNT_SNAPSHOT_KIND,
+    entityKey: instance.id,
+    sourceKey,
+  }, {
+    schemaVersion: BROKER_ACCOUNT_SNAPSHOT_SCHEMA_VERSION,
+  })?.value.accounts ?? null;
+}
+
+export function persistBrokerAccounts(
+  resources: ResourceStore,
+  instance: BrokerInstanceConfig,
+  broker: BrokerAdapter,
+  accounts: BrokerAccount[],
+): void {
+  const sourceKey = getBrokerAccountCacheSourceKey(instance, broker);
+  pruneMismatchedSnapshots(resources, instance, sourceKey);
+
+  resources.set<PersistedBrokerAccountSnapshot>({
+    namespace: brokerAccountNamespace(instance),
+    kind: BROKER_ACCOUNT_SNAPSHOT_KIND,
+    entityKey: instance.id,
+    sourceKey,
+  }, {
+    brokerType: instance.brokerType,
+    accounts,
+  }, {
+    schemaVersion: BROKER_ACCOUNT_SNAPSHOT_SCHEMA_VERSION,
+    cachePolicy: getBrokerAccountCachePolicy(instance, broker),
+  });
+}
+
+export function loadPersistedBrokerAccountMap(
+  resources: ResourceStore,
+  brokerInstances: BrokerInstanceConfig[],
+  brokers: ReadonlyMap<string, BrokerAdapter>,
+): Record<string, BrokerAccount[]> {
+  const accountMap: Record<string, BrokerAccount[]> = {};
+
+  for (const instance of brokerInstances) {
+    const broker = brokers.get(instance.brokerType);
+    if (!broker?.listAccounts) continue;
+    const accounts = loadPersistedBrokerAccounts(resources, instance, broker);
+    if (!accounts || accounts.length === 0) continue;
+    accountMap[instance.id] = accounts;
+  }
+
+  return accountMap;
+}
+
+export function clearPersistedBrokerAccounts(
+  resources: ResourceStore,
+  instance: BrokerInstanceConfig,
+): void {
+  const records = resources.list<PersistedBrokerAccountSnapshot>({
+    namespace: brokerAccountNamespace(instance),
+    kind: BROKER_ACCOUNT_SNAPSHOT_KIND,
+    entityKey: instance.id,
+  }, {
+    schemaVersion: BROKER_ACCOUNT_SNAPSHOT_SCHEMA_VERSION,
+    allowExpired: true,
+  });
+
+  for (const record of records) {
+    resources.delete({
+      namespace: brokerAccountNamespace(instance),
+      kind: BROKER_ACCOUNT_SNAPSHOT_KIND,
+      entityKey: instance.id,
+      sourceKey: record.sourceKey,
+    });
+  }
+}

package/src/brokers/profile-form.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, test } from "bun:test";
+import type { BrokerAdapter } from "../types/broker";
+import type { BrokerInstanceConfig } from "../types/config";
+import { ibkrBroker } from "../plugins/ibkr/broker-adapter";
+import {
+  buildBrokerProfileConfig,
+  createBrokerProfileDraft,
+  validateBrokerProfileValues,
+} from "./profile-form";
+
+function createFlexInstance(): BrokerInstanceConfig {
+  return {
+    id: "ibkr-flex",
+    brokerType: "ibkr",
+    label: "IBKR Flex",
+    connectionMode: "flex",
+    config: {
+      connectionMode: "flex",
+      gatewaySetupMode: "auto",
+      flex: { token: "saved-token", queryId: "123", endpoint: "https://example.test/flex" },
+      gateway: { host: "127.0.0.1", marketDataType: "auto" },
+    },
+    enabled: true,
+  };
+}
+
+describe("broker profile form helpers", () => {
+  test("builds canonical IBKR Flex config from flat values", () => {
+    const config = buildBrokerProfileConfig(ibkrBroker, {
+      connectionMode: "flex",
+      token: "token",
+      queryId: "456",
+      endpoint: "",
+      gatewaySetupMode: "auto",
+    });
+
+    expect(config).toMatchObject({
+      connectionMode: "flex",
+      flex: { token: "token", queryId: "456" },
+    });
+  });
+
+  test("preserves saved password fields when editing leaves them blank", () => {
+    const previous = createFlexInstance();
+    const draft = createBrokerProfileDraft(ibkrBroker, previous);
+    draft.values.token = "";
+
+    expect(validateBrokerProfileValues(ibkrBroker, draft.values, previous)).toBeNull();
+    expect(buildBrokerProfileConfig(ibkrBroker, draft.values, previous)).toMatchObject({
+      flex: { token: "saved-token" },
+    });
+  });
+
+  test("requires password fields for new profiles", () => {
+    expect(validateBrokerProfileValues(ibkrBroker, {
+      connectionMode: "flex",
+      token: "",
+      queryId: "123",
+    })).toBe("Flex Token is required.");
+  });
+
+  test("falls back to raw values for generic brokers", () => {
+    const adapter: BrokerAdapter = {
+      id: "demo",
+      name: "Demo",
+      configSchema: [{ key: "apiKey", label: "API Key", type: "password", required: true }],
+      validate: async () => true,
+      importPositions: async () => [],
+    };
+
+    expect(buildBrokerProfileConfig(adapter, { apiKey: "secret" })).toEqual({ apiKey: "secret" });
+  });
+});

package/src/brokers/profile-form.ts

@@ -0,0 +1,109 @@
+import type { BrokerAdapter, BrokerConfigField } from "../types/broker";
+import type { BrokerInstanceConfig } from "../types/config";
+import { resolveBrokerConfigFields } from "../types/broker";
+
+export interface BrokerProfileDraft {
+  label: string;
+  enabled: boolean;
+  values: Record<string, string>;
+}
+
+export const PRESERVED_PASSWORD_HINT = "Saved; leave blank to keep";
+
+function fieldDefaultValue(field: BrokerConfigField): string {
+  if (field.defaultValue != null) return field.defaultValue;
+  if (field.type === "select" && field.options?.[0]?.value) return field.options[0].value;
+  return "";
+}
+
+function normalizeFormValue(value: unknown): string {
+  if (value == null) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return "";
+}
+
+export function flattenBrokerConfigValues(
+  adapter: BrokerAdapter,
+  instance?: BrokerInstanceConfig,
+): Record<string, string> {
+  const raw = instance
+    ? adapter.toConfigValues?.(instance) ?? instance.config
+    : {};
+  const values: Record<string, string> = {};
+
+  for (const field of adapter.configSchema) {
+    values[field.key] = normalizeFormValue(raw[field.key] ?? fieldDefaultValue(field));
+  }
+
+  return values;
+}
+
+export function createBrokerProfileDraft(
+  adapter: BrokerAdapter,
+  instance?: BrokerInstanceConfig,
+): BrokerProfileDraft {
+  return {
+    label: instance?.label || adapter.name,
+    enabled: instance?.enabled !== false,
+    values: flattenBrokerConfigValues(adapter, instance),
+  };
+}
+
+export function getVisibleBrokerConfigFields(
+  adapter: BrokerAdapter,
+  values: Record<string, unknown>,
+): BrokerConfigField[] {
+  return resolveBrokerConfigFields(adapter, values);
+}
+
+function getPreviousPasswordValue(
+  adapter: BrokerAdapter,
+  previous: BrokerInstanceConfig | undefined,
+  key: string,
+): string {
+  if (!previous) return "";
+  return normalizeFormValue((adapter.toConfigValues?.(previous) ?? previous.config)[key]);
+}
+
+export function withPreservedBrokerPasswords(
+  adapter: BrokerAdapter,
+  values: Record<string, string>,
+  previous?: BrokerInstanceConfig,
+): Record<string, string> {
+  const next = { ...values };
+  if (!previous) return next;
+
+  for (const field of adapter.configSchema) {
+    if (field.type !== "password") continue;
+    if (next[field.key]?.trim()) continue;
+    const previousValue = getPreviousPasswordValue(adapter, previous, field.key);
+    if (previousValue) next[field.key] = previousValue;
+  }
+
+  return next;
+}
+
+export function validateBrokerProfileValues(
+  adapter: BrokerAdapter,
+  values: Record<string, string>,
+  previous?: BrokerInstanceConfig,
+): string | null {
+  const resolvedValues = withPreservedBrokerPasswords(adapter, values, previous);
+  for (const field of getVisibleBrokerConfigFields(adapter, resolvedValues)) {
+    if (!field.required) continue;
+    if (!normalizeFormValue(resolvedValues[field.key]).trim()) {
+      return `${field.label} is required.`;
+    }
+  }
+  return null;
+}
+
+export function buildBrokerProfileConfig(
+  adapter: BrokerAdapter,
+  values: Record<string, string>,
+  previous?: BrokerInstanceConfig,
+): Record<string, unknown> {
+  const resolvedValues = withPreservedBrokerPasswords(adapter, values, previous);
+  return adapter.fromConfigValues?.(resolvedValues, previous) ?? resolvedValues;
+}

package/src/brokers/remote-broker-adapter.ts

@@ -0,0 +1,91 @@
+import type { TimeRange } from "../components/chart/chart-types";
+import type { ManualChartResolution } from "../components/chart/chart-resolution";
+import type { BrokerAdapter, BrokerConnectionStatus } from "../types/broker";
+import type { BrokerInstanceConfig } from "../types/config";
+import type { QuoteSubscriptionTarget } from "../types/data-provider";
+import type { BrokerContractRef } from "../types/instrument";
+import type { BrokerOrderRequest } from "../types/trading";
+
+export interface BrokerRemoteClient {
+  invoke<T = unknown>(instanceId: string, operation: string, args?: unknown[]): Promise<T>;
+  getStatus(instanceId: string): BrokerConnectionStatus | null;
+  subscribeStatus(instanceId: string, listener: () => void): () => void;
+  subscribeQuotes(
+    instanceId: string,
+    targets: QuoteSubscriptionTarget[],
+    onQuote: (target: QuoteSubscriptionTarget, quote: any) => void,
+  ): () => void;
+  removeInstance(instanceId: string): Promise<void>;
+  destroyAll(): Promise<void>;
+}
+
+let brokerRemoteClient: BrokerRemoteClient | null = null;
+
+export function setBrokerRemoteClient(client: BrokerRemoteClient | null): void {
+  brokerRemoteClient = client;
+}
+
+export function getBrokerRemoteClient(): BrokerRemoteClient | null {
+  return brokerRemoteClient;
+}
+
+function disconnectedStatus(): BrokerConnectionStatus {
+  return { state: "disconnected", updatedAt: 0 };
+}
+
+export function createRemoteBrokerAdapter(adapter: BrokerAdapter): BrokerAdapter {
+  const invoke = <T,>(instance: BrokerInstanceConfig, operation: string, args: unknown[] = []) => {
+    const client = getBrokerRemoteClient();
+    if (!client) throw new Error("Broker remote host is not available.");
+    return client.invoke<T>(instance.id, operation, args);
+  };
+
+  return {
+    ...adapter,
+    validate: (instance) => invoke<boolean>(instance, "validate"),
+    importPositions: (instance) => invoke(instance, "importPositions"),
+    connect: (instance) => invoke<void>(instance, "connect"),
+    disconnect: (instance) => invoke<void>(instance, "disconnect"),
+    getStatus: (instance) => getBrokerRemoteClient()?.getStatus(instance.id) ?? adapter.getStatus?.(instance) ?? disconnectedStatus(),
+    subscribeStatus: (instance, listener) => getBrokerRemoteClient()?.subscribeStatus(instance.id, listener) ?? (() => {}),
+    getPersistedConfigUpdate: (instance) => invoke<Record<string, unknown> | null>(instance, "getPersistedConfigUpdate"),
+    listAccounts: (instance) => invoke(instance, "listAccounts"),
+    searchInstruments: (query, instance) => invoke(instance, "searchInstruments", [query]),
+    getTickerFinancials: (ticker, instance, exchange?: string, instrument?: BrokerContractRef | null) =>
+      invoke(instance, "getTickerFinancials", [ticker, exchange, instrument]),
+    getQuote: (ticker, instance, exchange?: string, instrument?: BrokerContractRef | null) =>
+      invoke(instance, "getQuote", [ticker, exchange, instrument]),
+    getPriceHistory: (ticker, instance, exchange: string, range: TimeRange, instrument?: BrokerContractRef | null) =>
+      invoke(instance, "getPriceHistory", [ticker, exchange, range, instrument]),
+    getPriceHistoryForResolution: (
+      ticker,
+      instance,
+      exchange: string,
+      bufferRange: TimeRange,
+      resolution: ManualChartResolution,
+      instrument?: BrokerContractRef | null,
+    ) => invoke(instance, "getPriceHistoryForResolution", [ticker, exchange, bufferRange, resolution, instrument]),
+    getDetailedPriceHistory: (
+      ticker,
+      instance,
+      exchange: string,
+      startDate: Date,
+      endDate: Date,
+      barSize: string,
+      instrument?: BrokerContractRef | null,
+    ) => invoke(instance, "getDetailedPriceHistory", [ticker, exchange, startDate, endDate, barSize, instrument]),
+    getChartResolutionSupport: (ticker, instance, exchange?: string, instrument?: BrokerContractRef | null) =>
+      invoke(instance, "getChartResolutionSupport", [ticker, exchange, instrument]),
+    getChartResolutionCapabilities: (ticker, instance, exchange?: string, instrument?: BrokerContractRef | null) =>
+      invoke(instance, "getChartResolutionCapabilities", [ticker, exchange, instrument]),
+    getOptionsChain: (ticker, instance, exchange?: string, expirationDate?: number, instrument?: BrokerContractRef | null) =>
+      invoke(instance, "getOptionsChain", [ticker, exchange, expirationDate, instrument]),
+    subscribeQuotes: (instance, targets, onQuote) => getBrokerRemoteClient()?.subscribeQuotes(instance.id, targets, onQuote) ?? (() => {}),
+    listOpenOrders: (instance) => invoke(instance, "listOpenOrders"),
+    listExecutions: (instance) => invoke(instance, "listExecutions"),
+    previewOrder: (instance, request: BrokerOrderRequest) => invoke(instance, "previewOrder", [request]),
+    placeOrder: (instance, request: BrokerOrderRequest) => invoke(instance, "placeOrder", [request]),
+    modifyOrder: (instance, orderId: number, request: BrokerOrderRequest) => invoke(instance, "modifyOrder", [orderId, request]),
+    cancelOrder: (instance, orderId: number) => invoke<void>(instance, "cancelOrder", [orderId]),
+  };
+}