gloomberb 0.9.9 → 0.10.0

package/src/cli/pane-functions/data.ts

@@ -1,9 +1,13 @@
-import type { TickerFinancials } from "../../types/financials";
+import type { PricePoint, TickerFinancials } from "../../types/financials";
 import type { TickerRecord } from "../../types/ticker";
-import { LEGACY_TICKER_DETAIL_PANE_ID } from "../../types/config";
+import type { TimeRange } from "../../components/chart/core/types";
+import { subtractTimeRange } from "../../components/chart/core/date-window";
+import { CHART_COMPOSER_PANE_ID, LEGACY_TICKER_DETAIL_PANE_ID } from "../../types/config";
+import { parseChartSpec } from "../../plugins/builtin/chart-composer/chart-spec";
 import { normalizeTickerInput } from "../../tickers/search";
 import type { MarketContext } from "../types";
 import { cleanTickerInput } from "./options";
+import { parsePublicTickerKey, publicTickerKey } from "../../utils/exchanges";
 import type { ResolvedPaneFunction } from "./resolver";
 
 const SHOT_PRICE_HISTORY_RANGE = "5Y" as const;
@@ -13,12 +17,18 @@ const FINANCIAL_ANALYSIS_TEMPLATE_ID = "financial-analysis-pane";
 export async function fetchTickerFinancials(
   context: MarketContext,
   symbol: string,
-): Promise<{ tickerFile: TickerRecord | null; financials: TickerFinancials }> {
+): Promise<{
+  tickerFile: TickerRecord | null;
+  financials: TickerFinancials;
+  instrument: { symbol: string; exchange?: string };
+}> {
   const normalized = cleanTickerInput(symbol);
-  const tickerFile = await context.store.loadTicker(normalized);
-  const exchange = tickerFile?.metadata.exchange ?? "";
-  const financials = await context.dataProvider.getTickerFinancials(normalized, exchange);
-  return { tickerFile, financials };
+  const instrument = parsePublicTickerKey(normalized);
+  const tickerFile = await context.store.loadTicker(normalized)
+    ?? (instrument.symbol !== normalized ? await context.store.loadTicker(instrument.symbol) : null);
+  const exchange = instrument.exchange ?? tickerFile?.metadata.exchange ?? "";
+  const financials = await context.dataProvider.getTickerFinancials(instrument.symbol, exchange);
+  return { tickerFile, financials, instrument: { symbol: instrument.symbol, ...(exchange ? { exchange } : {}) } };
 }
 
 export async function withShotPriceHistory(
@@ -28,12 +38,14 @@ export async function withShotPriceHistory(
   financials: TickerFinancials,
 ): Promise<TickerFinancials> {
   if (financials.priceHistory?.length) return financials;
-  const exchange = tickerFile?.metadata.exchange
+  const instrument = parsePublicTickerKey(symbol);
+  const exchange = instrument.exchange
+    ?? tickerFile?.metadata.exchange
     ?? financials.quote?.listingExchangeName
     ?? financials.quote?.exchangeName
     ?? "";
   try {
-    const priceHistory = await context.dataProvider.getPriceHistory(symbol, exchange, SHOT_PRICE_HISTORY_RANGE);
+    const priceHistory = await context.dataProvider.getPriceHistory(instrument.symbol, exchange, SHOT_PRICE_HISTORY_RANGE);
     return priceHistory.length > 0 ? { ...financials, priceHistory } : financials;
   } catch {
     return financials;
@@ -54,13 +66,14 @@ export function isFinancialAnalysisFunction(resolved: ResolvedPaneFunction): boo
 }
 
 export function createFallbackTicker(symbol: string, financials: TickerFinancials | null, context: MarketContext): TickerRecord {
+  const instrument = parsePublicTickerKey(symbol);
   const quote = financials?.quote;
   return {
     metadata: {
-      ticker: symbol,
-      exchange: quote?.listingExchangeName ?? quote?.exchangeName ?? "",
+      ticker: instrument.symbol,
+      exchange: instrument.exchange ?? quote?.listingExchangeName ?? quote?.exchangeName ?? "",
       currency: quote?.currency ?? context.config.baseCurrency,
-      name: quote?.name ?? symbol,
+      name: quote?.name ?? instrument.symbol,
       portfolios: [],
       watchlists: [],
       positions: [],
@@ -71,8 +84,37 @@ export function createFallbackTicker(symbol: string, financials: TickerFinancial
 }
 
 export function collectShotSymbols(resolved: ResolvedPaneFunction, rawArg: string): string[] {
-  const symbols = resolved.createOptions?.symbols?.length
+  if (resolved.pane.id === CHART_COMPOSER_PANE_ID) {
+    const spec = parseChartSpec(resolved.instance.settings?.chartSpec);
+    if (spec) {
+      return [...new Set(spec.series.flatMap((series) => (
+        series.source.kind === "security"
+          ? [publicTickerKey(series.source.instrument.symbol, series.source.instrument.exchange)]
+          : []
+      )).filter(Boolean))];
+    }
+  }
+  let symbols = resolved.createOptions?.symbols?.length
     ? resolved.createOptions.symbols
     : [resolved.createOptions?.symbol ?? normalizeTickerInput(null, cleanTickerInput(rawArg))].filter((symbol): symbol is string => !!symbol);
+  if (resolved.capability.id === "security-relationship" && symbols.length === 1) {
+    symbols = [...symbols, "SPY"];
+  }
   return [...new Set(symbols.map(cleanTickerInput).filter(Boolean))];
 }
+
+export function clipPriceHistoryToRange(points: PricePoint[], range: TimeRange): PricePoint[] {
+  if (range === "ALL" || points.length === 0) return points;
+  const dated = points.flatMap((point) => {
+    const date = point.date instanceof Date ? point.date : new Date(point.date);
+    return Number.isFinite(date.getTime()) ? [{ point, date }] : [];
+  });
+  const end = dated.reduce<Date | null>((latest, entry) => (
+    !latest || entry.date.getTime() > latest.getTime() ? entry.date : latest
+  ), null);
+  if (!end) return [];
+  const start = subtractTimeRange(end, range);
+  return dated
+    .filter(({ date }) => date.getTime() >= start.getTime() && date.getTime() <= end.getTime())
+    .map(({ point }) => point);
+}

package/src/cli/pane-functions/discovery.ts

@@ -1,4 +1,11 @@
-import type { GloomPlugin, PaneDef, PaneTemplateDef } from "../../types/plugin";
+import type {
+  GloomPlugin,
+  GloomPluginContext,
+  PaneDef,
+  PaneTemplateDef,
+  PluginPersistence,
+} from "../../types/plugin";
+import type { PersistedResourceValue } from "../../types/persistence";
 import type { MarketContext } from "../types";
 import type { PaneFunctionCatalog } from "./catalog";
 
@@ -6,9 +13,11 @@ export async function createPaneCatalog(context: MarketContext, plugins: GloomPl
   const panes = new Map<string, PaneDef>();
   const paneTemplates = new Map<string, PaneTemplateDef>();
   const setupPlugins: GloomPlugin[] = [];
-  const fakePersistence = createFakePluginPersistence();
+  const fakePersistence = createDiscoveryPluginPersistence();
   // Collect setup-registered panes without booting the real plugin runtime or polling engines.
-  const fakeContext = {
+  // Keep this object exhaustively typed so additions to GloomPluginContext fail at
+  // compile time instead of crashing `gloomberb catalog` at runtime.
+  const discoveryContext: GloomPluginContext = {
     registerPane: (pane: PaneDef) => panes.set(pane.id, pane),
     registerPaneTemplate: (template: PaneTemplateDef) => paneTemplates.set(template.id, template),
     registerCommand: () => {},
@@ -19,6 +28,8 @@ export async function createPaneCatalog(context: MarketContext, plugins: GloomPl
     registerShortcut: () => {},
     registerTickerAction: () => {},
     registerContextMenuProvider: () => {},
+    registerSyncContributor: () => () => {},
+    registerSyncTransport: () => () => {},
     watchNewsQuery: () => () => {},
     getData: () => null,
     getTicker: () => null,
@@ -79,7 +90,7 @@ export async function createPaneCatalog(context: MarketContext, plugins: GloomPl
     for (const template of plugin.paneTemplates ?? []) paneTemplates.set(template.id, template);
     if (plugin.setup) {
       setupPlugins.push(plugin);
-      await plugin.setup(fakeContext as never);
+      await plugin.setup(discoveryContext);
     }
   }
 
@@ -94,15 +105,31 @@ export async function createPaneCatalog(context: MarketContext, plugins: GloomPl
   };
 }
 
-function createFakePluginPersistence() {
-  const resources = new Map<string, unknown>();
+function createDiscoveryPluginPersistence(): PluginPersistence {
+  const resources = new Map<string, PersistedResourceValue<unknown>>();
   return {
     getState: () => null,
     setState: () => {},
     deleteState: () => {},
-    getResource: (kind: string, key: string) => resources.get(`${kind}:${key}`) ?? null,
-    setResource: (kind: string, key: string, value: unknown) => {
-      const entry = { value, updatedAt: Date.now(), expiresAt: null, provenance: null };
+    getResource: <T = unknown>(kind: string, key: string) => (
+      resources.get(`${kind}:${key}`) as PersistedResourceValue<T> | undefined
+    ) ?? null,
+    setResource: <T = unknown>(
+      kind: string,
+      key: string,
+      value: T,
+      options: Parameters<PluginPersistence["setResource"]>[3],
+    ) => {
+      const fetchedAt = Date.now();
+      const entry: PersistedResourceValue<T> = {
+        value,
+        fetchedAt,
+        staleAt: fetchedAt + options.cachePolicy.staleMs,
+        expiresAt: fetchedAt + options.cachePolicy.expireMs,
+        sourceKey: options.sourceKey ?? "",
+        schemaVersion: options.schemaVersion ?? 1,
+        provenance: options.provenance ?? null,
+      };
       resources.set(`${kind}:${key}`, entry);
       return entry;
     },

package/src/cli/pane-functions/index.test.ts

@@ -9,8 +9,27 @@ const {
   optionPaneState,
   filterPaneCatalogEntries,
   renderPaneCatalogReport,
+  getPaneFunctionCapability,
+  normalizeCapabilityOptions,
+  capabilityPluginState,
 } = paneFunctionTestInternals;
 
+const dummyPane = {
+  id: "test-pane",
+  name: "Test",
+  component: () => null,
+  defaultPosition: "right" as const,
+};
+
+function capabilityFor(templateId: string) {
+  return getPaneFunctionCapability({
+    id: templateId,
+    paneId: dummyPane.id,
+    label: "Test",
+    description: "Test",
+  }, dummyPane);
+}
+
 describe("pane function CLI args", () => {
   test("parses target, argument, output, size, and pane options", () => {
     const parsed = parsePaneFunctionArgs([
@@ -31,6 +50,7 @@ describe("pane function CLI args", () => {
     expect(parsed.outputPath).toBe("/tmp/fa-nvda.png");
     expect(parsed.width).toBe(900);
     expect(parsed.height).toBe(700);
+    expect(parsed.requireBotSafe).toBe(false);
     expect(parsed.options).toEqual({
       period: "quarterly",
       statement: "balance",
@@ -75,6 +95,12 @@ describe("pane function CLI args", () => {
     expect(parsePaneCatalogArgs(["chart", "price", "--limit", "3"])).toEqual({
       query: "chart price",
       limit: 3,
+      botSafeOnly: false,
+    });
+    expect(parsePaneCatalogArgs(["cash", "flow", "--bot-safe"])).toEqual({
+      query: "cash flow",
+      limit: 25,
+      botSafeOnly: true,
     });
   });
 
@@ -92,6 +118,7 @@ describe("pane function CLI args", () => {
         argPlaceholder: "ticker",
         keywords: ["gp", "graph", "price", "chart"],
         defaultSettings: { lockedTabId: "chart", chartRangePreset: "5Y" },
+        capability: capabilityFor("graph-price-pane"),
       },
       {
         token: "FA",
@@ -105,10 +132,86 @@ describe("pane function CLI args", () => {
         argPlaceholder: "ticker",
         keywords: ["fa", "financial", "analysis", "statements"],
         defaultSettings: { lockedTabId: "financials" },
+        capability: capabilityFor("financial-analysis-pane"),
       },
     ], "price chart");
 
     expect(matches.map((entry) => entry.token)).toEqual(["GP"]);
-    expect(renderPaneCatalogReport(matches, { query: "price chart", limit: 10 })).toContain("gloomberb shot GP <ticker>");
+    expect(renderPaneCatalogReport(matches, { query: "price chart", limit: 10, botSafeOnly: false })).toContain("gloomberb shot GP <ticker>");
+  });
+
+  test("finds the semantic financial comparison capability from natural wording", () => {
+    const matches = filterPaneCatalogEntries([
+      {
+        token: "GF",
+        label: "Fundamental Graph",
+        description: "Graph statement metrics for one or more tickers.",
+        paneId: "fundamental-graph",
+        paneName: "Fundamental Graph",
+        templateId: "fundamental-graph-pane",
+        shortcut: "GF",
+        argKind: "ticker-list",
+        argPlaceholder: "tickers",
+        keywords: ["fundamental", "graph", "financials", "statements"],
+        defaultSettings: {},
+        capability: capabilityFor("fundamental-graph-pane"),
+      },
+      {
+        token: "CMP",
+        label: "Comparison Chart",
+        description: "Compare stock prices.",
+        paneId: "comparison-chart",
+        paneName: "Compare",
+        templateId: "comparison-chart-pane",
+        shortcut: "CMP",
+        argKind: "ticker-list",
+        argPlaceholder: "tickers",
+        keywords: ["compare", "price"],
+        defaultSettings: {},
+        capability: capabilityFor("comparison-chart-pane"),
+      },
+    ], "cash flow comparison");
+
+    expect(matches.map(({ token }) => token)).toEqual(["GF", "CMP"]);
+  });
+
+  test("normalizes GF options without creating retired plugin state", () => {
+    const capability = capabilityFor("fundamental-graph-pane");
+    const options = normalizeCapabilityOptions(capability, {
+      metric: "operating cash flow",
+      period: "yearly",
+    });
+
+    expect(options).toEqual({
+      metric: "operatingCashFlow",
+      period: "annual",
+    });
+    expect(capabilityPluginState(capability, options)).toEqual({});
+  });
+
+  test("exposes custom G as a bot-safe mixed-series capability", () => {
+    const capability = capabilityFor("chart-composer-pane");
+
+    expect(capability).toMatchObject({
+      id: "chart-composer",
+      botSafe: true,
+      tickerCardinality: "none",
+      reportReadiness: "ready",
+      screenshotReadiness: "ready",
+    });
+    expect(normalizeCapabilityOptions(capability, {
+      range: "five years",
+      resolution: "1d",
+    })).toEqual({
+      rangePreset: "5Y",
+      chartResolution: "1d",
+    });
+  });
+
+  test("rejects financial statement options on a price comparison", () => {
+    const capability = capabilityFor("comparison-chart-pane");
+    expect(() => normalizeCapabilityOptions(capability, {
+      tab: "cashflow",
+    })).toThrow("price-comparison does not support --tab");
   });
 });

package/src/cli/pane-functions/index.ts

@@ -21,6 +21,11 @@ import { defaultScreenshotPath, renderDesktopShot } from "./screenshot";
 import {
   buildPaneCatalogEntries,
 } from "./catalog";
+import {
+  capabilityPluginState,
+  getPaneFunctionCapability,
+  normalizeCapabilityOptions,
+} from "./capabilities";
 
 async function withPaneRuntime<T>(
   ctx: CliCommandContext,
@@ -47,8 +52,26 @@ async function withPaneRuntime<T>(
 export async function runPaneFunction(args: string[], ctx: CliCommandContext) {
   await runPaneCliCommand(ctx, async () => {
     await withPaneRuntime(ctx, args, async ({ parsed, context, resolved }) => {
-      const report = await buildFunctionReport(resolved, context, parsed.arg, parsed.options);
-      console.log(report);
+      if (parsed.requireBotSafe && (
+        !resolved.capability.botSafe || resolved.capability.reportReadiness !== "ready"
+      )) {
+        throw new Error(
+          `${resolved.token} is not a verified bot-safe report capability. `
+          + `Use "gloomberb catalog ${resolved.token}" to inspect readiness.`,
+        );
+      }
+      const report = await buildFunctionReport(resolved, context, parsed.arg);
+      if (parsed.requireBotSafe && (report.data.empty || !report.data.complete)) {
+        const unavailable = report.data.unavailableSymbols.length > 0
+          ? ` Missing data for ${report.data.unavailableSymbols.join(", ")}.`
+          : "";
+        throw new Error(
+          `${resolved.token} did not produce a complete bot-safe report.${unavailable}`,
+        );
+      }
+      ctx.printResult({ data: report.data }, {
+        text: () => report.text,
+      });
     });
   });
 }
@@ -56,10 +79,18 @@ export async function runPaneFunction(args: string[], ctx: CliCommandContext) {
 export async function runPaneScreenshot(args: string[], ctx: CliCommandContext) {
   await runPaneCliCommand(ctx, async () => {
     await withPaneRuntime(ctx, args, async ({ parsed, context, resolved }) => {
+      if (parsed.requireBotSafe && (
+        !resolved.capability.botSafe || resolved.capability.screenshotReadiness !== "ready"
+      )) {
+        throw new Error(
+          `${resolved.token} is not a verified bot-safe screenshot capability. `
+          + `Use "gloomberb catalog ${resolved.token}" to inspect readiness.`,
+        );
+      }
       const outputPath = parsed.outputPath
         ? resolve(process.cwd(), ensurePngExtension(parsed.outputPath))
         : defaultScreenshotPath(resolved, parsed.arg);
-      await renderDesktopShot({
+      const result = await renderDesktopShot({
         resolved,
         context,
         rawArg: parsed.arg,
@@ -68,7 +99,29 @@ export async function runPaneScreenshot(args: string[], ctx: CliCommandContext)
         height: parsed.height,
         options: parsed.options,
       });
-      console.log(`Saved screenshot to ${outputPath}`);
+      if (parsed.requireBotSafe && !result.usable) {
+        throw new Error(
+          `${resolved.token} did not produce a usable bot-safe screenshot: `
+          + `${result.empty ? "empty render" : ""}${result.empty && !result.complete ? ", " : ""}`
+          + `${!result.complete ? `missing data for ${result.unavailableSymbols.join(", ")}` : ""}`
+          + `${result.semanticMismatch ? `${(result.empty || !result.complete) ? ", " : ""}rendered content did not match the requested capability` : ""}`,
+        );
+      }
+      ctx.printResult({ data: result }, {
+        text: (data) => [
+          `Saved screenshot to ${data.outputPath}`,
+          `Result: ${data.rowCount} semantic rows; empty=${data.empty}; complete=${data.complete}; mismatch=${data.semanticMismatch}; usable=${data.usable}`,
+          ...(data.unavailableSymbols.length > 0
+            ? [`Unavailable symbols: ${data.unavailableSymbols.join(", ")}`]
+            : []),
+          ...(data.render.emptyStateMarkers.length > 0
+            ? [`Empty markers: ${data.render.emptyStateMarkers.join(", ")}`]
+            : []),
+          ...(data.render.missingExpectedText.length > 0
+            ? [`Missing expected text: ${data.render.missingExpectedText.join(", ")}`]
+            : []),
+        ].join("\n"),
+      });
     });
   });
 }
@@ -84,7 +137,10 @@ export async function runPaneCatalog(args: string[], ctx: CliCommandContext) {
     const registry = await createPaneCatalog(context, ctx.plugins);
     try {
       const entries = await buildPaneCatalogEntries(registry, context);
-      const filtered = filterPaneCatalogEntries(entries, parsed.query);
+      const botSafeEntries = effectiveParsed.botSafeOnly
+        ? entries.filter((entry) => entry.capability.botSafe)
+        : entries;
+      const filtered = filterPaneCatalogEntries(botSafeEntries, parsed.query);
       if (ctx.cliOptions.format === "text") {
         console.log(renderPaneCatalogReport(filtered, effectiveParsed));
       } else {
@@ -118,4 +174,7 @@ export const paneFunctionTestInternals = {
   optionPaneState,
   filterPaneCatalogEntries,
   renderPaneCatalogReport,
+  getPaneFunctionCapability,
+  normalizeCapabilityOptions,
+  capabilityPluginState,
 };

package/src/cli/pane-functions/options.ts

@@ -6,6 +6,7 @@ import {
   resolveFinancialPeriodOption,
 } from "../../plugins/builtin/ticker-detail/financials/model";
 import type { PaneRuntimeState } from "../../core/state/app/state";
+import type { NormalizedPaneFunctionOptions } from "./capabilities";
 
 const DEFAULT_SHOT_WIDTH = 1280;
 const DEFAULT_SHOT_HEIGHT = 720;
@@ -22,11 +23,13 @@ export interface ParsedPaneFunctionArgs {
   outputPath: string | null;
   width: number;
   height: number;
+  requireBotSafe: boolean;
 }
 
 export interface ParsedPaneCatalogArgs {
   query: string;
   limit: number;
+  botSafeOnly: boolean;
 }
 
 function normalizeOptionKey(value: string): string {
@@ -59,6 +62,7 @@ export function parsePaneFunctionArgs(args: string[]): ParsedPaneFunctionArgs {
   let outputPath: string | null = null;
   let width = DEFAULT_SHOT_WIDTH;
   let height = DEFAULT_SHOT_HEIGHT;
+  let requireBotSafe = false;
 
   for (let index = 0; index < args.length; index += 1) {
     const token = args[index]!;
@@ -80,7 +84,9 @@ export function parsePaneFunctionArgs(args: string[]): ParsedPaneFunctionArgs {
     const nextValue = next && !next.startsWith("--") ? args[++index] : true;
     const value: string | true = inlineValue ?? nextValue ?? true;
     const normalizedKey = normalizeOptionKey(key);
-    if (normalizedKey === "output" || normalizedKey === "out" || normalizedKey === "o") {
+    if (normalizedKey === "requireBotSafe" || normalizedKey === "botSafe") {
+      requireBotSafe = value === true || String(value).toLowerCase() === "true";
+    } else if (normalizedKey === "output" || normalizedKey === "out" || normalizedKey === "o") {
       outputPath = value === true ? null : value;
     } else if (normalizedKey === "width" && value !== true) {
       const parsedWidth = Number(value);
@@ -101,12 +107,13 @@ export function parsePaneFunctionArgs(args: string[]): ParsedPaneFunctionArgs {
 
   const target = positionals[0]?.trim() ?? "";
   const arg = positionals.slice(1).join(" ").trim();
-  return { target, arg, options, outputPath, width, height };
+  return { target, arg, options, outputPath, width, height, requireBotSafe };
 }
 
 export function parsePaneCatalogArgs(args: string[]): ParsedPaneCatalogArgs {
   const queryParts: string[] = [];
   let limit = DEFAULT_CATALOG_LIMIT;
+  let botSafeOnly = false;
 
   for (let index = 0; index < args.length; index += 1) {
     const token = args[index]!;
@@ -120,6 +127,11 @@ export function parsePaneCatalogArgs(args: string[]): ParsedPaneCatalogArgs {
       continue;
     }
 
+    if (token === "--bot-safe" || token === "--botsafe") {
+      botSafeOnly = true;
+      continue;
+    }
+
     if (token === "--limit") {
       const parsed = Number(args[++index]);
       if (Number.isFinite(parsed) && parsed > 0) {
@@ -142,12 +154,15 @@ export function parsePaneCatalogArgs(args: string[]): ParsedPaneCatalogArgs {
   return {
     query: queryParts.join(" ").trim(),
     limit,
+    botSafeOnly,
   };
 }
 
-export function optionString(options: Record<string, string | true>, key: string): string | undefined {
+type PaneOptionValues = Record<string, string | number | boolean>;
+
+export function optionString(options: PaneOptionValues, key: string): string | undefined {
   const value = options[normalizeOptionKey(key)];
-  return value === true ? undefined : value;
+  return value === true || value === undefined ? undefined : String(value);
 }
 
 const RESERVED_OPTION_KEYS = new Set(["output", "out", "o", "width", "height", "arguments", "state"]);
@@ -211,7 +226,7 @@ function normalizeFinancialSubTabOption(value: string | undefined): string | und
   ))?.key;
 }
 
-export function optionPaneState(options: Record<string, string | true>): PaneRuntimeState {
+export function optionPaneState(options: PaneOptionValues | NormalizedPaneFunctionOptions): PaneRuntimeState {
   const state: PaneRuntimeState = {};
   const rawState = optionString(options, "state");
   if (rawState) {
@@ -222,7 +237,7 @@ export function optionPaneState(options: Record<string, string | true>): PaneRun
 
   for (const [key, value] of Object.entries(options)) {
     if (!key.startsWith("state.") || value === true) continue;
-    state[key.slice("state.".length)] = coerceSettingValue(value);
+    state[key.slice("state.".length)] = typeof value === "string" ? coerceSettingValue(value) : value;
   }
 
   const activeTab = optionString(options, "activeTabId")