@iflow-mcp/kitfunso-luminus 0.2.0

package/dist/tools/hydro-inflows.js

@@ -0,0 +1,114 @@
+import { z } from "zod";
+import { TtlCache, TTL } from "../lib/cache.js";
+const API_BASE = "https://api.open-meteo.com/v1/forecast";
+const HYDRO_API = "https://archive-api.open-meteo.com/v1/archive";
+const cache = new TtlCache();
+/**
+ * Key hydropower basins in Europe with representative coordinates.
+ * River discharge data from Open-Meteo (backed by ERA5-Land) serves as
+ * a proxy for hydropower inflow conditions.
+ */
+const HYDRO_BASINS = {
+    NO: { lat: 60.5, lon: 7.5, description: "Norway (major hydro reservoirs)" },
+    SE: { lat: 63.0, lon: 15.0, description: "Sweden (northern hydro)" },
+    CH: { lat: 46.8, lon: 8.2, description: "Switzerland (Alpine hydro)" },
+    AT: { lat: 47.2, lon: 13.3, description: "Austria (Alpine hydro)" },
+    FR: { lat: 45.0, lon: 6.0, description: "France (Alpine + Pyrenees hydro)" },
+    IT: { lat: 46.0, lon: 11.0, description: "Italy (Alpine hydro)" },
+    ES: { lat: 42.5, lon: -0.5, description: "Spain (Pyrenees + central hydro)" },
+    PT: { lat: 41.0, lon: -8.0, description: "Portugal (Douro basin)" },
+    FI: { lat: 64.0, lon: 27.0, description: "Finland (northern hydro)" },
+    RO: { lat: 45.5, lon: 24.5, description: "Romania (Carpathian hydro)" },
+};
+export const hydroInflowsSchema = z.object({
+    country: z
+        .string()
+        .describe(`Country code for hydropower basin. Available: ${Object.keys(HYDRO_BASINS).join(", ")}. ` +
+        "Data uses precipitation, snowmelt, and temperature as proxies for hydro inflow conditions."),
+    period: z
+        .enum(["recent", "historical"])
+        .optional()
+        .describe('"recent" = last 7 days of conditions (default). ' +
+        '"historical" = last 30 days for trend analysis.'),
+});
+export async function getHydroInflows(params) {
+    const code = params.country.toUpperCase();
+    const basin = HYDRO_BASINS[code];
+    if (!basin) {
+        throw new Error(`Unknown country "${params.country}". Available: ${Object.keys(HYDRO_BASINS).join(", ")}`);
+    }
+    const days = params.period === "historical" ? 30 : 7;
+    const endDate = new Date();
+    endDate.setDate(endDate.getDate() - 1); // yesterday (ERA5 lag)
+    const startDate = new Date(endDate);
+    startDate.setDate(startDate.getDate() - days);
+    const start = startDate.toISOString().slice(0, 10);
+    const end = endDate.toISOString().slice(0, 10);
+    const url = `${HYDRO_API}?latitude=${basin.lat}&longitude=${basin.lon}` +
+        `&start_date=${start}&end_date=${end}` +
+        `&daily=precipitation_sum,snowfall_sum,temperature_2m_max,rain_sum` +
+        `&timezone=UTC`;
+    const cached = cache.get(url);
+    if (cached)
+        return cached;
+    const response = await fetch(url);
+    if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`Open-Meteo Archive returned ${response.status}: ${body.slice(0, 300)}`);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const json = await response.json();
+    const dailyData = json.daily ?? {};
+    const times = dailyData.time ?? [];
+    const daily = [];
+    let totalPrecip = 0;
+    let totalSnow = 0;
+    let tempSum = 0;
+    let proxySum = 0;
+    for (let i = 0; i < times.length; i++) {
+        const precip = Number(dailyData.precipitation_sum?.[i] ?? 0);
+        const snow = Number(dailyData.snowfall_sum?.[i] ?? 0);
+        const tempMax = Number(dailyData.temperature_2m_max?.[i] ?? 0);
+        const rain = Number(dailyData.rain_sum?.[i] ?? 0);
+        // Inflow proxy: rain + snowmelt contribution (positive temps melt accumulated snow)
+        const snowmeltContrib = tempMax > 2 && snow > 0 ? Math.min(snow * 5, tempMax * 2) : 0;
+        const inflowProxy = Math.round((rain + snowmeltContrib) * 10) / 10;
+        daily.push({
+            date: times[i],
+            precipitation_mm: Math.round(precip * 10) / 10,
+            snowfall_mm: Math.round(snow * 10) / 10,
+            temperature_max_c: Math.round(tempMax * 10) / 10,
+            rain_mm: Math.round(rain * 10) / 10,
+            inflow_proxy_index: inflowProxy,
+        });
+        totalPrecip += precip;
+        totalSnow += snow;
+        tempSum += tempMax;
+        proxySum += inflowProxy;
+    }
+    const n = daily.length || 1;
+    const avgProxy = Math.round((proxySum / n) * 10) / 10;
+    // Determine trend from first half vs second half
+    const mid = Math.floor(n / 2);
+    const firstHalf = daily.slice(0, mid).reduce((s, d) => s + d.inflow_proxy_index, 0) / (mid || 1);
+    const secondHalf = daily.slice(mid).reduce((s, d) => s + d.inflow_proxy_index, 0) / ((n - mid) || 1);
+    const trend = secondHalf > firstHalf * 1.2 ? "increasing" : secondHalf < firstHalf * 0.8 ? "decreasing" : "stable";
+    const result = {
+        source: "Open-Meteo Archive (ERA5-Land reanalysis) — hydro inflow proxy",
+        country: code,
+        basin_description: basin.description,
+        latitude: basin.lat,
+        longitude: basin.lon,
+        period_days: days,
+        daily,
+        summary: {
+            total_precipitation_mm: Math.round(totalPrecip * 10) / 10,
+            total_snowfall_mm: Math.round(totalSnow * 10) / 10,
+            avg_temperature_c: Math.round((tempSum / n) * 10) / 10,
+            avg_inflow_proxy: avgProxy,
+            trend,
+        },
+    };
+    cache.set(url, result, TTL.WEATHER);
+    return result;
+}

