@glasshome/sync-layer 0.9.1 → 0.10.1

package/dist/track-DssLNusE.js

@@ -0,0 +1,4959 @@
+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) {
+	privileged = conn;
+}
+//#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$1();
+	return () => unregisterEntity(entityId);
+}
+/**
+* Set the connection reference used for resubscribing.
+*/
+function setManagerConnection(connection) {
+	conn = connection;
+	if (refCounts.size > 0) scheduleFlush$1();
+}
+/**
+* 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$1() {
+	if (flushScheduled) return;
+	flushScheduled = true;
+	queueMicrotask(() => {
+		flushScheduled = false;
+		flush().catch(logFlushError);
+	});
+}
+function scheduleDelayedFlush() {
+	if (unregisterTimeout) return;
+	unregisterTimeout = setTimeout(() => {
+		unregisterTimeout = null;
+		flush().catch(logFlushError);
+	}, UNREGISTER_DELAY_MS);
+}
+function logFlushError(error) {
+	console.error("[@glasshome/sync-layer] entity resubscribe failed:", error);
+}
+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/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 = attributes.friendly_name ?? registry?.name ?? entity.entity_id;
+	const name = registry?.name ?? friendlyName;
+	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,
+		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;
+	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
+/**
+* Area View Builder
+*
+* Constructs unified AreaView objects by combining registry data with computed
+* entities and devices.
+*
+* Membership (which entities/devices belong to an area) is registry-driven and
+* cheap; live entity *views* read entity state and are therefore exposed as a
+* lazy `entities` getter. Callers that only need names, ids, or counts never
+* touch entity state, so building the whole-area list does not recompute on
+* every entity state tick.
+*
+* @packageDocumentation
+*/
+/** 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;
+	}
+}
+//#endregion
+//#region src/history/points.ts
+/** Hard cap on retained points per entity timeline. */
+const MAX_HISTORY_POINTS = 5760;
+/**
+* Append a state change to an entity's history.
+* Called by the entity subscription handler when a tracked entity changes.
+*/
+function appendHistoryPoint(entityId, stateValue, attributes, lastUpdated, lastChanged) {
+	setState(produce((s) => {
+		const history = s.history[entityId];
+		if (!history) return;
+		const point = {
+			s: stateValue,
+			a: attributes,
+			lu: lastUpdated,
+			lc: lastChanged
+		};
+		history.entityHistory.push(point);
+		history.timeline.push({
+			timestamp: lastUpdated,
+			state: stateValue,
+			attributes,
+			lastChanged,
+			lastUpdated
+		});
+	}));
+}
+/**
+* Append multiple history points in a single setState(produce(...)).
+* Called by the rAF-batched subscription flush.
+*/
+function bulkAppendHistoryPoints(points) {
+	if (points.length === 0) return;
+	setState(produce((s) => {
+		const touched = /* @__PURE__ */ new Set();
+		for (const { entityId, stateValue, attributes, lastUpdated, lastChanged } of points) {
+			const history = s.history[entityId];
+			if (!history) continue;
+			history.entityHistory.push({
+				s: stateValue,
+				a: attributes,
+				lu: lastUpdated,
+				lc: lastChanged
+			});
+			history.timeline.push({
+				timestamp: lastUpdated,
+				state: stateValue,
+				attributes,
+				lastChanged,
+				lastUpdated
+			});
+			touched.add(entityId);
+		}
+		for (const entityId of touched) {
+			const history = s.history[entityId];
+			if (!history) continue;
+			if (history.entityHistory.length > 5760) history.entityHistory.splice(0, history.entityHistory.length - MAX_HISTORY_POINTS);
+			if (history.timeline.length > 5760) history.timeline.splice(0, history.timeline.length - MAX_HISTORY_POINTS);
+		}
+	}));
+}
+//#endregion
+//#region src/demo/demo-album-cover.ts
+const DEMO_ALBUM_COVER = "data:image/webp;base64,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";
+//#endregion
+//#region src/demo/world/sun.ts
+const RAD$1 = Math.PI / 180;
+function declinationAndEquation(ms) {
+	const d = ms / 864e5 + 2440587.5 - 2451545;
+	const g = (357.529 + .98560028 * d) * RAD$1;
+	const q = 280.459 + .98564736 * d;
+	const l = (q + 1.915 * Math.sin(g) + .02 * Math.sin(2 * g)) * RAD$1;
+	const e = (23.439 - 36e-8 * d) * RAD$1;
+	const ra = Math.atan2(Math.cos(e) * Math.sin(l), Math.cos(l)) / RAD$1 / 15;
+	return {
+		decl: Math.asin(Math.sin(e) * Math.sin(l)),
+		eqTimeMin: ((q / 15 - (ra % 24 + 24) % 24) * 60 + 720) % 1440 - 720
+	};
+}
+function solarElevation(ms, lat, lon) {
+	const { decl, eqTimeMin } = declinationAndEquation(ms);
+	const hourAngle = ((ms / 6e4 % 1440 + eqTimeMin + lon * 4) / 4 - 180) * RAD$1;
+	const phi = lat * RAD$1;
+	const sinEl = Math.sin(phi) * Math.sin(decl) + Math.cos(phi) * Math.cos(decl) * Math.cos(hourAngle);
+	return Math.asin(sinEl) / RAD$1;
+}
+const STEP_MS = 6e4;
+function nextCrossing(ms, lat, lon, rising) {
+	let prev = solarElevation(ms, lat, lon);
+	for (let t = ms + STEP_MS; t < ms + 1728e5; t += STEP_MS) {
+		const el = solarElevation(t, lat, lon);
+		if (rising ? prev < -.833 && el >= -.833 : prev >= -.833 && el < -.833) return t;
+		prev = el;
+	}
+	return ms + 864e5;
+}
+function sunTimes(ms, lat, lon) {
+	return {
+		risingMs: nextCrossing(ms, lat, lon, true),
+		settingMs: nextCrossing(ms, lat, lon, false)
+	};
+}
+//#endregion
+//#region src/demo/world/local-time.ts
+const formatters = /* @__PURE__ */ new Map();
+function formatter(timeZone) {
+	let f = formatters.get(timeZone);
+	if (!f) {
+		f = new Intl.DateTimeFormat("en-US", {
+			timeZone,
+			hourCycle: "h23",
+			year: "numeric",
+			month: "2-digit",
+			day: "2-digit",
+			hour: "2-digit",
+			minute: "2-digit",
+			second: "2-digit",
+			weekday: "short"
+		});
+		formatters.set(timeZone, f);
+	}
+	return f;
+}
+const WEEKDAYS = {
+	Sun: 0,
+	Mon: 1,
+	Tue: 2,
+	Wed: 3,
+	Thu: 4,
+	Fri: 5,
+	Sat: 6
+};
+function parts(ms, timeZone) {
+	const out = {};
+	for (const p of formatter(timeZone).formatToParts(ms)) out[p.type] = p.value;
+	return {
+		year: Number(out.year),
+		month: Number(out.month),
+		day: Number(out.day),
+		hour: Number(out.hour),
+		minute: Number(out.minute),
+		second: Number(out.second),
+		weekday: WEEKDAYS[out.weekday ?? "Sun"] ?? 0
+	};
+}
+function utcOffsetMinutes(ms, timeZone) {
+	const p = parts(ms, timeZone);
+	const asUtc = Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute, p.second);
+	return Math.round((asUtc - Math.floor(ms / 1e3) * 1e3) / 6e4);
+}
+function localTime$1(ms, timeZone) {
+	const p = parts(ms, timeZone);
+	const minuteOfDay = p.hour * 60 + p.minute + p.second / 60;
+	const startOfYear = Date.UTC(p.year, 0, 1);
+	const dayUtc = Date.UTC(p.year, p.month - 1, p.day);
+	const dateKey = `${p.year}-${String(p.month).padStart(2, "0")}-${String(p.day).padStart(2, "0")}`;
+	const midnightMs = dayUtc - utcOffsetMinutes(dayUtc, timeZone) * 6e4;
+	return {
+		hour: minuteOfDay / 60,
+		minuteOfDay,
+		weekday: p.weekday,
+		dayOfYear: Math.round((dayUtc - startOfYear) / 864e5) + 1,
+		dateKey,
+		midnightMs
+	};
+}
+//#endregion
+//#region src/demo/world/noise.ts
+function noise(seed, key) {
+	let h = 2166136261 ^ seed;
+	for (let i = 0; i < key.length; i++) {
+		h ^= key.charCodeAt(i);
+		h = Math.imul(h, 16777619);
+	}
+	h ^= h >>> 13;
+	h = Math.imul(h, 1540483477);
+	h ^= h >>> 15;
+	return (h >>> 0) / 4294967296;
+}
+//#endregion
+//#region src/demo/world/world.ts
+const LATITUDE = 48;
+function worldFor(timeZone, seed, atMs) {
+	return {
+		timeZone,
+		seed,
+		latitude: LATITUDE,
+		longitude: utcOffsetMinutes(atMs, timeZone) / 4
+	};
+}
+let current = {
+	timeZone: "UTC",
+	seed: 1,
+	latitude: LATITUDE,
+	longitude: 0
+};
+function setWorld(w) {
+	current = w;
+}
+function getWorld() {
+	return current;
+}
+function outdoorTempC(ms, w) {
+	const lt = localTime$1(ms, w.timeZone);
+	const seasonal = 10 - 11 * Math.cos((lt.dayOfYear - 20) / 365 * 2 * Math.PI);
+	const diurnal = 5 * Math.cos((lt.hour - 15) / 24 * 2 * Math.PI);
+	const dayDrift = (noise(w.seed, `temp:${lt.dateKey}`) - .5) * 6;
+	return seasonal + diurnal + dayDrift;
+}
+function cloudCover(ms, w) {
+	const lt = localTime$1(ms, w.timeZone);
+	const base = noise(w.seed, `cloud:${lt.dateKey}`);
+	const hourly = noise(w.seed, `cloud:${lt.dateKey}:${Math.floor(lt.hour)}`);
+	return Math.min(1, Math.max(0, base * .7 + hourly * .3));
+}
+//#endregion
+//#region src/demo/energy-sim.ts
+/**
+* Demo Energy Simulation
+*
+* A pure, deterministic model of a solar home: solar production, household
+* load with appliance events, a battery that charges on surplus and covers
+* deficits, and grid import/export as the residual.
+*
+* `simulateEnergy(timestampMs)` is the single source of truth. Live ticks,
+* day history, and long-term statistics are all derived from it, so every
+* widget agrees with every other widget. There is no hidden mutable state:
+* the only module-level data is a memoization cache of a pure computation
+* (battery SOC integrated from local midnight).
+*
+* @packageDocumentation
+*/
+const SOLAR_PEAK_W = 5200;
+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 lt = localTime$1(timestampMs, getWorld().timeZone);
+	return {
+		hourFrac: lt.hour,
+		minuteOfDay: lt.minuteOfDay,
+		dayOfWeek: lt.weekday,
+		dayKey: Math.round(lt.midnightMs / 864e5),
+		midnightMs: lt.midnightMs
+	};
+}
+const RAD = Math.PI / 180;
+function solarPower(timestampMs) {
+	const w = getWorld();
+	const elevation = solarElevation(timestampMs, w.latitude, w.longitude);
+	if (elevation <= 0) return 0;
+	const shape = Math.sin(elevation * RAD) ** 1.3;
+	return SOLAR_PEAK_W * shape * (1 - .7 * cloudCover(timestampMs, w));
+}
+function fridgePower(lt) {
+	const phase = mulberry32(hashInt(lt.dayKey * 40503 + 7))() * FRIDGE_CYCLE_MIN;
+	return (lt.minuteOfDay + phase) % FRIDGE_CYCLE_MIN < 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 >= 1165) return 0;
+	return (lt.minuteOfDay - start) % 6.5 < 4 ? 2200 : 0;
+}
+function dishwasherPower(lt) {
+	const start = 1270;
+	if (lt.minuteOfDay < start || lt.minuteOfDay >= 1335) 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 >= 680) return 0;
+	return lt.minuteOfDay - start < 14 ? 2100 : 250;
+}
+function evChargerPower(lt) {
+	if (![
+		2,
+		4,
+		0
+	].includes(lt.dayOfWeek)) return 0;
+	const start = 1100;
+	if (lt.minuteOfDay < start || lt.minuteOfDay >= 1300) return 0;
+	const into = lt.minuteOfDay - start;
+	return 7200 * (into < 2 ? into / 2 : 1);
+}
+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 phase = mulberry32(hashInt(lt.dayKey * 22699 + 13))() * 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);
+	return solarPower(timestampMs) - homePower(lt);
+}
+/**
+* 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(1440 / SOC_STEP_MIN);
+	const arr = /* @__PURE__ */ new Float64Array(289);
+	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 surplus = netSurplusAt(midnightMs + i * stepMs);
+		let chargeW = 0;
+		let dischargeW = 0;
+		if (surplus > 0) {
+			const headroomW = (BATTERY_MAX_SOC - soc) / 100 * BATTERY_CAPACITY_WH / stepHours;
+			chargeW = Math.min(surplus, BATTERY_POWER_CAP_W, Math.max(0, headroomW));
+		} else if (surplus < 0) {
+			const availW = (soc - BATTERY_MIN_SOC) / 100 * BATTERY_CAPACITY_WH / stepHours;
+			dischargeW = Math.min(-surplus, BATTERY_POWER_CAP_W, Math.max(0, availW));
+		}
+		const nextSoc = soc + (chargeW - dischargeW) * stepHours / 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;
+	return a + ((prefix[i + 1] ?? a) - a) * frac;
+}
+function homePower(lt) {
+	return (ALWAYS_ON_W + fridgePower(lt) + kettlePower(lt) + ovenPower(lt) + dishwasherPower(lt) + washerPower(lt) + evChargerPower(lt) + heatPumpPower(lt) + occupancyEnvelope(lt)) * 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 = lt.midnightMs;
+	const solarW = solarPower(timestampMs);
+	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) batteryChargeW = Math.min(surplus, soc < BATTERY_MAX_SOC ? BATTERY_POWER_CAP_W : 0);
+	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
+	};
+}
+/** 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;
+	}
+}
+/** 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 = 3e5;
+	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/kinds/types.ts
+/** Registry override wins; otherwise domain.device-key[_suffix], the generator's default naming. */
+function entityIdFor(domain, device, role, suffix) {
+	const explicit = device.ids?.[role];
+	if (explicit) return explicit;
+	const base = device.key;
+	return `${domain}.${suffix ? `${base}_${suffix}` : base}`;
+}
+//#endregion
+//#region src/demo/kinds/actuators.ts
+const round1$1 = (n) => Math.round(n * 10) / 10;
+const round2 = (n) => Math.round(n * 100) / 100;
+const round10$1 = (n) => Math.round(n / 10) * 10;
+const roundInt$1 = (n) => Math.round(n);
+const clamp = (n, lo, hi) => Math.min(hi, Math.max(lo, n));
+function lightColorModes(p) {
+	if (p.color) return p.colorTemp ? ["hs", "color_temp"] : ["hs"];
+	if (p.colorTemp) return ["color_temp"];
+	if (p.dimmable) return ["brightness"];
+	return ["onoff"];
+}
+function lightSupportedFeatures(p) {
+	return p.supportedFeatures ?? (p.color || p.colorTemp ? 44 : p.dimmable ? 1 : 0);
+}
+function applyLightOn(s, data) {
+	const next = {
+		...s,
+		on: true
+	};
+	if (data.brightness_pct != null) next.brightness = roundInt$1(clamp(Number(data.brightness_pct), 0, 100) / 100 * 255);
+	else if (data.brightness != null) next.brightness = Number(data.brightness);
+	if (data.color_temp_kelvin != null) {
+		next.colorTempKelvin = Number(data.color_temp_kelvin);
+		next.colorMode = "color_temp";
+	}
+	if (data.hs_color != null) {
+		next.hsColor = data.hs_color;
+		next.colorMode = "hs";
+	}
+	return next;
+}
+const light = {
+	entities(device) {
+		const p = device.params;
+		return [{
+			entityId: entityIdFor("light", device, "light"),
+			name: device.name,
+			supportedFeatures: lightSupportedFeatures(p),
+			primary: true
+		}];
+	},
+	apply(state, event, device) {
+		const p = device.params;
+		const s = state ?? {
+			on: false,
+			brightness: 255,
+			colorMode: lightColorModes(p)[0],
+			watts: p.watts ?? 0
+		};
+		if (event.type !== "call") return s;
+		switch (event.service) {
+			case "turn_on": return applyLightOn(s, event.data);
+			case "turn_off": return {
+				...s,
+				on: false
+			};
+			case "toggle": return s.on ? {
+				...s,
+				on: false
+			} : applyLightOn(s, event.data);
+			default: return s;
+		}
+	},
+	project(state, device) {
+		const s = state;
+		const p = device.params;
+		const id = entityIdFor("light", device, "light");
+		const attributes = {
+			supported_color_modes: lightColorModes(p),
+			supported_features: lightSupportedFeatures(p)
+		};
+		if (s.on) {
+			attributes.color_mode = s.colorMode;
+			attributes.brightness = roundInt$1(s.brightness);
+			if (s.colorMode === "color_temp" && s.colorTempKelvin != null) attributes.color_temp_kelvin = s.colorTempKelvin;
+			if (s.colorMode === "hs" && s.hsColor) attributes.hs_color = s.hsColor;
+		}
+		return { [id]: {
+			state: s.on ? "on" : "off",
+			attributes
+		} };
+	},
+	powerW(state) {
+		const s = state;
+		return s.on ? s.watts * s.brightness / 255 : 0;
+	},
+	handles: [
+		"turn_on",
+		"turn_off",
+		"toggle"
+	]
+};
+const KWH_PER_WATT_MS = 1 / 36e8;
+function switchPowerId(device, p) {
+	return p.legacyPowerId ?? entityIdFor("sensor", device, "power", "power");
+}
+function legacyWatts(id, nowMs) {
+	return Number(formatEnergyState(id, energyEntityValue(id, simulateEnergy(nowMs)) ?? 0));
+}
+function switchWatts(s, p, nowMs) {
+	if (p.legacyPowerId) return legacyWatts(p.legacyPowerId, nowMs);
+	return s.on ? s.watts : 0;
+}
+function nextSwitchState(s, event, p, nowMs) {
+	if (event.type === "tick") {
+		if (!p.energy) return s;
+		return {
+			...s,
+			energyKwh: s.energyKwh + switchWatts(s, p, nowMs) * event.dtMs * KWH_PER_WATT_MS
+		};
+	}
+	if (event.type !== "call") return s;
+	switch (event.service) {
+		case "turn_on": return {
+			...s,
+			on: true
+		};
+		case "turn_off": return {
+			...s,
+			on: false
+		};
+		case "toggle": return {
+			...s,
+			on: !s.on
+		};
+		default: return s;
+	}
+}
+const switchKind = {
+	entities(device) {
+		const p = device.params;
+		const seeds = [{
+			entityId: entityIdFor("switch", device, "switch"),
+			name: device.name,
+			deviceClass: p.deviceClass,
+			primary: true
+		}];
+		if (p.power || p.legacyPowerId) seeds.push({
+			entityId: switchPowerId(device, p),
+			name: "Power",
+			deviceClass: "power",
+			unit: "W"
+		});
+		if (p.energy) seeds.push({
+			entityId: entityIdFor("sensor", device, "energy", "energy"),
+			name: "Energy",
+			deviceClass: "energy",
+			unit: "kWh"
+		});
+		return seeds;
+	},
+	apply(state, event, device, ctx) {
+		const p = device.params;
+		const s = state ?? {
+			on: false,
+			watts: p.watts ?? 0,
+			energyKwh: round2(ctx.noise(`${device.key}:energy`) * 200),
+			lastWatts: 0
+		};
+		const next = nextSwitchState(s, event, p, ctx.nowMs);
+		const lastWatts = switchWatts(next, p, ctx.nowMs);
+		return next === s && s.lastWatts === lastWatts ? s : {
+			...next,
+			lastWatts
+		};
+	},
+	project(state, device, ctx) {
+		const s = state;
+		const p = device.params;
+		const watts = switchWatts(s, p, ctx.nowMs);
+		const on = p.legacyPowerId ? watts > 5 : s.on;
+		const out = { [entityIdFor("switch", device, "switch")]: {
+			state: on ? "on" : "off",
+			attributes: p.deviceClass ? { device_class: p.deviceClass } : {}
+		} };
+		if (p.power || p.legacyPowerId) out[switchPowerId(device, p)] = {
+			state: String(p.legacyPowerId ? watts : round10$1(watts)),
+			attributes: {
+				unit_of_measurement: "W",
+				device_class: "power",
+				state_class: "measurement"
+			}
+		};
+		if (p.energy) out[entityIdFor("sensor", device, "energy", "energy")] = {
+			state: s.energyKwh.toFixed(2),
+			attributes: {
+				unit_of_measurement: "kWh",
+				device_class: "energy",
+				state_class: "total_increasing"
+			}
+		};
+		return out;
+	},
+	powerW(state) {
+		return state.lastWatts;
+	},
+	handles: [
+		"turn_on",
+		"turn_off",
+		"toggle"
+	]
+};
+function fanSupportedFeatures(p) {
+	let sf = 1;
+	if (p.oscillate) sf |= 2;
+	if (p.direction) sf |= 4;
+	if (p.presets) sf |= 8;
+	return sf;
+}
+const fan = {
+	entities(device) {
+		const p = device.params;
+		return [{
+			entityId: entityIdFor("fan", device, "fan"),
+			name: device.name,
+			supportedFeatures: fanSupportedFeatures(p),
+			primary: true
+		}];
+	},
+	apply(state, event, device) {
+		const p = device.params;
+		const s = state ?? {
+			on: false,
+			percentage: 0,
+			oscillating: p.oscillate ? false : void 0,
+			direction: p.direction ? "forward" : void 0,
+			watts: p.watts ?? 0
+		};
+		if (event.type !== "call") return s;
+		const data = event.data;
+		switch (event.service) {
+			case "turn_on": return {
+				...s,
+				on: true,
+				percentage: data.percentage != null ? Number(data.percentage) : s.percentage > 0 ? s.percentage : 100
+			};
+			case "turn_off": return {
+				...s,
+				on: false
+			};
+			case "toggle": return s.on ? {
+				...s,
+				on: false
+			} : {
+				...s,
+				on: true,
+				percentage: s.percentage > 0 ? s.percentage : 100
+			};
+			case "set_percentage": {
+				const percentage = clamp(Number(data.percentage), 0, 100);
+				return {
+					...s,
+					percentage,
+					on: percentage > 0
+				};
+			}
+			case "set_preset_mode": return typeof data.preset_mode === "string" ? {
+				...s,
+				presetMode: data.preset_mode,
+				on: true
+			} : s;
+			case "oscillate": return data.oscillating != null ? {
+				...s,
+				oscillating: Boolean(data.oscillating)
+			} : s;
+			case "set_direction": return typeof data.direction === "string" ? {
+				...s,
+				direction: data.direction
+			} : s;
+			default: return s;
+		}
+	},
+	project(state, device) {
+		const s = state;
+		const p = device.params;
+		const id = entityIdFor("fan", device, "fan");
+		const attributes = {
+			percentage: roundInt$1(s.percentage),
+			supported_features: fanSupportedFeatures(p)
+		};
+		if (p.presets) {
+			attributes.preset_modes = p.presets;
+			attributes.preset_mode = s.presetMode;
+		}
+		if (p.oscillate) attributes.oscillating = s.oscillating ?? false;
+		if (p.direction) attributes.current_direction = s.direction ?? "forward";
+		return { [id]: {
+			state: s.on ? "on" : "off",
+			attributes
+		} };
+	},
+	powerW(state) {
+		const s = state;
+		return s.on ? s.watts : 0;
+	},
+	handles: [
+		"turn_on",
+		"turn_off",
+		"toggle",
+		"set_percentage",
+		"set_preset_mode",
+		"oscillate",
+		"set_direction"
+	]
+};
+function coverSupportedFeatures(p) {
+	if (p.supportedFeatures != null) return p.supportedFeatures;
+	let sf = 11;
+	if (p.position) sf |= 4;
+	if (p.tilt) sf |= 240;
+	return sf;
+}
+function coverRestLabel(position) {
+	return (position ?? 0) > 0 ? "open" : "closed";
+}
+function tickCover(s, dtMs, travelMs) {
+	if (s.position === void 0 || s.target === void 0 || s.position === s.target) return {
+		...s,
+		state: coverRestLabel(s.position)
+	};
+	const dir = s.target > s.position ? 1 : -1;
+	const step = 100 / travelMs * dtMs;
+	let next = s.position + dir * step;
+	if (dir > 0 && next >= s.target || dir < 0 && next <= s.target) next = s.target;
+	const reached = next === s.target;
+	return {
+		...s,
+		position: next,
+		state: reached ? coverRestLabel(next) : dir > 0 ? "opening" : "closing"
+	};
+}
+const cover = {
+	entities(device) {
+		const p = device.params;
+		return [{
+			entityId: entityIdFor("cover", device, "cover"),
+			name: device.name,
+			deviceClass: p.deviceClass,
+			supportedFeatures: coverSupportedFeatures(p),
+			primary: true
+		}];
+	},
+	apply(state, event, device) {
+		const p = device.params;
+		const s = state ?? {
+			state: "closed",
+			position: p.position ? 0 : void 0,
+			target: p.position ? 0 : void 0,
+			tiltPosition: p.tilt ? 0 : void 0
+		};
+		if (event.type === "tick") return p.position ? tickCover(s, event.dtMs, p.travelMs ?? 8e3) : s;
+		if (event.type !== "call") return s;
+		const data = event.data;
+		switch (event.service) {
+			case "open_cover": return p.position ? {
+				...s,
+				target: 100
+			} : {
+				...s,
+				state: "open"
+			};
+			case "close_cover": return p.position ? {
+				...s,
+				target: 0
+			} : {
+				...s,
+				state: "closed"
+			};
+			case "stop_cover": return p.position ? {
+				...s,
+				target: s.position
+			} : s;
+			case "set_cover_position": return p.position && data.position != null ? {
+				...s,
+				target: clamp(Number(data.position), 0, 100)
+			} : s;
+			case "toggle":
+				if (p.position) {
+					const atOpen = s.state === "open" || s.state === "opening";
+					return {
+						...s,
+						target: atOpen ? 0 : 100
+					};
+				}
+				return {
+					...s,
+					state: s.state === "open" ? "closed" : "open"
+				};
+			case "open_cover_tilt": return p.tilt ? {
+				...s,
+				tiltPosition: 100
+			} : s;
+			case "close_cover_tilt": return p.tilt ? {
+				...s,
+				tiltPosition: 0
+			} : s;
+			case "set_cover_tilt_position": return p.tilt && data.tilt_position != null ? {
+				...s,
+				tiltPosition: clamp(Number(data.tilt_position), 0, 100)
+			} : s;
+			case "stop_cover_tilt": return s;
+			default: return s;
+		}
+	},
+	project(state, device) {
+		const s = state;
+		const p = device.params;
+		const id = entityIdFor("cover", device, "cover");
+		const attributes = { supported_features: coverSupportedFeatures(p) };
+		if (p.position) attributes.current_position = roundInt$1(s.position ?? 0);
+		if (p.tilt) attributes.current_tilt_position = roundInt$1(s.tiltPosition ?? 0);
+		if (p.deviceClass) attributes.device_class = p.deviceClass;
+		return { [id]: {
+			state: s.state,
+			attributes
+		} };
+	},
+	handles: [
+		"open_cover",
+		"close_cover",
+		"stop_cover",
+		"set_cover_position",
+		"toggle",
+		"open_cover_tilt",
+		"close_cover_tilt",
+		"set_cover_tilt_position",
+		"stop_cover_tilt"
+	]
+};
+const lock = {
+	entities(device) {
+		const p = device.params;
+		return [{
+			entityId: entityIdFor("lock", device, "lock"),
+			name: device.name,
+			supportedFeatures: p.supportedFeatures,
+			primary: true
+		}];
+	},
+	apply(state, event, device) {
+		const s = state ?? { locked: !device.params.unlocked };
+		if (event.type !== "call") return s;
+		switch (event.service) {
+			case "lock": return { locked: true };
+			case "unlock": return { locked: false };
+			default: return s;
+		}
+	},
+	project(state, device) {
+		const s = state;
+		const p = device.params;
+		const id = entityIdFor("lock", device, "lock");
+		const attributes = p.supportedFeatures != null ? { supported_features: p.supportedFeatures } : {};
+		return { [id]: {
+			state: s.locked ? "locked" : "unlocked",
+			attributes
+		} };
+	},
+	handles: ["lock", "unlock"]
+};
+const CLIMATE_ACTIVE_MODES = /* @__PURE__ */ new Set([
+	"heat",
+	"cool",
+	"heat_cool",
+	"auto"
+]);
+function climateHvacAction(s) {
+	if (s.hvacMode === "off") return "off";
+	if (s.hvacMode === "heat") return s.currentTemp < s.targetTemp - .1 ? "heating" : "idle";
+	if (s.hvacMode === "cool") return s.currentTemp > s.targetTemp + .1 ? "cooling" : "idle";
+	if (s.currentTemp < s.targetTemp - .1) return "heating";
+	if (s.currentTemp > s.targetTemp + .1) return "cooling";
+	return "idle";
+}
+function climateSupportedFeatures(p) {
+	if (p.supportedFeatures != null) return p.supportedFeatures;
+	let sf = 1;
+	if (p.fanModes) sf |= 8;
+	if (p.presets) sf |= 16;
+	return sf;
+}
+const climate = {
+	entities(device) {
+		const p = device.params;
+		return [{
+			entityId: entityIdFor("climate", device, "climate"),
+			name: device.name,
+			supportedFeatures: climateSupportedFeatures(p),
+			primary: true
+		}];
+	},
+	apply(state, event, device, ctx) {
+		const p = device.params;
+		const s = state ?? {
+			hvacMode: "heat",
+			targetTemp: 21,
+			currentTemp: 21,
+			watts: p.watts ?? 0
+		};
+		if (event.type === "tick") {
+			const heating = CLIMATE_ACTIVE_MODES.has(s.hvacMode);
+			const ambient = 20 + (outdoorTempC(ctx.nowMs, ctx.world) - 20) * .15;
+			const targetAmbient = heating ? s.targetTemp : ambient;
+			const tauMs = heating ? 4e4 : 12e5;
+			const decay = Math.exp(-event.dtMs / tauMs);
+			return {
+				...s,
+				currentTemp: targetAmbient + (s.currentTemp - targetAmbient) * decay
+			};
+		}
+		if (event.type !== "call") return s;
+		const data = event.data;
+		switch (event.service) {
+			case "set_temperature": {
+				const next = { ...s };
+				if (data.temperature != null) next.targetTemp = Number(data.temperature);
+				if (data.target_temp_low != null) next.targetTempLow = Number(data.target_temp_low);
+				if (data.target_temp_high != null) next.targetTempHigh = Number(data.target_temp_high);
+				return next;
+			}
+			case "set_hvac_mode": return typeof data.hvac_mode === "string" ? {
+				...s,
+				hvacMode: data.hvac_mode
+			} : s;
+			case "set_fan_mode": return typeof data.fan_mode === "string" ? {
+				...s,
+				fanMode: data.fan_mode
+			} : s;
+			case "set_preset_mode": return typeof data.preset_mode === "string" ? {
+				...s,
+				presetMode: data.preset_mode
+			} : s;
+			default: return s;
+		}
+	},
+	project(state, device) {
+		const s = state;
+		const p = device.params;
+		const id = entityIdFor("climate", device, "climate");
+		const attributes = {
+			temperature: round1$1(s.targetTemp),
+			current_temperature: round1$1(s.currentTemp),
+			hvac_modes: p.modes ?? [
+				"off",
+				"heat",
+				"cool",
+				"auto"
+			],
+			hvac_action: climateHvacAction(s),
+			min_temp: 7,
+			max_temp: 35,
+			supported_features: climateSupportedFeatures(p)
+		};
+		if (s.targetTempLow != null) attributes.target_temp_low = round1$1(s.targetTempLow);
+		if (s.targetTempHigh != null) attributes.target_temp_high = round1$1(s.targetTempHigh);
+		if (p.fanModes) {
+			attributes.fan_modes = p.fanModes;
+			attributes.fan_mode = s.fanMode ?? p.fanModes[0];
+		}
+		if (p.presets) {
+			attributes.preset_modes = p.presets;
+			attributes.preset_mode = s.presetMode ?? p.presets[0];
+		}
+		return { [id]: {
+			state: s.hvacMode,
+			attributes
+		} };
+	},
+	powerW(state) {
+		const s = state;
+		const action = climateHvacAction(s);
+		return action === "heating" || action === "cooling" ? s.watts : 0;
+	},
+	handles: [
+		"set_temperature",
+		"set_hvac_mode",
+		"set_fan_mode",
+		"set_preset_mode"
+	]
+};
+const waterHeater = {
+	entities(device) {
+		const p = device.params;
+		return [{
+			entityId: entityIdFor("water_heater", device, "water_heater"),
+			name: device.name,
+			supportedFeatures: p.supportedFeatures,
+			primary: true
+		}];
+	},
+	apply(state, event, device) {
+		const p = device.params;
+		const s = state ?? {
+			mode: p.modes[0] ?? "off",
+			targetTemp: round1$1(p.min + (p.max - p.min) * .5),
+			currentTemp: round1$1(p.min + (p.max - p.min) * .4),
+			awayMode: false
+		};
+		if (event.type !== "call") return s;
+		const data = event.data;
+		switch (event.service) {
+			case "set_temperature": return data.temperature != null ? {
+				...s,
+				targetTemp: Number(data.temperature)
+			} : s;
+			case "set_operation_mode": return typeof data.operation_mode === "string" ? {
+				...s,
+				mode: data.operation_mode
+			} : s;
+			case "set_away_mode": return data.away_mode != null ? {
+				...s,
+				awayMode: Boolean(data.away_mode)
+			} : s;
+			default: return s;
+		}
+	},
+	project(state, device) {
+		const s = state;
+		const p = device.params;
+		return { [entityIdFor("water_heater", device, "water_heater")]: {
+			state: s.mode,
+			attributes: {
+				temperature: round1$1(s.targetTemp),
+				current_temperature: round1$1(s.currentTemp),
+				operation_list: p.modes,
+				min_temp: p.min,
+				max_temp: p.max,
+				away_mode: s.awayMode ? "on" : "off",
+				...p.supportedFeatures != null ? { supported_features: p.supportedFeatures } : {}
+			}
+		} };
+	},
+	handles: [
+		"set_temperature",
+		"set_operation_mode",
+		"set_away_mode"
+	]
+};
+const MEDIA_DURATION_SEC = 180;
+const MEDIA_SUPPORTED_FEATURES = 152509;
+function skipMediaTrack(s, nowMs, trackCount, delta) {
+	return {
+		...s,
+		trackIndex: (s.trackIndex + delta + trackCount) % trackCount,
+		positionSec: 0,
+		positionUpdatedMs: nowMs
+	};
+}
+const ACTUATORS = {
+	light,
+	switch: switchKind,
+	fan,
+	cover,
+	lock,
+	climate,
+	water_heater: waterHeater,
+	media_player: {
+		entities(device) {
+			return [{
+				entityId: entityIdFor("media_player", device, "media_player"),
+				name: device.name,
+				supportedFeatures: MEDIA_SUPPORTED_FEATURES,
+				primary: true
+			}];
+		},
+		apply(state, event, device, ctx) {
+			const p = device.params;
+			const s = state ?? {
+				playing: false,
+				trackIndex: 0,
+				volume: .4,
+				muted: false,
+				source: p.sources?.[0],
+				positionSec: 0,
+				positionUpdatedMs: ctx.nowMs
+			};
+			if (event.type === "tick") {
+				if (!s.playing) return s;
+				const elapsedSec = s.positionSec + event.dtMs / 1e3;
+				const skipped = Math.floor(elapsedSec / MEDIA_DURATION_SEC);
+				const positionSec = elapsedSec - skipped * MEDIA_DURATION_SEC;
+				const trackIndex = (s.trackIndex + skipped) % p.tracks.length;
+				return {
+					...s,
+					positionSec,
+					trackIndex,
+					positionUpdatedMs: ctx.nowMs
+				};
+			}
+			if (event.type !== "call") return s;
+			const data = event.data;
+			switch (event.service) {
+				case "media_play_pause": return {
+					...s,
+					playing: !s.playing
+				};
+				case "media_play": return {
+					...s,
+					playing: true
+				};
+				case "media_pause": return {
+					...s,
+					playing: false
+				};
+				case "media_next_track": return skipMediaTrack(s, ctx.nowMs, p.tracks.length, 1);
+				case "media_previous_track": return skipMediaTrack(s, ctx.nowMs, p.tracks.length, -1);
+				case "volume_set": return data.volume_level != null ? {
+					...s,
+					volume: Number(data.volume_level)
+				} : s;
+				case "select_source": return typeof data.source === "string" ? {
+					...s,
+					source: data.source
+				} : s;
+				default: return s;
+			}
+		},
+		project(state, device) {
+			const s = state;
+			const p = device.params;
+			const id = entityIdFor("media_player", device, "media_player");
+			const track = p.tracks[s.trackIndex] ?? p.tracks[0];
+			const attributes = {
+				media_title: track?.title,
+				media_artist: track?.artist,
+				media_content_type: "music",
+				entity_picture: DEMO_ALBUM_COVER,
+				volume_level: s.volume,
+				is_volume_muted: s.muted,
+				media_duration: MEDIA_DURATION_SEC,
+				media_position: roundInt$1(s.positionSec),
+				media_position_updated_at: new Date(s.positionUpdatedMs).toISOString(),
+				supported_features: MEDIA_SUPPORTED_FEATURES
+			};
+			if (p.sources) {
+				attributes.source_list = p.sources;
+				attributes.source = s.source ?? p.sources[0];
+			}
+			return { [id]: {
+				state: s.playing ? "playing" : "paused",
+				attributes
+			} };
+		},
+		handles: [
+			"media_play_pause",
+			"media_play",
+			"media_pause",
+			"media_next_track",
+			"media_previous_track",
+			"volume_set",
+			"select_source"
+		]
+	},
+	button: {
+		entities(device) {
+			const p = device.params;
+			return [{
+				entityId: entityIdFor("button", device, "button"),
+				name: device.name,
+				category: p.category,
+				deviceClass: p.deviceClass,
+				primary: true
+			}];
+		},
+		apply(state, event, device, ctx) {
+			const s = state ?? {};
+			if (event.type !== "call" || event.service !== "press") return s;
+			return { lastPressedMs: ctx.nowMs };
+		},
+		project(state, device) {
+			const s = state;
+			const p = device.params;
+			const id = entityIdFor("button", device, "button");
+			const value = s.lastPressedMs != null ? new Date(s.lastPressedMs).toISOString() : "unknown";
+			return { [id]: {
+				state: value,
+				attributes: p.deviceClass ? { device_class: p.deviceClass } : {}
+			} };
+		},
+		handles: ["press"]
+	},
+	scene: {
+		entities(device) {
+			return [{
+				entityId: entityIdFor("scene", device, "scene"),
+				name: device.name,
+				primary: true
+			}];
+		},
+		apply(state, event, device, ctx) {
+			const s = state ?? {};
+			if (event.type !== "call" || event.service !== "turn_on") return s;
+			return { lastActivatedMs: ctx.nowMs };
+		},
+		project(state, device) {
+			const s = state;
+			const id = entityIdFor("scene", device, "scene");
+			const value = s.lastActivatedMs != null ? new Date(s.lastActivatedMs).toISOString() : "unknown";
+			return { [id]: {
+				state: value,
+				attributes: {}
+			} };
+		},
+		effects(state, event, device) {
+			if (event.type !== "call" || event.service !== "turn_on") return [];
+			return device.params.targets;
+		},
+		handles: ["turn_on"]
+	}
+};
+//#endregion
+//#region src/demo/assets.ts
+function demoAssetUrl(path) {
+	return globalThis.location ? new URL(path, globalThis.location.origin).href : path;
+}
+//#endregion
+//#region src/demo/kinds/readings.ts
+const round1 = (n) => Math.round(n * 10) / 10;
+const roundInt = (n) => Math.round(n);
+const round10 = (n) => Math.round(n / 10) * 10;
+/** Appliance power ids owned by appliance devices; energy_meter never owns them. */
+const APPLIANCE_ENERGY_IDS = [
+	"sensor.fridge_power",
+	"sensor.dishwasher_power",
+	"sensor.washing_machine_power",
+	"sensor.oven_power",
+	"sensor.ev_charger_power"
+];
+const SENSOR_UNIT = {
+	temperature: "°C",
+	outdoor_temperature: "°C",
+	humidity: "%",
+	illuminance: "lx",
+	battery: "%",
+	signal: "dBm",
+	fixed: void 0,
+	power: "W"
+};
+const SENSOR_DEVICE_CLASS = {
+	temperature: "temperature",
+	outdoor_temperature: "temperature",
+	humidity: "humidity",
+	illuminance: "illuminance",
+	battery: "battery",
+	signal: "signal_strength",
+	fixed: void 0,
+	power: "power"
+};
+function sensorUnit(p) {
+	return p.unit ?? SENSOR_UNIT[p.reading];
+}
+function sensorDeviceClass(p) {
+	return p.deviceClass ?? SENSOR_DEVICE_CLASS[p.reading];
+}
+function isLegacyEnergyId(id) {
+	return ENERGY_METER_ENTITY_IDS.includes(id) || APPLIANCE_ENERGY_IDS.includes(id);
+}
+function sensorValue(id, p, nowMs, noiseVal, outdoorC) {
+	switch (p.reading) {
+		case "temperature": return round1(20.5 + (outdoorC - 20.5) * .1 + (noiseVal - .5) * .4).toFixed(1);
+		case "outdoor_temperature": return round1(outdoorC).toFixed(1);
+		case "humidity": return roundInt(45 + (noiseVal - .5) * 30).toString();
+		case "illuminance": return roundInt(Math.max(0, 400 * noiseVal)).toString();
+		case "battery": return roundInt(35 + noiseVal * 65).toString();
+		case "signal": return roundInt(-85 + noiseVal * 40).toString();
+		case "power":
+			if (isLegacyEnergyId(id)) return formatEnergyState(id, energyEntityValue(id, simulateEnergy(nowMs)) ?? 0);
+			return round10(p.value ?? 0).toString();
+		default: return String(p.value ?? 0);
+	}
+}
+const sensor = {
+	entities(device) {
+		const p = device.params;
+		const seed = {
+			entityId: entityIdFor("sensor", device, "sensor"),
+			name: device.name,
+			unit: sensorUnit(p),
+			deviceClass: sensorDeviceClass(p),
+			primary: true
+		};
+		if (p.reading === "signal") seed.category = "diagnostic";
+		return [seed];
+	},
+	apply() {},
+	project(_state, device, ctx) {
+		const p = device.params;
+		const id = entityIdFor("sensor", device, "sensor");
+		const lt = localTime$1(ctx.nowMs, ctx.world.timeZone);
+		const noiseVal = ctx.noise(`${device.key}:${p.reading}:${lt.dateKey}`);
+		const outdoorC = outdoorTempC(ctx.nowMs, ctx.world);
+		const attributes = {};
+		const unit = sensorUnit(p);
+		const deviceClass = sensorDeviceClass(p);
+		if (unit) attributes.unit_of_measurement = unit;
+		if (deviceClass) attributes.device_class = deviceClass;
+		return { [id]: {
+			state: sensorValue(id, p, ctx.nowMs, noiseVal, outdoorC),
+			attributes
+		} };
+	},
+	publishMs: 3e4
+};
+const MOTION_AUTO_OFF_MS = 12e4;
+const binarySensor = {
+	entities(device) {
+		const p = device.params;
+		return [{
+			entityId: entityIdFor("binary_sensor", device, "binary_sensor"),
+			name: device.name,
+			deviceClass: p.deviceClass,
+			primary: true
+		}];
+	},
+	apply(state, event, device) {
+		const p = device.params;
+		const s = state ?? { on: p.initial ?? false };
+		if (event.type === "tick") {
+			if (s.autoOffRemainingMs == null) return s;
+			const remaining = s.autoOffRemainingMs - event.dtMs;
+			return remaining <= 0 ? { on: false } : {
+				...s,
+				autoOffRemainingMs: remaining
+			};
+		}
+		if (event.type !== "call" || event.service !== "demo_set") return s;
+		const on = Boolean(event.data.on);
+		return p.deviceClass === "motion" && on ? {
+			on: true,
+			autoOffRemainingMs: MOTION_AUTO_OFF_MS
+		} : { on };
+	},
+	project(state, device) {
+		const s = state;
+		const p = device.params;
+		return { [entityIdFor("binary_sensor", device, "binary_sensor")]: {
+			state: s.on ? "on" : "off",
+			attributes: { device_class: p.deviceClass }
+		} };
+	},
+	handles: ["demo_set"]
+};
+function sunCacheValid(state, nowMs, lat, lon, dateKey) {
+	return state != null && state.dateKey === dateKey && state.latKey === lat && state.lonKey === lon && nowMs < state.risingMs && nowMs < state.settingMs;
+}
+function sunTimesFor(state, nowMs, lat, lon, dateKey) {
+	if (sunCacheValid(state, nowMs, lat, lon, dateKey)) return state;
+	const { risingMs, settingMs } = sunTimes(nowMs, lat, lon);
+	return {
+		dateKey,
+		latKey: lat,
+		lonKey: lon,
+		risingMs,
+		settingMs
+	};
+}
+const sun = {
+	entities(device) {
+		return [{
+			entityId: entityIdFor("sun", device, "sun"),
+			name: "Sun",
+			primary: true
+		}];
+	},
+	apply(state, event, device, ctx) {
+		const lt = localTime$1(ctx.nowMs, ctx.world.timeZone);
+		return sunTimesFor(state, ctx.nowMs, ctx.world.latitude, ctx.world.longitude, lt.dateKey);
+	},
+	project(state, device, ctx) {
+		const s = state;
+		const id = entityIdFor("sun", device, "sun");
+		const elevation = solarElevation(ctx.nowMs, ctx.world.latitude, ctx.world.longitude);
+		return { [id]: {
+			state: elevation > -.833 ? "above_horizon" : "below_horizon",
+			attributes: {
+				elevation: round1(elevation),
+				next_rising: new Date(s.risingMs).toISOString(),
+				next_setting: new Date(s.settingMs).toISOString(),
+				rising: solarElevation(ctx.nowMs + 6e5, ctx.world.latitude, ctx.world.longitude) > elevation
+			}
+		} };
+	}
+};
+function weatherCondition(cloud, sunUp, noiseVal) {
+	if (cloud > .85) return noiseVal < .3 ? "rainy" : "cloudy";
+	if (cloud > .6) return "cloudy";
+	if (cloud > .3) return "partlycloudy";
+	return sunUp ? "sunny" : "clear-night";
+}
+function weatherForecastDay(nowMs, world, dayOffset, ctxNoise) {
+	const noonMs = localTime$1(nowMs, world.timeZone).midnightMs + dayOffset * 864e5 + 432e5;
+	const cloud = cloudCover(noonMs, world);
+	const sunUp = solarElevation(noonMs, world.latitude, world.longitude) > -.833;
+	const targetDateKey = localTime$1(noonMs, world.timeZone).dateKey;
+	const noiseVal = ctxNoise(`weather:condition:${targetDateKey}`);
+	return {
+		datetime: new Date(noonMs).toISOString(),
+		condition: weatherCondition(cloud, sunUp, noiseVal),
+		temperature: round1(outdoorTempC(noonMs, world)),
+		templow: round1(outdoorTempC(noonMs - 288e5, world))
+	};
+}
+function weatherForecastHourly(nowMs, world, hours = 24) {
+	const firstHourMs = Math.floor(nowMs / 36e5) * 36e5;
+	return Array.from({ length: hours }, (_, i) => {
+		const t = firstHourMs + i * 36e5;
+		const sunUp = solarElevation(t, world.latitude, world.longitude) > -.833;
+		const noiseVal = noise(world.seed, `weather:condition:${localTime$1(t, world.timeZone).dateKey}`);
+		return {
+			datetime: new Date(t).toISOString(),
+			condition: weatherCondition(cloudCover(t, world), sunUp, noiseVal),
+			temperature: round1(outdoorTempC(t, world))
+		};
+	});
+}
+const weather = {
+	entities(device) {
+		return [{
+			entityId: entityIdFor("weather", device, "weather"),
+			name: device.name,
+			primary: true
+		}];
+	},
+	apply() {},
+	project(_state, device, ctx) {
+		const id = entityIdFor("weather", device, "weather");
+		const cloud = cloudCover(ctx.nowMs, ctx.world);
+		const sunUp = solarElevation(ctx.nowMs, ctx.world.latitude, ctx.world.longitude) > -.833;
+		const dateKey = localTime$1(ctx.nowMs, ctx.world.timeZone).dateKey;
+		const noiseVal = ctx.noise(`weather:condition:${dateKey}`);
+		const forecast = Array.from({ length: 7 }, (_, i) => weatherForecastDay(ctx.nowMs, ctx.world, i, (key) => ctx.noise(key)));
+		return { [id]: {
+			state: weatherCondition(cloud, sunUp, noiseVal),
+			attributes: {
+				temperature: round1(outdoorTempC(ctx.nowMs, ctx.world)),
+				temperature_unit: "°C",
+				humidity: roundInt(40 + cloud * 30),
+				forecast
+			}
+		} };
+	},
+	publishMs: 3e4
+};
+/** One fixed fixture per weather scene the widget can showcase. */
+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 buildShowcaseForecast(w, midnightMs) {
+	const day = (n) => new Date(midnightMs + n * 864e5).toISOString();
+	return [
+		{
+			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
+		},
+		{
+			datetime: day(5),
+			condition: "cloudy",
+			temperature: w.temp - 1,
+			templow: w.low - 2
+		},
+		{
+			datetime: day(6),
+			condition: "partlycloudy",
+			temperature: w.temp + 1,
+			templow: w.low
+		}
+	];
+}
+const weatherShowcase = {
+	entities(device) {
+		return [{
+			entityId: entityIdFor("weather", device, "weather"),
+			name: device.name,
+			primary: true
+		}];
+	},
+	apply() {},
+	project(_state, device, ctx) {
+		const w = device.params;
+		return { [entityIdFor("weather", device, "weather")]: {
+			state: w.state,
+			attributes: {
+				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: buildShowcaseForecast(w, localTime$1(ctx.nowMs, ctx.world.timeZone).midnightMs)
+			}
+		} };
+	},
+	publishMs: 6e4
+};
+const ENERGY_METER_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.always_on_power"
+];
+const ENERGY_METER_META = {
+	"sensor.solar_power": {
+		name: "Solar Production",
+		deviceClass: "power",
+		unit: "W"
+	},
+	"sensor.grid_import_power": {
+		name: "Grid Import",
+		deviceClass: "power",
+		unit: "W"
+	},
+	"sensor.grid_export_power": {
+		name: "Grid Export",
+		deviceClass: "power",
+		unit: "W"
+	},
+	"sensor.battery_charge_power": {
+		name: "Battery Charge",
+		deviceClass: "power",
+		unit: "W"
+	},
+	"sensor.battery_discharge_power": {
+		name: "Battery Discharge",
+		deviceClass: "power",
+		unit: "W"
+	},
+	"sensor.battery_soc": {
+		name: "Battery",
+		deviceClass: "battery",
+		unit: "%"
+	},
+	"sensor.home_power": {
+		name: "Home Consumption",
+		deviceClass: "power",
+		unit: "W"
+	},
+	"sensor.always_on_power": {
+		name: "Always On",
+		deviceClass: "power",
+		unit: "W"
+	}
+};
+const energyMeter = {
+	entities() {
+		return ENERGY_METER_ENTITY_IDS.map((id) => {
+			const meta = ENERGY_METER_META[id];
+			return {
+				entityId: id,
+				name: meta.name,
+				deviceClass: meta.deviceClass,
+				unit: meta.unit,
+				primary: id === "sensor.home_power"
+			};
+		});
+	},
+	apply() {},
+	project(_state, _device, ctx) {
+		const sample = simulateEnergy(ctx.nowMs);
+		const out = {};
+		for (const id of ENERGY_METER_ENTITY_IDS) {
+			const meta = ENERGY_METER_META[id];
+			out[id] = {
+				state: formatEnergyState(id, energyEntityValue(id, sample) ?? 0),
+				attributes: {
+					unit_of_measurement: meta.unit,
+					device_class: meta.deviceClass,
+					state_class: "measurement"
+				}
+			};
+		}
+		return out;
+	},
+	publishMs: 5e3
+};
+const person = {
+	entities(device) {
+		return [{
+			entityId: entityIdFor("person", device, "person"),
+			name: device.name,
+			primary: true
+		}];
+	},
+	apply(state, event) {
+		const s = state ?? { home: true };
+		if (event.type !== "call" || event.service !== "demo_set") return s;
+		return event.data.home != null ? { home: Boolean(event.data.home) } : s;
+	},
+	project(state, device) {
+		const s = state;
+		return { [entityIdFor("person", device, "person")]: {
+			state: s.home ? "home" : "not_home",
+			attributes: {}
+		} };
+	},
+	handles: ["demo_set"]
+};
+function bumpMinor(version) {
+	const parts = version.split(".").map(Number);
+	const [major, minor, patch] = [
+		parts[0] ?? 1,
+		parts[1] ?? 0,
+		parts[2] ?? 0
+	];
+	return `${major}.${minor + 1}.${patch}`;
+}
+const READINGS = {
+	sensor,
+	binary_sensor: binarySensor,
+	sun,
+	weather,
+	weather_showcase: weatherShowcase,
+	energy_meter: energyMeter,
+	person,
+	update: {
+		entities(device) {
+			return [{
+				entityId: entityIdFor("update", device, "update", "firmware"),
+				name: `${device.name} Firmware`,
+				deviceClass: "firmware",
+				category: "diagnostic",
+				primary: true
+			}];
+		},
+		apply() {},
+		project(_state, device, ctx) {
+			const p = device.params;
+			const id = entityIdFor("update", device, "update", "firmware");
+			const installed = p.installedVersion ?? "1.0.0";
+			const available = ctx.noise(`${device.key}:update`) < 1 / 12;
+			const latest = available ? bumpMinor(installed) : installed;
+			return { [id]: {
+				state: available ? "on" : "off",
+				attributes: {
+					installed_version: installed,
+					latest_version: latest,
+					device_class: "firmware"
+				}
+			} };
+		}
+	},
+	camera: {
+		entities(device) {
+			return [{
+				entityId: entityIdFor("camera", device, "camera"),
+				name: device.name,
+				supportedFeatures: 2,
+				primary: true
+			}];
+		},
+		apply() {},
+		project(_state, device) {
+			return { [entityIdFor("camera", device, "camera")]: {
+				state: "streaming",
+				attributes: {
+					entity_picture: demoAssetUrl("/demo/camera/front-door.webp"),
+					frontend_stream_type: "hls",
+					access_token: "demo-token",
+					supported_features: 2
+				}
+			} };
+		}
+	}
+};
+//#endregion
+//#region src/demo/kinds/index.ts
+const KINDS = {
+	...ACTUATORS,
+	...READINGS
+};
+//#endregion
+//#region src/demo/house/builders.ts
+const PRIMARY_ROLE = {
+	light: "light",
+	switch: "switch",
+	fan: "fan",
+	cover: "cover",
+	lock: "lock",
+	climate: "climate",
+	water_heater: "water_heater",
+	media_player: "media_player",
+	button: "button",
+	scene: "scene",
+	sensor: "sensor",
+	binary_sensor: "binary_sensor",
+	sun: "sun",
+	weather: "weather",
+	weather_showcase: "weather",
+	energy_meter: "sensor",
+	person: "person",
+	update: "update",
+	camera: "camera"
+};
+const HUE = {
+	manufacturer: "Signify",
+	model: "Hue White Ambiance",
+	integration: "hue",
+	transport: "zigbee"
+};
+const SHELLY_RELAY = {
+	manufacturer: "Shelly",
+	model: "Plus 1PM",
+	integration: "shelly",
+	transport: "wifi"
+};
+const SHELLY_PLUG = {
+	manufacturer: "Shelly",
+	model: "Plus Plug S",
+	integration: "shelly",
+	transport: "wifi"
+};
+const ZIGBEE_BATTERY = {
+	integration: "zha",
+	transport: "zigbee",
+	battery: true
+};
+function slug(text) {
+	return text.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+function definedOnly(o) {
+	return Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0));
+}
+const DEFAULT_TRACKS = [
+	{
+		title: "Lo-fi Beats",
+		artist: "Chill Station"
+	},
+	{
+		title: "Sunday Morning",
+		artist: "Maroon Coast"
+	},
+	{
+		title: "Night Drive",
+		artist: "Neon Avenue"
+	}
+];
+function titleCase(text) {
+	return text.replace(/\b\w/g, (c) => c.toUpperCase());
+}
+/** Builders bound to one room (`null` for whole-house devices); keys are the name's slug, room-prefixed unless it already is. */
+function inRoom(roomId) {
+	const keyOf = (name, opts) => {
+		if (opts.key) return opts.key;
+		const own = slug(name);
+		return !roomId || own.startsWith(`${roomId}_`) ? own : `${roomId}_${own}`;
+	};
+	function make(kind, name, params, hw, opts = {}) {
+		const ids = {};
+		if (opts.id) ids[PRIMARY_ROLE[kind]] = opts.id;
+		if (opts.batteryId) ids.battery = opts.batteryId;
+		return {
+			key: keyOf(name, opts),
+			kind,
+			name,
+			areaId: roomId,
+			manufacturer: opts.manufacturer ?? hw.manufacturer,
+			model: opts.model ?? hw.model,
+			params: definedOnly({
+				...params,
+				integration: hw.integration,
+				transport: hw.transport,
+				battery: hw.battery
+			}),
+			...Object.keys(ids).length > 0 ? { ids } : {},
+			...opts.entityName ? { entityName: opts.entityName } : {},
+			...opts.deviceId ? { deviceId: opts.deviceId } : {}
+		};
+	}
+	return {
+		light: (name, opts = {}) => {
+			const model = opts.color ? "Hue White and Color Ambiance" : HUE.model;
+			const { dimmable = true, color, colorTemp, watts = 9, supportedFeatures } = opts;
+			return make("light", name, {
+				dimmable,
+				color,
+				colorTemp,
+				watts,
+				supportedFeatures
+			}, {
+				...HUE,
+				model
+			}, opts);
+		},
+		switchDevice: (name, opts = {}) => make("switch", name, {
+			watts: opts.watts ?? 0,
+			deviceClass: opts.deviceClass
+		}, SHELLY_RELAY, opts),
+		plug: (name, watts, opts = {}) => make("switch", name, {
+			watts,
+			power: true,
+			energy: true,
+			legacyPowerId: opts.legacyPowerId
+		}, SHELLY_PLUG, opts),
+		appliance: (name, watts, opts = {}) => make("switch", name, {
+			watts,
+			power: true,
+			legacyPowerId: opts.legacyPowerId
+		}, SHELLY_RELAY, opts),
+		fan: (name, opts = {}) => make("fan", name, {
+			presets: opts.presets,
+			oscillate: opts.oscillate,
+			direction: opts.direction,
+			watts: opts.watts ?? 40
+		}, {
+			manufacturer: "Dreo",
+			model: "Smart Fan",
+			integration: "demo",
+			transport: "wifi"
+		}, opts),
+		cover: (name, opts = {}) => make("cover", name, {
+			position: opts.position ?? true,
+			tilt: opts.tilt,
+			deviceClass: opts.deviceClass ?? "shade",
+			travelMs: opts.travelMs,
+			supportedFeatures: opts.supportedFeatures
+		}, {
+			manufacturer: "IKEA",
+			model: "Fyrtur",
+			integration: "zha",
+			transport: "zigbee"
+		}, opts),
+		lock: (name, opts = {}) => make("lock", name, {
+			supportedFeatures: opts.supportedFeatures,
+			unlocked: opts.unlocked
+		}, {
+			manufacturer: "Yale",
+			model: "Assure Lock 2",
+			...ZIGBEE_BATTERY
+		}, opts),
+		climate: (name, opts = {}) => make("climate", name, {
+			modes: opts.modes,
+			fanModes: opts.fanModes,
+			presets: opts.presets,
+			watts: opts.watts ?? 1500,
+			supportedFeatures: opts.supportedFeatures
+		}, {
+			manufacturer: "Google",
+			model: "Nest Learning Thermostat",
+			integration: "demo",
+			transport: "wifi"
+		}, opts),
+		waterHeater: (name, opts) => make("water_heater", name, {
+			modes: opts.modes,
+			min: opts.min,
+			max: opts.max,
+			supportedFeatures: opts.supportedFeatures
+		}, {
+			manufacturer: "Vaillant",
+			model: "uniSTOR",
+			integration: "demo",
+			transport: "wifi"
+		}, opts),
+		mediaPlayer: (name, opts = {}) => make("media_player", name, {
+			sources: opts.sources,
+			tracks: opts.tracks ?? DEFAULT_TRACKS
+		}, {
+			manufacturer: "Sonos",
+			model: "One",
+			integration: "demo",
+			transport: "wifi"
+		}, opts),
+		button: (name, opts = {}) => make("button", name, {
+			category: opts.category,
+			deviceClass: opts.deviceClass
+		}, {
+			manufacturer: "Home Assistant",
+			model: "Core",
+			integration: "demo"
+		}, opts),
+		scene: (name, targets, opts = {}) => make("scene", name, { targets }, {
+			manufacturer: "Home Assistant",
+			model: "Scene",
+			integration: "demo"
+		}, opts),
+		climateSensor: (name, opts = {}) => {
+			const base = keyOf(name, opts);
+			const hw = {
+				manufacturer: "Aqara",
+				model: "Temperature and Humidity Sensor",
+				...ZIGBEE_BATTERY
+			};
+			const reading = (role, entityName, id) => {
+				const value = role === "temperature" && opts.outdoor ? "outdoor_temperature" : role;
+				const own = {
+					...opts,
+					key: `${base}_${role}`,
+					id,
+					deviceId: base,
+					entityName
+				};
+				return make("sensor", name, { reading: value }, hw, own);
+			};
+			return [reading("temperature", "Temperature", opts.temperatureId), reading("humidity", "Humidity", opts.humidityId)];
+		},
+		motion: (name, opts = {}) => make("binary_sensor", name, {
+			deviceClass: "motion",
+			initial: opts.initial
+		}, {
+			manufacturer: "Aqara",
+			model: "Motion Sensor P1",
+			...ZIGBEE_BATTERY
+		}, opts),
+		contact: (deviceClass, name, opts = {}) => make("binary_sensor", name, {
+			deviceClass,
+			initial: opts.initial
+		}, {
+			manufacturer: "Aqara",
+			model: "Door and Window Sensor",
+			...ZIGBEE_BATTERY
+		}, opts),
+		smoke: (name, opts = {}) => make("binary_sensor", name, { deviceClass: "smoke" }, {
+			manufacturer: "Heiman",
+			model: "Smoke Sensor",
+			...ZIGBEE_BATTERY
+		}, opts),
+		leak: (name, opts = {}) => make("binary_sensor", name, { deviceClass: "moisture" }, {
+			manufacturer: "Aqara",
+			model: "Water Leak Sensor",
+			...ZIGBEE_BATTERY
+		}, opts),
+		camera: (name, opts = {}) => make("camera", name, {}, {
+			manufacturer: "Ring",
+			model: "Video Doorbell",
+			integration: "demo",
+			transport: "wifi"
+		}, opts),
+		fixedSensor: (name, opts) => make("sensor", name, {
+			reading: "fixed",
+			value: opts.value,
+			unit: opts.unit,
+			deviceClass: opts.deviceClass
+		}, {
+			manufacturer: "Home Assistant",
+			model: "Sensor",
+			integration: "demo"
+		}, opts),
+		sun: () => make("sun", "Sun", {}, {
+			manufacturer: "Home Assistant",
+			model: "Sun",
+			integration: "sun"
+		}),
+		weather: (name, opts = {}) => make("weather", name, {}, {
+			manufacturer: "Met.no",
+			model: "Forecast",
+			integration: "met"
+		}, opts),
+		weatherShowcase: (fixture) => make("weather_showcase", titleCase(`Demo ${fixture.slug.replace(/_/g, " ")}`), { ...fixture }, {
+			manufacturer: "Met.no",
+			model: "Forecast",
+			integration: "met"
+		}, { key: `demo_${fixture.slug}` }),
+		energyMeter: (name, opts = {}) => make("energy_meter", name, {}, {
+			manufacturer: "Shelly",
+			model: "Pro 3EM",
+			integration: "shelly",
+			transport: "wifi"
+		}, opts),
+		person: (name, opts) => make("person", name, { template: opts.template }, {
+			manufacturer: "Home Assistant",
+			model: "Person",
+			integration: "person"
+		}, opts),
+		phone: (name, opts = {}) => make("sensor", name, { reading: "battery" }, {
+			manufacturer: "Apple",
+			model: "iPhone",
+			integration: "demo"
+		}, {
+			...opts,
+			entityName: "Battery"
+		})
+	};
+}
+function room(id, name, floor, build) {
+	return {
+		id,
+		name,
+		floor,
+		devices: build(inRoom(id)).flat()
+	};
+}
+function wholeHouse(build) {
+	return build(inRoom(null)).flat();
+}
+//#endregion
+//#region src/demo/house/generate.ts
+const SIDE_NAME = {
+	signal: "Signal strength",
+	battery: "Battery",
+	firmware: "Firmware"
+};
+const registryIdOf = (d) => d.deviceId ?? d.key;
+function sideRoles(owner) {
+	const transport = owner.params.transport;
+	const roles = [];
+	if (transport === "zigbee" || transport === "wifi") roles.push("signal");
+	if (transport === "zigbee" && owner.params.battery) roles.push("battery");
+	if (transport === "wifi" || owner.kind === "light") roles.push("firmware");
+	return roles;
+}
+function sideSpec(owner, role) {
+	const deviceId = registryIdOf(owner);
+	const base = {
+		name: owner.name,
+		areaId: owner.areaId,
+		manufacturer: owner.manufacturer,
+		model: owner.model,
+		deviceId,
+		entityName: SIDE_NAME[role]
+	};
+	const integration = owner.params.integration;
+	switch (role) {
+		case "signal": return {
+			...base,
+			key: `${deviceId}_signal_strength`,
+			kind: "sensor",
+			params: {
+				reading: "signal",
+				integration
+			}
+		};
+		case "battery": {
+			const batteryId = owner.ids?.battery;
+			return {
+				...base,
+				key: `${deviceId}_battery`,
+				kind: "sensor",
+				params: {
+					reading: "battery",
+					integration
+				},
+				...batteryId ? { ids: { sensor: batteryId } } : {}
+			};
+		}
+		case "firmware": return {
+			...base,
+			key: `${deviceId}_firmware`,
+			kind: "update",
+			params: { integration },
+			ids: { update: `update.${deviceId}_firmware` }
+		};
+	}
+}
+function peopleSpecs(house) {
+	const b = inRoom(null);
+	return house.people.flatMap((p) => [b.person(p.name, {
+		key: `person_${p.id}`,
+		id: `person.${p.id}`,
+		template: p.template
+	}), b.phone(`${p.name}'s Phone`, {
+		key: `phone_${p.id}`,
+		id: `sensor.phone_${p.id}_battery`
+	})]);
+}
+function place(declared) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const d of declared) {
+		const id = registryIdOf(d);
+		groups.set(id, [...groups.get(id) ?? [], d]);
+	}
+	const placed = [];
+	for (const [deviceId, specs] of groups) {
+		const owner = specs[0];
+		if (!owner) continue;
+		for (const spec of specs) placed.push({
+			spec,
+			deviceId,
+			side: false,
+			seeds: KINDS[spec.kind].entities(spec)
+		});
+		for (const role of sideRoles(owner)) {
+			const spec = sideSpec(owner, role);
+			const category = role === "battery" && owner.ids?.battery ? void 0 : "diagnostic";
+			placed.push({
+				spec,
+				deviceId,
+				side: true,
+				seeds: KINDS[spec.kind].entities(spec),
+				category
+			});
+		}
+	}
+	return placed;
+}
+function resolveTarget(t, placed) {
+	const entityIds = t.entityIds ?? placed.filter((p) => !p.side && (t.area === void 0 || p.spec.areaId === t.area)).flatMap((p) => p.seeds.filter((s) => s.primary && s.entityId.startsWith(`${t.domain}.`)).map((s) => s.entityId));
+	return {
+		domain: t.domain,
+		service: t.service,
+		data: t.data ?? {},
+		entityIds
+	};
+}
+function resolveScenes(placed) {
+	return placed.map((p) => {
+		if (p.spec.kind !== "scene") return p;
+		const targets = p.spec.params.targets.map((t) => resolveTarget(t, placed));
+		return {
+			...p,
+			spec: {
+				...p.spec,
+				params: {
+					...p.spec.params,
+					targets
+				}
+			}
+		};
+	});
+}
+function assertUnique(label, values) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const v of values) {
+		if (seen.has(v)) throw new Error(`demo house: duplicate ${label} ${v}`);
+		seen.add(v);
+	}
+}
+function assertTargetsExist(placed, known) {
+	for (const p of placed) {
+		if (p.spec.kind !== "scene") continue;
+		for (const t of p.spec.params.targets) {
+			const missing = t.entityIds.find((id) => !known.has(id));
+			if (missing) throw new Error(`demo house: scene ${p.spec.key} targets unknown ${missing}`);
+		}
+	}
+}
+function toCategory(c) {
+	return c ?? null;
+}
+function entityEntry(p, seed, name, createdIso) {
+	const integration = p.spec.params.integration;
+	const platform = typeof integration === "string" ? integration : "demo";
+	return {
+		aliases: [],
+		area_id: null,
+		capabilities: null,
+		categories: {},
+		config_entry_id: `${platform}_entry`,
+		config_subentry_id: null,
+		created_at: createdIso,
+		device_class: seed.deviceClass ?? null,
+		device_id: p.deviceId,
+		disabled_by: null,
+		entity_category: toCategory(p.side ? p.category : seed.category),
+		entity_id: seed.entityId,
+		has_entity_name: true,
+		hidden_by: null,
+		icon: null,
+		id: `reg-${seed.entityId.replace(".", "-")}`,
+		labels: [],
+		modified_at: createdIso,
+		name,
+		options: {},
+		original_device_class: seed.deviceClass ?? null,
+		original_icon: null,
+		original_name: name,
+		platform,
+		previous_unique_id: null,
+		suggested_object_id: null,
+		supported_features: seed.supportedFeatures ?? 0,
+		translation_key: null,
+		unique_id: `demo_${seed.entityId.replace(".", "_")}`,
+		unit_of_measurement: seed.unit ?? null
+	};
+}
+function deviceEntry(owner, id, createdIso) {
+	const integration = owner.params.integration;
+	const platform = typeof integration === "string" ? integration : "demo";
+	const entry = `${platform}_entry`;
+	return {
+		id,
+		name: owner.name,
+		name_by_user: null,
+		manufacturer: owner.manufacturer,
+		model: owner.model,
+		model_id: null,
+		sw_version: "1.0.0",
+		hw_version: null,
+		area_id: owner.areaId,
+		config_entries: [entry],
+		config_entries_subentries: {},
+		configuration_url: null,
+		connections: [],
+		created_at: createdIso,
+		disabled_by: null,
+		entry_type: null,
+		identifiers: [[platform, id]],
+		labels: [],
+		modified_at: createdIso,
+		primary_config_entry: entry,
+		serial_number: null,
+		via_device_id: null
+	};
+}
+function areaEntry(room, placed, createdIso) {
+	const reading = (...readings) => placed.find((p) => !p.side && p.spec.areaId === room.id && p.spec.kind === "sensor" && readings.includes(String(p.spec.params.reading)))?.seeds[0]?.entityId ?? null;
+	return {
+		id: room.id,
+		name: room.name,
+		normalized_name: room.name.toLowerCase().replace(/\s+/g, "_"),
+		created_at: createdIso,
+		modified_at: createdIso,
+		aliases: [],
+		floor_id: room.floor,
+		humidity_entity_id: reading("humidity"),
+		icon: null,
+		labels: [],
+		picture: null,
+		temperature_entity_id: reading("temperature", "outdoor_temperature")
+	};
+}
+function generateHouse(house, createdIso) {
+	const placed = resolveScenes(place([
+		...house.rooms.flatMap((r) => r.devices),
+		...house.whole,
+		...peopleSpecs(house)
+	]));
+	assertUnique("device key", placed.map((p) => p.spec.key));
+	const entityIds = placed.flatMap((p) => p.seeds.map((s) => s.entityId));
+	assertUnique("entity id", entityIds);
+	assertTargetsExist(placed, new Set(entityIds));
+	const devices = {};
+	const entityRegistry = {};
+	const roomOf = {};
+	const friendlyNames = {};
+	for (const p of placed) {
+		const owner = devices[p.deviceId] ?? (devices[p.deviceId] = deviceEntry(p.spec, p.deviceId, createdIso));
+		for (const seed of p.seeds) {
+			const name = seed.primary ? p.spec.entityName ?? null : seed.name;
+			entityRegistry[seed.entityId] = entityEntry(p, seed, name, createdIso);
+			friendlyNames[seed.entityId] = name ? `${owner.name} ${name}` : owner.name ?? seed.entityId;
+			if (p.spec.areaId) roomOf[seed.entityId] = p.spec.areaId;
+		}
+	}
+	const areas = Object.fromEntries(house.rooms.map((r) => [r.id, areaEntry(r, placed, createdIso)]));
+	const floors = Object.fromEntries(house.floors.map((f) => [f.id, {
+		floor_id: f.id,
+		name: f.name,
+		level: f.level,
+		icon: null,
+		aliases: [],
+		created_at: createdIso,
+		modified_at: createdIso
+	}]));
+	return {
+		devices: placed.map((p) => p.spec),
+		registry: {
+			entityRegistry,
+			devices,
+			areas,
+			floors
+		},
+		entityIds,
+		roomOf,
+		friendlyNames
+	};
+}
+//#endregion
+//#region src/demo/house/house.ts
+const LIVING_LIGHTS = {
+	domain: "light",
+	service: "turn_on",
+	data: { brightness_pct: 20 },
+	area: "living_room"
+};
+const ALL_LIGHTS_OFF = {
+	domain: "light",
+	service: "turn_off"
+};
+const ALL_LOCKS_LOCKED = {
+	domain: "lock",
+	service: "lock"
+};
+const HOUSE = {
+	version: 1,
+	floors: [{
+		id: "ground",
+		name: "Ground floor",
+		level: 0
+	}, {
+		id: "upstairs",
+		name: "Upstairs",
+		level: 1
+	}],
+	rooms: [
+		room("living_room", "Living Room", "ground", (b) => [
+			b.light("Living Room Main", {
+				id: "light.living_room_main",
+				colorTemp: true,
+				watts: 40
+			}),
+			b.light("Studio RGB", {
+				id: "light.studio_rgb",
+				color: true,
+				colorTemp: true
+			}),
+			b.light("Floor Lamp", { colorTemp: true }),
+			b.light("Reading Lamp"),
+			b.light("Shelf Strip", { color: true }),
+			b.climate("Living Room Thermostat", {
+				id: "climate.living_room_thermostat",
+				supportedFeatures: 385
+			}),
+			b.climateSensor("Living Room Climate", {
+				temperatureId: "sensor.temperature_living",
+				humidityId: "sensor.humidity_living"
+			}),
+			b.cover("Living Room Blinds", {
+				id: "cover.living_room_blinds",
+				manufacturer: "Somfy",
+				model: "Roller Shade"
+			}),
+			b.cover("Living Room Shutters", {
+				id: "cover.living_room_shutters",
+				tilt: true,
+				deviceClass: "shutter",
+				manufacturer: "Somfy",
+				model: "Venetian Shutter"
+			}),
+			b.switchDevice("Living Room Fan", {
+				id: "switch.fan_living_room",
+				watts: 45,
+				deviceClass: "switch"
+			}),
+			b.mediaPlayer("Living Room Speaker", {
+				id: "media_player.living_room_speaker",
+				sources: [
+					"Spotify",
+					"AirPlay",
+					"TV"
+				]
+			}),
+			b.plug("TV", 120),
+			b.fan("Air Purifier", {
+				id: "fan.air_purifier",
+				presets: [
+					"auto",
+					"sleep",
+					"turbo"
+				],
+				oscillate: true,
+				manufacturer: "Xiaomi",
+				model: "Air Purifier 4"
+			}),
+			b.motion("Living Room Motion"),
+			b.contact("window", "Living Room Left Window"),
+			b.contact("window", "Living Room Right Window"),
+			b.scene("Movie Night", [
+				LIVING_LIGHTS,
+				{
+					domain: "cover",
+					service: "close_cover",
+					entityIds: ["cover.living_room_blinds"]
+				},
+				{
+					domain: "media_player",
+					service: "media_play",
+					entityIds: ["media_player.living_room_speaker"]
+				}
+			], { key: "movie_night" })
+		]),
+		room("kitchen", "Kitchen", "ground", (b) => [
+			b.light("Kitchen Counter", { id: "light.kitchen_counter" }),
+			b.light("Kitchen Pendant"),
+			b.light("Kitchen Spots"),
+			b.cover("Kitchen Blinds", {
+				id: "cover.kitchen_blinds",
+				deviceClass: "blind",
+				model: "Praktlysing",
+				supportedFeatures: 127
+			}),
+			b.switchDevice("Coffee Machine", {
+				id: "switch.coffee_machine",
+				watts: 1200,
+				deviceClass: "outlet"
+			}),
+			b.appliance("Dishwasher", 1800, { legacyPowerId: "sensor.dishwasher_power" }),
+			b.appliance("Oven", 2200, { legacyPowerId: "sensor.oven_power" }),
+			b.appliance("Fridge", 150, { legacyPowerId: "sensor.fridge_power" }),
+			b.plug("Kettle", 2e3),
+			b.climateSensor("Kitchen Climate"),
+			b.motion("Kitchen Motion"),
+			b.smoke("Kitchen Smoke"),
+			b.leak("Kitchen Leak")
+		]),
+		room("dining", "Dining Room", "ground", (b) => [
+			b.light("Dining Table"),
+			b.light("Sideboard", { dimmable: false }),
+			b.contact("window", "Dining Room Window"),
+			b.climateSensor("Dining Room Climate"),
+			b.scene("Dinner", [{
+				domain: "light",
+				service: "turn_on",
+				data: { brightness_pct: 60 },
+				entityIds: ["light.dining_table"]
+			}, {
+				domain: "light",
+				service: "turn_on",
+				data: { brightness_pct: 40 },
+				entityIds: ["light.kitchen_pendant"]
+			}], { key: "dinner" })
+		]),
+		room("entry", "Entry", "ground", (b) => [
+			b.light("Hallway", { id: "light.hallway" }),
+			b.lock("Front Door Lock", {
+				id: "lock.front_door_lock",
+				batteryId: "sensor.door_lock_battery",
+				supportedFeatures: 1
+			}),
+			b.contact("door", "Front Door", {
+				id: "binary_sensor.front_door",
+				batteryId: "sensor.battery_door_sensor"
+			}),
+			b.motion("Hallway Motion", {
+				id: "binary_sensor.motion_hallway",
+				batteryId: "sensor.motion_sensor_battery"
+			}),
+			b.camera("Front Door Camera", { id: "camera.front_door_camera" })
+		]),
+		room("utility", "Utility", "ground", (b) => [
+			b.appliance("Washing Machine", 2e3, { legacyPowerId: "sensor.washing_machine_power" }),
+			b.appliance("Dryer", 2500),
+			b.waterHeater("Boiler", {
+				id: "water_heater.boiler",
+				modes: [
+					"off",
+					"eco",
+					"performance"
+				],
+				min: 43,
+				max: 60,
+				supportedFeatures: 7
+			}),
+			b.waterHeater("Heat Pump Tank", {
+				id: "water_heater.heat_pump_tank",
+				modes: [
+					"off",
+					"eco",
+					"heat_pump",
+					"high_demand"
+				],
+				min: 43,
+				max: 60,
+				supportedFeatures: 3
+			}),
+			b.leak("Utility Leak"),
+			b.light("Utility Ceiling", { dimmable: false })
+		]),
+		room("garage", "Garage", "ground", (b) => [
+			b.cover("Garage Door", {
+				id: "cover.garage_door",
+				position: false,
+				deviceClass: "garage",
+				manufacturer: "Chamberlain",
+				model: "MyQ"
+			}),
+			b.cover("Driveway Gate", {
+				id: "cover.driveway_gate",
+				position: false,
+				deviceClass: "gate",
+				manufacturer: "Nice",
+				model: "Robus",
+				supportedFeatures: 3
+			}),
+			b.lock("Back Door Lock", {
+				id: "lock.back_door_lock",
+				manufacturer: "August",
+				model: "Smart Lock Pro",
+				supportedFeatures: 1
+			}),
+			b.plug("EV Charger", 7200, {
+				legacyPowerId: "sensor.ev_charger_power",
+				manufacturer: "Wallbox",
+				model: "Pulsar Plus"
+			}),
+			b.light("Garage Ceiling", { dimmable: false }),
+			b.motion("Garage Motion")
+		]),
+		room("office", "Office", "ground", (b) => [
+			b.light("Office Ceiling"),
+			b.light("Desk Lamp", { colorTemp: true }),
+			b.plug("Monitor", 35),
+			b.plug("Printer", 15),
+			b.climateSensor("Office Climate"),
+			b.climate("Office Heat Pump", {
+				modes: [
+					"off",
+					"heat",
+					"cool",
+					"auto"
+				],
+				fanModes: [
+					"auto",
+					"low",
+					"medium",
+					"high"
+				],
+				presets: [
+					"home",
+					"away",
+					"eco"
+				],
+				manufacturer: "Mitsubishi",
+				model: "Wall Split"
+			}),
+			b.contact("window", "Office Window"),
+			b.cover("Office Blinds")
+		]),
+		room("bedroom", "Bedroom", "upstairs", (b) => [
+			b.light("Bedroom Ceiling", {
+				id: "light.bedroom_ceiling",
+				colorTemp: true
+			}),
+			b.light("Desk RGB", {
+				id: "light.desk_rgb",
+				color: true,
+				colorTemp: true
+			}),
+			b.light("Bedroom Bedside Left"),
+			b.light("Bedroom Bedside Right"),
+			b.climate("Bedroom AC", {
+				id: "climate.bedroom_ac",
+				modes: [
+					"off",
+					"cool",
+					"heat",
+					"dry",
+					"fan_only"
+				],
+				manufacturer: "Daikin",
+				model: "Split AC",
+				supportedFeatures: 385
+			}),
+			b.fan("Bedroom Ceiling Fan", {
+				id: "fan.bedroom_ceiling",
+				direction: true
+			}),
+			b.cover("Bedroom Curtains", {
+				id: "cover.bedroom_curtains",
+				deviceClass: "curtain"
+			}),
+			b.contact("window", "Bedroom Window", { id: "binary_sensor.window_bedroom" }),
+			b.climateSensor("Bedroom Climate"),
+			b.motion("Bedroom Motion")
+		]),
+		room("bathroom", "Bathroom", "upstairs", (b) => [
+			b.light("Bathroom Ceiling", {
+				id: "light.bathroom",
+				supportedFeatures: 0
+			}),
+			b.light("Bathroom Mirror"),
+			b.fan("Bathroom Extractor", { watts: 20 }),
+			b.climateSensor("Bathroom Climate"),
+			b.leak("Bathroom Leak"),
+			b.contact("window", "Bathroom Window")
+		]),
+		room("kids_room", "Kids Room", "upstairs", (b) => [
+			b.light("Kids Room Ceiling"),
+			b.light("Night Light", { color: true }),
+			b.cover("Kids Room Blinds"),
+			b.climateSensor("Kids Room Climate"),
+			b.contact("window", "Kids Room Window"),
+			b.motion("Kids Room Motion")
+		]),
+		room("guest_room", "Guest Room", "upstairs", (b) => [
+			b.light("Guest Room Ceiling"),
+			b.light("Guest Room Bedside"),
+			b.climateSensor("Guest Room Climate"),
+			b.contact("window", "Guest Room Window")
+		]),
+		room("landing", "Landing", "upstairs", (b) => [
+			b.light("Landing Ceiling"),
+			b.motion("Landing Motion"),
+			b.smoke("Landing Smoke")
+		]),
+		room("garden", "Garden", "ground", (b) => [
+			b.light("Path Lights", { dimmable: false }),
+			b.light("Terrace"),
+			b.switchDevice("Irrigation", { watts: 10 }),
+			b.plug("Pond Pump", 60),
+			b.climateSensor("Weather Station", {
+				temperatureId: "sensor.temperature_outdoor",
+				outdoor: true
+			}),
+			b.motion("Garden Motion"),
+			b.contact("door", "Garden Gate")
+		])
+	],
+	people: [
+		{
+			id: "alex",
+			name: "Alex",
+			template: "commuter"
+		},
+		{
+			id: "sam",
+			name: "Sam",
+			template: "home_office"
+		},
+		{
+			id: "robin",
+			name: "Robin",
+			template: "student"
+		}
+	],
+	whole: wholeHouse((b) => [
+		b.sun(),
+		b.weather("Home"),
+		b.energyMeter("Home", {
+			key: "energy_meter",
+			entityName: "Consumption"
+		}),
+		b.fixedSensor("Power Consumption", {
+			value: 1.2,
+			unit: "kW",
+			deviceClass: "power"
+		}),
+		b.fixedSensor("Electricity Maps", {
+			id: "sensor.electricity_maps_co2_intensity",
+			entityName: "CO2 intensity",
+			value: 214,
+			unit: "gCO2eq/kWh"
+		}),
+		b.fixedSensor("Electricity Maps", {
+			key: "electricity_maps_fossil_fuel_percentage",
+			deviceId: "electricity_maps",
+			entityName: "Fossil fuel percentage",
+			value: 31,
+			unit: "%"
+		}),
+		b.fixedSensor("Nordpool", {
+			id: "sensor.nordpool_current_price",
+			entityName: "Current price",
+			value: .18,
+			unit: "EUR/kWh"
+		}),
+		...["de", "pl"].flatMap((zone, i) => [b.fixedSensor("Electricity Maps", {
+			key: `electricity_maps_${zone}`,
+			id: `sensor.electricity_maps_co2_intensity_${zone}`,
+			entityName: "CO2 intensity",
+			value: [384, 692][i] ?? 0,
+			unit: "gCO2eq/kWh"
+		}), b.fixedSensor("Electricity Maps", {
+			key: `electricity_maps_fossil_fuel_percentage_${zone}`,
+			deviceId: `electricity_maps_${zone}`,
+			entityName: "Fossil fuel percentage",
+			value: [52, 81][i] ?? 0,
+			unit: "%"
+		})]),
+		b.lock("Side Gate", {
+			id: "lock.side_gate",
+			unlocked: true,
+			supportedFeatures: 1
+		}),
+		b.contact("door", "Patio Door", {
+			id: "binary_sensor.patio_door",
+			initial: true
+		}),
+		b.motion("Pantry Motion", {
+			id: "binary_sensor.motion_kitchen",
+			initial: true
+		}),
+		b.button("Restart Home Assistant", {
+			category: "config",
+			deviceClass: "restart"
+		}),
+		b.button("Update Firmware", {
+			category: "config",
+			deviceClass: "update"
+		}),
+		b.scene("Good Morning", [
+			{
+				domain: "cover",
+				service: "open_cover",
+				entityIds: ["cover.bedroom_curtains"]
+			},
+			{
+				domain: "light",
+				service: "turn_on",
+				entityIds: ["light.kitchen_counter"]
+			},
+			{
+				domain: "switch",
+				service: "turn_on",
+				entityIds: ["switch.coffee_machine"]
+			}
+		]),
+		b.scene("Good Night", [
+			ALL_LIGHTS_OFF,
+			ALL_LOCKS_LOCKED,
+			{
+				domain: "cover",
+				service: "close_cover"
+			}
+		]),
+		b.scene("Away", [ALL_LIGHTS_OFF, ALL_LOCKS_LOCKED]),
+		...WEATHER_FIXTURES.map((w) => b.weatherShowcase(w))
+	])
+};
+//#endregion
+//#region src/demo/sim/log.ts
+const PREFIX = "glasshome.demo.log.v";
+const MAX_AGE_MS = 864e5;
+function logKey(houseVersion) {
+	return `${PREFIX}${houseVersion}`;
+}
+function isServiceCall(v) {
+	if (typeof v !== "object" || v === null) return false;
+	const c = v;
+	return typeof c.domain === "string" && typeof c.service === "string" && typeof c.data === "object" && c.data !== null && Array.isArray(c.entityIds) && c.entityIds.every((id) => typeof id === "string");
+}
+function isLoggedCall(v) {
+	if (typeof v !== "object" || v === null) return false;
+	const c = v;
+	return typeof c.simMs === "number" && isServiceCall(c.call);
+}
+function pruneLog(entries, nowMs) {
+	const cutoff = nowMs - MAX_AGE_MS;
+	return entries.filter((e) => e.simMs >= cutoff).sort((a, b) => a.simMs - b.simMs).slice(-500);
+}
+function removeOtherVersions(storage, keep) {
+	const stale = [];
+	for (let i = 0; i < storage.length; i++) {
+		const key = storage.key(i);
+		if (key && key.startsWith(PREFIX) && key !== keep) stale.push(key);
+	}
+	for (const key of stale) storage.removeItem(key);
+}
+function readLog(storage, houseVersion, nowMs) {
+	if (!storage) return [];
+	const key = logKey(houseVersion);
+	try {
+		removeOtherVersions(storage, key);
+	} catch {}
+	try {
+		const raw = storage.getItem(key);
+		if (!raw) return [];
+		const parsed = JSON.parse(raw);
+		if (!Array.isArray(parsed)) return [];
+		return pruneLog(parsed.filter(isLoggedCall), nowMs);
+	} catch {
+		return [];
+	}
+}
+function appendLog(storage, houseVersion, entry, nowMs) {
+	if (!storage) return;
+	const key = logKey(houseVersion);
+	let existing = [];
+	try {
+		const raw = storage.getItem(key);
+		if (raw) {
+			const parsed = JSON.parse(raw);
+			if (Array.isArray(parsed)) existing = parsed.filter(isLoggedCall);
+		}
+	} catch {
+		existing = [];
+	}
+	try {
+		storage.setItem(key, JSON.stringify(pruneLog([...existing, entry], nowMs)));
+	} catch {}
+}
+function clearLog(storage, houseVersion) {
+	if (!storage) return;
+	try {
+		storage.removeItem(logKey(houseVersion));
+	} catch {}
+}
+//#endregion
+//#region src/demo/sim/model.ts
+const MAX_EFFECT_DEPTH = 4;
+function createDemoModel(devices, kinds, opts) {
+	const stepMs = opts.stepMs ?? 1e3;
+	const log = opts.log ?? (() => {});
+	let nowMs = opts.startMs;
+	const ctx = () => ({
+		nowMs,
+		world: opts.world,
+		noise: (k) => noise(opts.world.seed, k)
+	});
+	const byKey = new Map(devices.map((d) => [d.key, d]));
+	const byEntity = /* @__PURE__ */ new Map();
+	const states = /* @__PURE__ */ new Map();
+	const holds = /* @__PURE__ */ new Map();
+	let queue = [];
+	let queueSeq = 0;
+	const driver = opts.driver?.();
+	for (const d of devices) {
+		for (const seed of kinds[d.kind].entities(d)) byEntity.set(seed.entityId, d);
+		states.set(d.key, kinds[d.kind].apply(void 0, { type: "init" }, d, ctx()));
+	}
+	function applyTo(d, event, depth) {
+		const kind = kinds[d.kind];
+		const next = kind.apply(states.get(d.key), event, d, ctx());
+		states.set(d.key, next);
+		if (depth >= MAX_EFFECT_DEPTH || !kind.effects) return;
+		for (const call of kind.effects(next, event, d)) dispatchAt(call, depth + 1);
+	}
+	function dispatchAt(call, depth) {
+		let handled = 0;
+		for (const entityId of call.entityIds) {
+			const d = byEntity.get(entityId);
+			const kind = d ? kinds[d.kind] : void 0;
+			if (!d || !kind || kind.handles && !kind.handles.includes(call.service)) {
+				log(`demo: unmocked ${call.domain}.${call.service} on ${entityId}`);
+				continue;
+			}
+			applyTo(d, {
+				type: "call",
+				entityId,
+				service: call.service,
+				data: call.data
+			}, depth);
+			handled++;
+		}
+		return handled;
+	}
+	function flushDue() {
+		if (queue.length === 0 || (queue[0]?.atMs ?? Infinity) > nowMs) return;
+		const due = queue.filter((q) => q.atMs <= nowMs);
+		queue = queue.filter((q) => q.atMs > nowMs);
+		for (const { call } of due) {
+			const entityIds = call.entityIds.filter((id) => !holds.has(id));
+			if (entityIds.length > 0) dispatchAt({
+				...call,
+				entityIds
+			}, 0);
+		}
+	}
+	const model = {
+		get nowMs() {
+			return nowMs;
+		},
+		dispatch: (call) => dispatchAt(call, 0),
+		advanceTo(ms, step = stepMs) {
+			while (nowMs < ms) {
+				const nextEvent = Math.min(queue[0]?.atMs ?? Infinity, driver?.nextAtMs() ?? Infinity);
+				const dtMs = Math.min(step, ms - nowMs, Math.max(1, nextEvent - nowMs));
+				const prev = nowMs;
+				nowMs += dtMs;
+				for (const d of devices) applyTo(d, {
+					type: "tick",
+					dtMs
+				}, MAX_EFFECT_DEPTH);
+				flushDue();
+				driver?.step(model, prev, nowMs);
+				flushDue();
+			}
+		},
+		project() {
+			const out = {};
+			for (const d of devices) Object.assign(out, kinds[d.kind].project(states.get(d.key), d, ctx()));
+			return out;
+		},
+		projectDevice(key) {
+			const d = byKey.get(key);
+			return d ? kinds[d.kind].project(states.get(d.key), d, ctx()) : {};
+		},
+		deviceOf: (entityId) => byEntity.get(entityId),
+		hold: (entityId, until) => void holds.set(entityId, until),
+		isHeld: (entityId) => holds.has(entityId),
+		clearHolds(kind) {
+			for (const [id, until] of holds) if (until === kind) holds.delete(id);
+		},
+		schedule(atMs, call) {
+			queue.push({
+				atMs,
+				seq: queueSeq++,
+				call
+			});
+			queue.sort((a, b) => a.atMs - b.atMs || a.seq - b.seq);
+		}
+	};
+	driver?.settle(model);
+	return model;
+}
+//#endregion
+//#region src/demo/sim/schedule.ts
+const at = (startMin, activity, room) => ({
+	startMin,
+	activity,
+	room
+});
+const ADULT_WEEKEND = [
+	at(0, "sleep", "bedroom"),
+	at(510, "wake", "bathroom"),
+	at(540, "cook", "kitchen"),
+	at(600, "relax", "living_room"),
+	at(780, "away", null),
+	at(1020, "relax", "garden"),
+	at(1140, "cook", "kitchen"),
+	at(1200, "eat", "dining"),
+	at(1260, "relax", "living_room"),
+	at(1410, "sleep", "bedroom")
+];
+const TEMPLATES = {
+	commuter: {
+		weekday: [
+			at(0, "sleep", "bedroom"),
+			at(390, "wake", "bathroom"),
+			at(410, "eat", "kitchen"),
+			at(460, "away", null),
+			at(1050, "relax", "living_room"),
+			at(1110, "cook", "kitchen"),
+			at(1170, "eat", "dining"),
+			at(1230, "relax", "living_room"),
+			at(1350, "bath", "bathroom"),
+			at(1380, "sleep", "bedroom")
+		],
+		weekend: ADULT_WEEKEND
+	},
+	home_office: {
+		weekday: [
+			at(0, "sleep", "bedroom"),
+			at(420, "wake", "bathroom"),
+			at(450, "eat", "kitchen"),
+			at(480, "work", "office"),
+			at(750, "cook", "kitchen"),
+			at(800, "work", "office"),
+			at(1080, "relax", "living_room"),
+			at(1170, "eat", "dining"),
+			at(1230, "relax", "living_room"),
+			at(1380, "sleep", "bedroom")
+		],
+		weekend: ADULT_WEEKEND
+	},
+	student: {
+		weekday: [
+			at(0, "sleep", "kids_room"),
+			at(420, "wake", "bathroom"),
+			at(440, "eat", "kitchen"),
+			at(470, "away", null),
+			at(960, "relax", "kids_room"),
+			at(1170, "eat", "dining"),
+			at(1230, "relax", "kids_room"),
+			at(1320, "sleep", "kids_room")
+		],
+		weekend: [
+			at(0, "sleep", "kids_room"),
+			at(570, "wake", "bathroom"),
+			at(600, "relax", "kids_room"),
+			at(840, "away", null),
+			at(1080, "relax", "living_room"),
+			at(1200, "eat", "dining"),
+			at(1260, "relax", "kids_room"),
+			at(1380, "sleep", "kids_room")
+		]
+	}
+};
+const SHIFT_SPAN_MIN = 40;
+const MINUTE_MS = 6e4;
+const DAY_AHEAD_MS = 1296e5;
+const LIGHTS_BELOW_ELEVATION = 6;
+const RELOCK_AFTER_MS = 2 * MINUTE_MS;
+function dayPlan(person, dateKey, weekday, seed) {
+	const template = TEMPLATES[person.template];
+	const base = weekday === 0 || weekday === 6 ? template.weekend : template.weekday;
+	let previous = -1;
+	return base.map((slot, i) => {
+		const shifted = slot.startMin + Math.round((noise(seed, person.id + dateKey + i) - .5) * SHIFT_SPAN_MIN);
+		const startMin = Math.max(shifted, previous + 1);
+		previous = startMin;
+		return {
+			...slot,
+			startMin
+		};
+	});
+}
+function dayOf(person, ms, world) {
+	const lt = localTime$1(ms, world.timeZone);
+	return {
+		midnightMs: lt.midnightMs,
+		plan: dayPlan(person, lt.dateKey, lt.weekday, world.seed)
+	};
+}
+function lastSlot(plan) {
+	const last = plan[plan.length - 1];
+	if (!last) throw new Error("demo schedule: empty day plan");
+	return last;
+}
+function occupancyAt(person, ms, world) {
+	const today = dayOf(person, ms, world);
+	const minute = (ms - today.midnightMs) / MINUTE_MS;
+	let current;
+	for (let i = today.plan.length - 1; i >= 0; i--) {
+		const slot = today.plan[i];
+		if (slot && slot.startMin <= minute) {
+			current = slot;
+			break;
+		}
+	}
+	if (current) return {
+		slot: current,
+		startMs: today.midnightMs + current.startMin * MINUTE_MS
+	};
+	const yesterday = dayOf(person, today.midnightMs - 1, world);
+	const last = lastSlot(yesterday.plan);
+	return {
+		slot: last,
+		startMs: yesterday.midnightMs + last.startMin * MINUTE_MS
+	};
+}
+function transitionsOf(person, day, world) {
+	let from = lastSlot(dayOf(person, day.midnightMs - 1, world).plan);
+	const out = [];
+	for (const to of day.plan) {
+		if (to.activity !== from.activity || to.room !== from.room) out.push({
+			atMs: day.midnightMs + to.startMin * MINUTE_MS,
+			person,
+			from,
+			to
+		});
+		from = to;
+	}
+	return out;
+}
+const OVEN = "switch.kitchen_oven";
+const COFFEE_MACHINE = "switch.coffee_machine";
+const FRONT_DOOR = "lock.front_door_lock";
+const GOOD_NIGHT = "scene.good_night";
+const AWAY = "scene.away";
+const ACTIONS = {
+	sleep: { lights: "none" },
+	wake: {
+		lights: "first",
+		appliance: {
+			id: COFFEE_MACHINE,
+			minutes: 10,
+			templates: ["commuter", "home_office"]
+		}
+	},
+	cook: {
+		lights: "all",
+		appliance: {
+			id: OVEN,
+			minutes: 40
+		}
+	},
+	eat: { lights: "all" },
+	work: { lights: "all" },
+	away: { lights: "none" },
+	relax: { lights: "first" },
+	bath: { lights: "all" }
+};
+const PICK_LIGHTS = {
+	none: () => [],
+	first: (lights) => lights.slice(0, 1),
+	all: (lights) => lights
+};
+function primaryId(d) {
+	return KINDS[d.kind].entities(d).find((e) => e.primary)?.entityId;
+}
+function gearByRoom(generated) {
+	const rooms = /* @__PURE__ */ new Map();
+	for (const d of generated.devices) {
+		const id = primaryId(d);
+		if (!d.areaId || !id) continue;
+		const gear = rooms.get(d.areaId) ?? {
+			lights: [],
+			motion: [],
+			covers: []
+		};
+		rooms.set(d.areaId, gear);
+		if (d.kind === "light" && d.params.scheduled !== false) gear.lights.push(id);
+		if (d.kind === "binary_sensor" && d.params.deviceClass === "motion") gear.motion.push(id);
+		if (d.kind === "cover") gear.covers.push(id);
+	}
+	return rooms;
+}
+const call = (domain, service, entityIds, data = {}) => ({
+	domain,
+	service,
+	data,
+	entityIds
+});
+const isAwakeAtHome = (s) => s.activity !== "sleep" && s.activity !== "away";
+const touchesEvent = (t) => [t.from.activity, t.to.activity].some((a) => a === "away" || a === "sleep");
+function createDriver(house, generated, world) {
+	const people = [...house.people].sort((a, b) => a.id.localeCompare(b.id));
+	const rooms = gearByRoom(generated);
+	const known = new Set(generated.entityIds);
+	const where = /* @__PURE__ */ new Map();
+	const pending = /* @__PURE__ */ new Map();
+	const nextDayAnchor = /* @__PURE__ */ new Map();
+	const runEnds = /* @__PURE__ */ new Map();
+	const gear = (room) => room ? rooms.get(room) : void 0;
+	function issue(model, c) {
+		const entityIds = c.entityIds.filter((id) => known.has(id) && !model.isHeld(id));
+		if (entityIds.length > 0) model.dispatch({
+			...c,
+			entityIds
+		});
+	}
+	function later(model, atMs, c) {
+		const entityIds = c.entityIds.filter((id) => known.has(id));
+		if (entityIds.length > 0) model.schedule(atMs, {
+			...c,
+			entityIds
+		});
+	}
+	const occupants = (room, except) => [...where].some(([id, s]) => id !== except && s.room === room);
+	const nobodyHome = (slots) => [...slots].every((s) => s.activity === "away");
+	const nobodyAwake = (slots) => ![...slots].some(isAwakeAtHome);
+	function runAppliance(model, person, to, startMs, nowMs) {
+		const appliance = ACTIONS[to.activity].appliance;
+		if (!appliance || appliance.templates && !appliance.templates.includes(person.template)) return;
+		const endMs = startMs + appliance.minutes * MINUTE_MS;
+		if (endMs <= nowMs || !known.has(appliance.id)) return;
+		issue(model, call("switch", "turn_on", [appliance.id]));
+		runEnds.set(appliance.id, Math.max(runEnds.get(appliance.id) ?? 0, endMs));
+	}
+	function enter(model, person, to, atMs) {
+		const room = gear(to.room);
+		if (room) {
+			issue(model, call("binary_sensor", "demo_set", room.motion, { on: true }));
+			if (solarElevation(atMs, world.latitude, world.longitude) < LIGHTS_BELOW_ELEVATION) issue(model, call("light", "turn_on", PICK_LIGHTS[ACTIONS[to.activity].lights](room.lights)));
+		}
+		issue(model, call("person", "demo_set", [`person.${person.id}`], { home: to.activity !== "away" }));
+	}
+	function household(model, t, before) {
+		const intoAway = t.to.activity === "away" && t.from.activity !== "away";
+		const backFromAway = t.from.activity === "away" && t.to.activity !== "away";
+		if (intoAway && nobodyHome(where.values())) issue(model, call("scene", "turn_on", [AWAY]));
+		if (backFromAway && nobodyHome(before.values())) {
+			issue(model, call("lock", "unlock", [FRONT_DOOR]));
+			later(model, t.atMs + RELOCK_AFTER_MS, call("lock", "lock", [FRONT_DOOR]));
+		}
+		if (t.to.activity === "sleep" && t.from.activity !== "sleep" && nobodyAwake(where.values())) issue(model, call("scene", "turn_on", [GOOD_NIGHT]));
+		if (t.to.activity === "wake" && t.from.activity === "sleep" && nobodyAwake(before.values()) && solarElevation(t.atMs, world.latitude, world.longitude) > 0) issue(model, call("cover", "open_cover", gear(t.from.room)?.covers ?? []));
+	}
+	function apply(model, t) {
+		const before = new Map(where);
+		where.set(t.person.id, t.to);
+		model.clearHolds("boundary");
+		if (touchesEvent(t)) model.clearHolds("event");
+		const left = t.from.room;
+		if (left && left !== t.to.room && !occupants(left, t.person.id)) issue(model, call("light", "turn_off", gear(left)?.lights ?? []));
+		enter(model, t.person, t.to, t.atMs);
+		runAppliance(model, t.person, t.to, t.atMs, t.atMs);
+		household(model, t, before);
+	}
+	function track(person, fromMs) {
+		const today = dayOf(person, fromMs, world);
+		pending.set(person.id, transitionsOf(person, today, world).filter((t) => t.atMs > fromMs));
+		nextDayAnchor.set(person.id, today.midnightMs + DAY_AHEAD_MS);
+	}
+	function upcoming(person) {
+		const queue = pending.get(person.id) ?? [];
+		pending.set(person.id, queue);
+		while (queue.length === 0) {
+			const next = dayOf(person, nextDayAnchor.get(person.id) ?? 0, world);
+			queue.push(...transitionsOf(person, next, world));
+			nextDayAnchor.set(person.id, next.midnightMs + DAY_AHEAD_MS);
+		}
+		return queue;
+	}
+	function dueBy(toMs) {
+		const due = [];
+		for (const [id, endMs] of runEnds) {
+			if (endMs > toMs) continue;
+			runEnds.delete(id);
+			due.push({
+				atMs: endMs,
+				order: 0,
+				key: id,
+				run: (m) => issue(m, call("switch", "turn_off", [id]))
+			});
+		}
+		for (const person of people) {
+			const queue = upcoming(person);
+			while ((queue[0]?.atMs ?? Infinity) <= toMs) {
+				const t = queue.shift();
+				if (t) due.push({
+					atMs: t.atMs,
+					order: 1,
+					key: person.id,
+					run: (m) => apply(m, t)
+				});
+				upcoming(person);
+			}
+		}
+		return due.sort((a, b) => a.atMs - b.atMs || a.order - b.order || a.key.localeCompare(b.key));
+	}
+	return {
+		settle(model) {
+			const now = model.nowMs;
+			const at = new Map(people.map((p) => [p.id, occupancyAt(p, now, world)]));
+			for (const person of people) {
+				const occ = at.get(person.id);
+				if (occ) where.set(person.id, occ.slot);
+				track(person, now);
+			}
+			for (const person of people) {
+				const occ = at.get(person.id);
+				if (!occ) continue;
+				enter(model, person, occ.slot, now);
+				runAppliance(model, person, occ.slot, occ.startMs, now);
+			}
+			if (nobodyHome(where.values())) issue(model, call("scene", "turn_on", [AWAY]));
+			else if (nobodyAwake(where.values())) issue(model, call("scene", "turn_on", [GOOD_NIGHT]));
+		},
+		nextAtMs() {
+			let next = Infinity;
+			for (const endMs of runEnds.values()) next = Math.min(next, endMs);
+			for (const person of people) next = Math.min(next, upcoming(person)[0]?.atMs ?? Infinity);
+			return next;
+		},
+		step(model, _fromMs, toMs) {
+			for (const d of dueBy(toMs)) d.run(model);
+		}
+	};
+}
+//#endregion
+//#region src/demo/demo-provider.ts
+const DEMO_HASS_URL = "https://demo.home-assistant.local";
+const TICK_MS = 1e3;
+const FINE_STEP_MS = 1e3;
+const COARSE_STEP_MS = 6e4;
+const FINE_GAP_MS = 12e4;
+const COARSE_GAP_MS = 216e5;
+const LONG_STEP_MS = 3e5;
+const MAX_SPEED = 3600;
+const VISITOR_HOLDS = {
+	light: "boundary",
+	switch: "boundary",
+	fan: "boundary",
+	climate: "event",
+	lock: "event",
+	cover: "event",
+	water_heater: "event"
+};
+let session = null;
+let ticker = null;
+let contextCounter = 0;
+function isDemoMode() {
+	return session !== null;
+}
+/** Internal: the running demo model, for history replay. */
+function demoModel() {
+	return session?.model ?? null;
+}
+/** Internal: visitor calls applied this session, for persistence and history replay. */
+function demoCallLog() {
+	return session?.log ?? [];
+}
+/** Internal: a fresh model for history replay, built exactly like the running one but starting at `startMs`. */
+function demoReplayModel(startMs) {
+	const s = session;
+	if (!s) return null;
+	return buildModel(s.generated, startMs, getWorld());
+}
+/** Internal: apply the provider's visitor-hold mapping to a model, for history replay of logged calls. */
+function applyVisitorHolds(model, entityIds) {
+	holdVisitorEntities(model, entityIds);
+}
+function catchUp(model, simMs) {
+	const gap = simMs - model.nowMs;
+	model.advanceTo(simMs, gap <= FINE_GAP_MS ? FINE_STEP_MS : gap <= COARSE_GAP_MS ? COARSE_STEP_MS : LONG_STEP_MS);
+}
+function advanceSession(s, simMs) {
+	if (!Number.isFinite(simMs)) return;
+	if (simMs - s.model.nowMs > COARSE_GAP_MS) {
+		s.log = pruneLog(s.log, simMs);
+		s.model = replayedModel(s.generated, getWorld(), s.log, simMs);
+		return;
+	}
+	catchUp(s.model, simMs);
+}
+/** Builds from the oldest logged call, replays each with holds, catches up to `targetMs`. */
+function replayedModel(generated, world, log, targetMs) {
+	const oldest = log[0];
+	const model = buildModel(generated, oldest ? Math.min(oldest.simMs, targetMs) : targetMs, world);
+	for (const entry of log) {
+		catchUp(model, entry.simMs);
+		model.dispatch(entry.call);
+		holdVisitorEntities(model, entry.call.entityIds);
+	}
+	catchUp(model, targetMs);
+	return model;
+}
+function holdVisitorEntities(model, entityIds) {
+	for (const entityId of entityIds) {
+		const until = VISITOR_HOLDS[extractDomain(entityId)];
+		if (until) model.hold(entityId, until);
+	}
+}
+function visitorTimeZone() {
+	try {
+		return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+	} catch {
+		return "UTC";
+	}
+}
+function demoStorage() {
+	try {
+		return globalThis.localStorage;
+	} catch {
+		return;
+	}
+}
+const TIME_PATTERN = /^([01]?\d|2[0-3]):([0-5]\d)$/;
+function parseDemoOverrides(search, visitorZone, nowMs) {
+	const params = new URLSearchParams(search);
+	const out = {};
+	const time = TIME_PATTERN.exec(params.get("demo-time") ?? "");
+	if (time) {
+		const minutes = Number(time[1]) * 60 + Number(time[2]);
+		out.pinnedMs = localTime$1(nowMs, visitorZone).midnightMs + minutes * 6e4;
+	}
+	const seed = params.get("demo-seed");
+	if (seed && /^\d+$/.test(seed)) out.seed = Number(seed);
+	const speed = Number(params.get("demo-speed") ?? NaN);
+	if (Number.isFinite(speed) && speed > 0) out.speed = Math.min(speed, MAX_SPEED);
+	return out;
+}
+function resolveClock(opts) {
+	const clock = opts.clock;
+	if (clock !== "live") {
+		const startMs = Date.parse(clock.pinned);
+		if (Number.isNaN(startMs)) throw new Error(`invalid demo pinned time: ${clock.pinned}`);
+		return {
+			startMs,
+			timeZone: clock.timeZone ?? "UTC",
+			seed: clock.seed,
+			live: false,
+			speed: 0,
+			persist: false
+		};
+	}
+	const timeZone = visitorTimeZone();
+	const nowMs = Date.now();
+	const o = parseDemoOverrides(opts.search ?? globalThis.location?.search ?? "", timeZone, nowMs);
+	const seed = o.seed ?? 1;
+	const hasOverride = o.pinnedMs !== void 0 || o.seed !== void 0 || o.speed !== void 0;
+	if (o.pinnedMs !== void 0 && o.speed === void 0) return {
+		startMs: o.pinnedMs,
+		timeZone,
+		seed,
+		live: false,
+		speed: 0,
+		persist: false
+	};
+	return {
+		startMs: o.pinnedMs ?? nowMs,
+		timeZone,
+		seed,
+		live: true,
+		speed: o.speed ?? 1,
+		persist: !hasOverride
+	};
+}
+function nextContext() {
+	contextCounter += 1;
+	return {
+		id: `demo-${contextCounter}`,
+		parent_id: null,
+		user_id: null
+	};
+}
+function buildModel(generated, startMs, world) {
+	return createDemoModel(generated.devices, KINDS, {
+		startMs,
+		world,
+		driver: () => createDriver(HOUSE, generated, world)
+	});
+}
+function attributesOf(generated, entityId, p) {
+	return {
+		friendly_name: generated.friendlyNames[entityId] ?? entityId,
+		...p.attributes
+	};
+}
+function toEntities(generated, projections, iso) {
+	const entities = {};
+	for (const [entityId, p] of Object.entries(projections)) entities[entityId] = {
+		entity_id: entityId,
+		state: p.state,
+		attributes: attributesOf(generated, entityId, p),
+		last_changed: iso,
+		last_updated: iso,
+		context: nextContext()
+	};
+	return entities;
+}
+function sameValue(a, b) {
+	if (a === b) return true;
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+	return JSON.stringify(a) === JSON.stringify(b);
+}
+function sameProjection(a, b) {
+	if (a.state !== b.state) return false;
+	const keys = Object.keys(a.attributes);
+	if (keys.length !== Object.keys(b.attributes).length) return false;
+	return keys.every((k) => k in b.attributes && sameValue(a.attributes[k], b.attributes[k]));
+}
+function publish(s, force) {
+	const wallMs = Date.now();
+	const due = [];
+	for (const [entityId, p] of Object.entries(s.model.project())) {
+		const last = s.published.get(entityId);
+		if (last && sameProjection(last.projection, p)) continue;
+		if (s.live && last && wallMs - last.wallMs < (s.publishMs.get(entityId) ?? 0) && !force.has(entityId)) continue;
+		due.push([entityId, p]);
+	}
+	if (due.length === 0) return;
+	const simMs = s.model.nowMs;
+	const iso = new Date(simMs).toISOString();
+	const luSeconds = Math.round(timeMapOf(s).toWall(simMs) / 1e3);
+	const points = [];
+	setState(produce((st) => {
+		for (const [entityId, p] of due) {
+			const attributes = attributesOf(s.generated, entityId, p);
+			const e = st.entities[entityId];
+			const changed = e?.state !== p.state;
+			if (!e) st.entities[entityId] = {
+				entity_id: entityId,
+				state: p.state,
+				attributes,
+				last_changed: iso,
+				last_updated: iso,
+				context: nextContext()
+			};
+			else {
+				if (changed) e.last_changed = iso;
+				e.state = p.state;
+				for (const key of Object.keys(e.attributes)) if (!(key in attributes)) delete e.attributes[key];
+				for (const [key, value] of Object.entries(attributes)) if (!sameValue(e.attributes[key], value)) e.attributes[key] = value;
+				e.last_updated = iso;
+				e.context = nextContext();
+			}
+			s.published.set(entityId, {
+				projection: p,
+				wallMs
+			});
+			points.push({
+				entityId,
+				stateValue: p.state,
+				attributes: p.attributes,
+				lastUpdated: luSeconds,
+				...changed ? { lastChanged: luSeconds } : {}
+			});
+		}
+	}));
+	bulkAppendHistoryPoints(points);
+}
+/** Internal: advance the running demo to `simMs` and publish what changed. */
+function advanceDemoTo(simMs) {
+	const s = session;
+	if (!s) return;
+	advanceSession(s, simMs);
+	publish(s, /* @__PURE__ */ new Set());
+}
+function liveSimMs(s) {
+	return s.startMs + (Date.now() - s.wallStartMs) * s.speed;
+}
+/** Internal: maps wall-clock instants to the session's sim clock; a pinned session's wall now is its model's now. */
+function demoTimeMap() {
+	return session ? timeMapOf(session) : null;
+}
+function timeMapOf(s) {
+	const anchorWallMs = s.live ? s.wallStartMs : Date.now();
+	const anchorSimMs = s.live ? s.startMs : s.model.nowMs;
+	const speed = s.live ? s.speed : 1;
+	return {
+		toSim: (wallMs) => anchorSimMs + (wallMs - anchorWallMs) * speed,
+		toWall: (simMs) => anchorWallMs + (simMs - anchorSimMs) / speed
+	};
+}
+function tick() {
+	const s = session;
+	if (s?.live) advanceDemoTo(liveSimMs(s));
+}
+async function loadDemoHouse(opts) {
+	const clock = resolveClock(opts);
+	stopDemoEnergyTicker();
+	const world = worldFor(clock.timeZone, clock.seed, clock.startMs);
+	setWorld(world);
+	const generated = generateHouse(HOUSE, new Date(clock.startMs).toISOString());
+	contextCounter = 0;
+	const log = clock.persist ? readLog(demoStorage(), HOUSE.version, clock.startMs) : [];
+	const model = replayedModel(generated, world, log, clock.startMs);
+	const publishMs = /* @__PURE__ */ new Map();
+	for (const entityId of generated.entityIds) {
+		const kind = model.deviceOf(entityId)?.kind;
+		publishMs.set(entityId, kind ? KINDS[kind].publishMs ?? 0 : 0);
+	}
+	const projections = model.project();
+	const wallMs = Date.now();
+	const published = /* @__PURE__ */ new Map();
+	for (const [entityId, projection] of Object.entries(projections)) published.set(entityId, {
+		projection,
+		wallMs
+	});
+	const { registry } = generated;
+	setState("entities", reconcile(toEntities(generated, projections, new Date(clock.startMs).toISOString())));
+	setState("entityRegistry", reconcile(registry.entityRegistry));
+	setState("areas", reconcile(registry.areas));
+	setState("floors", reconcile(registry.floors));
+	setState("devices", reconcile(registry.devices));
+	setState("hassUrl", DEMO_HASS_URL);
+	setState("connectionState", "connected");
+	session = {
+		generated,
+		model,
+		live: clock.live,
+		startMs: clock.startMs,
+		wallStartMs: wallMs,
+		speed: clock.speed,
+		published,
+		publishMs,
+		log: [...log],
+		persist: clock.persist
+	};
+	if (clock.live) startTicker();
+}
+function unloadDemoData() {
+	stopDemoEnergyTicker();
+	session = null;
+	setWorld(worldFor("UTC", 1, 0));
+	setState("entities", reconcile({}));
+	setState("entityRegistry", reconcile({}));
+	setState("areas", reconcile({}));
+	setState("floors", reconcile({}));
+	setState("devices", reconcile({}));
+	setState("hassUrl", null);
+	setState("connectionState", "disconnected");
+}
+async function resetDemo() {
+	clearLog(demoStorage(), HOUSE.version);
+	unloadDemoData();
+	await loadDemoHouse({ clock: "live" });
+}
+/** @deprecated since 0.10.0, use loadDemoHouse({ clock: "live" }) */
+async function loadDemoData() {
+	await loadDemoHouse({ clock: "live" });
+}
+function startTicker() {
+	if (ticker !== null || typeof setInterval !== "function") return;
+	ticker = setInterval(tick, TICK_MS);
+}
+/** @deprecated since 0.10.0, the demo ticker starts with loadDemoHouse */
+function startDemoEnergyTicker() {
+	if (session?.live) startTicker();
+}
+/** @deprecated since 0.10.0, the demo ticker stops with unloadDemoData */
+function stopDemoEnergyTicker() {
+	if (ticker !== null) {
+		clearInterval(ticker);
+		ticker = null;
+	}
+}
+function targetIds(target) {
+	if (Array.isArray(target.entity_id)) return target.entity_id;
+	return target.entity_id ? [target.entity_id] : [];
+}
+/** @deprecated since 0.10.0, service calls reach the demo through callService */
+function applyDemoServiceCall(domain, service, serviceData = {}, target = {}) {
+	const s = session;
+	if (!s) return;
+	const entityIds = targetIds(target);
+	if (entityIds.length === 0) return;
+	if (s.live) advanceSession(s, liveSimMs(s));
+	const call = {
+		domain,
+		service,
+		data: serviceData,
+		entityIds
+	};
+	if (s.model.dispatch(call) === 0) return;
+	holdVisitorEntities(s.model, entityIds);
+	const entry = {
+		simMs: s.model.nowMs,
+		call
+	};
+	s.log.push(entry);
+	if (s.log.length > 500) s.log.splice(0, s.log.length - 500);
+	if (s.persist) appendLog(demoStorage(), HOUSE.version, entry, Date.now());
+	publish(s, new Set(entityIds));
+}
+/** @deprecated since 0.10.0, use loadDemoHouse */
+function createDemoFixtures() {
+	const nowMs = Date.now();
+	const iso = new Date(nowMs).toISOString();
+	const generated = generateHouse(HOUSE, iso);
+	const world = worldFor("UTC", 1, nowMs);
+	const savedWorld = getWorld();
+	const savedCounter = contextCounter;
+	setWorld(world);
+	contextCounter = 0;
+	try {
+		const entities = toEntities(generated, buildModel(generated, nowMs, world).project(), iso);
+		const { entityRegistry, areas, devices } = generated.registry;
+		return {
+			entities,
+			entityRegistry,
+			areas,
+			devices
+		};
+	} finally {
+		setWorld(savedWorld);
+		contextCounter = savedCounter;
+	}
+}
+//#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 {
+		await connection.sendMessagePromise({
+			type: "call_service",
+			domain,
+			service,
+			service_data: serviceData,
+			target
+		});
+	} catch (error) {
+		throw new Error(`Service call failed: ${messageOf(error)}`);
+	}
+}
+function messageOf(error) {
+	if (typeof error === "object" && error !== null && "message" in error) {
+		const { message } = error;
+		if (typeof message === "string" && message) return message;
+	}
+	return 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.");
+	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) {
+		const message = messageOf(error);
+		if (message.includes("Entity registry entry not found")) throw error;
+		throw new Error(`Entity update failed: ${message}`);
+	}
+}
+/**
+* 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: ${messageOf(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/demo/sensor-history.ts
+const DAY_MS$1 = 864e5;
+function seedOf(entityId) {
+	let h = 0;
+	for (let i = 0; i < entityId.length; i++) h = h * 31 + entityId.charCodeAt(i) | 0;
+	return Math.abs(h) % 1e3 / 1e3;
+}
+/**
+* A slow daily swing plus a faster ripple, pinned so the last point is the reading
+* the demo shows now. Deterministic per entity, so previews repeat.
+*/
+function synthesizeSensorHistory(entityId, current, startMs, endMs, stepMs = 9e5) {
+	const amplitude = Math.max(Math.abs(current) * .08, .6);
+	const phase = seedOf(entityId) * 2 * Math.PI;
+	const wave = (t) => Math.sin(2 * Math.PI * t / DAY_MS$1 + phase) + .15 * Math.sin(2 * Math.PI * t * 3 / DAY_MS$1 + 2 * phase);
+	const decimals = Number.isInteger(current) ? 1 : 2;
+	const points = [];
+	for (let t = startMs; t <= endMs; t += stepMs) {
+		const value = current + amplitude * (wave(t) - wave(endMs));
+		points.push({
+			lu: Math.round(t / 1e3),
+			s: value.toFixed(decimals)
+		});
+	}
+	const last = points.at(-1);
+	if (last) last.s = String(current);
+	return points;
+}
+function currentReading(id) {
+	if (!id.startsWith("sensor.")) return void 0;
+	const current = Number(state.entities[id]?.state);
+	return Number.isFinite(current) ? current : void 0;
+}
+/** History for a demo sensor with a numeric reading; undefined for anything else. */
+function numericSensorHistory(id, startMs, endMs) {
+	const current = currentReading(id);
+	return current === void 0 ? void 0 : synthesizeSensorHistory(id, current, startMs, endMs);
+}
+/** Hour or day buckets of the same curve, shaped like recorder statistics. */
+function numericSensorStatistics(id, startMs, endMs, period) {
+	const points = numericSensorHistory(id, startMs, endMs);
+	if (!points) return [];
+	const span = period === "hour" ? 36e5 : DAY_MS$1;
+	const buckets = [];
+	for (let start = startMs; start < endMs; start += span) {
+		const end = start + span;
+		const values = points.filter((p) => p.lu * 1e3 >= start && p.lu * 1e3 < end).map((p) => Number(p.s));
+		if (values.length === 0) continue;
+		const mean = values.reduce((a, b) => a + b, 0) / values.length;
+		buckets.push({
+			start,
+			end,
+			mean,
+			min: Math.min(...values),
+			max: Math.max(...values),
+			sum: 0,
+			change: 0
+		});
+	}
+	return buckets;
+}
+//#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 = {};
+		const statPeriod = period === "hour" || period === "day" ? period : "day";
+		const endMs = (endTime ?? /* @__PURE__ */ new Date()).getTime();
+		for (const id of statisticIds) result[id] = isEnergyEntity(id) ? synthesizeEnergyStatistics(id, startTime.getTime(), endMs, statPeriod) : numericSensorStatistics(id, startTime.getTime(), endMs, statPeriod);
+		return result;
+	}
+	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
+//#region src/weather/fetch.ts
+/**
+* Weather Forecast Fetching
+*
+* @packageDocumentation
+*/
+const DEMO_RAIN_CHANCE = {
+	sunny: 0,
+	"clear-night": 0,
+	partlycloudy: 10,
+	cloudy: 20,
+	windy: 10,
+	fog: 10,
+	rainy: 80,
+	pouring: 95,
+	lightning: 60,
+	"lightning-rainy": 85,
+	snowy: 70,
+	"snowy-rainy": 75,
+	hail: 70,
+	exceptional: 40
+};
+/**
+* In demo mode, derive forecasts from the entity's `forecast` attribute.
+* Hourly and daily are synthesised from the same source (daily entries
+* expanded into 24 hourly steps).
+*/
+function buildDemoForecast(entityId, type) {
+	const entity = state.entities[entityId];
+	const raw = entity?.attributes?.forecast ?? [];
+	if (raw.length === 0) return [];
+	if (type === "daily" || type === "twice_daily") return raw.map((d) => {
+		const chance = DEMO_RAIN_CHANCE[d.condition ?? ""] ?? 10;
+		const templow = d.templow;
+		return {
+			...d,
+			temp_high: d.temp_high ?? d.temperature,
+			temp_low: d.temp_low ?? templow,
+			precipitation_probability: d.precipitation_probability ?? chance
+		};
+	});
+	const model = demoModel();
+	if (model?.deviceOf(entityId)?.kind === "weather") return weatherForecastHourly(model.nowMs, getWorld()).map((h) => ({
+		...h,
+		precipitation_probability: DEMO_RAIN_CHANCE[String(h.condition)] ?? 10
+	}));
+	const start = /* @__PURE__ */ new Date();
+	start.setMinutes(0, 0, 0);
+	const today = raw[0];
+	const tomorrow = raw[1] ?? today;
+	const tHi = today?.temperature ?? 18;
+	const tLo = today?.templow ?? tHi - 5;
+	const tNext = tomorrow?.temperature ?? tHi;
+	const out = [];
+	for (let i = 0; i < 24; i++) {
+		const dt = new Date(start.getTime() + i * 60 * 60 * 1e3);
+		const hour = dt.getHours();
+		const dayMix = i < 12 ? 0 : (i - 12) / 12;
+		const baseHi = tHi * (1 - dayMix) + tNext * dayMix;
+		const phase = (hour - 6) / 24 * Math.PI * 2;
+		const swing = (baseHi - tLo) / 2;
+		const mid = (baseHi + tLo) / 2;
+		const source = i < 8 ? today : tomorrow;
+		const night = hour < 6 || hour >= 21;
+		const condition = source?.condition ?? entity?.state ?? "cloudy";
+		out.push({
+			datetime: dt.toISOString(),
+			temperature: Math.round((mid + Math.sin(phase) * swing) * 10) / 10,
+			condition: night && condition === "sunny" ? "clear-night" : condition,
+			precipitation_probability: DEMO_RAIN_CHANCE[condition] ?? 10
+		});
+	}
+	return out;
+}
+/**
+* Fetch forecast for a single entity and type
+*/
+async function fetchForecast(entityId, type) {
+	if (isDemoMode()) return buildDemoForecast(entityId, type);
+	const conn = privilegedConn();
+	if (!conn) throw new Error("Not connected");
+	return new Promise((resolve, reject) => {
+		let resolved = false;
+		let unsubscribe = null;
+		const timeout = setTimeout(() => {
+			if (!resolved && unsubscribe) {
+				resolved = true;
+				unsubscribe().then(() => reject(/* @__PURE__ */ new Error("Forecast subscription timeout"))).catch(() => reject(/* @__PURE__ */ new Error("Forecast subscription timeout")));
+			}
+		}, 1e4);
+		conn.subscribeMessage((event) => {
+			if (resolved) return;
+			if (event && typeof event === "object" && "forecast" in event) {
+				resolved = true;
+				clearTimeout(timeout);
+				const forecast = event.forecast;
+				const forecastArray = Array.isArray(forecast) ? forecast : [];
+				if (unsubscribe) unsubscribe().then(() => resolve(forecastArray)).catch(() => resolve(forecastArray));
+				else resolve(forecastArray);
+			}
+		}, {
+			type: "weather/subscribe_forecast",
+			entity_id: entityId,
+			forecast_type: type === "twice_daily" ? "twice_daily" : type
+		}).then((unsubFn) => {
+			unsubscribe = unsubFn;
+		}).catch((error) => {
+			resolved = true;
+			clearTimeout(timeout);
+			reject(error);
+		});
+	});
+}
+/**
+* Fetch forecasts for a single entity and multiple types
+*/
+async function fetchForecasts(entityId, types) {
+	const forecasts = {};
+	const loading = {};
+	const errors = {};
+	const lastFetched = {};
+	const fetchPromises = types.map(async (type) => {
+		loading[type] = true;
+		errors[type] = null;
+		try {
+			const forecast = await fetchForecast(entityId, type);
+			forecasts[type] = forecast;
+			lastFetched[type] = Date.now();
+			loading[type] = false;
+		} catch (error) {
+			errors[type] = error instanceof Error ? error : new Error(String(error));
+			forecasts[type] = [];
+			loading[type] = false;
+			lastFetched[type] = null;
+		}
+	});
+	await Promise.all(fetchPromises);
+	return {
+		entityId,
+		forecasts,
+		loading,
+		errors,
+		lastFetched
+	};
+}
+/**
+* Fetch forecast data with error handling
+*/
+async function fetchForecastData(entityId, type) {
+	try {
+		return {
+			entityId,
+			type,
+			forecast: await fetchForecast(entityId, type),
+			loading: false,
+			error: null,
+			lastFetched: Date.now()
+		};
+	} catch (error) {
+		return {
+			entityId,
+			type,
+			forecast: [],
+			loading: false,
+			error: error instanceof Error ? error : new Error(String(error)),
+			lastFetched: null
+		};
+	}
+}
+//#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 = 864e5;
+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: (/* @__PURE__ */ 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();
+	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() {
+	queueMicrotask(() => {
+		flushAll();
+	});
+}
+async function flushAll() {
+	const ids = /* @__PURE__ */ 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 = privilegedConn();
+	if (!conn) 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.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 = /* @__PURE__ */ new Date();
+	const next = new Date(now);
+	next.setHours(24, 0, 30, 0);
+	rollTimer = setTimeout(() => {
+		rollTimer = null;
+		flushAll().then(ensureRollTimer);
+	}, next.getTime() - now.getTime());
+}
+function stopRollTimer() {
+	if (rollTimer) {
+		clearTimeout(rollTimer);
+		rollTimer = null;
+	}
+}
+//#endregion
+export { setPrivilegedConn as $, unloadDemoData as A, getAreaView as B, demoTimeMap as C, resetDemo as D, loadDemoHouse as E, MAX_HISTORY_POINTS as F, getEntityView as G, buildEntityView as H, appendHistoryPoint as I, forceResubscribe as J, getEntityViews as K, bulkAppendHistoryPoints as L, demoEnergyPreferences as M, isEnergyEntity as N, startDemoEnergyTicker as O, synthesizeEnergyHistory as P, privilegedConn as Q, buildAreaView as R, demoReplayModel as S, loadDemoData as T, entityViewEquals as U, getAreaViews as V, getAllEntityViews as W, setManagerConnection as X, registerEntity as Y, setResubscribeHandler as Z, applyDemoServiceCall as _, fetchForecastData as a, demoCallLog as b, normalizeStatisticTime as c, callService as d, setState as et, sendCommand as f, updateEntity as g, turnOn as h, fetchForecast as i, demoAssetUrl as j, stopDemoEnergyTicker as k, batchEntityUpdates as l, turnOff as m, trackCalendarEvents as n, fetchForecasts as o, toggle as p, extractDomain as q, buildDemoForecast as r, fetchStatisticsDuringPeriod as s, forceResubscribeCalendars as t, state as tt, batchServiceCalls as u, applyVisitorHolds as v, isDemoMode as w, demoModel as x, createDemoFixtures as y, buildDeviceView as z };