gloomberb 0.16.4 → 0.16.6

package/src/plugins/builtin/power/headless.ts

@@ -1,25 +1,68 @@
-import type { HeadlessPaneDefinition } from "../../../types/plugin";
-import { fetchPowerBoard, fetchAllPowerHistory } from "./client";
+import type { DataTableColumn } from "../../../components";
+import type { HeadlessPaneColumn, HeadlessPaneDefinition, HeadlessPaneRow } from "../../../types/plugin";
+import { withoutQuietColumns } from "../shared/research-cells";
+import { fetchPowerBoard, fetchAllPowerHistory, fetchPowerTickerScopes } from "./client";
 import { powerQuery } from "./query";
-import { POWER_TABS, powerTab } from "./model";
+import { loadPowerPricesReport } from "./prices-headless";
+import { isCarbonQuery, powerPriceMarket } from "./prices-model";
+import {
+  COVERAGE_COLUMNS, EXPOSURE_COLUMNS, GENERATION_COLUMNS, HISTORY_COLUMNS, POWER_TABS, PROJECT_COLUMNS, RATE_COLUMNS, UTILITY_COLUMNS,
+  historyRows, powerCoverageNote, powerLoadedSources, powerNumber, powerPercent, powerRegion, powerScopeOptions, powerTab, powerTickerEmpty, projectRows, tickerLabel, titleCase, UNMAPPED, type PowerTab,
+} from "./model";
+
+/** Bars the pane draws beside the numbers they are made of; the report has the numbers. */
+const GRAPHIC_COLUMNS = new Set(["outcome", "pipeline"]);
+/** Columns that only repeat a default on every row, as the pane leaves them out. */
+const QUIET_COLUMNS: Record<string, readonly string[]> = { scope: ["Project"], unknownCapacity: ["0"], unknown: ["0"], fuel: ["Load"], role: ["Direct"], kind: ["Queue"] };
+const text = (value: unknown) => value == null || value === "" ? "-" : String(value);
+const coded = (value: unknown) => typeof value === "string" && value ? titleCase(value) : "-";
+
+/**
+ * The pane's columns for a tab, printed as the pane prints them: MW and MWh
+ * to a tenth with thousands separators, rates as percentages, register codes
+ * by name, and each record's listed company or "unmapped". Raw metrics and
+ * evidence stay in the exported rows, out of the table.
+ */
+function reportColumns(tab: PowerTab, context: unknown): HeadlessPaneColumn[] {
+  const columns: DataTableColumn[] = tab === "capacity" && context === "generation" ? GENERATION_COLUMNS : tab === "capacity" && context === "utility" ? UTILITY_COLUMNS
+    : ["queue", "loads", "capacity"].includes(tab) ? PROJECT_COLUMNS : tab === "history" ? HISTORY_COLUMNS : tab === "outcomes" ? RATE_COLUMNS : tab === "utilities" ? EXPOSURE_COLUMNS : COVERAGE_COLUMNS;
+  // The coverage list names its register by its own id; everything else by the record's source.
+  const region = (value: unknown, row: HeadlessPaneRow) => typeof value !== "string" ? "-"
+    : tab === "utilities" ? value : powerRegion(value, String((tab === "coverage" ? row.id : row.sourceId) ?? ""));
+  const format = (column: DataTableColumn): HeadlessPaneColumn["format"] => {
+    if (column.id === "region") return region;
+    if (["fuel", "status", "kind", "role"].includes(column.id)) return coded;
+    if (column.id === "ticker") return (value) => typeof value === "string" && value ? value : UNMAPPED;
+    if (column.id === "developer") return (value, row) => text(value ?? row.utility);
+    if (column.id === "observedAt") return (value) => typeof value === "string" ? value.slice(0, 16).replace("T", " ") : "-";
+    if (/Rate$/.test(column.id)) return (value) => typeof value === "number" ? powerPercent(value) : "-";
+    if (column.align === "right") return (value) => typeof value === "number" ? `${column.id === "changeMw" && value > 0 ? "+" : ""}${powerNumber(value)}` : "-";
+    return text;
+  };
+  // The pane groups outcomes under region headings; the report names the region on each row.
+  return [...(tab === "outcomes" ? [{ id: "region", label: "Region", width: 16, align: "left" as const }] : []), ...columns].filter((column) => !GRAPHIC_COLUMNS.has(column.id))
+    .map((column) => ({ key: column.id, header: column.label, align: column.align === "right" ? "right" as const : "left" as const, format: format(column) }));
+}
 
 export const powerHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle",
