@glasshome/sync-layer 0.5.0 → 0.7.0

package/dist/statistics-CtRfIF6D.js

@@ -0,0 +1,2175 @@
+import { createStore, produce, reconcile } from "solid-js/store";
+
+//#region src/core/store.ts
+const initialState = {
+	connectionState: "disconnected",
+	connectionError: null,
+	hassUrl: null,
+	mediaProxyBase: null,
+	config: null,
+	entities: {},
+	entityRegistry: {},
+	devices: {},
+	areas: {},
+	floors: {},
+	labels: {},
+	statistics: {},
+	statisticsMetadata: {},
+	history: {},
+	forecasts: {},
+	calendars: {},
+	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];
+
+//#endregion
+//#region src/core/privileged-conn.ts
+let privileged = null;
+/** Read the live connection. Null before connect and after disconnect. */
+function privilegedConn() {
+	return privileged;
+}
+/** Set by the connection layer on connect/disconnect. Host-side callers only. */
+function setPrivilegedConn(conn$1) {
+	privileged = conn$1;
+}
+
+//#endregion
+//#region src/calendar/track.ts
+/**
+* Ref-counted live calendar tracking, the per-entity analog of
+* `connection/subscription-manager`. Each tracked calendar entity holds one
+* upstream `calendar/event/subscribe` (HA pushes an initial snapshot, then
+* debounced updates); trackers declare desired windows and a reconciler keeps
+* the subscription matched to the union. Data lands in `state.calendars`;
+* read-scoping for widget consumers arrives with WS-8 like every other store
+* read.
+*/
+const DEFAULT_DAYS_BEHIND = 7;
+const DEFAULT_DAYS_AHEAD = 35;
+/** Debounce for untrack, so dashboard switches don't churn subscriptions. */
+const UNTRACK_FLUSH_DELAY_MS = 5e3;
+const DAY_MS = 24 * 60 * 60 * 1e3;
+const trackers = /* @__PURE__ */ new Map();
+const active = /* @__PURE__ */ new Map();
+/** Per-entity reconcile chain; serializes subscribe/unsubscribe per calendar. */
+const chains = /* @__PURE__ */ new Map();
+let untrackTimer = null;
+let rollTimer = null;
+/** Day-quantized union of all tracker windows, so equal requests within a day
+reconcile to the same subscription instead of churning. */
+function windowFor(list) {
+	let behind = 0;
+	let ahead = 0;
+	for (const t of list) {
+		if (t.daysBehind > behind) behind = t.daysBehind;
+		if (t.daysAhead > ahead) ahead = t.daysAhead;
+	}
+	const dayStart = /* @__PURE__ */ new Date();
+	dayStart.setHours(0, 0, 0, 0);
+	return {
+		start: new Date(dayStart.getTime() - behind * DAY_MS).toISOString(),
+		end: new Date(dayStart.getTime() + (ahead + 1) * DAY_MS).toISOString()
+	};
+}
+/**
+* Start tracking live events for a calendar entity. Returns the untrack
+* function. Safe while disconnected: the subscription activates on the next
+* `forceResubscribeCalendars()` (called by the connection layer on connect
+* and reconnect).
+*/
+function trackCalendarEvents(entityId, options) {
+	const tracker = {
+		daysBehind: options?.daysBehind ?? DEFAULT_DAYS_BEHIND,
+		daysAhead: options?.daysAhead ?? DEFAULT_DAYS_AHEAD
+	};
+	const list = trackers.get(entityId) ?? [];
+	list.push(tracker);
+	trackers.set(entityId, list);
+	scheduleFlush$1();
+	ensureRollTimer();
+	let untracked = false;
+	return () => {
+		if (untracked) return;
+		untracked = true;
+		untrackCalendarEvents(entityId, tracker);
+	};
+}
+function untrackCalendarEvents(entityId, tracker) {
+	const list = trackers.get(entityId);
+	if (!list) return;
+	const i = list.indexOf(tracker);
+	if (i !== -1) list.splice(i, 1);
+	if (list.length === 0) trackers.delete(entityId);
+	if (untrackTimer) return;
+	untrackTimer = setTimeout(() => {
+		untrackTimer = null;
+		flushAll();
+	}, UNTRACK_FLUSH_DELAY_MS);
+}
+/**
+* Reconcile every tracked calendar, dropping current subscription handles
+* first. The connection layer calls this on connect and after reconnect:
+* an unchanged window is no proof the old subscription is alive, so each
+* tracked entity resubscribes (HA re-pushes the snapshot, refreshing the
+* store through any missed changes).
+*/
+async function forceResubscribeCalendars() {
+	for (const entry of active.values()) {
+		const dead = entry.unsub;
+		entry.unsub = null;
+		if (dead) Promise.resolve().then(dead).catch(() => {});
+	}
+	await flushAll();
+}
+function scheduleFlush$1() {
+	queueMicrotask(() => {
+		flushAll();
+	});
+}
+async function flushAll() {
+	const ids = new Set([...trackers.keys(), ...active.keys()]);
+	await Promise.all([...ids].map(reconcileEntity));
+	if (trackers.size === 0) stopRollTimer();
+}
+function reconcileEntity(entityId) {
+	const next = (chains.get(entityId) ?? Promise.resolve()).then(() => runReconcile(entityId));
+	chains.set(entityId, next.catch(() => {}));
+	return next;
+}
+async function runReconcile(entityId) {
+	const list = trackers.get(entityId);
+	const current = active.get(entityId);
+	if (!list || list.length === 0) {
+		if (current) {
+			active.delete(entityId);
+			try {
+				await current.unsub?.();
+			} catch {}
+		}
+		chains.delete(entityId);
+		setState(produce((s) => {
+			delete s.calendars[entityId];
+		}));
+		return;
+	}
+	const conn$1 = privilegedConn();
+	if (!conn$1) return;
+	const win = windowFor(list);
+	if (current?.unsub && current.start === win.start && current.end === win.end) return;
+	setState(produce((s) => {
+		s.calendars[entityId] = {
+			entityId,
+			events: s.calendars[entityId]?.events ?? [],
+			loading: true,
+			error: null,
+			start: win.start,
+			end: win.end
+		};
+	}));
+	const old = current?.unsub ?? null;
+	const entry = {
+		start: win.start,
+		end: win.end,
+		unsub: null
+	};
+	active.set(entityId, entry);
+	try {
+		entry.unsub = await conn$1.subscribeMessage((msg) => {
+			setState(produce((s) => {
+				const rec = s.calendars[entityId];
+				if (!rec) return;
+				rec.events = msg.events ?? [];
+				rec.loading = false;
+				rec.error = null;
+			}));
+		}, {
+			type: "calendar/event/subscribe",
+			entity_id: entityId,
+			start: win.start,
+			end: win.end
+		});
+	} catch (err) {
+		active.delete(entityId);
+		setState(produce((s) => {
+			const rec = s.calendars[entityId];
+			if (!rec) return;
+			rec.loading = false;
+			rec.error = err instanceof Error ? err : new Error(String(err));
+		}));
+	}
+	if (old) try {
+		await old();
+	} catch {}
+}
+/** One timer for the whole module: at local midnight the day-quantized
+windows shift, so a reconcile slides every subscription forward. Only
+armed while something is tracked — an idle app holds no timer. */
+function ensureRollTimer() {
+	if (rollTimer || trackers.size === 0) return;
+	const now$1 = /* @__PURE__ */ new Date();
+	const next = new Date(now$1);
+	next.setHours(24, 0, 30, 0);
+	rollTimer = setTimeout(() => {
+		rollTimer = null;
+		flushAll().then(ensureRollTimer);
+	}, next.getTime() - now$1.getTime());
+}
+function stopRollTimer() {
+	if (rollTimer) {
+		clearTimeout(rollTimer);
+		rollTimer = null;
+	}
+}
+
+//#endregion
+//#region src/connection/subscription-manager.ts
+if (globalThis.__GH_SYNC_LAYER_SUB_MGR__) console.error("[@glasshome/sync-layer] DUPLICATE subscription-manager module instantiated. registerEntity() and the connection setter will hit different singletons → subscribe_entities will never be sent. Cause: relative import of subscription-manager from a separate entry point.");
+globalThis.__GH_SYNC_LAYER_SUB_MGR__ = true;
+/** Ref counts — how many consumers need each entity */
+const refCounts = /* @__PURE__ */ new Map();
+/** Current HA subscription unsub function */
+let currentEntityUnsub = null;
+/** Snapshot of entity IDs in the current HA subscription */
+let subscribedIds = /* @__PURE__ */ new Set();
+/** Connection reference for resubscribing */
+let conn = null;
+/** Pending flush timer (microtask for register, timeout for unregister) */
+let flushScheduled = false;
+/** Delayed unregister timeout */
+let unregisterTimeout = null;
+/** Callback invoked on resubscribe — set by subscriptions.ts */
+let onResubscribe = null;
+/** Delay before unregistered entities are actually removed from subscription */
+const UNREGISTER_DELAY_MS = 5e3;
+/** Guard against concurrent flush() calls */
+let flushInFlight = false;
+/**
+* Register an entity for live updates. Returns an unregister function.
+* Call from useEntity/useEntities hooks via onCleanup.
+*/
+function registerEntity(entityId) {
+	refCounts.set(entityId, (refCounts.get(entityId) ?? 0) + 1);
+	scheduleFlush();
+	return () => unregisterEntity(entityId);
+}
+/**
+* Set the connection reference used for resubscribing.
+*/
+function setManagerConnection(connection) {
+	conn = connection;
+	if (refCounts.size > 0) scheduleFlush();
+}
+/**
+* Set the resubscribe callback. Called by subscriptions.ts to wire
+* the manager into the actual WS subscription lifecycle.
+*/
+function setResubscribeHandler(handler) {
+	onResubscribe = handler;
+}
+/**
+* Force a resubscribe with the current active set.
+* Used on reconnect.
+*/
+async function forceResubscribe() {
+	await flush();
+}
+function unregisterEntity(entityId) {
+	const count = (refCounts.get(entityId) ?? 1) - 1;
+	if (count <= 0) refCounts.delete(entityId);
+	else refCounts.set(entityId, count);
+	scheduleDelayedFlush();
+}
+function scheduleFlush() {
+	if (flushScheduled) return;
+	flushScheduled = true;
+	queueMicrotask(() => {
+		flushScheduled = false;
+		flush();
+	});
+}
+function scheduleDelayedFlush() {
+	if (unregisterTimeout) return;
+	unregisterTimeout = setTimeout(() => {
+		unregisterTimeout = null;
+		flush();
+	}, UNREGISTER_DELAY_MS);
+}
+async function flush() {
+	if (!conn || !onResubscribe) return;
+	if (flushInFlight) return;
+	flushInFlight = true;
+	try {
+		const newIds = new Set(refCounts.keys());
+		if (setsEqual(newIds, subscribedIds)) return;
+		const oldUnsub = currentEntityUnsub;
+		const entityIds = [...newIds];
+		currentEntityUnsub = await onResubscribe(conn, entityIds);
+		subscribedIds = newIds;
+		if (oldUnsub) try {
+			await oldUnsub();
+		} catch {}
+	} finally {
+		flushInFlight = false;
+	}
+}
+function setsEqual(a, b) {
+	if (a.size !== b.size) return false;
+	for (const id of a) if (!b.has(id)) return false;
+	return true;
+}
+
+//#endregion
+//#region src/core/types.ts
+/**
+* Extract domain from entity ID
+*/
+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 = {
+		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.living_room.temperature_entity_id = "sensor.temperature_living";
+	areas.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 = {};
+	const entityRegistry = {};
+	function add(e, regOverrides = {}) {
+		entities[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("sensor.electricity_maps_co2_intensity", "214", {
+		unit_of_measurement: "gCO2eq/kWh",
+		state_class: "measurement"
+	}), { unit_of_measurement: "gCO2eq/kWh" });
+	add(makeEntity("sensor.electricity_maps_fossil_fuel_percentage", "31", {
+		unit_of_measurement: "%",
+		state_class: "measurement"
+	}), { unit_of_measurement: "%" });
+	add(makeEntity("sensor.nordpool_current_price", "0.18", {
+		unit_of_measurement: "EUR/kWh",
+		state_class: "measurement"
+	}), { unit_of_measurement: "EUR/kWh" });
+	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,
+		entityRegistry,
+		areas,
+		devices
+	};
+}
+
+//#endregion
+//#region src/demo/demo-provider.ts
+let _isDemoMode = false;
+/**
+* Whether demo mode is currently active.
+*/
+function isDemoMode() {
+	return _isDemoMode;
+}
+/**
+* Load demo fixtures into the SolidJS store.
+*
+* Populates entities, entity registry, areas, and devices.
+* Sets connection state to "connected" (pretend connected).
+*/
+async function loadDemoData() {
+	const fixtures = createDemoFixtures();
+	setState("entities", reconcile(fixtures.entities));
+	setState("entityRegistry", reconcile(fixtures.entityRegistry));
+	setState("areas", reconcile(fixtures.areas));
+	setState("devices", reconcile(fixtures.devices));
+	setState("hassUrl", "https://demo.home-assistant.local");
+	setState("connectionState", "connected");
+	_isDemoMode = true;
+	startDemoEnergyTicker();
+}
+/**
+* Unload demo data and reset to disconnected state.
+*/
+function unloadDemoData() {
+	stopDemoEnergyTicker();
+	setState("entities", reconcile({}));
+	setState("entityRegistry", reconcile({}));
+	setState("areas", reconcile({}));
+	setState("devices", reconcile({}));
+	setState("hassUrl", null);
+	setState("connectionState", "disconnected");
+	_isDemoMode = false;
+}
+const ENERGY_TICK_MS = 5e3;
+let _energyTicker = null;
+/** Write the current energy sample into the store as string states (like real HA). */
+function tickEnergy() {
+	const nowMs = Date.now();
+	const sample = simulateEnergy(nowMs);
+	const sun = sunEvents(nowMs);
+	const nowIso = new Date(nowMs).toISOString();
+	setState(produce((s) => {
+		for (const entityId of ENERGY_ENTITY_IDS) {
+			const e = s.entities[entityId];
+			if (!e) continue;
+			const value = energyEntityValue(entityId, sample);
+			if (value === void 0) continue;
+			const next = formatEnergyState(entityId, value);
+			if (e.state !== next) e.last_changed = nowIso;
+			e.state = next;
+			e.last_updated = nowIso;
+		}
+		const sunEntity = s.entities["sun.sun"];
+		if (sunEntity) {
+			const nextState = isSunUp(nowMs) ? "above_horizon" : "below_horizon";
+			if (sunEntity.state !== nextState) sunEntity.last_changed = nowIso;
+			sunEntity.state = nextState;
+			sunEntity.last_updated = nowIso;
+			sunEntity.attributes.elevation = sun.elevation;
+			sunEntity.attributes.next_rising = sun.nextRising;
+			sunEntity.attributes.next_setting = sun.nextSetting;
+		}
+	}));
+}
+/**
+* Start the demo energy ticker. Updates the energy sensors and `sun.sun`
+* every 5 seconds. Idempotent: clears any prior interval first. SSR-safe.
+*/
+function startDemoEnergyTicker() {
+	stopDemoEnergyTicker();
+	if (typeof setInterval !== "function") return;
+	tickEnergy();
+	_energyTicker = setInterval(tickEnergy, ENERGY_TICK_MS);
+}
+/** Stop the demo energy ticker if running. */
+function stopDemoEnergyTicker() {
+	if (_energyTicker !== null) {
+		clearInterval(_energyTicker);
+		_energyTicker = null;
+	}
+}
+/**
+* Apply an optimistic state update for demo mode.
+*
+* When a service call is made in demo mode, this updates the entity
+* state locally (no WebSocket message sent). State resets on page refresh.
+*/
+function applyDemoServiceCall(_domain, service, _serviceData = {}, target = {}) {
+	if (!_isDemoMode) return;
+	const entityIds = Array.isArray(target.entity_id) ? target.entity_id : target.entity_id ? [target.entity_id] : [];
+	for (const entityId of entityIds) {
+		const entity = state.entities[entityId];
+		if (!entity) continue;
+		const entityDomain = extractDomain(entityId);
+		setState(produce((s) => {
+			const e = s.entities[entityId];
+			if (!e) return;
+			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);
+			else if (service === "lock") e.state = "locked";
+			else if (service === "unlock") e.state = "unlocked";
+			else if (service === "open_cover") {
+				e.state = "open";
+				if ("current_position" in e.attributes) e.attributes.current_position = 100;
+			} else if (service === "close_cover") {
+				e.state = "closed";
+				if ("current_position" in e.attributes) e.attributes.current_position = 0;
+			} 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 === "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";
+		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;
+		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";
+		delete e.attributes.brightness;
+	} else if (domain === "media_player") e.state = "paused";
+	else if (domain === "cover") {
+		e.state = "closed";
+		if ("current_position" in e.attributes) e.attributes.current_position = 0;
+	} else e.state = "off";
+}
+
+//#endregion
+//#region src/commands/service.ts
+/**
+* Call a Home Assistant service
+*/
+async function callService(domain, service, serviceData = {}, target = {}) {
+	const connection = privilegedConn();
+	if (!connection) {
+		applyDemoServiceCall(domain, service, serviceData, target);
+		return;
+	}
+	try {
+		const mockConnection = connection;
+		if (mockConnection && typeof mockConnection.callService === "function") await mockConnection.callService(domain, service, serviceData, target);
+		else await connection.sendMessagePromise({
+			type: "call_service",
+			domain,
+			service,
+			service_data: serviceData,
+			target
+		});
+	} catch (error) {
+		throw new Error(`Service call failed: ${error.message || String(error)}`);
+	}
+}
+/**
+* Turn on entity or entities
+*/
+async function turnOn(entityId, serviceData = {}) {
+	const firstEntityId = Array.isArray(entityId) ? entityId[0] : entityId;
+	if (!firstEntityId) throw new Error("Entity ID is required");
+	const domain = firstEntityId.split(".")[0];
+	if (!domain) throw new Error(`Invalid entity ID: ${firstEntityId}`);
+	await callService(domain, "turn_on", serviceData, { entity_id: entityId });
+}
+/**
+* Turn off entity or entities
+*/
+async function turnOff(entityId, serviceData = {}) {
+	const firstEntityId = Array.isArray(entityId) ? entityId[0] : entityId;
+	if (!firstEntityId) throw new Error("Entity ID is required");
+	const domain = firstEntityId.split(".")[0];
+	if (!domain) throw new Error(`Invalid entity ID: ${firstEntityId}`);
+	await callService(domain, "turn_off", serviceData, { entity_id: entityId });
+}
+/**
+* Toggle entity or entities
+*/
+async function toggle(entityId, serviceData = {}) {
+	const firstEntityId = Array.isArray(entityId) ? entityId[0] : entityId;
+	if (!firstEntityId) throw new Error("Entity ID is required");
+	const domain = firstEntityId.split(".")[0];
+	if (!domain) throw new Error(`Invalid entity ID: ${firstEntityId}`);
+	await callService(domain, "toggle", serviceData, { entity_id: entityId });
+}
+/**
+* Update entity registry entry
+*/
+async function updateEntity(entityId, updates) {
+	const connection = privilegedConn();
+	if (!connection) throw new Error("Not connected to Home Assistant. Call initConnection() first.");
+	try {
+		const result = await connection.sendMessagePromise({
+			type: "config/entity_registry/update",
+			entity_id: entityId,
+			...updates
+		});
+		if (result && typeof result === "object" && "_mockError" in result) throw new Error(`Entity registry entry not found: ${entityId}`);
+		return result;
+	} catch (error) {
+		if (error?.message && error.message.includes("Entity registry entry not found")) throw error;
+		throw new Error(`Entity update failed: ${error.message || String(error)}`);
+	}
+}
+/**
+* Send a generic WebSocket command
+*/
+async function sendCommand(command) {
+	const connection = privilegedConn();
+	if (!connection) throw new Error("Not connected");
+	try {
+		return await connection.sendMessagePromise(command);
+	} catch (error) {
+		throw new Error(`Command failed: ${error.message || String(error)}`);
+	}
+}
+/**
+* Execute multiple service calls in parallel
+*/
+async function batchServiceCalls(calls) {
+	await Promise.all(calls.map((call) => callService(call.domain, call.service, call.serviceData, call.target)));
+}
+/**
+* Execute multiple entity updates in parallel
+*/
+async function batchEntityUpdates(updates) {
+	return Promise.all(updates.map((u) => updateEntity(u.entityId, u.updates)));
+}
+
+//#endregion
+//#region src/entities/views.ts
+/**
+* Get icon for an entity from registry or attributes
+*/
+function resolveIcon(entity, registry) {
+	if (registry?.icon) return {
+		icon: registry.icon,
+		source: "registry"
+	};
+	if (entity.attributes?.icon) return {
+		icon: entity.attributes.icon,
+		source: "attribute"
+	};
+	return null;
+}
+/**
+* Build an EntityView from runtime state and registry metadata
+*/
+function buildEntityView(entity, registry) {
+	const domain = extractDomain(entity.entity_id);
+	const attributes = entity.attributes ?? {};
+	const friendlyName$1 = attributes.friendly_name ?? registry?.name ?? entity.entity_id;
+	const name = registry?.name ?? friendlyName$1;
+	const iconResolution = resolveIcon(entity, registry);
+	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];
+		if (device) areaId = device.area_id ?? null;
+	}
+	return {
+		id: entity.entity_id,
+		domain,
+		state: entity.state,
+		attributes: restAttributes,
+		lastChanged: new Date(entity.last_changed),
+		lastUpdated: new Date(entity.last_updated),
+		context: {
+			id: entity.context?.id ?? "",
+			parentId: entity.context?.parent_id ?? null,
+			userId: entity.context?.user_id ?? null
+		},
+		name,
+		friendlyName: friendlyName$1,
+		areaId,
+		deviceId: registry?.device_id ?? null,
+		platform: registry?.platform ?? "unknown",
+		uniqueId: registry?.unique_id ?? null,
+		isDisabled: registry?.disabled_by !== null && registry?.disabled_by !== void 0,
+		isHidden: registry?.hidden_by !== null && registry?.hidden_by !== void 0,
+		icon: iconResolution?.icon ?? null,
+		iconSource: iconResolution?.source ?? "default",
+		entityCategory: registry?.entity_category ?? null,
+		labels: registry?.labels ?? [],
+		aliases: registry?.aliases ?? [],
+		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
+	};
+}
+/**
+* Get or build an EntityView
+*/
+function getEntityView(entityId) {
+	const entity = state.entities[entityId];
+	if (!entity) return void 0;
+	const registry = state.entityRegistry[entityId];
+	return buildEntityView(entity, registry);
+}
+/**
+* Get multiple entity views
+*/
+function getEntityViews(entityIds) {
+	const views = [];
+	for (const id of entityIds) {
+		const view = getEntityView(id);
+		if (view) views.push(view);
+	}
+	return views;
+}
+/**
+* Get all entity views
+*/
+function getAllEntityViews() {
+	return getEntityViews(Object.keys(state.entities));
+}
+/**
+* Shallow equality check for EntityView.
+* Compares fields that affect rendering; skips lastUpdated (heartbeat noise).
+*/
+function entityViewEquals(a, b) {
+	if (a === b) return true;
+	if (!a || !b) return false;
+	return a.id === b.id && a.state === b.state && a.lastChanged.getTime() === b.lastChanged.getTime() && a.name === b.name && a.friendlyName === b.friendlyName && a.areaId === b.areaId && a.deviceId === b.deviceId && a.icon === b.icon && a.isDisabled === b.isDisabled && a.isHidden === b.isHidden && a.attributes === b.attributes;
+}
+
+//#endregion
+//#region src/entities/area-views.ts
+/** The area an entity belongs to: its own `area_id` wins; otherwise it inherits
+*  the area of its device. Null when neither resolves. */
+function entityAreaId(entry) {
+	if (entry.area_id) return entry.area_id;
+	if (entry.device_id) return state.devices[entry.device_id]?.area_id ?? null;
+	return null;
+}
+/** One pass over the device + entity registries → membership per area.
+*  O(devices + entities) for the whole home, vs the O(areas × (devices +
+*  entities)) of resolving each area independently. */
+function computeAreaMembership() {
+	const byArea = /* @__PURE__ */ new Map();
+	const ensure = (areaId) => {
+		let m = byArea.get(areaId);
+		if (!m) {
+			m = {
+				devices: [],
+				entityIds: []
+			};
+			byArea.set(areaId, m);
+		}
+		return m;
+	};
+	for (const device of Object.values(state.devices)) if (device.area_id) ensure(device.area_id).devices.push(device);
+	for (const [entityId, entry] of Object.entries(state.entityRegistry)) {
+		const areaId = entityAreaId(entry);
+		if (areaId) ensure(areaId).entityIds.push(entityId);
+	}
+	return byArea;
+}
+/** Membership for a single area, without indexing every other area. */
+function membershipFor(areaId) {
+	const devices = [];
+	for (const device of Object.values(state.devices)) if (device.area_id === areaId) devices.push(device);
+	const entityIds = [];
+	for (const [entityId, entry] of Object.entries(state.entityRegistry)) if (entityAreaId(entry) === areaId) entityIds.push(entityId);
+	return {
+		devices,
+		entityIds
+	};
+}
+/**
+* Build a DeviceView from registry data
+*/
+function buildDeviceView(device) {
+	return {
+		id: device.id,
+		name: device.name ?? "",
+		nameByUser: device.name_by_user ?? null,
+		manufacturer: device.manufacturer ?? null,
+		model: device.model ?? null,
+		swVersion: device.sw_version ?? null,
+		areaId: device.area_id ?? null,
+		configEntries: device.config_entries ?? [],
+		connections: device.connections ?? [],
+		identifiers: device.identifiers ?? [],
+		disabledBy: device.disabled_by ?? null
+	};
+}
+/** Assemble an AreaView from pre-resolved membership. `entities` is a lazy
+*  getter: materializing live EntityViews reads entity state, so deferring it
+*  keeps callers that only need names/ids/counts off the per-state-tick
+*  recompute path. The getter stays reactive — read inside a tracking scope it
+*  tracks those entities' state and updates like any other store read. */
+function assembleAreaView(areaId, membership) {
+	const area = state.areas[areaId];
+	if (!area) throw new Error(`Area ${areaId} not found`);
+	const devices = membership.devices.map((device) => buildDeviceView(device));
+	const entityIds = membership.entityIds;
+	return {
+		id: areaId,
+		name: area.name,
+		normalizedName: area.normalized_name ?? area.name.toLowerCase(),
+		aliases: Array.isArray(area.aliases) ? area.aliases : [],
+		floorId: area.floor_id ?? null,
+		icon: area.icon ?? null,
+		picture: area.picture ?? null,
+		labels: Array.isArray(area.labels) ? area.labels : [],
+		temperatureEntityId: area.temperature_entity_id ?? null,
+		humidityEntityId: area.humidity_entity_id ?? null,
+		createdAt: area.created_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+		modifiedAt: area.modified_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+		devices,
+		entityIds,
+		deviceIds: devices.map((d) => d.id),
+		get entities() {
+			return entityIds.length > 0 ? getEntityViews(entityIds) : [];
+		}
+	};
+}
+/**
+* Build an AreaView for a single area from registry data.
+*/
+function buildAreaView(areaId) {
+	return assembleAreaView(areaId, membershipFor(areaId));
+}
+/**
+* Get all area views. Membership is resolved in a single registry pass; entity
+* views stay lazy per area (see `assembleAreaView`).
+*/
+function getAreaViews() {
+	const membership = computeAreaMembership();
+	return Object.keys(state.areas).map((areaId) => assembleAreaView(areaId, membership.get(areaId) ?? {
+		devices: [],
+		entityIds: []
+	}));
+}
+/**
+* Get area view
+*/
+function getAreaView(areaId) {
+	try {
+		return buildAreaView(areaId);
+	} catch {
+		return void 0;
+	}
+}
+
+//#endregion
+//#region src/history/statistics.ts
+const STATISTIC_TYPES = [
+	"mean",
+	"sum",
+	"min",
+	"max",
+	"state",
+	"change"
+];
+/**
+* HA returns start/end as ISO strings or ms numbers depending on version.
+* Normalize both shapes to ms epoch numbers; unparseable values become NaN.
+*/
+function normalizeStatisticTime(value) {
+	if (typeof value === "number") return value;
+	if (typeof value === "string") return new Date(value).getTime();
+	return NaN;
+}
+function normalizeNumber(value) {
+	return typeof value === "number" ? value : void 0;
+}
+function normalizeStatisticValue(raw) {
+	const value = {
+		start: normalizeStatisticTime(raw.start),
+		end: normalizeStatisticTime(raw.end)
+	};
+	const mean = normalizeNumber(raw.mean);
+	if (mean !== void 0) value.mean = mean;
+	const sum = normalizeNumber(raw.sum);
+	if (sum !== void 0) value.sum = sum;
+	const min = normalizeNumber(raw.min);
+	if (min !== void 0) value.min = min;
+	const max = normalizeNumber(raw.max);
+	if (max !== void 0) value.max = max;
+	const stateVal = normalizeNumber(raw.state);
+	if (stateVal !== void 0) value.state = stateVal;
+	const change = normalizeNumber(raw.change);
+	if (change !== void 0) value.change = change;
+	return value;
+}
+/**
+* Fetch long-term statistics for one or more statistic ids during a period.
+*
+* Statistic ids with no data are returned as empty arrays so callers never
+* hit `undefined`.
+*/
+async function fetchStatisticsDuringPeriod(connection, statisticIds, options) {
+	const { startTime, endTime, period } = options;
+	if (isDemoMode()) {
+		const result$1 = {};
+		const statPeriod = period === "hour" || period === "day" ? period : "day";
+		const endMs = (endTime ?? /* @__PURE__ */ new Date()).getTime();
+		for (const id of statisticIds) result$1[id] = isEnergyEntity(id) ? synthesizeEnergyStatistics(id, startTime.getTime(), endMs, statPeriod) : [];
+		return result$1;
+	}
+	const params = {
+		type: "recorder/statistics_during_period",
+		start_time: startTime.toISOString(),
+		statistic_ids: statisticIds,
+		period,
+		types: STATISTIC_TYPES
+	};
+	if (endTime) params.end_time = endTime.toISOString();
+	const response = await connection.sendMessagePromise(params);
+	const result = {};
+	for (const id of statisticIds) result[id] = [];
+	if (response && typeof response === "object") for (const [id, buckets] of Object.entries(response)) result[id] = Array.isArray(buckets) ? buckets.map(normalizeStatisticValue) : [];
+	return result;
+}
+
+//#endregion
+export { applyDemoServiceCall, batchEntityUpdates, batchServiceCalls, buildAreaView, buildDeviceView, buildEntityView, callService, createDemoFixtures, demoEnergyPreferences, entityViewEquals, extractDomain, fetchStatisticsDuringPeriod, forceResubscribe, forceResubscribeCalendars, getAllEntityViews, getAreaView, getAreaViews, getEntityView, getEntityViews, isDemoMode, isEnergyEntity, loadDemoData, normalizeStatisticTime, privilegedConn, registerEntity, sendCommand, setManagerConnection, setPrivilegedConn, setResubscribeHandler, setState, startDemoEnergyTicker, state, stopDemoEnergyTicker, synthesizeEnergyHistory, toggle, trackCalendarEvents, turnOff, turnOn, unloadDemoData, updateEntity };