gloomberb 0.11.0 → 0.11.2

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

@@ -2,10 +2,12 @@ import { describe, expect, test } from "bun:test";
 import { cloneLayout, createDefaultConfig, createPaneInstance, type LayoutConfig } from "../types/config";
 import {
   addPaneFloating,
+  analyzeFloatingPaneVisibility,
   applyDrop,
   floatAtRect,
   getDockResizeTargets,
   gridlockAllPanes,
+  shouldShowTidyWindows,
   getDockDividerLayouts,
   getDockLeafLayouts,
   getDockedPaneIds,
@@ -122,6 +124,34 @@ describe("pane-manager split-tree drops", () => {
     expect(getDockedPaneIds(next)).toHaveLength(layout.instances.length);
   });
 
+  test("detects a floating pane whose title bar is buried", () => {
+    const layout: LayoutConfig = {
+      dockRoot: null,
+      instances: [
+        createPaneInstance("chat", { instanceId: "lower" }),
+        createPaneInstance("chat", { instanceId: "upper" }),
+      ],
+      floating: [
+        { instanceId: "lower", x: 0, y: 0, width: 40, height: 20, zIndex: 10 },
+        { instanceId: "upper", x: 0, y: 0, width: 40, height: 4, zIndex: 20 },
+      ],
+      detached: [],
+    };
+
+    const visibility = analyzeFloatingPaneVisibility(layout);
+    const lower = visibility.find((pane) => pane.instanceId === "lower");
+    expect(lower?.visibleRatio).toBeCloseTo(0.8);
+    expect(lower?.titleBarVisibleRatio).toBe(0);
+    expect(lower?.buried).toBe(true);
+    expect(shouldShowTidyWindows(layout)).toBe(true);
+
+    const separated = {
+      ...layout,
+      floating: [layout.floating[0]!, { ...layout.floating[1]!, x: 50 }],
+    };
+    expect(shouldShowTidyWindows(separated)).toBe(false);
+  });
+
   test("gridlock drops pane types that cannot render before tiling", () => {
     const layout: LayoutConfig = {
       dockRoot: {

package/src/plugins/pane-manager.ts

@@ -55,7 +55,12 @@ export {
   removeUnavailablePaneTypes,
   type PaneTypeAvailability,
 } from "./pane-manager/layout-state";
-export { gridlockAllPanes } from "./pane-manager/gridlock";
+export {
+  analyzeFloatingPaneVisibility,
+  gridlockAllPanes,
+  shouldShowTidyWindows,
+  type FloatingPaneVisibility,
+} from "./pane-manager/gridlock";
 export type {
   DropTarget,
   FloatingResizeCorner,

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

@@ -146,8 +146,8 @@ export function PredictionMarketChart({
       <CompositeChart
         width={width}
         height={chartHeight}
-        focused={false}
-        interactive={false}
+        focused={focused}
+        interactive
         series={[priceSeries]}
         panels={[{ id: "price" }]}
         axisWidth={8}

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

@@ -13,8 +13,8 @@ import {
 } from "./status";
 import { useAutoRefresh } from "../../builtin/shared/auto-refresh";
 import { getCachedPredictionResource } from "../services/fetch";
-import { loadKalshiCatalog } from "../services/kalshi/adapter";
-import { loadPolymarketCatalog } from "../services/polymarket/adapter";
+import { kalshiCatalogCursor, loadKalshiCatalog, loadMoreKalshiCatalog } from "../services/kalshi/adapter";
+import { loadMorePolymarketCatalog, loadPolymarketCatalog, nextPolymarketCatalogOffset } from "../services/polymarket/adapter";
 import type {
   PredictionCategoryId,
   PredictionMarketSummary,
@@ -46,6 +46,9 @@ export function usePredictionCatalogData({
   const [debouncedSearchQuery, setDebouncedSearchQuery] = useState(searchQuery);
   const [polymarketLoadedAt, setPolymarketLoadedAt] = useState<number | null>(null);
   const [kalshiLoadedAt, setKalshiLoadedAt] = useState<number | null>(null);
+  const [polymarketNextOffset, setPolymarketNextOffset] = useState<number | null>(null);
+  const [kalshiNextCursor, setKalshiNextCursor] = useState<string | null>(null);
+  const [loadingMore, setLoadingMore] = useState(false);
   const activeCatalogRef = useRef<PredictionCatalogCache>({});
 
   const normalizedCatalogQuery = debouncedSearchQuery.trim().toLowerCase();
@@ -192,6 +195,7 @@ export function usePredictionCatalogData({
         setCatalogErrors((current) =>
           updatePredictionErrorState(current, cacheKey, null),
         );
+        setPolymarketNextOffset(nextPolymarketCatalogOffset(category, search));
       } catch (error) {
         setCatalogErrors((current) =>
           updatePredictionErrorState(
@@ -243,6 +247,7 @@ export function usePredictionCatalogData({
         setCatalogErrors((current) =>
           updatePredictionErrorState(current, cacheKey, null),
         );
+        setKalshiNextCursor(kalshiCatalogCursor(search, category));
       } catch (error) {
         setCatalogErrors((current) =>
           updatePredictionErrorState(
@@ -310,11 +315,81 @@ export function usePredictionCatalogData({
     void loadKalshi(kalshiCatalogKey, debouncedSearchQuery, categoryId);
   }, [categoryId, debouncedSearchQuery, kalshiCatalogKey, loadKalshi]));
 
+  const loadMoreCatalog = useCallback(async () => {
+    if (loadingMore) return;
+    const canLoadPolymarket = includePolymarket && polymarketNextOffset != null;
+    const canLoadKalshi = includeKalshi && !!kalshiNextCursor;
+    if (!canLoadPolymarket && !canLoadKalshi) return;
+    setLoadingMore(true);
+    try {
+      if (canLoadPolymarket && polymarketNextOffset != null) {
+        const page = await loadMorePolymarketCatalog(
+          debouncedSearchQuery,
+          categoryId,
+          polymarketNextOffset,
+        );
+        setCatalogCache((current) => ({
+          ...current,
+          [polymarketCatalogKey]: mergeCatalogMarkets(
+            current[polymarketCatalogKey] ?? activeCatalogRef.current[polymarketCatalogKey] ?? [],
+            page.markets,
+          ),
+        }));
+        setPolymarketNextOffset(page.hasMore ? page.nextOffset : null);
+      }
+      if (canLoadKalshi && kalshiNextCursor) {
+        const page = await loadMoreKalshiCatalog(
+          debouncedSearchQuery,
+          categoryId,
+          kalshiNextCursor,
+        );
+        setCatalogCache((current) => ({
+          ...current,
+          [kalshiCatalogKey]: mergeCatalogMarkets(
+            current[kalshiCatalogKey] ?? activeCatalogRef.current[kalshiCatalogKey] ?? [],
+            page.markets,
+          ),
+        }));
+        setKalshiNextCursor(page.nextCursor);
+      }
+    } finally {
+      setLoadingMore(false);
+    }
+  }, [
+    categoryId,
+    debouncedSearchQuery,
+    includeKalshi,
+    includePolymarket,
+    kalshiCatalogKey,
+    kalshiNextCursor,
+    loadingMore,
+    polymarketCatalogKey,
+    polymarketNextOffset,
+  ]);
+
   return {
     allMarkets,
+    catalogHasMore: (includePolymarket && polymarketNextOffset != null) || (includeKalshi && !!kalshiNextCursor),
     catalogLoadCount,
+    catalogLoadingMore: loadingMore,
     catalogStatus,
     debouncedSearchQuery,
+    loadMoreCatalog,
     setCatalogCache,
   };
 }
+
+function mergeCatalogMarkets(
+  current: PredictionMarketSummary[],
+  extra: PredictionMarketSummary[],
+): PredictionMarketSummary[] {
+  if (extra.length === 0) return current;
+  const seen = new Set(current.map((market) => market.key));
+  const merged = [...current];
+  for (const market of extra) {
+    if (seen.has(market.key)) continue;
+    seen.add(market.key);
+    merged.push(market);
+  }
+  return merged;
+}

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

@@ -53,9 +53,12 @@ export function usePredictionMarketsDataState({
 }) {
   const {
     allMarkets,
+    catalogHasMore,
     catalogLoadCount,
+    catalogLoadingMore,
     catalogStatus,
     debouncedSearchQuery,
+    loadMoreCatalog,
     setCatalogCache,
   } = usePredictionCatalogData({
     categoryId,
@@ -150,13 +153,16 @@ export function usePredictionMarketsDataState({
   });
 
   return {
-    catalogStatus,
+    catalogHasMore,
     catalogLoadCount,
+    catalogLoadingMore,
+    catalogStatus,
     debouncedSearchQuery,
     detail,
     detailError,
     detailLoadCount,
     lastRefreshAt,
+    loadMoreCatalog,
     selectedIndex,
     selectedRow,
     selectedSummary,

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

@@ -56,10 +56,14 @@ export function usePredictionMarketsController({
     "browseTab",
     paneSettings.defaultBrowseTab,
   );
-  const [detailTab, setDetailTab] = usePluginPaneState<PredictionDetailTab>(
+  const [storedDetailTab, setDetailTab] = usePluginPaneState<PredictionDetailTab>(
     "detailTab",
     "overview",
   );
+  const detailTab = storedDetailTab === "chart" ? "overview" : storedDetailTab;
+  useEffect(() => {
+    if (storedDetailTab === "chart") setDetailTab("overview");
+  }, [setDetailTab, storedDetailTab]);
   const [searchQuery, setSearchQuery] = usePluginPaneState<string>(
     "searchQuery",
     "",
@@ -316,8 +320,10 @@ export function usePredictionMarketsController({
     paneSettings,
     browseTab,
     categoryId,
-    catalogStatus: data.catalogStatus,
+    catalogHasMore: data.catalogHasMore,
     catalogLoadCount: data.catalogLoadCount,
+    catalogLoadingMore: data.catalogLoadingMore,
+    catalogStatus: data.catalogStatus,
     detail: data.detail,
     detailError: data.detailError,
     detailLoadCount: data.detailLoadCount,
@@ -344,6 +350,7 @@ export function usePredictionMarketsController({
     actions: {
       blurSearch,
       closeDetail,
+      loadMoreCatalog: data.loadMoreCatalog,
       focusSearch,
       handleSortHeaderClick,
       openSelectedRow,

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

@@ -134,27 +134,23 @@ export function usePredictionControllerKeyboard({
       }
 
       if (detailOpen) {
-        if (command === "move-down") {
-          event.stopPropagation?.();
-          event.preventDefault?.();
-          if (detailTab === "overview" && sortedOutcomeMarkets.length > 0) {
-            cycleDetailOutcome("next");
-          } else {
-            scrollDetailBy(1);
+        if (detailTab === "overview" && sortedOutcomeMarkets.length > 0) {
+          if (command === "move-down" || command === "move-up") {
+            event.stopPropagation?.();
+            event.preventDefault?.();
+            cycleDetailOutcome(command === "move-down" ? "next" : "previous");
           }
           return;
         }
 
-        if (command === "move-up") {
+        if (
+          (detailTab === "overview" || detailTab === "rules")
+          && (command === "move-down" || command === "move-up")
+        ) {
           event.stopPropagation?.();
           event.preventDefault?.();
-          if (detailTab === "overview" && sortedOutcomeMarkets.length > 0) {
-            cycleDetailOutcome("previous");
-          } else {
-            scrollDetailBy(-1);
-          }
+          scrollDetailBy(command === "move-down" ? 1 : -1);
         }
-
         return;
       }
 

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

@@ -2,7 +2,9 @@ import { Box, Text } from "../../../ui";
 import { TextAttributes } from "../../../ui";
 import { colors } from "../../../theme/colors";
 import { formatPercentRaw } from "../../../utils/format";
+import { PredictionMarketChart } from "../chart";
 import type {
+  PredictionHistoryRange,
   PredictionListRow,
   PredictionMarketDetail,
   PredictionMarketSummary,
@@ -13,12 +15,22 @@ import { SummaryLink } from "./shared";
 export function PredictionMarketOverviewView({
   detail,
   detailWidth,
+  focused,
+  height,
+  historyRange,
+  loading,
+  onHistoryRangeChange,
   onSelectMarket,
   selectedRow,
   summary,
 }: {
   detail: PredictionMarketDetail | null;
   detailWidth: number;
+  focused: boolean;
+  height: number;
+  historyRange: PredictionHistoryRange;
+  loading: boolean;
+  onHistoryRangeChange: (range: PredictionHistoryRange) => void;
   onSelectMarket: (marketKey: string) => void;
   selectedRow: PredictionListRow | null;
   summary: PredictionMarketSummary;
@@ -35,6 +47,15 @@ export function PredictionMarketOverviewView({
           selectedRow={selectedRow}
         />
       )}
+      <PredictionMarketChart
+        history={detail?.history ?? []}
+        width={detailWidth}
+        height={Math.max(Math.floor(height * 0.36), 10)}
+        loading={loading}
+        focused={focused}
+        range={historyRange}
+        onRangeSelect={onHistoryRangeChange}
+      />
       <SummaryLink
         url={summary.url}
         maxLength={Math.max(detailWidth - 8, 12)}

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

@@ -25,7 +25,6 @@ import { PredictionMarketOverviewView } from "./overview";
 import { PredictionMarketRulesView } from "./rules";
 import { truncatePredictionText } from "./shared";
 import { PredictionMarketTradesView } from "./trades";
-import { PredictionMarketChart } from "../chart";
 
 type RelatedMarketPointerEvent = { preventDefault(): void };
 
@@ -210,7 +209,14 @@ export function PredictionMarketDetailPane({
   const detailTextWidth = Math.max(detailWidth, 12);
 
   return (
-    <>
+    <Box
+      flexDirection="column"
+      flexGrow={1}
+      flexShrink={1}
+      flexBasis={0}
+      minHeight={0}
+      overflow="hidden"
+    >
       {headerHeight > 0 && (
         <Box flexDirection="column" height={headerHeight} paddingBottom={1}>
           <Box flexDirection="row" height={1}>
@@ -274,11 +280,22 @@ export function PredictionMarketDetailPane({
       )}
 
       {detailTab === "overview" || detailTab === "rules" ? (
-        <ScrollBox ref={scrollRef} flexGrow={1} scrollY>
+        <ScrollBox
+          ref={scrollRef}
+          flexGrow={1}
+          flexShrink={1}
+          flexBasis={0}
+          scrollY
+        >
           {detailTab === "overview" && (
             <PredictionMarketOverviewView
               detail={detail}
               detailWidth={detailWidth}
+              focused={focused}
+              height={height}
+              historyRange={historyRange}
+              loading={detailLoading}
+              onHistoryRangeChange={onHistoryRangeChange}
               onSelectMarket={onSelectMarket}
               selectedRow={selectedRow}
               summary={summaryMetrics}
@@ -294,42 +311,34 @@ export function PredictionMarketDetailPane({
         </ScrollBox>
       ) : null}
 
-      {detailTab === "chart" && (
-        <PredictionMarketChart
-          history={detail?.history ?? []}
-          width={detailWidth}
-          height={Math.max(height - 8, 8)}
-          loading={detailLoading}
-          focused={focused}
-          range={historyRange}
-          onRangeSelect={onHistoryRangeChange}
-        />
-      )}
-
       {detailTab === "book" && (
-        detail ? (
-          <PredictionMarketBookView
-            detail={detail}
-            focused={focused}
-            width={detailWidth}
-          />
-        ) : (
-          <Box flexGrow={1} justifyContent="center">
-            <EmptyState
-              title={detailLoading ? "Loading order book." : "No order book."}
-              hint="This venue did not return current order book depth."
+        <Box flexGrow={1} flexShrink={1} flexBasis={0} overflow="hidden">
+          {detail ? (
+            <PredictionMarketBookView
+              detail={detail}
+              focused={focused}
+              width={detailWidth}
             />
-          </Box>
-        )
+          ) : (
+            <Box flexGrow={1} justifyContent="center">
+              <EmptyState
+                title={detailLoading ? "Loading order book." : "No order book."}
+                hint="This venue did not return current order book depth."
+              />
+            </Box>
+          )}
+        </Box>
       )}
 
       {detailTab === "trades" && (
-        <PredictionMarketTradesView
-          focused={focused}
-          trades={detail?.trades ?? []}
-          width={detailWidth}
-        />
+        <Box flexGrow={1} flexShrink={1} flexBasis={0} overflow="hidden">
+          <PredictionMarketTradesView
+            focused={focused}
+            trades={detail?.trades ?? []}
+            width={detailWidth}
+          />
+        </Box>
       )}
-    </>
+    </Box>
   );
 }

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

@@ -1,3 +1,4 @@
+import { useEffect, useState } from "react";
 import { DataTableView, type DataTableColumn } from "../../../components";
 import { colors } from "../../../theme/colors";
 import { formatNumber } from "../../../utils/format";
@@ -24,20 +25,44 @@ export function PredictionMarketTradesView({
   trades: PredictionTrade[];
   width: number;
 }) {
+  const visibleTrades = trades.slice(0, 30);
+  const [selectedIndex, setSelectedIndex] = useState<number | null>(() =>
+    visibleTrades.length > 0 ? 0 : null,
+  );
+
+  useEffect(() => {
+    setSelectedIndex((current) => {
+      if (visibleTrades.length === 0) return null;
+      if (current == null || current >= visibleTrades.length) return 0;
+      return current;
+    });
+  }, [visibleTrades.length]);
+
   return (
     <DataTableView<PredictionTrade, TradeColumn>
       focused={focused}
-      keyboardNavigation={false}
+      keyboardNavigation={focused}
       rootWidth={width}
       rootBackgroundColor={colors.panel}
-      selection={{ kind: "none" }}
+      selection={{
+        kind: "index",
+        selectedIndex,
+        onChange: (index) => setSelectedIndex(index),
+      }}
       columns={TRADE_COLUMNS}
-      items={trades.slice(0, 30)}
+      items={visibleTrades}
       sortColumnId={null}
       sortDirection="asc"
       onHeaderClick={() => {}}
       getItemKey={(trade) => trade.id}
-      renderCell={(trade, column) => {
+      onRowMouseDown={(_trade, index, event) => {
+        event.preventDefault();
+        setSelectedIndex(index);
+        return true;
+      }}
+      renderCell={(trade, column, _index, rowState) => {
+        const color = (fallback: string) =>
+          rowState.selected ? undefined : fallback;
         const tradeColor = trade.side === "buy" ? colors.positive : colors.negative;
         switch (column.id) {
           case "time":
@@ -45,27 +70,27 @@ export function PredictionMarketTradesView({
               text: new Date(trade.timestamp).toLocaleTimeString("en-US", {
                 hour12: false,
               }),
-              color: colors.textDim,
+              color: color(colors.textDim),
             };
           case "side":
             return {
               text: trade.side.toUpperCase(),
-              color: tradeColor,
+              color: color(tradeColor),
             };
           case "outcome":
             return {
               text: trade.outcome.toUpperCase(),
-              color: colors.text,
+              color: color(colors.text),
             };
           case "price":
             return {
               text: formatPredictionProbability(trade.price),
-              color: tradeColor,
+              color: color(tradeColor),
             };
           case "size":
             return {
               text: formatNumber(trade.size, 0),
-              color: colors.textDim,
+              color: color(colors.textDim),
             };
         }
       }}

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

@@ -1,4 +1,5 @@
 import { afterEach, describe, expect, test } from "bun:test";
+import { act } from "react";
 import { testRender } from "../../renderers/opentui/test-utils";
 import {
   ChartHarness,
@@ -32,7 +33,7 @@ describe("prediction markets detail views", () => {
     expect(frame).not.toContain("TypeError");
   });
 
-  test("renders grouped selections as ranked outcomes in the detail overview", async () => {
+  test("renders grouped outcomes with their chart directly below", async () => {
     testSetup = await testRender(<GroupedDetailHarness />, {
       width: 64,
       height: 24,
@@ -43,6 +44,9 @@ describe("prediction markets detail views", () => {
     expect(frame).toContain("Outcomes");
     expect(frame).toContain("Above 4.25%");
     expect(frame).toContain("Above 4.50%");
+    expect(frame).toContain("1M");
+    expect(frame.indexOf("1M")).toBeGreaterThan(frame.indexOf("Above 4.50%"));
+    expect(frame).not.toContain(" Chart ");
     expect(frame).not.toContain("Ranked by implied YES probability.");
     expect(frame).not.toContain("TOP Above 4.25%");
     expect(frame).not.toContain("Kalshi");
@@ -59,9 +63,32 @@ describe("prediction markets detail views", () => {
     const frame = testSetup.captureCharFrame();
     expect(frame).toContain("Outcomes");
     expect(frame).toContain("Above 4.25%");
-    expect(frame).toContain("Chart");
+    expect(frame).toContain("Loading chart...");
     expect(frame).not.toContain("No chart history.");
     expect(frame).not.toContain("Loading market detail...");
   });
 
+  test("shows the chart crosshair on pointer movement", async () => {
+    testSetup = await testRender(
+      <ChartHarness
+        history={[
+          { date: "2026-04-01T00:00:00Z", close: 0.45 },
+          { date: "2026-04-02T00:00:00Z", close: 0.48 },
+          { date: "2026-04-03T00:00:00Z", close: 0.51 },
+        ]}
+      />,
+      { width: 80, height: 12 },
+    );
+    await flushFrames(testSetup);
+    const initialFrame = testSetup.captureCharFrame();
+
+    await act(async () => {
+      await testSetup!.mockMouse.moveTo(30, 5);
+      await testSetup!.renderOnce();
+    });
+    await flushFrames(testSetup);
+
+    expect(testSetup.captureCharFrame()).not.toBe(initialFrame);
+  });
+
 });

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

@@ -1,4 +1,5 @@
 import type { GloomPlugin, GloomPluginContext } from "../../types/plugin";
+import { resolvePaneInstance } from "../../types/config";
 import { parsePredictionSearchShortcut } from "./navigation";
 import { PredictionMarketsPane } from "./pane";
 import { attachPredictionMarketsPersistence, resetPredictionMarketsPersistence } from "./services/fetch";
@@ -15,10 +16,13 @@ const MAIN_INSTANCE_ID = `${PANE_ID}:main`;
 
 function openPredictionMarkets(ctx: GloomPluginContext, query = ""): void {
   const parsed = parsePredictionSearchShortcut(query);
-  ctx.resume.setPaneState(MAIN_INSTANCE_ID, "venueScope", parsed.venueScope);
-  ctx.resume.setPaneState(MAIN_INSTANCE_ID, "searchQuery", parsed.searchQuery);
-  ctx.resume.setPaneState(MAIN_INSTANCE_ID, "selectedMarketKey", null);
-  ctx.focusPane(PANE_ID);
+  const existingInstanceId = resolvePaneInstance(ctx.getConfig().layout, PANE_ID)?.instanceId;
+  const targetInstanceId = existingInstanceId ?? MAIN_INSTANCE_ID;
+  ctx.resume.setPaneState(targetInstanceId, "venueScope", parsed.venueScope);
+  ctx.resume.setPaneState(targetInstanceId, "searchQuery", parsed.searchQuery);
+  ctx.resume.setPaneState(targetInstanceId, "selectedRowKey", null);
+  ctx.resume.setPaneState(targetInstanceId, "selectedDetailMarketKey", null);
+  ctx.focusPane(existingInstanceId ?? PANE_ID);
 }
 
 export const predictionMarketsPlugin: GloomPlugin = {

package/src/plugins/prediction-markets/navigation.ts

@@ -28,7 +28,6 @@ export const DETAIL_TABS: ReadonlyArray<{
   value: PredictionDetailTab;
 }> = [
   { label: "Overview", value: "overview" },
-  { label: "Chart", value: "chart" },
   { label: "Book", value: "book" },
   { label: "Trades", value: "trades" },
   { label: "Rules", value: "rules" },