gloomberb 0.9.2 → 0.9.4

package/src/plugins/ibkr/gateway/account-summary.ts

@@ -148,6 +148,7 @@ export function summarizeBrokerAccount(
     source: "gateway",
     updatedAt,
     netLiquidation: getAccountSummaryNumberWithAggregateFallback(tags, aggregateTags, "NetLiquidation", currency, allowAggregateCashBalances),
+    grossPositionValue: getAccountSummaryNumberWithAggregateFallback(tags, aggregateTags, "GrossPositionValue", currency, allowAggregateCashBalances),
     totalCashValue: getAccountSummaryNumberWithAggregateFallback(tags, aggregateTags, "TotalCashValue", currency, allowAggregateCashBalances),
     settledCash: getAccountSummaryNumberWithAggregateFallback(tags, aggregateTags, "SettledCash", currency, allowAggregateCashBalances),
     availableFunds: getAccountSummaryNumberWithAggregateFallback(tags, aggregateTags, "AvailableFunds", currency, allowAggregateCashBalances),

package/src/plugins/ibkr/gateway/service/index.test.ts

@@ -35,6 +35,7 @@ describe("summarizeBrokerAccount", () => {
   test("maps gateway account summary fields and ledger balances", () => {
     const tags = makeTags({
       NetLiquidation: { USD: "764713.62" },
+      GrossPositionValue: { USD: "1815667.34" },
       TotalCashValue: { USD: "-1050953.72" },
       SettledCash: { USD: "-917604.44" },
       AvailableFunds: { USD: "112345.67" },
@@ -52,6 +53,7 @@ describe("summarizeBrokerAccount", () => {
       source: "gateway",
       updatedAt: 1_717_000_000_000,
       netLiquidation: 764713.62,
+      grossPositionValue: 1815667.34,
       totalCashValue: -1050953.72,
       settledCash: -917604.44,
       availableFunds: 112345.67,
@@ -72,6 +74,7 @@ describe("summarizeBrokerAccount", () => {
   test("falls back to the aggregate cash summary for single-account gateways", () => {
     const accountTags = makeTags({
       NetLiquidation: { USD: "129360.15" },
+      GrossPositionValue: { USD: "1066.36" },
       TotalCashValue: { USD: "128293.79" },
       AvailableFunds: { USD: "129031.52" },
       BuyingPower: { USD: "860210.13" },
@@ -99,6 +102,7 @@ describe("summarizeBrokerAccount", () => {
       source: "gateway",
       updatedAt: 1_717_000_000_000,
       netLiquidation: 129360.15,
+      grossPositionValue: 1066.36,
       totalCashValue: 128293.79,
       settledCash: undefined,
       availableFunds: 129031.52,
@@ -119,6 +123,7 @@ describe("summarizeBrokerAccount", () => {
   test("falls back to aggregate summary metrics when a single-account gateway only returns the All row", () => {
     const aggregateTags = makeTags({
       NetLiquidation: { USD: "129360.15" },
+      GrossPositionValue: { USD: "1066.36" },
       TotalCashValue: { USD: "128293.79" },
       AvailableFunds: { USD: "129031.52" },
       BuyingPower: { USD: "860210.13" },
@@ -144,6 +149,7 @@ describe("summarizeBrokerAccount", () => {
       source: "gateway",
       updatedAt: 1_717_000_000_000,
       netLiquidation: 129360.15,
+      grossPositionValue: 1066.36,
       totalCashValue: 128293.79,
       settledCash: undefined,
       availableFunds: 129031.52,
@@ -164,6 +170,7 @@ describe("summarizeBrokerAccount", () => {
   test("maps account-level P&L into gateway account snapshots", () => {
     const tags = makeTags({
       NetLiquidation: { USD: "100000" },
+      GrossPositionValue: { USD: "75000" },
     });
 
     expect(summarizeBrokerAccount("DU12345", tags, 1_717_000_000_000, undefined, false, {
@@ -186,6 +193,7 @@ describe("summarizeBrokerAccount", () => {
       source: "gateway",
       updatedAt: 123,
       netLiquidation: undefined,
+      grossPositionValue: undefined,
       totalCashValue: undefined,
       settledCash: undefined,
       availableFunds: undefined,

package/src/plugins/pane-manager/docking.ts

@@ -6,6 +6,7 @@ import {
   findDockLeaf,
   getNodeAtPath,
   replaceNodeAtPath,
+  type DockGeometryOptions,
   type DockTarget,
   type LayoutBounds,
 } from "./dock-tree";
@@ -116,11 +117,17 @@ export function applyDrop(layout: LayoutConfig, draggedId: string, dropTarget: D
   return insertRelativeToLeaf(layout, draggedId, dropTarget.targetId, direction);
 }
 
-export function simulateDrop(layout: LayoutConfig, draggedId: string, dropTarget: DropTarget, bounds: LayoutBounds): LayoutSimulation {
+export function simulateDrop(
+  layout: LayoutConfig,
+  draggedId: string,
+  dropTarget: DropTarget,
+  bounds: LayoutBounds,
+  options?: DockGeometryOptions,
+): LayoutSimulation {
   const nextLayout = applyDrop(layout, draggedId, dropTarget);
   return {
     layout: nextLayout,
-    previewRect: getLeafRect(nextLayout, draggedId, bounds),
+    previewRect: getLeafRect(nextLayout, draggedId, bounds, options),
   };
 }
 

package/src/plugins/pane-manager/gridlock.ts

@@ -8,15 +8,23 @@ import {
   getDockLeafLayouts,
   type LayoutBounds,
 } from "./dock-tree";
-import { finalizeLayout } from "./layout-state";
+import {
+  finalizeLayout,
+  removeUnavailablePaneTypes,
+  type PaneTypeAvailability,
+} from "./layout-state";
 
 export function gridlockAllPanes(
   layout: LayoutConfig,
   bounds: LayoutBounds = { x: 0, y: 0, width: 120, height: 40 },
+  paneTypes?: PaneTypeAvailability,
 ): LayoutConfig {
-  const dockedRects: GridlockRect[] = getDockLeafLayouts(layout, bounds)
+  const visibleLayout = paneTypes
+    ? removeUnavailablePaneTypes(layout, paneTypes)
+    : layout;
+  const dockedRects: GridlockRect[] = getDockLeafLayouts(visibleLayout, bounds)
     .map((leaf) => ({ instanceId: leaf.instanceId, ...leaf.rect }));
-  const floatingRects: GridlockRect[] = layout.floating.map((entry) => ({
+  const floatingRects: GridlockRect[] = visibleLayout.floating.map((entry) => ({
     instanceId: entry.instanceId,
     x: entry.x,
     y: entry.y,
@@ -24,10 +32,10 @@ export function gridlockAllPanes(
     height: entry.height,
   }));
   const allRects = [...dockedRects, ...floatingRects];
-  if (allRects.length === 0) return layout;
+  if (allRects.length === 0) return visibleLayout;
 
   return finalizeLayout({
-    ...layout,
+    ...visibleLayout,
     dockRoot: inferDockTreeFromRects(allRects, boundsForRects(allRects)),
     floating: [],
   });

package/src/plugins/pane-manager/layout-state.ts

@@ -169,3 +169,28 @@ export function removeFloatingPanes(layout: LayoutConfig): LayoutConfig {
     layout.floating.map((entry) => entry.instanceId),
   ));
 }
+
+export type PaneTypeAvailability = { has(paneId: string): boolean } | ((paneId: string) => unknown);
+
+function paneTypeIsAvailable(availability: PaneTypeAvailability, paneId: string): boolean {
+  return typeof availability === "function"
+    ? !!availability(paneId)
+    : availability.has(paneId);
+}
+
+export function removeUnavailablePaneTypes(
+  layout: LayoutConfig,
+  availability: PaneTypeAvailability,
+  options: { disabledPaneIds?: ReadonlySet<string> } = {},
+): LayoutConfig {
+  const unavailableInstanceIds = layout.instances
+    .filter((instance) => (
+      options.disabledPaneIds?.has(instance.paneId)
+      || !paneTypeIsAvailable(availability, instance.paneId)
+    ))
+    .map((instance) => instance.instanceId);
+
+  return unavailableInstanceIds.length > 0
+    ? removePaneInstances(layout, unavailableInstanceIds)
+    : layout;
+}

package/src/plugins/pane-manager/queries.ts

@@ -10,6 +10,7 @@ import {
   countColumnsFromGeometry,
   findDockLeaf,
   getDockLeafLayouts,
+  type DockGeometryOptions,
   type LayoutBounds,
 } from "./dock-tree";
 
@@ -20,8 +21,13 @@ export interface ResolvedPane {
   path?: Array<0 | 1>;
 }
 
-export function getLeafRect(layout: LayoutConfig, instanceId: string, bounds: LayoutBounds): LayoutBounds | null {
-  return getDockLeafLayouts(layout, bounds).find((entry) => entry.instanceId === instanceId)?.rect ?? null;
+export function getLeafRect(
+  layout: LayoutConfig,
+  instanceId: string,
+  bounds: LayoutBounds,
+  options?: DockGeometryOptions,
+): LayoutBounds | null {
+  return getDockLeafLayouts(layout, bounds, options).find((entry) => entry.instanceId === instanceId)?.rect ?? null;
 }
 
 export function resolveDocked(

package/src/plugins/pane-manager.test.ts

@@ -109,6 +109,39 @@ describe("pane-manager split-tree drops", () => {
     expect(getDockedPaneIds(next)).toHaveLength(layout.instances.length);
   });
 
+  test("gridlock drops pane types that cannot render before tiling", () => {
+    const layout: LayoutConfig = {
+      dockRoot: {
+        kind: "split" as const,
+        axis: "horizontal" as const,
+        ratio: 0.5,
+        first: {
+          kind: "split" as const,
+          axis: "vertical" as const,
+          ratio: 0.5,
+          first: { kind: "pane" as const, instanceId: "missing:main" },
+          second: { kind: "pane" as const, instanceId: "chat:main" },
+        },
+        second: { kind: "pane" as const, instanceId: "sectors:main" },
+      },
+      instances: [
+        createPaneInstance("missing-plugin", { instanceId: "missing:main" }),
+        createPaneInstance("chat", { instanceId: "chat:main" }),
+        createPaneInstance("sectors", { instanceId: "sectors:main" }),
+      ],
+      floating: [],
+      detached: [],
+    };
+
+    const next = gridlockAllPanes(layout, BOUNDS, new Set(["chat", "sectors"]));
+
+    expect(next.instances.map((instance) => instance.instanceId)).toEqual(["chat:main", "sectors:main"]);
+    expect(getDockedPaneIds(next)).toEqual(["chat:main", "sectors:main"]);
+    expect(getLeafRect(next, "missing:main", BOUNDS)).toBeNull();
+    expect(getLeafRect(next, "chat:main", BOUNDS)).toEqual({ x: 0, y: 0, width: 60, height: 40 });
+    expect(getLeafRect(next, "sectors:main", BOUNDS)).toEqual({ x: 60, y: 0, width: 60, height: 40 });
+  });
+
   test("gridlock infers a matching tiled layout from arranged windows", () => {
     const config = createDefaultConfig("/tmp/gloomberb-test");
     let layout: LayoutConfig = {

package/src/plugins/pane-manager.ts

@@ -49,7 +49,12 @@ export {
   swapPanes,
 } from "./pane-manager/docking";
 
-export { removeFloatingPanes, removePane } from "./pane-manager/layout-state";
+export {
+  removeFloatingPanes,
+  removePane,
+  removeUnavailablePaneTypes,
+  type PaneTypeAvailability,
+} from "./pane-manager/layout-state";
 export { gridlockAllPanes } from "./pane-manager/gridlock";
 export type {
   DropTarget,

package/src/plugins/prediction-markets/chart.tsx

@@ -72,12 +72,14 @@ export function PredictionMarketChart({
   history,
   width,
   height,
+  loading = false,
   range,
   onRangeSelect,
 }: {
   history: PredictionHistoryPoint[];
   width: number;
   height: number;
+  loading?: boolean;
   range: PredictionHistoryRange;
   onRangeSelect: (range: PredictionHistoryRange) => void;
 }) {
@@ -93,10 +95,14 @@ export function PredictionMarketChart({
           />
         </Box>
         <Box flexGrow={1} justifyContent="center">
-          <EmptyState
-            title="No chart history."
-            hint="This venue did not return price history for the selected market."
-          />
+          {loading ? (
+            <Text fg={colors.textDim}>Loading chart...</Text>
+          ) : (
+            <EmptyState
+              title="No chart history."
+              hint="This venue did not return price history for the selected market."
+            />
+          )}
         </Box>
       </Box>
     );

package/src/plugins/prediction-markets/controller/index.ts

@@ -1,6 +1,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { type InputRenderable, type ScrollBoxRenderable } from "../../../ui";
 import { useViewport } from "../../../react/input";
+import { useAppInputCapture } from "../../../state/app/input-capture";
 import { usePaneInstance } from "../../../state/app/context";
 import {
   useDebouncedPluginPaneState,
@@ -101,6 +102,7 @@ export function usePredictionMarketsController({
   const [searchFocused, setSearchFocused] = useState(false);
   const [initialParamsApplied, setInitialParamsApplied] = useState(false);
   const appViewport = useViewport();
+  useAppInputCapture(focused && searchFocused);
 
   const scrollRef = useRef<ScrollBoxRenderable>(null);
   const headerScrollRef = useRef<ScrollBoxRenderable>(null);

package/src/plugins/prediction-markets/controller/keyboard.ts

@@ -1,6 +1,7 @@
 import { useCallback, type RefObject } from "react";
 import { type ScrollBoxRenderable } from "../../../ui";
 import { useShortcut } from "../../../react/input";
+import { isPlainArrowDown, stopSearchFocusNavigation } from "../../../utils/search-focus-navigation";
 import { getAdjacentPredictionCategoryId } from "../categories";
 import { resolvePredictionKeyboardCommand } from "../keyboard";
 import { getAdjacentPredictionVenueScope } from "../navigation";
@@ -16,7 +17,14 @@ import type {
 interface PredictionKeyboardEvent {
   name?: string;
   sequence?: string;
+  ctrl?: boolean;
+  meta?: boolean;
+  super?: boolean;
+  alt?: boolean;
+  option?: boolean;
   shift?: boolean;
+  defaultPrevented?: boolean;
+  propagationStopped?: boolean;
   preventDefault?: () => void;
   stopPropagation?: () => void;
 }
@@ -62,6 +70,25 @@ export function usePredictionControllerKeyboard({
   setVenue,
   toggleWatchlist,
 }: UsePredictionControllerKeyboardParams) {
+  const handleSearchNavigation = useCallback(
+    (event: PredictionKeyboardEvent) => {
+      if (!focused || !searchFocused) return;
+
+      if (isPlainArrowDown(event)) {
+        stopSearchFocusNavigation(event);
+        blurSearch();
+        return;
+      }
+
+      if (resolvePredictionKeyboardCommand(event) === "escape") {
+        event.stopPropagation?.();
+        event.preventDefault?.();
+        blurSearch();
+      }
+    },
+    [blurSearch, focused, searchFocused],
+  );
+
   const cycleDetailOutcome = useCallback(
     (direction: "previous" | "next") => {
       if (detailTab !== "overview" || sortedOutcomeMarkets.length === 0) {
@@ -98,15 +125,11 @@ export function usePredictionControllerKeyboard({
 
   const handleKeyboard = useCallback(
     (event: PredictionKeyboardEvent) => {
+      if (event.defaultPrevented || event.propagationStopped) return;
       if (!focused) return;
       const command = resolvePredictionKeyboardCommand(event);
 
       if (searchFocused) {
-        if (command === "escape") {
-          event.stopPropagation?.();
-          event.preventDefault?.();
-          blurSearch();
-        }
         return;
       }
 
@@ -216,5 +239,11 @@ export function usePredictionControllerKeyboard({
     ],
   );
 
+  useShortcut(handleSearchNavigation, {
+    allowEditable: true,
+    enabled: focused && searchFocused,
+    phase: "before",
+  });
+
   useShortcut(handleKeyboard);
 }

package/src/plugins/prediction-markets/detail/book.tsx

@@ -1,7 +1,7 @@
-import { Box, Text } from "../../../ui";
-import { TextAttributes } from "../../../ui";
+import { useEffect, useMemo, useState } from "react";
+import { DataTableView, type DataTableColumn } from "../../../components";
 import { colors } from "../../../theme/colors";
-import { formatNumber, padTo } from "../../../utils/format";
+import { formatNumber } from "../../../utils/format";
 import { formatPredictionProbability } from "../metrics";
 import type {
   PredictionBookLevel,
@@ -9,111 +9,156 @@ import type {
   PredictionOrderPreviewIntent,
 } from "../types";
 
-function BookTable({
-  title,
+type BookColumnId = "outcome" | "side" | "price" | "size";
+type BookColumn = DataTableColumn & { id: BookColumnId };
+
+interface BookRow {
+  id: string;
+  outcome: "yes" | "no";
+  side: "buy" | "sell";
+  level: PredictionBookLevel;
+  intent: PredictionOrderPreviewIntent;
+}
+
+const BOOK_COLUMNS: BookColumn[] = [
+  { id: "outcome", label: "OUT", width: 5 },
+  { id: "side", label: "SIDE", width: 6 },
+  { id: "price", label: "PRICE", width: 8, align: "right" },
+  { id: "size", label: "SIZE", width: 10, align: "right" },
+];
+
+function bookRowsForLevels({
   levels,
-  onSelect,
+  marketKey,
+  outcome,
+  side,
 }: {
-  title: string;
   levels: PredictionBookLevel[];
-  onSelect: (level: PredictionBookLevel) => void;
-}) {
-  return (
-    <Box flexDirection="column" flexGrow={1}>
-      <Box height={1}>
-        <Text fg={colors.textBright} attributes={TextAttributes.BOLD}>
-          {title}
-        </Text>
-      </Box>
-      <Box height={1}>
-        <Text fg={colors.textDim}>
-          {padTo("PRICE", 8)} {padTo("SIZE", 10)}
-        </Text>
-      </Box>
-      {levels.slice(0, 10).map((level) => (
-        <Box
-          key={`${title}:${level.price}:${level.size}`}
-          height={1}
-          onMouseDown={(event) => {
-            event.preventDefault();
-            onSelect(level);
-          }}
-        >
-          <Text fg={colors.text}>
-            {`${padTo(formatPredictionProbability(level.price), 8)} ${padTo(formatNumber(level.size, 0), 10, "right")}`}
-          </Text>
-        </Box>
-      ))}
-      {levels.length === 0 && <Text fg={colors.textDim}>No levels.</Text>}
-    </Box>
-  );
+  marketKey: string;
+  outcome: "yes" | "no";
+  side: "buy" | "sell";
+}): BookRow[] {
+  return levels.slice(0, 10).map((level, index) => ({
+    id: `${outcome}:${side}:${index}:${level.price}:${level.size}`,
+    outcome,
+    side,
+    level,
+    intent: {
+      marketKey,
+      outcome,
+      side,
+      price: level.price,
+      size: level.size,
+    },
+  }));
+}
+
+function buildBookRows(detail: PredictionMarketDetail): BookRow[] {
+  const marketKey = detail.summary.key;
+  return [
+    ...bookRowsForLevels({
+      levels: detail.book.yesBids,
+      marketKey,
+      outcome: "yes",
+      side: "buy",
+    }),
+    ...bookRowsForLevels({
+      levels: detail.book.yesAsks,
+      marketKey,
+      outcome: "yes",
+      side: "sell",
+    }),
+    ...bookRowsForLevels({
+      levels: detail.book.noBids,
+      marketKey,
+      outcome: "no",
+      side: "buy",
+    }),
+    ...bookRowsForLevels({
+      levels: detail.book.noAsks,
+      marketKey,
+      outcome: "no",
+      side: "sell",
+    }),
+  ];
 }
 
 export function PredictionMarketBookView({
   detail,
+  focused,
   onPreviewOrder,
+  width,
 }: {
   detail: PredictionMarketDetail;
+  focused: boolean;
   onPreviewOrder: (intent: PredictionOrderPreviewIntent) => void;
+  width: number;
 }) {
+  const rows = useMemo(() => buildBookRows(detail), [detail]);
+  const [selectedIndex, setSelectedIndex] = useState<number | null>(() =>
+    rows.length > 0 ? 0 : null,
+  );
+
+  useEffect(() => {
+    setSelectedIndex((current) => {
+      if (rows.length === 0) return null;
+      if (current == null || current >= rows.length) return 0;
+      return current;
+    });
+  }, [rows.length]);
+
   return (
-    <Box flexDirection="column" gap={1}>
-      <Box flexDirection="row" gap={2}>
-        <BookTable
-          title="YES Bids"
-          levels={detail.book.yesBids}
-          onSelect={(level) =>
-            onPreviewOrder({
-              marketKey: detail.summary.key,
-              outcome: "yes",
-              side: "buy",
-              price: level.price,
-              size: level.size,
-            })
-          }
-        />
-        <BookTable
-          title="YES Asks"
-          levels={detail.book.yesAsks}
-          onSelect={(level) =>
-            onPreviewOrder({
-              marketKey: detail.summary.key,
-              outcome: "yes",
-              side: "sell",
-              price: level.price,
-              size: level.size,
-            })
-          }
-        />
-      </Box>
-      <Box flexDirection="row" gap={2}>
-        <BookTable
-          title="NO Bids"
-          levels={detail.book.noBids}
-          onSelect={(level) =>
-            onPreviewOrder({
-              marketKey: detail.summary.key,
-              outcome: "no",
-              side: "buy",
-              price: level.price,
-              size: level.size,
-            })
-          }
-        />
-        <BookTable
-          title="NO Asks"
-          levels={detail.book.noAsks}
-          onSelect={(level) =>
-            onPreviewOrder({
-              marketKey: detail.summary.key,
-              outcome: "no",
-              side: "sell",
-              price: level.price,
-              size: level.size,
-            })
-          }
-        />
-      </Box>
-    </Box>
+    <DataTableView<BookRow, BookColumn>
+      focused={focused}
+      keyboardNavigation={focused}
+      rootWidth={width}
+      rootBackgroundColor={colors.panel}
+      selection={{
+        kind: "index",
+        selectedIndex,
+        onChange: (index) => setSelectedIndex(index),
+      }}
+      columns={BOOK_COLUMNS}
+      items={rows}
+      sortColumnId={null}
+      sortDirection="asc"
+      onHeaderClick={() => {}}
+      getItemKey={(row) => row.id}
+      onActivate={(row) => onPreviewOrder(row.intent)}
+      onRowMouseDown={(row, index, event) => {
+        event.preventDefault();
+        setSelectedIndex(index);
+        onPreviewOrder(row.intent);
+        return true;
+      }}
+      renderCell={(row, column, _index, rowState) => {
+        const color = (fallback: string) =>
+          rowState.selected ? undefined : fallback;
+        switch (column.id) {
+          case "outcome":
+            return {
+              text: row.outcome.toUpperCase(),
+              color: color(colors.textBright),
+            };
+          case "side":
+            return {
+              text: row.side === "buy" ? "BID" : "ASK",
+              color: color(row.side === "buy" ? colors.positive : colors.negative),
+            };
+          case "price":
+            return {
+              text: formatPredictionProbability(row.level.price),
+              color: color(colors.text),
+            };
+          case "size":
+            return {
+              text: formatNumber(row.level.size, 0),
+              color: color(colors.textDim),
+            };
+        }
+      }}
+      emptyStateTitle="No book levels."
+      emptyStateHint="This venue did not return current order book depth."
+    />
   );
 }

package/src/plugins/prediction-markets/detail/overview.tsx

@@ -17,6 +17,7 @@ export function PredictionMarketOverviewView({
   detailWidth,
   height,
   historyRange,
+  loading,
   onHistoryRangeChange,
   onSelectMarket,
   selectedRow,
@@ -26,6 +27,7 @@ export function PredictionMarketOverviewView({
   detailWidth: number;
   height: number;
   historyRange: PredictionHistoryRange;
+  loading: boolean;
   onHistoryRangeChange: (range: PredictionHistoryRange) => void;
   onSelectMarket: (marketKey: string) => void;
   selectedRow: PredictionListRow | null;
@@ -47,6 +49,7 @@ export function PredictionMarketOverviewView({
         history={detail?.history ?? []}
         width={detailWidth}
         height={Math.max(Math.floor(height * 0.36), 10)}
+        loading={loading}
         range={historyRange}
         onRangeSelect={onHistoryRangeChange}
       />