@enyo-energy/energy-app-sdk 0.0.180 → 0.0.182

package/README.md

@@ -49,6 +49,8 @@ The official TypeScript SDK for building Energy Apps on the enyo platform. Creat
   - [EvChargingForecast](#evchargingforecast)
   - [HeatpumpConsumptionForecast](#heatpumpconsumptionforecast)
   - [HeatpumpDhwTemperatureForecast](#heatpumpdhwtemperatureforecast)
+  - [AirConditioningConsumptionForecast](#airconditioningconsumptionforecast)
+  - [AirConditioningRoomTemperatureForecast](#airconditioningroomtemperatureforecast)
 - [Appliance Energy-Manager Forecast](#appliance-energy-manager-forecast)
   - [`useApplianceEnergyManagerForecast()`](#useapplianceenergymanagerforecast-energyappapplianceenergymanagerforecast)
   - [ChargerForecast](#chargerforecast)
@@ -144,6 +146,8 @@ The SDK exposes several layered building blocks. Pick the one that matches the k
 | Forecast EV charging demand | [`EvChargingForecast`](#evchargingforecast) |
 | Forecast heatpump electrical consumption | [`HeatpumpConsumptionForecast`](#heatpumpconsumptionforecast) |
 | Forecast heatpump DHW tank temperature | [`HeatpumpDhwTemperatureForecast`](#heatpumpdhwtemperatureforecast) |
+| Forecast air conditioning electrical consumption | [`AirConditioningConsumptionForecast`](#airconditioningconsumptionforecast) |
+| Forecast air conditioning room temperature | [`AirConditioningRoomTemperatureForecast`](#airconditioningroomtemperatureforecast) |
 | Announce a charger / battery / heatpump command plan you **intend to apply** | [`useApplianceEnergyManagerForecast()`](#useapplianceenergymanagerforecast-energyappapplianceenergymanagerforecast) |
 | Talk to an EEBUS / SHIP / SPINE device | [`useEebus()`](#useeebus-energyappeebus) |
 | Speak MQTT (SDK broker or external) | [`useMqtt()`](#usemqtt-energyappmqtt) |
@@ -1744,6 +1748,8 @@ new EnergyManagerEnergyApp({
 - `getEvChargingForecast(applianceId, config?)`
 - `getHeatpumpConsumptionForecast(applianceId, config?)`
 - `getHeatpumpDhwTemperatureForecast(applianceId, config?)`
+- `getAirConditioningConsumptionForecast(applianceId, config?)`
+- `getAirConditioningRoomTemperatureForecast(applianceId, config?)`
 
 **Lifecycle**
 
@@ -1761,7 +1767,7 @@ const batteryForecast = battery.getForecast();
 
 ## Forecasting
 
-The forecasting module provides 24-hour predictions across the energy domains the SDK already understands (PV, battery, home consumption, EV charging, heatpump consumption, DHW temperature). Every forecaster follows the same lifecycle and shares the same configuration shape, so once you've used one you've used them all.
+The forecasting module provides 24-hour predictions across the energy domains the SDK already understands (PV, battery, home consumption, EV charging, heatpump consumption, DHW temperature, air conditioning consumption, air conditioning room temperature). Every forecaster follows the same lifecycle and shares the same configuration shape, so once you've used one you've used them all.
 
 ### ✨ Common pattern
 
@@ -1880,6 +1886,36 @@ new HeatpumpDhwTemperatureForecast(app, applianceId, {
 - **Notable config:** `dhwTankIndex` selects a specific tank (zero-based); omit to average across all tanks.
 - **Live source:** heatpump temperature timeseries / live updates.
 
+### AirConditioningConsumptionForecast
+
+Forecasts the electrical consumption of an air conditioning appliance (cooling + heating combined).
+
+```typescript
+new AirConditioningConsumptionForecast(app, applianceId, { source: EnyoSourceEnum.Device, config? });
+```
+
+- **Output per slot:** `{ powerW: number; powerWh: number }`
+- **History default:** 14 days — AC load is weather-driven and bursty, so a wider window than the heatpump's 7 days gives a more stable per-slot profile.
+- **Live source:** `AirConditioningValuesUpdateV1`.
+- **Note:** `powerW` is optional on that message; updates without a power reading are ignored rather than counted as `0 W`, so an appliance that only reports its operation mode does not drag the forecast towards zero.
+- **Note:** like the heatpump forecaster, it does not adjust for forecasted weather; layer a correction on top if you need that.
+
+### AirConditioningRoomTemperatureForecast
+
+Forecasts the room temperature served by an air conditioning appliance — the input you need to plan pre-cooling on forecasted PV surplus.
+
+```typescript
+new AirConditioningRoomTemperatureForecast(app, applianceId, {
+    source: EnyoSourceEnum.Device,
+    config?: { roomIndex?: number, ...ForecastConfig }
+});
+```
+
+- **Output per slot:** `{ temperatureC: number }` (rounded to 0.1 °C).
+- **History default:** 7 days.
+- **Notable config:** `roomIndex` selects a specific room (zero-based); omit to average across all rooms. When set, it is echoed back on the published message's `data.roomIndex`.
+- **Live source:** `AirConditioningTemperaturesUpdateV1`.
+
 ### 🚀 Common usage example
 
 ```typescript

package/dist/cjs/implementations/forecasts/air-conditioning-consumption-forecast.cjs

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AirConditioningConsumptionForecast = void 0;
+const enyo_data_bus_value_js_1 = require("../../types/enyo-data-bus-value.cjs");
+const forecast_types_js_1 = require("./forecast-types.cjs");
+const forecast_utils_js_1 = require("./forecast-utils.cjs");
+/**
+ * Builds a 24-hour air conditioning electrical consumption forecast for a
+ * single air conditioning appliance (cooling and heating combined). Historical
+ * buckets are sourced from the dedicated
+ * `useTimeseries().getAirConditioningPowerTimeseries()` endpoint, and live
+ * `AirConditioningValuesUpdateV1` data-bus messages are merged in as new
+ * readings arrive.
+ *
+ * Air conditioning load follows the household's daily occupancy rhythm, so the
+ * algorithm uses a same-weekday recency-weighted average over the configured
+ * history window, with an all-weekday fallback. The default history window is
+ * 14 days (longer than the heatpump's 7): AC operation is weather-driven and
+ * bursty, so a wider window yields a more stable per-slot profile.
+ *
+ * Note: `powerW` is optional on `AirConditioningValuesUpdateV1`. Messages
+ * without a power reading are ignored rather than counted as `0 W`, so that an
+ * appliance that only reports its operation mode does not drag the forecast
+ * towards zero.
+ *
+ * Like the heatpump forecaster, this implementation does not adjust for
+ * forecasted outdoor temperature; layer a correction on top of the returned
+ * `powerW` values using the weather forecast for the same horizon if you need
+ * that.
+ *
+ * @example
+ * ```ts
+ * const forecast = new AirConditioningConsumptionForecast(app, 'ac-1', {
+ *     source: EnyoSourceEnum.Device,
+ * });
+ * await forecast.initialize();
+ * const result = forecast.getForecast();
+ * ```
+ */
+class AirConditioningConsumptionForecast {
+    app;
+    applianceId;
+    /**
+     * Default history window. AC load is weather-driven and bursty, so a longer
+     * window than the heatpump's is used to stabilise the per-slot profile.
+     */
+    static DEFAULT_HISTORY_DAYS = 14;
+    config;
+    history = [];
+    listenerId;
+    currentSlotMs;
+    currentSlotPowerSum = 0;
+    currentSlotSamples = 0;
+    initialized = false;
+    source;
+    /**
+     * @param app - The energy-app SDK instance.
+     * @param applianceId - Air conditioning appliance ID.
+     * @param options.source - Source identifier used for outgoing forecast messages.
+     * @param options.config - Optional config overrides; `historyDays` defaults to 14.
+     */
+    constructor(app, applianceId, options) {
+        this.app = app;
+        this.applianceId = applianceId;
+        this.config = (0, forecast_types_js_1.resolveForecastConfig)({ historyDays: AirConditioningConsumptionForecast.DEFAULT_HISTORY_DAYS }, options.config);
+        this.source = options.source;
+    }
+    /**
+     * Loads historical air conditioning power buckets via
+     * `useTimeseries().getAirConditioningPowerTimeseries()` and starts listening
+     * to live `AirConditioningValuesUpdateV1` events for ongoing updates.
+     * Idempotent.
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        this.initialized = true;
+        const now = Date.now();
+        const startMs = now - this.config.historyDays * 24 * 60 * 60 * 1000;
+        const response = await this.app.useTimeseries().getAirConditioningPowerTimeseries({
+            startDateIso: new Date(startMs).toISOString(),
+            endDateIso: new Date(now).toISOString(),
+            applianceIds: [this.applianceId],
+            resolution: this.config.resolution,
+        });
+        for (const entry of response.entries) {
+            this.history.push({
+                timestampIso: entry.timestampIso,
+                values: {
+                    powerW: entry.airConditioningPowerW,
+                    powerWh: entry.airConditioningPowerWh,
+                    samples: 1,
+                },
+            });
+        }
+        this.listenerId = this.app.useDataBus().listenForMessages([enyo_data_bus_value_js_1.EnyoDataBusMessageEnum.AirConditioningValuesUpdateV1], (msg) => this.onAirConditioningValues(msg));
+    }
+    /**
+     * Returns the current forecast as an
+     * `EnyoDataBusAirConditioningConsumptionForecastV1`-shaped payload over the
+     * configured horizon.
+     */
+    getForecast() {
+        const now = Date.now();
+        this.flushCurrentSlot(now);
+        const parsed = (0, forecast_utils_js_1.parseHistory)(this.history);
+        const todayWeekday = new Date(now).getUTCDay();
+        const sameWeekdayMap = (0, forecast_utils_js_1.buildSlotMap)(parsed, (b) => b.weekday === todayWeekday);
+        const fallbackMap = (0, forecast_utils_js_1.buildSlotMap)(parsed);
+        const isoIndex = (0, forecast_utils_js_1.buildIsoIndex)(parsed, (v) => v.powerW);
+        const buckets = (0, forecast_utils_js_1.buildForecastSlots)(now, this.config.horizonHours, this.config.resolution).map((slotMs) => {
+            const key = formatSlotKey(slotMs);
+            const slotBuckets = sameWeekdayMap.get(key) ?? fallbackMap.get(key);
+            const avg = (0, forecast_utils_js_1.weightedAverageBySlot)(slotBuckets, now, this.config.historyDays, {
+                powerW: (v) => v.powerW,
+            });
+            const powerW = Math.max(0, Math.round(avg.powerW));
+            return {
+                timestampIso: new Date(slotMs).toISOString(),
+                payload: { powerW, powerWh: (0, forecast_utils_js_1.wToWhPer15Min)(powerW) },
+            };
+        });
+        if (this.config.alignToRecentActuals) {
+            (0, forecast_utils_js_1.alignForecastToRecentActuals)(buckets, (iso) => isoIndex.get(iso), 'powerW', ['powerW', 'powerWh']);
+            for (const b of buckets) {
+                b.payload.powerW = Math.max(0, Math.round(b.payload.powerW));
+                b.payload.powerWh = (0, forecast_utils_js_1.wToWhPer15Min)(b.payload.powerW);
+            }
+        }
+        const entries = buckets.map((b) => ({
+            timestampIso: b.timestampIso,
+            powerW: b.payload.powerW,
+            powerWh: b.payload.powerWh,
+        }));
+        const result = {
+            generatedAtIso: new Date(now).toISOString(),
+            data: { resolution: this.config.resolution, entries },
+        };
+        if (this.config.publishToBus) {
+            this.publish(result);
+        }
+        return result;
+    }
+    /**
+     * Computes and explicitly publishes the current forecast on the data bus.
+     */
+    publishForecast() {
+        const result = this.getForecast();
+        if (!this.config.publishToBus) {
+            this.publish(result);
+        }
+    }
+    /**
+     * Detaches data-bus listeners and clears in-memory history.
+     */
+    dispose() {
+        if (this.listenerId) {
+            this.app.useDataBus().unsubscribe(this.listenerId);
+            this.listenerId = undefined;
+        }
+        this.history.length = 0;
+        this.initialized = false;
+    }
+    onAirConditioningValues(message) {
+        if (message.applianceId !== this.applianceId)
+            return;
+        const power = message.data.values.powerW;
+        if (typeof power !== 'number' || Number.isNaN(power))
+            return;
+        const ts = new Date(message.timestampIso).getTime();
+        const slotMs = (0, forecast_utils_js_1.roundDownTo15Minutes)(ts);
+        if (this.currentSlotMs === undefined || slotMs !== this.currentSlotMs) {
+            this.flushCurrentSlot(ts);
+            this.currentSlotMs = slotMs;
+            this.currentSlotPowerSum = 0;
+            this.currentSlotSamples = 0;
+        }
+        this.currentSlotPowerSum += power;
+        this.currentSlotSamples += 1;
+    }
+    flushCurrentSlot(nowMs) {
+        if (this.currentSlotMs === undefined || this.currentSlotSamples === 0)
+            return;
+        const avg = this.currentSlotPowerSum / this.currentSlotSamples;
+        (0, forecast_utils_js_1.upsertLiveBucket)(this.history, this.currentSlotMs, { powerW: avg, powerWh: (0, forecast_utils_js_1.wToWhPer15Min)(avg), samples: this.currentSlotSamples }, (existing, incoming) => {
+            const total = existing.samples + incoming.samples;
+            const mergedPowerW = (existing.powerW * existing.samples + incoming.powerW * incoming.samples) / total;
+            return {
+                powerW: mergedPowerW,
+                powerWh: (0, forecast_utils_js_1.wToWhPer15Min)(mergedPowerW),
+                samples: total,
+            };
+        });
+        if (this.currentSlotMs < (0, forecast_utils_js_1.roundDownTo15Minutes)(nowMs)) {
+            this.currentSlotMs = undefined;
+            this.currentSlotPowerSum = 0;
+            this.currentSlotSamples = 0;
+        }
+        (0, forecast_utils_js_1.trimHistory)(this.history, nowMs, this.config.historyDays * 24 * 60 * 60 * 1000 + forecast_utils_js_1.FIFTEEN_MIN_MS);
+    }
+    publish(result) {
+        const message = {
+            id: globalThis.crypto.randomUUID(),
+            type: 'message',
+            message: enyo_data_bus_value_js_1.EnyoDataBusMessageEnum.AirConditioningConsumptionForecastV1,
+            source: this.source,
+            applianceId: this.applianceId,
+            timestampIso: result.generatedAtIso,
+            resolution: 'dynamic',
+            data: result.data,
+        };
+        this.app.useDataBus().sendMessage([message]);
+    }
+}
+exports.AirConditioningConsumptionForecast = AirConditioningConsumptionForecast;
+function formatSlotKey(slotMs) {
+    const d = new Date(slotMs);
+    return `${d.getUTCHours().toString().padStart(2, '0')}:${d.getUTCMinutes()
+        .toString()
+        .padStart(2, '0')}`;
+}

package/dist/cjs/implementations/forecasts/air-conditioning-consumption-forecast.d.cts

@@ -0,0 +1,94 @@
+import { EnergyApp } from '../../energy-app.cjs';
+import { EnyoDataBusAirConditioningConsumptionForecastV1 } from '../../types/enyo-data-bus-value.cjs';
+import { EnyoSourceEnum } from '../../types/enyo-source.enum.cjs';
+import { BaseForecast, Forecaster, ForecastConfig } from './forecast-types.cjs';
+/**
+ * Forecast result returned by
+ * {@link AirConditioningConsumptionForecast.getForecast}, shaped to match
+ * `EnyoDataBusAirConditioningConsumptionForecastV1.data`.
+ */
+export type AirConditioningConsumptionForecastResult = BaseForecast<EnyoDataBusAirConditioningConsumptionForecastV1['data']>;
+/**
+ * Builds a 24-hour air conditioning electrical consumption forecast for a
+ * single air conditioning appliance (cooling and heating combined). Historical
+ * buckets are sourced from the dedicated
+ * `useTimeseries().getAirConditioningPowerTimeseries()` endpoint, and live
+ * `AirConditioningValuesUpdateV1` data-bus messages are merged in as new
+ * readings arrive.
+ *
+ * Air conditioning load follows the household's daily occupancy rhythm, so the
+ * algorithm uses a same-weekday recency-weighted average over the configured
+ * history window, with an all-weekday fallback. The default history window is
+ * 14 days (longer than the heatpump's 7): AC operation is weather-driven and
+ * bursty, so a wider window yields a more stable per-slot profile.
+ *
+ * Note: `powerW` is optional on `AirConditioningValuesUpdateV1`. Messages
+ * without a power reading are ignored rather than counted as `0 W`, so that an
+ * appliance that only reports its operation mode does not drag the forecast
+ * towards zero.
+ *
+ * Like the heatpump forecaster, this implementation does not adjust for
+ * forecasted outdoor temperature; layer a correction on top of the returned
+ * `powerW` values using the weather forecast for the same horizon if you need
+ * that.
+ *
+ * @example
+ * ```ts
+ * const forecast = new AirConditioningConsumptionForecast(app, 'ac-1', {
+ *     source: EnyoSourceEnum.Device,
+ * });
+ * await forecast.initialize();
+ * const result = forecast.getForecast();
+ * ```
+ */
+export declare class AirConditioningConsumptionForecast implements Forecaster {
+    private readonly app;
+    readonly applianceId: string;
+    /**
+     * Default history window. AC load is weather-driven and bursty, so a longer
+     * window than the heatpump's is used to stabilise the per-slot profile.
+     */
+    static readonly DEFAULT_HISTORY_DAYS = 14;
+    private readonly config;
+    private readonly history;
+    private listenerId;
+    private currentSlotMs;
+    private currentSlotPowerSum;
+    private currentSlotSamples;
+    private initialized;
+    private readonly source;
+    /**
+     * @param app - The energy-app SDK instance.
+     * @param applianceId - Air conditioning appliance ID.
+     * @param options.source - Source identifier used for outgoing forecast messages.
+     * @param options.config - Optional config overrides; `historyDays` defaults to 14.
+     */
+    constructor(app: EnergyApp, applianceId: string, options: {
+        source: EnyoSourceEnum;
+        config?: ForecastConfig;
+    });
+    /**
+     * Loads historical air conditioning power buckets via
+     * `useTimeseries().getAirConditioningPowerTimeseries()` and starts listening
+     * to live `AirConditioningValuesUpdateV1` events for ongoing updates.
+     * Idempotent.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Returns the current forecast as an
+     * `EnyoDataBusAirConditioningConsumptionForecastV1`-shaped payload over the
+     * configured horizon.
+     */
+    getForecast(): AirConditioningConsumptionForecastResult;
+    /**
+     * Computes and explicitly publishes the current forecast on the data bus.
+     */
+    publishForecast(): void;
+    /**
+     * Detaches data-bus listeners and clears in-memory history.
+     */
+    dispose(): void;
+    private onAirConditioningValues;
+    private flushCurrentSlot;
+    private publish;
+}

package/dist/cjs/implementations/forecasts/air-conditioning-room-temperature-forecast.cjs

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AirConditioningRoomTemperatureForecast = void 0;
+const enyo_data_bus_value_js_1 = require("../../types/enyo-data-bus-value.cjs");
+const forecast_types_js_1 = require("./forecast-types.cjs");
+const forecast_utils_js_1 = require("./forecast-utils.cjs");
+/**
+ * Builds a 24-hour room temperature forecast for a single air conditioning
+ * appliance from historical air conditioning temperature timeseries data, with
+ * live updates merged in from `AirConditioningTemperaturesUpdateV1` data-bus
+ * events.
+ *
+ * Room temperature follows the household's daily occupancy and setpoint
+ * rhythm, which is strongly weekday-cyclic, so the algorithm uses a
+ * same-weekday recency-weighted average over the configured history window
+ * (default 7 d), with an all-weekday fallback. A single room can be selected
+ * via {@link AirConditioningRoomTemperatureForecastConfig.roomIndex};
+ * otherwise all reported rooms are averaged per timestamp.
+ *
+ * The forecast is the primary input for planning AC flexibility — for example
+ * pre-cooling on forecasted PV surplus — since it says where the room
+ * temperature is heading if nothing changes.
+ *
+ * @example
+ * ```ts
+ * const forecast = new AirConditioningRoomTemperatureForecast(app, 'ac-1', {
+ *     source: EnyoSourceEnum.Device,
+ *     config: { roomIndex: 0 },
+ * });
+ * await forecast.initialize();
+ * const result = forecast.getForecast();
+ * ```
+ */
+class AirConditioningRoomTemperatureForecast {
+    app;
+    applianceId;
+    /** Default history window. Room temperature cycles are weekday-cyclic. */
+    static DEFAULT_HISTORY_DAYS = 7;
+    config;
+    history = [];
+    roomIndex;
+    listenerId;
+    currentSlotMs;
+    currentSlotTempSum = 0;
+    currentSlotSamples = 0;
+    initialized = false;
+    source;
+    /**
+     * @param app - The energy-app SDK instance.
+     * @param applianceId - Air conditioning appliance ID.
+     * @param options.source - Source identifier used for outgoing forecast messages.
+     * @param options.config - Optional config overrides; `historyDays` defaults to 7.
+     */
+    constructor(app, applianceId, options) {
+        this.app = app;
+        this.applianceId = applianceId;
+        this.config = (0, forecast_types_js_1.resolveForecastConfig)({ historyDays: AirConditioningRoomTemperatureForecast.DEFAULT_HISTORY_DAYS }, options.config);
+        this.source = options.source;
+        this.roomIndex = options.config?.roomIndex;
+    }
+    /**
+     * Pulls the air conditioning temperature timeseries history and starts
+     * listening to live `AirConditioningTemperaturesUpdateV1` events.
+     * Idempotent.
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        this.initialized = true;
+        const now = Date.now();
+        const startMs = now - this.config.historyDays * 24 * 60 * 60 * 1000;
+        const response = await this.app.useTimeseries().getAirConditioningTemperatureTimeseries({
+            startDateIso: new Date(startMs).toISOString(),
+            endDateIso: new Date(now).toISOString(),
+            applianceIds: [this.applianceId],
+            resolution: this.config.resolution,
+        });
+        for (const entry of response.entries) {
+            const temperature = this.extractHistoricalTemperature(entry.rooms);
+            if (temperature === undefined)
+                continue;
+            this.history.push({
+                timestampIso: entry.timestampIso,
+                values: { temperatureC: temperature, samples: 1 },
+            });
+        }
+        this.listenerId = this.app.useDataBus().listenForMessages([enyo_data_bus_value_js_1.EnyoDataBusMessageEnum.AirConditioningTemperaturesUpdateV1], (msg) => this.onAirConditioningTemperatures(msg));
+    }
+    /**
+     * Returns the current forecast as an
+     * `EnyoDataBusAirConditioningRoomTemperatureForecastV1`-shaped payload over
+     * the configured horizon.
+     */
+    getForecast() {
+        const now = Date.now();
+        this.flushCurrentSlot(now);
+        const parsed = (0, forecast_utils_js_1.parseHistory)(this.history);
+        const todayWeekday = new Date(now).getUTCDay();
+        const sameWeekdayMap = (0, forecast_utils_js_1.buildSlotMap)(parsed, (b) => b.weekday === todayWeekday);
+        const fallbackMap = (0, forecast_utils_js_1.buildSlotMap)(parsed);
+        const isoIndex = (0, forecast_utils_js_1.buildIsoIndex)(parsed, (v) => v.temperatureC);
+        const buckets = (0, forecast_utils_js_1.buildForecastSlots)(now, this.config.horizonHours, this.config.resolution).map((slotMs) => {
+            const key = formatSlotKey(slotMs);
+            const slotBuckets = sameWeekdayMap.get(key) ?? fallbackMap.get(key);
+            const avg = (0, forecast_utils_js_1.weightedAverageBySlot)(slotBuckets, now, this.config.historyDays, {
+                temperatureC: (v) => v.temperatureC,
+            });
+            return {
+                timestampIso: new Date(slotMs).toISOString(),
+                payload: { temperatureC: avg.temperatureC },
+            };
+        });
+        if (this.config.alignToRecentActuals) {
+            (0, forecast_utils_js_1.alignForecastToRecentActuals)(buckets, (iso) => isoIndex.get(iso), 'temperatureC', ['temperatureC']);
+        }
+        const entries = buckets.map((b) => ({
+            timestampIso: b.timestampIso,
+            temperatureC: round1(b.payload.temperatureC),
+        }));
+        const result = {
+            generatedAtIso: new Date(now).toISOString(),
+            data: {
+                resolution: this.config.resolution,
+                ...(this.roomIndex !== undefined ? { roomIndex: this.roomIndex } : {}),
+                entries,
+            },
+        };
+        if (this.config.publishToBus) {
+            this.publish(result);
+        }
+        return result;
+    }
+    /**
+     * Computes and explicitly publishes the current forecast on the data bus.
+     */
+    publishForecast() {
+        const result = this.getForecast();
+        if (!this.config.publishToBus) {
+            this.publish(result);
+        }
+    }
+    /**
+     * Detaches data-bus listeners and clears in-memory history.
+     */
+    dispose() {
+        if (this.listenerId) {
+            this.app.useDataBus().unsubscribe(this.listenerId);
+            this.listenerId = undefined;
+        }
+        this.history.length = 0;
+        this.initialized = false;
+    }
+    onAirConditioningTemperatures(message) {
+        if (message.applianceId !== this.applianceId)
+            return;
+        const rooms = message.data.rooms;
+        if (!rooms || rooms.length === 0)
+            return;
+        const temperature = this.extractLiveTemperature(rooms);
+        if (temperature === undefined)
+            return;
+        const ts = new Date(message.timestampIso).getTime();
+        const slotMs = (0, forecast_utils_js_1.roundDownTo15Minutes)(ts);
+        if (this.currentSlotMs === undefined || slotMs !== this.currentSlotMs) {
+            this.flushCurrentSlot(ts);
+            this.currentSlotMs = slotMs;
+            this.currentSlotTempSum = 0;
+            this.currentSlotSamples = 0;
+        }
+        this.currentSlotTempSum += temperature;
+        this.currentSlotSamples += 1;
+    }
+    flushCurrentSlot(nowMs) {
+        if (this.currentSlotMs === undefined || this.currentSlotSamples === 0)
+            return;
+        const avg = this.currentSlotTempSum / this.currentSlotSamples;
+        (0, forecast_utils_js_1.upsertLiveBucket)(this.history, this.currentSlotMs, { temperatureC: avg, samples: this.currentSlotSamples }, (existing, incoming) => {
+            const total = existing.samples + incoming.samples;
+            return {
+                temperatureC: (existing.temperatureC * existing.samples + incoming.temperatureC * incoming.samples) / total,
+                samples: total,
+            };
+        });
+        if (this.currentSlotMs < (0, forecast_utils_js_1.roundDownTo15Minutes)(nowMs)) {
+            this.currentSlotMs = undefined;
+            this.currentSlotTempSum = 0;
+            this.currentSlotSamples = 0;
+        }
+        (0, forecast_utils_js_1.trimHistory)(this.history, nowMs, this.config.historyDays * 24 * 60 * 60 * 1000 + forecast_utils_js_1.FIFTEEN_MIN_MS);
+    }
+    extractHistoricalTemperature(rooms) {
+        if (!rooms || rooms.length === 0)
+            return undefined;
+        const matching = this.roomIndex !== undefined
+            ? rooms.filter((r) => r.index === this.roomIndex)
+            : rooms;
+        if (matching.length === 0)
+            return undefined;
+        const sum = matching.reduce((acc, r) => acc + r.averageTemperatureC, 0);
+        return sum / matching.length;
+    }
+    extractLiveTemperature(rooms) {
+        const matching = this.roomIndex !== undefined
+            ? rooms.filter((r) => r.index === this.roomIndex)
+            : rooms;
+        if (matching.length === 0)
+            return undefined;
+        const sum = matching.reduce((acc, r) => acc + r.temperatureC, 0);
+        return sum / matching.length;
+    }
+    publish(result) {
+        const message = {
+            id: globalThis.crypto.randomUUID(),
+            type: 'message',
+            message: enyo_data_bus_value_js_1.EnyoDataBusMessageEnum.AirConditioningRoomTemperatureForecastV1,
+            source: this.source,
+            applianceId: this.applianceId,
+            timestampIso: result.generatedAtIso,
+            resolution: 'dynamic',
+            data: result.data,
+        };
+        this.app.useDataBus().sendMessage([message]);
+    }
+}
+exports.AirConditioningRoomTemperatureForecast = AirConditioningRoomTemperatureForecast;
+function round1(value) {
+    return Math.round(value * 10) / 10;
+}
+function formatSlotKey(slotMs) {
+    const d = new Date(slotMs);
+    return `${d.getUTCHours().toString().padStart(2, '0')}:${d.getUTCMinutes()
+        .toString()
+        .padStart(2, '0')}`;
+}