@forgecharts/sdk 1.1.23

package/src/trading/__tests__/ManagedTradingController.test.ts

@@ -0,0 +1,338 @@
+/**
+ * ManagedTradingController — unit tests
+ *
+ * Covers:
+ *   - Cannot initialize (registerProvider) in unmanaged mode
+ *   - Can initialize in managed mode
+ *   - isReady() reflects provider registration state
+ *   - placeOrder() throws without a provider
+ *   - placeOrder() with a mock provider: writes optimistic overlay entry,
+ *     updates with provider id on success, rolls back on failure
+ *   - cancelOrder() updates overlay status to 'cancelled'
+ *   - modifyOrder() patches price / qty / label in overlay
+ *   - placeBracketOrder() creates 3 orders with the same groupId in the overlay
+ *   - reportFill() pushes to overlay + updates order status
+ *   - All methods blocked in unmanaged mode
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { LicenseManager } from '../../licensing/LicenseManager';
+import { TradingOverlayStore } from '../TradingOverlayStore';
+import { ManagedTradingController } from '../managed/ManagedTradingController';
+import type { IExecutionProvider, PlaceOrderInput, PlaceBracketOrderInput } from '../managed/managedTypes';
+import type { ExecutionFill } from '../tradingTypes';
+
+// ─── License helpers ──────────────────────────────────────────────────────────
+
+function installManaged() {
+  LicenseManager.getInstance().loadLicense({ licenseKey: 'm', mode: 'managed' });
+}
+
+function installUnmanaged() {
+  LicenseManager.getInstance().loadLicense({ licenseKey: 'u', mode: 'unmanaged' });
+}
+
+function clearLicense() {
+  LicenseManager.getInstance().clear();
+}
+
+// ─── Mock provider factory ────────────────────────────────────────────────────
+
+function makeMockProvider(overrides: Partial<IExecutionProvider> = {}): IExecutionProvider {
+  return {
+    providerId: 'mock-provider',
+    placeOrder: vi.fn().mockResolvedValue({ orderId: 'prov-001', status: 'open' }),
+    cancelOrder: vi.fn().mockResolvedValue(undefined),
+    modifyOrder: vi.fn().mockResolvedValue({ orderId: 'prov-001', status: 'open' }),
+    placeBracketOrder: vi.fn().mockResolvedValue({
+      entry:      { orderId: 'prov-entry', timestamp: 1000 },
+      stopLoss:   { orderId: 'prov-sl',    timestamp: 1000 },
+      takeProfit: { orderId: 'prov-tp',    timestamp: 1000 },
+      groupId:    'bracket-test',
+    }),
+    ...overrides,
+  };
+}
+
+function makeOrderInput(overrides: Partial<PlaceOrderInput> = {}): PlaceOrderInput {
+  return {
+    symbol:     'BTCUSDT',
+    side:       'buy',
+    type:       'limit',
+    limitPrice: 50_000,
+    qty:        1,
+    ...overrides,
+  };
+}
+
+// ─── Mode gate ────────────────────────────────────────────────────────────────
+
+describe('ManagedTradingController — mode gate', () => {
+  afterEach(clearLicense);
+
+  it('registerProvider() throws in unmanaged mode', () => {
+    installUnmanaged();
+    const store = new TradingOverlayStore();
+    const ctrl  = new ManagedTradingController(store);
+    expect(() => ctrl.registerProvider(makeMockProvider())).toThrow(/managed/i);
+  });
+
+  it('registerProvider() throws when no license (defaults to unmanaged)', () => {
+    clearLicense();
+    const store = new TradingOverlayStore();
+    const ctrl  = new ManagedTradingController(store);
+    expect(() => ctrl.registerProvider(makeMockProvider())).toThrow(/managed/i);
+  });
+
+  it('registerProvider() succeeds in managed mode', () => {
+    installManaged();
+    const store = new TradingOverlayStore();
+    const ctrl  = new ManagedTradingController(store);
+    expect(() => ctrl.registerProvider(makeMockProvider())).not.toThrow();
+  });
+
+  it('placeOrder() throws in unmanaged mode', async () => {
+    installUnmanaged();
+    const store = new TradingOverlayStore();
+    const ctrl  = new ManagedTradingController(store);
+    await expect(ctrl.placeOrder(makeOrderInput())).rejects.toThrow(/managed/i);
+  });
+});
+
+// ─── isReady / getProviderId ──────────────────────────────────────────────────
+
+describe('ManagedTradingController — readiness', () => {
+  beforeEach(installManaged);
+  afterEach(clearLicense);
+
+  it('isReady() is false before provider registration', () => {
+    const ctrl = new ManagedTradingController(new TradingOverlayStore());
+    expect(ctrl.isReady()).toBe(false);
+  });
+
+  it('isReady() is true after registration', () => {
+    const ctrl = new ManagedTradingController(new TradingOverlayStore());
+    ctrl.registerProvider(makeMockProvider());
+    expect(ctrl.isReady()).toBe(true);
+  });
+
+  it('getProviderId() returns null before registration', () => {
+    const ctrl = new ManagedTradingController(new TradingOverlayStore());
+    expect(ctrl.getProviderId()).toBeNull();
+  });
+
+  it('getProviderId() returns the provider id after registration', () => {
+    const ctrl = new ManagedTradingController(new TradingOverlayStore());
+    ctrl.registerProvider(makeMockProvider({ providerId: 'rithmic' }));
+    expect(ctrl.getProviderId()).toBe('rithmic');
+  });
+});
+
+// ─── placeOrder ───────────────────────────────────────────────────────────────
+
+describe('ManagedTradingController — placeOrder', () => {
+  beforeEach(installManaged);
+  afterEach(clearLicense);
+
+  it('throws when no provider is registered', async () => {
+    const ctrl = new ManagedTradingController(new TradingOverlayStore());
+    await expect(ctrl.placeOrder(makeOrderInput())).rejects.toThrow(/no execution provider/i);
+  });
+
+  it('writes a pending order to overlay before provider responds', async () => {
+    const store    = new TradingOverlayStore();
+    const ctrl     = new ManagedTradingController(store);
+    let resolveAck: () => void;
+    const provider = makeMockProvider({
+      placeOrder: vi.fn().mockImplementation(
+        () => new Promise<{ orderId: string; status: 'open' }>((res) => {
+          resolveAck = () => res({ orderId: 'prov-001', status: 'open' });
+        }),
+      ),
+    });
+    ctrl.registerProvider(provider);
+
+    const promise = ctrl.placeOrder(makeOrderInput());
+    // Overlay should have a pending entry immediately (optimistic)
+    expect(store.getOrders().some(o => o.status === 'pending')).toBe(true);
+
+    resolveAck!();
+    await promise;
+  });
+
+  it('updates overlay with provider-assigned id on success', async () => {
+    const store    = new TradingOverlayStore();
+    const ctrl     = new ManagedTradingController(store);
+    const provider = makeMockProvider({
+      placeOrder: vi.fn().mockResolvedValue({ orderId: 'server-id-1', status: 'open' }),
+    });
+    ctrl.registerProvider(provider);
+
+    await ctrl.placeOrder(makeOrderInput());
+
+    const orders = store.getOrders();
+    expect(orders.some(o => o.id === 'server-id-1' && o.status === 'open')).toBe(true);
+  });
+
+  it('rolls back to rejected status when provider throws', async () => {
+    const store    = new TradingOverlayStore();
+    const ctrl     = new ManagedTradingController(store);
+    const provider = makeMockProvider({
+      placeOrder: vi.fn().mockRejectedValue(new Error('venue rejected')),
+    });
+    ctrl.registerProvider(provider);
+
+    await expect(ctrl.placeOrder(makeOrderInput())).rejects.toThrow('venue rejected');
+
+    const orders = store.getOrders();
+    expect(orders.some(o => o.status === 'rejected')).toBe(true);
+  });
+
+  it('delegates to the registered provider', async () => {
+    const store    = new TradingOverlayStore();
+    const ctrl     = new ManagedTradingController(store);
+    const mockFn   = vi.fn().mockResolvedValue({ orderId: 'x', status: 'open' });
+    ctrl.registerProvider(makeMockProvider({ placeOrder: mockFn }));
+
+    const input = makeOrderInput({ side: 'sell', qty: 3 });
+    await ctrl.placeOrder(input);
+
+    expect(mockFn).toHaveBeenCalledOnce();
+    expect(mockFn).toHaveBeenCalledWith(input);
+  });
+});
+
+// ─── cancelOrder ─────────────────────────────────────────────────────────────
+
+describe('ManagedTradingController — cancelOrder', () => {
+  beforeEach(installManaged);
+  afterEach(clearLicense);
+
+  it('updates overlay status to cancelled after provider confirms', async () => {
+    const store    = new TradingOverlayStore();
+    const ctrl     = new ManagedTradingController(store);
+    ctrl.registerProvider(makeMockProvider());
+
+    await ctrl.placeOrder(makeOrderInput());
+    // Find the confirmed order id
+    const orderId = store.getOrders().find(o => o.status === 'open')?.id;
+    expect(orderId).toBeDefined();
+
+    await ctrl.cancelOrder(orderId!);
+    expect(store.getOrders().find(o => o.id === orderId)!.status).toBe('cancelled');
+  });
+});
+
+// ─── modifyOrder ──────────────────────────────────────────────────────────────
+
+describe('ManagedTradingController — modifyOrder', () => {
+  beforeEach(installManaged);
+  afterEach(clearLicense);
+
+  it('patches price in overlay when limitPrice is provided', async () => {
+    const store    = new TradingOverlayStore();
+    const ctrl     = new ManagedTradingController(store);
+    ctrl.registerProvider(makeMockProvider());
+
+    await ctrl.placeOrder(makeOrderInput({ limitPrice: 50_000 }));
+    const orderId = store.getOrders().find(o => o.status === 'open')?.id;
+    expect(orderId).toBeDefined();
+
+    await ctrl.modifyOrder(orderId!, { limitPrice: 51_000 });
+    expect(store.getOrders().find(o => o.id === orderId)!.price).toBe(51_000);
+  });
+
+  it('patches qty in overlay when qty is provided', async () => {
+    const store    = new TradingOverlayStore();
+    const ctrl     = new ManagedTradingController(store);
+    ctrl.registerProvider(makeMockProvider());
+
+    await ctrl.placeOrder(makeOrderInput({ qty: 1 }));
+    const orderId = store.getOrders().find(o => o.status === 'open')?.id;
+    await ctrl.modifyOrder(orderId!, { qty: 5 });
+    expect(store.getOrders().find(o => o.id === orderId)!.qty).toBe(5);
+  });
+});
+
+// ─── placeBracketOrder ────────────────────────────────────────────────────────
+
+describe('ManagedTradingController — placeBracketOrder', () => {
+  beforeEach(installManaged);
+  afterEach(clearLicense);
+
+  it('throws without a provider', async () => {
+    const ctrl = new ManagedTradingController(new TradingOverlayStore());
+    const input: PlaceBracketOrderInput = {
+      entry:              makeOrderInput(),
+      stopLossPrice:      49_000,
+      takeProfitPrice:    55_000,
+    };
+    await expect(ctrl.placeBracketOrder(input)).rejects.toThrow(/no execution provider/i);
+  });
+
+  it('creates 3 orders sharing a groupId in the overlay', async () => {
+    const store    = new TradingOverlayStore();
+    const ctrl     = new ManagedTradingController(store);
+    ctrl.registerProvider(makeMockProvider());
+
+    const groupId = 'bracket-test';
+    const input: PlaceBracketOrderInput = {
+      entry:           makeOrderInput({ groupId }),
+      stopLossPrice:   49_000,
+      takeProfitPrice: 55_000,
+    };
+    await ctrl.placeBracketOrder(input);
+
+    const group = store.getOrdersByGroup(groupId);
+    expect(group).toHaveLength(3);
+
+    const roles = group.map(o => o.role).sort();
+    expect(roles).toContain('entry');
+    expect(roles).toContain('stop_loss');
+    expect(roles).toContain('take_profit');
+  });
+});
+
+// ─── reportFill ───────────────────────────────────────────────────────────────
+
+describe('ManagedTradingController — reportFill', () => {
+  beforeEach(installManaged);
+  afterEach(clearLicense);
+
+  it('pushes fill into overlay store', async () => {
+    const store = new TradingOverlayStore();
+    const ctrl  = new ManagedTradingController(store);
+    ctrl.registerProvider(makeMockProvider());
+
+    await ctrl.placeOrder(makeOrderInput());
+    const orderId = store.getOrders().find(o => o.status === 'open')?.id ?? 'oid';
+
+    const fill: ExecutionFill = {
+      id:        'fill-1',
+      orderId,
+      side:      'buy',
+      price:     50_000,
+      qty:       1,
+      timestamp: Date.now(),
+    };
+    ctrl.reportFill(fill);
+
+    expect(store.getFills()).toHaveLength(1);
+    expect(store.getFills()[0]!.id).toBe('fill-1');
+  });
+
+  it('updates order status to filled after a fill report', async () => {
+    const store = new TradingOverlayStore();
+    const ctrl  = new ManagedTradingController(store);
+    ctrl.registerProvider(makeMockProvider());
+
+    await ctrl.placeOrder(makeOrderInput());
+    const orderId = store.getOrders().find(o => o.status === 'open')?.id ?? 'oid';
+
+    ctrl.reportFill({
+      id: 'fill-2', orderId, side: 'buy', price: 50_000, qty: 1, timestamp: Date.now(),
+    });
+
+    expect(store.getOrders().find(o => o.id === orderId)!.status).toBe('filled');
+  });
+});

package/src/trading/__tests__/TradingOverlayStore.test.ts

@@ -0,0 +1,323 @@
+/**
+ * TradingOverlayStore — unit tests
+ *
+ * Covers:
+ *   - Orders: set, upsert, remove, getByGroup
+ *   - Positions: set, upsert, remove
+ *   - Fills: push, getFills, getFillsByOrder
+ *   - clear() resets everything
+ *   - snapshot() reflects current state
+ *   - onChange subscriber fires on every mutation
+ *   - Both unmanaged and managed pathways can write into the same store
+ *   - groupId-based linked orders coexist correctly
+ *   - TP / SL / entry roles are stored verbatim
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { TradingOverlayStore } from '../TradingOverlayStore';
+import type { ChartOrder, ChartPosition, ExecutionFill } from '../tradingTypes';
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function makeOrder(id: string, overrides: Partial<ChartOrder> = {}): ChartOrder {
+  return {
+    id,
+    role:   'entry',
+    side:   'buy',
+    status: 'open',
+    price:  100,
+    qty:    1,
+    ...overrides,
+  };
+}
+
+function makePosition(id: string, overrides: Partial<ChartPosition> = {}): ChartPosition {
+  return {
+    id,
+    side:       'long',
+    status:     'open',
+    entryPrice: 100,
+    qty:        1,
+    ...overrides,
+  };
+}
+
+function makeFill(id: string, orderId?: string): ExecutionFill {
+  return {
+    id,
+    side:      'buy',
+    price:     100,
+    qty:       1,
+    timestamp: Date.now(),
+    ...(orderId !== undefined ? { orderId } : {}),
+  };
+}
+
+// ─── Orders ───────────────────────────────────────────────────────────────────
+
+describe('TradingOverlayStore — orders', () => {
+  let store: TradingOverlayStore;
+  beforeEach(() => { store = new TradingOverlayStore(); });
+
+  it('starts empty', () => {
+    expect(store.getOrders()).toHaveLength(0);
+  });
+
+  it('setOrders replaces the entire set', () => {
+    store.setOrders([makeOrder('a'), makeOrder('b')]);
+    expect(store.getOrders()).toHaveLength(2);
+
+    store.setOrders([makeOrder('c')]);
+    expect(store.getOrders()).toHaveLength(1);
+    expect(store.getOrders()[0]!.id).toBe('c');
+  });
+
+  it('upsertOrder inserts a new order', () => {
+    store.upsertOrder(makeOrder('o1'));
+    expect(store.getOrders()).toHaveLength(1);
+    expect(store.getOrders()[0]!.id).toBe('o1');
+  });
+
+  it('upsertOrder replaces an existing order by id', () => {
+    store.upsertOrder(makeOrder('o1', { price: 100 }));
+    store.upsertOrder(makeOrder('o1', { price: 200 }));
+    expect(store.getOrders()).toHaveLength(1);
+    expect(store.getOrders()[0]!.price).toBe(200);
+  });
+
+  it('removeOrder removes by id', () => {
+    store.upsertOrder(makeOrder('o1'));
+    store.upsertOrder(makeOrder('o2'));
+    store.removeOrder('o1');
+    expect(store.getOrders()).toHaveLength(1);
+    expect(store.getOrders()[0]!.id).toBe('o2');
+  });
+
+  it('removeOrder is a silent no-op for unknown id', () => {
+    store.upsertOrder(makeOrder('o1'));
+    store.removeOrder('nonexistent');
+    expect(store.getOrders()).toHaveLength(1);
+  });
+
+  it('getOrdersByGroup filters correctly', () => {
+    store.setOrders([
+      makeOrder('entry', { groupId: 'bracket1', role: 'entry' }),
+      makeOrder('sl',    { groupId: 'bracket1', role: 'stop_loss' }),
+      makeOrder('tp',    { groupId: 'bracket1', role: 'take_profit' }),
+      makeOrder('lone',  { role: 'limit' }),  // no groupId
+    ]);
+    const group = store.getOrdersByGroup('bracket1');
+    expect(group).toHaveLength(3);
+    const roles = group.map(o => o.role).sort();
+    expect(roles).toEqual(['entry', 'stop_loss', 'take_profit']);
+  });
+
+  it('getOrdersByGroup returns [] for unknown groupId', () => {
+    store.upsertOrder(makeOrder('o1', { groupId: 'g1' }));
+    expect(store.getOrdersByGroup('g2')).toHaveLength(0);
+  });
+});
+
+// ─── Positions ────────────────────────────────────────────────────────────────
+
+describe('TradingOverlayStore — positions', () => {
+  let store: TradingOverlayStore;
+  beforeEach(() => { store = new TradingOverlayStore(); });
+
+  it('starts empty', () => {
+    expect(store.getPositions()).toHaveLength(0);
+  });
+
+  it('setPositions replaces the entire set', () => {
+    store.setPositions([makePosition('p1'), makePosition('p2')]);
+    expect(store.getPositions()).toHaveLength(2);
+    store.setPositions([]);
+    expect(store.getPositions()).toHaveLength(0);
+  });
+
+  it('upsertPosition inserts when missing', () => {
+    store.upsertPosition(makePosition('p1'));
+    expect(store.getPositions()).toHaveLength(1);
+  });
+
+  it('upsertPosition updates when id matches', () => {
+    store.upsertPosition(makePosition('p1', { qty: 1 }));
+    store.upsertPosition(makePosition('p1', { qty: 5 }));
+    expect(store.getPositions()).toHaveLength(1);
+    expect(store.getPositions()[0]!.qty).toBe(5);
+  });
+
+  it('removePosition removes by id', () => {
+    store.upsertPosition(makePosition('p1'));
+    store.removePosition('p1');
+    expect(store.getPositions()).toHaveLength(0);
+  });
+
+  it('removePosition is a silent no-op for unknown id', () => {
+    expect(() => store.removePosition('ghost')).not.toThrow();
+  });
+});
+
+// ─── Fills ────────────────────────────────────────────────────────────────────
+
+describe('TradingOverlayStore — fills', () => {
+  let store: TradingOverlayStore;
+  beforeEach(() => { store = new TradingOverlayStore(); });
+
+  it('starts empty', () => {
+    expect(store.getFills()).toHaveLength(0);
+  });
+
+  it('pushExecution appends fills in order', () => {
+    store.pushExecution(makeFill('f1'));
+    store.pushExecution(makeFill('f2'));
+    expect(store.getFills()).toHaveLength(2);
+    expect(store.getFills()[0]!.id).toBe('f1');
+    expect(store.getFills()[1]!.id).toBe('f2');
+  });
+
+  it('getFillsByOrder filters by orderId', () => {
+    store.pushExecution(makeFill('f1', 'orderA'));
+    store.pushExecution(makeFill('f2', 'orderB'));
+    store.pushExecution(makeFill('f3', 'orderA'));
+    const fills = store.getFillsByOrder('orderA');
+    expect(fills).toHaveLength(2);
+    expect(fills.map(f => f.id)).toEqual(['f1', 'f3']);
+  });
+
+  it('getFillsByOrder returns [] for unknown orderId', () => {
+    store.pushExecution(makeFill('f1', 'o1'));
+    expect(store.getFillsByOrder('unknown')).toHaveLength(0);
+  });
+});
+
+// ─── clear & snapshot ─────────────────────────────────────────────────────────
+
+describe('TradingOverlayStore — clear and snapshot', () => {
+  let store: TradingOverlayStore;
+  beforeEach(() => { store = new TradingOverlayStore(); });
+
+  it('clear() removes all state', () => {
+    store.upsertOrder(makeOrder('o1'));
+    store.upsertPosition(makePosition('p1'));
+    store.pushExecution(makeFill('f1'));
+    store.clear();
+    expect(store.getOrders()).toHaveLength(0);
+    expect(store.getPositions()).toHaveLength(0);
+    expect(store.getFills()).toHaveLength(0);
+  });
+
+  it('snapshot() reflects the current state', () => {
+    store.upsertOrder(makeOrder('o1'));
+    store.upsertPosition(makePosition('p1'));
+    store.pushExecution(makeFill('f1'));
+    const snap = store.snapshot();
+    expect(snap.orders).toHaveLength(1);
+    expect(snap.positions).toHaveLength(1);
+    expect(snap.fills).toHaveLength(1);
+  });
+});
+
+// ─── onChange subscription ────────────────────────────────────────────────────
+
+describe('TradingOverlayStore — onChange notifications', () => {
+  let store: TradingOverlayStore;
+  beforeEach(() => { store = new TradingOverlayStore(); });
+
+  function countCalls(fn: () => void): number {
+    const spy = vi.fn();
+    const unsub = store.onChange(spy);
+    fn();
+    unsub();
+    return spy.mock.calls.length;
+  }
+
+  it('fires on setOrders', () => {
+    expect(countCalls(() => store.setOrders([makeOrder('o1')]))).toBe(1);
+  });
+
+  it('fires on upsertOrder', () => {
+    expect(countCalls(() => store.upsertOrder(makeOrder('o1')))).toBe(1);
+  });
+
+  it('fires on removeOrder (when item exists)', () => {
+    store.upsertOrder(makeOrder('o1'));
+    expect(countCalls(() => store.removeOrder('o1'))).toBe(1);
+  });
+
+  it('does NOT fire on removeOrder for unknown id', () => {
+    expect(countCalls(() => store.removeOrder('ghost'))).toBe(0);
+  });
+
+  it('fires on setPositions', () => {
+    expect(countCalls(() => store.setPositions([makePosition('p1')]))).toBe(1);
+  });
+
+  it('fires on upsertPosition', () => {
+    expect(countCalls(() => store.upsertPosition(makePosition('p1')))).toBe(1);
+  });
+
+  it('fires on pushExecution', () => {
+    expect(countCalls(() => store.pushExecution(makeFill('f1')))).toBe(1);
+  });
+
+  it('fires on clear', () => {
+    expect(countCalls(() => store.clear())).toBe(1);
+  });
+
+  it('unsubscribe stops future notifications', () => {
+    const spy = vi.fn();
+    const unsub = store.onChange(spy);
+    unsub();
+    store.upsertOrder(makeOrder('o1'));
+    expect(spy).not.toHaveBeenCalled();
+  });
+});
+
+// ─── Shared overlay: both modes write into the same store ─────────────────────
+
+describe('TradingOverlayStore — shared between unmanaged and managed pathways', () => {
+  it('unmanaged push and managed push coexist in the same store', () => {
+    const store = new TradingOverlayStore();
+
+    // Simulate unmanaged host pushing an external position
+    store.upsertPosition(makePosition('ext-pos', { qty: 2 }));
+
+    // Simulate managed controller pushing an order (e.g. bracket entry)
+    store.upsertOrder(makeOrder('mgd-entry', { groupId: 'brk1', role: 'entry' }));
+    store.upsertOrder(makeOrder('mgd-sl',    { groupId: 'brk1', role: 'stop_loss',   price: 90 }));
+    store.upsertOrder(makeOrder('mgd-tp',    { groupId: 'brk1', role: 'take_profit', price: 115 }));
+
+    expect(store.getPositions()).toHaveLength(1);
+    expect(store.getOrders()).toHaveLength(3);
+    expect(store.getOrdersByGroup('brk1')).toHaveLength(3);
+  });
+
+  it('groupId-based bracket legs can coexist alongside unlinked orders', () => {
+    const store = new TradingOverlayStore();
+
+    store.upsertOrder(makeOrder('solo',   { role: 'limit' }));
+    store.upsertOrder(makeOrder('b1-ent', { groupId: 'brk-A', role: 'entry'       }));
+    store.upsertOrder(makeOrder('b1-sl',  { groupId: 'brk-A', role: 'stop_loss'   }));
+    store.upsertOrder(makeOrder('b1-tp',  { groupId: 'brk-A', role: 'take_profit' }));
+    store.upsertOrder(makeOrder('b2-ent', { groupId: 'brk-B', role: 'entry'       }));
+    store.upsertOrder(makeOrder('b2-sl',  { groupId: 'brk-B', role: 'stop_loss'   }));
+
+    expect(store.getOrders()).toHaveLength(6);
+    expect(store.getOrdersByGroup('brk-A')).toHaveLength(3);
+    expect(store.getOrdersByGroup('brk-B')).toHaveLength(2);
+  });
+
+  it('TP / SL / entry roles are stored verbatim', () => {
+    const store = new TradingOverlayStore();
+    const entry = makeOrder('entry-1', { role: 'entry',       price: 100 });
+    const sl    = makeOrder('sl-1',    { role: 'stop_loss',   price: 90  });
+    const tp    = makeOrder('tp-1',    { role: 'take_profit', price: 115 });
+    store.setOrders([entry, sl, tp]);
+
+    const orders = store.getOrders();
+    expect(orders.find(o => o.id === 'entry-1')!.role).toBe('entry');
+    expect(orders.find(o => o.id === 'sl-1')!.role).toBe('stop_loss');
+    expect(orders.find(o => o.id === 'tp-1')!.role).toBe('take_profit');
+  });
+});