gloomberb 0.11.3 → 0.12.0

package/src/plugins/builtin/world-venue-map/model.ts

@@ -11,8 +11,49 @@ export interface WorldVenueCluster extends WorldMapPoint {
   isOpen: boolean;
 }
 
+export interface WorldMapViewport {
+  zoom: number;
+  centerLongitude: number;
+  centerLatitude: number;
+}
+
 const MAX_LATITUDE = 85;
 const MIN_LATITUDE = -60;
+const LONGITUDE_SPAN = 360;
+export const MAX_WORLD_MAP_ZOOM = 18;
+
+export const DEFAULT_WORLD_MAP_VIEWPORT: WorldMapViewport = {
+  zoom: 1,
+  centerLongitude: 0,
+  centerLatitude: (MAX_LATITUDE + MIN_LATITUDE) / 2,
+};
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.max(min, Math.min(max, value));
+}
+
+function mapExtent(width: number, height: number, yUnitAspect = 1) {
+  const availableWidth = Math.max(width - 1, 0);
+  const availableHeight = Math.max(height - 1, 0);
+  const unitAspect = Math.max(yUnitAspect, Number.EPSILON);
+  const effectiveHeight = availableHeight * unitAspect;
+  const latitudeSpan = MAX_LATITUDE - MIN_LATITUDE;
+  return { availableWidth, availableHeight, unitAspect, effectiveHeight, latitudeSpan };
+}
+
+function fittedWorldMapScale(width: number, height: number, yUnitAspect = 1): number {
+  const { availableWidth, effectiveHeight, latitudeSpan } = mapExtent(width, height, yUnitAspect);
+  return Math.min(availableWidth / LONGITUDE_SPAN, effectiveHeight / latitudeSpan);
+}
+
+function worldMapScale(
+  width: number,
+  height: number,
+  yUnitAspect: number,
+  viewport: WorldMapViewport,
+): number {
+  return fittedWorldMapScale(width, height, yUnitAspect) * Math.max(viewport.zoom, 1);
+}
 
 export function projectWorldPoint(
   longitude: number,
@@ -20,35 +61,115 @@ export function projectWorldPoint(
   width: number,
   height: number,
   yUnitAspect = 1,
+  viewport: WorldMapViewport = DEFAULT_WORLD_MAP_VIEWPORT,
 ): WorldMapPoint {
-  const availableWidth = Math.max(width - 1, 0);
-  const availableHeight = Math.max(height - 1, 0);
-  const unitAspect = Math.max(yUnitAspect, Number.EPSILON);
-  const effectiveHeight = availableHeight * unitAspect;
-  const latitudeSpan = MAX_LATITUDE - MIN_LATITUDE;
-  const scale = Math.min(availableWidth / 360, effectiveHeight / latitudeSpan);
-  const mapWidth = 360 * scale;
-  const mapHeight = latitudeSpan * scale;
-  const clampedLatitude = Math.max(MIN_LATITUDE, Math.min(MAX_LATITUDE, latitude));
+  const { availableWidth, unitAspect, effectiveHeight } = mapExtent(width, height, yUnitAspect);
+  const scale = worldMapScale(width, height, yUnitAspect, viewport);
+  const clampedLatitude = clamp(latitude, MIN_LATITUDE, MAX_LATITUDE);
 
   return {
-    x: (availableWidth - mapWidth) / 2 + (longitude + 180) * scale,
-    y: ((effectiveHeight - mapHeight) / 2 + (MAX_LATITUDE - clampedLatitude) * scale) / unitAspect,
+    x: availableWidth / 2 + (longitude - viewport.centerLongitude) * scale,
+    y: (effectiveHeight / 2 - (clampedLatitude - viewport.centerLatitude) * scale) / unitAspect,
   };
 }
 
+export function unprojectWorldPoint(
+  x: number,
+  y: number,
+  width: number,
+  height: number,
+  yUnitAspect = 1,
+  viewport: WorldMapViewport = DEFAULT_WORLD_MAP_VIEWPORT,
+): { longitude: number; latitude: number } {
+  const { availableWidth, unitAspect, effectiveHeight } = mapExtent(width, height, yUnitAspect);
+  const scale = worldMapScale(width, height, yUnitAspect, viewport);
+  return {
+    longitude: viewport.centerLongitude + (x - availableWidth / 2) / scale,
+    latitude: viewport.centerLatitude - (y * unitAspect - effectiveHeight / 2) / scale,
+  };
+}
+
+export function clampWorldMapViewport(
+  viewport: WorldMapViewport,
+  width: number,
+  height: number,
+  yUnitAspect = 1,
+): WorldMapViewport {
+  const zoom = clamp(viewport.zoom, 1, MAX_WORLD_MAP_ZOOM);
+  if (zoom <= 1) return DEFAULT_WORLD_MAP_VIEWPORT;
+
+  const { availableWidth, effectiveHeight, latitudeSpan } = mapExtent(width, height, yUnitAspect);
+  const scale = fittedWorldMapScale(width, height, yUnitAspect) * zoom;
+  const halfLongitude = availableWidth / (2 * scale);
+  const halfLatitude = effectiveHeight / (2 * scale);
+  const minLongitude = -180 + halfLongitude;
+  const maxLongitude = 180 - halfLongitude;
+  const minLatitude = MIN_LATITUDE + halfLatitude;
+  const maxLatitude = MAX_LATITUDE - halfLatitude;
+
+  return {
+    zoom,
+    centerLongitude: minLongitude < maxLongitude
+      ? clamp(viewport.centerLongitude, minLongitude, maxLongitude)
+      : DEFAULT_WORLD_MAP_VIEWPORT.centerLongitude,
+    centerLatitude: halfLatitude < latitudeSpan / 2
+      ? clamp(viewport.centerLatitude, minLatitude, maxLatitude)
+      : DEFAULT_WORLD_MAP_VIEWPORT.centerLatitude,
+  };
+}
+
+export function zoomWorldMapViewport(
+  viewport: WorldMapViewport,
+  width: number,
+  height: number,
+  point: WorldMapPoint,
+  zoomFactor: number,
+  yUnitAspect = 1,
+): WorldMapViewport {
+  const nextZoom = clamp(viewport.zoom * zoomFactor, 1, MAX_WORLD_MAP_ZOOM);
+  if (nextZoom <= 1) return DEFAULT_WORLD_MAP_VIEWPORT;
+
+  const geographic = unprojectWorldPoint(point.x, point.y, width, height, yUnitAspect, viewport);
+  const { availableWidth, unitAspect, effectiveHeight } = mapExtent(width, height, yUnitAspect);
+  const scale = fittedWorldMapScale(width, height, yUnitAspect) * nextZoom;
+  return clampWorldMapViewport({
+    zoom: nextZoom,
+    centerLongitude: geographic.longitude - (point.x - availableWidth / 2) / scale,
+    centerLatitude: geographic.latitude + (point.y * unitAspect - effectiveHeight / 2) / scale,
+  }, width, height, yUnitAspect);
+}
+
+export function panWorldMapViewport(
+  viewport: WorldMapViewport,
+  width: number,
+  height: number,
+  deltaX: number,
+  deltaY: number,
+  yUnitAspect = 1,
+): WorldMapViewport {
+  if (viewport.zoom <= 1) return DEFAULT_WORLD_MAP_VIEWPORT;
+  const scale = worldMapScale(width, height, yUnitAspect, viewport);
+  const unitAspect = Math.max(yUnitAspect, Number.EPSILON);
+  return clampWorldMapViewport({
+    zoom: viewport.zoom,
+    centerLongitude: viewport.centerLongitude - deltaX / scale,
+    centerLatitude: viewport.centerLatitude + (deltaY * unitAspect) / scale,
+  }, width, height, yUnitAspect);
+}
+
 export function clusterWorldVenues(
   venues: readonly CloudWorldVenuePayload[],
   width: number,
   height: number,
   yUnitAspect = 1,
+  viewport: WorldMapViewport = DEFAULT_WORLD_MAP_VIEWPORT,
 ): WorldVenueCluster[] {
   const buckets = new Map<string, CloudWorldVenuePayload[]>();
   const cellWidth = Math.max(4, Math.round(width / 18));
   const cellHeight = Math.max(2, Math.round(height / 12));
 
   for (const venue of venues) {
-    const point = projectWorldPoint(venue.longitude, venue.latitude, width, height, yUnitAspect);
+    const point = projectWorldPoint(venue.longitude, venue.latitude, width, height, yUnitAspect, viewport);
     const key = `${Math.floor(point.x / cellWidth)}:${Math.floor(point.y / cellHeight)}`;
     const bucket = buckets.get(key) ?? [];
     bucket.push(venue);
@@ -58,7 +179,7 @@ export function clusterWorldVenues(
   return [...buckets.entries()].map(([id, grouped]) => {
     const point = grouped.reduce(
       (sum, venue) => {
-        const projected = projectWorldPoint(venue.longitude, venue.latitude, width, height, yUnitAspect);
+        const projected = projectWorldPoint(venue.longitude, venue.latitude, width, height, yUnitAspect, viewport);
         return { x: sum.x + projected.x, y: sum.y + projected.y };
       },
       { x: 0, y: 0 },

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

@@ -5,7 +5,7 @@ import { Button, EmptyState, Spinner, StaticChartSurface, type PaneFooterSegment
 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 { resolveChartPalette } from "../../../components/chart/core/palette";
 import type { ProjectedChartPoint } from "../../../components/chart/core/data";
 import {
   curveAsOf,

package/src/plugins/bundle.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+import { bundleExternalPlugin, buildSharedModuleSource } from "./bundle";
+import { PLUGIN_HOST_GLOBAL } from "./host-contract";
+
+/**
+ * This is the seam that lets a plugin on disk run inside the desktop and
+ * browser renderers, and the failure it prevents is nasty: if `react` or a
+ * `gloomberb/*` module gets bundled into the plugin instead of shared with the
+ * host, the plugin loads fine and then throws on its first hook, or silently
+ * renders against a second copy of the theme. That is worth pinning down.
+ */
+
+function scratchPlugin(source: string): string {
+  const dir = mkdtempSync(join(tmpdir(), "gloom-bundle-"));
+  writeFileSync(join(dir, "package.json"), JSON.stringify({ name: "scratch", main: "index.tsx" }));
+  writeFileSync(join(dir, "index.tsx"), source);
+  return dir;
+}
+
+const fakeExports = async (specifier: string) => (
+  specifier === "gloomberb/ui" ? ["Box", "Text"] : specifier === "react" ? ["useState"] : []
+);
+
+describe("buildSharedModuleSource", () => {
+  test("re-exports each name from the host registry", () => {
+    const source = buildSharedModuleSource("gloomberb/ui", ["Box", "Text"]);
+
+    expect(source).toContain(PLUGIN_HOST_GLOBAL);
+    expect(source).toContain('export const Box = mod["Box"];');
+    expect(source).toContain('export const Text = mod["Text"];');
+  });
+
+  test("throws a directed error when the host registry is missing", () => {
+    // A plugin bundle loaded before the host installs its modules should say so,
+    // not fail later with an undefined property read deep in a render.
+    const source = buildSharedModuleSource("gloomberb/ui", []);
+    expect(source).toContain("was not installed before this plugin loaded");
+  });
+
+  test("skips a default export, which the module already provides", () => {
+    expect(buildSharedModuleSource("react", ["default", "useState"]))
+      .not.toContain("export const default");
+  });
+});
+
+describe("bundleExternalPlugin", () => {
+  test("shares react and gloomberb modules instead of bundling them", async () => {
+    const dir = scratchPlugin(`
+      import { useState } from "react";
+      import { Box } from "gloomberb/ui";
+      export default { id: "scratch", name: "Scratch", version: "1.0.0", useState, Box };
+    `);
+    const out = join(dir, "out");
+    try {
+      const result = await bundleExternalPlugin(dir, out, { exportNamesFor: fakeExports });
+      const code = await Bun.file(result.outputPath).text();
+
+      expect(result.shared).toEqual(["gloomberb/ui", "react"]);
+      expect(code).toContain(PLUGIN_HOST_GLOBAL);
+      // The giveaway that React got inlined rather than shared.
+      expect(code).not.toContain("react-dom/client");
+      expect(code).not.toContain("Invalid hook call");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("bundles a plugin's own dependencies rather than sharing them", async () => {
+    const dir = scratchPlugin(`
+      import { double } from "./helper";
+      export default { id: "scratch", name: "Scratch", version: "1.0.0", value: double(21) };
+    `);
+    writeFileSync(join(dir, "helper.ts"), "export function double(n: number) { return n * 2; }");
+    const out = join(dir, "out");
+    try {
+      const result = await bundleExternalPlugin(dir, out, { exportNamesFor: fakeExports });
+      const code = await Bun.file(result.outputPath).text();
+
+      expect(result.shared).toEqual([]);
+      expect(code).toContain("* 2");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("reports a compile error against the plugin instead of throwing something opaque", async () => {
+    const dir = scratchPlugin(`import { missing } from "./nope"; export default missing;`);
+    try {
+      await expect(bundleExternalPlugin(dir, join(dir, "out"), { exportNamesFor: fakeExports }))
+        .rejects.toThrow();
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("rejects a directory with no entry file", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "gloom-bundle-empty-"));
+    mkdirSync(join(dir, "src"), { recursive: true });
+    try {
+      await expect(bundleExternalPlugin(dir, join(dir, "out"))).rejects.toThrow("No plugin entry file");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/src/plugins/bundle.ts

@@ -0,0 +1,139 @@
+import { mkdir } from "fs/promises";
+import { join } from "path";
+
+import { resolvePluginEntry } from "./loader";
+import { PLUGIN_HOST_GLOBAL, SHARED_SPECIFIERS } from "./host-contract";
+
+/**
+ * Compiles an external plugin for a renderer that cannot read the filesystem.
+ *
+ * The terminal renderer runs in Bun and can `import()` a plugin directly from
+ * `~/.gloomberb/plugins`. The desktop view and the hosted browser app cannot:
+ * they are browser contexts running a sealed bundle, so plugin source has to be
+ * compiled to an ES module they can fetch.
+ *
+ * The hard part is not compiling, it is *sharing*. A plugin bundle that carries
+ * its own React would give the process a second React instance and throw on the
+ * first hook, and it has no way to reach the host's `gloomberb/*` modules at
+ * all. So those specifiers are not bundled — they are rewritten to read from a
+ * registry the host publishes on `globalThis` before it loads any plugin. One
+ * instance of every shared module, exactly as on the terminal side where the
+ * host is symlinked in.
+ */
+
+
+
+/**
+ * Source for a module that re-exports one shared specifier from the host
+ * registry. Named exports have to be listed statically — `export *` cannot
+ * forward from a runtime object — so the caller passes the names it found by
+ * importing the real module.
+ */
+export function buildSharedModuleSource(specifier: string, exportNames: readonly string[]): string {
+  const lines = [
+    `const mod = globalThis[${JSON.stringify(PLUGIN_HOST_GLOBAL)}]?.[${JSON.stringify(specifier)}];`,
+    `if (!mod) throw new Error(${JSON.stringify(`Gloomberb host module "${specifier}" is unavailable. The plugin host was not installed before this plugin loaded.`)});`,
+    "export default mod;",
+  ];
+  for (const name of exportNames) {
+    if (name === "default") continue;
+    // Not `export const`: a getter keeps live bindings working and avoids
+    // capturing a value the host may replace on a theme or locale change.
+    lines.push(`export const ${name} = mod[${JSON.stringify(name)}];`);
+  }
+  return lines.join("\n");
+}
+
+export interface BundlePluginResult {
+  /** Absolute path of the emitted ES module. */
+  outputPath: string;
+  /** Shared specifiers this plugin actually imported. */
+  shared: string[];
+  warnings: string[];
+}
+
+/**
+ * Bun plugin that redirects the shared specifiers to generated modules.
+ *
+ * `exportNamesFor` is injected so this stays testable and so the caller decides
+ * how names are discovered — the bundler runs in Bun and can simply import the
+ * real module, but a test should not have to.
+ */
+export function createSharedModuleResolver(
+  exportNamesFor: (specifier: string) => Promise<readonly string[]>,
+  onShared?: (specifier: string) => void,
+): import("bun").BunPlugin {
+  const namespace = "gloom-host";
+  const shared = new Set<string>(SHARED_SPECIFIERS);
+
+  return {
+    name: "gloomberb-host-modules",
+    setup(build) {
+      build.onResolve({ filter: /.*/ }, (args) => {
+        if (!shared.has(args.path)) return undefined;
+        onShared?.(args.path);
+        return { path: args.path, namespace };
+      });
+
+      build.onLoad({ filter: /.*/, namespace }, async (args) => ({
+        contents: buildSharedModuleSource(args.path, await exportNamesFor(args.path)),
+        loader: "js",
+      }));
+    },
+  };
+}
+
+async function hostExportNames(specifier: string): Promise<readonly string[]> {
+  const mod = await import(specifier);
+  return Object.keys(mod).sort();
+}
+
+/**
+ * Bundles one plugin directory to `outDir`, returning the emitted module path.
+ * Throws on a compile error so the caller can surface it against the plugin
+ * rather than failing the whole renderer.
+ */
+export async function bundleExternalPlugin(
+  pluginDir: string,
+  outDir: string,
+  options: { exportNamesFor?: (specifier: string) => Promise<readonly string[]> } = {},
+): Promise<BundlePluginResult> {
+  const entry = await resolvePluginEntry(pluginDir);
+  if (!entry) throw new Error(`No plugin entry file in ${pluginDir}`);
+
+  await mkdir(outDir, { recursive: true });
+
+  const shared = new Set<string>();
+  const result = await Bun.build({
+    entrypoints: [entry],
+    outdir: outDir,
+    target: "browser",
+    format: "esm",
+    splitting: false,
+    minify: false,
+    sourcemap: "none",
+    plugins: [
+      createSharedModuleResolver(
+        options.exportNamesFor ?? hostExportNames,
+        (specifier) => shared.add(specifier),
+      ),
+    ],
+  });
+
+  if (!result.success) {
+    throw new Error(result.logs.map((log) => log.message).join("\n"));
+  }
+
+  const output = result.outputs.find((entryOutput) => entryOutput.kind === "entry-point");
+  if (!output) throw new Error(`Bundling ${pluginDir} produced no entry point`);
+
+  return {
+    outputPath: output.path,
+    shared: [...shared].sort(),
+    warnings: result.logs.filter((log) => log.level === "warning").map((log) => log.message),
+  };
+}
+
+export function pluginBundleCacheDir(baseDir: string): string {
+  return join(baseDir, "bundles");
+}

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

@@ -63,6 +63,7 @@ describe("browser plugin catalog", () => {
       "market-heatmap",
       "market-movers",
       "market-halts",
+      "fear-greed",
       "earnings-calendar",
       "ipo-calendar",
       "tv",

package/src/plugins/catalog-browser.ts

@@ -12,7 +12,13 @@ import { connectionsModule } from "./builtin/connections";
 import { correlationModule } from "./builtin/correlation";
 import { cdsModule } from "./builtin/cds";
 import { creditConditionsModule } from "./builtin/credit-conditions";
+import { marketValuationModule } from "./builtin/market-valuation";
+import {
+  attachValuationPersistence,
+  resetValuationPersistence,
+} from "./builtin/market-valuation/cache";
 import { economicCalendarModule } from "./builtin/econ";
+import { econStatisticsModule } from "./builtin/econ-statistics";
 import { futuresModule } from "./builtin/futures";
 import { fxMatrixModule } from "./builtin/fx-matrix";
 import { helpModule } from "./builtin/help";
@@ -94,9 +100,11 @@ const browserMarketOverviewPlugin = composeBuiltinPlugin({
 const browserFredResourcesModule: PluginModule = {
   setup(ctx) {
     attachFredSeriesPersistence(ctx.persistence);
+    attachValuationPersistence(ctx.persistence);
   },
   dispose() {
     resetFredSeriesPersistence();
+    resetValuationPersistence();
   },
 };
 
@@ -109,9 +117,11 @@ const browserMacroPlugin = composeBuiltinPlugin({
   modules: [
     browserFredResourcesModule,
     economicCalendarModule,
+    econStatisticsModule,
     yieldCurveModule,
     volatilityModule,
     creditConditionsModule,
+    marketValuationModule,
     cdsModule,
     treasuryAuctionsModule,
   ],

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

@@ -0,0 +1,43 @@
+import { describe, expect, test } from "bun:test";
+
+import { buildBuiltinManifest } from "./catalog-manifest";
+
+/**
+ * The published manifest is the built-in half of the plugin directory. It used
+ * to be hand-maintained in a separate repository, where it drifted from the
+ * real catalog with nothing to catch it: a built-in could rename itself, gain a
+ * pane, or be added outright, and the directory would keep showing the old
+ * description indefinitely.
+ *
+ * These tests exist so that cannot recur. Drift now fails here rather than
+ * being discovered by a user reading a stale listing.
+ */
+describe("built-in plugin manifest", () => {
+  test("matches the committed file, so the directory cannot serve a stale catalog", async () => {
+    const committed = JSON.parse(
+      await Bun.file(new URL("../../plugin-manifest.json", import.meta.url)).text(),
+    );
+    const { uncategorised: _drop, ...generated } = buildBuiltinManifest();
+
+    expect(generated).toEqual(committed);
+  });
+
+  test("every built-in has editorial metadata", () => {
+    // A new built-in with no categories would appear unfiltered and
+    // uncategorised in the directory, so generation refuses instead.
+    expect(buildBuiltinManifest().uncategorised).toEqual([]);
+  });
+
+  test("exactly one plugin is featured", () => {
+    const featured = buildBuiltinManifest().plugins.filter((plugin) => plugin.featured);
+
+    expect(featured.map((plugin) => plugin.id)).toEqual(["gloomberb-cloud"]);
+  });
+
+  test("describes what each plugin contributes, which is what the directory renders", () => {
+    const cloud = buildBuiltinManifest().plugins.find((plugin) => plugin.id === "gloomberb-cloud");
+
+    expect(cloud?.contributes.panes).toContain("chat");
+    expect(cloud?.contributes.capabilities.length).toBeGreaterThan(0);
+  });
+});

package/src/plugins/catalog-manifest.ts

@@ -0,0 +1,92 @@
+import { getPluginCatalog } from "./catalog";
+
+/**
+ * The public description of the plugins that ship inside Gloomberb.
+ *
+ * The plugin directory has to list built-ins alongside installable ones, but a
+ * built-in has no repository to read metadata from. Hand-maintaining that half
+ * elsewhere meant it silently drifted every time a built-in changed its panes
+ * or description, so it is derived from the live catalog here instead and
+ * checked against a committed snapshot in CI.
+ */
+
+export interface BuiltinPluginManifestEntry {
+  id: string;
+  name: string;
+  description: string;
+  /** Curated, since the catalog has no notion of categories. */
+  categories: string[];
+  toggleable: boolean;
+  featured?: true;
+  contributes: {
+    panes: string[];
+    capabilities: string[];
+    broker: boolean;
+  };
+}
+
+/**
+ * Editorial metadata the runtime catalog does not carry. Anything missing here
+ * is reported by `generate-plugin-manifest.ts` rather than silently defaulted,
+ * so a new built-in cannot slip into the directory uncategorised.
+ */
+const EDITORIAL: Record<string, { categories: string[]; featured?: true }> = {
+  "gloomberb-cloud": { categories: ["data", "cloud"], featured: true },
+  ai: { categories: ["ai"] },
+  alerts: { categories: ["alerts"] },
+  application: { categories: ["core"] },
+  broker: { categories: ["broker"] },
+  debug: { categories: ["developer"] },
+  macro: { categories: ["macro"] },
+  "market-overview": { categories: ["markets"] },
+  news: { categories: ["news"] },
+  notes: { categories: ["productivity"] },
+  polls: { categories: ["data"] },
+  portfolio: { categories: ["portfolio"] },
+  "prediction-markets": { categories: ["markets"] },
+  public: { categories: ["broker"] },
+  "research-search": { categories: ["research", "news"] },
+  robinhood: { categories: ["broker"] },
+  simplefin: { categories: ["broker"] },
+  "ticker-research": { categories: ["research"] },
+  yahoo: { categories: ["data"] },
+};
+
+export interface BuiltinManifest {
+  version: 1;
+  plugins: BuiltinPluginManifestEntry[];
+  /** Built-in ids with no editorial entry; a non-empty list fails generation. */
+  uncategorised: string[];
+}
+
+export function buildBuiltinManifest(): BuiltinManifest {
+  const uncategorised: string[] = [];
+
+  const plugins = getPluginCatalog()
+    .map(({ plugin }) => {
+      const editorial = EDITORIAL[plugin.id];
+      if (!editorial) uncategorised.push(plugin.id);
+
+      return {
+        id: plugin.id,
+        name: plugin.name,
+        description: plugin.description ?? "",
+        categories: editorial?.categories ?? [],
+        toggleable: plugin.toggleable === true,
+        ...(editorial?.featured ? { featured: true as const } : {}),
+        contributes: {
+          panes: (plugin.panes ?? []).map((pane) => pane.id).sort(),
+          capabilities: (plugin.capabilities ?? [])
+            .map((capability) => {
+              const value = capability as { id?: string; kind?: string };
+              return value.id ?? value.kind ?? "capability";
+            })
+            .sort(),
+          broker: !!plugin.broker,
+        },
+      };
+    })
+    .sort((left, right) => left.id.localeCompare(right.id));
+
+  return { version: 1, plugins, uncategorised: uncategorised.sort() };
+}

package/src/plugins/catalog-ui.ts

@@ -1,16 +1,16 @@
 import type { GloomPlugin } from "../types/plugin";
+import type { LoadedExternalPlugin } from "./loader";
 import { newsPlugin } from "./builtin/news";
 import { notesPlugin } from "./builtin/notes";
-import { substackPlugin } from "./builtin/substack";
 import { aiPlugin } from "./builtin/ai";
 import { gloomberbCloudPlugin } from "./builtin/cloud";
-import { ibkrPlugin } from "./ibkr";
 import { publicPlugin } from "./broker-sync/public";
 import { robinhoodPlugin } from "./broker-sync/robinhood";
 import { simpleFinPlugin } from "./broker-sync/simplefin";
 import { predictionMarketsPlugin } from "./prediction-markets";
 import { pollsPlugin } from "./builtin/polls";
 import { alertsPlugin } from "./builtin/alerts";
+import { researchSearchPlugin } from "./builtin/research-search";
 import {
   applicationPlugin,
   brokerPlugin,
@@ -25,13 +25,11 @@ export const uiBuiltinPlugins: GloomPlugin[] = [
   portfolioPlugin,
   tickerResearchPlugin,
   brokerPlugin,
-  ibkrPlugin,
   publicPlugin,
   robinhoodPlugin,
   simpleFinPlugin,
   applicationPlugin,
   newsPlugin,
-  substackPlugin,
   notesPlugin,
   aiPlugin,
   predictionMarketsPlugin,
@@ -39,8 +37,26 @@ export const uiBuiltinPlugins: GloomPlugin[] = [
   marketOverviewPlugin,
   macroPlugin,
   alertsPlugin,
+  researchSearchPlugin,
 ];
 
 export function getRendererBuiltinPlugins(): GloomPlugin[] {
   return uiBuiltinPlugins;
 }
+
+/**
+ * The plugin list for a UI renderer: the built-ins it ships with, plus any
+ * external plugins that loaded and support this renderer.
+ *
+ * Deliberately not `getLoadablePlugins`, which is the CLI catalog and also
+ * carries the Yahoo fallback provider and the debug plugin. Routing the desktop
+ * through it would quietly change which plugins the app runs.
+ */
+export function getRendererPlugins(externalPlugins: readonly LoadedExternalPlugin[] = []): GloomPlugin[] {
+  return [
+    ...uiBuiltinPlugins,
+    ...externalPlugins
+      .filter((entry) => !entry.error && !entry.unsupportedTarget)
+      .map((entry) => entry.plugin),
+  ];
+}