gloomberb 0.10.0 → 0.10.2

package/src/renderers/electrobun/shared/protocol.ts

@@ -1,8 +1,11 @@
 import type { AppSessionSnapshot } from "../../../core/state/session-persistence";
+import type { PaneRuntimeState } from "../../../core/state/app/state";
 import type { DesktopDockPreviewState, DesktopSharedStateSnapshot, DesktopThemePreviewState } from "../../../types/desktop-window";
 import type { DesktopApplicationMenuCommand } from "../../../types/desktop-menu";
 import type { AppConfig } from "../../../types/config";
-import type { UpdateProgress } from "../../../updater";
+import type { LiveStreamResolveRequest, ResolvedLiveStream } from "../../../types/media";
+import type { TickerRecord } from "../../../types/ticker";
+import type { ReleaseInfo, UpdateCheckResult, UpdateProgress } from "../../../updater";
 import type { CapabilityManifest } from "../../../capabilities";
 import type { RemoteControlRequest, RemoteControlResponse } from "../../../remote/types";
 
@@ -20,8 +23,149 @@ export interface ElectrobunBackendInit {
   paneId?: string;
 }
 
+export interface DesktopRestartMessage {
+  reason?: string;
+  source?: string;
+}
+
+export type DesktopWindowControlAction = "minimize" | "toggle-maximize" | "close";
+
+export type DesktopContextMenuItem =
+  | { type: "divider" }
+  | {
+    type?: "normal";
+    label?: string;
+    tooltip?: string;
+    action?: string;
+    role?: string;
+    data?: unknown;
+    submenu?: DesktopContextMenuItem[];
+    enabled?: boolean;
+    checked?: boolean;
+    hidden?: boolean;
+    accelerator?: string;
+  };
+
+export interface DesktopPluginStateSetEntry {
+  pluginId: string;
+  key: string;
+  value: unknown;
+  schemaVersion?: number;
+}
+
+export interface DesktopHttpFetchRequest {
+  url: string;
+  init?: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+    redirect?: "follow" | "error" | "manual";
+    timeoutMs?: number;
+  };
+}
+
+export interface DesktopHttpFetchResponse {
+  status: number;
+  statusText: string;
+  headers: Record<string, string>;
+  setCookie?: string[];
+  body: string;
+}
+
+export interface DesktopCapabilityInvokeRequest {
+  capabilityId: string;
+  operationId: string;
+  payload?: unknown;
+}
+
+export interface DesktopCapabilitySubscribeRequest extends DesktopCapabilityInvokeRequest {
+  subscriptionId: string;
+}
+
+export interface DesktopBackendRequestMap {
+  init: {
+    request: { kind?: "main" | "detached"; paneId?: string };
+    response: ElectrobunBackendInit;
+  };
+  "http.fetch": { request: DesktopHttpFetchRequest; response: DesktopHttpFetchResponse };
+  "media.resolveLiveStream": { request: LiveStreamResolveRequest; response: ResolvedLiveStream };
+  "remote.forward": { request: { request: RemoteControlRequest }; response: RemoteControlResponse };
+  "capability.invoke": { request: DesktopCapabilityInvokeRequest; response: unknown };
+  "capability.subscribe": { request: DesktopCapabilitySubscribeRequest; response: null };
+  "capability.unsubscribe": { request: { subscriptionId: string }; response: null };
+  "desktop.syncMainState": { request: { snapshot: DesktopSharedStateSnapshot }; response: null };
+  "desktop.setThemePreview": { request: { preview: DesktopThemePreviewState }; response: null };
+  "desktop.replaceDetachedPaneState": {
+    request: { paneId: string; paneState: PaneRuntimeState };
+    response: null;
+  };
+  "desktop.popOutPane": { request: { paneId: string }; response: null };
+  "desktop.dockDetachedPane": {
+    request: { paneId: string; edge?: "left" | "right" | "top" | "bottom" };
+    response: null;
+  };
+  "desktop.closeDetachedPane": { request: { paneId: string }; response: null };
+  "desktop.focusDetachedPane": { request: { paneId: string }; response: null };
+  "pluginState.set": { request: DesktopPluginStateSetEntry; response: null };
+  "pluginState.setMany": { request: { entries: DesktopPluginStateSetEntry[] }; response: null };
+  "pluginState.delete": { request: { pluginId: string; key: string }; response: null };
+  "host.restart": { request: DesktopRestartMessage; response: null };
+  "host.exit": { request: null; response: null };
+  "host.windowControl": { request: { action: DesktopWindowControlAction }; response: null };
+  "host.openExternal": { request: { url: string }; response: null };
+  "host.copyText": { request: { text: string }; response: null };
+  "host.focusWindow": { request: null; response: null };
+  "host.copyPngImage": { request: { pngBase64: string }; response: null };
+  "host.readText": { request: null; response: string };
+  "host.notify": {
+    request: { title?: string; body?: string; subtitle?: string; sound?: string };
+    response: null;
+  };
+  "host.showContextMenu": { request: { menu: DesktopContextMenuItem[] }; response: boolean };
+  "update.check": { request: { currentVersion: string }; response: UpdateCheckResult };
+  "update.start": { request: { release: ReleaseInfo; currentVersion?: string }; response: null };
+  "ticker.loadAll": { request: null; response: TickerRecord[] };
+  "ticker.load": { request: { symbol: string }; response: TickerRecord | null };
+  "ticker.save": { request: { ticker: TickerRecord }; response: null };
+  "ticker.delete": { request: { symbol: string }; response: null };
+  "config.save": { request: { config: AppConfig }; response: null };
+  "config.resetAllData": { request: { dataDir: string }; response: null };
+  "config.export": { request: { config: AppConfig; destPath: string }; response: null };
+  "config.import": { request: { dataDir: string; srcPath: string }; response: AppConfig };
+  "session.set": {
+    request: { sessionId: string; value: unknown; schemaVersion?: number };
+    response: null;
+  };
+  "session.delete": { request: { sessionId: string }; response: null };
+}
+
+export type DesktopBackendRequestMethod = keyof DesktopBackendRequestMap;
+export type DesktopBackendRequestPayload<K extends DesktopBackendRequestMethod> =
+  DesktopBackendRequestMap[K]["request"];
+export type DesktopBackendRequestResponse<K extends DesktopBackendRequestMethod> =
+  DesktopBackendRequestMap[K]["response"];
+export type DesktopBackendRequestFor<K extends DesktopBackendRequestMethod> = {
+  [Method in K]: {
+    method: Method;
+    payload: DesktopBackendRequestPayload<Method>;
+  };
+}[K];
+export type DesktopBackendRequest = DesktopBackendRequestFor<DesktopBackendRequestMethod>;
+export type DesktopBackendRequestArgs<K extends DesktopBackendRequestMethod> =
+  null extends DesktopBackendRequestPayload<K>
+    ? [payload?: DesktopBackendRequestPayload<K>]
+    : [payload: DesktopBackendRequestPayload<K>];
+
+export type DesktopCapabilityRequest = DesktopBackendRequestFor<Extract<DesktopBackendRequestMethod, `capability.${string}`>>;
+export type DesktopWorkspaceRequest = DesktopBackendRequestFor<Extract<DesktopBackendRequestMethod, `desktop.${string}`>>;
+export type DesktopPluginStateRequest = DesktopBackendRequestFor<Extract<DesktopBackendRequestMethod, `pluginState.${string}`>>;
+export type DesktopHostRequest = DesktopBackendRequestFor<Extract<DesktopBackendRequestMethod, `host.${string}`>>;
+export type DesktopCoreRequest = DesktopBackendRequestFor<
+  Extract<DesktopBackendRequestMethod, `update.${string}` | `ticker.${string}` | `config.${string}` | `session.${string}`>
+>;
+
 interface BackendRequestPayload {
-  method: string;
+  method: DesktopBackendRequestMethod;
   payload?: unknown;
 }
 