-  freshness: { source: "Grid operator queues and utility filings", status: "not-a-feed", basis: "published records" },
+  freshness: { source: "Grid operator queues and utility filings", status: "not-a-feed", basis: "published records", dataset: true },
   argument: { kind: "free-text", optional: true, placeholder: "ticker", description: "Optional listed developer or utility ticker, with exchange suffix where needed." },
   options: [
-    { key: "tab", type: "enum", settingKey: "tab", defaultValue: "queue", values: POWER_TABS.map(({ value }) => ({ value })), description: "Queue, history, outcomes, large loads, utility exposure, capacity or coverage." },
+    { key: "tab", type: "enum", settingKey: "tab", defaultValue: "queue", values: POWER_TABS.map(({ value }) => ({ value })), description: "Queue, history, outcomes, large loads, utility exposure, capacity, European day-ahead prices or coverage." },
     ...["country", "region", "fuel", "status", "search", "sourceId", "from", "to"].map((key) => ({ key, type: "string" as const, settingKey: key, description: `Filter by ${key}.` })),
     { key: "context", type: "enum", settingKey: "context", values: [{ value: "capacity" }, { value: "generation" }, { value: "utility" }], defaultValue: "capacity", description: "Generation capacity, monthly generation or utility context on the Capacity tab." },
     { key: "loadClass", aliases: ["load-class"], type: "enum", settingKey: "loadClass", values: [{ value: "datacenter" }], description: "Only loads explicitly classified as datacenters." },
     { key: "historical", type: "boolean", settingKey: "historical", defaultValue: false, description: "Use historical benchmark queues separately from direct observations." },
   ],
   discovery: { aliases: ["POWER"], dataRequirements: ["Gloom Cloud power queues and large-load disclosures"],
-    limitations: ["Pro dataset; free accounts see three rows per section and limited history", "Proposed projects are not committed supply; requests and approvals are distinct", "Coverage varies by jurisdiction; missing MW and unavailable sources remain explicit"] },
+    limitations: ["Pro dataset; free accounts see three rows per section and limited history.", "Proposed projects are not committed supply; requests and approvals are distinct.", "Coverage varies by jurisdiction; missing MW and unavailable sources remain explicit."] },
   describe: "Power queues, large loads and utility exposure (Pro)",
   async load(args, ctx) {
     const tab = powerTab(args.options.tab);
     const symbol = (Array.isArray(args.argument) ? args.argument.join(" ") : args.argument)?.trim();
+    // Prices are their own board (EPWR); a typed market narrows it, a ticker does not apply.
+    if (tab === "prices") return loadPowerPricesReport(powerPriceMarket(symbol) || isCarbonQuery(symbol) ? symbol : undefined, ctx.apiClient);
     const filter = { ...powerQuery(args.options, symbol), limit: 500 };
     const board = await fetchPowerBoard(filter, ctx.apiClient);
     const projects = [...board.projects];
@@ -36,10 +79,35 @@ export const powerHeadless: HeadlessPaneDefinition<"bundle"> = {
       projects.push(...page.projects); offset = page.nextOffset; hasMore = page.hasMore;
     }
     const history = tab === "history" ? await fetchAllPowerHistory(filter, ctx.apiClient) : null;
-    const rows = tab === "history" ? history!.points : tab === "outcomes" ? board.rates : tab === "utilities" ? board.exposure : tab === "coverage" ? board.coverage : projects;
+    // Exported rows keep every field the server sent; the pane's derived cells (the ticker map, location, scope) ride beside them.
+    const cells = projectRows(projects);
+    const rows: HeadlessPaneRow[] = tab === "history" ? historyRows(history!.points).map((point) => ({ ...point, date: point.basis === "published" ? point.period : point.observedAt.slice(0, 16).replace("T", " ") }))
+      : tab === "outcomes" ? board.rates.map((rate) => ({ ...rate }))
+        : tab === "utilities" ? board.exposure.map((exposure) => ({ ...exposure, ticker: tickerLabel(exposure) }))
+          : tab === "coverage" ? board.coverage.map((coverage) => ({ ...coverage }))
+            : projects.map((project, index) => {
+              const { ticker, location, scope, generationMwh, summerPeakDemandMw, winterPeakDemandMw, salesMwh, revenueUsd } = cells[index]!.cells;
+              return { ...project, ticker, location, scope, generationMwh, summerPeakDemandMw, winterPeakDemandMw, salesMwh, revenueUsd };
+            });
     const locked = history?.locked ?? (tab === "outcomes" ? board.locked.rates : tab === "utilities" ? board.locked.exposure : tab === "coverage" ? 0 : board.locked.projects);
-    return { complete: locked === 0, sections: [{ title: POWER_TABS.find((t) => t.value === tab)!.label, rows: rows.map((r) => ({ ...r })) }],
+    const columns = reportColumns(tab, args.options.context);
+    const shown = withoutQuietColumns(columns.map((column) => ({ id: column.key, label: column.header, width: 0, align: "left" as const })), rows,
+      (row, id) => columns.find((column) => column.key === id)!.format!(row[id], row), QUIET_COLUMNS).map((column) => column.id);
+    // A ticker with nothing on this tab says where its records are instead; a narrower filter is the filters' doing.
+    const narrowed = ["country", "region", "fuel", "status", "search", "sourceId", "from", "to", "loadClass", "historical"].some((key) => !!args.options[key]);
+    const empty = !rows.length && symbol && !narrowed && tab !== "coverage" ? await fetchPowerTickerScopes(symbol, tab, String(args.options.context ?? "capacity"), ctx.apiClient)
+      .then((scopes) => {
+        const message = powerTickerEmpty(symbol, tab, String(args.options.context ?? "capacity"), scopes);
+        const where = message.found.map((scope) => `${powerNumber(scope.total)} ${scope.label} (${powerScopeOptions(scope)})`).join(", ");
+        const loaded = powerLoadedSources(tab, board.coverage);
+        return [message.title, where ? `${symbol} has ${where}.` : message.hint?.replace(/\.$/, " (--search <name>)."),
+          loaded ? `Sources loaded now: ${loaded}.` : null].filter(Boolean).join(" ");
+      }) : "No reported records match these filters.";
+    // Missing or unsupported sources are coverage, not failures: one plain line, details in --tab coverage.
+    const coverageNote = tab === "capacity" ? null : powerCoverageNote(board.coverage);
+    return { complete: locked === 0, sections: [{ title: POWER_TABS.find((t) => t.value === tab)!.label, columns: columns.filter((column) => shown.includes(column.key)), rows, empty }],
       metadata: { generatedAt: board.generatedAt, access: board.access, locked, total: board.total, units: "MW unless specified", filters: filter, aggregates: board.aggregates, coverage: board.coverage },
-      errors: [...(locked ? ["Additional records and history need Gloom Pro."] : []), ...board.coverage.filter((c) => c.status !== "current").map((c) => `${c.region}: ${c.status}${c.reason ? `: ${c.reason}` : ""}`)] };
+      ...(coverageNote ? { notes: [coverageNote] } : {}),
+      ...(locked ? { errors: ["Additional records and history need Gloom Pro."] } : {}) };
   },
 };

package/src/plugins/builtin/power/index.tsx

@@ -2,15 +2,40 @@ import type { PluginModule } from "../plugin-module";
 import { powerBoardCache, powerDetailCache, powerHistoryCache } from "./client";
 import { powerHeadless } from "./headless";
 import { PowerPane } from "./pane";
