gloomberb 0.11.2 → 0.12.0

package/src/plugins/builtin/market-valuation/defs.ts

@@ -0,0 +1,251 @@
+import { blendHex, colors } from "../../../theme/colors";
+
+export type ValuationRangeId = "10Y" | "25Y" | "ALL";
+
+/** Columns of Shiller's monthly dataset the pane can chart. */
+export type ShillerField =
+  | "price"
+  | "dividend"
+  | "earnings"
+  | "cpi"
+  | "longRate"
+  | "cape"
+  | "excessCapeYield";
+
+/**
+ * Every leg resolves through the Gloom Cloud proxy. Nothing here talks to Yahoo or
+ * FRED directly, which is what lets the pane run in the hosted browser build.
+ */
+export type SeriesSource =
+  | { kind: "fred"; seriesId: string; limit: number }
+  | { kind: "market-history"; symbol: string; exchange: string; startDate: string }
+  | { kind: "shiller"; field: ShillerField };
+
+export interface SeriesDef {
+  /** Stable identity for caching and for de-duplicating legs shared by indicators. */
+  key: string;
+  /** Multiplier that brings a raw observation into billions of dollars. */
+  scaleToBillions: number;
+  source: SeriesSource;
+}
+
+export type ValuationZoneId =
+  | "significantly-undervalued"
+  | "modestly-undervalued"
+  | "fair"
+  | "modestly-overvalued"
+  | "significantly-overvalued";
+
+export interface ZoneHit {
+  id: ValuationZoneId;
+  label: string;
+  color: string;
+}
+
+/**
+ * Upper edge of a valuation band, in the indicator's own units, ascending.
+ * `max: null` is the open top band. Bands carry their own id, so an indicator
+ * where a high reading means cheap (a yield spread) simply lists them in the
+ * opposite order rather than needing an inversion flag.
+ */
+export interface ZoneBand {
+  max: number | null;
+  id: ValuationZoneId;
+  label: string;
+}
+
+export interface ZoneScaleBand {
+  id: ValuationZoneId;
+  from: number;
+  to: number;
+  color: string;
+}
+
+/** A ratio of two series, or a single series that is already the measure. */
+export type IndicatorInput =
+  | {
+    kind: "ratio";
+    numerator: SeriesDef;
+    denominator: SeriesDef;
+    /**
+     * Set only when both legs are dollar amounts worth showing. A ratio of two
+     * index columns has no meaningful level to print, so it omits this.
+     */
+    levels?: { numeratorLabel: string; denominatorLabel: string };
+  }
+  | { kind: "direct"; series: SeriesDef };
+
+export interface IndicatorDef {
+  id: string;
+  /** Full name for the detail heading and catalog copy. */
+  label: string;
+  /** Fits the summary table's INDICATOR column. */
+  shortLabel: string;
+  description: string;
+  input: IndicatorInput;
+  /** Multiplies the raw value: 100 renders a quotient as a percent. */
+  ratioScale: number;
+  formatValue: (value: number) => string;
+  /** Drives the chart's own axis and cursor formatting. "" leaves a bare number. */
+  axisUnit: "%" | "";
+  zones: readonly ZoneBand[];
+  zoneScale: {
+    min: number;
+    max: number;
+    /** Band edges, low to high, from `min` to `max`. Each band gets equal width. */
+    edges: readonly number[];
+    ticks: readonly number[];
+  };
+  /** Horizontal line drawn on the chart, e.g. Buffett's 100% parity. */
+  reference: { value: number; label: string } | null;
+  /** Y-axis gridline spacing, in the indicator's own units. */
+  chartGridStep: number;
+  /**
+   * Log-linear suits a level that compounds. A measure that can sit at or below
+   * zero, like an excess yield, needs the linear fit.
+   */
+  trendModel: "log" | "linear";
+  /** How old the newest observation may get before the pane flags it stale. */
+  staleAfterMs: number;
+  notes: string[];
+  link: { url: string; label: string } | null;
+}
+
+const MS_PER_YEAR = 365.25 * 24 * 60 * 60 * 1000;
+
+export const RANGE_WINDOWS_MS: { readonly [K in ValuationRangeId]: number | null } = {
+  "10Y": 10 * MS_PER_YEAR,
+  "25Y": 25 * MS_PER_YEAR,
+  ALL: null,
+};
+
+export function zoneColor(id: ValuationZoneId): string {
+  switch (id) {
+    case "significantly-undervalued":
+      return blendHex(colors.positive, "#000000", 0.2);
+    case "modestly-undervalued":
+      return colors.positive;
+    case "fair":
+      return colors.textBright;
+    case "modestly-overvalued":
+      return blendHex(colors.warning, colors.negative, 0.25);
+    case "significantly-overvalued":
+      return blendHex(colors.negative, "#000000", 0.2);
+    default: {
+      const _exhaustive: never = id;
+      return _exhaustive;
+    }
+  }
+}
+
+/** Column-width form of the zone name for the summary table. */
+export function shortZoneLabel(id: ValuationZoneId): string {
+  switch (id) {
+    case "significantly-undervalued":
+      return "Sig. under";
+    case "modestly-undervalued":
+      return "Under";
+    case "fair":
+      return "Fair";
+    case "modestly-overvalued":
+      return "Over";
+    case "significantly-overvalued":
+      return "Sig. over";
+    default: {
+      const _exhaustive: never = id;
+      return _exhaustive;
+    }
+  }
+}
+
+/**
+ * True when a bigger number means a more expensive market. A yield-shaped measure
+ * runs the other way, and lists its bands starting at overvalued to say so. The
+ * summary table uses this to put every row on one "expensive" scale, so a column
+ * can be read straight down.
+ */
+export function higherIsExpensive(indicator: IndicatorDef): boolean {
+  return indicator.zones[0]?.id !== "significantly-overvalued";
+}
+
+export function classifyZone(indicator: IndicatorDef, value: number): ZoneHit {
+  for (const band of indicator.zones) {
+    if (band.max == null || value < band.max) {
+      return { id: band.id, label: band.label, color: zoneColor(band.id) };
+    }
+  }
+  const last = indicator.zones[indicator.zones.length - 1]!;
+  return { id: last.id, label: last.label, color: zoneColor(last.id) };
+}
+
+export function zoneScaleBands(indicator: IndicatorDef): ZoneScaleBand[] {
+  const { min, max } = indicator.zoneScale;
+  let from = min;
+  return indicator.zones.map((band) => {
+    const to = band.max == null ? max : band.max;
+    const entry = { id: band.id, from, to, color: zoneColor(band.id) };
+    from = band.max ?? from;
+    return entry;
+  });
+}
+
+/**
+ * Position a value on the scale as a 0..1 fraction. Each valuation band gets equal
+ * width so fair sits near the visual center instead of being pushed to one side by
+ * a long open-ended band.
+ */
+export function zoneScaleFraction(indicator: IndicatorDef, value: number): number {
+  const edges = indicator.zoneScale.edges;
+  const bands = edges.length - 1;
+  if (bands <= 0) return 0;
+  const { min, max } = indicator.zoneScale;
+  const clamped = Math.max(min, Math.min(max, value));
+  let bandIdx = bands - 1;
+  for (let i = 0; i < bands; i += 1) {
+    if (clamped < edges[i + 1]! || i === bands - 1) {
+      bandIdx = i;
+      break;
+    }
+  }
+  const lo = edges[bandIdx]!;
+  const hi = edges[bandIdx + 1]!;
+  const t = hi === lo ? 0 : (clamped - lo) / (hi - lo);
+  return (bandIdx + t) / bands;
+}
+
+/** Inverse of zoneScaleFraction: scale position back to the indicator's units. */
+export function zoneScaleValueAt(indicator: IndicatorDef, fraction: number): number {
+  const edges = indicator.zoneScale.edges;
+  const bands = edges.length - 1;
+  if (bands <= 0) return 0;
+  const pos = Math.min(bands, Math.max(0, fraction * bands));
+  const bandIdx = Math.min(bands - 1, Math.floor(pos));
+  const lo = edges[bandIdx]!;
+  const hi = edges[bandIdx + 1]!;
+  return lo + (pos - bandIdx) * (hi - lo);
+}
+
+export function zoneScaleMarkerColumn(
+  indicator: IndicatorDef,
+  value: number,
+  width: number,
+): number {
+  if (width <= 1) return 0;
+  return Math.round(zoneScaleFraction(indicator, value) * (width - 1));
+}
+
+export function zoneScaleColumnValue(
+  indicator: IndicatorDef,
+  column: number,
+  width: number,
+): number {
+  if (width <= 1) return 0;
+  return zoneScaleValueAt(indicator, column / Math.max(width - 1, 1));
+}
+
+/** Every leg an indicator needs, so callers can fetch without knowing its shape. */
+export function indicatorSeries(indicator: IndicatorDef): SeriesDef[] {
+  return indicator.input.kind === "ratio"
+    ? [indicator.input.numerator, indicator.input.denominator]
+    : [indicator.input.series];
+}