@@ -55,11 +199,6 @@ export interface CapabilityEventMessage {
   event: unknown;
 }
 
-export interface DesktopRestartMessage {
-  reason?: string;
-  source?: string;
-}
-
 export interface DesktopDeepLinkMessage {
   url: string;
 }

package/src/renderers/electrobun/view/app-services.ts

@@ -3,8 +3,7 @@ import { createRemoteBrokerAdapter } from "../../../brokers/remote-broker-adapte
 import { NewsService } from "../../../news/aggregator";
 import { setSharedNewsService } from "../../../news/hooks";
 import { PluginRegistry } from "../../../plugins/registry";
-import type { AppServices } from "../../../core/app-services";
-import type { AppConfig } from "../../../types/config";
+import type { AppRuntimeServices, AppServicesFactoryOptions } from "../../../core/app-service-ports";
 import { newsProvider } from "../../../capabilities";
 import { debugLog } from "../../../utils/debug-log";
 import { measurePerf, measurePerfAsync } from "../../../utils/perf-marks";
@@ -15,7 +14,7 @@ import { RemoteTickerRepository } from "./remote/ticker-repository";
 
 const servicesLog = debugLog.createLogger("services");
 
-export function createAppServices({ config }: { config: AppConfig }): AppServices {
+export function createElectrobunAppServices({ config }: AppServicesFactoryOptions): AppRuntimeServices {
   servicesLog.info("create desktop web services start", {
     brokerInstanceCount: config.brokerInstances.length,
   });
@@ -23,7 +22,7 @@ export function createAppServices({ config }: { config: AppConfig }): AppService
   const tickerRepository = measurePerf("startup.services.ticker-repository", () => new RemoteTickerRepository());
   const dataProvider = measurePerf("startup.services.data-provider", () => createRemoteAssetDataClient());
   const marketData = new MarketDataCoordinator(dataProvider);
-  const pluginRegistry = new PluginRegistry(dataProvider, tickerRepository as never, persistence as never, {
+  const pluginRegistry = new PluginRegistry(dataProvider, tickerRepository, persistence, {
     enableCapabilityHandlers: false,
     wrapBrokerAdapter: (broker) => createRemoteBrokerAdapter(broker),
   });
@@ -59,13 +58,11 @@ export function createAppServices({ config }: { config: AppConfig }): AppService
   servicesLog.info("create desktop web services complete", { pluginCount: plugins.length });
 
   return {
-    persistence: persistence as never,
-    tickerRepository: tickerRepository as never,
-    providerRouter: dataProvider as never,
+    persistence,
+    tickerRepository,
     dataProvider,
     marketData,
     pluginRegistry,
-    newsService,
     ready: Promise.all(pluginReadyPromises).then(() => {}),
     destroy() {
       setSharedMarketDataCoordinator(null);

package/src/renderers/electrobun/view/backend-rpc.ts

@@ -1,10 +1,13 @@
-/// <reference lib="dom" />
 import { Electroview } from "electrobun/view";
 import {
   type ApplicationMenuSelectMessage,
   type CapabilityEventMessage,
   type ContextMenuSelectMessage,
   type DesktopDeepLinkMessage,
+  type DesktopBackendRequestArgs,
+  type DesktopBackendRequestMethod,
+  type DesktopBackendRequestPayload,
+  type DesktopBackendRequestResponse,
   type DesktopDockPreviewMessage,
   type DesktopRestartMessage,
   type DesktopStateMessage,
@@ -155,21 +158,28 @@ async function waitForBridgeReady(): Promise<void> {
   throw new Error("Electrobun RPC socket did not open in time.");
 }
 
-export async function backendRequest<T = unknown>(method: string, payload: unknown = null): Promise<T> {
+export function backendRequest<T = unknown>(
+  method: "capability.invoke",
+  payload: DesktopBackendRequestPayload<"capability.invoke">,
+): Promise<T>;
+export function backendRequest<K extends Exclude<DesktopBackendRequestMethod, "capability.invoke">>(
+  method: K,
+  ...args: DesktopBackendRequestArgs<K>
+): Promise<DesktopBackendRequestResponse<K>>;
+export async function backendRequest(
+  method: DesktopBackendRequestMethod,
+  payload: unknown = null,
+): Promise<unknown> {
   await waitForBridgeReady();
   const result = await rpc.request["backend.request"]({
     method,
     payload: encodeRpcValue(payload),
   });
-  return decodeRpcValue<T>(result);
-}
-
-export function requestMainWindowRemoteControl(request: RemoteControlRequest): Promise<RemoteControlResponse> {
-  return backendRequest("remote.forward", { request });
+  return decodeRpcValue(result);
 }
 
 export async function initElectrobunBackend(payload?: { kind?: "main" | "detached"; paneId?: string }): Promise<ElectrobunBackendInit> {
-  initSnapshot = await backendRequest<ElectrobunBackendInit>("init", payload ?? null);
+  initSnapshot = await backendRequest("init", payload ?? {});
   return initSnapshot;
 }
 

package/src/renderers/electrobun/view/broker-remote-client.ts

@@ -39,12 +39,12 @@ function invokeBrokerCapability<T>(operationId: string, payload: unknown): Promi
   });
 }
 
-function subscribeBrokerCapability(
+async function subscribeBrokerCapability(
   subscriptionId: string,
   operationId: string,
   payload: unknown,
 ): Promise<void> {
-  return backendRequest("capability.subscribe", {
+  await backendRequest("capability.subscribe", {
     subscriptionId,
     capabilityId: BROKER_CAPABILITY_ID,
     operationId,

package/src/renderers/electrobun/view/cli-pane-shot-entry.tsx

@@ -1,4 +1,3 @@
-/// <reference lib="dom" />
 /** @jsxImportSource react */
 import { createRoot } from "react-dom/client";
 import { useEffect, type ComponentType, type ReactNode } from "react";
@@ -23,21 +22,21 @@ import { FloatingPaneWrapper } from "../../../components/layout/floating-pane";
 import { PaneContent } from "../../../components/layout/pane/content";
 import { resolvePaneBodyFrame } from "../../../components/layout/pane/sizing";
 import { getPaneDisplayTitle } from "../../../components/layout/pane/title";
-import { subtractTimeRange } from "../../../components/chart/core/date-window";
 import {
   getPresetResolution,
   normalizeChartResolutionSupport,
   TIME_RANGE_ORDER,
-} from "../../../components/chart/core/resolution";
+} from "../../../time-series/resolution";
 import type { TimeRange } from "../../../components/chart/core/types";
 import type { AppConfig } from "../../../types/config";
 import type { CachedFinancialsTarget, DataProvider, QuoteSubscriptionTarget } from "../../../types/data-provider";
-import type { OptionsChain, PricePoint, TickerFinancials } from "../../../types/financials";
+import type { OptionsChain, TickerFinancials } from "../../../types/financials";
 import type { TickerRecord } from "../../../types/ticker";
 import type { AppState, PaneRuntimeState } from "../../../core/state/app/state";
 import type { PaneDef } from "../../../types/plugin";
 import { canonicalTickerKey, parsePublicTickerKey } from "../../../utils/exchanges";
 import { hydrateFredSeries, type FredSeriesCacheEntry } from "../../../data/fred-series";
+import { clipPriceHistoryToRange } from "../../../time-series/history-window";
 
 interface CliPaneShotPayload {
   config: AppConfig;
@@ -98,22 +97,6 @@ function normalizeSymbol(value: string): string {
   return value.trim().replace(/^\$/, "").toUpperCase();
 }
 
-function clipShotPriceHistory(points: PricePoint[], range: TimeRange): PricePoint[] {
-  if (range === "ALL" || points.length === 0) return points;
-  const dated = points.flatMap((point) => {
-    const date = point.date instanceof Date ? point.date : new Date(point.date);
-    return Number.isFinite(date.getTime()) ? [{ point, date }] : [];
-  });
-  const end = dated.reduce<Date | null>((latest, entry) => (
-    !latest || entry.date.getTime() > latest.getTime() ? entry.date : latest
-  ), null);
-  if (!end) return [];
-  const start = subtractTimeRange(end, range);
-  return dated
-    .filter(({ date }) => date.getTime() >= start.getTime() && date.getTime() <= end.getTime())
-    .map(({ point }) => point);
-}
-
 function updatePendingShotWork(next: number): void {
   pendingShotWork = Math.max(0, next);
   window.__GLOOM_CLI_SHOT_PENDING__ = pendingShotWork;
@@ -294,12 +277,12 @@ function createShotDataProvider(payload: CliPaneShotPayload): DataProvider {
     },
     getPriceHistory(ticker, exchange, range) {
       return trackShotWork(Promise.resolve().then(() => (
-        clipShotPriceHistory(getFinancials(ticker, exchange).priceHistory ?? [], range)
+        clipPriceHistoryToRange(getFinancials(ticker, exchange).priceHistory ?? [], range)
       )));
     },
     getPriceHistoryForResolution(ticker, exchange, bufferRange) {
       return trackShotWork(Promise.resolve().then(() => (
-        clipShotPriceHistory(getFinancials(ticker, exchange).priceHistory ?? [], bufferRange)
+        clipPriceHistoryToRange(getFinancials(ticker, exchange).priceHistory ?? [], bufferRange)
       )));
     },
     getChartResolutionSupport() {

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

@@ -26,7 +26,7 @@ const electrobunConfigStoreHost: ConfigStoreHost = {
     await backendRequest("config.export", { config, destPath });
   },
   async importConfig(dataDir: string, srcPath: string) {
-    return backendRequest<AppConfig>("config.import", { dataDir, srcPath });
+    return backendRequest("config.import", { dataDir, srcPath });
   },
 };
 

package/src/renderers/electrobun/view/context-menu.ts

@@ -1,21 +1,5 @@
 import type { ContextMenuActionItem, ContextMenuItem, ContextMenuRoleItem } from "../../../types/context-menu";
-import { ELECTROBUN_CONTEXT_MENU_ACTION } from "../shared/protocol";
-
-type DesktopContextMenuItem =
-  | { type: "divider" }
-  | {
-    type?: "normal";
-    label?: string;
-    tooltip?: string;
-    action?: string;
-    role?: string;
-    data?: unknown;
-    submenu?: DesktopContextMenuItem[];
-    enabled?: boolean;
-    checked?: boolean;
-    hidden?: boolean;
-    accelerator?: string;
-  };
+import { ELECTROBUN_CONTEXT_MENU_ACTION, type DesktopContextMenuItem } from "../shared/protocol";
 
 export interface PreparedDesktopContextMenu {
   menu: DesktopContextMenuItem[];

package/src/renderers/electrobun/view/data-table/index.tsx

@@ -1,4 +1,3 @@
-/// <reference lib="dom" />
 /** @jsxImportSource react */
 import { useVirtualizer } from "@tanstack/react-virtual";
 import {

package/src/renderers/electrobun/view/data-table/row.tsx

@@ -1,8 +1,6 @@
-/// <reference lib="dom" />
 /** @jsxImportSource react */
 import { memo, type CSSProperties } from "react";
 import { TextAttributes } from "../../../../ui/host";
-import { useThemeColors } from "../../../../theme/theme-context";
 import type {
   DataTableCell,
   DataTableColumn,
@@ -72,7 +70,6 @@ export function WebDataTableHeader<C extends DataTableColumn>({
   sortColumnId: string | null;
   sortDirection: "asc" | "desc";
 }) {
-  useThemeColors();
   return (
     <div
       data-gloom-role="data-table-header-row"
@@ -183,7 +180,6 @@ function WebDataTableRowInner<
   rowContextMenuSurface: boolean;
   selected: boolean;
 }) {
-  useThemeColors();
   const sectionHeader: DataTableSectionHeader | null =
     renderSectionHeader?.(item, index) ?? null;
   const baseRowStyle: CSSProperties = {

package/src/renderers/electrobun/view/desktop/control-styles.ts

@@ -1,77 +1,80 @@
 import type { ButtonProps } from "../../../../components/ui/button";
-import { blendHex, colors } from "../../../../theme/colors";
+import { blendHex, colors, type ThemeColors } from "../../../../theme/colors";
 
 export const CONTROL_RADIUS = 6;
 
-export function panelBorder(): string {
-  return blendHex(colors.border, colors.borderFocused, 0.18);
+export function panelBorder(palette: ThemeColors = colors): string {
+  return blendHex(palette.border, palette.borderFocused, 0.18);
 }
 
-export function panelFill(): string {
-  return blendHex(colors.panel, colors.bg, 0.22);
+export function panelFill(palette: ThemeColors = colors): string {
+  return blendHex(palette.panel, palette.bg, 0.22);
 }
 
-export function subtlePanelFill(): string {
-  return blendHex(colors.panel, colors.bg, 0.42);
+export function subtlePanelFill(palette: ThemeColors = colors): string {
+  return blendHex(palette.panel, palette.bg, 0.42);
 }
 
-export function selectedPanelFill(): string {
-  return blendHex(colors.selected, colors.bg, 0.42);
+export function selectedPanelFill(palette: ThemeColors = colors): string {
+  return blendHex(palette.selected, palette.bg, 0.42);
 }
 
-export function controlBorderColor(focused = false, active = false): string {
-  if (active) return colors.borderFocused;
-  if (focused) return blendHex(colors.borderFocused, colors.textBright, 0.24);
-  return panelBorder();
+export function controlBorderColor(focused = false, active = false, palette: ThemeColors = colors): string {
+  if (active) return palette.borderFocused;
+  if (focused) return blendHex(palette.borderFocused, palette.textBright, 0.24);
+  return panelBorder(palette);
 }
 
-export function controlShadow(active = false): string {
+export function controlShadow(active = false, palette: ThemeColors = colors): string {
   return active
-    ? `0 0 0 1px ${blendHex(colors.bg, colors.borderFocused, 0.18)}, inset 0 1px 0 ${blendHex(colors.bg, colors.textBright, 0.06)}`
-    : `inset 0 1px 0 ${blendHex(colors.bg, colors.textBright, 0.04)}`;
+    ? `0 0 0 1px ${blendHex(palette.bg, palette.borderFocused, 0.18)}, inset 0 1px 0 ${blendHex(palette.bg, palette.textBright, 0.06)}`
+    : `inset 0 1px 0 ${blendHex(palette.bg, palette.textBright, 0.04)}`;
 }
 
-export function buttonPalette(props: Pick<ButtonProps, "variant" | "active" | "disabled">) {
+export function buttonPalette(
+  props: Pick<ButtonProps, "variant" | "active" | "disabled">,
+  palette: ThemeColors = colors,
+) {
   if (props.disabled) {
     return {
-      fg: colors.textMuted,
-      bg: subtlePanelFill(),
-      border: panelBorder(),
+      fg: palette.textMuted,
+      bg: subtlePanelFill(palette),
+      border: panelBorder(palette),
     };
   }
   if (props.active) {
     return {
-      fg: colors.selectedText,
-      bg: colors.selected,
-      border: colors.borderFocused,
+      fg: palette.selectedText,
+      bg: palette.selected,
+      border: palette.borderFocused,
     };
   }
 
   switch (props.variant) {
     case "primary":
       return {
-        fg: colors.bg,
-        bg: colors.borderFocused,
-        border: colors.borderFocused,
+        fg: palette.bg,
+        bg: palette.borderFocused,
+        border: palette.borderFocused,
       };
     case "danger":
       return {
-        fg: colors.bg,
-        bg: colors.negative,
-        border: colors.negative,
+        fg: palette.bg,
+        bg: palette.negative,
+        border: palette.negative,
       };
     case "ghost":
       return {
-        fg: colors.textDim,
+        fg: palette.textDim,
         bg: "transparent",
-        border: panelBorder(),
+        border: panelBorder(palette),
       };
     case "secondary":
     default:
       return {
-        fg: colors.text,
-        bg: panelFill(),
-        border: panelBorder(),
+        fg: palette.text,
+        bg: panelFill(palette),
+        border: panelBorder(palette),
       };
   }
 }