+import { carbonHistoryCache, carbonPriceCache, powerPriceHistoryCache, powerPricesCache } from "./prices-client";
+import { powerPricesHeadless } from "./prices-headless";
+import { CARBON_SELECTION, CARBON_SERIES, DAY_AHEAD_SERIES, isCarbonQuery, POWER_PRICE_MARKETS, powerPriceMarket } from "./prices-model";
+
+const CACHES = [powerBoardCache, powerHistoryCache, powerDetailCache, powerPricesCache, powerPriceHistoryCache, carbonPriceCache, carbonHistoryCache];
 
 export const powerModule: PluginModule = {
+  series: [...DAY_AHEAD_SERIES, ...CARBON_SERIES],
   panes: [{ id: "power", name: "Power & Grid", icon: "P", component: PowerPane, defaultPosition: "right", defaultMode: "floating",
     defaultFloatingSize: { width: 132, height: 34 }, tableExport: true, headless: powerHeadless }],
   paneTemplates: [{ id: "power-pane", paneId: "power", label: "Power & Grid",
     description: "Pro: interconnection queues, historical MW and outcomes, datacenter loads, utility exposure and generation capacity, with primary evidence.",
     keywords: ["power", "electricity", "interconnection", "grid", "datacenter", "utility", "renewables", "storage", "capacity"],
     shortcut: { prefix: "POWER", argKind: "text", argPlaceholder: "ticker", argOptional: true }, headless: powerHeadless,
-    createInstance: (_context, options) => ({ placement: "floating", params: { symbol: options?.symbol ?? options?.arg?.trim().toUpperCase() ?? "" } }) }],
-  setup(ctx) { for (const cache of [powerBoardCache, powerHistoryCache, powerDetailCache]) cache.attach(ctx.persistence); },
-  dispose() { for (const cache of [powerBoardCache, powerHistoryCache, powerDetailCache]) cache.reset(); },
+    createInstance: (_context, options) => {
+      const symbol = options?.symbol ?? options?.arg?.trim().toUpperCase() ?? "";
+      return { placement: "floating", params: { symbol }, ...(symbol ? { title: `POWER ${symbol}` } : {}) };
+    } }, {
+    id: "power-prices-pane", paneId: "power", label: "EU Power & Carbon",
+    description: "Day-ahead power prices for 32 European markets in EUR/MWh and the EU carbon allowance (EUA) auction price in EUR/tCO2: the latest day, 7- and 30-day averages, a year ago and the 52-week range, with daily history.",
+    keywords: ["day-ahead", "day ahead", "power price", "power prices", "electricity price", "electricity prices", "wholesale power",
+      "spot power", "baseload", "europe", "european", "eur/mwh", "carbon", "eu carbon", "eua", "eu ets", "carbon price",
+      "carbon allowance", "emission allowances", "co2", "eur/tco2"],
+    shortcut: { prefix: "EPWR", argKind: "text", argPlaceholder: "market", argOptional: true,
+      argOptions: () => [{ value: "EUA", label: "EU carbon allowance" }, ...POWER_PRICE_MARKETS.map(({ code, name }) => ({ value: code, label: name }))] },
+    headless: powerPricesHeadless,
+    createInstance: (_context, options) => {
+      const input = options?.arg?.trim();
+      const market = powerPriceMarket(input);
+      // EPWR EUA opens the tab with the carbon allowance charted above the board.
+      const carbon = isCarbonQuery(input);
+      if (input && !market && !carbon) throw new Error("Use a market such as DE, FR, GB or Spain, or EUA");
+      return { placement: "floating", settings: { tab: "prices" }, ...(market || carbon ? { params: { market: market?.code ?? CARBON_SELECTION } } : {}) };
+    } }],
+  setup(ctx) { for (const cache of CACHES) cache.attach(ctx.persistence); },
+  dispose() { for (const cache of CACHES) cache.reset(); },
 };

package/src/plugins/builtin/power/model.ts

@@ -2,16 +2,87 @@ import type { PowerAggregate, PowerBoard, PowerCoverage, PowerExposure, PowerHis
 import { staticSeries, type DataTableColumn } from "../../../components";
 
 export const POWER_TABS = [{ value: "queue", label: "Queue" }, { value: "history", label: "History" }, { value: "outcomes", label: "Outcomes" },
-  { value: "loads", label: "Loads" }, { value: "utilities", label: "Utilities" }, { value: "capacity", label: "Capacity" }, { value: "coverage", label: "Coverage" }] as const;
+  { value: "loads", label: "Loads" }, { value: "utilities", label: "Utilities" }, { value: "capacity", label: "Capacity" }, { value: "prices", label: "Prices" }, { value: "coverage", label: "Coverage" }] as const;
 export type PowerTab = typeof POWER_TABS[number]["value"];
 export const powerTab = (value: unknown): PowerTab => POWER_TABS.find((tab) => tab.value === value)?.value ?? "queue";
 const REGISTERS: Record<string, string> = { "neso-tec": "GB transmission", "neso-embedded": "GB embedded", "neso-interconnector": "GB interconnectors" };
 const REGIONS: Record<string, string> = { LBNL: "US project queues", "LBNL-ANNUAL": "US annual queues", EIA860: "US generation capacity", EIA861: "US utilities", EIA923: "US generation output" };
 export const powerRegion = (value: string, sourceId?: string) => REGISTERS[sourceId ?? ""] ?? REGIONS[value] ?? value;
