gloomberb 0.13.1 → 0.13.2

package/src/plugins/builtin/earnings-calls/headless.ts

@@ -0,0 +1,300 @@
+import type {
+  CloudEarningsCallPayload,
+  CloudEarningsTranscriptPayload,
+} from "../../../api-client";
+import type {
+  HeadlessPaneContext,
+  HeadlessPaneDefinition,
+  HeadlessPaneLoadArgs,
+  HeadlessRowsResult,
+} from "../../../types/plugin";
+import {
+  callStatusLabel,
+  isPendingTranscript,
+  loadEarningsCallsWithClient,
+  loadTranscriptWithClient,
+  type EarningsCallsResult,
+} from "./data";
+import {
+  buildTranscriptSegments,
+  findCallForQuarter,
+  sortCallsNewest,
+  type TranscriptSection,
+} from "./model";
+
+const CALL_COLUMNS = [
+  { key: "ticker", header: "Ticker" },
+  { key: "company", header: "Company" },
+  { key: "callAt", header: "Call date" },
+  { key: "fiscalYear", header: "FY", align: "right" as const },
+  { key: "fiscalQuarter", header: "FQ", align: "right" as const },
+  { key: "status", header: "Status" },
+  { key: "durationSeconds", header: "Seconds", align: "right" as const },
+  { key: "wordCount", header: "Words", align: "right" as const },
+  { key: "sentiment", header: "Tone", align: "right" as const },
+];
+
+const TRANSCRIPT_COLUMNS = [
+  { key: "index", header: "#", align: "right" as const },
+  { key: "section", header: "Section" },
+  { key: "startSeconds", header: "Start", align: "right" as const },
+  { key: "speaker", header: "Speaker" },
+  { key: "role", header: "Role" },
+  { key: "isQa", header: "Q&A" },
+  { key: "text", header: "Text" },
+];
+
+export interface EarningsCallsHeadlessDependencies {
+  loadCalls(
+    ticker: string | null,
+    limit: number,
+    context: HeadlessPaneContext,
+  ): Promise<EarningsCallsResult>;
+  loadTranscript(
+    callId: string,
+    context: HeadlessPaneContext,
+  ): Promise<CloudEarningsTranscriptPayload>;
+}
+
+const defaultDependencies: EarningsCallsHeadlessDependencies = {
+  loadCalls: (ticker, limit, context) => loadEarningsCallsWithClient(
+    context.apiClient,
+    ticker,
+    { limit },
+  ),
+  loadTranscript: (callId, context) => loadTranscriptWithClient(context.apiClient, callId),
+};
+
+function callRow(call: CloudEarningsCallPayload) {
+  return {
+    id: call.id,
+    ticker: call.ticker,
+    company: call.companyName,
+    callAt: call.callAt,
+    fiscalYear: call.fiscalYear,
+    fiscalQuarter: call.fiscalQuarter,
+    status: call.hasTranscript ? "transcribed" : callStatusLabel(call) || call.status,
+    durationSeconds: call.durationSeconds,
+    wordCount: call.wordCount,
+    hasTranscript: call.hasTranscript,
+    sentiment: call.sentiment,
+    webcastUrl: call.webcastUrl ?? null,
+  };
+}
+
+function availabilityMatches(call: CloudEarningsCallPayload, availability: string): boolean {
+  if (availability === "all") return true;
+  return availability === "transcribed" ? call.hasTranscript : !call.hasTranscript;
+}
+
+export function projectEarningsCallsHeadless(
+  result: EarningsCallsResult,
+  args: HeadlessPaneLoadArgs,
+): HeadlessRowsResult {
+  const availability = String(args.options.availability ?? "all");
+  const limit = Number(args.options.limit ?? 50);
+  const matching = sortCallsNewest(result.calls)
+    .filter((call) => availabilityMatches(call, availability));
+  const rows = matching.slice(0, limit).map(callRow);
+
+  return {
+    columns: CALL_COLUMNS,
+    rows,
+    errors: result.refreshError ? [result.refreshError] : undefined,
+    metadata: {
+      fetchedAt: result.fetchedAt,
+      stale: result.stale,
+      pending: result.pending ?? false,
+      unknownTicker: result.unknownTicker ?? false,
+      availability,
+      total: matching.length,
+      returned: rows.length,
+      truncated: rows.length < matching.length,
+    },
+  };
+}
+
+function selectedSection(args: HeadlessPaneLoadArgs): TranscriptSection {
+  return String(args.options.section ?? "overview") as TranscriptSection;
+}
+
+function transcriptResult(
+  transcript: CloudEarningsTranscriptPayload,
+  call: CloudEarningsCallPayload,
+  args: HeadlessPaneLoadArgs,
+): HeadlessRowsResult {
+  const section = selectedSection(args);
+  const speaker = String(args.options.speaker ?? "").trim();
+  const search = String(args.options.search ?? "").trim();
+  const offset = Number(args.options.offset ?? 0);
+  const limit = Number(args.options.limit ?? 20);
+  const segments = buildTranscriptSegments(transcript, section, { speaker, search });
+  const rows = segments.slice(offset, offset + limit).map((segment) => ({ ...segment }));
+  const hasMore = offset + rows.length < segments.length;
+
+  return {
+    columns: TRANSCRIPT_COLUMNS,
+    rows,
+    metadata: {
+      callId: call.id,
+      ticker: transcript.ticker,
+      company: transcript.companyName,
+      fiscalYear: transcript.fiscalYear,
+      fiscalQuarter: transcript.fiscalQuarter,
+      callAt: transcript.callAt,
+      durationSeconds: transcript.durationSeconds,
+      wordCount: transcript.wordCount,
+      sentiment: transcript.sentiment,
+      updatedAt: transcript.updatedAt,
+      section,
+      speaker: speaker || null,
+      search: search || null,
+      offset,
+      limit,
+      totalSegments: segments.length,
+      returnedSegments: rows.length,
+      truncated: offset > 0 || hasMore,
+      hasMore,
+      nextOffset: hasMore ? offset + rows.length : null,
+    },
+  };
+}
+
+function transcriptOptions() {
+  return [
+    {
+      key: "section",
+      description: "Transcript section to return.",
+      type: "enum" as const,
+      values: [
+        { value: "overview" },
+        { value: "summary" },
+        { value: "transcript" },
+        { value: "qa", aliases: ["q&a"] },
+        { value: "guidance" },
+        { value: "risks" },
+        { value: "notable" },
+        { value: "analyst-focus", aliases: ["analyst"] },
+        { value: "participants", aliases: ["speakers"] },
+      ],
+      defaultValue: "overview",
+    },
+    {
+      key: "quarter",
+      description: "Fiscal quarter such as latest, FQ2-2026, or FY2026.",
+      type: "string" as const,
+      defaultValue: "latest",
+    },
+    {
+      key: "speaker",
+      description: "Speaker name, role, or role acronym such as CFO.",
+      type: "string" as const,
+      defaultValue: "",
+    },
+    {
+      key: "search",
+      description: "Text to find in transcript turns.",
+      type: "string" as const,
+      defaultValue: "",
+    },
+    {
+      key: "offset",
+      description: "Transcript segment offset for paging.",
+      type: "integer" as const,
+      defaultValue: 0,
+      minimum: 0,
+      maximum: 100_000,
+    },
+    {
+      key: "limit",
+      description: "Maximum transcript segments to return.",
+      type: "integer" as const,
+      defaultValue: 20,
+      minimum: 1,
+      maximum: 200,
+    },
+  ];
+}
+
+export function createEarningsCallsHeadless(
+  dependencies: EarningsCallsHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"rows"> {
+  return {
+    shape: "rows",
+    argument: {
+      kind: "ticker",
+      placeholder: "ticker",
+      description: "Optional company symbol. Omit it to browse all calls.",
+      optional: true,
+    },
+    options: [
+      {
+        key: "availability",
+        description: "Transcript availability to include.",
+        type: "enum",
+        values: [
+          { value: "all" },
+          { value: "transcribed" },
+          { value: "pending" },
+        ],
+        defaultValue: "all",
+      },
+      {
+        key: "limit",
+        description: "Maximum calls to return.",
+        type: "integer",
+        defaultValue: 50,
+        minimum: 1,
+        maximum: 200,
+      },
+    ],
+    columns: CALL_COLUMNS,
+    describe: (args) => args.argument
+      ? `Earnings Calls | ${String(args.argument)}`
+      : "Earnings Calls",
+    async load(args, context) {
+      const ticker = typeof args.argument === "string" ? args.argument : null;
+      return projectEarningsCallsHeadless(
+        await dependencies.loadCalls(ticker, 200, context),
+        args,
+      );
+    },
+  };
+}
+
+export function createEarningsTranscriptHeadless(
+  dependencies: EarningsCallsHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"rows"> {
+  return {
+    shape: "rows",
+    argument: {
+      kind: "ticker",
+      placeholder: "ticker",
+      description: "Company symbol.",
+    },
+    options: transcriptOptions(),
+    columns: TRANSCRIPT_COLUMNS,
+    describe: (args) => (
+      `Earnings Call Transcript | ${String(args.argument)} | ${String(args.options.quarter)}`
+    ),
+    async load(args, context) {
+      const ticker = String(args.argument);
+      const calls = await dependencies.loadCalls(ticker, 200, context);
+      const quarter = String(args.options.quarter ?? "latest");
+      const selected = findCallForQuarter(calls.calls, quarter);
+      if (!selected) {
+        if (calls.unknownTicker) throw new Error(`${ticker} is not a known listed company.`);
+        if (calls.pending) throw new Error(`Earnings call discovery for ${ticker} is still pending.`);
+        throw new Error(`No ${quarter} earnings call found for ${ticker}.`);
+      }
+      const transcript = await dependencies.loadTranscript(selected.id, context);
+      if (isPendingTranscript(transcript)) {
+        throw new Error(`Transcript for ${ticker} ${quarter} is still being produced.`);
+      }
+      return transcriptResult(transcript, selected, args);
+    },
+  };
+}
+
+export const earningsCallsHeadless = createEarningsCallsHeadless();
+export const earningsTranscriptHeadless = createEarningsTranscriptHeadless();

package/src/plugins/builtin/earnings-calls/index.tsx

@@ -2,6 +2,12 @@ import type { PluginModule } from "../plugin-module";
 import { createTickerSurfacePaneTemplate } from "../shared/ticker-surface";
 import { attachEarningsCallsPersistence, resetEarningsCallsPersistence } from "./data";
 import { EarningsCallsPane, EARNINGS_CALLS_PANE_ID } from "./pane";
+import {
+  earningsCallsHeadless,
+  earningsTranscriptHeadless,
+} from "./headless";
+
+export { earningsCallsHeadless, earningsTranscriptHeadless } from "./headless";
 
 const description =
   "Earnings call transcripts with speaker attribution, analyst Q&A, and extracted guidance.";
@@ -54,16 +60,20 @@ export const earningsCallsModule: PluginModule = {
         "qa",
       ],
       shortcut: { prefix: "CALLS" },
+      headless: earningsCallsHeadless,
       createInstance: () => ({ placement: "floating" }),
     },
-    createTickerSurfacePaneTemplate({
-      id: "earnings-call-transcripts-pane",
-      paneId: EARNINGS_CALLS_PANE_ID,
-      label: "Earnings Call Transcripts",
-      description,
-      keywords: ["earnings", "call", "transcript", "ect", "qa", "guidance"],
-      shortcut: "ECT",
-      publicShare: false,
-    }),
+    {
+      ...createTickerSurfacePaneTemplate({
+        id: "earnings-call-transcripts-pane",
+        paneId: EARNINGS_CALLS_PANE_ID,
+        label: "Earnings Call Transcripts",
+        description,
+        keywords: ["earnings", "call", "transcript", "ect", "qa", "guidance"],
+        shortcut: "ECT",
+        publicShare: false,
+      }),
+      headless: earningsTranscriptHeadless,
+    },
   ],
 };

