gloomberb 0.9.9 → 0.10.0

package/src/plugins/builtin/ticker-detail/settings.ts

@@ -2,12 +2,6 @@ import type { PaneSettingsDef, TickerResearchTabDef } from "../../../types/plugi
 import type { TickerFinancials } from "../../../types/financials";
 import type { TickerRecord } from "../../../types/ticker";
 import type { AppConfig } from "../../../types/config";
-import type { ChartAxisMode, TimeRange } from "../../../components/chart/core/types";
-import {
-  DEFAULT_TICKER_CHART_RANGE_PRESET,
-  DEFAULT_TICKER_CHART_RESOLUTION,
-  normalizeChartResolution,
-} from "../../../components/chart/core/resolution";
 import type { PriceSparklinePeriod } from "../../../components/price-sparkline/view";
 import { getSharedRegistry } from "../../registry";
 import { formatTickerListInput, MAX_TICKER_LIST_SIZE, parseTickerListInput } from "../../../tickers/list";
@@ -17,9 +11,6 @@ type TickerResearchTabSummary = { id: string; name: string; order: number };
 export interface TickerResearchPaneSettings {
   hideTabs: boolean;
   lockedTabId: string;
-  chartAxisMode: ChartAxisMode;
-  chartRangePreset: TimeRange;
-  chartResolution: ReturnType<typeof normalizeChartResolution>;
 }
 
 export interface QuoteMonitorPaneSettings {
@@ -35,19 +26,9 @@ export function getTickerResearchPaneSettings(
 ): TickerResearchPaneSettings {
   return {
     hideTabs: settings?.hideTabs === true,
-    lockedTabId: typeof settings?.lockedTabId === "string" ? settings.lockedTabId : "overview",
-    chartAxisMode: settings?.chartAxisMode === "percent" ? "percent" : "price",
-    chartRangePreset: settings?.chartRangePreset === "1D"
-      || settings?.chartRangePreset === "1W"
-      || settings?.chartRangePreset === "1M"
-      || settings?.chartRangePreset === "3M"
-      || settings?.chartRangePreset === "6M"
-      || settings?.chartRangePreset === "1Y"
-      || settings?.chartRangePreset === "5Y"
-      || settings?.chartRangePreset === "ALL"
-      ? settings.chartRangePreset
-      : DEFAULT_TICKER_CHART_RANGE_PRESET,
-    chartResolution: normalizeChartResolution(settings?.chartResolution, DEFAULT_TICKER_CHART_RESOLUTION),
+    lockedTabId: settings?.lockedTabId === "fundamental-graphs"
+      ? "chart"
+      : typeof settings?.lockedTabId === "string" ? settings.lockedTabId : "overview",
   };
 }
 
@@ -92,34 +73,6 @@ export function buildTickerResearchSettingsDef(settings: TickerResearchPaneSetti
           options: tabs.map((tab) => ({ value: tab.id, label: tab.name })),
         }]
         : []),
-      {
-        key: "chartAxisMode",
-        label: "Chart Y-Axis",
-        description: "Show chart values as raw prices or percent change from the first visible point.",
-        type: "select" as const,
-        options: [
-          { value: "price", label: "Price" },
-          { value: "percent", label: "Percent" },
-        ],
-      },
-    ],
-  };
-}
-
-export function buildTickerChartSettingsDef(): PaneSettingsDef {
-  return {
-    title: "Chart Pane Settings",
-    fields: [
-      {
-        key: "chartAxisMode",
-        label: "Chart Y-Axis",
-        description: "Show chart values as raw prices or percent change from the first visible point.",
-        type: "select" as const,
-        options: [
-          { value: "price", label: "Price" },
-          { value: "percent", label: "Percent" },
-        ],
-      },
     ],
   };
 }

package/src/plugins/builtin/ticker-research-backend-plugin.ts

@@ -0,0 +1,17 @@
+import { attachFredSeriesPersistence } from "../../data/fred-series";
+import { composeBuiltinPlugin, type PluginModule } from "./plugin-module";
+
+const chartSeriesPersistenceModule: PluginModule = {
+  setup(ctx) {
+    attachFredSeriesPersistence(ctx.persistence);
+  },
+};
+
+export const tickerResearchBackendPlugin = composeBuiltinPlugin({
+  id: "ticker-research",
+  name: "Ticker Research",
+  version: "1.0.0",
+  description: "Company research workspace: overview, charts, financials, filings, ownership, options, analyst research, and events.",
+  toggleable: true,
+  modules: [chartSeriesPersistenceModule],
+});