+/** A source with stored records, even when its latest refresh failed. */
+const loadedSource = (c: PowerCoverage) => (c.status === "current" || c.status === "stale") && c.records > 0;
+const names = (rows: readonly PowerCoverage[]) => [...new Set(rows.map((c) => c.region === "EirGrid" ? "Ireland" : c.region))].join(", ");
+/**
+ * Which US grid operators' queues loaded, in plain words. Source errors and
+ * unsupported registers stay in the Coverage tab and on the server; a missing
+ * queue is a gap in coverage, never zero.
+ */
+export function powerCoverageNote(coverage: readonly PowerCoverage[]): string | null {
+  const queues = coverage.filter((c) => c.country === "US" && c.role === "direct" && c.kind === "queue");
+  const missing = queues.filter((c) => !loadedSource(c));
+  if (!missing.length) return null;
+  const loaded = queues.filter(loadedSource);
+  return `US queues: ${loaded.length ? `${names(loaded)} loaded; ` : ""}${names(missing)} not available`;
+}
+/**
+ * The registers carrying records right now, named, for a ticker that has none
+ * in them: grid operator and TSO registers, or the EIA filings behind the
+ * Capacity tab. Null when nothing is loaded.
+ */
+export function powerLoadedSources(tab: PowerTab, coverage: readonly PowerCoverage[]): string | null {
+  const loaded = coverage.filter((c) => loadedSource(c) && (tab === "capacity" ? c.role === "context" : c.role === "direct"));
+  if (!loaded.length) return null;
+  return tab === "capacity" ? "US EIA generation and utility filings" : names([...loaded.filter((c) => c.country === "US"), ...loaded.filter((c) => c.country !== "US")]);
+}
 export const titleCase = (value: string) => value.replace(/(^|[ _-])\w/g, (match) => match.toUpperCase());
 export const powerNumber = (n: number | null | undefined) => n == null ? "--" : n.toLocaleString("en-US", { maximumFractionDigits: 1 });
 export const powerPercent = (n: number | null) => n == null ? "--" : `${(n * 100).toFixed(1)}%`;
