gloomberb 0.9.9 → 0.10.0

package/src/renderers/opentui/chart-surface.test.tsx

@@ -1,9 +1,10 @@
 import { afterEach, describe, expect, test } from "bun:test";
 import { createTestRenderer } from "@opentui/core/testing";
-import { act } from "react";
+import { act, useState } from "react";
 import { ChartSurface, Text } from "../../ui";
 import { getNativeSurfaceManager } from "../../components/chart/native/surface/manager";
 import type { ChartRendererPreference } from "../../components/chart/core/types";
+import type { CellRect } from "../../components/chart/native/chart-rasterizer";
 import { AppProvider } from "../../state/app/context";
 import { createDefaultConfig } from "../../types/config";
 import { createOpenTuiTestRoot } from "./test-utils";
@@ -23,11 +24,15 @@ function setNativeRendererReady(): void {
   (testSetup!.renderer as { _resolution: unknown })._resolution = { width: 800, height: 400 };
 }
 
-function surfaceCount(): number {
+function surfaces(): Map<string, { snapshot: { rect: CellRect; imageZIndex?: number } }> {
   const manager = getNativeSurfaceManager(testSetup!.renderer as never) as unknown as {
-    surfaces: Map<string, unknown>;
+    surfaces: Map<string, { snapshot: { rect: CellRect; imageZIndex?: number } }>;
   };
-  return manager.surfaces.size;
+  return manager.surfaces;
+}
+
+function surfaceCount(): number {
+  return surfaces().size;
 }
 
 async function flushFrames(): Promise<void> {
@@ -39,13 +44,24 @@ async function flushFrames(): Promise<void> {
   });
 }
 
