gloomberb 0.11.3 → 0.12.0

package/src/api-client/normalizers.ts

@@ -3,11 +3,50 @@ import type {
   ChatMessage,
   ChatNotification,
   ChatStateResponse,
+  CloudSavedSearch,
+  CloudSearchHit,
+  CloudSearchResponse,
   CloudTweetPayload,
   CloudTweetSearchResponse,
 } from "./types";
 import { normalizeTimestamp } from "../utils/timestamp";
 
+/**
+ * Saved-search writes answer with either the record itself or `{ search }`.
+ * Both shapes are accepted so a server-side envelope change cannot silently
+ * hand the pane an object with no `id`.
+ */
+export function normalizeSavedSearchResponse(response: unknown): CloudSavedSearch {
+  const envelope = response as { search?: CloudSavedSearch } | CloudSavedSearch | null;
+  const search = envelope && "search" in envelope && envelope.search
+    ? envelope.search
+    : envelope as CloudSavedSearch | null;
+  if (!search?.id) throw new Error("The saved search response was missing a record.");
+  return search;
+}
+
+export function normalizeSavedSearchHits(response: unknown): CloudSearchHit[] {
+  const hits = (response as { hits?: unknown } | null)?.hits;
+  return Array.isArray(hits) ? (hits as CloudSearchHit[]).map(normalizeSearchHit) : [];
+}
+
+/**
+ * A wire story or filing need not name an issuer, and the server sends `ticker:
+ * null` when it does not. Coerced to an empty string at the boundary so the
+ * declared `string` is true of every hit: consumers test it for truthiness,
+ * join it into search text, and hand it to a badge, and a null reaches each of
+ * those as an empty chip, the literal "null", or a crash.
+ */
+export function normalizeSearchHit(hit: CloudSearchHit): CloudSearchHit {
+  return hit.ticker ? hit : { ...hit, ticker: "" };
+}
+
+export function normalizeSearchResponse(response: CloudSearchResponse): CloudSearchResponse {
+  const hits = response.hits;
+  if (!Array.isArray(hits)) return { ...response, hits: [] };
+  return { ...response, hits: hits.map(normalizeSearchHit) };
+}
+
 export function normalizeChatMessage(message: ChatMessage): ChatMessage {
   return {
     ...message,

package/src/api-client/paths.ts

@@ -1,4 +1,4 @@
-import type { CloudTweetQueryType } from "./types";
+import type { CloudSearchDocType, CloudSearchSort, CloudTweetQueryType } from "./types";
 import { normalizeSymbol, publicTickerKey } from "../utils/exchanges";
 
 export type CloudHistoryParams = {
@@ -34,6 +34,14 @@ export type CloudCongressHouseParams = {
   refresh?: boolean;
 };
 
+export type CloudEarningsCallsParams = {
+  ticker?: string;
+  limit?: number;
+  offset?: number;
+  /** Include calls still working through the transcription pipeline. */
+  includePending?: boolean;
+};
+
 export type CloudNewsParams = {
   feed?: "latest" | "top" | "breaking" | "ticker" | "sector" | "topic";
   ticker?: string;
@@ -131,6 +139,10 @@ export function cloudHistoryPath(symbol: string, exchange: string, params: Cloud
   return appendQuery("/market/history", search);
 }
 
+export function cloudShillerPath(): string {
+  return "/cloud/econ/shiller";
+}
+
 export function cloudExchangeRatePath(fromCurrency: string): string {
   return appendQuery("/market/exchange-rate", new URLSearchParams({ fromCurrency }));
 }
@@ -181,6 +193,19 @@ export function cloudCongressHousePath(params: CloudCongressHouseParams = {}): s
   return appendQuery("/cloud/congress/house", search);
 }
 
+export function cloudEarningsCallsPath(params: CloudEarningsCallsParams = {}): string {
+  const search = new URLSearchParams();
+  if (params.ticker) search.set("ticker", params.ticker);
+  if (params.limit != null) search.set("limit", String(params.limit));
+  if (params.offset != null) search.set("offset", String(params.offset));
+  if (params.includePending) search.set("includePending", "true");
+  return appendQuery("/cloud/transcripts", search);
+}
+
+export function cloudEarningsTranscriptPath(id: string): string {
+  return `/cloud/transcripts/${encodeURIComponent(id)}`;
+}
+
 export function cloudSecFilingsPath(params: CloudSecFilingsParams): string {
   const search = new URLSearchParams({ ticker: params.ticker });
   if (params.limit != null) search.set("limit", String(params.limit));
@@ -218,6 +243,65 @@ export function cloudSec13FPath(path: string, params: Record<string, string | nu
   return appendQuery(`/cloud/sec/13f/${normalized}`, search);
 }
 
+export type CloudSearchParams = {
+  query: string;
+  tickers?: readonly string[];
+  docTypes?: readonly CloudSearchDocType[];
+  sources?: readonly string[];
+  /** Inclusive ISO date or timestamp bounds on `publishedAt`. */
+  from?: string;
+  to?: string;
+  sort?: CloudSearchSort;
+  limit?: number;
+  offset?: number;
+  /** Set false to skip the total-count pass when only the top hits are shown. */
+  count?: boolean;
+  /** One row per source document instead of one per matching chunk. */
+  distinct?: boolean;
+};
+
+function csvParam(values: readonly string[] | undefined): string | null {
+  if (!values) return null;
+  const cleaned = values.map((value) => value.trim()).filter((value) => value.length > 0);
+  return cleaned.length > 0 ? cleaned.join(",") : null;
+}
+
+export function cloudSearchPath(params: CloudSearchParams): string {
+  const search = new URLSearchParams({ q: params.query.trim() });
+  const tickers = csvParam(params.tickers?.map(normalizeSymbol));
+  if (tickers) search.set("tickers", tickers);
+  const docTypes = csvParam(params.docTypes);
+  if (docTypes) search.set("docTypes", docTypes);
+  const sources = csvParam(params.sources);
+  if (sources) search.set("sources", sources);
+  if (params.from) search.set("from", params.from);
+  if (params.to) search.set("to", params.to);
+  if (params.sort) search.set("sort", params.sort);
+  if (params.limit != null) search.set("limit", String(params.limit));
+  // Offset 0 is the default page, so sending it only lengthens the cache key.
+  if (params.offset) search.set("offset", String(params.offset));
+  // Counting is the server default, so only opting out is worth a parameter.
+  if (params.count === false) search.set("count", "false");
+  if (params.distinct) search.set("distinct", "true");
+  return appendQuery("/cloud/search", search);
+}
+
+export function cloudSearchDocumentPath(docType: CloudSearchDocType, sourceId: string): string {
+  return `/cloud/search/documents/${encodeURIComponent(docType)}/${encodeURIComponent(sourceId)}`;
+}
+
+export function cloudSavedSearchesPath(): string {
+  return "/cloud/search/saved";
+}
+
+export function cloudSavedSearchPath(id: string): string {
+  return `/cloud/search/saved/${encodeURIComponent(id)}`;
+}
+
+export function cloudSavedSearchHitsPath(id: string): string {
+  return `${cloudSavedSearchPath(id)}/hits`;
+}
+
 export function cloudNewsPath(params: CloudNewsParams = {}): string {
   const search = new URLSearchParams();
   if (params.feed) search.set("feed", params.feed);

package/src/api-client/types.ts

@@ -346,6 +346,28 @@ export interface CloudFredSeriesPayload {
   info: CloudFredSeriesInfoPayload | null;
 }
 
+/**
+ * One month of Robert Shiller's dataset. FRED carries no long-run S&P earnings,
+ * so this is what every earnings-based valuation ratio is built from.
+ */
+export interface CloudShillerObservationPayload {
+  date: string;
+  price: number | null;
+  dividend: number | null;
+  earnings: number | null;
+  cpi: number | null;
+  longRate: number | null;
+  cape: number | null;
+  /** CAPE earnings yield over the real 10-year rate; Shiller's equity risk premium. */
+  excessCapeYield: number | null;
+}
+
+export interface CloudShillerPayload {
+  observations: CloudShillerObservationPayload[];
+  sourceUrl: string;
+  fetchedAt: string;
+}
+
 /** One publicly disseminated single-name CDS transaction report. */
 export interface CloudCdsTradePayload {
   disseminationId: string;
@@ -466,6 +488,180 @@ export interface CloudCongressHousePayload {
   members: CloudCongressMemberPayload[];
 }
 
+export interface CloudEarningsCallPayload {
+  id: string;
+  ticker: string;
+  companyName: string | null;
+  fiscalYear: number | null;
+  fiscalQuarter: number | null;
+  callAt: string | null;
+  status: string;
+  durationSeconds: number | null;
+  wordCount: number | null;
+  hasTranscript: boolean;
+  sentiment: number | null;
+  /** The replay or event page the transcript came from. */
+  webcastUrl?: string | null;
+}
+
+export interface CloudEarningsCallListPayload {
+  calls: CloudEarningsCallPayload[];
+  /** Set when asking about a company started a search that is still running. */
+  pending?: boolean;
+  /** Set when the requested symbol is not one the SEC knows. */
+  unknownTicker?: boolean;
+}
+
+export interface CloudTranscriptTurnPayload {
+  speaker: string;
+  role?: string;
+  company?: string;
+  text: string;
+  isQa: boolean;
+  startSeconds: number;
+}
+
+export interface CloudTranscriptParticipantPayload {
+  name: string;
+  role?: string;
+  company?: string;
+}
+
+export interface CloudEarningsTranscriptPayload {
+  id: string;
+  ticker: string;
+  companyName: string | null;
+  fiscalYear: number | null;
+  fiscalQuarter: number | null;
+  callAt: string | null;
+  timing: string | null;
+  webcastUrl: string | null;
+  durationSeconds: number | null;
+  status: string;
+  fullText: string;
+  turns: CloudTranscriptTurnPayload[];
+  participants: CloudTranscriptParticipantPayload[];
+  summary: string | null;
+  guidance: string | null;
+  riskFactors: string | null;
+  analystFocus: string | null;
+  notable: string | null;
+  sentiment: number | null;
+  sentimentRationale: string | null;
+  qaStartTurn: number | null;
+  wordCount: number | null;
+  asrModel: string | null;
+  updatedAt: string | null;
+}
+
+export type CloudSearchDocType = "transcript" | "news" | "filing";
+
+export type CloudSearchSort = "relevance" | "newest" | "oldest";
+
+/**
+ * Per-chunk provenance. Which keys are present depends on `docType`: transcripts
+ * carry speaker attribution, news carries the wire source, filings carry the
+ * form and section. Kept as one optional-key record so an unknown docType from a
+ * newer server still renders instead of failing to parse.
+ */
+export interface CloudSearchChunkMetadata {
+  speaker?: string;
+  role?: string;
+  company?: string;
+  isQa?: boolean;
+  startSeconds?: number;
+  turnIndex?: number;
+  source?: string;
+  summary?: string;
+  form?: string;
+  accession?: string;
+  section?: string;
+}
+
+export interface CloudSearchHit {
+  id: string;
+  docType: CloudSearchDocType;
+  sourceId: string;
+  chunkIndex: number;
+  ticker: string;
+  publishedAt: string;
+  title: string;
+  url: string;
+  /** Matched terms wrapped in `<mark>`, fragments joined by an ellipsis. */
+  snippet: string;
+  score: number;
+  metadata: CloudSearchChunkMetadata;
+  /**
+   * Chunks of this document that matched. Only sent for a distinct search,
+   * where the row stands for the document rather than for one chunk.
+   */
+  matchCount?: number;
+}
+
+export interface CloudSearchResponse {
+  hits: CloudSearchHit[];
+  total: number;
+  /** The server stopped counting past its cap, so `total` is a lower bound. */
+  countCapped: boolean;
+  hasMore: boolean;
+  nextOffset: number;
+  tookMs: number;
+}
+
+export interface CloudSearchDocumentChunk {
+  id: string;
+  chunkIndex: number;
+  body: string;
+  metadata: CloudSearchChunkMetadata;
+}
+
+export interface CloudSearchDocument {
+  docType: CloudSearchDocType;
+  sourceId: string;
+  ticker: string;
+  title: string;
+  url: string;
+  publishedAt: string;
+  chunks: CloudSearchDocumentChunk[];
+}
+
+export interface CloudSearchDocumentResponse {
+  document: CloudSearchDocument;
+}
+
+export interface CloudSavedSearchFilters {
+  tickers?: string[];
+  docTypes?: CloudSearchDocType[];
+  sources?: string[];
+  from?: string;
+  to?: string;
+}
+
+export interface CloudSavedSearch {
+  id: string;
+  name: string;
+  query: string;
+  filters: CloudSavedSearchFilters;
+  alertEnabled: boolean;
+  alertChannels: string[];
+  lastRunAt: string | null;
+  lastMatchAt: string | null;
+  matchCount: number;
+  createdAt: string;
+}
+
+export interface CloudSavedSearchListResponse {
+  searches: CloudSavedSearch[];
+}
+
+export interface CloudSavedSearchInput {
+  name: string;
+  query: string;
+  filters?: CloudSavedSearchFilters;
+  alertEnabled?: boolean;
+  alertChannels?: string[];
+}
+
 export interface CloudSecFilingPayload {
   accessionNumber: string;
   form: string;

package/src/app/pane-runtime/index.tsx

@@ -9,6 +9,7 @@ import {
   isPaneInLayout,
 } from "../../plugins/pane-manager";
 import type { PluginRegistry } from "../../plugins/registry";
+import type { LoadedExternalPlugin } from "../../plugins/loader";
 import {
   getFocusedCollectionId,
   resolveTickerForPane,
@@ -19,7 +20,6 @@ import {
 import { scheduleConfigSave } from "../../state/config-save-scheduler";
 import {
   createPaneInstance,
-  findPaneInstance,
   isTickerPaneId,
   normalizePaneId,
   normalizePaneLayout,
@@ -36,6 +36,7 @@ import type {
 import type { DialogApi } from "../../ui/dialog";
 import {
   resolvePanelForPane,
+  resolvePaneShowTarget,
   resolvePaneTarget as resolvePaneTargetInLayout,
   selectEdgeAnchor,
 } from "./layout-placement";
@@ -50,8 +51,10 @@ interface AppPaneRuntimeArgs {
   detachedPaneId: string | null;
   dialog: DialogApi;
   dispatch: Dispatch<AppAction>;
+  externalPlugins: readonly LoadedExternalPlugin[];
   isDetachedWindow: boolean;
   notify: (body: string, options?: { type?: "info" | "success" | "error" }) => void;
+  persistConfig: (nextConfig: AppState["config"]) => void;
   pluginRegistry: PluginRegistry;
   state: AppState;
   stateRef: { current: AppState };
@@ -63,8 +66,10 @@ export function useAppPaneRuntime({
   detachedPaneId,
   dialog,
   dispatch,
+  externalPlugins,
   isDetachedWindow,
   notify,
+  persistConfig,
   pluginRegistry,
   state,
   stateRef,
@@ -204,26 +209,23 @@ export function useAppPaneRuntime({
   ]);
 
   const showPane = useCallback((paneId: string) => {
-    const normalizedPaneId = normalizePaneId(paneId);
-    const paneDef = pluginRegistry.panes.get(normalizedPaneId);
+    const target = resolvePaneShowTarget(state.config.layout, paneId);
+    const paneDef = pluginRegistry.panes.get(target.paneType);
     if (!paneDef) return;
 
-    if (normalizedPaneId === TICKER_RESEARCH_PANE_ID) {
+    if (target.paneType === TICKER_RESEARCH_PANE_ID) {
       showTickerResearchPane();
       return;
     }
 
-    const existingInstanceId = resolvePaneTarget(normalizedPaneId);
-    if (existingInstanceId && isPaneInLayout(state.config.layout, existingInstanceId)) {
-      pluginRegistry.focusPaneFn(existingInstanceId);
+    if (target.instance && isPaneInLayout(state.config.layout, target.instance.instanceId)) {
+      pluginRegistry.focusPaneFn(target.instance.instanceId);
       return;
     }
 
-    const instance = existingInstanceId
-      ? findPaneInstance(state.config.layout, existingInstanceId)
-      : buildPaneInstance(normalizedPaneId);
+    const instance = target.instance ?? buildPaneInstance(target.paneType);
     if (!instance) {
-      if (isTickerPaneId(paneId)) {
+      if (isTickerPaneId(target.paneType)) {
         notify("Open a ticker or collection context first.");
       }
       return;
@@ -234,7 +236,6 @@ export function useAppPaneRuntime({
     notify,
     placePaneInstance,
     pluginRegistry,
-    resolvePaneTarget,
     showTickerResearchPane,
     state.config.layout,
   ]);
@@ -286,10 +287,12 @@ export function useAppPaneRuntime({
     dataProvider,
     detachedPaneId,
     dispatch,
+    externalPlugins,
     focusVisiblePane,
     isDetachedWindow,
     openPaneSettings,
     openPinnedTicker,
+    persistConfig,
     persistLayout,
     placePaneInstance,
     placePinnedTickerTarget,

package/src/app/pane-runtime/layout-placement.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, test } from "bun:test";
+import type { LayoutConfig } from "../../types/config";
+import { resolvePaneShowTarget } from "./layout-placement";
+
+describe("resolvePaneShowTarget", () => {
+  test("resolves a hidden pane by its exact instance id", () => {
+    const hiddenPane = {
+      instanceId: "news-top:stored",
+      paneId: "news-top",
+      binding: { kind: "none" as const },
+      placementMemory: {
+        floating: { x: 12, y: 4, width: 90, height: 30 },
+      },
+    };
+    const layout: LayoutConfig = {
+      dockRoot: null,
+      instances: [hiddenPane],
+      floating: [],
+      detached: [],
+    };
+
+    expect(resolvePaneShowTarget(layout, hiddenPane.instanceId)).toEqual({
+      paneType: "news-top",
+      instance: hiddenPane,
+    });
+  });
+});

package/src/app/pane-runtime/layout-placement.ts

@@ -28,6 +28,19 @@ export function resolvePaneTarget(layout: LayoutConfig, paneId: string): string
     ?? null;
 }
 
+/** Resolve an instance id before looking up its registered pane type. */
+export function resolvePaneShowTarget(
+  layout: LayoutConfig,
+  paneId: string,
+): { paneType: string; instance: PaneInstanceConfig | null } {
+  const instanceId = resolvePaneTarget(layout, paneId);
+  const instance = instanceId ? findPaneInstance(layout, instanceId) ?? null : null;
+  return {
+    paneType: normalizePaneId(instance?.paneId ?? paneId),
+    instance,
+  };
+}
+
 export function resolvePanelForPane({
   layout,
   paneId,

package/src/app/pane-runtime/plugin-bindings.ts

@@ -5,6 +5,9 @@ import {
 } from "../../components/command-bar/workflow/ops";
 import type { AppTickerRepositoryPort } from "../../core/app-service-ports";
 import { setLayoutManagerDispatch } from "../../plugins/builtin/layout-manager";
+import { setMarketplaceHost } from "../../plugins/builtin/plugin-marketplace/store";
+import type { InstalledPlugin } from "../../plugins/builtin/plugin-marketplace/model";
+import type { LoadedExternalPlugin } from "../../plugins/loader";
 import { materializeMarketplaceLayout } from "../../layout-marketplace/payload";
 import {
   isPaneInLayout,
@@ -46,10 +49,12 @@ interface BindAppPanePluginRegistryOptions {
   dataProvider: DataProvider;
   detachedPaneId: string | null;
   dispatch: Dispatch<AppAction>;
+  externalPlugins: readonly LoadedExternalPlugin[];
   focusVisiblePane: (paneId: string, layout?: LayoutConfig) => void;
   isDetachedWindow: boolean;
   openPaneSettings: (paneId?: string) => Promise<void>;
   openPinnedTicker: (rawSymbol: string, options?: PinTickerOptions) => Promise<void>;
+  persistConfig: (nextConfig: AppState["config"]) => void;
   persistLayout: (layout: LayoutConfig, options?: { pushHistory?: boolean }) => void;
   placePaneInstance: (
     instance: PaneInstanceConfig,
@@ -76,10 +81,12 @@ export function bindAppPanePluginRegistry({
   dataProvider,
   detachedPaneId,
   dispatch,
+  externalPlugins,
   focusVisiblePane,
   isDetachedWindow,
   openPaneSettings,
   openPinnedTicker,
+  persistConfig,
   persistLayout,
   placePaneInstance,
   placePinnedTickerTarget,
@@ -249,4 +256,59 @@ export function bindAppPanePluginRegistry({
     termHeight: pluginRegistry.getTermSizeFn().height,
     focusedPaneId: state.focusedPaneId,
   }));
+
+  setMarketplaceHost({
+    listInstalled: () => {
+      const disabled = new Set(stateRef.current.config.disabledPlugins ?? []);
+      const externalById = new Map(externalPlugins.map((entry) => [entry.plugin.id, entry]));
+      const installed: InstalledPlugin[] = [];
+
+      for (const plugin of pluginRegistry.allPlugins.values()) {
+        const external = externalById.get(plugin.id);
+        externalById.delete(plugin.id);
+        installed.push({
+          id: plugin.id,
+          name: plugin.name,
+          version: plugin.version,
+          ...(plugin.description ? { description: plugin.description } : {}),
+          toggleable: plugin.toggleable === true,
+          enabled: !disabled.has(plugin.id),
+          source: external ? "external" : "builtin",
+        });
+      }
+
+      // Entries that never registered — a broken import, or a plugin this
+      // renderer cannot run. They are invisible everywhere else, which is
+      // exactly why the marketplace has to show them.
+      for (const entry of externalById.values()) {
+        installed.push({
+          id: entry.plugin.id,
+          name: entry.plugin.name,
+          version: entry.plugin.version ?? "0.0.0",
+          ...(entry.plugin.description ? { description: entry.plugin.description } : {}),
+          toggleable: true,
+          enabled: !disabled.has(entry.plugin.id),
+          source: "external",
+          ...(entry.unsupportedTarget ? { unsupportedTarget: entry.unsupportedTarget } : {}),
+          ...(entry.error ? { loadError: entry.error } : {}),
+        });
+      }
+
+      return installed;
+    },
+    setPluginEnabled: (pluginId, enabled) => {
+      const current = stateRef.current.config;
+      if (!enabled) {
+        for (const paneId of pluginRegistry.getPluginPaneIds(pluginId)) pluginRegistry.hidePane(paneId);
+      }
+      dispatch({ type: "TOGGLE_PLUGIN", pluginId });
+      const disabled = current.disabledPlugins ?? [];
+      persistConfig({
+        ...current,
+        disabledPlugins: enabled
+          ? disabled.filter((entry) => entry !== pluginId)
+          : [...disabled, pluginId],
+      });
+    },
+  });
 }