-const tickerLabel = (row: { entities: PowerProject["entities"] }) => [...new Set(row.entities.flatMap((e) => e.tickers.map((t) => t.ticker)))].join(", ") || "--";
+/** The listed companies a record names, or null when its register names none: the ticker map. */
+export const tickerLabel = (row: { entities: PowerProject["entities"] }) => [...new Set(row.entities.flatMap((e) => e.tickers.map((t) => t.ticker)))].join(", ") || null;
+/** What the ticker column says for a record no listed company is mapped to. */
+export const UNMAPPED = "unmapped";
+
+/** Where else a ticker's records can sit: each tab, and the capacity tab's contexts, with what they list. */
+const POWER_TICKER_SCOPES = [
+  { tab: "queue", context: "capacity", label: "interconnection queue records", view: "Queue" },
+  { tab: "loads", context: "capacity", label: "large-load requests", view: "Loads" },
+  { tab: "capacity", context: "capacity", label: "generation capacity records", view: "Capacity" },
+  { tab: "capacity", context: "generation", label: "monthly generation records", view: "Generation" },
+  { tab: "capacity", context: "utility", label: "utility sales records", view: "Utility sales" },
+] as const satisfies readonly { tab: PowerTab; context: string; label: string; view: string }[];
+/** `total` is null for a scope that did not answer, which is no evidence either way. */
+export type PowerTickerScope = (typeof POWER_TICKER_SCOPES)[number] & { total: number | null };
+const sameScope = (scope: { tab: string; context: string }, tab: PowerTab, context: string) =>
+  scope.tab === tab && (tab !== "capacity" || scope.context === context)
+  // Utilities are the large loads summed by utility: a ticker with no loads has no exposure either.
+  || tab === "utilities" && scope.tab === "loads";
+/** The scopes to count a ticker's records in when the open tab has none of them. */
+export const powerTickerScopes = (tab: PowerTab, context: string) => POWER_TICKER_SCOPES.filter((scope) => !sameScope(scope, tab, context));
+
+/** What the open tab lists, for the sentence that says none of it maps to a ticker. */
+function powerTabRecords(tab: PowerTab, context: string): string {
+  if (tab === "capacity") return POWER_TICKER_SCOPES.find((scope) => scope.tab === "capacity" && scope.context === context)?.label ?? "capacity records";
+  return { queue: "interconnection queue records", history: "queue history records", outcomes: "queue outcomes", loads: "large-load requests",
+    utilities: "large-load requests or utility exposure", prices: "records", coverage: "records" }[tab];
+}
+
+/**
+ * Why a ticker's tab is empty, and where its records are instead: the title
+ * says what does not map to it, the hint where it has records, or, once every
+ * other tab has answered with none, that a name search is what is left.
+ */
+export function powerTickerEmpty(symbol: string, tab: PowerTab, context: string, scopes: readonly PowerTickerScope[]) {
+  const found = scopes.filter((scope): scope is PowerTickerScope & { total: number } => (scope.total ?? 0) > 0);
+  const answered = scopes.length > 0 && scopes.every((scope) => scope.total != null);
+  return {
+    title: `No ${powerTabRecords(tab, context)} map to ${symbol}.`,
+    found,
+    hint: found.length ? `${symbol} has ${found.map((scope) => `${powerNumber(scope.total)} ${scope.label}`).join(", ")}.`
+      : answered ? `No power records map to ${symbol}; search by the company's or a subsidiary's name instead.` : null,
+  };
+}
+/** The options that open a scope from the command line. */
+export const powerScopeOptions = (scope: { tab: string; context: string }) =>
+  scope.tab === "capacity" && scope.context !== "capacity" ? `--tab capacity --context ${scope.context}` : `--tab ${scope.tab}`;
 const historyKey = (p: PowerHistoryPoint) => JSON.stringify([p.sourceId, p.country, p.region, p.kind, p.fuel, p.status, p.historical, p.basis]);
 /** Annual benchmarks use their stated period. Current queues use when we observed them, never a proposed completion date. */
 export function historyDate(p: PowerHistoryPoint): Date {

package/src/plugins/builtin/power/pane.tsx

@@ -2,25 +2,28 @@ import { useCallback, useEffect, useMemo, useRef } from "react";
 import type { PowerBoard, PowerFilter, PowerHistory } from "../../../api-client/power";
 import { isAccessDenied } from "../../../api-client/errors";
 import { usePlanAccess } from "../../../api-client/plan-access";
-import { ChartTableHeader, DataTableStackView, PaneStatusBody, QueryBar, useChartTableSelection, usePagedRows, usePaneNoticeFooter, usePaneStatusFooter, usePaneTabs, useQueryBarSearch, useTableLoadMore, type DataTableCell, type PaneHint, type QueryBarFilter } from "../../../components";
+import { Button, ChartTableHeader, DataTableStackView, EmptyState, PaneStatusBody, QueryBar, useChartTableSelection, usePagedRows, usePaneNoticeFooter, usePaneStatusFooter, usePaneTabs, useQueryBarSearch, useTableLoadMore, type DataTableCell, type PaneHint, type QueryBarFilter } from "../../../components";
 import { usePaneRefreshKey } from "../../../components/data-table/table-pane";
-import { useAutoRefresh, usePaneSettingValue, usePluginAppActions, usePluginPaneState } from "../../../public/react";
+import { useAsyncResource, useAutoRefresh, usePaneSettingValue, usePluginAppActions, usePluginPaneState } from "../../../public/react";
 import { useThemeColors } from "../../../theme/theme-context";
 import type { PaneProps } from "../../../types/plugin";
 import { Box, Text, TextAttributes, useRendererHost, useUiCapabilities, type ScrollBoxRenderable } from "../../../ui";
 import { publicTickerKey } from "../../../utils/exchanges";
 import { getSharedRegistry } from "../../registry/shared";
+import { usePaneInstance } from "../../../state/app/context";
 import { SignInWall } from "../cloud/auth-actions";
 import { CLOUD_PLAN_KEY, useCloudUpgradeAction } from "../shared/cloud-upgrade";
+import { useOpenDescription } from "../shared/open-description";
 import { Blurred, LockedOverlay, UpgradeLabel } from "../shared/locked-rows";
 import { isCloudSessionRequired, useResearchCloudSession } from "../shared/research-cloud-session";
-import { loadPowerBoard, loadPowerHistory, validatePowerBoard, validatePowerHistory } from "./client";
+import { fetchPowerTickerScopes, loadPowerBoard, loadPowerHistory, validatePowerBoard, validatePowerHistory } from "./client";
 import { usePowerEvidence } from "./evidence";
 import { POWER_SORT_COLUMNS, powerQuery } from "./query";
 import { PowerDetailView } from "./detail";
+import { PowerPricesView } from "./prices";
 import { blendHex } from "../../../theme/colors";
 import { missingCell, PartsBar, signedColor, toneColor, withoutQuietColumns, type StateTone } from "../shared/research-cells";
-import { COVERAGE_COLUMNS, EXPOSURE_COLUMNS, HISTORY_COLUMNS, GENERATION_COLUMNS, UTILITY_COLUMNS, POWER_TABS, PROJECT_COLUMNS, RATE_COLUMNS, historyDate, historyId, historySeries, otherRows, powerFigures, powerRegion, powerNumber, powerPercent, powerTab, projectRows, titleCase, type PowerRow } from "./model";
+import { COVERAGE_COLUMNS, EXPOSURE_COLUMNS, HISTORY_COLUMNS, GENERATION_COLUMNS, UTILITY_COLUMNS, POWER_TABS, PROJECT_COLUMNS, RATE_COLUMNS, historyDate, historyId, historySeries, otherRows, powerCoverageNote, powerFigures, powerLoadedSources, powerRegion, powerNumber, powerPercent, powerTab, powerTickerEmpty, projectRows, titleCase, UNMAPPED, type PowerRow, type PowerTickerScope } from "./model";
 
 const rowId = (r: PowerRow) => r.id;
 const isRecord = (r: PowerRow) => !r.section;
@@ -36,7 +39,11 @@ const UTILITY_SORT: typeof DEFAULT_SORT = { column: "salesMwh", direction: "desc
 export function PowerPane(props: PaneProps) {
   const session = useResearchCloudSession();
   const access = usePlanAccess();
+  const [openingTab] = usePaneSettingValue("tab", "queue");
+  const [savedTab] = usePluginPaneState("power:tab", openingTab);
   const scope = `${session.requestKey}:${access.hasProAccess ? "full" : "preview"}`;
+  // Prices are open data from another source: their own view, free and without the queue board.
+  if (powerTab(savedTab) === "prices") return <PowerPricesView {...props} />;
   return <PowerView key={scope} {...props} scope={scope} needsVerification={session.needsVerification} />;
 }
 function PowerView({ width, height, focused, scope, needsVerification }: PaneProps & { scope: string; needsVerification: boolean }) {
@@ -44,6 +51,7 @@ function PowerView({ width, height, focused, scope, needsVerification }: PanePro
   const host = useRendererHost();
   const desktop = !!useUiCapabilities().nativePaneChrome;
   const { createPaneFromTemplate } = usePluginAppActions();
+  const openDescription = useOpenDescription();
   const upgrade = useCloudUpgradeAction("power");
   const [openingTab] = usePaneSettingValue("tab", "queue");
   const [savedTab, setTab] = usePluginPaneState("power:tab", openingTab);
@@ -58,7 +66,10 @@ function PowerView({ width, height, focused, scope, needsVerification }: PanePro
   const [fuel, setFuel] = usePluginPaneState("power:fuel", initialFuel);
   const [initialStatus] = usePaneSettingValue("status", "");
   const [status, setStatus] = usePluginPaneState("power:status", initialStatus);
-  const [symbol] = usePaneSettingValue("symbol", "");
+  // `POWER VST` opens with the ticker in the instance params; a saved setting still wins.
+  const params = usePaneInstance()?.params;
+  const [settingSymbol] = usePaneSettingValue("symbol", "");
+  const symbol = settingSymbol || params?.symbol || "";
   const [initialHistorical] = usePaneSettingValue("historical", false);
   const [historical, setHistorical] = usePluginPaneState("power:historical", initialHistorical);
   const [initialContext] = usePaneSettingValue("context", "capacity");
@@ -73,8 +84,9 @@ function PowerView({ width, height, focused, scope, needsVerification }: PanePro
   const [selectedId, setSelectedId] = usePluginPaneState<string | null>(`power:selected:${tab}`, null);
   const [openId, setOpenId] = usePluginPaneState<string | null>(`power:open:${tab}`, null);
   const searchFocus = useQueryBarSearch();
-  const [snapshotSetting] = usePaneSettingValue<{ board: PowerBoard; history?: PowerHistory } | null>("powerSnapshot", null);
-  const snapshot = useMemo(() => { try { return snapshotSetting ? { board: validatePowerBoard(snapshotSetting.board), history: snapshotSetting.history ? validatePowerHistory(snapshotSetting.history) : undefined } : null; } catch { return null; } }, [snapshotSetting]);
+  const [snapshotSetting] = usePaneSettingValue<{ board: PowerBoard; history?: PowerHistory; tickerScopes?: PowerTickerScope[] } | null>("powerSnapshot", null);
+  const snapshot = useMemo(() => { try { return snapshotSetting ? { board: validatePowerBoard(snapshotSetting.board), history: snapshotSetting.history ? validatePowerHistory(snapshotSetting.history) : undefined,
+    tickerScopes: Array.isArray(snapshotSetting.tickerScopes) ? snapshotSetting.tickerScopes : null } : null; } catch { return null; } }, [snapshotSetting]);
   const projectTab = ["queue", "loads", "capacity"].includes(tab);
   const filter = useMemo(() => powerQuery({ tab, country, region, fuel, status, search, historical, context, loadClass, sourceId, from, to,
     sort: sort.column, direction: sort.direction }, symbol), [tab, country, region, fuel, status, search, historical, context, loadClass, sourceId, from, to, sort.column, sort.direction, symbol]);
@@ -106,6 +118,14 @@ function PowerView({ width, height, focused, scope, needsVerification }: PanePro
   usePowerEvidence(board, historyData?.payload, tab, rows.map((row) => row.id), pages.loading || historyPages.loading || historyPages.hasMore);
   const locked = board ? tab === "history" ? historyData?.payload.locked ?? 0 : tab === "outcomes" ? board.locked.rates : tab === "utilities" ? board.locked.exposure : projectTab ? board.locked.projects : 0 : 0;
   const items = useMemo(() => [...rows, ...Array.from({ length: Math.min(3, locked) }, (_, i): PowerRow => ({ id: `locked:${i}`, label: "Pro", cells: {}, locked: true }))], [rows, locked]);
+  // A ticker with nothing on this tab says where its records are instead, and opens them; a narrower filter is the filters' doing.
+  const narrowed = !!(country || region || fuel || status || search || loadClass || historical || sourceId || from || to);
+  const tickerEmpty = !!board && !!symbol && !narrowed && tab !== "coverage" && !items.length && !pages.loading && !historyPages.loading;
+  const scopesLoader = useCallback(() => fetchPowerTickerScopes(symbol, tab, context), [symbol, tab, context]);
+  const scopes = useAsyncResource(tickerEmpty && !snapshot ? scopesLoader : null);
+  const tickerScopes = snapshot ? snapshot.tickerScopes : scopes.data;
+  const tickerMessage = tickerEmpty ? powerTickerEmpty(symbol, tab, context, tickerScopes ?? []) : null;
+  const loadedSources = tickerEmpty && board ? powerLoadedSources(tab, board.coverage) : null;
   const selected = rows.find((r) => r.id === selectedId && isRecord(r)) ?? rows.find(isRecord);
   const openRow = rows.find((r) => r.id === openId);
   const scrollRef = useRef<ScrollBoxRenderable>(null);
@@ -120,7 +140,7 @@ function PowerView({ width, height, focused, scope, needsVerification }: PanePro
   const hints: PaneHint[] = [
     ...(sourceUrl ? [{ id: "source", key: "o", label: "pen source", onPress: () => void host.openExternal(sourceUrl) }] : []),
     ...(tickerKey ? [
-      { id: "description", key: "d", label: "es", onPress: () => navigate("new-ticker-detail-pane") },
+      { id: "description", key: "d", label: "es", onPress: () => openDescription(tickerKey) },
       { id: "financials", key: "f", label: "a", onPress: () => navigate("financial-analysis-pane") },
       { id: "chart", key: "g", label: "raph", onPress: () => createPaneFromTemplate("chart-composer-pane", { arg: tickerKey }) },
       { id: "supply", key: "s", label: "plc", onPress: () => navigate("supply-chain-pane") },
@@ -134,8 +154,9 @@ function PowerView({ width, height, focused, scope, needsVerification }: PanePro
     error: board ? error : null, stale: pages.pages.some((p) => p.stale) || historyData?.stale,
     info: [...(pages.loadingMore || historyPages.loadingMore ? [{ id: "more", parts: [{ text: "loading more", tone: "muted" as const }] }] : []),
       ...(active?.project ? [{ id: "as-of", parts: [{ text: active.project.asOf ? `as of ${active.project.asOf}` : `observed ${active.project.observedAt.slice(0, 10)}`, tone: "muted" as const }] }] : [])], hints });
+  // Unavailable queues are a coverage gap in plain words; per-source reasons live on the Coverage tab.
   const notices = [pages.moreError?.message, historyPages.moreError?.message, ...pages.pages.map((p) => p.refreshError), historyData?.refreshError,
-    ...(board?.coverage.filter((c) => c.status !== "current").map((c) => `${powerRegion(c.region)} ${titleCase(c.kind)}: ${c.status}${c.reason ? ` · ${c.reason}` : ""}`) ?? [])].filter((v): v is string => !!v);
+    board && tab !== "capacity" ? powerCoverageNote(board.coverage) : null].filter((v): v is string => !!v);
   usePaneNoticeFooter({ registrationId: "power:notices", focused, notices: [...new Set(notices)], enabled: !openRow });
   const { strip, rows: tabRows } = usePaneTabs(board ? { tabs: [...POWER_TABS], activeValue: tab, onSelect: setTab, focused, dense: true } : null);
   const baseColumns = tab === "capacity" && context === "generation" ? GENERATION_COLUMNS : tab === "capacity" && context === "utility" ? UTILITY_COLUMNS : projectTab ? PROJECT_COLUMNS : tab === "history" ? HISTORY_COLUMNS : tab === "outcomes" ? RATE_COLUMNS : tab === "utilities" ? EXPOSURE_COLUMNS : COVERAGE_COLUMNS;
@@ -174,6 +195,8 @@ function PowerView({ width, height, focused, scope, needsVerification }: PanePro
       { id: "operating", value: e.operatingMw, color: colors.positive }, { id: "approved", value: Math.max(0, e.approvedMw - e.operatingMw), color: blendHex(colors.bg, colors.borderFocused, 0.55) },
       { id: "requested", value: Math.max(0, e.requestedMw - Math.max(e.approvedMw, e.operatingMw)), color: blendHex(colors.bg, colors.textDim, 0.4) }]} /> }; }
     const value = row.cells[column.id];
+    // The ticker map: a record no listed company is mapped to says so.
+    if (column.id === "ticker" && value == null && (row.project || row.exposure)) return { text: UNMAPPED, color: colors.textMuted };
     if (value == null || value === "") return missingCell(colors);
     const text = typeof value === "number" ? /Rate$/.test(column.id) ? powerPercent(value) : powerNumber(value) : String(value);
     const numeric = typeof value === "number" && /Rate$/.test(column.id) ? value * 100 : value;
@@ -202,6 +225,11 @@ function PowerView({ width, height, focused, scope, needsVerification }: PanePro
           chart={tab === "history" ? { series, ...chartLink, formatValue: (n) => `${powerNumber(n)} MW`, loading: historyPages.loading || historyPages.hasMore && !historyPages.moreError,
             empty: series.length ? undefined : historyPages.moreError ? "Full history could not load. Refresh to retry." : historyData?.payload.access === "preview" ? "Full history is available with Pro." : "History is accumulating from recorded snapshots.", remoteKind: "power-history" } : null} />}
         emptyStateTitle={tab === "history" ? historyPages.error?.message ?? "No recorded history for these filters." : "No reported records match these filters."}
+        emptyContent={tickerMessage ? <Box paddingX={1} paddingY={1}>
+          <EmptyState title={tickerMessage.title} hint={[tickerMessage.hint, loadedSources ? `Sources loaded now: ${loadedSources}.` : null].filter(Boolean).join(" ") || undefined}
+            actions={tickerMessage.found.length ? tickerMessage.found.map((scope) => <Button key={`${scope.tab}:${scope.context}`} label={`Open ${scope.view}`}
+              onPress={() => { if (scope.tab === "capacity") setContext(scope.context); setTab(scope.tab); }} />) : undefined} />
+        </Box> : undefined}
         bodyAfter={locked && desktop ? <LockedOverlay rows={Math.min(3, locked)} text="Unlock full power data with Pro" onPress={upgrade} role="power-upgrade" /> : undefined}
       /> : null}
     </PaneStatusBody>

package/src/plugins/builtin/power/prices-client.ts

@@ -0,0 +1,139 @@
+import { apiClient } from "../../../api-client";
+import type { CarbonBoard, CarbonHistory, EuropePowerBoard, EuropePowerHistory, PowerPriceRow } from "../../../api-client/europe-energy";
+import { createPluginCache } from "../../../data/plugin-cache";
+import { cachedCloudResource, loadCloudResource, unavailableOnServer } from "../shared/cloud-resource";
+
+/** What the tab and the series say while the server has no prices to serve: before the backend ships, or before its first read. */
+export const POWER_PRICES_NOT_AVAILABLE = "European power prices are not available yet.";
+const CARBON_PRICE_NOT_AVAILABLE = "The EU carbon auction price is not available yet.";
+
+// Daily data, rewritten once a day: a quarter hour is soon enough to catch it.
+const policy = { staleMs: 15 * 60_000, expireMs: 14 * 86_400_000 };
+export const powerPricesCache = createPluginCache<EuropePowerBoard>({ kind: "europe-power-board", source: "gloom-cloud", schemaVersion: 1, policy });
+export const powerPriceHistoryCache = createPluginCache<EuropePowerHistory>({ kind: "europe-power-history", source: "gloom-cloud", schemaVersion: 1, policy });
+export const carbonPriceCache = createPluginCache<CarbonBoard>({ kind: "europe-carbon-board", source: "gloom-cloud", schemaVersion: 1, policy });
+export const carbonHistoryCache = createPluginCache<CarbonHistory>({ kind: "europe-carbon-history", source: "gloom-cloud", schemaVersion: 1, policy });
+
+const record = (v: unknown): v is Record<string, any> => !!v && typeof v === "object" && !Array.isArray(v);
+const text = (v: unknown): v is string => typeof v === "string";
+const finite = (v: unknown): v is number => typeof v === "number" && Number.isFinite(v);
+const date = (v: unknown) => text(v) && /^\d{4}-\d{2}-\d{2}$/.test(v) && new Date(`${v}T00:00:00Z`).toISOString().slice(0, 10) === v;
+const dateOrNull = (v: unknown) => v === null || date(v);
+const finiteOrNull = (v: unknown) => v === null || finite(v);
+const instantOrNull = (v: unknown) => v === null || text(v) && Number.isFinite(Date.parse(v));
+const source = (v: unknown) => record(v) && text(v.name) && text(v.licence) && text(v.url);
+const publisher = (v: unknown) => record(v) && text(v.name) && text(v.url);
+const nullableText = (v: unknown) => v === null || text(v);
+const nonnegativeOrNull = (v: unknown) => v === null || finite(v) && v >= 0;
+const points = (v: unknown) => Array.isArray(v) && v.every((p) => record(p) && date(p.date) && finite(p.value));
+
+function validRow(row: PowerPriceRow, code = /^[A-Z]{2}$/): boolean {
+  return record(row) && code.test(row.code) && text(row.name) && dateOrNull(row.date) && finiteOrNull(row.price)
+    && (row.price == null) === (row.date == null) && dateOrNull(row.previousDate) && dateOrNull(row.yearAgoDate)
+    && [row.change, row.average7, row.average30, row.yearAgo, row.low52w, row.high52w].every(finiteOrNull) && points(row.trail);
+}
+
+/** A board that breaks the contract is refused whole rather than drawn with holes in it. */
+export function validatePowerPrices(data: EuropePowerBoard): EuropePowerBoard {
+  if (!record(data) || !text(data.generatedAt) || !instantOrNull(data.generatedAt) || !["available", "unavailable"].includes(data.status)
+    || data.market !== "day-ahead" || data.unit !== "EUR/MWh" || !source(data.source)
+    || !instantOrNull(data.checkedAt) || !instantOrNull(data.publishedAt)
+    || !Array.isArray(data.gaps) || !data.gaps.every(text)
+    || !Array.isArray(data.rows) || !data.rows.every((row) => validRow(row)) || new Set(data.rows.map((row) => row.code)).size !== data.rows.length) {
+    throw new Error("The server returned unreadable power prices.");
+  }
+  return data;
+}
+
+function validateHistory(data: EuropePowerHistory): EuropePowerHistory {
+  if (!record(data) || !/^[A-Z]{2}$/.test(data.code) || !text(data.name) || data.unit !== "EUR/MWh" || !source(data.source) || !points(data.points)) {
+    throw new Error("The server returned unreadable power price history.");
+  }
+  return data;
+}
+
+/** An EUA board that breaks the contract is refused whole. */
+export function validateCarbonPrice(data: CarbonBoard): CarbonBoard {
+  const row = data?.row;
+  if (!record(data) || !text(data.generatedAt) || !instantOrNull(data.generatedAt) || !["available", "unavailable"].includes(data.status)
+    || data.market !== "primary auction" || data.unit !== "EUR/tCO2" || !publisher(data.source)
+    || !instantOrNull(data.checkedAt) || !instantOrNull(data.publishedAt) || !Array.isArray(data.gaps) || !data.gaps.every(text)
+    || !record(row) || !validRow(row, /^EUA$/) || !nonnegativeOrNull(row.volume) || !nonnegativeOrNull(row.auctions)
+    || !Array.isArray(data.auctions) || !data.auctions.every((a) => record(a) && date(a.date) && text(a.auction) && text(a.contract) && text(a.status)
+      && nullableText(a.zone) && [a.price, a.minBid, a.maxBid, a.meanBid, a.medianBid].every(finiteOrNull) && finite(a.volume)
+      && [a.coverRatio, a.bidders, a.successfulBidders].every(nonnegativeOrNull) && typeof a.aviation === "boolean")) {
+    throw new Error("The server returned an unreadable EU carbon price.");
+  }
+  return data;
+}
+
+function validateCarbonHistory(data: CarbonHistory): CarbonHistory {
+  if (!record(data) || data.code !== "EUA" || data.unit !== "EUR/tCO2" || !publisher(data.source) || !points(data.points)) {
+    throw new Error("The server returned an unreadable EU carbon price history.");
+  }
+  return data;
+}
+
+type PricesApi = Pick<typeof apiClient, "getCloudEuropePower" | "getCloudEuropePowerHistory" | "getCloudEuropeCarbon" | "getCloudEuropeCarbonHistory">;
+
+/**
+ * The board, or the not-available message when the server does not serve the
+ * route yet (404), cannot read its tables (503) or has no days stored.
+ */
+export async function fetchPowerPrices(client: Pick<PricesApi, "getCloudEuropePower"> = apiClient): Promise<EuropePowerBoard> {
+  let board: EuropePowerBoard;
+  try {
+    board = validatePowerPrices(await client.getCloudEuropePower());
+  } catch (error) {
+    throw unavailableOnServer(error, POWER_PRICES_NOT_AVAILABLE, [404, 503]);
+  }
+  if (board.status === "unavailable") throw new Error(POWER_PRICES_NOT_AVAILABLE);
+  return board;
+}
+
+/** One market's days from `from`, all of them without one. */
+export async function fetchPowerPriceHistory(
+  code: string, from?: string | null, client: Pick<PricesApi, "getCloudEuropePowerHistory"> = apiClient,
+): Promise<EuropePowerHistory> {
+  try {
+    return validateHistory(await client.getCloudEuropePowerHistory(code, from));
+  } catch (error) {
+    throw unavailableOnServer(error, POWER_PRICES_NOT_AVAILABLE, [404, 503]);
+  }
+}
+
+/** The EUA board, or the not-available message before the server serves it or has an auction stored. */
+export async function fetchCarbonPrice(client: Pick<PricesApi, "getCloudEuropeCarbon"> = apiClient): Promise<CarbonBoard> {
+  let board: CarbonBoard;
+  try {
+    board = validateCarbonPrice(await client.getCloudEuropeCarbon());
+  } catch (error) {
+    throw unavailableOnServer(error, CARBON_PRICE_NOT_AVAILABLE, [404, 503]);
+  }
+  if (board.status === "unavailable") throw new Error(CARBON_PRICE_NOT_AVAILABLE);
+  return board;
+}
+
+/** The daily EUA price from `from`, every auction day since 2020 without one. */
+export async function fetchCarbonHistory(
+  from?: string | null, client: Pick<PricesApi, "getCloudEuropeCarbonHistory"> = apiClient,
+): Promise<CarbonHistory> {
+  try {
+    return validateCarbonHistory(await client.getCloudEuropeCarbonHistory(from));
+  } catch (error) {
+    throw unavailableOnServer(error, CARBON_PRICE_NOT_AVAILABLE, [404, 503]);
+  }
+}
+
+export const getCachedPowerPrices = () => cachedCloudResource(powerPricesCache, "board", validatePowerPrices);
+export const loadPowerPrices = (force = false) =>
+  loadCloudResource(powerPricesCache, "board", () => fetchPowerPrices(), { force, validate: validatePowerPrices });
+export const getCachedCarbonPrice = () => cachedCloudResource(carbonPriceCache, "board", validateCarbonPrice);
+export const loadCarbonPrice = (force = false) =>
+  loadCloudResource(carbonPriceCache, "board", () => fetchCarbonPrice(), { force, validate: validateCarbonPrice });
+/** Every auction day of the EUA since 2020. */
+export const loadCarbonHistory = (force = false) =>
+  loadCloudResource(carbonHistoryCache, "EUA", () => fetchCarbonHistory(), { force, validate: validateCarbonHistory });
+/** The whole history of one market, cached per market. */
+export const loadPowerPriceHistory = (code: string, force = false) =>
+  loadCloudResource(powerPriceHistoryCache, code, () => fetchPowerPriceHistory(code), { force, validate: validateHistory });