package/src/plugins/builtin/earnings-calls/model.ts

@@ -0,0 +1,238 @@
+import type {
+  CloudEarningsCallPayload,
+  CloudEarningsTranscriptPayload,
+  CloudTranscriptTurnPayload,
+} from "../../../api-client";
+
+export type TranscriptSection =
+  | "overview"
+  | "summary"
+  | "transcript"
+  | "qa"
+  | "guidance"
+  | "risks"
+  | "notable"
+  | "analyst-focus"
+  | "participants";
+
+export interface TranscriptFilter {
+  section: "transcript" | "qa";
+  speaker?: string;
+  search?: string;
+}
+
+export interface TranscriptSegment {
+  index: number;
+  section: string;
+  startSeconds: number | null;
+  speaker: string | null;
+  role: string | null;
+  company: string | null;
+  isQa: boolean;
+  text: string;
+}
+
+const MAX_SEGMENT_CHARS = 1_600;
+
+function roleAcronym(value: string): string {
+  return value
+    .split(/\s+/)
+    .filter((word) => /^[A-Za-z]/.test(word))
+    .map((word) => word[0])
+    .join("");
+}
+
+function turnSpeakerText(turn: CloudTranscriptTurnPayload): string {
+  const role = turn.role ?? "";
+  return [
+    turn.speaker,
+    role,
+    roleAcronym(role),
+    turn.company ?? "",
+  ].join(" ").toLowerCase();
+}
+
+function turnSearchText(turn: CloudTranscriptTurnPayload): string {
+  return `${turnSpeakerText(turn)} ${turn.text}`.toLowerCase();
+}
+
+export function filterTranscriptTurns(
+  turns: CloudTranscriptTurnPayload[],
+  filter: TranscriptFilter,
+): CloudTranscriptTurnPayload[] {
+  const speaker = filter.speaker?.trim().toLowerCase() ?? "";
+  const search = filter.search?.trim().toLowerCase() ?? "";
+  return turns.filter((turn) => {
+    if (filter.section === "qa" && !turn.isQa) return false;
+    if (speaker && !turnSpeakerText(turn).includes(speaker)) return false;
+    return !search || turnSearchText(turn).includes(search);
+  });
+}
+
+function chunks(text: string): string[] {
+  const normalized = text.trim();
+  if (!normalized) return [];
+  const result: string[] = [];
+  let remaining = normalized;
+  while (remaining.length > MAX_SEGMENT_CHARS) {
+    const breakAt = Math.max(
+      remaining.lastIndexOf(" ", MAX_SEGMENT_CHARS),
+      remaining.lastIndexOf("\n", MAX_SEGMENT_CHARS),
+    );
+    const cut = breakAt > MAX_SEGMENT_CHARS / 2 ? breakAt : MAX_SEGMENT_CHARS;
+    result.push(remaining.slice(0, cut).trim());
+    remaining = remaining.slice(cut).trim();
+  }
+  if (remaining) result.push(remaining);
+  return result;
+}
+
+function summaryFields(
+  transcript: CloudEarningsTranscriptPayload,
+  section: TranscriptSection,
+): Array<{ section: string; text: string }> {
+  const fields = [
+    { section: "summary", text: transcript.summary ?? "" },
+    { section: "notable", text: transcript.notable ?? "" },
+    { section: "analyst-focus", text: transcript.analystFocus ?? "" },
+    { section: "guidance", text: transcript.guidance ?? "" },
+    { section: "risks", text: transcript.riskFactors ?? "" },
+  ];
+  return section === "overview"
+    ? fields.filter((field) => field.text.trim())
+    : fields.filter((field) => field.section === section && field.text.trim());
+}
+
+export function buildTranscriptSegments(
+  transcript: CloudEarningsTranscriptPayload,
+  section: TranscriptSection,
+  options: { speaker?: string; search?: string } = {},
+): TranscriptSegment[] {
+  const withoutIndexes: Array<Omit<TranscriptSegment, "index">> = [];
+
+  if (section === "transcript" || section === "qa") {
+    const turns = filterTranscriptTurns(transcript.turns ?? [], {
+      section,
+      speaker: options.speaker,
+      search: options.search,
+    });
+    for (const turn of turns) {
+      for (const text of chunks(turn.text)) {
+        withoutIndexes.push({
+          section,
+          startSeconds: turn.startSeconds,
+          speaker: turn.speaker,
+          role: turn.role ?? null,
+          company: turn.company ?? null,
+          isQa: turn.isQa,
+          text,
+        });
+      }
+    }
+    if (withoutIndexes.length === 0 && section === "transcript" && transcript.fullText.trim()) {
+      const search = options.search?.trim().toLowerCase() ?? "";
+      if (!options.speaker?.trim() && (!search || transcript.fullText.toLowerCase().includes(search))) {
+        for (const paragraph of transcript.fullText.split(/\n{2,}/)) {
+          for (const text of chunks(paragraph)) {
+            withoutIndexes.push({
+              section,
+              startSeconds: null,
+              speaker: null,
+              role: null,
+              company: null,
+              isQa: false,
+              text,
+            });
+          }
+        }
+      }
+    }
+  } else if (section === "participants") {
+    const speaker = options.speaker?.trim().toLowerCase() ?? "";
+    for (const participant of transcript.participants) {
+      const haystack = [
+        participant.name,
+        participant.role ?? "",
+        roleAcronym(participant.role ?? ""),
+        participant.company ?? "",
+      ].join(" ").toLowerCase();
+      if (speaker && !haystack.includes(speaker)) continue;
+      withoutIndexes.push({
+        section,
+        startSeconds: null,
+        speaker: participant.name,
+        role: participant.role ?? null,
+        company: participant.company ?? null,
+        isQa: false,
+        text: [participant.role, participant.company].filter(Boolean).join(", "),
+      });
+    }
+  } else {
+    for (const field of summaryFields(transcript, section)) {
+      for (const text of chunks(field.text)) {
+        withoutIndexes.push({
+          section: field.section,
+          startSeconds: null,
+          speaker: null,
+          role: null,
+          company: null,
+          isQa: false,
+          text,
+        });
+      }
+    }
+  }
+
+  return withoutIndexes.map((segment, index) => ({ index, ...segment }));
+}
+
+function callTime(call: CloudEarningsCallPayload): number {
+  const timestamp = call.callAt ? Date.parse(call.callAt) : Number.NaN;
+  if (Number.isFinite(timestamp)) return timestamp;
+  return (call.fiscalYear ?? 0) * 10 + (call.fiscalQuarter ?? 0);
+}
+
+export function sortCallsNewest(calls: CloudEarningsCallPayload[]): CloudEarningsCallPayload[] {
+  return [...calls].sort((left, right) => callTime(right) - callTime(left));
+}
+
+function sameYear(actual: number | null, requested: number | null): boolean {
+  if (requested == null) return true;
+  if (actual == null) return false;
+  return requested < 100 ? actual % 100 === requested : actual === requested;
+}
+
+export function findCallForQuarter(
+  calls: CloudEarningsCallPayload[],
+  requestedQuarter: string,
+): CloudEarningsCallPayload | null {
+  const sorted = sortCallsNewest(calls);
+  const token = requestedQuarter.trim().toUpperCase().replace(/[\s_-]+/g, "");
+  if (!token || token === "LATEST") return sorted[0] ?? null;
+
+  const quarterFirst = token.match(/^(?:F?Q)?([1-4])(?:\/?(\d{2}|\d{4}))?$/);
+  if (quarterFirst) {
+    const quarter = Number(quarterFirst[1]);
+    const year = quarterFirst[2] ? Number(quarterFirst[2]) : null;
+    return sorted.find((call) => (
+      call.fiscalQuarter === quarter && sameYear(call.fiscalYear, year)
+    )) ?? null;
+  }
+
+  const yearFirst = token.match(/^(\d{2}|\d{4})(?:\/?F?Q)([1-4])$/);
+  if (yearFirst) {
+    const year = Number(yearFirst[1]);
+    const quarter = Number(yearFirst[2]);
+    return sorted.find((call) => (
+      call.fiscalQuarter === quarter && sameYear(call.fiscalYear, year)
+    )) ?? null;
+  }
+
+  const fiscalYear = token.match(/^(?:FY)?(\d{2}|\d{4})$/);
+  if (fiscalYear) {
+    const year = Number(fiscalYear[1]);
+    return sorted.find((call) => sameYear(call.fiscalYear, year)) ?? null;
+  }
+
+  return null;
+}