package/src/plugins/builtin/ticker-research-plugin.ts

@@ -0,0 +1,27 @@
+import { chartComposerModule } from "./chart-composer";
+import { holdersModule } from "./holders";
+import { insiderModule } from "./insider";
+import { optionsModule } from "./options";
+import { composeBuiltinPlugin } from "./plugin-module";
+import { researchModule } from "./research";
+import { secModule } from "./sec";
+import { thirteenFModule } from "./thirteenf";
+import { tickerDetailModule } from "./ticker-detail";
+
+export const tickerResearchPlugin = composeBuiltinPlugin({
+  id: "ticker-research",
+  name: "Ticker Research",
+  version: "1.0.0",
+  description: "Company research workspace: overview, charts, financials, filings, ownership, options, analyst research, and events.",
+  toggleable: true,
+  modules: [
+    tickerDetailModule,
+    chartComposerModule,
+    optionsModule,
+    researchModule,
+    holdersModule,
+    thirteenFModule,
+    secModule,
+    insiderModule,
+  ],
+});

package/src/plugins/builtin/tv/channels.ts

@@ -0,0 +1,27 @@
+export const TV_CHANNELS = [
+  {
+    id: "bloomberg",
+    name: "Bloomberg",
+    channelId: "UCIALMKvObZNtJ6AmdCLP7Lg",
+    channelUrl: "https://www.youtube.com/@markets/live",
+  },
+  {
+    id: "cnbc",
+    name: "CNBC",
+    channelId: "UCvJJ_dzjViJCoLf5uKUTwoA",
+    channelUrl: "https://www.youtube.com/@CNBC/live",
+  },
+  {
+    id: "yahoo-finance",
+    name: "Yahoo Finance",
+    channelId: "UCEAZeUIeJs0IjQiqTCdVSIg",
+    channelUrl: "https://www.youtube.com/@YahooFinance/live",
+  },
+] as const;
+
+export type TvChannel = (typeof TV_CHANNELS)[number];
+export type TvChannelId = TvChannel["id"];
+
+export function getTvChannel(id: TvChannelId): TvChannel {
+  return TV_CHANNELS.find((channel) => channel.id === id) ?? TV_CHANNELS[0];
+}

package/src/plugins/builtin/tv/index.tsx

@@ -0,0 +1,40 @@
+import type { PluginModule } from "../plugin-module";
+import { TvPane } from "./pane";
+
+export const tvModule: PluginModule = {
+  panes: [{
+    id: "macro-tv",
+    name: "TV",
+    icon: "T",
+    component: TvPane,
+    defaultPosition: "right",
+    defaultMode: "floating",
+    defaultFloatingSize: { width: 92, height: 32 },
+  }],
+  paneTemplates: [{
+    id: "macro-tv-pane",
+    paneId: "macro-tv",
+    label: "TV",
+    description: "Live Bloomberg, CNBC, and Yahoo Finance television.",
+    keywords: [
+      "tv",
+      "television",
+      "live tv",
+      "finance tv",
+      "financial television",
+      "live stream",
+      "market news",
+      "business news",
+      "markets",
+      "news",
+      "bloomberg",
+      "bloomberg tv",
+      "cnbc",
+      "cnbc tv",
+      "yahoo",
+      "yahoo finance",
+      "macro",
+    ],
+    shortcut: { prefix: "TV" },
+  }],
+};

package/src/plugins/builtin/tv/pane.tsx