package/dist/tools/hydro.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export declare const hydroSchema: z.ZodObject<{
+    zone: z.ZodString;
+    start_date: z.ZodOptional<z.ZodString>;
+    end_date: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+interface ReservoirPoint {
+    week_start: string;
+    stored_energy_mwh: number;
+}
+export declare function getHydroReservoir(params: z.infer<typeof hydroSchema>): Promise<{
+    zone: string;
+    start_date: string;
+    end_date: string;
+    reservoir: ReservoirPoint[];
+    latest_stored_mwh: number;
+}>;
+export {};

package/dist/tools/hydro.js

@@ -0,0 +1,85 @@
+import { z } from "zod";
+import { queryEntsoe, formatEntsoeDate } from "../lib/entsoe-client.js";
+import { resolveZone, AVAILABLE_ZONES } from "../lib/zone-codes.js";
+import { ensureArray } from "../lib/xml-parser.js";
+import { TTL } from "../lib/cache.js";
+export const hydroSchema = z.object({
+    zone: z
+        .string()
+        .describe(`Country/zone code. Available: ${AVAILABLE_ZONES}. ` +
+        "Best coverage: NO (Norway), SE (Sweden), AT (Austria), CH (Switzerland), ES (Spain), PT (Portugal)."),
+    start_date: z
+        .string()
+        .optional()
+        .describe("Start date in YYYY-MM-DD format. Defaults to 4 weeks ago."),
+    end_date: z
+        .string()
+        .optional()
+        .describe("End date in YYYY-MM-DD format. Defaults to today."),
+});
+function parsePeriodStepDays(resolution) {
+    if (!resolution)
+        return 7;
+    const weekMatch = /^P(\d+)W$/i.exec(resolution);
+    if (weekMatch)
+        return Number(weekMatch[1]) * 7;
+    const dayMatch = /^P(\d+)D$/i.exec(resolution);
+    if (dayMatch)
+        return Number(dayMatch[1]);
+    return 7;
+}
+function addDays(isoStart, dayOffset) {
+    const date = new Date(isoStart);
+    date.setUTCDate(date.getUTCDate() + dayOffset);
+    return date.toISOString().slice(0, 10);
+}
+export async function getHydroReservoir(params) {
+    const eic = resolveZone(params.zone);
+    const endDate = params.end_date
+        ? new Date(params.end_date + "T00:00:00Z")
+        : new Date();
+    const startDate = params.start_date
+        ? new Date(params.start_date + "T00:00:00Z")
+        : new Date(endDate.getTime() - 28 * 24 * 60 * 60 * 1000);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const data = await queryEntsoe({
+        documentType: "A72",
+        processType: "A16",
+        in_Domain: eic,
+        periodStart: formatEntsoeDate(startDate),
+        periodEnd: formatEntsoeDate(endDate),
+    }, TTL.STORAGE);
+    const doc = data.GL_MarketDocument;
+    if (!doc)
+        throw new Error("No hydro reservoir data returned for this zone/date range.");
+    const timeSeries = ensureArray(doc.TimeSeries);
+    const reservoir = [];
+    for (const ts of timeSeries) {
+        const periods = ensureArray(ts.Period);
+        for (const period of periods) {
+            const start = period.timeInterval?.start ?? "";
+            const startIso = typeof start === "string" ? start : "";
+            const stepDays = parsePeriodStepDays(period.resolution);
+            const points = ensureArray(period.Point);
+            for (const point of points) {
+                const storedMwh = Number(point.quantity ?? 0);
+                const position = Math.max(1, Number(point.position ?? 1));
+                reservoir.push({
+                    week_start: addDays(startIso, (position - 1) * stepDays),
+                    stored_energy_mwh: storedMwh,
+                });
+            }
+        }
+    }
+    reservoir.sort((a, b) => a.week_start.localeCompare(b.week_start));
+    const latestStored = reservoir.length > 0
+        ? reservoir[reservoir.length - 1].stored_energy_mwh
+        : 0;
+    return {
+        zone: params.zone.toUpperCase(),
+        start_date: params.start_date ?? startDate.toISOString().slice(0, 10),
+        end_date: params.end_date ?? endDate.toISOString().slice(0, 10),
+        reservoir,
+        latest_stored_mwh: latestStored,
+    };
+}

package/dist/tools/imbalance-prices.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const imbalancePricesSchema: z.ZodObject<{
+    zone: z.ZodString;
+    date: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+interface ImbalancePricePoint {
+    period: number;
+    price_eur_mwh: number;
+}
+export declare function getImbalancePrices(params: z.infer<typeof imbalancePricesSchema>): Promise<{
+    zone: string;
+    date: string;
+    currency: string;
+    prices: ImbalancePricePoint[];
+    stats: {
+        min: number;
+        max: number;
+        mean: number;
+    };
+}>;
+export {};

package/dist/tools/imbalance-prices.js

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import { queryEntsoe, dayRange } from "../lib/entsoe-client.js";
+import { resolveZone, AVAILABLE_ZONES } from "../lib/zone-codes.js";
+import { ensureArray } from "../lib/xml-parser.js";
+import { TTL } from "../lib/cache.js";
+export const imbalancePricesSchema = z.object({
+    zone: z
+        .string()
+        .describe(`Bidding zone code. Examples: DE, FR, GB. Available: ${AVAILABLE_ZONES}`),
+    date: z
+        .string()
+        .optional()
+        .describe("Date in YYYY-MM-DD format. Defaults to today."),
+});
+export async function getImbalancePrices(params) {
+    const eic = resolveZone(params.zone);
+    const { periodStart, periodEnd } = dayRange(params.date);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const data = await queryEntsoe({
+        documentType: "A86",
+        processType: "A16",
+        controlArea_Domain: eic,
+        periodStart,
+        periodEnd,
+    }, TTL.BALANCING);
+    const doc = data.Imbalance_MarketDocument ?? data.GL_MarketDocument ?? data.Publication_MarketDocument;
+    if (!doc)
+        throw new Error("No imbalance price data returned for this zone/date.");
+    const timeSeries = ensureArray(doc.TimeSeries);
+    const prices = [];
+    for (const ts of timeSeries) {
+        const periods = ensureArray(ts.Period);
+        for (const period of periods) {
+            const points = ensureArray(period.Point);
+            for (const point of points) {
+                const position = Number(point.position);
+                const price = Number(point["imbalance_Price.amount"] ?? point["price.amount"] ?? point.quantity ?? 0);
+                prices.push({ period: position, price_eur_mwh: price });
+            }
+        }
+    }
+    prices.sort((a, b) => a.period - b.period);
+    const values = prices.map((p) => p.price_eur_mwh);
+    const min = values.length > 0 ? Math.min(...values) : 0;
+    const max = values.length > 0 ? Math.max(...values) : 0;
+    const mean = values.length > 0
+        ? Math.round((values.reduce((s, v) => s + v, 0) / values.length) * 100) / 100
+        : 0;
+    return {
+        zone: params.zone.toUpperCase(),
+        date: params.date ?? new Date().toISOString().slice(0, 10),
+        currency: "EUR",
+        prices,
+        stats: { min, max, mean },
+    };
+}

package/dist/tools/intraday-prices.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const intradayPricesSchema: z.ZodObject<{
+    zone: z.ZodString;
+    date: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+interface IntradayPricePoint {
+    hour: number;
+    price_eur_mwh: number;
+}
+export declare function getIntradayPrices(params: z.infer<typeof intradayPricesSchema>): Promise<{
+    zone: string;
+    date: string;
+    currency: string;
+    prices: IntradayPricePoint[];
+    stats: {
+        min: number;
+        max: number;
+        mean: number;
+    };
+}>;
+export {};

package/dist/tools/intraday-prices.js

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { queryEntsoe, dayRange } from "../lib/entsoe-client.js";
+import { resolvePriceZone, AVAILABLE_ZONES } from "../lib/zone-codes.js";
+import { ensureArray } from "../lib/xml-parser.js";
+import { TTL } from "../lib/cache.js";
+export const intradayPricesSchema = z.object({
+    zone: z
+        .string()
+        .describe(`Bidding zone code. Examples: DE, FR, GB. Available: ${AVAILABLE_ZONES}`),
+    date: z
+        .string()
+        .optional()
+        .describe("Date in YYYY-MM-DD format. Defaults to today."),
+});
+export async function getIntradayPrices(params) {
+    const eic = resolvePriceZone(params.zone);
+    const { periodStart, periodEnd } = dayRange(params.date);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const data = await queryEntsoe({
+        documentType: "A67",
+        processType: "A01",
+        in_Domain: eic,
+        out_Domain: eic,
+        periodStart,
+        periodEnd,
+    }, TTL.INTRADAY);
+    const doc = data.Publication_MarketDocument;
+    if (!doc)
+        throw new Error("No intraday price data returned for this zone/date.");
+    const timeSeries = ensureArray(doc.TimeSeries);
+    const prices = [];
+    for (const ts of timeSeries) {
+        const periods = ensureArray(ts.Period);
+        for (const period of periods) {
+            const points = ensureArray(period.Point);
+            for (const point of points) {
+                const position = Number(point.position);
+                const price = Number(point["price.amount"]);
+                prices.push({ hour: position - 1, price_eur_mwh: price });
+            }
+        }
+    }
+    prices.sort((a, b) => a.hour - b.hour);
+    const values = prices.map((p) => p.price_eur_mwh);
+    const min = values.length > 0 ? Math.min(...values) : 0;
+    const max = values.length > 0 ? Math.max(...values) : 0;
+    const mean = values.length > 0
+        ? Math.round((values.reduce((s, v) => s + v, 0) / values.length) * 100) / 100
+        : 0;
+    return {
+        zone: params.zone.toUpperCase(),
+        date: params.date ?? new Date().toISOString().slice(0, 10),
+        currency: "EUR",
+        prices,
+        stats: { min, max, mean },
+    };
+}

package/dist/tools/intraday-spread.d.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+export declare const intradaySpreadSchema: z.ZodObject<{
+    zone: z.ZodString;
+    date: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+interface SpreadPoint {
+    hour: number;
+    day_ahead: number;
+    intraday: number;
+    spread: number;
+}
+type SpreadSignal = "intraday_premium" | "intraday_discount" | "neutral";
+export declare function getIntradayDaSpread(params: z.infer<typeof intradaySpreadSchema>): Promise<{
+    zone: string;
+    date: string;
+    spreads: SpreadPoint[];
+    stats: {
+        mean_spread: number;
+        max_spread: number;
+        min_spread: number;
+    };
+    signal: SpreadSignal;
+}>;
+export {};

package/dist/tools/intraday-spread.js

@@ -0,0 +1,55 @@
+import { z } from "zod";
+import { getDayAheadPrices, pricesSchema } from "./prices.js";
+import { getIntradayPrices } from "./intraday-prices.js";
+import { AVAILABLE_ZONES } from "../lib/zone-codes.js";
+export const intradaySpreadSchema = z.object({
+    zone: z
+        .string()
+        .describe(`Bidding zone code. Examples: DE, FR, GB. Available: ${AVAILABLE_ZONES}`),
+    date: z
+        .string()
+        .optional()
+        .describe("Date in YYYY-MM-DD format. Defaults to today."),
+});
+export async function getIntradayDaSpread(params) {
+    const date = params.date ?? new Date().toISOString().slice(0, 10);
+    const [daResult, idResult] = await Promise.all([
+        getDayAheadPrices(pricesSchema.parse({ zone: params.zone, start_date: date })),
+        getIntradayPrices({ zone: params.zone, date }),
+    ]);
+    // Build lookup maps keyed by hour
+    const daByHour = new Map(daResult.prices.map((p) => [p.hour, p.price_eur_mwh]));
+    const idByHour = new Map(idResult.prices.map((p) => [p.hour, p.price_eur_mwh]));
+    // Compute spreads for matching hours
+    const spreads = [];
+    for (const [hour, idPrice] of idByHour) {
+        const daPrice = daByHour.get(hour);
+        if (daPrice == null)
+            continue;
+        spreads.push({
+            hour,
+            day_ahead: daPrice,
+            intraday: idPrice,
+            spread: Math.round((idPrice - daPrice) * 100) / 100,
+        });
+    }
+    spreads.sort((a, b) => a.hour - b.hour);
+    const spreadValues = spreads.map((s) => s.spread);
+    const meanSpread = spreadValues.length > 0
+        ? Math.round((spreadValues.reduce((s, v) => s + v, 0) / spreadValues.length) * 100) / 100
+        : 0;
+    const maxSpread = spreadValues.length > 0 ? Math.max(...spreadValues) : 0;
+    const minSpread = spreadValues.length > 0 ? Math.min(...spreadValues) : 0;
+    let signal = "neutral";
+    if (meanSpread > 5)
+        signal = "intraday_premium";
+    else if (meanSpread < -5)
+        signal = "intraday_discount";
+    return {
+        zone: params.zone.toUpperCase(),
+        date,
+        spreads,
+        stats: { mean_spread: meanSpread, max_spread: maxSpread, min_spread: minSpread },
+        signal,
+    };
+}

package/dist/tools/land-constraints.d.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import { type ConstraintFeature } from "../lib/natural-england.js";
+import { type GisSourceMetadata } from "../lib/gis-sources.js";
+export declare const landConstraintsSchema: z.ZodObject<{
+    lat: z.ZodNumber;
+    lon: z.ZodNumber;
+    radius_km: z.ZodOptional<z.ZodNumber>;
+    country: z.ZodString;
+}, z.core.$strip>;
+interface LandConstraintsSummary {
+    has_hard_constraint: boolean;
+    constraint_count: number;
+}
+interface LandConstraintsResult {
+    lat: number;
+    lon: number;
+    radius_km: number;
+    country: string;
+    constraints: ConstraintFeature[];
+    summary: LandConstraintsSummary;
+    source_metadata: GisSourceMetadata;
+    warnings?: string[];
+}
+export declare function getLandConstraints(params: z.infer<typeof landConstraintsSchema>): Promise<LandConstraintsResult>;
+export {};

package/dist/tools/land-constraints.js

@@ -0,0 +1,148 @@
+import { z } from "zod";
+import { TtlCache, TTL } from "../lib/cache.js";
+import { GB_PROTECTED_AREA_LAYERS, queryLayer, } from "../lib/natural-england.js";
+import { queryNatura2000Layer } from "../lib/eea-natura2000.js";
+import { GIS_SOURCES } from "../lib/gis-sources.js";
+const cache = new TtlCache();
+export const landConstraintsSchema = z.object({
+    lat: z.number().describe("Latitude (-90 to 90). WGS84."),
+    lon: z.number().describe("Longitude (-180 to 180). WGS84."),
+    radius_km: z
+        .number()
+        .optional()
+        .describe("Search radius in km (default 2, max 10)."),
+    country: z
+        .string()
+        .describe('ISO 3166-1 alpha-2 country code. Supports "GB" plus EU member states in this version.'),
+});
+/** Designation types that represent hard planning exclusions for PV/BESS siting. */
+const HARD_CONSTRAINT_TYPES = new Set([
+    "sssi",
+    "sac",
+    "spa",
+    "ramsar",
+    "national_park",
+    "natura2000",
+    "natura2000_birds",
+    "natura2000_habitats",
+]);
+const EU_COUNTRY_CODES = new Set([
+    "AT",
+    "BE",
+    "BG",
+    "CY",
+    "CZ",
+    "DE",
+    "DK",
+    "EE",
+    "ES",
+    "FI",
+    "FR",
+    "GR",
+    "HR",
+    "HU",
+    "IE",
+    "IT",
+    "LT",
+    "LU",
+    "LV",
+    "MT",
+    "NL",
+    "PL",
+    "PT",
+    "RO",
+    "SE",
+    "SI",
+    "SK",
+]);
+function dedupeConstraints(constraints) {
+    const seen = new Set();
+    return constraints.filter((constraint) => {
+        const key = `${constraint.type}:${constraint.name}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function summariseConstraints(constraints) {
+    return {
+        has_hard_constraint: constraints.some((constraint) => HARD_CONSTRAINT_TYPES.has(constraint.type)),
+        constraint_count: constraints.length,
+    };
+}
+export async function getLandConstraints(params) {
+    const { lat, lon } = params;
+    const country = params.country.toUpperCase();
+    const radiusKm = params.radius_km ?? 2;
+    if (lat < -90 || lat > 90) {
+        throw new Error("Latitude must be between -90 and 90.");
+    }
+    if (lon < -180 || lon > 180) {
+        throw new Error("Longitude must be between -180 and 180.");
+    }
+    if (radiusKm <= 0 || radiusKm > 10) {
+        throw new Error("radius_km must be between 0 and 10.");
+    }
+    if (country !== "GB" && !EU_COUNTRY_CODES.has(country)) {
+        throw new Error(`Country "${params.country}" is not supported. Use "GB" for Great Britain or an EU member-state country code in this version.`);
+    }
+    const cacheKey = `land-constraints:${lat}:${lon}:${radiusKm}:${country}`;
+    const cached = cache.get(cacheKey);
+    if (cached)
+        return cached;
+    if (country === "GB") {
+        const layerResults = await Promise.allSettled(GB_PROTECTED_AREA_LAYERS.map((layer) => queryLayer(layer, lat, lon, radiusKm)));
+        const constraints = [];
+        const warnings = [];
+        for (let i = 0; i < layerResults.length; i++) {
+            const result = layerResults[i];
+            if (result.status === "fulfilled") {
+                constraints.push(...result.value);
+            }
+            else {
+                const layerType = GB_PROTECTED_AREA_LAYERS[i].constraintType;
+                const msg = result.reason instanceof Error
+                    ? result.reason.message
+                    : String(result.reason);
+                warnings.push(`${layerType}: ${msg}`);
+            }
+        }
+        if (warnings.length === GB_PROTECTED_AREA_LAYERS.length) {
+            throw new Error(`All Natural England API queries failed: ${warnings.join("; ")}`);
+        }
+        const deduped = dedupeConstraints(constraints);
+        const result = {
+            lat,
+            lon,
+            radius_km: radiusKm,
+            country: "GB",
+            constraints: deduped,
+            summary: summariseConstraints(deduped),
+            source_metadata: GIS_SOURCES["natural-england"],
+        };
+        if (warnings.length > 0) {
+            result.warnings = warnings;
+        }
+        cache.set(cacheKey, result, TTL.STATIC_DATA);
+        return result;
+    }
+    try {
+        const constraints = dedupeConstraints(await queryNatura2000Layer(lat, lon, radiusKm));
+        const result = {
+            lat,
+            lon,
+            radius_km: radiusKm,
+            country,
+            constraints,
+            summary: summariseConstraints(constraints),
+            source_metadata: GIS_SOURCES["eea-natura2000"],
+        };
+        cache.set(cacheKey, result, TTL.STATIC_DATA);
+        return result;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`EEA Natura 2000 query failed: ${message}`);
+    }
+}

package/dist/tools/land-cover.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { type CorineResult } from "../lib/corine.js";
+import { type GisSourceMetadata } from "../lib/gis-sources.js";
+export declare const landCoverSchema: z.ZodObject<{
+    lat: z.ZodNumber;
+    lon: z.ZodNumber;
+    country: z.ZodString;
+}, z.core.$strip>;
+interface LandCoverResult {
+    lat: number;
+    lon: number;
+    country: string;
+    land_cover: CorineResult | null;
+    coverage_note: string | null;
+    source_metadata: GisSourceMetadata;
+}
+export declare function getLandCover(params: z.infer<typeof landCoverSchema>): Promise<LandCoverResult>;
+export {};