package/src/plugins/builtin/earnings-calls/transcript-view.tsx

@@ -18,6 +18,7 @@ import type {
 } from "../../../api-client";
 import { formatCallDate, formatDuration, formatSentiment, formatTimestamp } from "./format";
 import { splitFigures, splitSentences } from "./prose";
+import { filterTranscriptTurns } from "./model";
 
 export type ReaderTab = "summary" | "transcript" | "qa";
 
@@ -200,15 +201,13 @@ export function TranscriptView({
   const { nativePaneChrome } = useUiCapabilities();
   const isNative = nativePaneChrome === true;
 
-  const turns = useMemo(() => {
-    const all = transcript?.turns ?? [];
-    const scoped = tab === "qa" ? all.filter((turn) => turn.isQa) : all;
-    const needle = (query ?? "").trim().toLowerCase();
-    if (!needle) return scoped;
-    return scoped.filter((turn) =>
-      `${turn.speaker} ${turn.company ?? ""} ${turn.text}`.toLowerCase().includes(needle),
-    );
-  }, [transcript, tab, query]);
+  const turns = useMemo(() => filterTranscriptTurns(
+    transcript?.turns ?? [],
+    {
+      section: tab === "qa" ? "qa" : "transcript",
+      search: query,
+    },
+  ), [transcript, tab, query]);
 
   if (loading && !transcript) {
     return (

package/src/plugins/builtin/holders/client.ts

@@ -0,0 +1,29 @@
+import type { DataProvider, MarketDataRequestContext } from "../../../types/data-provider";
+import type { HolderData } from "../../../types/financials";
+
+export async function loadHolderData(
+  provider: DataProvider,
+  symbol: string,
+  exchange = "",
+  context?: MarketDataRequestContext,
+): Promise<HolderData> {
+  if (!provider.getHolders) throw new Error("Holder data unavailable");
+  return provider.getHolders(symbol, exchange, context);
+}
+
+export async function loadHolderSnapshot(
+  provider: DataProvider,
+  symbol: string,
+  exchange = "",
+): Promise<{ data: HolderData; marketCap?: number }> {
+  const [data, financials] = await Promise.all([
+    loadHolderData(provider, symbol, exchange),
+    provider.getTickerFinancials(symbol, exchange).catch(() => null),
+  ]);
+  const quoteMarketCap = financials?.quote?.marketCap;
+  const marketCap = financials?.quote?.currency && data.currency
+    && financials.quote.currency !== data.currency
+    ? undefined
+    : quoteMarketCap;
+  return { data, marketCap };
+}

package/src/plugins/builtin/holders/headless.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, test } from "bun:test";
+import { createTestDataProvider } from "../../../test-support/data-provider";
+import { createDefaultConfig } from "../../../types/config";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
+import { createHoldersHeadless } from "./headless";
+
+function context(): HeadlessPaneContext {
+  return {
+    marketData: createTestDataProvider(),
+    apiClient: {} as HeadlessPaneContext["apiClient"],
+    config: createDefaultConfig("/tmp/gloomberb-headless-holders"),
+    signal: new AbortController().signal,
+  };
+}
+
+function args(overrides: Partial<HeadlessPaneLoadArgs["options"]> = {}): HeadlessPaneLoadArgs {
+  return {
+    rawArgument: "NVDA",
+    argument: "NVDA",
+    symbols: ["NVDA"],
+    options: { sort: "value", order: "desc", limit: 25, ...overrides },
+  };
+}
+
+describe("holders headless model", () => {
+  test("projects holder values and applies sorting and limits", async () => {
+    const headless = createHoldersHeadless({
+      loadSnapshot: async () => ({
+        marketCap: 1_000,
+        data: {
+          symbol: "NVDA",
+          currency: "USD",
+          asOf: "2026-06-30",
+          holders: [
+            { ownerType: "institution", name: "Small Fund", value: 100, shares: 4, reportDate: "2026-06-30" },
+            { ownerType: "fund", name: "Large Fund", value: 300, shares: 8, changeShares: 2, reportDate: "2026-06-30" },
+          ],
+        },
+      }),
+    });
+
+    const byValue = await headless.load(args({ limit: 1 }), context());
+    expect(byValue.rows).toEqual([{
+      name: "Large Fund",
+      ownerType: "fund",
+      value: 300,
+      shares: 8,
+      changeShares: 2,
+      changePercent: null,
+      percentHeld: 0.3,
+      reportDate: "2026-06-30",
+      currency: "USD",
+    }]);
+
+    const byName = await headless.load(args({ sort: "holder", order: "asc", limit: 2 }), context());
+    expect(byName.rows.map((row) => row.name)).toEqual(["Large Fund", "Small Fund"]);
+  });
+});