gloomberb 0.10.0 → 0.10.2

package/src/renderers/electrobun/view/native-stubs/native-stubs.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, test } from "bun:test";
+import { Glob } from "bun";
+import * as realSurfaceSync from "../../../../components/chart/native/surface/sync";
+import * as realKittySupport from "../../../../components/chart/native/kitty/support";
+import { NativeSurfaceManager as StubNativeSurfaceManager } from "./chart/surface-manager";
+import * as stubSurfaceSync from "./chart/surface-sync";
+import * as stubKittySupport from "./chart/kitty-support";
+
+// The desktop view bundle aliases these modules to the stubs in this directory
+// (see build-assets.ts COMMON_ALIAS_RULES). A method the app calls but the stub
+// lacks is a desktop startup crash, not a type error, so check the shapes here.
+
+function exportedFunctions(module: Record<string, unknown>): string[] {
+  return Object.keys(module)
+    .filter((name) => typeof module[name] === "function")
+    .sort();
+}
+
+async function calledSurfaceManagerMethods(): Promise<string[]> {
+  const calls = new Set<string>();
+  const pattern = /\b\w*[sS]urfaceManager(?:\.current)?\.([a-zA-Z]\w*)\s*\(/g;
+  for await (const path of new Glob("src/**/*.{ts,tsx}").scan(".")) {
+    if (path.includes("native-stubs") || path.includes("native/surface/manager")) continue;
+    for (const match of (await Bun.file(path).text()).matchAll(pattern)) {
+      calls.add(match[1]!);
+    }
+  }
+  return [...calls].sort();
+}
+
+describe("desktop view native stubs", () => {
+  test("surface manager stub answers every method the app calls on it", async () => {
+    const called = await calledSurfaceManagerMethods();
+    expect(called.length).toBeGreaterThan(3);
+    const stub = StubNativeSurfaceManager.prototype as unknown as Record<string, unknown>;
+    expect(called.filter((name) => typeof stub[name] !== "function")).toEqual([]);
+  });
+
+  test("module stubs export every function of the modules they replace", () => {
+    expect(
+      exportedFunctions(realSurfaceSync).filter((name) => !exportedFunctions(stubSurfaceSync).includes(name)),
+    ).toEqual([]);
+    expect(
+      exportedFunctions(realKittySupport).filter((name) => !exportedFunctions(stubKittySupport).includes(name)),
+    ).toEqual([]);
+  });
+});

package/src/renderers/electrobun/view/remote/asset-data-client.ts

@@ -4,6 +4,7 @@ import type { DataProvider, QuoteSubscriptionTarget } from "../../../../types/da
 import type { Quote, TickerFinancials } from "../../../../types/financials";
 import { backendRequest, getElectrobunBackendInitSnapshot, onCapabilityEvent } from "../backend-rpc";
 import { createCapabilityInvoker } from "./capability-invoker";
+import { RemoteQuoteSubscriptionRegistry } from "./quote-subscription-registry";
 
 const ASSET_DATA_CAPABILITY_ID = "asset-data.asset-data-router";
 const NEWS_CAPABILITY_ID = "news.core";
@@ -75,17 +76,10 @@ export function createRemoteAssetDataClient(): RemoteAssetDataClient {
   const assetDataOperations = getRendererOperationIds(ASSET_DATA_CAPABILITY_ID);
   const newsOperations = getRendererOperationIds(NEWS_CAPABILITY_ID);
   let nextSubscriptionId = 1;
-  const quoteListeners = new Map<string, {
-    target: QuoteSubscriptionTarget;
-    listeners: Set<(target: QuoteSubscriptionTarget, quote: Quote) => void>;
-  }>();
   let quoteBackendSubscriptionId: string | null = null;
   let disposeQuoteBackendMessages: (() => void) | null = null;
   let quoteBackendFlushTimer: ReturnType<typeof setTimeout> | null = null;
 
-  const quoteTargetKey = (target: QuoteSubscriptionTarget) =>
-    `${target.symbol}:${target.exchange ?? ""}:${target.context?.brokerId ?? ""}:${target.context?.brokerInstanceId ?? ""}:${target.context?.instrument?.conId ?? target.context?.instrument?.localSymbol ?? target.context?.instrument?.symbol ?? ""}`;
-
   const scheduleQuoteBackendSubscriptionFlush = () => {
     if (quoteBackendFlushTimer) return;
     quoteBackendFlushTimer = setTimeout(() => {
@@ -94,9 +88,11 @@ export function createRemoteAssetDataClient(): RemoteAssetDataClient {
     }, 25);
   };
 
+  const quoteSubscriptions = new RemoteQuoteSubscriptionRegistry(scheduleQuoteBackendSubscriptionFlush);
+
   const flushQuoteBackendSubscription = () => {
     if (!hasRendererOperation(assetDataOperations, "subscribeQuotes")) return;
-    const targets = [...quoteListeners.values()].map((entry) => entry.target);
+    const targets = quoteSubscriptions.backendTargets();
     const previousSubscriptionId = quoteBackendSubscriptionId;
     if (previousSubscriptionId) {
       quoteBackendSubscriptionId = null;
@@ -110,10 +106,7 @@ export function createRemoteAssetDataClient(): RemoteAssetDataClient {
     quoteBackendSubscriptionId = subscriptionId;
     disposeQuoteBackendMessages = onCapabilityEvent(subscriptionId, (message) => {
       const event = message.event as { target: QuoteSubscriptionTarget; quote: Quote };
-      const key = quoteTargetKey(event.target);
-      for (const listener of quoteListeners.get(key)?.listeners ?? []) {
-        listener(event.target, event.quote);
-      }
+      quoteSubscriptions.dispatch(event.target, event.quote);
     });
     void backendRequest("capability.subscribe", {
       subscriptionId,
@@ -145,38 +138,7 @@ export function createRemoteAssetDataClient(): RemoteAssetDataClient {
     ),
     subscribeQuotes: (targets, onQuote) => {
       if (!hasRendererOperation(assetDataOperations, "subscribeQuotes")) return () => {};
-      const uniqueTargets = [...new Map(
-        targets.map((target) => [
-          quoteTargetKey(target),
-          target,
-        ] as const),
-      ).values()];
-      if (uniqueTargets.length === 0) return () => {};
-
-      let disposed = false;
-      for (const target of uniqueTargets) {
-        const key = quoteTargetKey(target);
-        const entry = quoteListeners.get(key) ?? { target, listeners: new Set() };
-        entry.target = target;
-        entry.listeners.add(onQuote);
-        quoteListeners.set(key, entry);
-      }
-      scheduleQuoteBackendSubscriptionFlush();
-
-      return () => {
-        if (disposed) return;
-        disposed = true;
-        for (const target of uniqueTargets) {
-          const key = quoteTargetKey(target);
-          const entry = quoteListeners.get(key);
-          if (!entry) continue;
-          entry.listeners.delete(onQuote);
-          if (entry.listeners.size === 0) {
-            quoteListeners.delete(key);
-          }
-        }
-        scheduleQuoteBackendSubscriptionFlush();
-      };
+      return quoteSubscriptions.subscribe(targets, onQuote);
     },
   };
 

package/src/renderers/electrobun/view/remote/persistence.ts

@@ -16,7 +16,9 @@ class RemoteSessionStore {
     schemaVersion: number;
   }>({
     delayMs: SESSION_SAVE_DEBOUNCE_MS,
-    save: ({ sessionId, value, schemaVersion }) => backendRequest("session.set", { sessionId, value, schemaVersion }),
+    save: async ({ sessionId, value, schemaVersion }) => {
+      await backendRequest("session.set", { sessionId, value, schemaVersion });
+    },
   });
 
   get<T>(sessionId = "app", schemaVersion = 1) {
@@ -138,7 +140,9 @@ class RemotePluginStateStore {
     this.pendingBackendSaves.clear();
     const save = this.backendSaveInFlight
       .catch(() => {})
-      .then(() => backendRequest<void>("pluginState.setMany", { entries }))
+      .then(async () => {
+        await backendRequest("pluginState.setMany", { entries });
+      })
       .catch(() => {});
     this.backendSaveInFlight = save;
     return save;

package/src/renderers/electrobun/view/remote/quote-subscription-registry.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, test } from "bun:test";
+import type { QuoteSubscriptionTarget } from "../../../../types/data-provider";
+import type { Quote } from "../../../../types/financials";
+import { RemoteQuoteSubscriptionRegistry } from "./quote-subscription-registry";
+
+const lowPriorityTarget: QuoteSubscriptionTarget = {
+  symbol: "TSLA",
+  exchange: "NASDAQ",
+  surface: "watchlist",
+  visible: true,
+  selected: false,
+  weight: 10,
+};
+
+const highPriorityTarget: QuoteSubscriptionTarget = {
+  ...lowPriorityTarget,
+  surface: "detail",
+  selected: true,
+  weight: 100,
+};
+
+const quote: Quote = {
+  symbol: "TSLA",
+  price: 250,
+  currency: "USD",
+  change: 5,
+  changePercent: 2,
+  lastUpdated: 1_700_000_000_000,
+};
+
+describe("RemoteQuoteSubscriptionRegistry", () => {
+  test("recomputes the backend target and listener set when an overlapping subscription leaves", () => {
+    let changes = 0;
+    const lowEvents: Array<{ target: QuoteSubscriptionTarget; quote: Quote }> = [];
+    const highEvents: Array<{ target: QuoteSubscriptionTarget; quote: Quote }> = [];
+    const registry = new RemoteQuoteSubscriptionRegistry(() => { changes += 1; });
+
+    const unsubscribeLow = registry.subscribe([lowPriorityTarget], (target, event) => lowEvents.push({ target, quote: event }));
+    const unsubscribeHigh = registry.subscribe([highPriorityTarget], (target, event) => highEvents.push({ target, quote: event }));
+
+    expect(registry.backendTargets()).toEqual([highPriorityTarget]);
+    registry.dispatch(highPriorityTarget, quote);
+    expect(lowEvents).toEqual([{ target: lowPriorityTarget, quote }]);
+    expect(highEvents).toEqual([{ target: highPriorityTarget, quote }]);
+
+    unsubscribeHigh();
+    expect(registry.backendTargets()).toEqual([lowPriorityTarget]);
+    registry.dispatch(lowPriorityTarget, quote);
+    expect(lowEvents).toEqual([
+      { target: lowPriorityTarget, quote },
+      { target: lowPriorityTarget, quote },
+    ]);
+    expect(highEvents).toEqual([{ target: highPriorityTarget, quote }]);
+
+    unsubscribeLow();
+    expect(registry.backendTargets()).toEqual([]);
+    expect(changes).toBe(4);
+  });
+
+  test("preserves options stream scope across the desktop backend bridge", () => {
+    const target: QuoteSubscriptionTarget = {
+      symbol: "AAPL260731C00110000",
+      exchange: "OPTIONS",
+      surface: "options",
+      visible: true,
+      selected: true,
+      weight: 100,
+    };
+    const optionQuote: Quote = {
+      ...quote,
+      symbol: target.symbol,
+      price: 2.5,
+      bid: 2.45,
+      ask: 2.55,
+      dataSource: "live",
+    };
+    const events: Quote[] = [];
+    const registry = new RemoteQuoteSubscriptionRegistry();
+
+    registry.subscribe([target], (_eventTarget, event) => events.push(event));
+
+    expect(registry.backendTargets()).toEqual([target]);
+    registry.dispatch(target, optionQuote);
+    expect(events).toEqual([optionQuote]);
+  });
+});

package/src/renderers/electrobun/view/remote/quote-subscription-registry.ts

@@ -0,0 +1,72 @@
+import { mergeQuoteSubscriptionTargets } from "../../../../market-data/quote-subscription-target";
+import type { QuoteSubscriptionTarget } from "../../../../types/data-provider";
+import type { Quote } from "../../../../types/financials";
+
+export type RemoteQuoteListener = (target: QuoteSubscriptionTarget, quote: Quote) => void;
+
+interface RemoteQuoteSubscriptionEntry {
+  target: QuoteSubscriptionTarget;
+  listener: RemoteQuoteListener;
+}
+
+function quoteTargetKey(target: QuoteSubscriptionTarget): string {
+  return `${target.symbol}:${target.exchange ?? ""}:${target.context?.brokerId ?? ""}:${target.context?.brokerInstanceId ?? ""}:${target.context?.instrument?.conId ?? target.context?.instrument?.localSymbol ?? target.context?.instrument?.symbol ?? ""}`;
+}
+
+export class RemoteQuoteSubscriptionRegistry {
+  private nextSubscriptionId = 1;
+  private readonly entriesByTarget = new Map<string, Map<number, RemoteQuoteSubscriptionEntry>>();
+
+  constructor(private readonly onChange: () => void = () => {}) {}
+
+  subscribe(targets: QuoteSubscriptionTarget[], listener: RemoteQuoteListener): () => void {
+    const groupedTargets = new Map<string, QuoteSubscriptionTarget[]>();
+    for (const target of targets) {
+      const key = quoteTargetKey(target);
+      const group = groupedTargets.get(key) ?? [];
+      group.push(target);
+      groupedTargets.set(key, group);
+    }
+    if (groupedTargets.size === 0) return () => {};
+
+    const subscriptionId = this.nextSubscriptionId++;
+    for (const [key, candidates] of groupedTargets) {
+      const target = mergeQuoteSubscriptionTargets(candidates);
+      if (!target) continue;
+      const entries = this.entriesByTarget.get(key) ?? new Map();
+      entries.set(subscriptionId, { target, listener });
+      this.entriesByTarget.set(key, entries);
+    }
+    this.onChange();
+
+    let disposed = false;
+    return () => {
+      if (disposed) return;
+      disposed = true;
+      for (const key of groupedTargets.keys()) {
+        const entries = this.entriesByTarget.get(key);
+        if (!entries) continue;
+        entries.delete(subscriptionId);
+        if (entries.size === 0) this.entriesByTarget.delete(key);
+      }
+      this.onChange();
+    };
+  }
+
+  backendTargets(): QuoteSubscriptionTarget[] {
+    const targets: QuoteSubscriptionTarget[] = [];
+    for (const entries of this.entriesByTarget.values()) {
+      const target = mergeQuoteSubscriptionTargets(
+        [...entries.values()].map((entry) => entry.target),
+      );
+      if (target) targets.push(target);
+    }
+    return targets;
+  }
+
+  dispatch(target: QuoteSubscriptionTarget, quote: Quote): void {
+    for (const entry of this.entriesByTarget.get(quoteTargetKey(target))?.values() ?? []) {
+      entry.listener(entry.target, quote);
+    }
+  }
+}

package/src/renderers/electrobun/view/remote/ticker-repository.ts

@@ -3,11 +3,11 @@ import { backendRequest } from "../backend-rpc";
 
 export class RemoteTickerRepository {
   async loadAllTickers(): Promise<TickerRecord[]> {
-    return backendRequest<TickerRecord[]>("ticker.loadAll");
+    return backendRequest("ticker.loadAll");
   }
 
   async loadTicker(symbol: string): Promise<TickerRecord | null> {
-    return backendRequest<TickerRecord | null>("ticker.load", { symbol });
+    return backendRequest("ticker.load", { symbol });
   }
 
   async saveTicker(ticker: TickerRecord): Promise<void> {

package/src/renderers/electrobun/view/toast-host.tsx

@@ -1,4 +1,3 @@
-/// <reference lib="dom" />
 /** @jsxImportSource react */
 import { useCallback, useMemo, useState, type CSSProperties, type ReactNode } from "react";
 import { colors } from "../../../theme/colors";

package/src/renderers/electrobun/view/ui-host.tsx

@@ -1,4 +1,3 @@
-/// <reference lib="dom" />
 /** @jsxImportSource react */
 import { useEffect, useState, type CSSProperties, type ReactNode } from "react";
 import type { RendererHost, UiHost } from "../../../ui/host";
@@ -190,7 +189,7 @@ export const webRendererHost: RendererHost = {
     try {
       return await navigator.clipboard.readText();
     } catch {
-      return await backendRequest<string>("host.readText");
+      return await backendRequest("host.readText");
     }
   },
   notify(notification) {

package/src/renderers/electrobun/view/update-host.ts

@@ -9,7 +9,7 @@ import { backendRequest, onUpdateProgress } from "./backend-rpc";
 export function installElectrobunUpdateHost(): void {
   setUpdateHost({
     checkForUpdateDetailed(currentVersion: string): Promise<UpdateCheckResult> {
-      return backendRequest<UpdateCheckResult>("update.check", { currentVersion });
+      return backendRequest("update.check", { currentVersion });
     },
     performUpdate(release: ReleaseInfo, onProgress: (progress: UpdateProgress) => void): Promise<void> {
       return new Promise((resolve) => {

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

@@ -96,7 +96,8 @@ export const OpenTuiChartSurface = forwardRef<unknown, ChartSurfaceProps>(functi
   const surfaceId = useRef(`opentui-chart:${nextChartSurfaceId++}`).current;
   const renderableRef = useRef<NativeRenderableNode | null>(null);
   const [target, setTarget] = useState<SurfaceTarget | null>(null);
-  const nativeBitmap = (bitmaps?.[0] ?? bitmap ?? null) as NativeChartBitmap | null;
+  const firstBitmap = Array.isArray(bitmaps) ? bitmaps[0] : null;
+  const nativeBitmap = (firstBitmap ?? bitmap ?? null) as NativeChartBitmap | null;
   const nativeCrosshair = (crosshair ?? null) as ChartCrosshairOverlay | null;
   const nativeBitmapKey = useMemo(() => (nativeBitmap ? bitmapKey(nativeBitmap) : null), [nativeBitmap]);
 

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

@@ -2,6 +2,10 @@ import type { ReactNode } from "react";
 import { useMemo } from "react";
 import {
   DialogProvider as OpenTuiDialogProvider,
+  type AlertContext as OpenTuiAlertContext,
+  type AlertOptions as OpenTuiAlertOptions,
+  type PromptContext as OpenTuiPromptContext,
+  type PromptOptions as OpenTuiPromptOptions,
   useDialog as useOpenTuiDialog,
   useDialogState as useOpenTuiDialogState,
 } from "@opentui-ui/dialog/react";
@@ -45,9 +49,21 @@ function OpenTuiDialogBridge({ children }: { children: ReactNode }) {
   const openTuiDialog = useOpenTuiDialog();
   const isOpen = useOpenTuiDialogState((state) => state.isOpen);
   const dialog = useMemo<DialogApi>(() => {
-    const wrapOptions = (options: Record<string, unknown>) => ({
+    const wrapAlertOptions = (options: Record<string, unknown>): OpenTuiAlertOptions => ({
       ...options,
-      content: (context: Record<string, unknown>) => {
+      content: (context: OpenTuiAlertContext) => {
+        const dialogId = normalizeDialogId(context.dialogId);
+        return (
+          <OpenTuiDialogContentBridge dialog={dialog} dialogId={dialogId}>
+            {renderDialogContent(options.content, { ...context, dialogId })}
+          </OpenTuiDialogContentBridge>
+        );
+      },
+    });
+
+    const wrapPromptOptions = <T,>(options: Record<string, unknown>): OpenTuiPromptOptions<T> => ({
+      ...options,
+      content: (context: OpenTuiPromptContext<T>) => {
         const dialogId = normalizeDialogId(context.dialogId);
         return (
           <OpenTuiDialogContentBridge dialog={dialog} dialogId={dialogId}>
@@ -58,8 +74,8 @@ function OpenTuiDialogBridge({ children }: { children: ReactNode }) {
     });
 
     return {
-      alert: (options) => openTuiDialog.alert(wrapOptions(options)),
-      prompt: (options) => openTuiDialog.prompt(wrapOptions(options)),
+      alert: (options) => openTuiDialog.alert(wrapAlertOptions(options)),
+      prompt: <T,>(options: Record<string, unknown>) => openTuiDialog.prompt<T>(wrapPromptOptions<T>(options)),
     };
   }, [openTuiDialog]);
 

package/src/renderers/opentui/image/loader.ts

@@ -7,13 +7,22 @@ export interface JimpImageLike {
   bitmap: {
     width: number;
     height: number;
-    data: Uint8Array;
+    data: ArrayLike<number>;
   };
   clone(): JimpImageLike;
   contain(options: { w: number; h: number }): JimpImageLike;
   cover(options: { w: number; h: number }): JimpImageLike;
 }
 
+function adaptJimpImage(image: JimpImageLike): JimpImageLike {
+  return {
+    bitmap: image.bitmap,
+    clone: () => adaptJimpImage(image.clone()),
+    contain: (options) => adaptJimpImage(image.contain(options)),
+    cover: (options) => adaptJimpImage(image.cover(options)),
+  };
+}
+
 interface ImageBitmapOptions {
   width: number;
   height: number;
@@ -58,7 +67,8 @@ function loadSourceImage(src: string): Promise<JimpImageLike> {
   if (cached) return cached;
 
   const promise = fetchImageBytes(src)
-    .then((bytes) => Jimp.read(bytes) as Promise<JimpImageLike>)
+    .then((bytes) => Jimp.read(bytes))
+    .then(adaptJimpImage)
     .catch((error) => {
       sourceImageCache.delete(src);
       throw error;

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

@@ -1,74 +1,32 @@
-import { useLayoutEffect, useMemo, useRef, type ReactNode } from "react";
+import { useMemo, type ReactNode } from "react";
 import { useNativeRenderer } from "../../ui";
 import {
+  createShortcutRegistry,
   InputHostProvider,
-  shouldDeliverShortcut,
+  useRegisteredShortcut,
   type InputHost,
-  type KeyEventLike,
-  type ShortcutOptions,
 } from "../../react/input";
 import { toKeyEventLike, useKeyboard, useTerminalDimensions } from "./host";
 
-interface ShortcutEntry {
-  handlerRef: { current: (event: KeyEventLike) => void };
-  enabledRef: { current: boolean };
-  allowEditableRef: { current: boolean };
-  phase: NonNullable<ShortcutOptions["phase"]>;
-  order: number;
-}
-
-let nextShortcutOrder = 1;
-
 export function OpenTuiInputHostProvider({ children }: { children: ReactNode }) {
   const renderer = useNativeRenderer();
-  const shortcutsRef = useRef<ShortcutEntry[]>([]);
-  const dispatchShortcut = (event: KeyEventLike) => {
-    const shortcuts = shortcutsRef.current;
-    for (const phase of ["before", "normal", "after"] as const) {
-      if (phase === "after" && (event.defaultPrevented || event.propagationStopped)) return;
-      for (const entry of shortcuts) {
-        if (entry.phase !== phase || !entry.enabledRef.current) continue;
-        if (!shouldDeliverShortcut(event, entry.allowEditableRef.current)) continue;
-        entry.handlerRef.current(event);
-        if (event.propagationStopped) return;
-      }
-    }
-  };
+  const shortcutRegistry = useMemo(() => createShortcutRegistry(), []);
 
   useKeyboard((event) => {
     const shortcutEvent = toKeyEventLike(event);
     shortcutEvent.targetEditable = renderer.currentFocusedEditor != null;
-    dispatchShortcut(shortcutEvent);
+    shortcutRegistry.dispatch(shortcutEvent);
   });
 
   const host = useMemo<InputHost>(() => ({
     useShortcut(handler, options) {
-      const handlerRef = useRef(handler);
-      const enabledRef = useRef(options?.enabled !== false);
-      const allowEditableRef = useRef(options?.allowEditable === true);
-      handlerRef.current = handler;
-      enabledRef.current = options?.enabled !== false;
-      allowEditableRef.current = options?.allowEditable === true;
-
-      useLayoutEffect(() => {
-        const entry: ShortcutEntry = {
-          handlerRef,
-          enabledRef,
-          allowEditableRef,
-          phase: options?.phase ?? "normal",
-          order: nextShortcutOrder++,
-        };
-        shortcutsRef.current = [...shortcutsRef.current, entry].sort((a, b) => a.order - b.order);
-        return () => {
-          shortcutsRef.current = shortcutsRef.current.filter((current) => current !== entry);
-        };
-      }, [options?.phase, options?.scope]);
+      useRegisteredShortcut(shortcutRegistry, handler, options);
     },
     useViewport() {
       const dimensions = useTerminalDimensions();
       return { width: dimensions.width, height: dimensions.height };
     },
-  }), []);
+  }), [shortcutRegistry]);
 
   return (
     <InputHostProvider host={host}>

package/src/renderers/opentui/start.tsx

@@ -24,6 +24,7 @@ import { createPiAiHost } from "../../plugins/builtin/ai/pi";
 import {
   installAiRunHost,
 } from "../../plugins/builtin/ai/runner";
+import { createAppServices } from "../../core/app-services";
 
 const AI_STARTUP_READINESS_TIMEOUT_MS = 5_000;
 
@@ -140,6 +141,7 @@ export async function startOpenTuiApp(options: StartOpenTuiAppOptions = {}): Pro
             >
               <App
                 config={config}
+                servicesFactory={createAppServices}
                 externalPlugins={externalPlugins}
                 cliLaunchRequest={cliLaunchRequest}
                 remoteControlAdapter={remoteControlAdapter}

package/src/sources/gloomberb-cloud/history-quality.ts

@@ -0,0 +1,44 @@
+import type { PricePoint } from "../../types/financials";
+import { getPricePointTimestamp } from "../../utils/price-history";
+
+const MAX_NEIGHBOR_GAP_MS = 60 * 60 * 1000;
+const STABLE_NEIGHBOR_CLOSE_RATIO = 0.01;
+const ISOLATED_OHLC_OUTLIER_RATIO = 0.04;
+
+function relativeDifference(value: number, reference: number): number {
+  return Math.abs(value - reference) / reference;
+}
+
+function isIsolatedOhlcOutlier(
+  previous: PricePoint,
+  point: PricePoint,
+  next: PricePoint,
+): boolean {
+  const previousGap = getPricePointTimestamp(point) - getPricePointTimestamp(previous);
+  const nextGap = getPricePointTimestamp(next) - getPricePointTimestamp(point);
+  if (
+    previousGap <= 0
+    || nextGap <= 0
+    || previousGap > MAX_NEIGHBOR_GAP_MS
+    || nextGap > MAX_NEIGHBOR_GAP_MS
+    || relativeDifference(previous.close, point.close) > STABLE_NEIGHBOR_CLOSE_RATIO
+    || relativeDifference(next.close, point.close) > STABLE_NEIGHBOR_CLOSE_RATIO
+  ) {
+    return false;
+  }
+
+  return [point.open, point.high, point.low].some((value) => (
+    typeof value === "number"
+    && Number.isFinite(value)
+    && relativeDifference(value, point.close) > ISOLATED_OHLC_OUTLIER_RATIO
+  ));
+}
+
+export function hasMalformedCloudIntradayHistory(points: readonly PricePoint[]): boolean {
+  for (let index = 1; index < points.length - 1; index += 1) {
+    if (isIsolatedOhlcOutlier(points[index - 1]!, points[index]!, points[index + 1]!)) {
+      return true;
+    }
+  }
+  return false;
+}