@@ -0,0 +1,286 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Button, Tabs, usePaneFooter } from "../../../components";
+import { updatePaneInstance } from "../../../pane-settings";
+import { useShortcut } from "../../../react/input";
+import {
+  syncConfigActiveLayoutState,
+  useAppDispatch,
+  useAppStateRef,
+  usePaneInstance,
+} from "../../../state/app/context";
+import { scheduleConfigSave } from "../../../state/config-save-scheduler";
+import { colors } from "../../../theme/colors";
+import type { PaneProps } from "../../../types/plugin";
+import { Box, ImageSurface, MediaSurface, Text, useRendererHost, useUiHost, type MediaSurfaceHandle } from "../../../ui";
+import { getTvChannel, TV_CHANNELS, type TvChannelId } from "./channels";
+import type { ResolvedLiveStream } from "../../../types/media";
+import { resolveTvStream } from "./youtube-stream";
+
+type PlaybackState = "idle" | "loading" | "playing" | "paused" | "error";
+
+export function TvPane({ paneId, focused, width, height }: PaneProps) {
+  const isDesktop = useUiHost().kind === "desktop-web";
+  const renderer = useRendererHost();
+  const dispatch = useAppDispatch();
+  const stateRef = useAppStateRef();
+  const pane = usePaneInstance();
+  const initialChannelIdRef = useRef<TvChannelId>(
+    TV_CHANNELS.find((item) => item.id === pane?.settings?.channelId)?.id ?? "bloomberg",
+  );
+  const [channelId, setChannelId] = useState<TvChannelId>(initialChannelIdRef.current);
+  const [stream, setStream] = useState<ResolvedLiveStream | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const [playbackError, setPlaybackError] = useState<string | null>(null);
+  const [playbackState, setPlaybackState] = useState<PlaybackState>("idle");
+  const [muted, setMuted] = useState(true);
+  const mediaRef = useRef<MediaSurfaceHandle | null>(null);
+  const terminalAutoPlayedRef = useRef<string | null>(null);
+  const generationRef = useRef(0);
+  const channel = getTvChannel(channelId);
+
+  const persistChannelSelection = useCallback((nextId: TvChannelId) => {
+    const nextChannel = getTvChannel(nextId);
+    const nextTitle = `TV: ${nextChannel.name}`;
+    const currentState = stateRef.current;
+    const currentPane = currentState.config.layout.instances.find((instance) => instance.instanceId === paneId);
+    if (currentPane?.title === nextTitle && currentPane.settings?.channelId === nextId) return;
+
+    const layout = updatePaneInstance(currentState.config.layout, paneId, (instance) => ({
+      ...instance,
+      title: nextTitle,
+      settings: { ...instance.settings, channelId: nextId },
+    }));
+    const syncedConfig = syncConfigActiveLayoutState(
+      { ...currentState.config, layout },
+      currentState.paneState,
+      currentState.focusedPaneId,
+      currentState.activePanel,
+    );
+    dispatch({ type: "SET_CONFIG", config: syncedConfig });
+    scheduleConfigSave(syncedConfig);
+  }, [dispatch, paneId, stateRef]);
+
+  const load = useCallback(async (force = false) => {
+    const generation = ++generationRef.current;
+    setLoading(true);
+    setError(null);
+    setPlaybackError(null);
+    setPlaybackState("idle");
+    setStream((current) => current?.sourceId === channel.id ? current : null);
+    try {
+      const nextStream = renderer.resolveLiveStream
+        ? await renderer.resolveLiveStream({ provider: "youtube", sourceId: channel.id, force })
+        : await resolveTvStream(channel, { force });
+      if (generation !== generationRef.current) return;
+      setStream(nextStream);
+    } catch (cause) {
+      if (generation !== generationRef.current) return;
+      setStream(null);
+      setError(cause instanceof Error ? cause.message : String(cause));
+    } finally {
+      if (generation === generationRef.current) setLoading(false);
+    }
+  }, [channel, renderer]);
+
+  const refresh = useCallback(() => {
+    void load(true);
+  }, [load]);
+
+  useEffect(() => {
+    void load();
+    return () => {
+      generationRef.current += 1;
+    };
+  }, [load]);
+
+  useEffect(() => {
+    persistChannelSelection(channelId);
+  }, [channelId, persistChannelSelection]);
+
+  const selectChannel = useCallback((nextId: string) => {
+    if (TV_CHANNELS.some((item) => item.id === nextId)) {
+      setMuted(true);
+      setChannelId(nextId as TvChannelId);
+    }
+  }, []);
+
+  const playInTerminal = useCallback(async () => {
+    if (!stream || !renderer.playTerminalMedia) return;
+    setPlaybackError(null);
+    setPlaybackState("playing");
+    try {
+      await renderer.playTerminalMedia(stream.manifestUrl, stream.title, { muted });
+      setPlaybackState("paused");
+    } catch (cause) {
+      setPlaybackState("error");
+      setPlaybackError(cause instanceof Error ? cause.message : String(cause));
+    }
+  }, [muted, renderer, stream]);
+
+  useEffect(() => {
+    if (isDesktop || loading || !stream || stream.sourceId !== channel.id) return;
+    const streamKey = `${stream.sourceId}:${stream.videoId}`;
+    if (terminalAutoPlayedRef.current === streamKey) return;
+    terminalAutoPlayedRef.current = streamKey;
+    void playInTerminal();
+  }, [channel.id, isDesktop, loading, playInTerminal, stream]);
+
+  const togglePlayback = useCallback(async () => {
+    setPlaybackError(null);
+    try {
+      if (isDesktop) {
+        await mediaRef.current?.toggle();
+      } else {
+        await playInTerminal();
+      }
+    } catch (cause) {
+      setPlaybackState("error");
+      setPlaybackError(cause instanceof Error ? cause.message : String(cause));
+    }
+  }, [isDesktop, playInTerminal]);
+
+  const toggleMute = useCallback(() => {
+    if (isDesktop) {
+      const nextMuted = mediaRef.current?.toggleMuted();
+      if (typeof nextMuted === "boolean") setMuted(nextMuted);
+      return;
+    }
+    setMuted((current) => !current);
+  }, [isDesktop]);
+
+  useShortcut((event) => {
+    if (!focused) return;
+    const channelIndex = Number(event.name) - 1;
+    if (Number.isInteger(channelIndex) && TV_CHANNELS[channelIndex]) {
+      event.preventDefault?.();
+      selectChannel(TV_CHANNELS[channelIndex]!.id);
+      return;
+    }
+    if (event.name === "r") {
+      event.preventDefault?.();
+      refresh();
+      return;
+    }
+    if (event.name === "p" && stream) {
+      event.preventDefault?.();
+      void togglePlayback();
+      return;
+    }
+    if (event.name === "m" && stream) {
+      event.preventDefault?.();
+      toggleMute();
+    }
+  });
+
+  const status = loading
+    ? `resolving ${channel.name}`
+    : error || playbackError
+      ? "stream error"
+      : playbackState === "playing"
+        ? "playing live"
+        : playbackState === "loading"
+          ? "buffering live"
+          : stream
+            ? "live"
+            : "offline";
+
+  usePaneFooter(paneId, () => ({
+    info: [{
+      id: "tv-status",
+      parts: [{
+        text: status,
+        tone: error || playbackError ? "warning" : playbackState === "playing" ? "positive" : "value",
+      }],
+    }],
+    hints: [
+      {
+        id: "playback",
+        key: "p",
+        label: playbackState === "playing" ? "ause" : "lay",
+        onPress: () => { void togglePlayback(); },
+        disabled: loading || !stream,
+      },
+      {
+        id: "mute",
+        key: "m",
+        label: muted ? "unmute" : "ute",
+        onPress: toggleMute,
+        disabled: loading || !stream,
+      },
+      { id: "refresh", key: "r", label: "efresh", onPress: refresh, disabled: loading },
+    ],
+  }), [error, loading, muted, paneId, playbackError, playbackState, refresh, status, stream, toggleMute, togglePlayback]);
+
+  const channelTabs = useMemo(() => TV_CHANNELS.map((item, index) => ({
+    label: `${index + 1} ${item.name}`,
+    value: item.id,
+  })), []);
+  const mediaHeight = Math.max(6, height - 1);
+
+  return (
+    <Box flexDirection="column" width={width} height={height}>
+      <Box height={1} paddingX={1}>
+        <Tabs
+          tabs={channelTabs}
+          activeValue={channelId}
+          onSelect={selectChannel}
+          compact
+          variant="bare"
+          focused={focused}
+        />
+      </Box>
+
+      {loading && !stream ? (
+        <Box flexGrow={1} justifyContent="center" alignItems="center">
+          <Text fg={colors.textMuted}>{`Resolving ${channel.name} live stream...`}</Text>
+        </Box>
+      ) : error || !stream ? (
+        <Box flexGrow={1} flexDirection="column" justifyContent="center" alignItems="center" gap={1}>
+          <Text fg={colors.warning}>{error ?? `${channel.name} is offline.`}</Text>
+          <Button label="Try again" variant="primary" onPress={refresh} />
+        </Box>
+      ) : isDesktop ? (
+        <MediaSurface
+          src={stream.manifestUrl}
+          title={stream.title}
+          poster={stream.posterUrl}
+          autoPlay
+          muted={muted}
+          mediaHandleRef={mediaRef}
+          height={mediaHeight}
+          flexGrow={1}
+          onPlaybackStateChange={setPlaybackState}
+          onMutedChange={setMuted}
+          onError={setPlaybackError}
+        >
+          <Box flexGrow={1} justifyContent="center" alignItems="center">
+            <Text fg={colors.warning}>{playbackError ?? "Live video unavailable."}</Text>
+          </Box>
+        </MediaSurface>
+      ) : (
+        <Box flexGrow={1} flexDirection="column" alignItems="center" justifyContent="center" gap={1}>
+          <ImageSurface
+            src={stream.posterUrl}
+            alt={stream.title}
+            objectFit="contain"
+            width="100%"
+            height={Math.max(5, mediaHeight - 2)}
+          >
+            <Box flexGrow={1} justifyContent="center" alignItems="center">
+              <Text fg={colors.text}>{stream.title}</Text>
+            </Box>
+          </ImageSurface>
+          <Button
+            label="Play in Kitty"
+            shortcut="p"
+            variant="primary"
+            disabled={!renderer.playTerminalMedia}
+            onPress={() => void togglePlayback()}
+          />
+          {playbackError ? <Text fg={colors.warning}>{playbackError}</Text> : null}
+        </Box>
+      )}
+    </Box>
+  );
+}