-function Harness({ preference }: { preference: ChartRendererPreference }) {
+type TestCrosshair = { pixelX: number; pixelY: number; color: string } | null;
+let setHarnessCrosshair: ((crosshair: TestCrosshair) => void) | null = null;
+
+function Harness({
+  preference,
+  initialCrosshair = null,
+}: {
+  preference: ChartRendererPreference;
+  initialCrosshair?: TestCrosshair;
+}) {
   const config = createDefaultConfig(`/tmp/gloomberb-chart-surface-${preference}`);
   config.chartPreferences.renderer = preference;
+  const [crosshair, setCrosshair] = useState<TestCrosshair>(initialCrosshair);
+  setHarnessCrosshair = setCrosshair;
 
   return (
     <AppProvider config={config}>
-      <ChartSurface width={20} height={4} flexDirection="column" bitmaps={[bitmap]}>
+      <ChartSurface width={20} height={4} flexDirection="column" bitmaps={[bitmap]} crosshair={crosshair}>
         <Text>fallback chart</Text>
       </ChartSurface>
     </AppProvider>
@@ -98,4 +114,34 @@ describe("OpenTuiChartSurface", () => {
     expect(testSetup.captureCharFrame()).not.toContain("fallback chart");
     expect(surfaceCount()).toBe(1);
   });
+
+  test("overlays the crosshair as thin strips above the plot and drops them with the cursor", async () => {
+    actEnvironment.IS_REACT_ACT_ENVIRONMENT = true;
+    testSetup = await createTestRenderer({ width: 40, height: 12 });
+    setNativeRendererReady();
+    root = createOpenTuiTestRoot(testSetup.renderer);
+
+    // Cursor at the middle of a 4x4 source bitmap, scaled onto a 20x4 cell plot.
+    act(() => {
+      root!.render(<Harness preference="kitty" initialCrosshair={{ pixelX: 2, pixelY: 2, color: "#ffcc00" }} />);
+    });
+    await flushFrames();
+
+    const entries = surfaces();
+    expect(entries.size).toBe(3);
+    const vertical = [...entries].find(([id]) => id.endsWith(":crosshair-v"))![1].snapshot;
+    const horizontal = [...entries].find(([id]) => id.endsWith(":crosshair-h"))![1].snapshot;
+    // Both strips stay inside the plot and cover only the cursor's cells.
+    expect(vertical.rect).toEqual({ x: 12, y: 0, width: 3, height: 4 });
+    expect(horizontal.rect).toEqual({ x: 0, y: 2, width: 20, height: 1 });
+    expect(vertical.imageZIndex).toBe(1);
+    expect(horizontal.imageZIndex).toBe(1);
+
+    act(() => {
+      setHarnessCrosshair!(null);
+    });
+    await flushFrames();
+
+    expect(surfaceCount()).toBe(1);
+  });
 });

package/src/renderers/opentui/chart-surface.tsx

@@ -2,9 +2,11 @@ import { createElement, forwardRef, useCallback, useEffect, useMemo, useRef, use
 import {
   computeBitmapSize,
   intersectCellRects,
+  renderCrosshairStrips,
   type CellRect,
   type NativeChartBitmap,
 } from "../../components/chart/native/chart-rasterizer";
+import { scaleLocalPixelCoordinate } from "../../components/chart/core/pointer";
 import type { ChartRendererPreference } from "../../components/chart/core/types";
 import { useResolvedChartRendererState } from "../../components/chart/native/renderer-selection";
 import { getNativeSurfaceManager } from "../../components/chart/native/surface/manager";
@@ -15,6 +17,7 @@ import {
 } from "../../components/chart/native/surface/visibility";
 import { useOptionalAppSelector, useOptionalPaneInstanceId } from "../../state/app/context";
 import { useNativeRenderer, type BoxRenderable, type ChartSurfaceProps } from "../../ui";
+import type { ChartCrosshairOverlay } from "../../ui/host";
 
 interface NativeRenderableNode extends BoxRenderable, NativeSurfaceRenderableNode {
   x: number;
@@ -33,6 +36,9 @@ interface SurfaceTarget {
 
 let nextChartSurfaceId = 1;
 
+// Crosshair strips must land above the plot they annotate; plots use the kitty default.
+const CROSSHAIR_Z_INDEX = 1;
+
 function assignRef(ref: ForwardedRef<unknown>, value: unknown) {
   if (typeof ref === "function") {
     ref(value);
@@ -60,21 +66,22 @@ function sameTarget(left: SurfaceTarget | null, right: SurfaceTarget | null): bo
     && sameRect(left.visibleRect, right.visibleRect);
 }
 
-function hashBitmap(bitmap: NativeChartBitmap): string {
-  let hash = 0x811c9dc5;
-  for (let index = 0; index < bitmap.pixels.length; index += 1) {
-    hash ^= bitmap.pixels[index]!;
-    hash = Math.imul(hash, 0x01000193);
-  }
-  return (hash >>> 0).toString(16);
-}
+// ponytail: identity token instead of hashing every pixel — renderers always
+// build a new bitmap object per raster, and hashing megabytes per crosshair
+// move was the dominant cost. Mutating a bitmap in place would need a hash.
+const bitmapTokens = new WeakMap<NativeChartBitmap, string>();
+let nextBitmapToken = 1;
 
 function bitmapKey(bitmap: NativeChartBitmap): string {
-  return `${bitmap.width}x${bitmap.height}:${hashBitmap(bitmap)}`;
+  const existing = bitmapTokens.get(bitmap);
+  if (existing) return existing;
+  const token = `${bitmap.width}x${bitmap.height}:${nextBitmapToken++}`;
+  bitmapTokens.set(bitmap, token);
+  return token;
 }
 
 export const OpenTuiChartSurface = forwardRef<unknown, ChartSurfaceProps>(function OpenTuiChartSurface(
-  { children, bitmap, bitmaps, crosshair: _crosshair, nativeBitmapsEnabled = true, ...props },
+  { children, bitmap, bitmaps, crosshair, nativeBitmapsEnabled = true, ...props },
   forwardedRef,
 ) {
   const renderer = useNativeRenderer();
@@ -90,6 +97,7 @@ export const OpenTuiChartSurface = forwardRef<unknown, ChartSurfaceProps>(functi
   const renderableRef = useRef<NativeRenderableNode | null>(null);
   const [target, setTarget] = useState<SurfaceTarget | null>(null);
   const nativeBitmap = (bitmaps?.[0] ?? bitmap ?? null) as NativeChartBitmap | null;
+  const nativeCrosshair = (crosshair ?? null) as ChartCrosshairOverlay | null;
   const nativeBitmapKey = useMemo(() => (nativeBitmap ? bitmapKey(nativeBitmap) : null), [nativeBitmap]);
 
   const setRenderableRef = useCallback((node: unknown) => {
@@ -145,11 +153,17 @@ export const OpenTuiChartSurface = forwardRef<unknown, ChartSurfaceProps>(functi
     };
   }, [nativeBitmap, nativeBitmapKey, nativeSurfacesEnabled, renderer]);
 
+  const crosshairSurfaceIds = useMemo(
+    () => [`${surfaceId}:crosshair-v`, `${surfaceId}:crosshair-h`] as const,
+    [surfaceId],
+  );
+
   useEffect(() => {
     return () => {
       nativeSurfaceManager.removeSurface(surfaceId);
+      for (const id of crosshairSurfaceIds) nativeSurfaceManager.removeSurface(id);
     };
-  }, [nativeSurfaceManager, surfaceId]);
+  }, [crosshairSurfaceIds, nativeSurfaceManager, surfaceId]);
 
   useEffect(() => {
     if (!nativeSurfacesEnabled || !target?.visibleRect || !nativeBitmap) {
@@ -168,6 +182,76 @@ export const OpenTuiChartSurface = forwardRef<unknown, ChartSurfaceProps>(functi
     renderer.requestRender();
   }, [nativeBitmap, nativeSurfaceManager, nativeSurfacesEnabled, paneId, renderer, surfaceId, target]);
 
+  // Crosshair moves only re-encode two thin strips, leaving the plot image resident.
+  useEffect(() => {
+    const removeAll = () => {
+      for (const id of crosshairSurfaceIds) nativeSurfaceManager.removeSurface(id);
+    };
+    const visibleRect = target?.visibleRect;
+    if (!nativeSurfacesEnabled || !nativeCrosshair || !nativeBitmap || !target || !visibleRect || !renderer.resolution) {
+      removeAll();
+      return;
+    }
+
+    const { rect } = target;
+    const size = computeBitmapSize(rect, renderer.resolution, renderer.terminalWidth, renderer.terminalHeight);
+    const strips = renderCrosshairStrips({
+      pixelX: scaleLocalPixelCoordinate(nativeCrosshair.pixelX, nativeBitmap.width, size.pixelWidth) ?? 0,
+      pixelY: scaleLocalPixelCoordinate(nativeCrosshair.pixelY, nativeBitmap.height, size.pixelHeight) ?? 0,
+      pixelWidth: size.pixelWidth,
+      pixelHeight: size.pixelHeight,
+      cols: rect.width,
+      rows: rect.height,
+      cellWidth: size.cellWidth,
+      cellHeight: size.cellHeight,
+      color: nativeCrosshair.color,
+      markers: nativeCrosshair.markers?.map((marker) => ({
+        pixelY: scaleLocalPixelCoordinate(marker.pixelY, nativeBitmap.height, size.pixelHeight) ?? 0,
+        color: marker.color,
+      })),
+    });
+    if (strips.length === 0) {
+      removeAll();
+      return;
+    }
+
+    strips.forEach((strip, index) => {
+      const id = crosshairSurfaceIds[index];
+      if (!id) return;
+      const stripRect: CellRect = {
+        x: rect.x + strip.rect.x,
+        y: rect.y + strip.rect.y,
+        width: strip.rect.width,
+        height: strip.rect.height,
+      };
+      const stripVisibleRect = intersectCellRects(stripRect, visibleRect);
+      if (!stripVisibleRect) {
+        nativeSurfaceManager.removeSurface(id);
+        return;
+      }
+      nativeSurfaceManager.upsertSurface({
+        id,
+        paneId: paneId ?? "__global__",
+        rect: stripRect,
+        visibleRect: stripVisibleRect,
+        bitmap: strip.bitmap,
+        bitmapKey: `${strip.key}@${stripRect.x}:${stripRect.y}:${stripRect.width}x${stripRect.height}`,
+        imageZIndex: CROSSHAIR_Z_INDEX,
+      });
+    });
+    renderer.requestRender();
+  }, [
+    crosshairSurfaceIds,
+    nativeCrosshair,
+    nativeBitmap,
+    nativeSurfaceManager,
+    nativeSurfacesEnabled,
+    paneId,
+    renderer,
+    surfaceId,
+    target,
+  ]);
+
   const showFallback = !nativeSurfacesEnabled || !target || !nativeBitmap;
   return createElement("box" as any, { ...props, ref: setRenderableRef }, showFallback ? children as ReactNode : null);
 });

package/src/renderers/opentui/dialog-host.tsx

@@ -13,17 +13,48 @@ function renderDialogContent(content: unknown, context: Record<string, unknown>)
     : content as ReactNode;
 }
 
+function normalizeDialogId(value: unknown): string | undefined {
+  return typeof value === "string" || typeof value === "number" ? String(value) : undefined;
+}
+
+function OpenTuiDialogContentBridge({
+  dialog,
+  dialogId,
+  children,
+}: {
+  dialog: DialogApi;
+  dialogId: string | undefined;
+  children: ReactNode;
+}) {
+  const isTopmost = useOpenTuiDialogState(
+    (state) => normalizeDialogId(state.topDialog?.id) === dialogId,
+  );
+  return (
+    <DialogHostProvider
+      dialog={dialog}
+      isOpen={true}
+      dialogId={dialogId}
+      keyboardEnabled={isTopmost}
+    >
+      {children}
+    </DialogHostProvider>
+  );
+}
+
 function OpenTuiDialogBridge({ children }: { children: ReactNode }) {
   const openTuiDialog = useOpenTuiDialog();
   const isOpen = useOpenTuiDialogState((state) => state.isOpen);
   const dialog = useMemo<DialogApi>(() => {
     const wrapOptions = (options: Record<string, unknown>) => ({
       ...options,
-      content: (context: Record<string, unknown>) => (
-        <DialogHostProvider dialog={dialog} isOpen={true}>
-          {renderDialogContent(options.content, context)}
-        </DialogHostProvider>
-      ),
+      content: (context: Record<string, unknown>) => {
+        const dialogId = normalizeDialogId(context.dialogId);
+        return (
+          <OpenTuiDialogContentBridge dialog={dialog} dialogId={dialogId}>
+            {renderDialogContent(options.content, { ...context, dialogId })}
+          </OpenTuiDialogContentBridge>
+        );
+      },
     });
 
     return {

package/src/renderers/opentui/host.tsx

@@ -82,6 +82,9 @@ function installResolutionEventBridge(renderer: CliRenderer): void {
 export async function createOpenTuiHost(): Promise<OpenTuiHost> {
   resetTerminalInputState();
 
+  // Mouse motion is reported per pixel; our @opentui/core patch coalesces moves
+  // to one per fastest frame (~16ms) so pointer-tracked UI like the chart
+  // crosshair follows the cursor instead of stepping at 10fps.
   const renderer = await createCliRenderer({
     exitOnCtrlC: true,
     backgroundColor: colors.bg,
@@ -128,6 +131,42 @@ export async function createOpenTuiHost(): Promise<OpenTuiHost> {
     notify() {
       // The app-level notifier still owns toast/desktop notification behavior.
     },
+    async playTerminalMedia(url, title, options) {
+      const mpv = Bun.which("mpv");
+      if (!mpv) {
+        throw new Error("mpv is required for terminal TV playback. Install mpv and try again.");
+      }
+
+      renderer.suspend();
+      try {
+        const proc = Bun.spawn([
+          mpv,
+          "--no-config",
+          "--profile=sw-fast",
+          "--vo=kitty",
+          "--vo-kitty-auto-multiplexer-passthrough=yes",
+          "--ytdl=no",
+          `--mute=${options?.muted === false ? "no" : "yes"}`,
+          ...(title ? [`--title=${title}`] : []),
+          "--",
+          url,
+        ], {
+          stdin: "inherit",
+          stdout: "inherit",
+          stderr: "pipe",
+        });
+        const stderrPromise = new Response(proc.stderr).text();
+        const exitCode = await proc.exited;
+        const stderr = await stderrPromise;
+        if (exitCode !== 0) {
+          const detail = stderr.trim().split("\n").slice(-3).join(" ");
+          throw new Error(detail || `mpv exited with status ${exitCode}`);
+        }
+      } finally {
+        renderer.resume();
+        renderer.requestRender();
+      }
+    },
   };
 
   const nativeRenderer: NativeRendererHost = {

package/src/renderers/opentui/start.tsx

@@ -3,6 +3,7 @@ import { existsSync, mkdirSync } from "fs";
 import { App } from "../../app";
 import { dispatchCli } from "../../cli/index";
 import { getDataDir, initDataDir, setConfigStoreHost } from "../../data/config/store";
+import { applyLanguageFromConfig } from "../../i18n";
 import * as nodeConfigStoreHost from "../../data/config/store/node";
 import { loadExternalPlugins } from "../../plugins/loader";
 import { OpenTuiInputHostProvider } from "./input-host";
@@ -19,6 +20,12 @@ import { measurePerfAsync } from "../../utils/perf-marks";
 import type { CliLaunchRequest } from "../../types/plugin";
 import type { RemoteControlAdapter } from "../../remote/app-host";
 import { startRemoteControlServer, type RemoteControlServer } from "../../remote/server";
+import { createPiAiHost } from "../../plugins/builtin/ai/pi";
+import {
+  installAiRunHost,
+} from "../../plugins/builtin/ai/runner";
+
+const AI_STARTUP_READINESS_TIMEOUT_MS = 5_000;
 
 export interface StartOpenTuiAppOptions {
   externalPlugins?: Awaited<ReturnType<typeof loadExternalPlugins>>;
@@ -95,6 +102,29 @@ export async function startOpenTuiApp(options: StartOpenTuiAppOptions = {}): Pro
     }
 
     const config = await measurePerfAsync("startup.opentui.init-data-dir", () => initDataDir(dataDir));
+    applyLanguageFromConfig(config);
+    try {
+      const aiHost = createPiAiHost({
+        appKind: "tui",
+        dataDir: config.dataDir,
+      });
+      await measurePerfAsync(
+        "startup.opentui.ai-catalog",
+        () => installAiRunHost(aiHost, {
+          catalogTimeoutMs: AI_STARTUP_READINESS_TIMEOUT_MS,
+          timeoutMessage: "In-app AI provider discovery timed out during startup",
+          onCatalogError(error) {
+            appLog.warn("In-app AI provider discovery could not finish during startup", {
+              error: error instanceof Error ? error.message : String(error),
+            });
+          },
+        }),
+      );
+    } catch (error) {
+      appLog.warn("In-app AI providers could not be initialized", {
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
     host = await measurePerfAsync("startup.opentui.create-host", () => createOpenTuiHost());
     host.renderer.once("destroy", finishProcessExit);
 

package/src/renderers/opentui/ui-host.tsx

@@ -61,6 +61,7 @@ const OpenTuiScrollBox = createOpenTuiPrimitive("scrollbox");
 const OpenTuiInput = createOpenTuiPrimitive("input");
 const OpenTuiTextarea = createOpenTuiPrimitive("textarea");
 const OpenTuiSpinnerMark = createOpenTuiPrimitive("spinner");
+const OpenTuiMediaSurface = createOpenTuiPrimitive("box");
 
 const OpenTuiText = forwardRef<unknown, TextProps>(function OpenTuiText({ children, ...props }, ref) {
   const textProps = stripTextProps(props);
@@ -103,6 +104,7 @@ export const openTuiUiHost: UiHost = {
   Textarea: OpenTuiTextarea as UiHost["Textarea"],
   ChartSurface: OpenTuiChartSurface,
   ImageSurface: OpenTuiImageSurface,
+  MediaSurface: OpenTuiMediaSurface as UiHost["MediaSurface"],
   SpinnerMark: OpenTuiSpinnerMark as UiHost["SpinnerMark"],
   AsciiText: ({ text, font = "tiny", color, fg, bg, backgroundColor, selectable = false, ...props }) => {
     const resolvedColor = color ?? fg;

package/src/sources/provider-router/index.test.ts

@@ -209,6 +209,49 @@ describe("AssetDataRouter", () => {
     expect(holders.holders[0]?.name).toBe("Vanguard Group Inc");
   });
 
+  test("routes earnings calendars through providers and fills missing symbols from fallback", async () => {
+    const cloudCalls: string[][] = [];
+    const yahooCalls: string[][] = [];
+    const event = (symbol: string, date: string) => ({
+      symbol,
+      name: symbol,
+      earningsDate: new Date(date),
+      epsEstimate: null,
+      epsActual: null,
+      revenueEstimate: null,
+      revenueActual: null,
+      surprise: null,
+      timing: "" as const,
+    });
+    const cloudProvider: DataProvider = {
+      ...fallbackProvider,
+      id: "cloud",
+      name: "Cloud",
+      priority: 100,
+      async getEarningsCalendar(symbols) {
+        cloudCalls.push(symbols);
+        return [event("AAPL", "2026-07-30T20:00:00Z")];
+      },
+    };
+    const yahooProvider: DataProvider = {
+      ...fallbackProvider,
+      id: "yahoo",
+      name: "Yahoo",
+      priority: 1000,
+      async getEarningsCalendar(symbols) {
+        yahooCalls.push(symbols);
+        return [event("MSFT", "2026-07-29T20:00:00Z")];
+      },
+    };
+
+    const router = new AssetDataRouter(yahooProvider, [cloudProvider]);
+    const events = await router.getEarningsCalendar(["msft", " AAPL ", "aapl"]);
+
+    expect(cloudCalls).toEqual([["MSFT", "AAPL"]]);
+    expect(yahooCalls).toEqual([["MSFT"]]);
+    expect(events.map((entry) => entry.symbol)).toEqual(["MSFT", "AAPL"]);
+  });
+
   test("falls back to later analyst providers when rating targets are missing", async () => {
     const cloudProvider: DataProvider = {
       ...fallbackProvider,

package/src/sources/provider-router/index.ts

@@ -215,6 +215,10 @@ export class AssetDataRouter implements DataProvider {
     return this.supplementalRoutes.getCorporateActions(ticker, exchange, context);
   }
 
+  async getEarningsCalendar(symbols: string[], context?: MarketDataRequestContext) {
+    return this.supplementalRoutes.getEarningsCalendar(symbols, context);
+  }
+
   async getSecFilings(ticker: string, count = 15, exchange?: string, context?: MarketDataRequestContext): Promise<SecFilingItem[]> {
     return this.documentRoutes.getSecFilings(ticker, count, exchange, context);
   }

package/src/sources/provider-router/supplemental.ts

@@ -1,5 +1,6 @@
 import type {
   DataProvider,
+  EarningsEvent,
   MarketDataRequestContext,
 } from "../../types/data-provider";
 import type {
@@ -120,6 +121,51 @@ export class ProviderRouterSupplementalRoutes {
     throw new Error(`No corporate actions provider available for ${ticker}`);
   }
 
+  async getEarningsCalendar(
+    symbols: string[],
+    context?: MarketDataRequestContext,
+  ): Promise<EarningsEvent[]> {
+    const remaining = new Set(
+      symbols
+        .map((symbol) => symbol.trim().toUpperCase())
+        .filter(Boolean),
+    );
+    if (remaining.size === 0) return [];
+
+    const eventsBySymbol = new Map<string, EarningsEvent>();
+    let supported = false;
+    let succeeded = false;
+    let lastError: unknown = null;
+
+    for (const provider of this.deps.providersInPriorityOrder()) {
+      if (!provider.getEarningsCalendar || remaining.size === 0) continue;
+      supported = true;
+      try {
+        const events = await provider.getEarningsCalendar([...remaining], context);
+        succeeded = true;
+        for (const event of events) {
+          const symbol = event.symbol.trim().toUpperCase();
+          if (!remaining.has(symbol)) continue;
+          eventsBySymbol.set(symbol, event);
+          remaining.delete(symbol);
+        }
+      } catch (error) {
+        lastError = error;
+        if (shouldLogProviderError(error)) {
+          this.deps.logProviderError(`${provider.id} failed: ${error}`);
+        }
+      }
+    }
+
+    if (eventsBySymbol.size > 0 || succeeded) {
+      return [...eventsBySymbol.values()]
+        .sort((a, b) => a.earningsDate.getTime() - b.earningsDate.getTime());
+    }
+    if (lastError) throw lastError;
+    if (!supported) throw new Error("No earnings calendar provider available");
+    return [];
+  }
+
   async getOptionsChain(ticker: string, exchange?: string, expirationDate?: number, context?: MarketDataRequestContext): Promise<OptionsChain> {
     const entityKey = this.deps.getEntityKey(ticker, context?.instrument);
     const variantKeys = [