gloomberb 0.11.2 → 0.12.0

package/src/market-data/coordinator/quotes.ts

@@ -19,6 +19,21 @@ import {
 
 export type QuoteSubscriptionPriority = Pick<QuoteSubscriptionTarget, "route" | "surface" | "visible" | "selected" | "weight">;
 
+export interface QuoteSubscriptionRequest {
+  instrument: InstrumentRef;
+  priority?: QuoteSubscriptionPriority;
+}
+
+/**
+ * Remains callable for compatibility with the original disposer API. Updating
+ * the handle lets long-lived consumers change priorities without unregistering
+ * their whole target set first.
+ */
+export interface QuoteSubscriptionHandle {
+  (): void;
+  update(targets: QuoteSubscriptionRequest[]): void;
+}
+
 export interface QuoteSubscriptionEntry {
   target: QuoteSubscriptionTarget;
   targets: Map<number, QuoteSubscriptionTarget>;
@@ -30,7 +45,8 @@ interface PendingStreamQuote {
   quote: Quote;
 }
 
-const QUOTE_SUBSCRIPTION_REMOVE_GRACE_MS = 250;
+export const QUOTE_SUBSCRIPTION_REMOVE_GRACE_MS = 250;
+export const QUOTE_SUBSCRIPTION_PRIORITY_UPDATE_DELAY_MS = 100;
 
 const STREAM_QUOTE_FIELDS: Array<keyof Quote> = [
   "symbol",
@@ -198,101 +214,192 @@ export class QuoteSubscriptionManager {
   private readonly pendingStreamQuotes = new Map<string, PendingStreamQuote>();
   private lastStreamQuoteBatchAppliedAt: number | null = null;
   private pendingStreamQuoteTimer: ReturnType<typeof setTimeout> | null = null;
+  private pendingPriorityUpdateTimer: ReturnType<typeof setTimeout> | null = null;
   private nextQuoteSubscriptionId = 1;
   private quoteSubscriptionDispose: (() => void) | null = null;
   private quoteSubscriptionSignature = "";
+  private quoteSubscriptionRoutingSignature = "";
 
   constructor(
     private readonly dataProvider: DataProvider,
     private readonly applyQuote: (instrument: InstrumentRef, quote: Quote) => void,
   ) {}
 
-  subscribe(targets: Array<{ instrument: InstrumentRef; priority?: QuoteSubscriptionPriority }>): () => void {
-    if (!this.dataProvider.subscribeQuotes || targets.length === 0) {
-      return () => {};
+  subscribe(targets: QuoteSubscriptionRequest[]): QuoteSubscriptionHandle {
+    if (!this.dataProvider.subscribeQuotes) {
+      return this.createNoopSubscription();
     }
 
     const subscriptionId = this.nextQuoteSubscriptionId++;
-    const subscribedKeys = new Set<string>();
+    let subscribedKeys = new Set<string>();
+    let disposed = false;
+    const update = (nextTargets: QuoteSubscriptionRequest[]) => {
+      if (disposed) return;
+      subscribedKeys = this.updateSubscriptionTargets(subscriptionId, subscribedKeys, nextTargets);
+    };
+    const dispose = (() => {
+      if (disposed) return;
+      disposed = true;
+      subscribedKeys = this.updateSubscriptionTargets(subscriptionId, subscribedKeys, []);
+    }) as QuoteSubscriptionHandle;
+    dispose.update = update;
+    update(targets);
+    return dispose;
+  }
+
+  private createNoopSubscription(): QuoteSubscriptionHandle {
+    const dispose = (() => {}) as QuoteSubscriptionHandle;
+    dispose.update = () => {};
+    return dispose;
+  }
+
+  private updateSubscriptionTargets(
+    subscriptionId: number,
+    subscribedKeys: Set<string>,
+    targets: QuoteSubscriptionRequest[],
+  ): Set<string> {
+    const nextTargets = new Map<string, QuoteSubscriptionTarget>();
     for (const { instrument, priority } of targets) {
       const key = buildQuoteKey(instrument);
-      subscribedKeys.add(key);
       const target = quoteTargetFromInstrument(instrument, priority);
-      const existing = this.quoteSubscriptions.get(key);
-      if (existing) {
-        existing.targets.set(subscriptionId, target);
-        existing.target = mergeQuoteSubscriptionTargets(existing.targets.values()) ?? target;
-        if (existing.removeTimer) {
-          clearTimeout(existing.removeTimer);
-          existing.removeTimer = null;
+      const duplicate = nextTargets.get(key);
+      nextTargets.set(
+        key,
+        duplicate
+          ? mergeQuoteSubscriptionTargets([duplicate, target]) ?? target
+          : target,
+      );
+    }
+
+    const nextKeys = new Set(nextTargets.keys());
+    const affectedKeys = new Set([...subscribedKeys, ...nextKeys]);
+    let shouldFlush = false;
+    for (const key of affectedKeys) {
+      const nextTarget = nextTargets.get(key);
+      let entry = this.quoteSubscriptions.get(key);
+      if (nextTarget) {
+        if (!entry) {
+          entry = {
+            target: nextTarget,
+            targets: new Map(),
+            removeTimer: null,
+          };
+          this.quoteSubscriptions.set(key, entry);
         }
+        entry.targets.set(subscriptionId, nextTarget);
+        if (entry.removeTimer) {
+          clearTimeout(entry.removeTimer);
+          entry.removeTimer = null;
+        }
+      } else if (entry) {
+        entry.targets.delete(subscriptionId);
+      }
+      if (!entry) continue;
+
+      const mergedTarget = mergeQuoteSubscriptionTargets(entry.targets.values());
+      if (mergedTarget) {
+        entry.target = mergedTarget;
+        shouldFlush = true;
         continue;
       }
-      this.quoteSubscriptions.set(key, {
-        target,
-        targets: new Map([[subscriptionId, target]]),
-        removeTimer: null,
-      });
+      this.scheduleSubscriptionRemoval(key, entry);
     }
-    this.flush();
-
-    return () => {
-      for (const key of subscribedKeys) {
-        const existing = this.quoteSubscriptions.get(key);
-        if (!existing) continue;
-        existing.targets.delete(subscriptionId);
-        const mergedTarget = mergeQuoteSubscriptionTargets(existing.targets.values());
-        if (mergedTarget) {
-          existing.target = mergedTarget;
-          this.flush();
-          continue;
-        }
-        if (existing.removeTimer) continue;
-        this.clearPendingStreamQuote(key);
-        existing.removeTimer = setTimeout(() => {
-          const current = this.quoteSubscriptions.get(key);
-          if (!current || current.targets.size > 0) return;
-          this.quoteSubscriptions.delete(key);
-          this.clearPendingStreamQuote(key);
-          this.flush();
-        }, QUOTE_SUBSCRIPTION_REMOVE_GRACE_MS);
-      }
-    };
+    if (shouldFlush) {
+      this.flush();
+    } else if (![...this.quoteSubscriptions.values()].some((entry) => entry.targets.size > 0)) {
+      this.cancelPendingPriorityUpdate();
+    }
+    return nextKeys;
+  }
+
+  private scheduleSubscriptionRemoval(key: string, entry: QuoteSubscriptionEntry): void {
+    if (entry.removeTimer) return;
+    this.clearPendingStreamQuote(key);
+    entry.removeTimer = setTimeout(() => {
+      const current = this.quoteSubscriptions.get(key);
+      if (!current || current.targets.size > 0) return;
+      this.quoteSubscriptions.delete(key);
+      this.clearPendingStreamQuote(key);
+      this.flush();
+    }, QUOTE_SUBSCRIPTION_REMOVE_GRACE_MS);
   }
 
-  private flush(): void {
+  private flush({
+    coalescePriorityChanges = true,
+    requireStableRouting = false,
+  }: {
+    coalescePriorityChanges?: boolean;
+    requireStableRouting?: boolean;
+  } = {}): void {
     if (!this.dataProvider.subscribeQuotes) return;
 
     const activeEntries = [...this.quoteSubscriptions.entries()]
       .filter(([, entry]) => entry.targets.size > 0)
       .sort(([left], [right]) => left.localeCompare(right));
-    const nextSignature = activeEntries.map(([key, entry]) => [
+    const nextRoutingSignature = JSON.stringify(activeEntries.map(([key, entry]) => [
       key,
-      entry.target.route ?? "",
+      entry.target.route ?? "auto",
+    ]));
+    const nextSignature = JSON.stringify(activeEntries.map(([key, entry]) => [
+      key,
+      entry.target.route ?? "auto",
       entry.target.surface ?? "",
-      entry.target.visible ? "visible" : "",
-      entry.target.selected ? "selected" : "",
-      Number.isFinite(entry.target.weight) ? entry.target.weight : "",
-    ].join(":")).join("|");
-    if (nextSignature === this.quoteSubscriptionSignature) return;
-
-    this.quoteSubscriptionDispose?.();
-    this.quoteSubscriptionDispose = null;
-    this.quoteSubscriptionSignature = nextSignature;
+      entry.target.visible === true,
+      entry.target.selected === true,
+      Number.isFinite(entry.target.weight) ? entry.target.weight : null,
+    ]));
+    if (nextSignature === this.quoteSubscriptionSignature) {
+      this.cancelPendingPriorityUpdate();
+      return;
+    }
+    if (requireStableRouting && nextRoutingSignature !== this.quoteSubscriptionRoutingSignature) {
+      return;
+    }
+
+    const priorityOnlyChange = this.quoteSubscriptionSignature.length > 0
+      && nextRoutingSignature === this.quoteSubscriptionRoutingSignature;
+    if (coalescePriorityChanges && priorityOnlyChange) {
+      this.schedulePriorityUpdate();
+      return;
+    }
+    this.cancelPendingPriorityUpdate();
 
     const targets = activeEntries.map(([, entry]) => entry.target);
-    if (targets.length === 0) return;
-
-    this.quoteSubscriptionDispose = this.dataProvider.subscribeQuotes(targets, (target, quote) => {
-      const instrument: InstrumentRef = {
-        symbol: target.symbol,
-        exchange: target.exchange ?? "",
-        brokerId: target.context?.brokerId,
-        brokerInstanceId: target.context?.brokerInstanceId,
-        instrument: target.context?.instrument ?? null,
-      };
-      this.enqueueStreamQuote(instrument, quote);
-    });
+    const nextDispose = targets.length > 0
+      ? this.dataProvider.subscribeQuotes(targets, (target, quote) => {
+          const instrument: InstrumentRef = {
+            symbol: target.symbol,
+            exchange: target.exchange ?? "",
+            brokerId: target.context?.brokerId,
+            brokerInstanceId: target.context?.brokerInstanceId,
+            instrument: target.context?.instrument ?? null,
+          };
+          this.enqueueStreamQuote(instrument, quote);
+        })
+      : null;
+    // Register first so the cloud socket and desktop registries can merge the
+    // overlapping listeners without observing a zero-listener disconnect.
+    const previousDispose = this.quoteSubscriptionDispose;
+    this.quoteSubscriptionDispose = nextDispose;
+    this.quoteSubscriptionSignature = nextSignature;
+    this.quoteSubscriptionRoutingSignature = nextRoutingSignature;
+    previousDispose?.();
+  }
+
+  private schedulePriorityUpdate(): void {
+    // Do not reset this timer. Continuous navigation must still publish the
+    // latest priorities instead of postponing them indefinitely.
+    if (this.pendingPriorityUpdateTimer !== null) return;
+    this.pendingPriorityUpdateTimer = setTimeout(() => {
+      this.pendingPriorityUpdateTimer = null;
+      this.flush({ coalescePriorityChanges: false, requireStableRouting: true });
+    }, QUOTE_SUBSCRIPTION_PRIORITY_UPDATE_DELAY_MS);
+  }
+
+  private cancelPendingPriorityUpdate(): void {
+    if (this.pendingPriorityUpdateTimer === null) return;
+    clearTimeout(this.pendingPriorityUpdateTimer);
+    this.pendingPriorityUpdateTimer = null;
   }
 
   private enqueueStreamQuote(instrument: InstrumentRef, quote: Quote): void {

package/src/market-data/coordinator/subscriptions.test.ts

@@ -5,6 +5,11 @@ import { QUOTE_STREAM_UPDATE_THROTTLE_MS } from "../quotes/cadence";
 import { createTestDataProvider } from "../../test-support/data-provider";
 import type { Quote } from "../../types/financials";
 import type { DataProvider, QuoteSubscriptionTarget } from "../../types/data-provider";
+import {
+  QUOTE_SUBSCRIPTION_PRIORITY_UPDATE_DELAY_MS,
+  QUOTE_SUBSCRIPTION_REMOVE_GRACE_MS,
+  type QuoteSubscriptionRequest,
+} from "./quotes";
 
 function createProvider(): {
   provider: DataProvider;
@@ -75,47 +80,220 @@ describe("MarketDataCoordinator key subscriptions", () => {
   });
 
   test("keeps the highest-priority target when duplicate surfaces subscribe", () => {
-    const subscriptions: QuoteSubscriptionTarget[][] = [];
-    let disposals = 0;
-    const provider = createTestDataProvider({
-      id: "test-provider",
-      subscribeQuotes: (targets) => {
-        subscriptions.push(targets);
-        return () => {
-          disposals += 1;
-        };
-      },
-    });
-    const coordinator = new MarketDataCoordinator(provider);
-    const instrument = { symbol: "AAPL", exchange: "NASDAQ" };
+    jest.useFakeTimers();
+    try {
+      const subscriptions: QuoteSubscriptionTarget[][] = [];
+      let disposals = 0;
+      const provider = createTestDataProvider({
+        id: "test-provider",
+        subscribeQuotes: (targets) => {
+          subscriptions.push(targets);
+          return () => {
+            disposals += 1;
+          };
+        },
+      });
+      const coordinator = new MarketDataCoordinator(provider);
+      const instrument = { symbol: "AAPL", exchange: "NASDAQ" };
+
+      const unsubscribeDetail = coordinator.subscribeQuotes([{
+        instrument,
+        priority: { surface: "detail", visible: true, selected: true, weight: 100 },
+      }]);
+      const unsubscribePortfolio = coordinator.subscribeQuotes([{
+        instrument,
+        priority: { surface: "portfolio", visible: false, selected: false, weight: 10 },
+      }]);
+
+      expect(subscriptions).toHaveLength(1);
+      expect(subscriptions[0]?.[0]).toMatchObject({
+        surface: "detail",
+        visible: true,
+        selected: true,
+        weight: 100,
+      });
 
-    const unsubscribeDetail = coordinator.subscribeQuotes([{
-      instrument,
-      priority: { surface: "detail", visible: true, selected: true, weight: 100 },
-    }]);
-    coordinator.subscribeQuotes([{
-      instrument,
-      priority: { surface: "portfolio", visible: false, selected: false, weight: 10 },
-    }]);
+      unsubscribeDetail();
+      expect(subscriptions).toHaveLength(1);
 
-    expect(subscriptions).toHaveLength(1);
-    expect(subscriptions[0]?.[0]).toMatchObject({
-      surface: "detail",
-      visible: true,
-      selected: true,
-      weight: 100,
-    });
+      jest.advanceTimersByTime(QUOTE_SUBSCRIPTION_PRIORITY_UPDATE_DELAY_MS);
+      expect(subscriptions).toHaveLength(2);
+      expect(disposals).toBe(1);
+      expect(subscriptions[1]?.[0]).toMatchObject({
+        surface: "portfolio",
+        visible: false,
+        selected: false,
+        weight: 10,
+      });
 
-    unsubscribeDetail();
+      unsubscribePortfolio();
+      jest.runAllTimers();
+    } finally {
+      jest.useRealTimers();
+    }
+  });
 
-    expect(subscriptions).toHaveLength(2);
-    expect(disposals).toBe(1);
-    expect(subscriptions[1]?.[0]).toMatchObject({
-      surface: "portfolio",
-      visible: false,
-      selected: false,
-      weight: 10,
-    });
+  test("coalesces priority updates and overlaps the upstream replacement", () => {
+    jest.useFakeTimers();
+    try {
+      const events: string[] = [];
+      const subscriptions: QuoteSubscriptionTarget[][] = [];
+      const provider = createTestDataProvider({
+        id: "test-provider",
+        subscribeQuotes: (targets) => {
+          const subscriptionId = subscriptions.length + 1;
+          subscriptions.push(targets);
+          events.push(`subscribe:${subscriptionId}`);
+          return () => events.push(`dispose:${subscriptionId}`);
+        },
+      });
+      const coordinator = new MarketDataCoordinator(provider);
+      const instruments = ["AAPL", "MSFT", "NVDA"].map((symbol) => ({
+        symbol,
+        exchange: "NASDAQ",
+      }));
+      const requests = (
+        selectedSymbol: string,
+        selectedSurface: "portfolio" | "detail" = "portfolio",
+      ): QuoteSubscriptionRequest[] => instruments.map((instrument) => ({
+        instrument,
+        priority: {
+          surface: instrument.symbol === selectedSymbol ? selectedSurface : "portfolio",
+          visible: instrument.symbol === selectedSymbol,
+          selected: instrument.symbol === selectedSymbol,
+          weight: instrument.symbol === selectedSymbol ? 100 : 10,
+        },
+      }));
+
+      const subscription = coordinator.subscribeQuotes(requests("AAPL"));
+      subscription.update(requests("MSFT"));
+      subscription.update(requests("NVDA", "detail"));
+
+      jest.advanceTimersByTime(QUOTE_SUBSCRIPTION_PRIORITY_UPDATE_DELAY_MS - 1);
+      expect(subscriptions).toHaveLength(1);
+      expect(events).toEqual(["subscribe:1"]);
+
+      jest.advanceTimersByTime(1);
+      expect(subscriptions).toHaveLength(2);
+      expect(subscriptions[1]?.find((target) => target.symbol === "NVDA")).toMatchObject({
+        surface: "detail",
+        visible: true,
+        selected: true,
+        weight: 100,
+      });
+      expect(events).toEqual(["subscribe:1", "subscribe:2", "dispose:1"]);
+
+      subscription();
+      jest.runAllTimers();
+    } finally {
+      jest.useRealTimers();
+    }
+  });
+
+  test("applies membership and routing changes immediately", () => {
+    jest.useFakeTimers();
+    try {
+      const subscriptions: QuoteSubscriptionTarget[][] = [];
+      let disposals = 0;
+      const provider = createTestDataProvider({
+        id: "test-provider",
+        subscribeQuotes: (targets) => {
+          subscriptions.push(targets);
+          return () => { disposals += 1; };
+        },
+      });
+      const coordinator = new MarketDataCoordinator(provider);
+      const aapl = {
+        symbol: "AAPL",
+        exchange: "NASDAQ",
+        brokerId: "ibkr",
+        brokerInstanceId: "ibkr-work",
+        instrument: {
+          brokerId: "ibkr",
+          brokerInstanceId: "ibkr-work",
+          conId: 1001,
+          symbol: "AAPL",
+        },
+      };
+      const msft = { symbol: "MSFT", exchange: "NASDAQ" };
+      const subscription = coordinator.subscribeQuotes([{
+        instrument: aapl,
+        priority: { route: "provider", surface: "portfolio" },
+      }]);
+
+      subscription.update([
+        { instrument: aapl, priority: { route: "provider", surface: "portfolio" } },
+        { instrument: msft, priority: { route: "provider", surface: "portfolio" } },
+      ]);
+      expect(subscriptions).toHaveLength(2);
+      expect(disposals).toBe(1);
+      expect(subscriptions[1]?.map((target) => target.symbol).sort()).toEqual(["AAPL", "MSFT"]);
+
+      subscription.update([
+        { instrument: aapl, priority: { route: "broker", surface: "detail" } },
+        { instrument: msft, priority: { route: "provider", surface: "portfolio" } },
+      ]);
+      expect(subscriptions).toHaveLength(3);
+      expect(disposals).toBe(2);
+      expect(subscriptions[2]?.find((target) => target.symbol === "AAPL")).toMatchObject({
+        route: "broker",
+        surface: "detail",
+        context: {
+          brokerId: "ibkr",
+          brokerInstanceId: "ibkr-work",
+          instrument: { brokerId: "ibkr", conId: 1001, symbol: "AAPL" },
+        },
+      });
+
+      subscription();
+      jest.runAllTimers();
+    } finally {
+      jest.useRealTimers();
+    }
+  });
+
+  test("keeps an updated handle callable and honors removal grace on dispose", () => {
+    jest.useFakeTimers();
+    try {
+      const subscriptions: QuoteSubscriptionTarget[][] = [];
+      let disposals = 0;
+      const provider = createTestDataProvider({
+        id: "test-provider",
+        subscribeQuotes: (targets) => {
+          subscriptions.push(targets);
+          return () => { disposals += 1; };
+        },
+      });
+      const coordinator = new MarketDataCoordinator(provider);
+      const instrument = { symbol: "AAPL", exchange: "NASDAQ" };
+      const subscription = coordinator.subscribeQuotes([{
+        instrument,
+        priority: { surface: "portfolio", selected: false, weight: 10 },
+      }]);
+
+      expect(typeof subscription).toBe("function");
+      expect(typeof subscription.update).toBe("function");
+      subscription.update([{
+        instrument,
+        priority: { surface: "detail", selected: true, weight: 100 },
+      }]);
+      jest.advanceTimersByTime(QUOTE_SUBSCRIPTION_PRIORITY_UPDATE_DELAY_MS);
+      expect(subscriptions).toHaveLength(2);
+      expect(disposals).toBe(1);
+
+      subscription();
+      subscription.update([{ instrument: { symbol: "MSFT", exchange: "NASDAQ" } }]);
+      subscription();
+      jest.advanceTimersByTime(QUOTE_SUBSCRIPTION_REMOVE_GRACE_MS - 1);
+      expect(subscriptions).toHaveLength(2);
+      expect(disposals).toBe(1);
+
+      jest.advanceTimersByTime(1);
+      expect(subscriptions).toHaveLength(2);
+      expect(disposals).toBe(2);
+    } finally {
+      jest.useRealTimers();
+    }
   });
 
   test("replaces a capped target window without retaining pending removals", () => {

package/src/pane-settings.ts

@@ -52,7 +52,7 @@ export function setPaneSetting(
   value: unknown,
 ): LayoutConfig {
   const current = findPaneInstance(layout, paneId);
-  if (!current) return layout;
+  if (!current || Object.is(current.settings?.[key], value)) return layout;
   return setPaneSettings(layout, paneId, {
     ...(current.settings ?? {}),
     [key]: value,

package/src/plugins/builtin/analytics/pane-model.ts

@@ -1,4 +1,4 @@
-import { resolveChartPalette } from "../../../components/chart/core/renderer";
+import { resolveChartPalette } from "../../../components/chart/core/palette";
 import { colors, priceColor } from "../../../theme/colors";
 import type { TickerFinancials, PricePoint } from "../../../types/financials";
 import type { BrokerPortfolioPerformance } from "../../../types/trading";

package/src/plugins/builtin/analytics/view.tsx

@@ -5,7 +5,7 @@ import {
   loadingText,
   unavailableText,
 } from "../../../components";
-import type { StaticChartSurfaceProps } from "../../../components/chart/static/chart/surface";
+import type { StaticChartSurfaceProps } from "../../../components/chart/static";
 import type { ProjectedChartPoint } from "../../../components/chart/core/data";
 import { colors, priceColor } from "../../../theme/colors";
 import { formatCompact, formatPercentRaw } from "../../../utils/format";

package/src/plugins/builtin/broker-manager/index.test.tsx

@@ -7,7 +7,7 @@ import { AppContext, PaneInstanceProvider, createInitialState } from "../../../s
 import { createTestPluginRuntime } from "../../../test-support/plugin-runtime";
 import { createDefaultConfig, type BrokerInstanceConfig } from "../../../types/config";
 import { PluginRenderProvider } from "../../runtime";
-import { ibkrBroker } from "../../ibkr/broker-adapter";
+import { testBroker } from "../../../brokers/test-broker";
 import { BrokersPane } from "./index";
 
 let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
@@ -63,7 +63,7 @@ function Harness({
     };
   }
   const runtime = createTestPluginRuntime({
-    getBrokerAdapter: (brokerType) => brokerType === "ibkr" ? ibkrBroker : null,
+    getBrokerAdapter: (brokerType) => brokerType === "ibkr" ? testBroker : null,
     openCommandBar: (query) => calls.push(`command:${query ?? ""}`),
     showPane: (paneId) => calls.push(`pane:${paneId}`),
     connectBrokerInstance: async (instanceId) => { calls.push(`connect:${instanceId}`); },
@@ -113,6 +113,7 @@ async function pressKey(key: string) {
 
 describe("BrokersPane", () => {
   test("renders IBKR row and invokes broker actions", async () => {
+
     const calls: string[] = [];
     testSetup = await testRender(<FooterHarness calls={calls} instance={createGatewayInstance()} height={35} />, { width: 92, height: 35 });
     await act(async () => {

package/src/plugins/builtin/broker-manager/model.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 import type { BrokerAdapter } from "../../../types/broker";
 import { createDefaultConfig, type BrokerInstanceConfig } from "../../../types/config";
-import { ibkrBroker } from "../../ibkr/broker-adapter";
+import { testBroker } from "../../../brokers/test-broker";
 import { buildBrokerProfileRows, formatBrokerUpdatedAt } from "./model";
 
 function createInstance(patch: Partial<BrokerInstanceConfig> = {}): BrokerInstanceConfig {
@@ -131,7 +131,7 @@ describe("broker manager rows", () => {
         enabled: true,
       }],
     };
-    const rows = buildBrokerProfileRows(config, new Map([["ibkr", ibkrBroker]]), {});
+    const rows = buildBrokerProfileRows(config, new Map([["ibkr", testBroker]]), {});
 
     expect(rows[0]?.mode).toBe("Flex");
     expect(rows[0]?.stateLabel).toBe("Sync only");