@glasshome/sync-layer 0.1.0

package/dist/index.js

@@ -0,0 +1,1747 @@
+import { resetStore, setState, state } from "./store-B1sbyexX.js";
+import { batchEntityUpdates, batchServiceCalls, buildAreaView, buildDeviceView, buildEntityView, callService, getAllEntityIds, getAllEntityViews, getAreaView, getAreaViews, getEntitiesByArea, getEntitiesByDevice, getEntitiesByDomain, getEntitiesByFloor, getEntitiesByLabel, getEntityView, getEntityViews, sendCommand, toggle, turnOff, turnOn, updateEntity } from "./area-views-B-m8vwce.js";
+import { extractDomain } from "./types-Csog0nqk.js";
+import { createConnection, createLongLivedTokenAuth, getAuth } from "home-assistant-js-websocket";
+import { produce } from "solid-js/store";
+
+//#region src/connection/adapter.ts
+/**
+* Set of debug listeners for outgoing messages.
+* Supports multiple concurrent observers (e.g., WebSocket event recorder + network monitor).
+*/
+const debugOutgoingMessageListeners = /* @__PURE__ */ new Set();
+/**
+* Set of debug listeners for incoming messages.
+* Captures subscription callbacks and sendMessagePromise responses.
+*/
+const debugIncomingMessageListeners = /* @__PURE__ */ new Set();
+/**
+* Register a listener for all outgoing WebSocket messages.
+* Returns an unsubscribe function.
+*
+* @param listener - Function called with each outgoing message object
+* @returns Unsubscribe function to remove the listener
+*/
+function addDebugOutgoingMessageListener(listener) {
+	debugOutgoingMessageListeners.add(listener);
+	return () => {
+		debugOutgoingMessageListeners.delete(listener);
+	};
+}
+/**
+* Register a listener for all incoming WebSocket messages.
+* Returns an unsubscribe function. Receives subscription updates,
+* event callbacks, and sendMessagePromise responses.
+*
+* @param listener - Function called with each incoming message object
+* @returns Unsubscribe function to remove the listener
+*/
+function addDebugIncomingMessageListener(listener) {
+	debugIncomingMessageListeners.add(listener);
+	return () => {
+		debugIncomingMessageListeners.delete(listener);
+	};
+}
+function notifyOutgoingListeners(message) {
+	if (debugOutgoingMessageListeners.size > 0) for (const listener of debugOutgoingMessageListeners) listener(message);
+}
+function notifyIncomingListeners(message) {
+	if (debugIncomingMessageListeners.size > 0) for (const listener of debugIncomingMessageListeners) listener(message);
+}
+/**
+* Wrap HA Connection to SyncLayerConnection interface
+*
+* This adapter makes the real HA Connection compatible with our unified interface,
+* allowing it to be used interchangeably with MockConnection.
+*
+* @param conn - Home Assistant WebSocket connection
+* @returns Wrapped connection implementing SyncLayerConnection
+*
+* @example
+* ```typescript
+* const haConn = await createConnection({ auth });
+* const wrappedConn = wrapHAConnection(haConn);
+* await syncLayer.connect({ connection: wrappedConn });
+* ```
+*/
+function wrapHAConnection(conn) {
+	return {
+		connect: async () => {
+			return Promise.resolve();
+		},
+		disconnect: () => {
+			conn.close();
+		},
+		get connected$() {
+			return conn.connected;
+		},
+		authenticate: async () => {
+			return Promise.resolve();
+		},
+		get authState() {
+			return "authenticated";
+		},
+		subscribeEvents: async (callback, eventType) => {
+			const wrappedCallback = (event) => {
+				notifyIncomingListeners(event);
+				callback(event);
+			};
+			return conn.subscribeEvents(wrappedCallback, eventType);
+		},
+		subscribeMessage: async (callback, message) => {
+			const wrappedCallback = (msg) => {
+				notifyIncomingListeners(msg);
+				callback(msg);
+			};
+			return conn.subscribeMessage(wrappedCallback, message);
+		},
+		sendMessagePromise: async (message) => {
+			notifyOutgoingListeners(message);
+			const result = await conn.sendMessagePromise(message);
+			notifyIncomingListeners(result);
+			return result;
+		},
+		addEventListener: (handler) => {
+			return addDebugIncomingMessageListener(handler);
+		}
+	};
+}
+
+//#endregion
+//#region src/core/reducers.ts
+/**
+* Bulk update multiple entities
+*
+* Used during initial load or bulk sync operations.
+*
+* @param entities - Array of entity states
+*/
+function bulkUpdateEntities(entities$1) {
+	setState(produce((s) => {
+		for (const entity$1 of entities$1) s.entities[entity$1.entity_id] = entity$1;
+	}));
+}
+/**
+* Update entity registry entry
+*
+* @param entry - Entity registry entry
+*/
+function updateEntityRegistry(entry) {
+	setState(produce((s) => {
+		s.entityRegistry[entry.entity_id] = entry;
+	}));
+}
+/**
+* Remove entity registry entry
+*
+* @param entityId - Entity ID to remove
+*/
+function removeEntityRegistry(entityId) {
+	setState(produce((s) => {
+		delete s.entityRegistry[entityId];
+	}));
+}
+/**
+* Bulk update entity registry
+*
+* @param entries - Array of registry entries
+*/
+function bulkUpdateEntityRegistry(entries) {
+	setState(produce((s) => {
+		for (const entry of entries) s.entityRegistry[entry.entity_id] = entry;
+	}));
+}
+/**
+* Update device registry entry
+*
+* @param device - Device registry entry
+*/
+function updateDevice(device) {
+	setState(produce((s) => {
+		s.devices[device.id] = device;
+	}));
+}
+/**
+* Remove device registry entry
+*
+* @param deviceId - Device ID to remove
+*/
+function removeDevice(deviceId) {
+	setState(produce((s) => {
+		delete s.devices[deviceId];
+	}));
+}
+/**
+* Update area registry entry
+*
+* @param area - Area registry entry
+*/
+function updateArea(area$1) {
+	setState(produce((s) => {
+		s.areas[area$1.id] = area$1;
+	}));
+}
+/**
+* Remove area registry entry
+*
+* @param areaId - Area ID to remove
+*/
+function removeArea(areaId) {
+	setState(produce((s) => {
+		delete s.areas[areaId];
+	}));
+}
+/**
+* Update floor registry entry
+*
+* @param floor - Floor registry entry
+*/
+function updateFloor(floor) {
+	setState(produce((s) => {
+		s.floors[floor.floor_id] = floor;
+	}));
+}
+/**
+* Remove floor registry entry
+*
+* @param floorId - Floor ID to remove
+*/
+function removeFloor(floorId) {
+	setState(produce((s) => {
+		delete s.floors[floorId];
+	}));
+}
+/**
+* Update label registry entry
+*
+* @param label - Label registry entry
+*/
+function updateLabel(label) {
+	setState(produce((s) => {
+		s.labels[label.label_id] = label;
+	}));
+}
+/**
+* Remove label registry entry
+*
+* @param labelId - Label ID to remove
+*/
+function removeLabel(labelId) {
+	setState(produce((s) => {
+		delete s.labels[labelId];
+	}));
+}
+/**
+* Update statistics metadata
+*
+* @param metadata - Statistics metadata
+*/
+function updateStatisticsMetadata(metadata) {
+	setState(produce((s) => {
+		for (const meta of metadata) s.statisticsMetadata[meta.statistic_id] = meta;
+	}));
+}
+
+//#endregion
+//#region src/connection/auth.ts
+/**
+* Authenticate using OAuth flow
+*
+* This function uses `getAuth` from `home-assistant-js-websocket` which:
+* 1. Opens Home Assistant authorization page in a popup
+* 2. Waits for user authorization
+* 3. Exchanges authorization code for tokens
+* 4. Returns authenticated Auth object
+*
+* Note: For a complete OAuth flow, you typically need to:
+* - Set up a redirect URI endpoint in your app
+* - Handle the OAuth callback with the authorization code
+* - Use `getAuthCode` callback to provide the code
+*
+* Alternatively, `getAuth` can automatically handle the flow in browser environments
+* by opening a popup and listening for the callback.
+*
+* @param options - OAuth options
+* @returns Authenticated Auth object
+*
+* @example
+* ```typescript
+* // Basic OAuth flow (browser only)
+* const auth = await authenticateWithOAuth({
+*   url: 'https://homeassistant.local:8123',
+*   clientId: 'https://homeassistant.local:8123',
+*   redirectUri: 'https://myapp.com/auth/callback',
+* });
+* ```
+*
+* @example
+* ```typescript
+* // OAuth with custom code handling
+* const auth = await authenticateWithOAuth({
+*   url: 'https://homeassistant.local:8123',
+*   clientId: 'https://homeassistant.local:8123',
+*   redirectUri: 'https://myapp.com/auth/callback',
+*   getAuthCode: async () => {
+*     // Wait for user to authorize and get code from callback
+*     return await waitForAuthCode();
+*   },
+* });
+* ```
+*/
+async function authenticateWithOAuth(options) {
+	const { url, clientId, redirectUri, authCode, getAuthCode, saveAuth, loadAuth, limitHassInstance } = options;
+	try {
+		const auth$1 = await getAuth({
+			hassUrl: url,
+			clientId: clientId ?? null,
+			redirectUrl: redirectUri,
+			authCode,
+			limitHassInstance,
+			async loadTokens() {
+				if (loadAuth) {
+					const saved = await loadAuth();
+					if (saved?.data) return saved.data;
+				}
+				return null;
+			},
+			saveTokens(tokens) {
+				if (saveAuth && tokens) {
+					const authObj = {
+						hassUrl: url,
+						clientId,
+						redirectUrl: redirectUri,
+						data: tokens,
+						async refreshAccessToken() {
+							return Promise.resolve();
+						}
+					};
+					saveAuth(authObj);
+				}
+			}
+		});
+		return auth$1;
+	} catch {}
+	let finalAuthCode = authCode;
+	if (!finalAuthCode && getAuthCode) finalAuthCode = await getAuthCode();
+	const auth = await getAuth({
+		hassUrl: url,
+		clientId: clientId ?? null,
+		redirectUrl: redirectUri,
+		authCode: finalAuthCode,
+		limitHassInstance,
+		async loadTokens() {
+			if (loadAuth) {
+				const saved = await loadAuth();
+				if (saved?.data) return saved.data;
+			}
+			return null;
+		},
+		saveTokens(tokens) {
+			if (saveAuth && tokens) {
+				const authObj = {
+					hassUrl: url,
+					clientId,
+					redirectUrl: redirectUri,
+					data: tokens,
+					async refreshAccessToken() {
+						return Promise.resolve();
+					}
+				};
+				saveAuth(authObj);
+			}
+		}
+	});
+	return auth;
+}
+/**
+* Authenticate using a long-lived token
+*
+* @param url - Home Assistant instance URL
+* @param token - Long-lived access token
+* @returns Authenticated Auth object
+*
+* @example
+* ```typescript
+* const auth = authenticateWithToken(
+*   'https://homeassistant.local:8123',
+*   'your_long_lived_token'
+* );
+* ```
+*/
+function authenticateWithToken(url, token) {
+	return createLongLivedTokenAuth(url, token);
+}
+/**
+* Check if auth object is valid
+*
+* @param auth - Auth object to check
+* @returns True if auth is valid
+*/
+async function isAuthValid(auth) {
+	try {
+		await auth.refreshAccessToken();
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Refresh auth tokens
+*
+* @param auth - Auth object to refresh
+* @returns Refreshed Auth object
+*/
+async function refreshAuth(auth) {
+	await auth.refreshAccessToken();
+	return auth;
+}
+
+//#endregion
+//#region src/history/constants.ts
+const DOMAINS_USE_LAST_UPDATED = [
+	"climate",
+	"humidifier",
+	"water_heater"
+];
+const NEED_ATTRIBUTE_DOMAINS = [
+	"climate",
+	"humidifier",
+	"input_datetime",
+	"water_heater",
+	"person",
+	"device_tracker"
+];
+const LINE_ATTRIBUTES_TO_KEEP = [
+	"temperature",
+	"current_temperature",
+	"target_temp_low",
+	"target_temp_high",
+	"hvac_action",
+	"humidity",
+	"mode",
+	"action",
+	"current_humidity"
+];
+/**
+* Check if an entity needs attributes in history response
+*/
+function entityIdHistoryNeedsAttributes(entityId) {
+	const domain = extractDomain(entityId);
+	if (!state.entities[entityId]) return NEED_ATTRIBUTE_DOMAINS.includes(domain);
+	return NEED_ATTRIBUTE_DOMAINS.includes(domain);
+}
+
+//#endregion
+//#region src/history/fetch.ts
+/**
+* Fetch history for entities during a time period
+*/
+async function fetchHistory(options) {
+	const { startTime, endTime, entityIds = [], includeStartTimeState = true, significantChangesOnly = true, minimalResponse = true, noAttributes: noAttributesOverride } = options;
+	const startTimeStr = startTime.toISOString();
+	const endTimeStr = endTime?.toISOString();
+	const noAttributes = noAttributesOverride ?? (entityIds.length === 0 ? false : !entityIds.some((entityId) => entityIdHistoryNeedsAttributes(entityId)));
+	const params = {
+		type: "history/history_during_period",
+		start_time: startTimeStr,
+		minimal_response: minimalResponse,
+		no_attributes: noAttributes,
+		include_start_time_state: includeStartTimeState,
+		significant_changes_only: significantChangesOnly
+	};
+	if (endTimeStr) params.end_time = endTimeStr;
+	if (entityIds.length !== 0) params.entity_ids = entityIds;
+	const response = await sendCommand(params);
+	return response ?? {};
+}
+/**
+* Fetch history for a single entity
+*/
+async function fetchEntityHistory(entityId, options) {
+	const { startTime, endTime, includeStartTimeState = true, significantChangesOnly = true, minimalResponse = false, noAttributes = false } = options;
+	try {
+		const historyData = await fetchHistory({
+			startTime,
+			endTime,
+			entityIds: [entityId],
+			includeStartTimeState,
+			significantChangesOnly,
+			minimalResponse,
+			noAttributes
+		});
+		const entityHistory = historyData[entityId] ?? [];
+		const timeline = entityHistory.map((s) => ({
+			timestamp: s.lu,
+			state: s.s,
+			attributes: s.a,
+			lastChanged: s.lc,
+			lastUpdated: s.lu
+		}));
+		return {
+			entityId,
+			timeline,
+			entityHistory,
+			loading: false,
+			error: null,
+			lastFetched: Date.now()
+		};
+	} catch (error) {
+		return {
+			entityId,
+			timeline: [],
+			entityHistory: [],
+			loading: false,
+			error: error instanceof Error ? error : new Error(String(error)),
+			lastFetched: null
+		};
+	}
+}
+/**
+* Convert compressed history state to timeline state
+*/
+function historyStateToTimeline(s) {
+	return {
+		timestamp: s.lu,
+		state: s.s,
+		attributes: s.a,
+		lastChanged: s.lc,
+		lastUpdated: s.lu
+	};
+}
+
+//#endregion
+//#region src/history/query.ts
+/** Set of entity IDs with active history tracking. */
+const trackedEntities = /* @__PURE__ */ new Set();
+/** Check if an entity has active history tracking. */
+function isHistoryTracked(entityId) {
+	return trackedEntities.has(entityId);
+}
+/** Start tracking history for an entity. Fetches initial backfill. */
+async function trackEntityHistory(entityId, options) {
+	trackedEntities.add(entityId);
+	const historyData = await fetchEntityHistory(entityId, options);
+	setState(produce((s) => {
+		s.history[entityId] = historyData;
+	}));
+	return historyData;
+}
+/** Stop tracking history for an entity and clear its data. */
+function untrackEntityHistory(entityId) {
+	trackedEntities.delete(entityId);
+	setState(produce((s) => {
+		delete s.history[entityId];
+	}));
+}
+/**
+* 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
+		});
+	}));
+}
+
+//#endregion
+//#region src/connection/subscriptions.ts
+/** Active subscription cleanup functions (managed externally from store) */
+let activeSubscriptions = [];
+/**
+* Subscribe to all relevant events from Home Assistant
+*/
+async function subscribeToUpdates(conn) {
+	await cleanupSubscriptions();
+	const registryUpdatedSub = await conn.subscribeEvents((event) => {
+		handleRegistryUpdate(event);
+	}, "entity_registry_updated");
+	activeSubscriptions.push(() => registryUpdatedSub());
+	const deviceRegistrySub = await conn.subscribeEvents((event) => {
+		handleDeviceRegistryUpdate(event);
+	}, "device_registry_updated");
+	activeSubscriptions.push(() => deviceRegistrySub());
+	const areaRegistrySub = await conn.subscribeEvents((event) => {
+		handleAreaRegistryUpdate(event);
+	}, "area_registry_updated");
+	activeSubscriptions.push(() => areaRegistrySub());
+	const floorRegistrySub = await conn.subscribeEvents((event) => {
+		handleFloorRegistryUpdate(event);
+	}, "floor_registry_updated");
+	activeSubscriptions.push(() => floorRegistrySub());
+	const labelRegistrySub = await conn.subscribeEvents((event) => {
+		handleLabelRegistryUpdate(event);
+	}, "label_registry_updated");
+	activeSubscriptions.push(() => labelRegistrySub());
+	const statisticsSub = await conn.subscribeEvents((event) => {
+		handleStatisticsUpdate(event);
+	}, "recorder_5min_statistics_generated");
+	activeSubscriptions.push(() => statisticsSub());
+	const entityUpdatesSub = await conn.subscribeMessage((message) => {
+		setState(produce((s) => {
+			if (message.a) for (const [entityId, compressedState] of Object.entries(message.a)) applyCompressedState(s, entityId, compressedState);
+			if (message.c) for (const [entityId, diff] of Object.entries(message.c)) applyStateDiff(s, entityId, diff);
+			if (message.r) for (const entityId of message.r) delete s.entities[entityId];
+		}));
+		if (message.a) for (const [entityId, compressedState] of Object.entries(message.a)) maybeAppendHistory(entityId, compressedState);
+		if (message.c) {
+			for (const [entityId, diff] of Object.entries(message.c)) if (diff["+"]) maybeAppendHistoryFromDiff(entityId, diff["+"]);
+		}
+	}, { type: "subscribe_entities" });
+	activeSubscriptions.push(() => entityUpdatesSub());
+}
+/**
+* Clean up all active subscriptions
+*/
+async function cleanupSubscriptions() {
+	const subscriptions = [...activeSubscriptions];
+	for (const unsub of subscriptions) await unsub();
+	activeSubscriptions = [];
+}
+async function handleRegistryUpdate(event) {
+	const { action, entity_id } = event.data;
+	if (action === "create" || action === "update") {
+		const conn = state.conn;
+		if (!conn) return;
+		try {
+			const entry = await conn.sendMessagePromise({
+				type: "config/entity_registry/get",
+				entity_id
+			});
+			if (entry) updateEntityRegistry(entry);
+		} catch (error) {
+			console.error("Error fetching registry entry:", error);
+		}
+	} else if (action === "remove") removeEntityRegistry(entity_id);
+}
+async function handleDeviceRegistryUpdate(event) {
+	const { action, device_id } = event.data;
+	if (action === "create" || action === "update") {
+		const conn = state.conn;
+		if (!conn) return;
+		try {
+			const devices = await conn.sendMessagePromise({ type: "config/device_registry/list" });
+			const device = devices.find((d) => d.id === device_id);
+			if (device) updateDevice(device);
+		} catch (error) {
+			console.error("Error fetching device:", error);
+		}
+	} else if (action === "remove") removeDevice(device_id);
+}
+async function handleAreaRegistryUpdate(event) {
+	const { action, area_id } = event.data;
+	if (action === "create" || action === "update") {
+		const conn = state.conn;
+		if (!conn) return;
+		try {
+			const areas$1 = await conn.sendMessagePromise({ type: "config/area_registry/list" });
+			const areaApi = areas$1.find((a) => a.area_id === area_id || a.id === area_id);
+			if (areaApi) {
+				const area$1 = {
+					id: areaApi.area_id || areaApi.id,
+					name: areaApi.name,
+					normalized_name: areaApi.normalized_name || areaApi.name.toLowerCase().replace(/\s+/g, "_"),
+					aliases: Array.isArray(areaApi.aliases) ? areaApi.aliases : [],
+					floor_id: areaApi.floor_id ?? null,
+					humidity_entity_id: areaApi.humidity_entity_id ?? null,
+					icon: areaApi.icon ?? null,
+					labels: Array.isArray(areaApi.labels) ? areaApi.labels : [],
+					picture: areaApi.picture ?? null,
+					temperature_entity_id: areaApi.temperature_entity_id ?? null,
+					created_at: typeof areaApi.created_at === "number" ? new Date(areaApi.created_at * 1e3).toISOString() : areaApi.created_at,
+					modified_at: typeof areaApi.modified_at === "number" ? new Date(areaApi.modified_at * 1e3).toISOString() : areaApi.modified_at
+				};
+				updateArea(area$1);
+			}
+		} catch (error) {
+			console.error("Error fetching area:", error);
+		}
+	} else if (action === "remove") removeArea(area_id);
+}
+async function handleFloorRegistryUpdate(event) {
+	const { action, floor_id } = event.data;
+	if (action === "create" || action === "update") {
+		const conn = state.conn;
+		if (!conn) return;
+		try {
+			const floors = await conn.sendMessagePromise({ type: "config/floor_registry/list" });
+			const floor = floors.find((f) => f.floor_id === floor_id);
+			if (floor) updateFloor(floor);
+		} catch (error) {
+			console.error("Error fetching floor:", error);
+		}
+	} else if (action === "remove") removeFloor(floor_id);
+}
+async function handleLabelRegistryUpdate(event) {
+	const { action, label_id } = event.data;
+	if (action === "create" || action === "update") {
+		const conn = state.conn;
+		if (!conn) return;
+		try {
+			const labels = await conn.sendMessagePromise({ type: "config/label_registry/list" });
+			const label = labels.find((l) => l.label_id === label_id);
+			if (label) updateLabel(label);
+		} catch (error) {
+			console.error("Error fetching label:", error);
+		}
+	} else if (action === "remove") removeLabel(label_id);
+}
+async function handleStatisticsUpdate(event) {
+	const { statistic_ids } = event.data;
+	if (!statistic_ids || statistic_ids.length === 0) return;
+	const conn = state.conn;
+	if (!conn) return;
+	try {
+		const metadata = await conn.sendMessagePromise({
+			type: "recorder/get_statistics_metadata",
+			statistic_ids
+		});
+		if (metadata && Array.isArray(metadata)) updateStatisticsMetadata(metadata);
+	} catch (error) {
+		console.error("Error fetching statistics metadata:", error);
+	}
+}
+function timestampToIso(timestamp) {
+	if (timestamp === void 0) return (/* @__PURE__ */ new Date()).toISOString();
+	if (typeof timestamp === "string") return timestamp;
+	return new Date(timestamp * 1e3).toISOString();
+}
+function maybeAppendHistory(entityId, compressed) {
+	if (!isHistoryTracked(entityId)) return;
+	const stateVal = compressed.s ?? compressed.state ?? "unknown";
+	const attributes = compressed.a ?? compressed.attributes ?? {};
+	const lu = compressed.lu ?? (compressed.last_updated ? new Date(compressed.last_updated).getTime() / 1e3 : Date.now() / 1e3);
+	const lc = compressed.lc ?? (compressed.last_changed ? new Date(compressed.last_changed).getTime() / 1e3 : void 0);
+	appendHistoryPoint(entityId, stateVal, attributes, lu, lc);
+}
+function maybeAppendHistoryFromDiff(entityId, additions) {
+	if (!isHistoryTracked(entityId)) return;
+	const entity$1 = state.entities[entityId];
+	if (!entity$1) return;
+	const lu = additions.lu ?? Date.now() / 1e3;
+	const lc = additions.lc;
+	appendHistoryPoint(entityId, entity$1.state, entity$1.attributes, lu, lc);
+}
+function applyCompressedState(s, entityId, compressed) {
+	const stateVal = compressed.s ?? compressed.state ?? "unknown";
+	const attributes = compressed.a ?? compressed.attributes ?? {};
+	const context = compressed.c ?? compressed.context ?? {
+		id: "",
+		parent_id: null,
+		user_id: null
+	};
+	const lastChanged = timestampToIso(compressed.lc ?? compressed.last_changed);
+	const lastUpdated = timestampToIso(compressed.lu ?? compressed.last_updated);
+	const entity$1 = {
+		entity_id: entityId,
+		state: stateVal,
+		attributes,
+		last_changed: lastChanged,
+		last_updated: lastUpdated,
+		context
+	};
+	s.entities[entityId] = entity$1;
+}
+function applyStateDiff(s, entityId, diff) {
+	const existing = s.entities[entityId];
+	if (!existing) return;
+	const additions = diff["+"];
+	if (additions) {
+		if (additions.s !== void 0) existing.state = additions.s;
+		if (additions.a) Object.assign(existing.attributes, additions.a);
+		if (additions.lc !== void 0) existing.last_changed = timestampToIso(additions.lc);
+		if (additions.lu !== void 0) existing.last_updated = timestampToIso(additions.lu);
+		if (additions.c) existing.context = additions.c;
+	}
+	const removals = diff["-"];
+	if (removals?.a) for (const key of removals.a) delete existing.attributes[key];
+}
+
+//#endregion
+//#region src/connection/manager.ts
+/**
+* Initialize connection to Home Assistant
+*/
+async function initConnection(options) {
+	try {
+		setState(produce((s) => {
+			s.connectionState = "connecting";
+			s.connectionError = null;
+		}));
+		let auth;
+		if (typeof options.auth === "string") auth = authenticateWithToken(options.url, options.auth);
+		else if (typeof options.auth === "object" && "clientId" in options.auth) auth = await authenticateWithOAuth(options.auth);
+		else auth = options.auth;
+		const conn = await createConnection({
+			auth,
+			...options.createSocket ? { createSocket: options.createSocket } : {}
+		});
+		const wrappedConn = wrapHAConnection(conn);
+		setState(produce((s) => {
+			s.conn = conn;
+			s.connectionState = "connected";
+		}));
+		setupEventHandlers(conn, options);
+		await loadInitialData(conn);
+		await subscribeToUpdates(wrappedConn);
+		options.onConnect?.();
+		return conn;
+	} catch (error) {
+		const err = error instanceof Error ? error : new Error(String(error));
+		setState(produce((s) => {
+			s.connectionState = "error";
+			s.connectionError = err;
+		}));
+		options.onError?.(err);
+		throw err;
+	}
+}
+/**
+* Disconnect from Home Assistant
+*/
+function disconnect() {
+	const conn = state.conn;
+	if (conn) conn.close();
+	setState(produce((s) => {
+		s.conn = null;
+		s.connectionState = "disconnected";
+	}));
+}
+/**
+* Get current connection
+*/
+function getConnection() {
+	return state.conn;
+}
+/**
+* Check if currently connected
+*/
+function isConnected() {
+	return state.connectionState === "connected";
+}
+function setupEventHandlers(conn, options) {
+	conn.addEventListener("disconnected", () => {
+		setState(produce((s) => {
+			s.connectionState = "disconnected";
+		}));
+		options.onDisconnect?.();
+	});
+	conn.addEventListener("reconnect-error", () => {
+		setState(produce((s) => {
+			s.connectionState = "reconnecting";
+		}));
+	});
+	conn.addEventListener("ready", async () => {
+		const wasReconnecting = state.connectionState === "reconnecting";
+		setState(produce((s) => {
+			s.connectionState = "connected";
+			s.connectionError = null;
+		}));
+		if (wasReconnecting) {
+			await loadInitialData(conn);
+			options.onReconnect?.();
+		}
+	});
+}
+async function loadInitialData(conn) {
+	try {
+		const [states, entityRegistry, deviceRegistry, areaRegistry, floorRegistry, labelRegistry] = await Promise.all([
+			conn.sendMessagePromise({ type: "get_states" }),
+			conn.sendMessagePromise({ type: "config/entity_registry/list" }),
+			conn.sendMessagePromise({ type: "config/device_registry/list" }),
+			conn.sendMessagePromise({ type: "config/area_registry/list" }),
+			conn.sendMessagePromise({ type: "config/floor_registry/list" }),
+			conn.sendMessagePromise({ type: "config/label_registry/list" })
+		]);
+		bulkUpdateEntities(states);
+		bulkUpdateEntityRegistry(entityRegistry);
+		setState(produce((s) => {
+			for (const device of deviceRegistry) s.devices[device.id] = device;
+			for (const areaApi of areaRegistry) {
+				const area$1 = {
+					id: areaApi.area_id || areaApi.id,
+					name: areaApi.name,
+					normalized_name: areaApi.normalized_name || areaApi.name.toLowerCase().replace(/\s+/g, "_"),
+					aliases: Array.isArray(areaApi.aliases) ? areaApi.aliases : [],
+					floor_id: areaApi.floor_id ?? null,
+					humidity_entity_id: areaApi.humidity_entity_id ?? null,
+					icon: areaApi.icon ?? null,
+					labels: Array.isArray(areaApi.labels) ? areaApi.labels : [],
+					picture: areaApi.picture ?? null,
+					temperature_entity_id: areaApi.temperature_entity_id ?? null,
+					created_at: typeof areaApi.created_at === "number" ? new Date(areaApi.created_at * 1e3).toISOString() : areaApi.created_at,
+					modified_at: typeof areaApi.modified_at === "number" ? new Date(areaApi.modified_at * 1e3).toISOString() : areaApi.modified_at
+				};
+				s.areas[area$1.id] = area$1;
+			}
+			for (const floor of floorRegistry) s.floors[floor.floor_id] = floor;
+			for (const label of labelRegistry) s.labels[label.label_id] = label;
+		}));
+	} catch (error) {
+		console.error("Error loading initial data:", error);
+		throw error;
+	}
+}
+
+//#endregion
+//#region src/query/area-builder.ts
+var AreaQueryBuilderImpl = class AreaQueryBuilderImpl {
+	queryState;
+	constructor(initialState) {
+		this.queryState = initialState ?? {
+			filters: [],
+			sorts: []
+		};
+	}
+	byFloor(floorId) {
+		return this.clone({ filters: [...this.queryState.filters, {
+			type: "floor",
+			value: floorId
+		}] });
+	}
+	byLabel(labelId) {
+		return this.clone({ filters: [...this.queryState.filters, {
+			type: "label",
+			value: labelId
+		}] });
+	}
+	where(predicate) {
+		return this.clone({ filters: [...this.queryState.filters, {
+			type: "predicate",
+			value: predicate
+		}] });
+	}
+	orderBy(key, direction = "asc") {
+		return this.clone({ sorts: [...this.queryState.sorts, {
+			key,
+			direction
+		}] });
+	}
+	get() {
+		return this.execute();
+	}
+	first() {
+		const results = this.execute();
+		return results[0];
+	}
+	subscribe(callback) {
+		callback(this.get());
+		return () => {};
+	}
+	clone(updates) {
+		return new AreaQueryBuilderImpl({
+			...this.queryState,
+			...updates
+		});
+	}
+	execute() {
+		let areas$1 = getAreaViews();
+		for (const filter of this.queryState.filters) if (filter.type === "floor") areas$1 = areas$1.filter((area$1) => area$1.floorId === filter.value);
+		else if (filter.type === "label") areas$1 = areas$1.filter((area$1) => area$1.labels.includes(filter.value));
+		else if (filter.type === "predicate") areas$1 = areas$1.filter(filter.value);
+		if (this.queryState.sorts.length > 0) areas$1 = this.sortAreas(areas$1);
+		return areas$1;
+	}
+	sortAreas(areas$1) {
+		return [...areas$1].sort((a, b) => {
+			for (const sort of this.queryState.sorts) {
+				const aValue = this.getNestedValue(a, sort.key);
+				const bValue = this.getNestedValue(b, sort.key);
+				let comparison = 0;
+				if (aValue < bValue) comparison = -1;
+				else if (aValue > bValue) comparison = 1;
+				if (comparison !== 0) return sort.direction === "asc" ? comparison : -comparison;
+			}
+			return 0;
+		});
+	}
+	getNestedValue(obj, key) {
+		if (key in obj) return obj[key];
+		const parts = String(key).split(".");
+		let value = obj;
+		for (const part of parts) value = value?.[part];
+		return value;
+	}
+};
+/**
+* Create a query builder for areas
+*/
+function areas() {
+	return new AreaQueryBuilderImpl();
+}
+/**
+* Create a query for a single area
+*/
+function area(areaId) {
+	return getAreaView(areaId);
+}
+
+//#endregion
+//#region src/query/memoization.ts
+/**
+* Build a unique signature for a query
+*/
+function buildQuerySignature(query) {
+	const sig = {
+		index: query.indexFilters.map((f) => `${f.type}:${f.value}`).join(","),
+		predicates: query.predicateFilters.length,
+		sorts: query.sorts.map((s) => `${s.key}:${s.direction}`).join(","),
+		projection: query.projection ? JSON.stringify(query.projection) : null
+	};
+	return JSON.stringify(sig);
+}
+/**
+* Execute query (no caching -- SolidJS createMemo handles this in Plan 03)
+*/
+function memoizedExecute(signature, compute) {
+	return compute();
+}
+
+//#endregion
+//#region src/query/projections.ts
+/**
+* Project entities to IDs only
+*
+* @param entities - Array of entity views
+* @returns Array of entity IDs
+*/
+function projectToIds(entities$1) {
+	return entities$1.map((e) => e.id);
+}
+/**
+* Pick specific fields from entities
+*
+* @param entities - Array of entity views
+* @param keys - Array of field names to include
+* @returns Array of objects with only specified fields
+*/
+function projectPick(entities$1, keys) {
+	return entities$1.map((entity$1) => {
+		const result = {};
+		for (const key of keys) result[key] = entity$1[key];
+		return result;
+	});
+}
+/**
+* Pluck a single field from entities
+*
+* Supports dot-notation for nested fields (e.g., "attributes.brightness")
+*
+* @param entities - Array of entity views
+* @param key - Field name or dot-path to extract
+* @returns Array of field values
+*/
+function projectPluck(entities$1, key) {
+	return entities$1.map((entity$1) => getNestedValue(entity$1, key));
+}
+/**
+* Map entities using a custom function
+*
+* @param entities - Array of entity views
+* @param mapper - Function to transform each entity
+* @returns Array of mapped values
+*/
+function projectMap(entities$1, mapper) {
+	return entities$1.map(mapper);
+}
+/**
+* Get nested value from object using dot-notation
+*
+* @param obj - Object to extract value from
+* @param path - Dot-notation path (e.g., "attributes.brightness")
+* @returns Value at path or undefined
+*
+* @example
+* ```typescript
+* const entity = { attributes: { brightness: 255 } };
+* getNestedValue(entity, "attributes.brightness"); // 255
+* ```
+*/
+function getNestedValue(obj, path) {
+	const parts = path.split(".");
+	let current = obj;
+	for (const part of parts) {
+		if (current === null || current === void 0) return void 0;
+		current = current[part];
+	}
+	return current;
+}
+
+//#endregion
+//#region src/query/builder.ts
+var EntitiesQueryBuilderImpl = class EntitiesQueryBuilderImpl {
+	queryState;
+	constructor(initialState) {
+		this.queryState = initialState ?? {
+			indexFilters: [],
+			predicateFilters: [],
+			sorts: [],
+			projection: void 0,
+			searchText: void 0,
+			take: void 0,
+			skip: void 0,
+			distinct: void 0
+		};
+	}
+	byArea(areaId) {
+		return this.clone({ indexFilters: [...this.queryState.indexFilters, {
+			type: "area",
+			value: areaId
+		}] });
+	}
+	byDomain(domain) {
+		return this.clone({ indexFilters: [...this.queryState.indexFilters, {
+			type: "domain",
+			value: domain
+		}] });
+	}
+	byDevice(deviceId) {
+		return this.clone({ indexFilters: [...this.queryState.indexFilters, {
+			type: "device",
+			value: deviceId
+		}] });
+	}
+	byFloor(floorId) {
+		return this.clone({ indexFilters: [...this.queryState.indexFilters, {
+			type: "floor",
+			value: floorId
+		}] });
+	}
+	byLabel(labelId) {
+		return this.clone({ indexFilters: [...this.queryState.indexFilters, {
+			type: "label",
+			value: labelId
+		}] });
+	}
+	where(predicate) {
+		return this.clone({ predicateFilters: [...this.queryState.predicateFilters, predicate] });
+	}
+	search(searchText) {
+		const searchLower = searchText.toLowerCase();
+		return this.where((e) => e.id.toLowerCase().includes(searchLower) || e.name.toLowerCase().includes(searchLower) || e.friendlyName.toLowerCase().includes(searchLower));
+	}
+	orderBy(key, direction = "asc") {
+		return this.clone({ sorts: [...this.queryState.sorts, {
+			key,
+			direction
+		}] });
+	}
+	ids() {
+		return this.clone({ projection: { type: "ids" } });
+	}
+	pick(keys) {
+		return this.clone({ projection: {
+			type: "pick",
+			keys
+		} });
+	}
+	pluck(key) {
+		return this.clone({ projection: {
+			type: "pluck",
+			key
+		} });
+	}
+	map(mapper) {
+		return this.clone({ projection: {
+			type: "map",
+			mapper
+		} });
+	}
+	take(limit) {
+		return this.clone({ take: limit });
+	}
+	skip(count) {
+		return this.clone({ skip: count });
+	}
+	distinct(key) {
+		return this.clone({ distinct: key });
+	}
+	get() {
+		const signature = buildQuerySignature(this.queryState);
+		return memoizedExecute(signature, () => this.execute());
+	}
+	first() {
+		const results = this.get();
+		return results[0];
+	}
+	subscribe(callback) {
+		callback(this.get());
+		return () => {};
+	}
+	clone(updates) {
+		return new EntitiesQueryBuilderImpl({
+			...this.queryState,
+			...updates
+		});
+	}
+	execute() {
+		const entityIds = this.getEntityIdsFromIndices();
+		let entities$1 = getEntityViews(entityIds);
+		for (const filter of this.queryState.predicateFilters) entities$1 = entities$1.filter(filter);
+		if (this.queryState.sorts.length > 0) entities$1 = this.sortEntities(entities$1);
+		if (this.queryState.distinct) entities$1 = this.applyDistinct(entities$1);
+		if (this.queryState.skip !== void 0) entities$1 = entities$1.slice(this.queryState.skip);
+		if (this.queryState.take !== void 0) entities$1 = entities$1.slice(0, this.queryState.take);
+		if (this.queryState.projection) return this.applyProjection(entities$1);
+		return entities$1;
+	}
+	getEntityIdsFromIndices() {
+		if (this.queryState.indexFilters.length === 0) return getAllEntityIds();
+		const idSets = this.queryState.indexFilters.map((filter) => this.getIdsForFilter(filter));
+		return this.intersectArrays(idSets);
+	}
+	getIdsForFilter(filter) {
+		switch (filter.type) {
+			case "domain": return getEntitiesByDomain(filter.value);
+			case "area": return getEntitiesByArea(filter.value);
+			case "device": return getEntitiesByDevice(filter.value);
+			case "floor": return getEntitiesByFloor(filter.value);
+			case "label": return getEntitiesByLabel(filter.value);
+			default: return [];
+		}
+	}
+	intersectArrays(arrays) {
+		if (arrays.length === 0) return [];
+		if (arrays.length === 1) return arrays[0] ?? [];
+		let result = arrays[0] ?? [];
+		for (let i = 1; i < arrays.length; i++) {
+			const set = new Set(arrays[i]);
+			result = result.filter((item) => set.has(item));
+		}
+		return result;
+	}
+	sortEntities(entities$1) {
+		const sorted = [...entities$1];
+		sorted.sort((a, b) => {
+			for (const sort of this.queryState.sorts) {
+				const aVal = getNestedValue(a, sort.key);
+				const bVal = getNestedValue(b, sort.key);
+				const comparison = this.compareValues(aVal, bVal);
+				if (comparison !== 0) return sort.direction === "asc" ? comparison : -comparison;
+			}
+			return 0;
+		});
+		return sorted;
+	}
+	compareValues(a, b) {
+		if (a === b) return 0;
+		if (a === null || a === void 0) return 1;
+		if (b === null || b === void 0) return -1;
+		if (typeof a === "string" && typeof b === "string") return a.localeCompare(b);
+		if (typeof a === "number" && typeof b === "number") return a - b;
+		return String(a).localeCompare(String(b));
+	}
+	applyProjection(entities$1) {
+		if (!this.queryState.projection) return entities$1;
+		switch (this.queryState.projection.type) {
+			case "ids": return projectToIds(entities$1);
+			case "pick": return projectPick(entities$1, this.queryState.projection.keys);
+			case "pluck": return projectPluck(entities$1, this.queryState.projection.key);
+			case "map": return projectMap(entities$1, this.queryState.projection.mapper);
+			default: return entities$1;
+		}
+	}
+	applyDistinct(entities$1) {
+		if (!this.queryState.distinct) return entities$1;
+		const seen = /* @__PURE__ */ new Set();
+		const result = [];
+		for (const entity$1 of entities$1) {
+			const value = getNestedValue(entity$1, this.queryState.distinct);
+			const key = JSON.stringify(value);
+			if (!seen.has(key)) {
+				seen.add(key);
+				result.push(entity$1);
+			}
+		}
+		return result;
+	}
+};
+var EntityQueryBuilderImpl = class {
+	constructor(entityId) {
+		this.entityId = entityId;
+	}
+	get() {
+		return getEntityView(this.entityId);
+	}
+	pluck(key) {
+		const view = this.get();
+		return view ? view[key] : void 0;
+	}
+	subscribe(callback) {
+		callback(this.get());
+		return () => {};
+	}
+};
+/**
+* Create a query builder for multiple entities
+*/
+function entities() {
+	return new EntitiesQueryBuilderImpl();
+}
+/**
+* Create a query builder for a single entity
+*/
+function entity(entityId) {
+	return new EntityQueryBuilderImpl(entityId);
+}
+
+//#endregion
+//#region src/query/helpers.ts
+/**
+* Create a search query builder
+*/
+function searchEntities(searchText) {
+	const searchLower = searchText.toLowerCase();
+	return entities().where((e) => e.id.toLowerCase().includes(searchLower) || e.name.toLowerCase().includes(searchLower) || e.friendlyName.toLowerCase().includes(searchLower));
+}
+/**
+* Create a query for entities in an area by domain
+*/
+function entitiesByAreaAndDomain(areaId, domain) {
+	return entities().byArea(areaId).byDomain(domain);
+}
+/**
+* Create a query for entities matching a predicate
+*/
+function entitiesWhere(predicate) {
+	return entities().where(predicate);
+}
+
+//#endregion
+//#region src/camera/fetch.ts
+/**
+* Fetch stream for a camera entity
+*/
+async function fetchStream(entityId, format = "hls") {
+	const response = await sendCommand({
+		type: "camera/stream",
+		entity_id: entityId,
+		format
+	});
+	return response?.url ?? null;
+}
+/**
+* Transform relative stream URL to absolute URL
+*/
+function transformStreamUrl(streamUrl) {
+	if (!streamUrl) return null;
+	if (streamUrl.startsWith("http://") || streamUrl.startsWith("https://")) return streamUrl;
+	if (streamUrl.startsWith("/")) {
+		const hassUrl = state.hassUrl;
+		if (!hassUrl) {
+			console.warn("[fetchStreamData] No Home Assistant URL available to resolve relative stream URL");
+			return streamUrl;
+		}
+		const baseUrl = hassUrl.replace(/\/$/, "");
+		return `${baseUrl}${streamUrl}`;
+	}
+	return streamUrl;
+}
+/**
+* Fetch stream data for a camera entity
+*/
+async function fetchStreamData(entityId, options = {}) {
+	const { format = "hls" } = options;
+	try {
+		const streamUrl = await fetchStream(entityId, format);
+		const absoluteStreamUrl = transformStreamUrl(streamUrl);
+		const stream = {
+			url: absoluteStreamUrl,
+			loading: false,
+			error: null,
+			lastFetched: Date.now(),
+			format,
+			expiresAt: null
+		};
+		return {
+			entityId,
+			stream,
+			loading: false,
+			error: null,
+			lastFetched: Date.now()
+		};
+	} catch (error) {
+		const stream = {
+			url: null,
+			loading: false,
+			error: error instanceof Error ? error : new Error(String(error)),
+			lastFetched: null,
+			format,
+			expiresAt: null
+		};
+		return {
+			entityId,
+			stream,
+			loading: false,
+			error: error instanceof Error ? error : new Error(String(error)),
+			lastFetched: null
+		};
+	}
+}
+
+//#endregion
+//#region src/camera/query.ts
+const DEFAULT_REFRESH_INTERVAL = 4 * 60 * 1e3;
+function needsStreamRefresh(streamData, refreshInterval = DEFAULT_REFRESH_INTERVAL) {
+	if (!streamData || !streamData.lastFetched) return true;
+	const age = Date.now() - streamData.lastFetched;
+	return age >= refreshInterval;
+}
+/**
+* Get stream for a camera entity
+*/
+async function getStream(entityId, options = {}) {
+	const { format = "hls", autoRefresh = true, refreshInterval } = options;
+	const cached = state.streams[entityId];
+	if (cached && cached.stream.format === format) {
+		if (autoRefresh && needsStreamRefresh(cached, refreshInterval)) fetchStreamData(entityId, {
+			format,
+			autoRefresh,
+			refreshInterval
+		}).then((streamData$1) => {
+			setState(produce((s) => {
+				s.streams[entityId] = streamData$1;
+			}));
+		});
+		return cached;
+	}
+	const streamData = await fetchStreamData(entityId, {
+		format,
+		autoRefresh,
+		refreshInterval
+	});
+	setState(produce((s) => {
+		s.streams[entityId] = streamData;
+	}));
+	return streamData;
+}
+/**
+* Refresh stream for a camera entity
+*/
+async function refreshStream(entityId, format = "hls") {
+	setState(produce((s) => {
+		delete s.streams[entityId];
+	}));
+	return getStream(entityId, { format });
+}
+
+//#endregion
+//#region src/camera/webrtc.ts
+/**
+* Get WebRTC client configuration (STUN/TURN servers) from HA
+*/
+async function getWebRtcClientConfig(entityId) {
+	const conn = state.conn;
+	if (!conn) throw new Error("Not connected");
+	return conn.sendMessagePromise({
+		type: "camera/webrtc/get_client_config",
+		entity_id: entityId
+	});
+}
+/**
+* Start WebRTC session with HA.
+* Returns a promise that resolves when the answer SDP is received.
+* ICE candidates from HA are forwarded to the provided callback.
+* Local ICE candidates should be sent via sendWebRtcCandidate().
+*/
+function startWebRtcSession(entityId, sdpOffer, onCandidate) {
+	const conn = state.conn;
+	if (!conn) return Promise.reject(new Error("Not connected"));
+	return new Promise((resolve, reject) => {
+		const session = {
+			sessionId: null,
+			unsubscribe: null
+		};
+		let answered = false;
+		const timeout = setTimeout(() => {
+			if (!answered) {
+				session.unsubscribe?.();
+				reject(new Error("WebRTC offer timed out"));
+			}
+		}, 15e3);
+		conn.subscribeMessage((event) => {
+			switch (event.type) {
+				case "session":
+					session.sessionId = event.session_id ?? null;
+					break;
+				case "answer":
+					if (event.answer) {
+						answered = true;
+						clearTimeout(timeout);
+						resolve({
+							answer: event.answer,
+							session
+						});
+					}
+					break;
+				case "candidate":
+					if (event.candidate) onCandidate(event.candidate);
+					break;
+				case "error":
+					clearTimeout(timeout);
+					session.unsubscribe?.();
+					reject(new Error(event.message || event.code || "WebRTC offer failed"));
+					break;
+			}
+		}, {
+			type: "camera/webrtc/offer",
+			entity_id: entityId,
+			offer: sdpOffer
+		}).then((unsub) => {
+			session.unsubscribe = unsub;
+		}).catch((err) => {
+			clearTimeout(timeout);
+			reject(err);
+		});
+	});
+}
+/**
+* Send a local ICE candidate to HA
+*/
+async function sendWebRtcCandidate(entityId, sessionId, candidate) {
+	const conn = state.conn;
+	if (!conn) throw new Error("Not connected");
+	await conn.sendMessagePromise({
+		type: "camera/webrtc/candidate",
+		entity_id: entityId,
+		session_id: sessionId,
+		candidate
+	});
+}
+
+//#endregion
+//#region src/weather/fetch.ts
+/**
+* Fetch forecast for a single entity and type
+*/
+async function fetchForecast(entityId, type) {
+	const conn = state.conn;
+	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(new Error("Forecast subscription timeout"))).catch(() => reject(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 {
+		const forecast = await fetchForecast(entityId, type);
+		return {
+			entityId,
+			type,
+			forecast,
+			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/weather/query.ts
+/**
+* Get forecast for a single entity and type
+*/
+async function getForecast(entityId, type) {
+	const cached = state.forecasts[entityId];
+	if (cached?.forecasts[type] && cached.lastFetched[type]) return {
+		entityId,
+		type,
+		forecast: cached.forecasts[type],
+		loading: cached.loading[type] ?? false,
+		error: cached.errors[type] ?? null,
+		lastFetched: cached.lastFetched[type] ?? null
+	};
+	const forecastData = await fetchForecastData(entityId, type);
+	setState(produce((s) => {
+		if (!s.forecasts[entityId]) s.forecasts[entityId] = {
+			entityId,
+			forecasts: {},
+			loading: {},
+			errors: {},
+			lastFetched: {}
+		};
+		s.forecasts[entityId].forecasts[type] = forecastData.forecast;
+		s.forecasts[entityId].loading[type] = forecastData.loading;
+		s.forecasts[entityId].errors[type] = forecastData.error;
+		s.forecasts[entityId].lastFetched[type] = forecastData.lastFetched;
+	}));
+	return forecastData;
+}
+/**
+* Get forecasts for a single entity and multiple types
+*/
+async function getForecasts(entityId, types) {
+	const cachedData = {};
+	const typesToFetch = [];
+	const forecastsRecord = state.forecasts[entityId];
+	for (const type of types) if (forecastsRecord?.forecasts[type] && forecastsRecord.lastFetched[type]) cachedData[type] = {
+		entityId,
+		type,
+		forecast: forecastsRecord.forecasts[type],
+		loading: forecastsRecord.loading[type] ?? false,
+		error: forecastsRecord.errors[type] ?? null,
+		lastFetched: forecastsRecord.lastFetched[type] ?? null
+	};
+	else typesToFetch.push(type);
+	let fetchedData;
+	if (typesToFetch.length > 0) {
+		fetchedData = await fetchForecasts(entityId, typesToFetch);
+		setState(produce((s) => {
+			if (!s.forecasts[entityId]) s.forecasts[entityId] = {
+				entityId,
+				forecasts: {},
+				loading: {},
+				errors: {},
+				lastFetched: {}
+			};
+			for (const type of typesToFetch) {
+				s.forecasts[entityId].forecasts[type] = fetchedData.forecasts[type] ?? [];
+				s.forecasts[entityId].loading[type] = fetchedData.loading[type] ?? false;
+				s.forecasts[entityId].errors[type] = fetchedData.errors[type] ?? null;
+				s.forecasts[entityId].lastFetched[type] = fetchedData.lastFetched[type] ?? null;
+			}
+		}));
+		for (const type of types) if (cachedData[type]) {
+			fetchedData.forecasts[type] = cachedData[type].forecast;
+			fetchedData.loading[type] = cachedData[type].loading;
+			fetchedData.errors[type] = cachedData[type].error;
+			fetchedData.lastFetched[type] = cachedData[type].lastFetched;
+		}
+	} else {
+		fetchedData = {
+			entityId,
+			forecasts: {},
+			loading: {},
+			errors: {},
+			lastFetched: {}
+		};
+		for (const type of types) {
+			const cached = cachedData[type];
+			fetchedData.forecasts[type] = cached.forecast;
+			fetchedData.loading[type] = cached.loading;
+			fetchedData.errors[type] = cached.error;
+			fetchedData.lastFetched[type] = cached.lastFetched;
+		}
+	}
+	return fetchedData;
+}
+/**
+* Refresh forecast
+*/
+async function refreshForecast(entityId, type) {
+	setState(produce((s) => {
+		if (s.forecasts[entityId]) {
+			delete s.forecasts[entityId].forecasts[type];
+			delete s.forecasts[entityId].loading[type];
+			delete s.forecasts[entityId].errors[type];
+			delete s.forecasts[entityId].lastFetched[type];
+		}
+	}));
+	return getForecast(entityId, type);
+}
+/**
+* Refresh forecasts
+*/
+async function refreshForecasts(entityId, types) {
+	setState(produce((s) => {
+		if (s.forecasts[entityId]) for (const type of types) {
+			delete s.forecasts[entityId].forecasts[type];
+			delete s.forecasts[entityId].loading[type];
+			delete s.forecasts[entityId].errors[type];
+			delete s.forecasts[entityId].lastFetched[type];
+		}
+	}));
+	return getForecasts(entityId, types);
+}
+
+//#endregion
+//#region src/index.ts
+const VERSION = "0.1.0";
+
+//#endregion
+export { DOMAINS_USE_LAST_UPDATED, LINE_ATTRIBUTES_TO_KEEP, NEED_ATTRIBUTE_DOMAINS, VERSION, addDebugIncomingMessageListener, addDebugOutgoingMessageListener, appendHistoryPoint, area, areas, authenticateWithOAuth, authenticateWithToken, batchEntityUpdates, batchServiceCalls, buildAreaView, buildDeviceView, buildEntityView, callService, disconnect, entities, entitiesByAreaAndDomain, entitiesWhere, entity, entityIdHistoryNeedsAttributes, fetchEntityHistory, fetchForecast, fetchForecastData, fetchForecasts, fetchHistory, fetchStream, fetchStreamData, getAllEntityViews, getAreaView, getAreaViews, getConnection, getEntityView, getEntityViews, getForecast, getForecasts, getStream, getWebRtcClientConfig, historyStateToTimeline, initConnection, isAuthValid, isConnected, isHistoryTracked, refreshAuth, refreshForecast, refreshForecasts, refreshStream, resetStore, searchEntities, sendCommand, sendWebRtcCandidate, setState, startWebRtcSession, state, toggle, trackEntityHistory, turnOff, turnOn, untrackEntityHistory, updateEntity };