package/src/plugins/builtin/market-valuation/detail.tsx

@@ -0,0 +1,159 @@
+import { useMemo, useState } from "react";
+import { CompositeChart } from "../../../components/chart/composite";
+import { ExternalLinkText } from "../../../components/ui";
+import { blendHex, colors } from "../../../theme/colors";
+import { Box, Text } from "../../../ui";
+import { formatNumber } from "../../../utils/format";
+import { markerSeries, zoneSeriesFor } from "./chart-projection";
+import type { IndicatorViewModel } from "./view";
+import { ZoneColorScale } from "./zone-scale";
+
+function formatTrillions(billions: number): string {
+  return `${formatNumber(billions / 1000, 1)}T`;
+}
+
+export function IndicatorDetail({
+  view,
+  width,
+  height,
+  focused = false,
+}: {
+  view: IndicatorViewModel;
+  width: number;
+  height: number;
+  focused?: boolean;
+}) {
+  const PANELS = [{ id: "main" }];
+  const indicator = view.indicator;
+  const levels = indicator.input.kind === "ratio" ? indicator.input.levels : undefined;
+  const [userViewport, setUserViewport] = useState<{ start: Date; end: Date } | null>(null);
+  const chartWidth = Math.max(24, width - 2);
+  const AXIS_WIDTH = 8;
+  // Give a tall pane a taller plot instead of leaving the space empty below.
+  const chartHeight = Math.max(8, Math.min(26, height - 16));
+
+  const visible = view.chart.sourcePoints;
+  const series = useMemo(() => {
+    const zones = zoneSeriesFor(indicator, visible);
+    const markers = [
+      indicator.reference
+        ? markerSeries(
+          indicator,
+          "reference",
+          indicator.reference.label,
+          indicator.reference.value,
+          colors.textDim,
+          visible,
+        )
+        : null,
+      markerSeries(
+        indicator,
+        "mean",
+        "mean",
+        view.mean,
+        blendHex(colors.textDim, colors.bg, 0.35),
+        visible,
+      ),
+    ].filter((entry) => entry != null);
+    return [...markers, ...zones];
+  }, [indicator, view.mean, visible]);
+
+  // One clean entry instead of a row per valuation band.
+  const legendSeries = useMemo(
+    () => series.filter((entry) => entry.id === "reference" || entry.id === "mean"),
+    [series],
+  );
+
+  const viewport = useMemo(() => {
+    if (userViewport) return userViewport;
+    if (visible.length < 2) return undefined;
+    return { start: new Date(visible[0]!.date), end: new Date(visible.at(-1)!.date) };
+  }, [userViewport, visible]);
+
+
+  return (
+    <Box flexDirection="column" width={width} paddingX={1} gap={1}>
+      {view.chart.points.length >= 2 ? (
+        <Box flexDirection="column" gap={0}>
+          <Box flexDirection="row" width={chartWidth} overflow="hidden">
+            <Text>{" ".repeat(AXIS_WIDTH)}</Text>
+            <ZoneColorScale
+              indicator={indicator}
+              value={view.current.ratio}
+              width={Math.max(1, chartWidth - AXIS_WIDTH)}
+              markerColor={view.zone.color}
+            />
+          </Box>
+          <CompositeChart
+            series={series}
+            legendSeries={legendSeries}
+            panels={PANELS}
+            width={chartWidth}
+            height={chartHeight}
+            focused={focused}
+            interactive
+            axisWidth={AXIS_WIDTH}
+            showLegend
+            viewport={viewport}
+            viewportResetKey={`${indicator.id}:${view.range}`}
+            onViewportChange={setUserViewport}
+            formatValue={(value) => indicator.formatValue(value)}
+            emptyMessage="Not enough chart data"
+          />
+        </Box>
+      ) : (
+        <Box height={chartHeight} justifyContent="center" alignItems="center">
+          <Text fg={colors.textMuted}>Not enough chart data</Text>
+        </Box>
+      )}
+
+      <Box flexDirection="column" gap={0}>
+        {levels && view.current.numeratorBillions != null
+          && view.current.denominatorBillions != null ? (
+          <Box flexDirection="row" height={1} overflow="hidden">
+            <Text fg={colors.textDim}>{`${levels.numeratorLabel} `}</Text>
+            <Text fg={colors.textBright}>{formatTrillions(view.current.numeratorBillions)}</Text>
+            <Text fg={colors.textDim}>{`  ${levels.denominatorLabel} `}</Text>
+            <Text fg={colors.textBright}>{formatTrillions(view.current.denominatorBillions)}</Text>
+            {view.vintageLabel ? (
+              <Text fg={colors.textDim}>{`  ${view.vintageLabel}`}</Text>
+            ) : null}
+          </Box>
+        ) : null}
+        <Box flexDirection="row" height={1} overflow="hidden">
+          <Text fg={colors.textDim}>1Y ago </Text>
+          <Text fg={colors.text}>
+            {view.ratioOneYearAgo == null ? "--" : indicator.formatValue(view.ratioOneYearAgo)}
+          </Text>
+          <Text fg={colors.textDim}>{"  mean "}</Text>
+          <Text fg={colors.text}>{indicator.formatValue(view.mean)}</Text>
+          <Text fg={colors.textDim}>{"  ATH "}</Text>
+          <Text fg={colors.text}>
+            {`${indicator.formatValue(view.allTimeHigh.ratio)} ${view.allTimeHigh.date}`}
+          </Text>
+          <Text fg={colors.textDim}>{"  ATL "}</Text>
+          <Text fg={colors.text}>
+            {`${indicator.formatValue(view.allTimeLow.ratio)} ${view.allTimeLow.date}`}
+          </Text>
+        </Box>
+      </Box>
+
+      <Box flexDirection="column" gap={1} width={Math.max(1, width - 2)}>
+        {indicator.notes.map((note) => (
+          <Text key={note.slice(0, 24)} fg={colors.textDim} wrapMode="word" wrapText>
+            {note}
+          </Text>
+        ))}
+        {indicator.link ? (
+          <Box flexDirection="row" height={1} overflow="hidden">
+            <ExternalLinkText
+              url={indicator.link.url}
+              label={indicator.link.label}
+              color={colors.text}
+            />
+          </Box>
+        ) : null}
+      </Box>
+    </Box>
+  );
+}

