@glasshome/sync-layer 0.3.2 → 0.5.0

package/dist/index.js

@@ -1,7 +1,6 @@
-import { ENERGY_ENTITY_IDS, createDemoFixtures, demoEnergyPreferences, energyEntityValue, formatEnergyState, isEnergyEntity, isSunUp, resetStore, setState, simulateEnergy, state, sunEvents, synthesizeEnergyHistory, synthesizeEnergyStatistics } from "./demo-data-3LO-p1RV.js";
-import { runHaBridgeWorker } from "./worker-main-DTbzEKor.js";
+import { runHaBridgeWorker } from "./worker-main-Cf-k4f2N.js";
 import { createConnection, createLongLivedTokenAuth, getAuth } from "home-assistant-js-websocket";
-import { produce, reconcile } from "solid-js/store";
+import { createStore, produce, reconcile } from "solid-js/store";
 
 //#region src/connection/adapter.ts
 /**
@@ -106,6 +105,39 @@ function wrapHAConnection(conn$1) {
 	};
 }
 
+//#endregion
+//#region src/core/store.ts
+const initialState = {
+	conn: null,
+	connectionState: "disconnected",
+	connectionError: null,
+	hassUrl: null,
+	mediaProxyBase: null,
+	config: null,
+	entities: {},
+	entityRegistry: {},
+	devices: {},
+	areas: {},
+	floors: {},
+	labels: {},
+	statistics: {},
+	statisticsMetadata: {},
+	history: {},
+	forecasts: {},
+	streams: {}
+};
+if (globalThis.__GH_SYNC_LAYER_STORE__) console.error("[@glasshome/sync-layer] DUPLICATE store module instantiated. This means @glasshome/sync-layer was bundled into >1 chunk. Reads and writes will hit different singletons. Check vendor build externals and relative-vs-bare imports across entry points.");
+globalThis.__GH_SYNC_LAYER_STORE__ = true;
+const storeTuple = createStore(initialState);
+const state = storeTuple[0];
+const setState = storeTuple[1];
+/**
+* Reset store to initial state
+*/
+function resetStore() {
+	setState(reconcile(initialState));
+}
+
 //#endregion
 //#region src/core/reducers.ts
 /**
@@ -247,18 +279,18 @@ function updateStatisticsMetadata(metadata) {
 * Authenticate using OAuth flow
 *
 * This function uses `getAuth` from `home-assistant-js-websocket` which:
-* 1. Opens Home Assistant authorization page in a popup
+* 1. Redirects the whole page to the Home Assistant authorization page
 * 2. Waits for user authorization
-* 3. Exchanges authorization code for tokens
-* 4. Returns authenticated Auth object
+* 3. On return, HA redirects back to the app URL with `?auth_callback=1&code=…`
+* 4. Exchanges the authorization code for tokens and returns an Auth object
 *
 * Note: For a complete OAuth flow, you typically need to:
 * - Set up a redirect URI endpoint in your app
 * - Handle the OAuth callback with the authorization code
 * - Use `getAuthCode` callback to provide the code
 *
-* Alternatively, `getAuth` can automatically handle the flow in browser environments
-* by opening a popup and listening for the callback.
+* In browser environments `getAuth` handles this automatically via a full-page
+* redirect (not a popup); native platforms supply `getAuthCode` instead.
 *
 * @param options - OAuth options
 * @returns Authenticated Auth object
@@ -501,6 +533,1250 @@ function extractDomain(entityId) {
 	return entityId.split(".")[0] ?? "";
 }
 
+//#endregion
+//#region src/demo/energy-sim.ts
+const SOLAR_PEAK_W = 5200;
+const SUNRISE_HOUR = 6.5;
+const SUNSET_HOUR = 20.5;
+const ALWAYS_ON_W = 285;
+const FRIDGE_W = 95;
+const FRIDGE_CYCLE_MIN = 45;
+const FRIDGE_ON_MIN = 18;
+const BATTERY_CAPACITY_WH = 1e4;
+const BATTERY_MIN_SOC = 10;
+const BATTERY_MAX_SOC = 100;
+const BATTERY_POWER_CAP_W = 3e3;
+const MIDNIGHT_SOC = 55;
+const SOC_STEP_MIN = 5;
+/** Integer hash -> uint32, used to seed mulberry32 deterministically. */
+function hashInt(n) {
+	let h = n | 0;
+	h = Math.imul(h ^ h >>> 16, 73244475);
+	h = Math.imul(h ^ h >>> 16, 73244475);
+	h = (h ^ h >>> 16) >>> 0;
+	return h;
+}
+/** Deterministic [0,1) generator seeded by an integer. */
+function mulberry32(seed) {
+	let a = seed >>> 0;
+	return () => {
+		a |= 0;
+		a = a + 1831565813 | 0;
+		let t = Math.imul(a ^ a >>> 15, 1 | a);
+		t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+function localTime(timestampMs) {
+	const d = new Date(timestampMs);
+	const hours = d.getHours();
+	const minutes = d.getMinutes();
+	const seconds = d.getSeconds();
+	const hourFrac = hours + minutes / 60 + seconds / 3600;
+	const minuteOfDay = hours * 60 + minutes + seconds / 60;
+	const offsetMs = d.getTimezoneOffset() * 6e4;
+	const dayKey = Math.floor((timestampMs - offsetMs) / 864e5);
+	return {
+		hourFrac,
+		minuteOfDay,
+		dayOfWeek: d.getDay(),
+		dayKey
+	};
+}
+function localMidnightMs(timestampMs, lt) {
+	return timestampMs - lt.minuteOfDay * 6e4;
+}
+/** Smooth multiplicative cloud factor in [0.55, 1.0], seeded per day. */
+function cloudFactor(lt) {
+	const rand = mulberry32(hashInt(lt.dayKey * 2654435761));
+	const phase1 = rand() * Math.PI * 2;
+	const phase2 = rand() * Math.PI * 2;
+	const phase3 = rand() * Math.PI * 2;
+	const m = lt.minuteOfDay;
+	const wave = .16 * Math.sin(m / 37 * Math.PI * 2 + phase1) + .14 * Math.sin(m / 73 * Math.PI * 2 + phase2) + .05 * Math.sin(m / 11 * Math.PI * 2 + phase3);
+	const f = .85 + wave;
+	return Math.max(.55, Math.min(1, f));
+}
+function solarPower(lt) {
+	if (lt.hourFrac <= SUNRISE_HOUR || lt.hourFrac >= SUNSET_HOUR) return 0;
+	const frac = (lt.hourFrac - SUNRISE_HOUR) / (SUNSET_HOUR - SUNRISE_HOUR);
+	const shape = Math.sin(frac * Math.PI) ** 1.3;
+	return SOLAR_PEAK_W * shape * cloudFactor(lt);
+}
+/** Coarse solar elevation in degrees for sun.sun attributes. */
+function sunElevation(lt) {
+	if (lt.hourFrac <= SUNRISE_HOUR || lt.hourFrac >= SUNSET_HOUR) return -12;
+	const frac = (lt.hourFrac - SUNRISE_HOUR) / (SUNSET_HOUR - SUNRISE_HOUR);
+	return 60 * Math.sin(frac * Math.PI);
+}
+function fridgePower(lt) {
+	const rand = mulberry32(hashInt(lt.dayKey * 40503 + 7));
+	const phase = rand() * FRIDGE_CYCLE_MIN;
+	const pos = (lt.minuteOfDay + phase) % FRIDGE_CYCLE_MIN;
+	return pos < FRIDGE_ON_MIN ? FRIDGE_W : 0;
+}
+/** A square wave: `power` while inside [start, start+durationMin). */
+function windowPower(minuteOfDay, startMin, durationMin, power) {
+	return minuteOfDay >= startMin && minuteOfDay < startMin + durationMin ? power : 0;
+}
+function kettlePower(lt) {
+	return windowPower(lt.minuteOfDay, 430, 4, 2e3) + windowPower(lt.minuteOfDay, 1e3, 4, 2e3);
+}
+function ovenPower(lt) {
+	const start = 1125;
+	if (lt.minuteOfDay < start || lt.minuteOfDay >= start + 40) return 0;
+	const into = lt.minuteOfDay - start;
+	const cyclePos = into % 6.5;
+	return cyclePos < 4 ? 2200 : 0;
+}
+function dishwasherPower(lt) {
+	const start = 1270;
+	if (lt.minuteOfDay < start || lt.minuteOfDay >= start + 65) return 0;
+	const into = lt.minuteOfDay - start;
+	if (into < 12) return 1900;
+	if (into >= 57) return 1900;
+	return 120;
+}
+function washerPower(lt) {
+	if (![
+		1,
+		4,
+		6
+	].includes(lt.dayOfWeek)) return 0;
+	const start = 630;
+	if (lt.minuteOfDay < start || lt.minuteOfDay >= start + 50) return 0;
+	const into = lt.minuteOfDay - start;
+	return into < 14 ? 2100 : 250;
+}
+function evChargerPower(lt) {
+	if (![
+		2,
+		4,
+		0
+	].includes(lt.dayOfWeek)) return 0;
+	const start = 1100;
+	const stop = 1300;
+	if (lt.minuteOfDay < start || lt.minuteOfDay >= stop) return 0;
+	const into = lt.minuteOfDay - start;
+	const ramp = into < 2 ? into / 2 : 1;
+	return 7200 * ramp;
+}
+const HEAT_PUMP_PEAK_W = 3200;
+/**
+* A smooth heat-pump load: a slow morning/evening envelope carrying a
+* few-minute shimmer. Its peaks push the home deficit past the battery's power
+* cap, so grid import (and the running cost) visibly rise and fall on live
+* ticks instead of sitting at zero. Gated out of the deep-night window so the
+* quiet 02:00-03:00 baseline is unchanged.
+*/
+function heatPumpPower(lt) {
+	const h = lt.hourFrac;
+	let envelope = 0;
+	if (h >= 6 && h <= 9) envelope = Math.sin((h - 6) / 3 * Math.PI);
+	else if (h >= 16 && h <= 23) envelope = Math.sin((h - 16) / 7 * Math.PI);
+	else return 0;
+	const shimmer = .7 + .3 * Math.sin(lt.minuteOfDay * Math.PI * 2);
+	return HEAT_PUMP_PEAK_W * envelope * shimmer;
+}
+/** Smooth occupancy envelope: extra load mornings and evenings. */
+function occupancyEnvelope(lt) {
+	const h = lt.hourFrac;
+	let e = 0;
+	if (h >= 7 && h <= 9) e += 80 + 270 * Math.sin((h - 7) / 2 * Math.PI);
+	if (h >= 17.5 && h <= 23) e += 80 + 270 * Math.sin((h - 17.5) / 5.5 * Math.PI);
+	return e;
+}
+/** Low-amplitude smooth noise multiplier, ±4%, seeded per day. */
+function homeNoise(lt) {
+	const rand = mulberry32(hashInt(lt.dayKey * 22699 + 13));
+	const phase = rand() * Math.PI * 2;
+	return 1 + .04 * Math.sin(lt.minuteOfDay / 23 * Math.PI * 2 + phase);
+}
+const socCache = /* @__PURE__ */ new Map();
+/** Net surplus (solar - home) at a given local-time sample, in watts. */
+function netSurplusAt(timestampMs) {
+	const lt = localTime(timestampMs);
+	const solar = solarPower(lt);
+	const home = homePower(lt);
+	return solar - home;
+}
+/**
+* Battery SOC (%) at every {@link SOC_STEP_MIN}-minute step from local
+* midnight. Returns step `i` = SOC after integrating `i` steps. Index 0 is
+* the midnight SOC. Memoized per local day (pure computation).
+*/
+function socPrefix(dayKey, midnightMs) {
+	const cached = socCache.get(dayKey);
+	if (cached) return cached;
+	const steps = Math.ceil(24 * 60 / SOC_STEP_MIN);
+	const arr = new Float64Array(steps + 1);
+	arr[0] = MIDNIGHT_SOC;
+	const stepMs = SOC_STEP_MIN * 6e4;
+	const stepHours = SOC_STEP_MIN / 60;
+	for (let i = 0; i < steps; i++) {
+		const soc = arr[i] ?? MIDNIGHT_SOC;
+		const sampleMs = midnightMs + i * stepMs;
+		const surplus = netSurplusAt(sampleMs);
+		let chargeW = 0;
+		let dischargeW = 0;
+		if (surplus > 0) {
+			const headroomWh = (BATTERY_MAX_SOC - soc) / 100 * BATTERY_CAPACITY_WH;
+			const headroomW = headroomWh / stepHours;
+			chargeW = Math.min(surplus, BATTERY_POWER_CAP_W, Math.max(0, headroomW));
+		} else if (surplus < 0) {
+			const availWh = (soc - BATTERY_MIN_SOC) / 100 * BATTERY_CAPACITY_WH;
+			const availW = availWh / stepHours;
+			dischargeW = Math.min(-surplus, BATTERY_POWER_CAP_W, Math.max(0, availW));
+		}
+		const deltaWh = (chargeW - dischargeW) * stepHours;
+		const nextSoc = soc + deltaWh / BATTERY_CAPACITY_WH * 100;
+		arr[i + 1] = Math.max(BATTERY_MIN_SOC, Math.min(BATTERY_MAX_SOC, nextSoc));
+	}
+	socCache.set(dayKey, arr);
+	return arr;
+}
+/** Battery SOC (%) at an exact timestamp, linearly interpolated between steps. */
+function batterySoc(lt, midnightMs) {
+	const prefix = socPrefix(lt.dayKey, midnightMs);
+	const stepFloat = lt.minuteOfDay / SOC_STEP_MIN;
+	const i = Math.floor(stepFloat);
+	const frac = stepFloat - i;
+	const a = prefix[i] ?? MIDNIGHT_SOC;
+	const b = prefix[i + 1] ?? a;
+	return a + (b - a) * frac;
+}
+function homePower(lt) {
+	const base = ALWAYS_ON_W + fridgePower(lt) + kettlePower(lt) + ovenPower(lt) + dishwasherPower(lt) + washerPower(lt) + evChargerPower(lt) + heatPumpPower(lt) + occupancyEnvelope(lt);
+	return base * homeNoise(lt);
+}
+/**
+* Compute every instantaneous energy value at a timestamp.
+*
+* Deterministic: equal timestamps always yield deep-equal samples. Obeys the
+* conservation invariant
+* `solar + gridImport + batteryDischarge === home + gridExport + batteryCharge`
+* to within rounding.
+*/
+function simulateEnergy(timestampMs) {
+	const lt = localTime(timestampMs);
+	const midnightMs = localMidnightMs(timestampMs, lt);
+	const solarW = solarPower(lt);
+	const fridgeW = fridgePower(lt);
+	const ovenW = ovenPower(lt);
+	const dishwasherW = dishwasherPower(lt);
+	const washerW = washerPower(lt);
+	const evChargerW = evChargerPower(lt);
+	const alwaysOnW = ALWAYS_ON_W;
+	const homeW = homePower(lt);
+	const soc = batterySoc(lt, midnightMs);
+	const surplus = solarW - homeW;
+	let batteryChargeW = 0;
+	let batteryDischargeW = 0;
+	if (surplus > 0) {
+		const headroom = soc < BATTERY_MAX_SOC ? BATTERY_POWER_CAP_W : 0;
+		batteryChargeW = Math.min(surplus, headroom);
+	} else if (surplus < 0) {
+		const avail = soc > BATTERY_MIN_SOC ? BATTERY_POWER_CAP_W : 0;
+		batteryDischargeW = Math.min(-surplus, avail);
+	}
+	const remainingDeficit = homeW - solarW - batteryDischargeW + batteryChargeW;
+	const gridImportW = Math.max(0, remainingDeficit);
+	const gridExportW = Math.max(0, -remainingDeficit);
+	return {
+		solarW,
+		homeW,
+		batteryChargeW,
+		batteryDischargeW,
+		batterySocPct: soc,
+		gridImportW,
+		gridExportW,
+		fridgeW,
+		dishwasherW,
+		washerW,
+		ovenW,
+		evChargerW,
+		alwaysOnW
+	};
+}
+/** Whether the sun is above the horizon at a timestamp. */
+function isSunUp(timestampMs) {
+	const lt = localTime(timestampMs);
+	return lt.hourFrac > SUNRISE_HOUR && lt.hourFrac < SUNSET_HOUR;
+}
+/** Next sunrise/sunset ISO strings relative to a timestamp. */
+function sunEvents(timestampMs) {
+	const lt = localTime(timestampMs);
+	const midnightMs = localMidnightMs(timestampMs, lt);
+	const sunriseMs = midnightMs + SUNRISE_HOUR * 36e5;
+	const sunsetMs = midnightMs + SUNSET_HOUR * 36e5;
+	const nextRising = timestampMs < sunriseMs ? sunriseMs : sunriseMs + 864e5;
+	const nextSetting = timestampMs < sunsetMs ? sunsetMs : sunsetMs + 864e5;
+	return {
+		nextRising: new Date(nextRising).toISOString(),
+		nextSetting: new Date(nextSetting).toISOString(),
+		elevation: Math.round(sunElevation(lt) * 100) / 100
+	};
+}
+/** The energy sensor entity ids the simulation drives. */
+const ENERGY_ENTITY_IDS = [
+	"sensor.solar_power",
+	"sensor.grid_import_power",
+	"sensor.grid_export_power",
+	"sensor.battery_charge_power",
+	"sensor.battery_discharge_power",
+	"sensor.battery_soc",
+	"sensor.home_power",
+	"sensor.fridge_power",
+	"sensor.dishwasher_power",
+	"sensor.washing_machine_power",
+	"sensor.oven_power",
+	"sensor.ev_charger_power",
+	"sensor.always_on_power"
+];
+/** Map an energy entity id to its numeric value from a sample (W, or % for SOC). */
+function energyEntityValue(entityId, sample) {
+	switch (entityId) {
+		case "sensor.solar_power": return sample.solarW;
+		case "sensor.grid_import_power": return sample.gridImportW;
+		case "sensor.grid_export_power": return sample.gridExportW;
+		case "sensor.battery_charge_power": return sample.batteryChargeW;
+		case "sensor.battery_discharge_power": return sample.batteryDischargeW;
+		case "sensor.battery_soc": return sample.batterySocPct;
+		case "sensor.home_power": return sample.homeW;
+		case "sensor.fridge_power": return sample.fridgeW;
+		case "sensor.dishwasher_power": return sample.dishwasherW;
+		case "sensor.washing_machine_power": return sample.washerW;
+		case "sensor.oven_power": return sample.ovenW;
+		case "sensor.ev_charger_power": return sample.evChargerW;
+		case "sensor.always_on_power": return sample.alwaysOnW;
+		default: return void 0;
+	}
+}
+/** Whether an entity id is one of the simulated energy sensors. */
+function isEnergyEntity(entityId) {
+	return energyEntityValue(entityId, ZERO_SAMPLE) !== void 0;
+}
+const ZERO_SAMPLE = {
+	solarW: 0,
+	homeW: 0,
+	batteryChargeW: 0,
+	batteryDischargeW: 0,
+	batterySocPct: 0,
+	gridImportW: 0,
+	gridExportW: 0,
+	fridgeW: 0,
+	dishwasherW: 0,
+	washerW: 0,
+	ovenW: 0,
+	evChargerW: 0,
+	alwaysOnW: 0
+};
+/** Round to 1 decimal for display-friendly state strings (whole % for SOC). */
+function formatEnergyState(entityId, value) {
+	if (entityId === "sensor.battery_soc") return String(Math.round(value));
+	return String(Math.round(value));
+}
+/**
+* Synthesize history points for one energy entity by sampling the model across
+* the window at a fixed cadence (default 1-minute). Returns HA-compressed
+* `{ lu, s }` points with `lu` in Unix seconds.
+*/
+function synthesizeEnergyHistory(entityId, startMs, endMs, stepMs = 6e4) {
+	const points = [];
+	for (let t = startMs; t <= endMs; t += stepMs) {
+		const value = energyEntityValue(entityId, simulateEnergy(t));
+		if (value === void 0) continue;
+		points.push({
+			lu: Math.round(t / 1e3),
+			s: formatEnergyState(entityId, value)
+		});
+	}
+	return points;
+}
+/** Bucket length in ms for a statistics period. */
+function bucketMs(period) {
+	return period === "hour" ? 36e5 : 864e5;
+}
+/**
+* Synthesize statistics buckets for one energy entity across a window.
+*
+* `mean`/`min`/`max` come from 5-minute power samples in the bucket; `sum` is
+* the energy in Wh (mean W times bucket hours). `sum` is cumulative across the
+* window, matching HA's monotonically increasing meter semantics.
+*/
+function synthesizeEnergyStatistics(entityId, startMs, endMs, period) {
+	const span = bucketMs(period);
+	const sampleMs = 5 * 6e4;
+	const buckets = [];
+	let cumulativeWh = 0;
+	for (let bStart = startMs; bStart < endMs; bStart += span) {
+		const bEnd = bStart + span;
+		let sum = 0;
+		let count = 0;
+		let min = Number.POSITIVE_INFINITY;
+		let max = Number.NEGATIVE_INFINITY;
+		for (let t = bStart; t < bEnd; t += sampleMs) {
+			const value = energyEntityValue(entityId, simulateEnergy(t));
+			if (value === void 0) continue;
+			sum += value;
+			count++;
+			if (value < min) min = value;
+			if (value > max) max = value;
+		}
+		if (count === 0) continue;
+		const mean = sum / count;
+		const bucketHours = span / 36e5;
+		const energyWh = entityId === "sensor.battery_soc" ? 0 : mean * bucketHours;
+		cumulativeWh += energyWh;
+		buckets.push({
+			start: bStart,
+			end: bEnd,
+			mean,
+			min: min === Number.POSITIVE_INFINITY ? mean : min,
+			max: max === Number.NEGATIVE_INFINITY ? mean : max,
+			sum: cumulativeWh,
+			change: energyWh / 1e3
+		});
+	}
+	return buckets;
+}
+/** The demo energy dashboard preferences wiring the simulated sensors. */
+function demoEnergyPreferences() {
+	return {
+		energy_sources: [
+			{
+				type: "solar",
+				stat_energy_from: "sensor.solar_power"
+			},
+			{
+				type: "grid",
+				flow_from: [{ stat_energy_from: "sensor.grid_import_power" }],
+				flow_to: [{ stat_energy_to: "sensor.grid_export_power" }]
+			},
+			{
+				type: "battery",
+				stat_energy_from: "sensor.battery_discharge_power",
+				stat_energy_to: "sensor.battery_charge_power"
+			}
+		],
+		device_consumption: [
+			{
+				stat_consumption: "sensor.fridge_power",
+				name: "Fridge"
+			},
+			{
+				stat_consumption: "sensor.dishwasher_power",
+				name: "Dishwasher"
+			},
+			{
+				stat_consumption: "sensor.washing_machine_power",
+				name: "Washing Machine"
+			},
+			{
+				stat_consumption: "sensor.oven_power",
+				name: "Oven"
+			},
+			{
+				stat_consumption: "sensor.ev_charger_power",
+				name: "EV Charger"
+			},
+			{
+				stat_consumption: "sensor.always_on_power",
+				name: "Always On"
+			}
+		]
+	};
+}
+
+//#endregion
+//#region src/demo/demo-data.ts
+const now = (/* @__PURE__ */ new Date()).toISOString();
+let contextCounter = 0;
+function ctx() {
+	return {
+		id: `demo-${++contextCounter}`,
+		parent_id: null,
+		user_id: null
+	};
+}
+function makeEntity(entity_id, state$1, attributes = {}) {
+	return {
+		entity_id,
+		state: state$1,
+		attributes: {
+			friendly_name: friendlyName(entity_id),
+			...attributes
+		},
+		last_changed: now,
+		last_updated: now,
+		context: ctx()
+	};
+}
+/**
+* One entity per weather scene the widget can render. Entity IDs use the
+* `weather.demo_<slug>` form so a demo dashboard can reference them directly.
+*/
+const WEATHER_FIXTURES = [
+	{
+		slug: "sunny",
+		state: "sunny",
+		temp: 28,
+		apparent: 31,
+		humidity: 35,
+		pressure: 1018,
+		wind: 8,
+		low: 18
+	},
+	{
+		slug: "clear_night",
+		state: "clear-night",
+		temp: 14,
+		apparent: 12,
+		humidity: 55,
+		pressure: 1016,
+		wind: 5,
+		low: 9
+	},
+	{
+		slug: "cloudy",
+		state: "cloudy",
+		temp: 17,
+		apparent: 16,
+		humidity: 72,
+		pressure: 1010,
+		wind: 14,
+		low: 11
+	},
+	{
+		slug: "partly_cloudy",
+		state: "partlycloudy",
+		temp: 23,
+		apparent: 24,
+		humidity: 50,
+		pressure: 1014,
+		wind: 12,
+		low: 15
+	},
+	{
+		slug: "rainy",
+		state: "rainy",
+		temp: 12,
+		apparent: 10,
+		humidity: 88,
+		pressure: 1004,
+		wind: 18,
+		low: 8
+	},
+	{
+		slug: "pouring",
+		state: "pouring",
+		temp: 11,
+		apparent: 8,
+		humidity: 95,
+		pressure: 998,
+		wind: 26,
+		low: 7
+	},
+	{
+		slug: "snowy",
+		state: "snowy",
+		temp: -2,
+		apparent: -6,
+		humidity: 80,
+		pressure: 1020,
+		wind: 10,
+		low: -7
+	},
+	{
+		slug: "snowy_rainy",
+		state: "snowy-rainy",
+		temp: 1,
+		apparent: -2,
+		humidity: 92,
+		pressure: 1006,
+		wind: 16,
+		low: -2
+	},
+	{
+		slug: "lightning",
+		state: "lightning",
+		temp: 22,
+		apparent: 24,
+		humidity: 78,
+		pressure: 1001,
+		wind: 22,
+		low: 17
+	},
+	{
+		slug: "lightning_rainy",
+		state: "lightning-rainy",
+		temp: 19,
+		apparent: 18,
+		humidity: 90,
+		pressure: 996,
+		wind: 28,
+		low: 14
+	},
+	{
+		slug: "fog",
+		state: "fog",
+		temp: 8,
+		apparent: 6,
+		humidity: 98,
+		pressure: 1015,
+		wind: 4,
+		low: 6
+	},
+	{
+		slug: "hail",
+		state: "hail",
+		temp: 6,
+		apparent: 3,
+		humidity: 84,
+		pressure: 1002,
+		wind: 20,
+		low: 1
+	},
+	{
+		slug: "windy",
+		state: "windy",
+		temp: 18,
+		apparent: 15,
+		humidity: 60,
+		pressure: 1009,
+		wind: 42,
+		low: 12
+	},
+	{
+		slug: "exceptional",
+		state: "exceptional",
+		temp: 38,
+		apparent: 44,
+		humidity: 22,
+		pressure: 1005,
+		wind: 30,
+		low: 28
+	}
+];
+function makeWeatherEntity(w) {
+	const today = /* @__PURE__ */ new Date();
+	const day = (n) => new Date(today.getTime() + n * 864e5).toISOString();
+	return makeEntity(`weather.demo_${w.slug}`, w.state, {
+		temperature: w.temp,
+		temperature_unit: "°C",
+		apparent_temperature: w.apparent ?? w.temp,
+		humidity: w.humidity,
+		pressure: w.pressure,
+		pressure_unit: "hPa",
+		wind_speed: w.wind,
+		wind_speed_unit: "km/h",
+		wind_bearing: w.bearing ?? 220,
+		visibility: 10,
+		visibility_unit: "km",
+		uv_index: w.state === "sunny" ? 8 : 2,
+		forecast: [
+			{
+				datetime: day(0),
+				condition: w.state,
+				temperature: w.temp,
+				templow: w.low
+			},
+			{
+				datetime: day(1),
+				condition: "partlycloudy",
+				temperature: w.temp + 2,
+				templow: w.low
+			},
+			{
+				datetime: day(2),
+				condition: "cloudy",
+				temperature: w.temp + 1,
+				templow: w.low - 1
+			},
+			{
+				datetime: day(3),
+				condition: "sunny",
+				temperature: w.temp + 4,
+				templow: w.low + 1
+			},
+			{
+				datetime: day(4),
+				condition: "rainy",
+				temperature: w.temp - 2,
+				templow: w.low - 2
+			}
+		]
+	});
+}
+function friendlyName(entityId) {
+	const objectId = entityId.split(".")[1] ?? entityId;
+	return objectId.split("_").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function makeRegistryEntry(entity_id, overrides = {}) {
+	const domain = entity_id.split(".")[0] ?? "";
+	return {
+		aliases: [],
+		area_id: null,
+		capabilities: null,
+		categories: {},
+		config_entry_id: "demo_config",
+		config_subentry_id: null,
+		created_at: now,
+		device_class: null,
+		device_id: null,
+		disabled_by: null,
+		entity_category: null,
+		entity_id,
+		has_entity_name: false,
+		hidden_by: null,
+		icon: null,
+		id: `reg-${entity_id.replace(".", "-")}`,
+		labels: [],
+		modified_at: now,
+		name: null,
+		options: {},
+		original_device_class: null,
+		original_icon: null,
+		original_name: null,
+		platform: domain === "weather" ? "met" : "demo",
+		previous_unique_id: null,
+		suggested_object_id: null,
+		supported_features: 0,
+		translation_key: null,
+		unique_id: `demo_${entity_id.replace(".", "_")}`,
+		unit_of_measurement: null,
+		...overrides
+	};
+}
+function makeDevice(id, name, areaId, manufacturer = "Demo", model = "Virtual") {
+	return {
+		id,
+		name,
+		name_by_user: null,
+		manufacturer,
+		model,
+		model_id: null,
+		sw_version: "1.0.0",
+		hw_version: null,
+		area_id: areaId,
+		config_entries: ["demo_config"],
+		config_entries_subentries: {},
+		configuration_url: null,
+		connections: [],
+		created_at: now,
+		disabled_by: null,
+		entry_type: null,
+		identifiers: [["demo", id]],
+		labels: [],
+		modified_at: now,
+		primary_config_entry: "demo_config",
+		serial_number: null,
+		via_device_id: null
+	};
+}
+function makeArea(id, name, floorId = "ground_floor") {
+	return {
+		id,
+		name,
+		normalized_name: name.toLowerCase().replace(/\s+/g, "_"),
+		created_at: now,
+		modified_at: now,
+		aliases: [],
+		floor_id: floorId,
+		humidity_entity_id: null,
+		icon: null,
+		labels: [],
+		picture: null,
+		temperature_entity_id: null
+	};
+}
+/**
+* Create ~30 curated apartment entity fixtures.
+*
+* Entities span lights, sensors, binary sensors, climate, covers,
+* locks, switches, media player, weather, camera, scenes, and buttons
+* across 6 areas: living_room, bedroom, kitchen, entry, utility, garage.
+*/
+function createDemoFixtures() {
+	contextCounter = 0;
+	const areas$1 = {
+		living_room: makeArea("living_room", "Living Room"),
+		bedroom: makeArea("bedroom", "Bedroom"),
+		kitchen: makeArea("kitchen", "Kitchen"),
+		entry: makeArea("entry", "Entry"),
+		utility: makeArea("utility", "Utility"),
+		garage: makeArea("garage", "Garage")
+	};
+	areas$1.living_room.temperature_entity_id = "sensor.temperature_living";
+	areas$1.living_room.humidity_entity_id = "sensor.humidity_living";
+	const devices = {
+		living_room_lights: makeDevice("living_room_lights", "Living Room Lights", "living_room", "Philips", "Hue"),
+		kitchen_lights: makeDevice("kitchen_lights", "Kitchen Lights", "kitchen", "IKEA", "Tradfri"),
+		bedroom_lights: makeDevice("bedroom_lights", "Bedroom Lights", "bedroom", "Philips", "Hue"),
+		hallway_lights: makeDevice("hallway_lights", "Hallway Lights", "entry", "IKEA", "Tradfri"),
+		bathroom_lights: makeDevice("bathroom_lights", "Bathroom Lights", null),
+		thermostat_lr: makeDevice("thermostat_lr", "Living Room Thermostat", "living_room", "Nest", "Learning Thermostat"),
+		thermostat_br: makeDevice("thermostat_br", "Bedroom AC", "bedroom", "Daikin", "Split AC"),
+		blinds_lr: makeDevice("blinds_lr", "Living Room Blinds", "living_room", "Somfy", "Roller Shade"),
+		curtains_br: makeDevice("curtains_br", "Bedroom Curtains", "bedroom", "IKEA", "Fyrtur"),
+		garage_door_opener: makeDevice("garage_door_opener", "Garage Door Opener", "garage", "Chamberlain", "MyQ"),
+		shutters_lr: makeDevice("shutters_lr", "Living Room Shutters", "living_room", "Somfy", "Venetian Shutter"),
+		blinds_kitchen: makeDevice("blinds_kitchen", "Kitchen Blinds", "kitchen", "IKEA", "Praktlysing"),
+		lock_front: makeDevice("lock_front", "Front Door Lock", "entry", "Yale", "Assure Lock 2"),
+		lock_back: makeDevice("lock_back", "Back Door Lock", "entry", "August", "Smart Lock Pro"),
+		speaker_lr: makeDevice("speaker_lr", "Living Room Speaker", "living_room", "Sonos", "One"),
+		camera_front: makeDevice("camera_front", "Front Door Camera", "entry", "Ring", "Video Doorbell"),
+		door_sensor: makeDevice("door_sensor", "Front Door Sensor", "entry", "Aqara", "Door Sensor"),
+		motion_sensor: makeDevice("motion_sensor", "Hallway Motion Sensor", "entry", "Aqara", "Motion Sensor")
+	};
+	const entities$1 = {};
+	const entityRegistry = {};
+	function add(e, regOverrides = {}) {
+		entities$1[e.entity_id] = e;
+		entityRegistry[e.entity_id] = makeRegistryEntry(e.entity_id, regOverrides);
+	}
+	add(makeEntity("light.living_room_main", "on", {
+		brightness: 179,
+		color_temp_kelvin: 3e3,
+		color_mode: "color_temp",
+		supported_color_modes: ["color_temp", "xy"]
+	}), {
+		device_id: "living_room_lights",
+		area_id: "living_room",
+		supported_features: 44
+	});
+	add(makeEntity("light.kitchen_counter", "off", { supported_color_modes: ["brightness"] }), {
+		device_id: "kitchen_lights",
+		area_id: "kitchen",
+		supported_features: 1
+	});
+	add(makeEntity("light.bedroom_ceiling", "on", {
+		brightness: 77,
+		color_temp_kelvin: 2700,
+		color_mode: "color_temp",
+		supported_color_modes: ["color_temp"]
+	}), {
+		device_id: "bedroom_lights",
+		area_id: "bedroom",
+		supported_features: 44
+	});
+	add(makeEntity("light.bathroom", "off", { supported_color_modes: ["brightness"] }), { device_id: "bathroom_lights" });
+	add(makeEntity("light.hallway", "on", {
+		brightness: 128,
+		color_mode: "brightness",
+		supported_color_modes: ["brightness"]
+	}), {
+		device_id: "hallway_lights",
+		area_id: "entry",
+		supported_features: 1
+	});
+	add(makeEntity("light.studio_rgb", "on", {
+		brightness: 205,
+		hs_color: [265, 66],
+		color_mode: "hs",
+		supported_color_modes: ["hs", "color_temp"]
+	}), {
+		device_id: "studio_lights",
+		area_id: "living_room",
+		supported_features: 44
+	});
+	add(makeEntity("light.desk_rgb", "on", {
+		brightness: 200,
+		hs_color: [172, 79],
+		color_mode: "hs",
+		supported_color_modes: ["hs", "color_temp"]
+	}), {
+		device_id: "desk_lights",
+		area_id: "bedroom",
+		supported_features: 44
+	});
+	add(makeEntity("sensor.temperature_living", "22.5", {
+		unit_of_measurement: "°C",
+		device_class: "temperature",
+		state_class: "measurement"
+	}), {
+		area_id: "living_room",
+		device_class: "temperature",
+		unit_of_measurement: "°C"
+	});
+	add(makeEntity("sensor.humidity_living", "45", {
+		unit_of_measurement: "%",
+		device_class: "humidity",
+		state_class: "measurement"
+	}), {
+		area_id: "living_room",
+		device_class: "humidity",
+		unit_of_measurement: "%"
+	});
+	add(makeEntity("sensor.temperature_outdoor", "-2", {
+		unit_of_measurement: "°C",
+		device_class: "temperature",
+		state_class: "measurement"
+	}), {
+		device_class: "temperature",
+		unit_of_measurement: "°C"
+	});
+	add(makeEntity("sensor.power_consumption", "1.2", {
+		unit_of_measurement: "kW",
+		device_class: "power",
+		state_class: "measurement"
+	}), {
+		device_class: "power",
+		unit_of_measurement: "kW"
+	});
+	add(makeEntity("sensor.battery_door_sensor", "87", {
+		unit_of_measurement: "%",
+		device_class: "battery",
+		state_class: "measurement"
+	}), {
+		device_id: "door_sensor",
+		area_id: "entry",
+		device_class: "battery",
+		unit_of_measurement: "%"
+	});
+	add(makeEntity("binary_sensor.front_door", "off", { device_class: "door" }), {
+		device_id: "door_sensor",
+		area_id: "entry",
+		device_class: "door"
+	});
+	add(makeEntity("binary_sensor.motion_hallway", "off", { device_class: "motion" }), {
+		device_id: "motion_sensor",
+		area_id: "entry",
+		device_class: "motion"
+	});
+	add(makeEntity("binary_sensor.window_bedroom", "off", { device_class: "window" }), {
+		area_id: "bedroom",
+		device_class: "window"
+	});
+	add(makeEntity("climate.living_room_thermostat", "heat", {
+		temperature: 22,
+		current_temperature: 21.8,
+		hvac_modes: [
+			"off",
+			"heat",
+			"cool",
+			"auto"
+		],
+		hvac_action: "heating",
+		min_temp: 7,
+		max_temp: 35
+	}), {
+		device_id: "thermostat_lr",
+		area_id: "living_room",
+		supported_features: 385
+	});
+	add(makeEntity("climate.bedroom_ac", "off", {
+		temperature: 20,
+		current_temperature: 22.1,
+		hvac_modes: [
+			"off",
+			"cool",
+			"heat",
+			"dry",
+			"fan_only"
+		],
+		hvac_action: "idle",
+		min_temp: 16,
+		max_temp: 30
+	}), {
+		device_id: "thermostat_br",
+		area_id: "bedroom",
+		supported_features: 385
+	});
+	add(makeEntity("water_heater.boiler", "eco", {
+		temperature: 50,
+		current_temperature: 47.5,
+		operation_list: [
+			"off",
+			"eco",
+			"performance"
+		],
+		min_temp: 43,
+		max_temp: 60,
+		away_mode: "off"
+	}), {
+		device_id: "boiler",
+		area_id: "utility",
+		supported_features: 7
+	});
+	add(makeEntity("water_heater.heat_pump_tank", "heat_pump", {
+		temperature: 55,
+		current_temperature: 52.3,
+		operation_list: [
+			"off",
+			"eco",
+			"heat_pump",
+			"high_demand"
+		],
+		min_temp: 43,
+		max_temp: 60
+	}), {
+		device_id: "hp_tank",
+		area_id: "garage",
+		supported_features: 3
+	});
+	add(makeEntity("fan.bedroom_ceiling", "on", {
+		percentage: 200 / 3,
+		percentage_step: 100 / 3,
+		current_direction: "forward"
+	}), {
+		device_id: "ceiling_fan",
+		area_id: "bedroom",
+		supported_features: 5
+	});
+	add(makeEntity("fan.air_purifier", "on", {
+		percentage: 40,
+		preset_modes: [
+			"auto",
+			"sleep",
+			"turbo"
+		],
+		preset_mode: "auto",
+		oscillating: false
+	}), {
+		device_id: "purifier",
+		area_id: "living_room",
+		supported_features: 11
+	});
+	add(makeEntity("cover.living_room_blinds", "open", {
+		current_position: 80,
+		device_class: "shade"
+	}), {
+		device_id: "blinds_lr",
+		area_id: "living_room",
+		device_class: "shade",
+		supported_features: 15
+	});
+	add(makeEntity("cover.bedroom_curtains", "closed", {
+		current_position: 0,
+		device_class: "curtain"
+	}), {
+		device_id: "curtains_br",
+		area_id: "bedroom",
+		device_class: "curtain",
+		supported_features: 15
+	});
+	add(makeEntity("cover.garage_door", "closed", { device_class: "garage" }), {
+		device_id: "garage_door_opener",
+		area_id: "garage",
+		device_class: "garage",
+		supported_features: 11
+	});
+	add(makeEntity("cover.driveway_gate", "open", {
+		device_class: "gate",
+		assumed_state: true
+	}), {
+		area_id: "garage",
+		device_class: "gate",
+		supported_features: 3
+	});
+	add(makeEntity("cover.living_room_shutters", "open", {
+		current_position: 45,
+		current_tilt_position: 30,
+		device_class: "shutter"
+	}), {
+		device_id: "shutters_lr",
+		area_id: "living_room",
+		device_class: "shutter",
+		supported_features: 255
+	});
+	add(makeEntity("cover.kitchen_blinds", "open", {
+		current_position: 100,
+		device_class: "blind"
+	}), {
+		device_id: "blinds_kitchen",
+		area_id: "kitchen",
+		device_class: "blind",
+		supported_features: 127
+	});
+	add(makeEntity("lock.front_door_lock", "locked", {}), {
+		device_id: "lock_front",
+		area_id: "entry",
+		supported_features: 1
+	});
+	add(makeEntity("lock.back_door_lock", "locked", {}), {
+		device_id: "lock_back",
+		area_id: "entry",
+		supported_features: 1
+	});
+	add(makeEntity("switch.coffee_machine", "off", { device_class: "outlet" }), {
+		area_id: "kitchen",
+		device_class: "outlet"
+	});
+	add(makeEntity("switch.fan_living_room", "on", { device_class: "switch" }), {
+		area_id: "living_room",
+		device_class: "switch"
+	});
+	add(makeEntity("media_player.living_room_speaker", "playing", {
+		media_title: "Lo-fi Beats",
+		media_artist: "Chill Station",
+		media_content_type: "music",
+		volume_level: .4,
+		is_volume_muted: false,
+		supported_features: 152461
+	}), {
+		device_id: "speaker_lr",
+		area_id: "living_room",
+		supported_features: 152461
+	});
+	for (const w of WEATHER_FIXTURES) add(makeWeatherEntity(w), { platform: "met" });
+	add(makeEntity("camera.front_door_camera", "streaming", {
+		entity_picture: "/api/camera_proxy/camera.front_door_camera",
+		frontend_stream_type: "hls",
+		access_token: "demo-token"
+	}), {
+		device_id: "camera_front",
+		area_id: "entry",
+		supported_features: 2
+	});
+	add(makeEntity("scene.movie_night", "scening", { entity_id: [
+		"light.living_room_main",
+		"cover.living_room_blinds",
+		"media_player.living_room_speaker"
+	] }), { area_id: "living_room" });
+	add(makeEntity("scene.good_morning", "scening", { entity_id: [
+		"light.bedroom_ceiling",
+		"cover.bedroom_curtains",
+		"switch.coffee_machine"
+	] }), {});
+	add(makeEntity("button.restart_home_assistant", "unknown", { device_class: "restart" }), {
+		entity_category: "config",
+		device_class: "restart"
+	});
+	add(makeEntity("button.update_firmware", "unknown", { device_class: "update" }), {
+		entity_category: "config",
+		device_class: "update"
+	});
+	add(makeEntity("sensor.door_lock_battery", "92", {
+		unit_of_measurement: "%",
+		device_class: "battery",
+		state_class: "measurement"
+	}), {
+		device_id: "lock_front",
+		area_id: "entry",
+		device_class: "battery",
+		unit_of_measurement: "%"
+	});
+	add(makeEntity("sensor.motion_sensor_battery", "65", {
+		unit_of_measurement: "%",
+		device_class: "battery",
+		state_class: "measurement"
+	}), {
+		device_id: "motion_sensor",
+		area_id: "entry",
+		device_class: "battery",
+		unit_of_measurement: "%"
+	});
+	const nowMs = Date.now();
+	const sample = simulateEnergy(nowMs);
+	const sun = sunEvents(nowMs);
+	add(makeEntity("sun.sun", isSunUp(nowMs) ? "above_horizon" : "below_horizon", {
+		friendly_name: "Sun",
+		elevation: sun.elevation,
+		next_rising: sun.nextRising,
+		next_setting: sun.nextSetting
+	}), {});
+	const powerSensors = [
+		{
+			id: "sensor.solar_power",
+			name: "Solar Production",
+			deviceClass: "power",
+			unit: "W"
+		},
+		{
+			id: "sensor.grid_import_power",
+			name: "Grid Import",
+			deviceClass: "power",
+			unit: "W"
+		},
+		{
+			id: "sensor.grid_export_power",
+			name: "Grid Export",
+			deviceClass: "power",
+			unit: "W"
+		},
+		{
+			id: "sensor.battery_charge_power",
+			name: "Battery Charge",
+			deviceClass: "power",
+			unit: "W"
+		},
+		{
+			id: "sensor.battery_discharge_power",
+			name: "Battery Discharge",
+			deviceClass: "power",
+			unit: "W"
+		},
+		{
+			id: "sensor.battery_soc",
+			name: "Battery",
+			deviceClass: "battery",
+			unit: "%"
+		},
+		{
+			id: "sensor.home_power",
+			name: "Home Consumption",
+			deviceClass: "power",
+			unit: "W"
+		},
+		{
+			id: "sensor.fridge_power",
+			name: "Fridge",
+			deviceClass: "power",
+			unit: "W"
+		},
+		{
+			id: "sensor.dishwasher_power",
+			name: "Dishwasher",
+			deviceClass: "power",
+			unit: "W"
+		},
+		{
+			id: "sensor.washing_machine_power",
+			name: "Washing Machine",
+			deviceClass: "power",
+			unit: "W"
+		},
+		{
+			id: "sensor.oven_power",
+			name: "Oven",
+			deviceClass: "power",
+			unit: "W"
+		},
+		{
+			id: "sensor.ev_charger_power",
+			name: "EV Charger",
+			deviceClass: "power",
+			unit: "W"
+		},
+		{
+			id: "sensor.always_on_power",
+			name: "Always On",
+			deviceClass: "power",
+			unit: "W"
+		}
+	];
+	for (const s of powerSensors) {
+		const value = energyEntityValue(s.id, sample) ?? 0;
+		add(makeEntity(s.id, formatEnergyState(s.id, value), {
+			friendly_name: s.name,
+			unit_of_measurement: s.unit,
+			device_class: s.deviceClass,
+			state_class: "measurement"
+		}), {
+			area_id: "utility",
+			device_class: s.deviceClass,
+			unit_of_measurement: s.unit
+		});
+	}
+	return {
+		entities: entities$1,
+		entityRegistry,
+		areas: areas$1,
+		devices
+	};
+}
+
 //#endregion
 //#region src/demo/demo-provider.ts
 let _isDemoMode = false;
@@ -604,10 +1880,11 @@ function applyDemoServiceCall(_domain, service, _serviceData = {}, target = {})
 		setState(produce((s) => {
 			const e = s.entities[entityId];
 			if (!e) return;
-			const now = (/* @__PURE__ */ new Date()).toISOString();
-			e.last_changed = now;
-			e.last_updated = now;
+			const now$1 = (/* @__PURE__ */ new Date()).toISOString();
+			e.last_changed = now$1;
+			e.last_updated = now$1;
 			if (service === "turn_on") applyTurnOn(e, entityDomain, _serviceData);
+			else if (service === "press" && entityDomain === "button") e.state = now$1;
 			else if (service === "turn_off") applyTurnOff(e, entityDomain);
 			else if (service === "toggle") if (e.state === "on" || e.state === "playing" || e.state === "open") applyTurnOff(e, entityDomain);
 			else applyTurnOn(e, entityDomain, _serviceData);
@@ -622,23 +1899,69 @@ function applyDemoServiceCall(_domain, service, _serviceData = {}, target = {})
 			} else if (service === "set_cover_position" && _serviceData.position != null) {
 				e.attributes.current_position = _serviceData.position;
 				e.state = _serviceData.position > 0 ? "open" : "closed";
-			} else if (service === "set_temperature" && _serviceData.temperature != null) e.attributes.temperature = _serviceData.temperature;
-			else if (service === "set_hvac_mode" && _serviceData.hvac_mode != null) e.state = _serviceData.hvac_mode;
+			} else if (service === "open_cover_tilt") e.attributes.current_tilt_position = 100;
+			else if (service === "close_cover_tilt") e.attributes.current_tilt_position = 0;
+			else if (service === "set_cover_tilt_position" && _serviceData.tilt_position != null) e.attributes.current_tilt_position = _serviceData.tilt_position;
+			else if (service === "set_temperature") {
+				if (_serviceData.temperature != null) e.attributes.temperature = _serviceData.temperature;
+				if (_serviceData.target_temp_low != null) e.attributes.target_temp_low = _serviceData.target_temp_low;
+				if (_serviceData.target_temp_high != null) e.attributes.target_temp_high = _serviceData.target_temp_high;
+			} else if (service === "set_hvac_mode" && _serviceData.hvac_mode != null) e.state = _serviceData.hvac_mode;
+			else if (service === "set_fan_mode" && _serviceData.fan_mode != null) e.attributes.fan_mode = _serviceData.fan_mode;
+			else if (service === "set_preset_mode" && _serviceData.preset_mode != null) {
+				e.attributes.preset_mode = _serviceData.preset_mode;
+				if (entityDomain === "fan") e.state = "on";
+			} else if (service === "set_percentage" && _serviceData.percentage != null) {
+				e.attributes.percentage = _serviceData.percentage;
+				e.state = _serviceData.percentage > 0 ? "on" : "off";
+			} else if (service === "oscillate" && _serviceData.oscillating != null) e.attributes.oscillating = _serviceData.oscillating;
+			else if (service === "set_direction" && _serviceData.direction != null) e.attributes.current_direction = _serviceData.direction;
+			else if (service === "set_operation_mode" && _serviceData.operation_mode != null) e.state = _serviceData.operation_mode;
+			else if (service === "set_away_mode" && _serviceData.away_mode != null) e.attributes.away_mode = _serviceData.away_mode ? "on" : "off";
 			else if (service === "volume_set" && _serviceData.volume_level != null) e.attributes.volume_level = _serviceData.volume_level;
+			else if (service === "media_play_pause") e.state = e.state === "playing" ? "paused" : "playing";
+			else if (service === "media_next_track" || service === "media_previous_track") applyTrackSkip(e, service === "media_next_track" ? 1 : -1);
+			else if (service === "select_source" && _serviceData.source != null) e.attributes.source = _serviceData.source;
 		}));
 	}
 }
 function applyTurnOn(e, domain, serviceData = {}) {
 	if (domain === "light") {
 		e.state = "on";
-		e.attributes.brightness = serviceData.brightness ?? e.attributes.brightness ?? 255;
+		if (serviceData.brightness_pct !== void 0) {
+			const pct = Math.max(0, Math.min(100, serviceData.brightness_pct));
+			e.attributes.brightness = Math.round(pct / 100 * 255);
+		} else e.attributes.brightness = serviceData.brightness ?? e.attributes.brightness ?? 255;
 		if (serviceData.color_temp_kelvin) e.attributes.color_temp_kelvin = serviceData.color_temp_kelvin;
-	} else if (domain === "media_player") e.state = "playing";
+		if (serviceData.hs_color) e.attributes.hs_color = serviceData.hs_color;
+	} else if (domain === "scene") e.state = (/* @__PURE__ */ new Date()).toISOString();
+	else if (domain === "media_player") e.state = "playing";
 	else if (domain === "cover") {
 		e.state = "open";
 		if ("current_position" in e.attributes) e.attributes.current_position = 100;
 	} else e.state = "on";
 }
