gloomberb 0.16.5 → 0.16.6

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

@@ -3,6 +3,8 @@ import type { HeadlessPaneColumn, HeadlessPaneDefinition, HeadlessPaneRow } from
 import { withoutQuietColumns } from "../shared/research-cells";
 import { fetchPowerBoard, fetchAllPowerHistory, fetchPowerTickerScopes } from "./client";
 import { powerQuery } from "./query";
+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,
@@ -47,18 +49,20 @@ export const powerHeadless: HeadlessPaneDefinition<"bundle"> = {
   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];

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

@@ -2,8 +2,14 @@ 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",
@@ -13,7 +19,23 @@ export const powerModule: PluginModule = {
     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 [powerBoardCache, powerHistoryCache, powerDetailCache]) cache.attach(ctx.persistence); },
-  dispose() { for (const cache of [powerBoardCache, powerHistoryCache, powerDetailCache]) cache.reset(); },
+  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,7 +2,7 @@ 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" };
@@ -62,7 +62,7 @@ export const powerTickerScopes = (tab: PowerTab, context: string) => POWER_TICKE
 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", coverage: "records" }[tab];
+    utilities: "large-load requests or utility exposure", prices: "records", coverage: "records" }[tab];
 }
 
 /**

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

@@ -20,6 +20,7 @@ import { fetchPowerTickerScopes, loadPowerBoard, loadPowerHistory, validatePower
 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, powerCoverageNote, powerFigures, powerLoadedSources, powerRegion, powerNumber, powerPercent, powerTab, powerTickerEmpty, projectRows, titleCase, UNMAPPED, type PowerRow, type PowerTickerScope } from "./model";
@@ -38,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 }) {

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 });

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

@@ -0,0 +1,137 @@
+import { apiClient } from "../../../api-client";
+import type { CarbonBoard, EuropePowerBoard, PowerPriceRow } from "../../../api-client/europe-energy";
+import type { HeadlessBundleResult, HeadlessBundleSection, HeadlessPaneColumn, HeadlessPaneDefinition } from "../../../types/plugin";
+import { fetchCarbonPrice, fetchPowerPriceHistory, fetchPowerPrices } from "./prices-client";
+import {
+  CARBON_PRICE_UNIT, formatPowerChange, formatPowerPrice, isCarbonQuery, POWER_PRICE_UNIT, powerPriceMarket, powerRangePosition,
+} from "./prices-model";
+
+type PricesClient = Pick<typeof apiClient, "getCloudEuropePower" | "getCloudEuropePowerHistory" | "getCloudEuropeCarbon">;
+
+const price = (value: unknown) => typeof value === "number" ? formatPowerPrice(value) : "--";
+const text = (value: unknown) => typeof value === "string" && value ? value : "--";
+
+/** A board's columns, in its words: prices to the cent in the board's unit, each row dated by its own day. */
+const boardColumns = (unit: string, label = "Market"): HeadlessPaneColumn[] => [
+  { key: "market", header: label },
+  { key: "date", header: "As of", format: text, shrink: false },
+  { key: "price", header: unit, align: "right", format: price },
+  { key: "change", header: "1D", align: "right", format: (value) => typeof value === "number" ? formatPowerChange(value) : "--" },
+  { key: "average7", header: "7D avg", align: "right", format: price },
+  { key: "average30", header: "30D avg", align: "right", format: price },
+  { key: "yearAgo", header: "1Y ago", align: "right", format: price },
+  { key: "low52w", header: "52W low", align: "right", format: price },
+  { key: "high52w", header: "52W high", align: "right", format: price },
+  { key: "range", header: "In 1Y range", align: "right", format: (value) => typeof value === "number" ? `${value}%` : "--" },
+];
+const COLUMNS = boardColumns(POWER_PRICE_UNIT);
+const AUCTION_COLUMNS: HeadlessPaneColumn[] = [
+  { key: "date", header: "Date", shrink: false },
+  { key: "zone", header: "Zone", format: text },
+  { key: "status", header: "Status" },
+  { key: "price", header: CARBON_PRICE_UNIT, align: "right", format: price },
+  { key: "volume", header: "Volume tCO2", align: "right", format: (value) => typeof value === "number" ? value.toLocaleString("en-US") : "--" },
+  { key: "coverRatio", header: "Cover", align: "right", format: (value) => typeof value === "number" ? `${value.toFixed(2)}x` : "--" },
+  { key: "bidders", header: "Bidders", align: "right", format: (value) => typeof value === "number" ? String(value) : "--" },
+];
+
+function reportRow(row: Omit<PowerPriceRow, "code"> & { code: string }) {
+  const { trail: _trail, name, ...figures } = row;
+  return { market: name, ...figures, range: powerRangePosition(row as PowerPriceRow) };
+}
+
+/** The EUA as of its latest auction day, then its latest general-allowance auctions. */
+function carbonSections(carbon: CarbonBoard): HeadlessBundleSection[] {
+  const { volume: _volume, auctions: _auctions, ...row } = carbon.row;
+  return [
+    { title: `EU carbon allowance (EUA) auction price, ${CARBON_PRICE_UNIT}`, columns: boardColumns(CARBON_PRICE_UNIT, "Allowance"), rows: [reportRow(row)] },
+    { title: "Latest EUA auctions", columns: AUCTION_COLUMNS,
+      rows: carbon.auctions.filter((auction) => !auction.aviation).map(({ aviation: _aviation, ...auction }) => ({ ...auction })) },
+  ];
+}
+
+/**
+ * The delivery day most markets have reached: the median market's latest
+ * day. A few markets publish ahead of the rest (Ireland the day before, most
+ * of the continent four days behind), so the freshest one would understate
+ * how far behind the board is.
+ */
+function typicalPowerDate(rows: readonly Pick<PowerPriceRow, "date">[]): string | null {
+  const dates = rows.flatMap((row) => row.date ? [row.date] : []).sort();
+  return dates[Math.floor((dates.length - 1) / 2)] ?? null;
+}
+
+/**
+ * One short line, the same in the report, the pane and a capture: the board
+ * is dated by the day most markets have reached and lags from it (`most
+ * markets 2026-10-07 · lag 4 days`); one market by its own delivery day; the
+ * EUA alone by its last auction.
+ */
+function freshness(board: EuropePowerBoard | null, carbon: CarbonBoard | null, market?: PowerPriceRow): HeadlessBundleResult["freshness"] {
+  const asOf = market ? market.date : board ? typicalPowerDate(board.rows) : carbon?.row.date ?? null;
+  return {
+    source: [board?.source.name, carbon?.source.name].filter(Boolean).join(", "),
+    asOf, oldest: null,
+    observation: market ? "delivery day" : board ? "most markets" : "last auction",
+    status: "not-a-feed", observedKey: "date", basis: board ? "day-ahead auction" : "primary auction", dataset: true,
+  };
+}
+
+const failure = (error: unknown) => error instanceof Error ? error.message : String(error);
+
+/**
+ * Every market's latest day-ahead price and the EUA auction price; one
+ * market's figures and its last 30 delivery days when a market is named; the
+ * EUA and its latest auctions for EUA (or carbon).
+ */
+export async function loadPowerPricesReport(argument: string | undefined, client: PricesClient = apiClient): Promise<HeadlessBundleResult> {
+  if (isCarbonQuery(argument)) {
+    const carbon = await fetchCarbonPrice(client);
+    return { sections: carbonSections(carbon), notes: [...carbon.gaps], freshness: freshness(null, carbon),
+      metadata: { market: carbon.market, unit: carbon.unit, source: carbon.source, publishedAt: carbon.publishedAt, series: "CAP:carbon:eua" } };
+  }
+  const board = await fetchPowerPrices(client);
+  const notes = [...board.gaps];
+  if (argument?.trim()) {
+    const market = powerPriceMarket(argument);
+    const row = market ? board.rows.find((entry) => entry.code === market.code) : null;
+    if (!market || !row) throw new Error(`No day-ahead price for "${argument.trim()}". Use a market such as DE, FR, GB or Spain, or EUA.`);
+    const history = await fetchPowerPriceHistory(market.code, null, client);
+    return {
+      sections: [
+        { title: `${market.name} day-ahead power, ${POWER_PRICE_UNIT}`, columns: COLUMNS, rows: [reportRow(row)] },
+        { title: `${market.name}, last 30 delivery days`,
+          columns: [{ key: "date", header: "Date", shrink: false }, { key: "price", header: POWER_PRICE_UNIT, align: "right", format: price }],
+          rows: history.points.slice(-30).reverse().map((point) => ({ date: point.date, price: point.value })) },
+      ],
+      notes, freshness: freshness(board, null, row),
+      metadata: { market: board.market, unit: board.unit, source: board.source, publishedAt: board.publishedAt, row, series: `CAP:day-ahead:${market.code.toLowerCase()}` },
+    };
+  }
+  // The carbon allowance rides along; when it cannot load, the power board still reports and says so.
+  const carbon = await fetchCarbonPrice(client).catch((error: unknown) => failure(error));
+  return {
+    sections: [{ title: `Day-ahead power, ${POWER_PRICE_UNIT}`, columns: COLUMNS, rows: board.rows.map(reportRow) },
+      ...(typeof carbon === "string" ? [] : carbonSections(carbon))],
+    notes: [...notes, ...(typeof carbon === "string" ? [carbon] : carbon.gaps)],
+    freshness: freshness(board, typeof carbon === "string" ? null : carbon),
+    metadata: { market: board.market, unit: board.unit, source: board.source, publishedAt: board.publishedAt,
+      ...(typeof carbon === "string" ? {} : { carbon: { market: carbon.market, unit: carbon.unit, source: carbon.source, publishedAt: carbon.publishedAt } }) },
+  };
+}
+
+export const powerPricesHeadless: HeadlessPaneDefinition<"bundle"> = {
+  shape: "bundle",
+  argument: { kind: "free-text", optional: true, placeholder: "market", description: "A market such as DE, FR, GB or Spain, or EUA for the carbon auctions; omit for every market and the EUA." },
+  options: [],
+  freshness: { source: "Ember", status: "not-a-feed", basis: "day-ahead auction", dataset: true },
+  discovery: { aliases: ["EPWR"], dataRequirements: ["Gloom Cloud European power and carbon prices"],
+    limitations: ["Daily averages of the day-ahead auction, weighted by load, per country; not intraday or forward prices",
+      "Each market is dated by its own latest delivery day: continental markets usually trail by a few days",
+      "The EUA price is the primary auction clearing price on business days, volume-weighted across a day's auctions; not a futures settlement"] },
+  describe: "European day-ahead power prices by country (EUR/MWh) and the EU carbon allowance auction price (EUR/tCO2)",
+  async load(args, ctx) {
+    const argument = Array.isArray(args.argument) ? args.argument.join(" ") : args.argument ?? undefined;
+    return loadPowerPricesReport(argument, ctx.apiClient);
+  },
+};

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