package/src/plugins/builtin/market-valuation/headless.test.ts

@@ -0,0 +1,58 @@
+import { afterEach, beforeEach, 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 { resetValuationPersistence } from "./cache";
+import { marketValuationHeadless } from "./headless";
+
+beforeEach(resetValuationPersistence);
+afterEach(resetValuationPersistence);
+
+function loadArgs(): HeadlessPaneLoadArgs {
+  return {
+    rawArgument: "cape",
+    argument: "cape",
+    symbols: [],
+    options: { range: "10Y" },
+  };
+}
+
+describe("market valuation headless model", () => {
+  test("loads through the injected cloud client and produces bundle sections", async () => {
+    let shillerCalls = 0;
+    const apiClient = {
+      getCloudFredSeries: async () => { throw new Error("unexpected FRED request"); },
+      getCloudHistory: async () => { throw new Error("unexpected history request"); },
+      getCloudShiller: async () => {
+        shillerCalls += 1;
+        return {
+          observations: [
+            { date: "2024-01-01", price: 4800, dividend: 70, earnings: 180, cpi: 310, longRate: 4, cape: 32, excessCapeYield: 0.02 },
+            { date: "2025-01-01", price: 5900, dividend: 76, earnings: 200, cpi: 320, longRate: 4.2, cape: 36, excessCapeYield: 0.015 },
+            { date: "2026-01-01", price: 6300, dividend: 80, earnings: 220, cpi: 330, longRate: 4.4, cape: 39, excessCapeYield: 0.01 },
+          ],
+          sourceUrl: "https://example.test/shiller.xls",
+          fetchedAt: "2026-01-02T00:00:00Z",
+        };
+      },
+    } as unknown as HeadlessPaneContext["apiClient"];
+    const context: HeadlessPaneContext = {
+      marketData: createTestDataProvider(),
+      apiClient,
+      config: createDefaultConfig("/tmp/gloomberb-headless-valuation"),
+      signal: new AbortController().signal,
+    };
+
+    const result = await marketValuationHeadless.load(loadArgs(), context);
+
+    expect(shillerCalls).toBe(1);
+    expect(result.sections.map(({ title }) => title)).toEqual([
+      "Market valuation",
+      "Shiller CAPE",
+    ]);
+    expect(result.sections[0]).toMatchObject({
+      rows: [{ id: "shiller-cape", value: 39, formattedValue: "39.0" }],
+    });
+    expect(result.metadata).toMatchObject({ range: "10Y", selected: "shiller-cape" });
+  });
+});

package/src/plugins/builtin/market-valuation/headless.ts

@@ -0,0 +1,170 @@
+import type {
+  HeadlessBundleResult,
+  HeadlessPaneDefinition,
+  HeadlessPaneEntry,
+  HeadlessPaneLoadArgs,
+} from "../../../types/plugin";
+import { formatNumber } from "../../../utils/format";
+import {
+  createValuationSeriesLoader,
+  loadValuationBundle,
+  type ValuationSeriesLoader,
+} from "./client";
+import type { ValuationRangeId } from "./defs";
+import { DEFAULT_INDICATOR_ID, INDICATORS, resolveIndicatorArg } from "./indicators";
+import { createCloudSourceDeps } from "./sources";
+import {
+  formatSigma,
+  selectValuationViews,
+  type IndicatorViewModel,
+  type ValuationBundle,
+} from "./view";
+
+function detailEntries(view: IndicatorViewModel): HeadlessPaneEntry[] {
+  const format = view.indicator.formatValue;
+  return [
+    { label: "Current", value: view.current.ratio, formatted: format(view.current.ratio) },
+    {
+      label: "1Y ago",
+      value: view.ratioOneYearAgo,
+      formatted: view.ratioOneYearAgo == null ? "-" : format(view.ratioOneYearAgo),
+    },
+    { label: "Mean", value: view.mean, formatted: format(view.mean) },
+    {
+      label: "Rich percentile",
+      value: view.richPercentile,
+      formatted: formatNumber(view.richPercentile, 0),
+    },
+    {
+      label: "Trend deviation",
+      value: view.richSigma,
+      formatted: formatSigma(view.richSigma),
+    },
+    {
+      label: "All-time high",
+      value: { value: view.allTimeHigh.ratio, date: view.allTimeHigh.date },
+      formatted: `${format(view.allTimeHigh.ratio)} ${view.allTimeHigh.date}`,
+    },
+    {
+      label: "All-time low",
+      value: { value: view.allTimeLow.ratio, date: view.allTimeLow.date },
+      formatted: `${format(view.allTimeLow.ratio)} ${view.allTimeLow.date}`,
+    },
+    { label: "As of", value: view.asOf },
+  ];
+}
+
+export function projectValuationHeadlessBundle(
+  bundle: ValuationBundle,
+  range: ValuationRangeId,
+  selectedId: string,
+): HeadlessBundleResult {
+  const views = selectValuationViews(bundle, range);
+  const selected = views.find((view) => view.indicator.id === selectedId) ?? views[0] ?? null;
+  const rows = views.map((view) => ({
+    id: view.indicator.id,
+    indicator: view.indicator.label,
+    value: view.current.ratio,
+    formattedValue: view.indicator.formatValue(view.current.ratio),
+    zone: view.zone.label,
+    richPercentile: view.richPercentile,
+    richSigma: view.richSigma,
+    asOf: view.asOf,
+    stale: view.observationStale,
+  }));
+
+  return {
+    sections: [
+      {
+        title: "Market valuation",
+        columns: [
+          { key: "indicator", header: "Indicator" },
+          {
+            key: "value",
+            header: "Value",
+            align: "right",
+            format: (_value, row) => String(row.formattedValue),
+          },
+          { key: "zone", header: "Zone" },
+          {
+            key: "richPercentile",
+            header: "Rich %ile",
+            align: "right",
+            format: (value) => formatNumber(Number(value), 0),
+          },
+          {
+            key: "richSigma",
+            header: "Trend",
+            align: "right",
+            format: (value) => formatSigma(Number(value)),
+          },
+          { key: "asOf", header: "As of" },
+        ],
+        rows,
+      },
+      ...(selected
+        ? [{ title: selected.indicator.label, entries: detailEntries(selected) }]
+        : []),
+    ],
+    errors: bundle.errors,
+    metadata: {
+      fetchedAt: bundle.fetchedAt,
+      range,
+      selected: selected?.indicator.id ?? null,
+    },
+  };
+}
+
+export interface MarketValuationHeadlessDependencies {
+  loadBundle(args: HeadlessPaneLoadArgs, loader: ValuationSeriesLoader): Promise<ValuationBundle>;
+}
+
+const defaultDependencies: MarketValuationHeadlessDependencies = {
+  loadBundle: (args, loader) => {
+    const requested = typeof args.argument === "string" ? resolveIndicatorArg(args.argument) : null;
+    return loadValuationBundle({
+      loader,
+      ...(requested ? { indicators: [requested] } : {}),
+    });
+  },
+};
+
+export function createMarketValuationHeadless(
+  dependencies: MarketValuationHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"bundle"> {
+  return {
+    shape: "bundle",
+    argument: {
+      kind: "free-text",
+      placeholder: "indicator",
+      description: "Optional valuation indicator id, label, or prefix.",
+      optional: true,
+    },
+    options: [{
+      key: "range",
+      description: "History window used by the selected indicator view.",
+      type: "enum",
+      values: [{ value: "10Y" }, { value: "25Y" }, { value: "ALL", aliases: ["all"] }],
+      defaultValue: "25Y",
+    }],
+    describe: (args) => `Market Valuation | ${String(args.options.range)}`,
+    async load(args, ctx) {
+      const requested = typeof args.argument === "string" ? resolveIndicatorArg(args.argument) : null;
+      if (args.argument && !requested) {
+        throw new Error(
+          `Unknown valuation indicator "${String(args.argument)}". Use one of: ${INDICATORS.map(({ id }) => id).join(", ")}.`,
+        );
+      }
+      const range = args.options.range as ValuationRangeId;
+      const loader = createValuationSeriesLoader(createCloudSourceDeps(ctx.apiClient));
+      const bundle = await dependencies.loadBundle(args, loader);
+      return projectValuationHeadlessBundle(
+        bundle,
+        range,
+        requested?.id ?? DEFAULT_INDICATOR_ID,
+      );
+    },
+  };
+}
+
+export const marketValuationHeadless = createMarketValuationHeadless();

package/src/plugins/builtin/market-valuation/index.tsx

@@ -0,0 +1,64 @@
+import type { PluginModule } from "../plugin-module";
+import { createValuationChartSeriesCapability } from "./chart-series";
+import { INDICATORS, resolveIndicatorArg } from "./indicators";
+import { marketValuationHeadless } from "./headless";
+import { MarketValuationPane } from "./pane";
+import { buildValuationSettingsDef, VALUATION_DEFAULTS } from "./settings";
+
+export { marketValuationHeadless } from "./headless";
+
+const MARKET_VALUATION_PANE_ID = "market-valuation";
+
+const INDICATOR_KEYWORDS = INDICATORS.flatMap((indicator) => [
+  indicator.id,
+  ...indicator.shortLabel.toLowerCase().split(" "),
+  ...indicator.label.toLowerCase().split(" "),
+]);
+
+export const marketValuationModule: PluginModule = {
+  // Exposes each ratio as a chartable series, so G can overlay them on anything else.
+  capabilities: [createValuationChartSeriesCapability()],
+  panes: [{
+    id: MARKET_VALUATION_PANE_ID,
+    name: "Market Valuation",
+    icon: "V",
+    component: MarketValuationPane,
+    defaultPosition: "right",
+    defaultMode: "floating",
+    defaultFloatingSize: { width: 88, height: 34 },
+    settings: buildValuationSettingsDef(),
+  }],
+  paneTemplates: [{
+    id: "market-valuation-pane",
+    paneId: MARKET_VALUATION_PANE_ID,
+    label: "Market Valuation",
+    description: "Whole-market valuation ratios against their own history, with zones and trend deviation.",
+    keywords: [
+      "valuation",
+      "market cap",
+      "gdp",
+      "wilshire",
+      "macro",
+      "bubble",
+      "overvalued",
+      "undervalued",
+      ...INDICATOR_KEYWORDS,
+    ],
+    shortcut: {
+      prefix: "VAL",
+      argPlaceholder: "indicator",
+      argKind: "text",
+      argOptional: true,
+    },
+    headless: marketValuationHeadless,
+    // No wizard: VAL opens straight into the pane, where the summary rows swap
+    // indicators with the cursor. The argument form stays for deep links.
+    canCreate: () => true,
+    createInstance: (_context, options) => {
+      const indicator = resolveIndicatorArg(options?.arg);
+      return {
+        settings: { indicator: indicator?.id ?? VALUATION_DEFAULTS.indicator },
+      };
+    },
+  }],
+};