package/src/plugins/builtin/tv/youtube-stream.ts

@@ -0,0 +1,100 @@
+import type { TvChannel } from "./channels";
+import type { ResolvedLiveStream } from "../../../types/media";
+
+const CACHE_TTL_MS = 10 * 60 * 1000;
+const MAX_LIVE_CANDIDATES = 6;
+
+export interface ResolvedTvStream extends ResolvedLiveStream {
+  sourceId: TvChannel["id"];
+}
+
+type YoutubeModule = typeof import("youtubei.js");
+type YoutubeClient = InstanceType<YoutubeModule["Innertube"]>;
+
+let clientPromise: Promise<YoutubeClient> | null = null;
+const streamCache = new Map<TvChannel["id"], ResolvedTvStream>();
+const activeResolutions = new Map<TvChannel["id"], Promise<ResolvedTvStream>>();
+
+async function getYoutubeClient(): Promise<{ client: YoutubeClient; module: YoutubeModule }> {
+  const module = await import("youtubei.js");
+  module.Log.setLevel(module.Log.Level.ERROR);
+  clientPromise ??= module.Innertube.create({
+    generate_session_locally: true,
+    enable_session_cache: true,
+  });
+  return { client: await clientPromise, module };
+}
+
+function usableCachedStream(sourceId: TvChannel["id"]): ResolvedTvStream | null {
+  const cached = streamCache.get(sourceId);
+  if (!cached) return null;
+  const validUntil = Math.min(cached.resolvedAt + CACHE_TTL_MS, cached.expiresAt - 60_000);
+  return Date.now() < validUntil ? cached : null;
+}
+
+async function resolveUncached(channel: TvChannel): Promise<ResolvedTvStream> {
+  const { client, module } = await getYoutubeClient();
+  const channelFeed = await client.getChannel(channel.channelId);
+  if (!channelFeed.has_live_streams) {
+    throw new Error(`${channel.name} does not currently expose a live stream.`);
+  }
+
+  const liveFeed = await channelFeed.getLiveStreams();
+  const candidates = liveFeed.memo
+    .getType(module.YTNodes.LockupView)
+    .filter((item) => item.content_type === "VIDEO")
+    .slice(0, MAX_LIVE_CANDIDATES);
+
+  for (const candidate of candidates) {
+    const info = await client.getBasicInfo(candidate.content_id, { client: "ANDROID" });
+    const manifestUrl = info.streaming_data?.hls_manifest_url;
+    if (!info.basic_info.is_live || !manifestUrl) continue;
+
+    const thumbnails = info.basic_info.thumbnail ?? [];
+    const poster = thumbnails.reduce<(typeof thumbnails)[number] | undefined>((best, item) => {
+      if (!best) return item;
+      return (item.width ?? 0) * (item.height ?? 0) > (best.width ?? 0) * (best.height ?? 0) ? item : best;
+    }, undefined);
+    const resolvedAt = Date.now();
+    const expiresAt = info.streaming_data?.expires?.getTime() ?? resolvedAt + CACHE_TTL_MS;
+
+    return {
+      provider: "youtube",
+      sourceId: channel.id,
+      videoId: candidate.content_id,
+      title: info.basic_info.title || candidate.metadata?.title?.toString() || `${channel.name} Live`,
+      manifestUrl,
+      watchUrl: `https://www.youtube.com/watch?v=${candidate.content_id}`,
+      posterUrl: poster?.url,
+      resolvedAt,
+      expiresAt,
+    };
+  }
+
+  throw new Error(`${channel.name} does not currently have a playable public live stream.`);
+}
+
+export function resolveTvStream(
+  channel: TvChannel,
+  options?: { force?: boolean },
+): Promise<ResolvedTvStream> {
+  if (!options?.force) {
+    const cached = usableCachedStream(channel.id);
+    if (cached) return Promise.resolve(cached);
+    const active = activeResolutions.get(channel.id);
+    if (active) return active;
+  }
+
+  const resolution = resolveUncached(channel)
+    .then((stream) => {
+      streamCache.set(channel.id, stream);
+      return stream;
+    })
+    .finally(() => {
+      if (activeResolutions.get(channel.id) === resolution) {
+        activeResolutions.delete(channel.id);
+      }
+    });
+  activeResolutions.set(channel.id, resolution);
+  return resolution;
+}