@@ -0,0 +1,103 @@
+import type { PowerPriceRow } from "../../../api-client/europe-energy";
+import type { SeriesDefinition } from "../../../series/types";
+import { fetchCarbonHistory, fetchPowerPriceHistory } from "./prices-client";
+
+/**
+ * The markets the server serves day-ahead prices for, by ISO 3166 alpha-2
+ * code, known before the board loads so the data catalog can list them. Great
+ * Britain is its own market; Northern Ireland trades with Ireland.
+ */
+export const POWER_PRICE_MARKETS = [
+  { code: "AL", name: "Albania" }, { code: "AT", name: "Austria" }, { code: "BE", name: "Belgium" },
+  { code: "BG", name: "Bulgaria" }, { code: "HR", name: "Croatia" }, { code: "CZ", name: "Czechia" },
+  { code: "DK", name: "Denmark" }, { code: "EE", name: "Estonia" }, { code: "FI", name: "Finland" },
+  { code: "FR", name: "France" }, { code: "DE", name: "Germany" }, { code: "GB", name: "Great Britain" },
+  { code: "GR", name: "Greece" }, { code: "HU", name: "Hungary" }, { code: "IE", name: "Ireland" },
+  { code: "IT", name: "Italy" }, { code: "LV", name: "Latvia" }, { code: "LT", name: "Lithuania" },
+  { code: "LU", name: "Luxembourg" }, { code: "ME", name: "Montenegro" }, { code: "NL", name: "Netherlands" },
+  { code: "MK", name: "North Macedonia" }, { code: "NO", name: "Norway" }, { code: "PL", name: "Poland" },
+  { code: "PT", name: "Portugal" }, { code: "RO", name: "Romania" }, { code: "RS", name: "Serbia" },
+  { code: "SK", name: "Slovakia" }, { code: "SI", name: "Slovenia" }, { code: "ES", name: "Spain" },
+  { code: "SE", name: "Sweden" }, { code: "CH", name: "Switzerland" },
+] as const;
+
+export type PowerPriceMarket = (typeof POWER_PRICE_MARKETS)[number];
+
+/** Words a market goes by besides its name and code. */
+const ALIASES: Readonly<Record<string, string>> = {
+  UK: "GB", "UNITED KINGDOM": "GB", BRITAIN: "GB", ENGLAND: "GB", GBR: "GB",
+  DEU: "DE", FRA: "FR", NLD: "NL", BEL: "BE", ESP: "ES", ITA: "IT", AUT: "AT", CHE: "CH", POL: "PL", IRL: "IE",
+  "CZECH REPUBLIC": "CZ", HOLLAND: "NL",
+};
+
+/** A typed market: its code (DE), alpha-3 code (DEU), name (germany) or a common alias (UK). */
+export function powerPriceMarket(input: string | null | undefined): PowerPriceMarket | null {
+  const key = input?.trim().toUpperCase().replace(/\s+/g, " ") ?? "";
+  if (!key) return null;
+  const code = ALIASES[key] ?? key;
+  return POWER_PRICE_MARKETS.find((market) => market.code === code || market.name.toUpperCase() === key) ?? null;
+}
+
+export const CARBON_PRICE_UNIT = "EUR/tCO2";
+/** The Prices tab's selection when the band charts the carbon allowance instead of a market. */
+export const CARBON_SELECTION = "EUA";
+/** What `EPWR EUA` (or carbon, EU ETS, CO2) asks for: the carbon allowance instead of a market. */
+const CARBON_WORDS = new Set(["EUA", "EUAS", "CARBON", "EU CARBON", "EU ETS", "ETS", "CO2", "EU ALLOWANCE", "EU ALLOWANCES"]);
+export const isCarbonQuery = (input: string | null | undefined) =>
+  CARBON_WORDS.has(input?.trim().toUpperCase().replace(/[-\s]+/g, " ") ?? "");
+
+/** Germany is the benchmark market a trader reads first. */
+export const DEFAULT_PRICE_MARKET = "DE";
+
+export const POWER_PRICE_UNIT = "EUR/MWh";
+export const formatPowerPrice = (value: number | null | undefined) => value == null ? "--" : value.toFixed(2);
+export const formatPowerChange = (value: number | null | undefined) =>
+  value == null ? "--" : `${value > 0 ? "+" : ""}${value.toFixed(2)}`;
+/** Where the latest price sits in its 52-week range, 0 at the low and 100 at the high. */
+export function powerRangePosition(row: PowerPriceRow): number | null {
+  if (row.price == null || row.low52w == null || row.high52w == null || row.high52w <= row.low52w) return null;
+  return Math.round(((row.price - row.low52w) / (row.high52w - row.low52w)) * 100);
+}
+const DAY_AHEAD_PAGE_URL = "https://ember-energy.org/data/european-wholesale-electricity-price-data/";
+
+/** The benchmark markets a search lists first; the rest follow by name. */
+const LEAD_MARKETS = ["DE", "FR", "GB", "NL", "BE", "IT", "ES"];
+const leadRank = (code: string) => (LEAD_MARKETS.indexOf(code) + LEAD_MARKETS.length + 1) % (LEAD_MARKETS.length + 1);
+
+/** Each market's daily day-ahead price, as `CAP:day-ahead:de`. */
+export const DAY_AHEAD_SERIES: readonly SeriesDefinition[] = [...POWER_PRICE_MARKETS].sort((left, right) =>
+  leadRank(left.code) - leadRank(right.code)).map((market): SeriesDefinition => ({
+  id: `day-ahead:${market.code.toLowerCase()}`,
+  name: `${market.name} day-ahead power price`,
+  unit: POWER_PRICE_UNIT,
+  frequency: "daily",
+  group: "Energy",
+  tags: ["electricity", "power price", "day-ahead", "wholesale", "Europe", market.code, ...(market.code === "GB" ? ["UK"] : [])],
+  description: `Daily average of the ${market.name} day-ahead auction price, weighted by load, in euros per MWh.`,
+  publisher: "Ember",
+  url: DAY_AHEAD_PAGE_URL,
+  load: async ({ start }) => {
+    const history = await fetchPowerPriceHistory(market.code, start?.toISOString().slice(0, 10));
+    return history.points;
+  },
+}));
+
+/**
+ * The EU carbon allowance price, as `CAP:carbon:eua`: each business day's
+ * primary auction clearing price, volume-weighted across that day's auctions.
+ */
+export const CARBON_SERIES: readonly SeriesDefinition[] = [{
+  id: "carbon:eua",
+  name: "EU carbon allowance (EUA) auction price",
+  unit: CARBON_PRICE_UNIT,
+  frequency: "daily",
+  group: "Energy",
+  tags: ["carbon", "EU carbon", "EUA", "EU ETS", "carbon price", "carbon allowance", "emission allowances", "emissions", "CO2", "Europe"],
+  description: "Clearing price of each business day's EU ETS primary auctions of general allowances, volume-weighted, in euros per tonne of CO2. An auction price, not a futures settlement.",
+  publisher: "EEX",
+  url: "https://www.eex.com/en/markets/environmental-markets/emissions-auctions",
+  load: async ({ start }) => {
+    const history = await fetchCarbonHistory(start?.toISOString().slice(0, 10));
+    return history.points;
+  },
+}];