@iflow-mcp/kitfunso-luminus 0.2.0

package/dist/tools/energi-data.js

@@ -0,0 +1,170 @@
+import { z } from "zod";
+import { TtlCache, TTL } from "../lib/cache.js";
+const API_BASE = "https://api.energidataservice.dk/dataset";
+const cache = new TtlCache();
+const DATASETS = [
+    "co2_emissions",
+    "electricity_production",
+    "electricity_prices",
+    "electricity_balance",
+];
+export const energiDataSchema = z.object({
+    dataset: z
+        .enum(DATASETS)
+        .describe('"co2_emissions" = real-time CO2 emissions intensity for DK1/DK2 (gCO2/kWh). ' +
+        '"electricity_production" = Danish electricity production by source (MW). ' +
+        '"electricity_prices" = day-ahead spot prices for DK1/DK2 (DKK & EUR/MWh). ' +
+        '"electricity_balance" = production, consumption, import/export balance.'),
+    zone: z
+        .enum(["DK1", "DK2", "DK"])
+        .optional()
+        .describe("DK1 = West Denmark, DK2 = East Denmark, DK = both. Defaults to DK."),
+    date: z
+        .string()
+        .optional()
+        .describe("Date in YYYY-MM-DD format. Defaults to today."),
+});
+const DATASET_NAMES = {
+    co2_emissions: "CO2Emis",
+    electricity_production: "ElectricityProdex5MinRealtime",
+    electricity_prices: "Elspotprices",
+    electricity_balance: "ElectricityBalanceNonv",
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function fetchEnergiData(datasetName, filter, limit = 48) {
+    const url = `${API_BASE}/${datasetName}?limit=${limit}&offset=0&sort=Minutes5UTC%20DESC` +
+        `&filter=${encodeURIComponent(filter)}`;
+    const cached = cache.get(url);
+    if (cached)
+        return cached.records;
+    const response = await fetch(url, {
+        headers: { Accept: "application/json" },
+    });
+    if (!response.ok) {
+        // Try alternative sort column
+        const altUrl = `${API_BASE}/${datasetName}?limit=${limit}&offset=0&sort=HourUTC%20DESC` +
+            `&filter=${encodeURIComponent(filter)}`;
+        const altResponse = await fetch(altUrl, {
+            headers: { Accept: "application/json" },
+        });
+        if (!altResponse.ok) {
+            const body = await altResponse.text();
+            throw new Error(`Energi Data Service returned ${altResponse.status}: ${body.slice(0, 300)}`);
+        }
+        const altJson = await altResponse.json();
+        cache.set(url, altJson, TTL.REALTIME);
+        return altJson.records ?? [];
+    }
+    const json = await response.json();
+    cache.set(url, json, TTL.REALTIME);
+    return json.records ?? [];
+}
+async function fetchCo2(zone, date) {
+    const filter = zone === "DK"
+        ? `{"Minutes5UTC": {"$gte": "${date}T00:00"}}`
+        : `{"PriceArea": "${zone}", "Minutes5UTC": {"$gte": "${date}T00:00"}}`;
+    const records = await fetchEnergiData("CO2Emis", filter, 48);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const parsed = records.map((r) => ({
+        timestamp: r.Minutes5UTC ?? r.Minutes5DK ?? "",
+        zone: r.PriceArea ?? zone,
+        co2_gkwh: Math.round((Number(r.CO2Emission ?? 0)) * 10) / 10,
+    }));
+    return {
+        dataset: "co2_emissions",
+        source: "Energi Data Service (Energinet)",
+        zone,
+        records: parsed,
+    };
+}
+async function fetchProduction(zone, date) {
+    const filter = zone === "DK"
+        ? `{"Minutes5UTC": {"$gte": "${date}T00:00"}}`
+        : `{"PriceArea": "${zone}", "Minutes5UTC": {"$gte": "${date}T00:00"}}`;
+    const records = await fetchEnergiData("ElectricityProdex5MinRealtime", filter, 48);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const parsed = records.map((r) => {
+        const windOn = Number(r.OnshoreWindPower ?? r.OnshoreWindGe100MW_MWh ?? 0);
+        const windOff = Number(r.OffshoreWindPower ?? r.OffshoreWindGe100MW_MWh ?? 0);
+        const solar = Number(r.SolarPower ?? r.SolarGe100MW_MWh ?? 0);
+        const thermal = Number(r.ThermalPower ?? r.CentralPowerMWh ?? 0);
+        const hydro = Number(r.HydroPower ?? 0);
+        return {
+            timestamp: r.Minutes5UTC ?? r.Minutes5DK ?? "",
+            zone: r.PriceArea ?? zone,
+            wind_onshore_mw: Math.round(windOn),
+            wind_offshore_mw: Math.round(windOff),
+            solar_mw: Math.round(solar),
+            thermal_mw: Math.round(thermal),
+            hydro_mw: Math.round(hydro),
+            total_mw: Math.round(windOn + windOff + solar + thermal + hydro),
+        };
+    });
+    return {
+        dataset: "electricity_production",
+        source: "Energi Data Service (Energinet)",
+        zone,
+        records: parsed,
+    };
+}
+async function fetchPrices(zone, date) {
+    const filter = zone === "DK"
+        ? `{"HourUTC": {"$gte": "${date}T00:00"}}`
+        : `{"PriceArea": "${zone}", "HourUTC": {"$gte": "${date}T00:00"}}`;
+    const records = await fetchEnergiData("Elspotprices", filter, 48);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const parsed = records.map((r) => ({
+        timestamp: r.HourUTC ?? r.HourDK ?? "",
+        zone: r.PriceArea ?? zone,
+        price_eur_mwh: Math.round((Number(r.SpotPriceEUR ?? 0)) * 100) / 100,
+        price_dkk_mwh: Math.round((Number(r.SpotPriceDKK ?? 0)) * 100) / 100,
+    }));
+    return {
+        dataset: "electricity_prices",
+        source: "Energi Data Service (Energinet)",
+        zone,
+        records: parsed,
+    };
+}
+async function fetchBalance(zone, date) {
+    const filter = zone === "DK"
+        ? `{"HourUTC": {"$gte": "${date}T00:00"}}`
+        : `{"PriceArea": "${zone}", "HourUTC": {"$gte": "${date}T00:00"}}`;
+    const records = await fetchEnergiData("ElectricityBalanceNonv", filter, 48);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const parsed = records.map((r) => {
+        const prod = Number(r.ProductionGe100MW ?? r.GrossCon ?? 0);
+        const cons = Number(r.GrossCon ?? 0);
+        const imp = Number(r.ExchangeContinent ?? 0) > 0 ? Number(r.ExchangeContinent ?? 0) : 0;
+        const exp = Number(r.ExchangeContinent ?? 0) < 0 ? Math.abs(Number(r.ExchangeContinent ?? 0)) : 0;
+        return {
+            timestamp: r.HourUTC ?? r.HourDK ?? "",
+            zone: r.PriceArea ?? zone,
+            production_mwh: Math.round(prod),
+            consumption_mwh: Math.round(cons),
+            import_mwh: Math.round(imp),
+            export_mwh: Math.round(exp),
+            net_exchange_mwh: Math.round(Number(r.ExchangeContinent ?? 0)),
+        };
+    });
+    return {
+        dataset: "electricity_balance",
+        source: "Energi Data Service (Energinet)",
+        zone,
+        records: parsed,
+    };
+}
+export async function getEnergiData(params) {
+    const zone = params.zone ?? "DK";
+    const date = params.date ?? new Date().toISOString().slice(0, 10);
+    switch (params.dataset) {
+        case "co2_emissions":
+            return fetchCo2(zone, date);
+        case "electricity_production":
+            return fetchProduction(zone, date);
+        case "electricity_prices":
+            return fetchPrices(zone, date);
+        case "electricity_balance":
+            return fetchBalance(zone, date);
+    }
+}

package/dist/tools/energy-charts.d.ts

@@ -0,0 +1,103 @@
+import { z } from "zod";
+export declare const energyChartsSchema: z.ZodObject<{
+    dataset: z.ZodEnum<{
+        generation: "generation";
+        prices: "prices";
+        flows: "flows";
+        demand: "demand";
+        signal: "signal";
+        installed_capacity: "installed_capacity";
+    }>;
+    zone: z.ZodString;
+    start_date: z.ZodOptional<z.ZodString>;
+    end_date: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+interface PricePoint15min {
+    timestamp: string;
+    price: number;
+}
+interface PricePointHourly {
+    hour: number;
+    price: number;
+}
+interface PricesResult {
+    zone: string;
+    start_date: string;
+    end_date: string;
+    source: string;
+    resolution: string;
+    prices_15min: PricePoint15min[];
+    prices_hourly: PricePointHourly[];
+    stats: {
+        min: number;
+        max: number;
+        mean: number;
+    };
+}
+interface GenerationEntry {
+    fuel: string;
+    generation_mw: number;
+}
+interface GenerationResult {
+    zone: string;
+    timestamp: string;
+    source: string;
+    generation: GenerationEntry[];
+    total_mw: number;
+    renewable_pct: number;
+}
+interface FlowEntry {
+    country: string;
+    flow_mw: number;
+}
+interface FlowsResult {
+    zone: string;
+    source: string;
+    flows: FlowEntry[];
+    net_position_mw: number;
+}
+interface DemandHourly {
+    hour: number;
+    demand_mw: number;
+}
+interface DemandResult {
+    zone: string;
+    source: string;
+    timestamp: string;
+    demand_mw: number;
+    residual_load_mw: number;
+    renewable_share_load_pct: number;
+    renewable_share_generation_pct: number;
+    hourly_demand: DemandHourly[];
+}
+type SignalColor = "green" | "yellow" | "red";
+interface SignalHistoryEntry {
+    timestamp: string;
+    share_pct: number;
+    signal: SignalColor;
+}
+interface SignalResult {
+    zone: string;
+    source: string;
+    timestamp: string;
+    renewable_share_pct: number;
+    signal: SignalColor;
+    signal_description: string;
+    recent_history: SignalHistoryEntry[];
+}
+interface CapacityEntry {
+    fuel: string;
+    capacity_mw: number;
+}
+interface InstalledCapacityResult {
+    zone: string;
+    source: string;
+    year: string;
+    capacity: CapacityEntry[];
+    total_mw: number;
+    renewable_mw: number;
+    renewable_pct: number;
+}
+type EnergyChartsResult = PricesResult | GenerationResult | FlowsResult | DemandResult | SignalResult | InstalledCapacityResult;
+export declare function getEnergyCharts(params: z.infer<typeof energyChartsSchema>): Promise<EnergyChartsResult>;
+export {};

package/dist/tools/energy-charts.js

@@ -0,0 +1,411 @@
+import { z } from "zod";
+import { TtlCache, TTL } from "../lib/cache.js";
+const API_BASE = "https://api.energy-charts.info";
+const cache = new TtlCache();
+export const energyChartsSchema = z.object({
+    dataset: z
+        .enum(["prices", "generation", "flows", "demand", "signal", "installed_capacity"])
+        .describe('"prices" = day-ahead electricity prices (15-min resolution). ' +
+        '"generation" = real-time generation by fuel type. ' +
+        '"flows" = cross-border physical flows. ' +
+        '"demand" = total power demand and residual load. ' +
+        '"signal" = real-time renewable share traffic-light signal. ' +
+        '"installed_capacity" = installed generation capacity by fuel type (yearly).'),
+    zone: z
+        .string()
+        .describe("Country or bidding zone code. " +
+        "For prices: DE-LU, FR, ES, IT-North, NL, BE, AT, PL, NO2, SE4, DK1, DK2, CZ, HU, RO, BG, HR, SI, SK, GR, PT, FI, LT, LV, EE, IE-SEM. " +
+        "For generation/flows: de, fr, es, it, nl, be, at, pl, no, se, dk, cz, hu, ro, bg, hr, si, sk, gr, pt, fi, lt, lv, ee, ie."),
+    start_date: z
+        .string()
+        .optional()
+        .describe("Start date YYYY-MM-DD. Defaults to today."),
+    end_date: z
+        .string()
+        .optional()
+        .describe("End date YYYY-MM-DD. Defaults to start + 1 day."),
+});
+// ---------------------------------------------------------------------------
+// Shared fetch with caching
+// ---------------------------------------------------------------------------
+async function fetchEnergyCharts(url) {
+    const cached = cache.get(url);
+    if (cached)
+        return cached;
+    const response = await fetch(url, {
+        headers: { "User-Agent": "luminus-mcp/0.2" },
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`energy-charts.info returned ${response.status}: ${body.slice(0, 300)}`);
+    }
+    const json = (await response.json());
+    cache.set(url, json, TTL.REALTIME);
+    return json;
+}
+// ---------------------------------------------------------------------------
+// Date helpers
+// ---------------------------------------------------------------------------
+function resolveDates(startDate, endDate) {
+    const today = new Date().toISOString().slice(0, 10);
+    const start = startDate ?? today;
+    if (endDate) {
+        return { start, end: endDate };
+    }
+    const startDt = new Date(start + "T00:00:00Z");
+    const endDt = new Date(startDt.getTime() + 24 * 60 * 60 * 1000);
+    return { start, end: endDt.toISOString().slice(0, 10) };
+}
+async function fetchPrices(zone, startDate, endDate) {
+    const { start, end } = resolveDates(startDate, endDate);
+    const url = `${API_BASE}/price?bzn=${encodeURIComponent(zone)}&start=${start}&end=${end}`;
+    const data = await fetchEnergyCharts(url);
+    if (!data.unix_seconds || data.unix_seconds.length === 0) {
+        throw new Error(`No price data returned for zone "${zone}" (${start} to ${end}).`);
+    }
+    // Build 15-min price points, capped at first 96
+    const maxPoints = Math.min(data.unix_seconds.length, 96);
+    const prices15min = [];
+    for (let i = 0; i < maxPoints; i++) {
+        const ts = data.unix_seconds[i];
+        const price = data.price[i];
+        if (ts == null || price == null || !Number.isFinite(price))
+            continue;
+        prices15min.push({
+            timestamp: new Date(ts * 1000).toISOString(),
+            price: Math.round(price * 100) / 100,
+        });
+    }
+    // Convert 15-min to hourly by averaging each 4 consecutive values
+    const pricesHourly = [];
+    for (let h = 0; h < Math.floor(prices15min.length / 4); h++) {
+        const chunk = prices15min.slice(h * 4, h * 4 + 4);
+        const avg = chunk.reduce((s, p) => s + p.price, 0) / chunk.length;
+        pricesHourly.push({
+            hour: h,
+            price: Math.round(avg * 100) / 100,
+        });
+    }
+    const values = prices15min.map((p) => p.price);
+    const min = values.length > 0 ? Math.round(Math.min(...values) * 100) / 100 : 0;
+    const max = values.length > 0 ? Math.round(Math.max(...values) * 100) / 100 : 0;
+    const mean = values.length > 0
+        ? Math.round((values.reduce((s, v) => s + v, 0) / values.length) * 100) / 100
+        : 0;
+    return {
+        zone,
+        start_date: start,
+        end_date: end,
+        source: "energy-charts.info",
+        resolution: "15min",
+        prices_15min: prices15min,
+        prices_hourly: pricesHourly,
+        stats: { min, max, mean },
+    };
+}
+/** Fuel category mapping: source name -> aggregated category */
+const FUEL_CATEGORIES = {
+    "Wind onshore": "Wind",
+    "Wind offshore": "Wind",
+    Solar: "Solar",
+    "Fossil gas": "Gas",
+    "Fossil coal-derived gas": "Gas",
+    Nuclear: "Nuclear",
+    "Hydro Run-of-River": "Hydro",
+    "Hydro water reservoir": "Hydro",
+    "Hydro pumped storage": "Hydro",
+    "Fossil brown coal / lignite": "Coal",
+    "Fossil hard coal": "Coal",
+    Biomass: "Biomass",
+};
+/** Production types to exclude from aggregation (consumption, load, cross-border) */
+const EXCLUDED_TYPES = new Set([
+    "Load",
+    "Residual load",
+    "Pumped storage consumption",
+    "Cross border electricity trading",
+    "Power consumption",
+    "Import Balance",
+    "Export Balance",
+]);
+const RENEWABLE_FUELS = new Set(["Wind", "Solar", "Hydro", "Biomass"]);
+function getLatestNonNull(data) {
+    for (let i = data.length - 1; i >= 0; i--) {
+        if (data[i] != null && Number.isFinite(data[i])) {
+            return data[i];
+        }
+    }
+    return null;
+}
+async function fetchGeneration(zone, startDate, endDate) {
+    const { start, end } = resolveDates(startDate, endDate);
+    const url = `${API_BASE}/public_power?country=${encodeURIComponent(zone)}&start=${start}&end=${end}`;
+    const data = await fetchEnergyCharts(url);
+    if (!data.production_types || data.production_types.length === 0) {
+        throw new Error(`No generation data returned for zone "${zone}" (${start} to ${end}).`);
+    }
+    // Aggregate by fuel category
+    const categoryMw = new Map();
+    for (const pt of data.production_types) {
+        if (EXCLUDED_TYPES.has(pt.name))
+            continue;
+        const category = FUEL_CATEGORIES[pt.name] ?? "Other";
+        const mw = getLatestNonNull(pt.data);
+        if (mw == null || mw <= 0)
+            continue;
+        categoryMw.set(category, (categoryMw.get(category) ?? 0) + mw);
+    }
+    const generation = [];
+    for (const [fuel, mw] of categoryMw.entries()) {
+        generation.push({ fuel, generation_mw: Math.round(mw) });
+    }
+    generation.sort((a, b) => b.generation_mw - a.generation_mw);
+    const totalMw = generation.reduce((sum, g) => sum + g.generation_mw, 0);
+    const renewableMw = generation
+        .filter((g) => RENEWABLE_FUELS.has(g.fuel))
+        .reduce((sum, g) => sum + g.generation_mw, 0);
+    const renewablePct = totalMw > 0 ? Math.round((renewableMw / totalMw) * 1000) / 10 : 0;
+    // Determine timestamp from the latest non-null entry
+    let timestamp = new Date().toISOString();
+    if (data.unix_seconds && data.unix_seconds.length > 0) {
+        const lastTs = data.unix_seconds[data.unix_seconds.length - 1];
+        if (lastTs != null) {
+            timestamp = new Date(lastTs * 1000).toISOString();
+        }
+    }
+    return {
+        zone,
+        timestamp,
+        source: "energy-charts.info",
+        generation,
+        total_mw: totalMw,
+        renewable_pct: renewablePct,
+    };
+}
+async function fetchFlows(zone) {
+    const url = `${API_BASE}/cbpf?country=${encodeURIComponent(zone)}`;
+    const data = await fetchEnergyCharts(url);
+    if (!data.countries || data.countries.length === 0) {
+        throw new Error(`No cross-border flow data returned for zone "${zone}".`);
+    }
+    const flows = [];
+    let netPosition = 0;
+    for (const country of data.countries) {
+        const mw = getLatestNonNull(country.data);
+        if (mw == null)
+            continue;
+        const rounded = Math.round(mw);
+        flows.push({ country: country.name, flow_mw: rounded });
+        netPosition += rounded;
+    }
+    flows.sort((a, b) => Math.abs(b.flow_mw) - Math.abs(a.flow_mw));
+    return {
+        zone,
+        source: "energy-charts.info",
+        flows,
+        net_position_mw: netPosition,
+    };
+}
+async function fetchDemand(zone, startDate, endDate) {
+    const { start, end } = resolveDates(startDate, endDate);
+    const url = `${API_BASE}/total_power?country=${encodeURIComponent(zone)}&start=${start}&end=${end}`;
+    const data = await fetchEnergyCharts(url);
+    if (!data.production_types || data.production_types.length === 0) {
+        throw new Error(`No demand data returned for zone "${zone}" (${start} to ${end}).`);
+    }
+    // Extract key metrics from production types
+    let demandMw = 0;
+    let residualLoadMw = 0;
+    let renewableShareLoadPct = 0;
+    let renewableShareGenPct = 0;
+    let loadData = [];
+    for (const pt of data.production_types) {
+        if (pt.name === "Load" || pt.name === "Load (incl. self-consumption)") {
+            const val = getLatestNonNull(pt.data);
+            if (val != null)
+                demandMw = Math.round(val);
+            loadData = pt.data;
+        }
+        else if (pt.name === "Residual load") {
+            const val = getLatestNonNull(pt.data);
+            if (val != null)
+                residualLoadMw = Math.round(val);
+        }
+        else if (pt.name === "Renewable share of load") {
+            const val = getLatestNonNull(pt.data);
+            if (val != null)
+                renewableShareLoadPct = Math.round(val * 10) / 10;
+        }
+        else if (pt.name === "Renewable share of generation") {
+            const val = getLatestNonNull(pt.data);
+            if (val != null)
+                renewableShareGenPct = Math.round(val * 10) / 10;
+        }
+    }
+    // Build hourly demand profile from load data
+    const hourlyDemand = [];
+    if (data.unix_seconds && loadData.length > 0) {
+        const hourBuckets = new Map();
+        const maxPoints = Math.min(data.unix_seconds.length, loadData.length);
+        for (let i = 0; i < maxPoints; i++) {
+            const ts = data.unix_seconds[i];
+            const mw = loadData[i];
+            if (ts == null || mw == null || !Number.isFinite(mw))
+                continue;
+            const hour = new Date(ts * 1000).getUTCHours();
+            const bucket = hourBuckets.get(hour);
+            if (bucket) {
+                bucket.push(mw);
+            }
+            else {
+                hourBuckets.set(hour, [mw]);
+            }
+        }
+        for (const [hour, values] of hourBuckets.entries()) {
+            const avg = values.reduce((s, v) => s + v, 0) / values.length;
+            hourlyDemand.push({ hour, demand_mw: Math.round(avg) });
+        }
+        hourlyDemand.sort((a, b) => a.hour - b.hour);
+    }
+    // Determine timestamp
+    let timestamp = new Date().toISOString();
+    if (data.unix_seconds && data.unix_seconds.length > 0) {
+        const lastTs = data.unix_seconds[data.unix_seconds.length - 1];
+        if (lastTs != null) {
+            timestamp = new Date(lastTs * 1000).toISOString();
+        }
+    }
+    return {
+        zone,
+        source: "energy-charts.info",
+        timestamp,
+        demand_mw: demandMw,
+        residual_load_mw: residualLoadMw,
+        renewable_share_load_pct: renewableShareLoadPct,
+        renewable_share_generation_pct: renewableShareGenPct,
+        hourly_demand: hourlyDemand,
+    };
+}
+function signalToColor(value) {
+    if (value === 0)
+        return "green";
+    if (value === 1)
+        return "yellow";
+    return "red";
+}
+function signalDescription(color, sharePct) {
+    const label = color === "green"
+        ? "High renewable share"
+        : color === "yellow"
+            ? "Medium renewable share"
+            : "Low renewable share";
+    return `${label} (${sharePct}%)`;
+}
+async function fetchSignal(zone) {
+    const url = `${API_BASE}/signal?country=${encodeURIComponent(zone)}`;
+    const data = await fetchEnergyCharts(url);
+    if (!data.unix_seconds || data.unix_seconds.length === 0) {
+        throw new Error(`No signal data returned for zone "${zone}".`);
+    }
+    // Find latest non-null values
+    let latestShare = 0;
+    let latestSignal = "red";
+    let latestTimestamp = new Date().toISOString();
+    for (let i = data.unix_seconds.length - 1; i >= 0; i--) {
+        const ts = data.unix_seconds[i];
+        const share = data.share[i];
+        const sig = data.signal[i];
+        if (ts == null || share == null || sig == null)
+            continue;
+        if (!Number.isFinite(share) || !Number.isFinite(sig))
+            continue;
+        latestShare = Math.round(share * 10) / 10;
+        latestSignal = signalToColor(sig);
+        latestTimestamp = new Date(ts * 1000).toISOString();
+        break;
+    }
+    // Build recent history (last 12 non-null entries)
+    const recentHistory = [];
+    for (let i = data.unix_seconds.length - 1; i >= 0 && recentHistory.length < 12; i--) {
+        const ts = data.unix_seconds[i];
+        const share = data.share[i];
+        const sig = data.signal[i];
+        if (ts == null || share == null || sig == null)
+            continue;
+        if (!Number.isFinite(share) || !Number.isFinite(sig))
+            continue;
+        recentHistory.push({
+            timestamp: new Date(ts * 1000).toISOString(),
+            share_pct: Math.round(share * 10) / 10,
+            signal: signalToColor(sig),
+        });
+    }
+    recentHistory.reverse();
+    return {
+        zone,
+        source: "energy-charts.info",
+        timestamp: latestTimestamp,
+        renewable_share_pct: latestShare,
+        signal: latestSignal,
+        signal_description: signalDescription(latestSignal, latestShare),
+        recent_history: recentHistory,
+    };
+}
+async function fetchInstalledCapacity(zone) {
+    const url = `${API_BASE}/installed_power?country=${encodeURIComponent(zone)}&time_step=yearly`;
+    const data = await fetchEnergyCharts(url);
+    if (!data.production_types || data.production_types.length === 0) {
+        throw new Error(`No installed capacity data returned for zone "${zone}".`);
+    }
+    // Use the latest year's data
+    const latestIndex = data.time && data.time.length > 0 ? data.time.length - 1 : 0;
+    const year = data.time && data.time.length > 0 ? data.time[latestIndex] : "unknown";
+    // Aggregate by fuel category (reuse FUEL_CATEGORIES mapping)
+    const categoryMw = new Map();
+    for (const pt of data.production_types) {
+        if (EXCLUDED_TYPES.has(pt.name))
+            continue;
+        const category = FUEL_CATEGORIES[pt.name] ?? "Other";
+        const mw = pt.data[latestIndex];
+        if (mw == null || !Number.isFinite(mw) || mw <= 0)
+            continue;
+        categoryMw.set(category, (categoryMw.get(category) ?? 0) + mw);
+    }
+    const capacity = [];
+    for (const [fuel, mw] of categoryMw.entries()) {
+        capacity.push({ fuel, capacity_mw: Math.round(mw) });
+    }
+    capacity.sort((a, b) => b.capacity_mw - a.capacity_mw);
+    const totalMw = capacity.reduce((sum, c) => sum + c.capacity_mw, 0);
+    const renewableMw = capacity
+        .filter((c) => RENEWABLE_FUELS.has(c.fuel))
+        .reduce((sum, c) => sum + c.capacity_mw, 0);
+    const renewablePct = totalMw > 0 ? Math.round((renewableMw / totalMw) * 1000) / 10 : 0;
+    return {
+        zone,
+        source: "energy-charts.info",
+        year,
+        capacity,
+        total_mw: totalMw,
+        renewable_mw: renewableMw,
+        renewable_pct: renewablePct,
+    };
+}
+export async function getEnergyCharts(params) {
+    switch (params.dataset) {
+        case "prices":
+            return fetchPrices(params.zone, params.start_date, params.end_date);
+        case "generation":
+            return fetchGeneration(params.zone, params.start_date, params.end_date);
+        case "flows":
+            return fetchFlows(params.zone);
+        case "demand":
+            return fetchDemand(params.zone, params.start_date, params.end_date);
+        case "signal":
+            return fetchSignal(params.zone);
+        case "installed_capacity":
+            return fetchInstalledCapacity(params.zone);
+        default:
+            throw new Error(`Unknown dataset "${params.dataset}". Use: prices, generation, flows, demand, signal, installed_capacity.`);
+    }
+}