package/src/plugins/builtin/world-indices/index.tsx

@@ -1,6 +1,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { DataTableView } from "../../../components";
-import type { GloomPlugin, PaneProps } from "../../../types/plugin";
+import type { PaneProps } from "../../../types/plugin";
+import type { PluginModule } from "../plugin-module";
 import { TICKER_RESEARCH_PANE_ID } from "../../../types/config";
 import { useAssetData, usePluginTickerActions } from "../../runtime";
 import { WORLD_INDICES, REGION_LABELS, getIndicesByRegion } from "./indices";
@@ -185,13 +186,7 @@ function WorldIndicesPane({ focused, width, height }: PaneProps) {
   );
 }
 
-export const worldIndicesPlugin: GloomPlugin = {
-  id: "world-indices",
-  name: "World Equity Indices",
-  version: "1.0.0",
-  description: "Global equity index monitor grouped by region",
-  toggleable: true,
-
+export const worldIndicesModule: PluginModule = {
   panes: [
     {
       id: "world-indices",

package/src/plugins/builtin/yield-curve/index.tsx

@@ -2,7 +2,8 @@ import { Box, ScrollBox, Text } from "../../../ui";
 import { useCallback, useEffect, useRef, useState } from "react";
 import { useShortcut } from "../../../react/input";
 import { StaticChartSurface, usePaneFooter } from "../../../components";
-import type { GloomPluginContext, PaneProps } from "../../../types/plugin";
+import type { PaneProps } from "../../../types/plugin";
+import type { PluginModule } from "../plugin-module";
 import { colors } from "../../../theme/colors";
 import { resolveChartPalette } from "../../../components/chart/core/renderer";
 import type { ProjectedChartPoint } from "../../../components/chart/core/data";
@@ -162,8 +163,8 @@ function YieldCurvePane({ focused, width, height }: PaneProps) {
   );
 }
 
-export function registerYieldCurveFeature(ctx: GloomPluginContext): void {
-  ctx.registerPane({
+export const yieldCurveModule: PluginModule = {
+  panes: [{
     id: "yield-curve",
     name: "US Treasury Yield Curve",
     icon: "Y",
@@ -171,14 +172,13 @@ export function registerYieldCurveFeature(ctx: GloomPluginContext): void {
     defaultPosition: "right",
     defaultMode: "floating",
     defaultFloatingSize: { width: 80, height: 20 },
-  });
-
-  ctx.registerPaneTemplate({
+  }],
+  paneTemplates: [{
     id: "yield-curve-pane",
     paneId: "yield-curve",
     label: "Yield Curve",
     description: "US Treasury yield curve charted from FRED data.",
     keywords: ["yield", "curve", "treasury", "bonds", "rates", "gc", "interest"],
     shortcut: { prefix: "GC" },
-  });
-}
+  }],
+};

package/src/plugins/catalog-backend.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, test } from "bun:test";
+import { getDesktopBackendPlugins } from "./catalog-backend";
+import { getLoadablePlugins } from "./catalog";
+
+describe("desktop backend plugin catalog", () => {
+  test("keeps plugin identity and order aligned without renderer-only contributions", () => {
+    const backendPlugins = getDesktopBackendPlugins();
+
+    expect(backendPlugins.map((plugin) => plugin.id)).toEqual(
+      getLoadablePlugins().map((plugin) => plugin.id),
+    );
+
+    for (const pluginId of ["ticker-research", "prediction-markets"]) {
+      const plugin = backendPlugins.find((candidate) => candidate.id === pluginId);
+      expect(plugin).toBeDefined();
+      expect(plugin?.panes).toBeUndefined();
+      expect(plugin?.paneTemplates).toBeUndefined();
+      expect(plugin?.slots).toBeUndefined();
+    }
+  });
+});