+const DEMO_TRACKS = [
+	{
+		title: "Lo-fi Beats",
+		artist: "Chill Station"
+	},
+	{
+		title: "Golden Hour",
+		artist: "Analog Sunset"
+	},
+	{
+		title: "Night Drive",
+		artist: "Neon Coast"
+	}
+];
+function applyTrackSkip(e, delta) {
+	const current = DEMO_TRACKS.findIndex((t) => t.title === e.attributes.media_title);
+	const next = DEMO_TRACKS[(current + delta + DEMO_TRACKS.length) % DEMO_TRACKS.length];
+	if (!next) return;
+	e.attributes.media_title = next.title;
+	e.attributes.media_artist = next.artist;
+}
 function applyTurnOff(e, domain) {
 	if (domain === "light") {
 		e.state = "off";
@@ -1491,10 +2814,11 @@ function resolveIcon(entity$1, registry) {
 */
 function buildEntityView(entity$1, registry) {
 	const domain = extractDomain(entity$1.entity_id);
-	const friendlyName = entity$1.attributes.friendly_name ?? registry?.name ?? entity$1.entity_id;
-	const name = registry?.name ?? friendlyName;
+	const attributes = entity$1.attributes ?? {};
+	const friendlyName$1 = attributes.friendly_name ?? registry?.name ?? entity$1.entity_id;
+	const name = registry?.name ?? friendlyName$1;
 	const iconResolution = resolveIcon(entity$1, registry);
-	const { device_class: _dc, unit_of_measurement: _uom, friendly_name: _fn, icon: _icon,...restAttributes } = entity$1.attributes;
+	const { device_class: _dc, unit_of_measurement: _uom, friendly_name: _fn, icon: _icon,...restAttributes } = attributes;
 	let areaId = registry?.area_id ?? null;
 	if (areaId === null && registry?.device_id) {
 		const device = state.devices[registry.device_id];
@@ -1508,12 +2832,12 @@ function buildEntityView(entity$1, registry) {
 		lastChanged: new Date(entity$1.last_changed),
 		lastUpdated: new Date(entity$1.last_updated),
 		context: {
-			id: entity$1.context.id,
-			parentId: entity$1.context.parent_id,
-			userId: entity$1.context.user_id
+			id: entity$1.context?.id ?? "",
+			parentId: entity$1.context?.parent_id ?? null,
+			userId: entity$1.context?.user_id ?? null
 		},
 		name,
-		friendlyName,
+		friendlyName: friendlyName$1,
 		areaId,
 		deviceId: registry?.device_id ?? null,
 		platform: registry?.platform ?? "unknown",
@@ -1525,9 +2849,9 @@ function buildEntityView(entity$1, registry) {
 		entityCategory: registry?.entity_category ?? null,
 		labels: registry?.labels ?? [],
 		aliases: registry?.aliases ?? [],
-		deviceClass: registry?.device_class ?? entity$1.attributes.device_class ?? null,
-		unitOfMeasurement: registry?.unit_of_measurement ?? entity$1.attributes.unit_of_measurement ?? null,
-		supportedFeatures: registry?.supported_features ?? entity$1.attributes.supported_features
+		deviceClass: registry?.device_class ?? attributes.device_class ?? null,
+		unitOfMeasurement: registry?.unit_of_measurement ?? attributes.unit_of_measurement ?? null,
+		supportedFeatures: registry?.supported_features ?? attributes.supported_features
 	};
 }
 /**
@@ -1690,8 +3014,8 @@ function getAreaView(areaId) {
 //#region src/query/area-builder.ts
 var AreaQueryBuilderImpl = class AreaQueryBuilderImpl {
 	queryState;
-	constructor(initialState) {
-		this.queryState = initialState ?? {
+	constructor(initialState$1) {
+		this.queryState = initialState$1 ?? {
 			filters: [],
 			sorts: []
 		};
@@ -1945,8 +3269,8 @@ function getNestedValue(obj, path) {
 //#region src/query/builder.ts
 var EntitiesQueryBuilderImpl = class EntitiesQueryBuilderImpl {
 	queryState;
-	constructor(initialState) {
-		this.queryState = initialState ?? {
+	constructor(initialState$1) {
+		this.queryState = initialState$1 ?? {
 			indexFilters: [],
 			predicateFilters: [],
 			sorts: [],