@glasshome/sync-layer 0.1.0

package/dist/testing/index.js

@@ -0,0 +1,2047 @@
+import { state } from "../store-B1sbyexX.js";
+import { createDemoFixtures } from "../demo-data-D8JXWRpw.js";
+
+//#region src/testing/mock-behaviors/base.ts
+/**
+* Helper to create a simple state update result
+*/
+function simpleStateUpdate(update) {
+	return { stateUpdate: update };
+}
+/**
+* Helper to merge attributes safely
+*/
+function mergeAttributes(current, updates) {
+	return {
+		...current,
+		...updates
+	};
+}
+
+//#endregion
+//#region src/testing/mock-behaviors/climate.ts
+var ClimateBehavior = class {
+	domain = "climate";
+	handleService(entity, service, serviceData, _context) {
+		switch (service) {
+			case "set_temperature": return this.handleSetTemperature(entity, serviceData);
+			case "set_hvac_mode": return simpleStateUpdate({ state: serviceData?.hvac_mode ?? entity.state });
+			case "set_preset_mode": return simpleStateUpdate({ attributes: mergeAttributes(entity.attributes, { preset_mode: serviceData?.preset_mode }) });
+			case "set_fan_mode": return simpleStateUpdate({ attributes: mergeAttributes(entity.attributes, { fan_mode: serviceData?.fan_mode }) });
+			case "set_humidity": return simpleStateUpdate({ attributes: mergeAttributes(entity.attributes, { humidity: serviceData?.humidity }) });
+			case "set_swing_mode": return simpleStateUpdate({ attributes: mergeAttributes(entity.attributes, { swing_mode: serviceData?.swing_mode }) });
+			case "turn_on": return simpleStateUpdate({ state: entity.attributes.last_hvac_mode || "heat" });
+			case "turn_off": return simpleStateUpdate({ state: "off" });
+			default: return { stateUpdate: null };
+		}
+	}
+	handleSetTemperature(entity, serviceData) {
+		const attributeUpdates = {};
+		if (serviceData?.temperature !== void 0) attributeUpdates.temperature = serviceData.temperature;
+		if (serviceData?.target_temp_high !== void 0) attributeUpdates.target_temp_high = serviceData.target_temp_high;
+		if (serviceData?.target_temp_low !== void 0) attributeUpdates.target_temp_low = serviceData.target_temp_low;
+		const stateUpdate = { attributes: mergeAttributes(entity.attributes, attributeUpdates) };
+		if (serviceData?.hvac_mode !== void 0) stateUpdate.state = serviceData.hvac_mode;
+		return simpleStateUpdate(stateUpdate);
+	}
+};
+
+//#endregion
+//#region src/testing/mock-behaviors/cover.ts
+var CoverBehavior = class {
+	domain = "cover";
+	handleService(entity, service, serviceData, _context) {
+		switch (service) {
+			case "open_cover": return simpleStateUpdate({
+				state: "open",
+				attributes: mergeAttributes(entity.attributes, { current_position: 100 })
+			});
+			case "close_cover": return simpleStateUpdate({
+				state: "closed",
+				attributes: mergeAttributes(entity.attributes, { current_position: 0 })
+			});
+			case "stop_cover": return simpleStateUpdate({ state: entity.state === "opening" || entity.state === "closing" ? "open" : entity.state });
+			case "set_cover_position": {
+				const position = serviceData?.position ?? 50;
+				return simpleStateUpdate({
+					state: position === 0 ? "closed" : "open",
+					attributes: mergeAttributes(entity.attributes, { current_position: position })
+				});
+			}
+			case "open_cover_tilt": return simpleStateUpdate({ attributes: mergeAttributes(entity.attributes, { current_tilt_position: 100 }) });
+			case "close_cover_tilt": return simpleStateUpdate({ attributes: mergeAttributes(entity.attributes, { current_tilt_position: 0 }) });
+			case "set_cover_tilt_position": {
+				const tiltPosition = serviceData?.tilt_position ?? 50;
+				return simpleStateUpdate({ attributes: mergeAttributes(entity.attributes, { current_tilt_position: tiltPosition }) });
+			}
+			case "toggle": return simpleStateUpdate({
+				state: entity.state === "closed" ? "open" : "closed",
+				attributes: mergeAttributes(entity.attributes, { current_position: entity.state === "closed" ? 100 : 0 })
+			});
+			default: return { stateUpdate: null };
+		}
+	}
+};
+
+//#endregion
+//#region src/testing/mock-behaviors/light.ts
+var LightBehavior = class {
+	domain = "light";
+	handleService(entity, service, serviceData, _context) {
+		switch (service) {
+			case "turn_on": return this.handleTurnOn(entity, serviceData);
+			case "turn_off": return this.handleTurnOff(entity, serviceData);
+			case "toggle": return this.handleToggle(entity, serviceData);
+			default: return { stateUpdate: null };
+		}
+	}
+	handleTurnOn(entity, serviceData) {
+		const attributeUpdates = {};
+		if (serviceData?.brightness_pct !== void 0) {
+			const brightnessPct = Math.max(0, Math.min(100, serviceData.brightness_pct));
+			attributeUpdates.brightness = Math.round(brightnessPct / 100 * 255);
+		}
+		if (serviceData?.brightness_step_pct !== void 0) {
+			const currentBrightness = entity.attributes.brightness ?? 255;
+			const currentBrightnessPct = currentBrightness / 255 * 100;
+			const newBrightnessPct = Math.max(0, Math.min(100, currentBrightnessPct + serviceData.brightness_step_pct));
+			attributeUpdates.brightness = Math.round(newBrightnessPct / 100 * 255);
+		}
+		if (serviceData?.rgb_color !== void 0) {
+			let rgbArray = [
+				255,
+				255,
+				255
+			];
+			if (typeof serviceData.rgb_color === "string") {
+				const parts = serviceData.rgb_color.split(",").map((s) => Number.parseInt(s.trim(), 10));
+				if (parts.length === 3 && parts.every((n) => !Number.isNaN(n))) {
+					const r = parts[0];
+					const g = parts[1];
+					const b = parts[2];
+					if (r !== void 0 && g !== void 0 && b !== void 0) rgbArray = [
+						r,
+						g,
+						b
+					];
+				}
+			} else {
+				const rgb = serviceData.rgb_color;
+				if (Array.isArray(rgb) && rgb.length === 3) {
+					const r = rgb[0];
+					const g = rgb[1];
+					const b = rgb[2];
+					if (typeof r === "number" && typeof g === "number" && typeof b === "number" && !Number.isNaN(r) && !Number.isNaN(g) && !Number.isNaN(b)) rgbArray = [
+						r,
+						g,
+						b
+					];
+				}
+			}
+			attributeUpdates.rgb_color = rgbArray;
+			attributeUpdates.color_temp = void 0;
+			attributeUpdates.color_temp_kelvin = void 0;
+			attributeUpdates.hs_color = void 0;
+			attributeUpdates.xy_color = void 0;
+		}
+		if (serviceData?.color_temp_kelvin !== void 0) {
+			const kelvin = typeof serviceData.color_temp_kelvin === "string" ? Number.parseInt(serviceData.color_temp_kelvin, 10) : serviceData.color_temp_kelvin;
+			if (typeof kelvin === "number" && !Number.isNaN(kelvin)) {
+				attributeUpdates.color_temp_kelvin = kelvin;
+				attributeUpdates.rgb_color = void 0;
+				attributeUpdates.hs_color = void 0;
+				attributeUpdates.xy_color = void 0;
+			}
+		}
+		if (serviceData?.transition !== void 0) attributeUpdates.transition = serviceData.transition;
+		if (serviceData?.effect !== void 0) attributeUpdates.effect = serviceData.effect;
+		return simpleStateUpdate({
+			state: "on",
+			attributes: mergeAttributes(entity.attributes, attributeUpdates)
+		});
+	}
+	handleTurnOff(entity, serviceData) {
+		const attributeUpdates = {};
+		if (serviceData?.transition !== void 0) attributeUpdates.transition = serviceData.transition;
+		return simpleStateUpdate({
+			state: "off",
+			attributes: mergeAttributes(entity.attributes, attributeUpdates)
+		});
+	}
+	handleToggle(entity, serviceData) {
+		const newState = entity.state === "on" ? "off" : "on";
+		const attributeUpdates = {};
+		if (newState === "on" && serviceData) {
+			if (serviceData.brightness_pct !== void 0) {
+				const brightnessPct = Math.max(0, Math.min(100, serviceData.brightness_pct));
+				attributeUpdates.brightness = Math.round(brightnessPct / 100 * 255);
+			} else if (entity.attributes.brightness) attributeUpdates.brightness = entity.attributes.brightness;
+			if (serviceData.rgb_color !== void 0) {
+				let rgbArray = [
+					255,
+					255,
+					255
+				];
+				if (typeof serviceData.rgb_color === "string") {
+					const parts = serviceData.rgb_color.split(",").map((s) => Number.parseInt(s.trim(), 10));
+					if (parts.length === 3 && parts.every((n) => !Number.isNaN(n))) {
+						const r = parts[0];
+						const g = parts[1];
+						const b = parts[2];
+						if (r !== void 0 && g !== void 0 && b !== void 0) rgbArray = [
+							r,
+							g,
+							b
+						];
+					}
+				} else {
+					const rgb = serviceData.rgb_color;
+					if (Array.isArray(rgb) && rgb.length === 3) {
+						const r = rgb[0];
+						const g = rgb[1];
+						const b = rgb[2];
+						if (typeof r === "number" && typeof g === "number" && typeof b === "number" && !Number.isNaN(r) && !Number.isNaN(g) && !Number.isNaN(b)) rgbArray = [
+							r,
+							g,
+							b
+						];
+					}
+				}
+				attributeUpdates.rgb_color = rgbArray;
+				attributeUpdates.color_temp_kelvin = void 0;
+				attributeUpdates.hs_color = void 0;
+				attributeUpdates.xy_color = void 0;
+			}
+			if (serviceData.color_temp_kelvin !== void 0) {
+				const kelvin = typeof serviceData.color_temp_kelvin === "string" ? Number.parseInt(serviceData.color_temp_kelvin, 10) : serviceData.color_temp_kelvin;
+				if (typeof kelvin === "number" && !Number.isNaN(kelvin)) {
+					attributeUpdates.color_temp_kelvin = kelvin;
+					attributeUpdates.rgb_color = void 0;
+					attributeUpdates.hs_color = void 0;
+					attributeUpdates.xy_color = void 0;
+				}
+			}
+			if (serviceData.effect !== void 0) attributeUpdates.effect = serviceData.effect;
+			if (serviceData.transition !== void 0) attributeUpdates.transition = serviceData.transition;
+		}
+		return simpleStateUpdate({
+			state: newState,
+			attributes: Object.keys(attributeUpdates).length > 0 ? mergeAttributes(entity.attributes, attributeUpdates) : entity.attributes
+		});
+	}
+};
+
+//#endregion
+//#region src/testing/mock-behaviors/lock.ts
+var LockBehavior = class {
+	domain = "lock";
+	handleService(entity, service, _serviceData, _context) {
+		if (entity.state === "unavailable" || entity.state === "unknown") return { stateUpdate: null };
+		switch (service) {
+			case "lock": return this.handleLock(entity);
+			case "unlock": return this.handleUnlock(entity);
+			case "open": return this.handleOpen(entity);
+			default: return { stateUpdate: null };
+		}
+	}
+	handleLock(entity) {
+		if (entity.state === "locked") return { stateUpdate: null };
+		if (entity.state === "jammed") return { stateUpdate: null };
+		return {
+			stateUpdate: { state: "locking" },
+			additionalActions: [{
+				delay: 500,
+				update: { state: "locked" }
+			}]
+		};
+	}
+	handleUnlock(entity) {
+		if (entity.state === "unlocked") return { stateUpdate: null };
+		if (entity.state === "jammed") return { stateUpdate: null };
+		return {
+			stateUpdate: { state: "unlocking" },
+			additionalActions: [{
+				delay: 500,
+				update: { state: "unlocked" }
+			}]
+		};
+	}
+	handleOpen(entity) {
+		if (entity.state === "unlocked") return { stateUpdate: null };
+		if (entity.state === "jammed") return { stateUpdate: null };
+		return {
+			stateUpdate: { state: "opening" },
+			additionalActions: [{
+				delay: 500,
+				update: { state: "unlocked" }
+			}]
+		};
+	}
+};
+
+//#endregion
+//#region src/testing/mock-behaviors/media_player.ts
+/**
+* Example album covers for mock media players
+* Using placeholder image services that provide nice album art
+*/
+const EXAMPLE_ALBUM_COVERS = [
+	"https://picsum.photos/seed/album8/300/300",
+	"https://picsum.photos/seed/album2/300/300",
+	"https://picsum.photos/seed/album3/300/300",
+	"https://picsum.photos/seed/album4/300/300",
+	"https://picsum.photos/seed/album5/300/300"
+];
+/**
+* Example tracks for mock media players
+*/
+const EXAMPLE_TRACKS = [
+	{
+		title: "Midnight Horizons",
+		artist: "Synthetic Dreams",
+		album: "Neon Nights",
+		duration: 245
+	},
+	{
+		title: "Electric Pulse",
+		artist: "Digital Waves",
+		album: "Synth Collection",
+		duration: 198
+	},
+	{
+		title: "Cosmic Journey",
+		artist: "Space Echo",
+		album: "Galaxy Sounds",
+		duration: 312
+	},
+	{
+		title: "Urban Nights",
+		artist: "City Lights",
+		album: "Metropolitan",
+		duration: 267
+	},
+	{
+		title: "Ocean Breeze",
+		artist: "Coastal Vibes",
+		album: "Beach Sessions",
+		duration: 189
+	}
+];
+let currentTrackIndex = 0;
+function getNextTrack() {
+	const track = EXAMPLE_TRACKS[currentTrackIndex % EXAMPLE_TRACKS.length];
+	currentTrackIndex++;
+	return track;
+}
+function getCurrentTrack() {
+	return EXAMPLE_TRACKS[currentTrackIndex % EXAMPLE_TRACKS.length];
+}
+function getAlbumCover(trackIndex) {
+	return EXAMPLE_ALBUM_COVERS[trackIndex % EXAMPLE_ALBUM_COVERS.length];
+}
+var MediaPlayerBehavior = class {
+	domain = "media_player";
+	handleService(entity, service, serviceData, _context) {
+		switch (service) {
+			case "media_play": return this.handlePlay(entity);
+			case "media_pause": return this.handlePause(entity);
+			case "media_play_pause": return this.handlePlayPause(entity);
+			case "media_stop": return this.handleStop(entity);
+			case "media_next_track": return this.handleNextTrack(entity);
+			case "media_previous_track": return this.handlePreviousTrack(entity);
+			case "media_seek": return this.handleSeek(entity, serviceData);
+			case "volume_up": return this.handleVolumeUp(entity);
+			case "volume_down": return this.handleVolumeDown(entity);
+			case "set_volume_level": return this.handleSetVolumeLevel(entity, serviceData);
+			case "mute_volume": return this.handleMuteVolume(entity, serviceData);
+			case "turn_on": return this.handleTurnOn(entity);
+			case "turn_off": return this.handleTurnOff(entity);
+			case "toggle": return this.handleToggle(entity);
+			default: return { stateUpdate: null };
+		}
+	}
+	handlePlay(entity) {
+		const attributeUpdates = {};
+		if (!entity.attributes.media_title) {
+			const track = getCurrentTrack();
+			attributeUpdates.media_title = track.title;
+			attributeUpdates.media_artist = track.artist;
+			attributeUpdates.media_album_name = track.album;
+			attributeUpdates.media_duration = track.duration;
+			attributeUpdates.media_position = 0;
+			attributeUpdates.entity_picture = getAlbumCover(currentTrackIndex - 1);
+		}
+		if (entity.state === "paused" && entity.attributes.media_position) attributeUpdates.media_position = entity.attributes.media_position;
+		return simpleStateUpdate({
+			state: "playing",
+			attributes: mergeAttributes(entity.attributes, attributeUpdates)
+		});
+	}
+	handlePause(entity) {
+		return simpleStateUpdate({
+			state: "paused",
+			attributes: entity.attributes
+		});
+	}
+	handlePlayPause(entity) {
+		if (entity.state === "playing") return this.handlePause(entity);
+		return this.handlePlay(entity);
+	}
+	handleStop(entity) {
+		return simpleStateUpdate({
+			state: "idle",
+			attributes: mergeAttributes(entity.attributes, { media_position: 0 })
+		});
+	}
+	handleNextTrack(entity) {
+		const track = getNextTrack();
+		const trackIndex = currentTrackIndex - 1;
+		return simpleStateUpdate({
+			state: entity.state === "playing" ? "playing" : entity.state,
+			attributes: mergeAttributes(entity.attributes, {
+				media_title: track.title,
+				media_artist: track.artist,
+				media_album_name: track.album,
+				media_duration: track.duration,
+				media_position: 0,
+				entity_picture: getAlbumCover(trackIndex)
+			})
+		});
+	}
+	handlePreviousTrack(entity) {
+		currentTrackIndex = Math.max(0, currentTrackIndex - 2);
+		const track = getNextTrack();
+		const trackIndex = currentTrackIndex - 1;
+		return simpleStateUpdate({
+			state: entity.state === "playing" ? "playing" : entity.state,
+			attributes: mergeAttributes(entity.attributes, {
+				media_title: track.title,
+				media_artist: track.artist,
+				media_album_name: track.album,
+				media_duration: track.duration,
+				media_position: 0,
+				entity_picture: getAlbumCover(trackIndex)
+			})
+		});
+	}
+	handleSeek(entity, serviceData) {
+		const seekPosition = serviceData?.seek_position;
+		if (seekPosition === void 0) return { stateUpdate: null };
+		const duration = entity.attributes.media_duration ?? 0;
+		const newPosition = Math.max(0, Math.min(duration, seekPosition));
+		return simpleStateUpdate({ attributes: mergeAttributes(entity.attributes, { media_position: newPosition }) });
+	}
+	handleVolumeUp(entity) {
+		const currentVolume = entity.attributes.volume_level ?? 0;
+		const newVolume = Math.min(1, currentVolume + .1);
+		return simpleStateUpdate({ attributes: mergeAttributes(entity.attributes, {
+			volume_level: newVolume,
+			is_volume_muted: false
+		}) });
+	}
+	handleVolumeDown(entity) {
+		const currentVolume = entity.attributes.volume_level ?? 0;
+		const newVolume = Math.max(0, currentVolume - .1);
+		return simpleStateUpdate({ attributes: mergeAttributes(entity.attributes, {
+			volume_level: newVolume,
+			is_volume_muted: newVolume === 0
+		}) });
+	}
+	handleSetVolumeLevel(entity, serviceData) {
+		const volumeLevel = serviceData?.volume_level;
+		if (volumeLevel === void 0) return { stateUpdate: null };
+		const newVolume = Math.max(0, Math.min(1, volumeLevel));
+		return simpleStateUpdate({ attributes: mergeAttributes(entity.attributes, {
+			volume_level: newVolume,
+			is_volume_muted: newVolume === 0
+		}) });
+	}
+	handleMuteVolume(entity, serviceData) {
+		const isMuted = serviceData?.is_volume_muted ?? !entity.attributes.is_volume_muted;
+		return simpleStateUpdate({ attributes: mergeAttributes(entity.attributes, { is_volume_muted: isMuted }) });
+	}
+	handleTurnOn(entity) {
+		const attributeUpdates = {};
+		if (!entity.attributes.media_title) {
+			const track = getCurrentTrack();
+			attributeUpdates.media_title = track.title;
+			attributeUpdates.media_artist = track.artist;
+			attributeUpdates.media_album_name = track.album;
+			attributeUpdates.media_duration = track.duration;
+			attributeUpdates.media_position = 0;
+			attributeUpdates.entity_picture = getAlbumCover(currentTrackIndex - 1);
+		}
+		return simpleStateUpdate({
+			state: "playing",
+			attributes: mergeAttributes(entity.attributes, attributeUpdates)
+		});
+	}
+	handleTurnOff(entity) {
+		return simpleStateUpdate({
+			state: "off",
+			attributes: mergeAttributes(entity.attributes, { media_position: 0 })
+		});
+	}
+	handleToggle(entity) {
+		if (entity.state === "off") return this.handleTurnOn(entity);
+		return this.handleTurnOff(entity);
+	}
+};
+
+//#endregion
+//#region src/testing/mock-behaviors/switch.ts
+var SwitchBehavior = class {
+	domain = "switch";
+	handleService(entity, service, _serviceData, _context) {
+		switch (service) {
+			case "turn_on": return simpleStateUpdate({ state: "on" });
+			case "turn_off": return simpleStateUpdate({ state: "off" });
+			case "toggle": return simpleStateUpdate({ state: entity.state === "on" ? "off" : "on" });
+			default: return { stateUpdate: null };
+		}
+	}
+};
+
+//#endregion
+//#region src/testing/mock-behaviors/registry.ts
+/**
+* Central registry of all domain behavior handlers
+*/
+var BehaviorRegistry = class {
+	handlers = /* @__PURE__ */ new Map();
+	constructor() {
+		this.registerDefaultHandlers();
+	}
+	/**
+	* Register all built-in domain handlers
+	*/
+	registerDefaultHandlers() {
+		this.register(new LightBehavior());
+		this.register(new SwitchBehavior());
+		this.register(new CoverBehavior());
+		this.register(new ClimateBehavior());
+		this.register(new MediaPlayerBehavior());
+		this.register(new LockBehavior());
+	}
+	/**
+	* Register a domain behavior handler
+	*/
+	register(handler) {
+		this.handlers.set(handler.domain, handler);
+	}
+	/**
+	* Get handler for a specific domain
+	*/
+	getHandler(domain) {
+		return this.handlers.get(domain);
+	}
+	/**
+	* Check if a domain has a registered handler
+	*/
+	hasHandler(domain) {
+		return this.handlers.has(domain);
+	}
+	/**
+	* Get all registered domains
+	*/
+	getRegisteredDomains() {
+		return Array.from(this.handlers.keys());
+	}
+	/**
+	* Clear all handlers (useful for testing)
+	*/
+	clear() {
+		this.handlers.clear();
+	}
+	/**
+	* Reset to default handlers
+	*/
+	reset() {
+		this.clear();
+		this.registerDefaultHandlers();
+	}
+};
+/**
+* Global behavior registry instance
+*/
+const behaviorRegistry = new BehaviorRegistry();
+/**
+* Get behavior handler for a domain
+*/
+function getBehaviorHandler(domain) {
+	return behaviorRegistry.getHandler(domain);
+}
+
+//#endregion
+//#region src/testing/mock.ts
+const ERROR_CODES = {
+	UNKNOWN_ERROR: "unknown_error",
+	INVALID_FORMAT: "invalid_format",
+	NOT_FOUND: "not_found",
+	UNAUTHORIZED: "unauthorized",
+	HOME_ASSISTANT_ERROR: "home_assistant_error"
+};
+/**
+* Mock WebSocket connection for testing
+*
+* Simulates a Home Assistant WebSocket connection without requiring
+* a real backend.
+*
+* MockConnection does NOT manipulate the store directly.
+* SyncLayer loads fixtures via `getFixtures()` and manages state itself.
+*/
+var MockConnection = class {
+	connected = false;
+	authState = "pending";
+	messageHandlers = [];
+	eventSubscriptions = /* @__PURE__ */ new Map();
+	subscriptions = /* @__PURE__ */ new Map();
+	latency;
+	fixtures;
+	mockVersion = "2024.11.0";
+	messageIdCounter = 1;
+	autoReact;
+	reactionDelay;
+	serviceCalls = [];
+	sentCommands = [];
+	constructor(fixtures, latency = 0, options) {
+		this.fixtures = fixtures;
+		this.latency = latency;
+		this.autoReact = options?.autoReact ?? true;
+		this.reactionDelay = options?.reactionDelay ?? 0;
+	}
+	/**
+	* Get connected state
+	*/
+	get connected$() {
+		return this.connected;
+	}
+	/**
+	* Simulate connection - sends auth_required per WebSocket spec
+	*/
+	async connect() {
+		await this.delay(this.latency);
+		this.connected = true;
+		this.authState = "pending";
+		this.sendAuthRequired();
+	}
+	/**
+	* Register message handler for auth and other server messages
+	*/
+	addEventListener(handler) {
+		this.messageHandlers.push(handler);
+		return () => {
+			const index = this.messageHandlers.indexOf(handler);
+			if (index > -1) this.messageHandlers.splice(index, 1);
+		};
+	}
+	/**
+	* Handle authentication message (from client)
+	*/
+	async authenticate(_accessToken) {
+		if (!this.connected) throw new Error("Not connected");
+		if (this.authState !== "pending") throw new Error("Authentication already completed");
+		await this.delay(this.latency);
+		const isValid = true;
+		if (isValid) {
+			this.authState = "authenticated";
+			const message = {
+				type: "auth_ok",
+				ha_version: this.mockVersion
+			};
+			for (const handler of this.messageHandlers) handler(message);
+		} else {
+			this.authState = "failed";
+			const message = {
+				type: "auth_invalid",
+				message: "Invalid access token"
+			};
+			for (const handler of this.messageHandlers) handler(message);
+			this.disconnect();
+		}
+	}
+	/**
+	* Send auth_required message (server-initiated)
+	*/
+	sendAuthRequired() {
+		const message = {
+			type: "auth_required",
+			ha_version: this.mockVersion
+		};
+		for (const handler of this.messageHandlers) handler(message);
+	}
+	/**
+	* Simulate disconnection
+	*/
+	disconnect() {
+		this.connected = false;
+		this.authState = "pending";
+		this.messageHandlers = [];
+		this.eventSubscriptions.clear();
+		this.subscriptions.clear();
+	}
+	/**
+	* Close connection (alias for disconnect for compatibility)
+	*/
+	close() {
+		this.disconnect();
+	}
+	/**
+	* Send a message (mock implementation)
+	*/
+	async sendMessage(message) {
+		if (!this.connected) throw new Error("Not connected");
+		await this.delay(this.latency);
+		if (message.type === "get_states") this.sendResponse(message.id, Object.values(this.fixtures.entities));
+		else if (message.type === "call_service") this.sendResponse(message.id, { success: true });
+	}
+	/**
+	* Call a service (mock implementation)
+	*/
+	async callService(domain, service, serviceData, target) {
+		if (!this.connected) throw new Error("Not connected");
+		if (this.authState !== "authenticated") throw new Error("Not authenticated");
+		this.serviceCalls.push({
+			domain,
+			service,
+			serviceData,
+			target,
+			timestamp: Date.now()
+		});
+		return await this.sendMessagePromise({
+			type: "call_service",
+			domain,
+			service,
+			service_data: serviceData || {},
+			target: target || {}
+		});
+	}
+	/**
+	* Send a message and wait for response - returns proper WebSocket result format
+	*/
+	async sendMessagePromise(message) {
+		if (!this.connected) throw new Error("Not connected");
+		if (this.authState !== "authenticated") throw new Error("Not authenticated");
+		if (!message.type || typeof message.type !== "string") throw new Error("Invalid message: type must be a string");
+		if (!message.id || typeof message.id !== "number" || message.id < 0) message.id = this.messageIdCounter++;
+		this.sentCommands.push({
+			type: message.type,
+			data: message,
+			timestamp: Date.now()
+		});
+		await this.delay(this.latency);
+		try {
+			const result = this.handleMessage(message);
+			const response = {
+				id: message.id,
+				type: "result",
+				success: true,
+				result
+			};
+			for (const handler of this.messageHandlers) handler(response);
+			return result;
+		} catch (error) {
+			const code = error.code || ERROR_CODES.UNKNOWN_ERROR;
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			const errorResponse = {
+				id: message.id,
+				type: "result",
+				success: false,
+				error: {
+					code,
+					message: errorMessage
+				}
+			};
+			for (const handler of this.messageHandlers) handler(errorResponse);
+			throw error;
+		}
+	}
+	/**
+	* Handle different message types and return appropriate data
+	*/
+	handleMessage(message) {
+		switch (message.type) {
+			case "get_states": return Object.values(this.fixtures.entities);
+			case "config/entity_registry/list": return this.fixtures.entityRegistry;
+			case "config/entity_registry/get": {
+				const entityId = message.entity_id;
+				const entry = this.fixtures.entityRegistry.find((e) => e.entity_id === entityId);
+				if (!entry) {
+					const error = new Error("Entity registry entry not found");
+					error.code = ERROR_CODES.NOT_FOUND;
+					throw error;
+				}
+				return entry;
+			}
+			case "config/device_registry/list": return this.fixtures.deviceRegistry;
+			case "config/area_registry/list": return this.fixtures.areaRegistry;
+			case "config/floor_registry/list": return this.fixtures.floorRegistry;
+			case "config/label_registry/list": return this.fixtures.labelRegistry;
+			case "config/entity_registry/update": return this.handleEntityUpdate(message);
+			case "call_service": return this.handleServiceCall(message);
+			case "subscribe_events": return this.handleSubscribeEvents(message);
+			case "unsubscribe_events": return this.handleUnsubscribeEvents(message);
+			case "ping": return {};
+			case "supported_features": return {};
+			case "get_config": return {
+				latitude: 0,
+				longitude: 0,
+				elevation: 0,
+				unit_system: {
+					length: "km",
+					mass: "kg",
+					temperature: "°C",
+					volume: "L"
+				},
+				location_name: "Mock Home",
+				time_zone: "UTC",
+				components: [],
+				config_dir: "/config",
+				whitelist_external_dirs: [],
+				allowlist_external_dirs: [],
+				allowlist_external_urls: [],
+				version: this.mockVersion,
+				config_source: "default_config",
+				safe_mode: false,
+				state: "RUNNING",
+				external_url: null,
+				internal_url: null,
+				currency: "USD",
+				country: null,
+				language: "en"
+			};
+			case "get_services": return {};
+			case "fire_event": {
+				this.emitEvent({
+					event_type: message.event_type,
+					data: message.event_data || {},
+					origin: "LOCAL",
+					time_fired: (/* @__PURE__ */ new Date()).toISOString(),
+					context: {
+						id: this.generateId(),
+						parent_id: null,
+						user_id: null
+					}
+				});
+				return {};
+			}
+			case "history/history_during_period": {
+				const entityIds = message.entity_ids || [];
+				const result = {};
+				if (entityIds.length === 0) return {};
+				const startTime = message.start_time ? new Date(message.start_time).getTime() / 1e3 : void 0;
+				const endTime = message.end_time ? new Date(message.end_time).getTime() / 1e3 : void 0;
+				for (const entityId of entityIds) if (this.fixtures.history && this.fixtures.history[entityId]) {
+					let historyData = this.fixtures.history[entityId];
+					if (startTime !== void 0 || endTime !== void 0) historyData = historyData.filter((state$1) => {
+						if (startTime !== void 0 && state$1.lu < startTime) return false;
+						if (endTime !== void 0 && state$1.lu > endTime) return false;
+						return true;
+					});
+					if (historyData.length > 0) result[entityId] = historyData;
+				} else {
+					const entity = this.fixtures.entities[entityId];
+					if (entity) result[entityId] = [{
+						s: entity.state,
+						lu: Math.floor(Date.now() / 1e3),
+						lc: Math.floor(Date.now() / 1e3),
+						a: entity.attributes || {}
+					}];
+				}
+				return result;
+			}
+			case "camera/stream": {
+				const entityId = message.entity_id;
+				const entity = this.fixtures.entities[entityId];
+				if (!entity) {
+					const error = new Error(`Camera entity not found: ${entityId}`);
+					error.code = ERROR_CODES.NOT_FOUND;
+					throw error;
+				}
+				return { url: `http://homeassistant.local:8123/api/camera_proxy_stream/${entityId}` };
+			}
+			default: {
+				const error = new Error(`Unhandled message type: ${message.type}`);
+				error.code = ERROR_CODES.INVALID_FORMAT;
+				throw error;
+			}
+		}
+	}
+	/**
+	* Subscribe to events
+	*/
+	subscribeEvents(callback, eventType) {
+		if (!this.connected) return Promise.reject(new Error("Not connected"));
+		const handlers = this.eventSubscriptions.get(eventType || "*") || [];
+		handlers.push(callback);
+		this.eventSubscriptions.set(eventType || "*", handlers);
+		return Promise.resolve(() => {
+			const handlers$1 = this.eventSubscriptions.get(eventType || "*") || [];
+			const index = handlers$1.indexOf(callback);
+			if (index > -1) handlers$1.splice(index, 1);
+		});
+	}
+	/**
+	* Subscribe to WebSocket messages
+	*
+	* Used for subscribing to command responses like history/stream
+	*
+	* @param callback - Callback function for messages
+	* @param message - Message to subscribe to
+	* @returns Promise resolving to unsubscribe function
+	*/
+	async subscribeMessage(callback, message) {
+		if (!this.connected) throw new Error("Not connected");
+		if (this.authState !== "authenticated") throw new Error("Not authenticated");
+		const subscriptionId = this.messageIdCounter++;
+		this.subscriptions.set(subscriptionId, {});
+		if (message.type === "subscribe_entities") {
+			const additions = {};
+			for (const [entityId, entity] of Object.entries(this.fixtures.entities)) additions[entityId] = {
+				s: entity.state,
+				a: entity.attributes || {},
+				c: entity.context || {
+					id: "",
+					parent_id: null,
+					user_id: null
+				},
+				lc: Math.floor(new Date(entity.last_changed || Date.now()).getTime() / 1e3),
+				lu: Math.floor(new Date(entity.last_updated || Date.now()).getTime() / 1e3)
+			};
+			if (Object.keys(additions).length > 0) callback({ a: additions });
+			this.subscriptions.set(subscriptionId, {
+				callback,
+				isEntitySubscription: true
+			});
+			return async () => {
+				this.subscriptions.delete(subscriptionId);
+			};
+		}
+		if (message.type === "weather/subscribe_forecast") {
+			const entityId = message.entity_id;
+			const forecastType = message.forecast_type || "hourly";
+			if (!entityId) throw new Error("Entity ID required for forecast subscription");
+			if (!this.fixtures.entities[entityId]) throw new Error(`Weather entity not found: ${entityId}`);
+			const forecast = this.fixtures.forecasts?.[entityId]?.[forecastType] || [];
+			setImmediate(() => {
+				const forecastEvent = {
+					type: forecastType,
+					forecast: forecast.length > 0 ? forecast : null
+				};
+				callback(forecastEvent);
+			});
+			return async () => {
+				this.subscriptions.delete(subscriptionId);
+			};
+		}
+		if (message.type === "history/stream") {
+			const entityIds = message.entity_ids || [];
+			const startTime = message.start_time;
+			const endTime = message.end_time;
+			const startTimeSeconds = startTime ? Math.floor(new Date(startTime).getTime() / 1e3) : void 0;
+			const endTimeSeconds = endTime ? Math.floor(new Date(endTime).getTime() / 1e3) : void 0;
+			const initialHistory = {};
+			for (const entityId of entityIds) if (this.fixtures.history && this.fixtures.history[entityId]) {
+				let historyData = this.fixtures.history[entityId];
+				if (startTimeSeconds !== void 0 || endTimeSeconds !== void 0) historyData = historyData.filter((state$1) => {
+					if (startTimeSeconds !== void 0 && state$1.lu < startTimeSeconds) return false;
+					if (endTimeSeconds !== void 0 && state$1.lu > endTimeSeconds) return false;
+					return true;
+				});
+				if (historyData.length > 0) initialHistory[entityId] = historyData;
+			} else {
+				const entity = this.fixtures.entities[entityId];
+				if (entity) initialHistory[entityId] = [{
+					s: entity.state,
+					lu: Math.floor(Date.now() / 1e3),
+					lc: Math.floor(Date.now() / 1e3),
+					a: entity.attributes || {}
+				}];
+			}
+			await this.delay(this.latency);
+			const initialMessage = {
+				states: initialHistory,
+				start_time: startTimeSeconds,
+				end_time: endTimeSeconds
+			};
+			callback(initialMessage);
+			await this.delay(this.latency);
+			const emptyMessage = { states: {} };
+			callback(emptyMessage);
+		} else {
+			await this.delay(this.latency);
+			const result = this.handleMessage(message);
+			callback(result);
+		}
+		return async () => {
+			this.subscriptions.delete(subscriptionId);
+		};
+	}
+	/**
+	* Simulate state change
+	*/
+	setState(entityId, updates) {
+		const current = this.fixtures.entities[entityId];
+		if (!current) throw new Error(`Entity not found: ${entityId}`);
+		const newState = {
+			...current,
+			...updates,
+			last_changed: (/* @__PURE__ */ new Date()).toISOString(),
+			last_updated: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		this.fixtures.entities[entityId] = newState;
+		for (const [, subscription] of this.subscriptions.entries()) if (subscription.callback && subscription.isEntitySubscription) {
+			const changeMsg = { c: { [entityId]: { "+": {
+				s: newState.state,
+				a: newState.attributes || {},
+				lc: Math.floor(new Date(newState.last_changed || Date.now()).getTime() / 1e3),
+				lu: Math.floor(new Date(newState.last_updated || Date.now()).getTime() / 1e3)
+			} } } };
+			subscription.callback(changeMsg);
+		}
+	}
+	/**
+	* Simulate entity registry update
+	*/
+	updateEntityRegistry(entityId, updates) {
+		const index = this.fixtures.entityRegistry.findIndex((e) => e.entity_id === entityId);
+		if (index === -1) throw new Error(`Entity registry entry not found: ${entityId}`);
+		const updated = {
+			...this.fixtures.entityRegistry[index],
+			...updates
+		};
+		this.fixtures.entityRegistry[index] = updated;
+		this.emitEvent({
+			event_type: "entity_registry_updated",
+			data: {
+				action: "update",
+				entity_id: entityId,
+				changes: updates
+			},
+			origin: "LOCAL",
+			time_fired: (/* @__PURE__ */ new Date()).toISOString(),
+			context: {
+				id: this.generateId(),
+				parent_id: null,
+				user_id: null
+			}
+		});
+	}
+	/**
+	* Simulate area registry update
+	*/
+	updateAreaRegistry(areaId, updates) {
+		const index = this.fixtures.areaRegistry.findIndex((a) => a.id === areaId);
+		if (index === -1) throw new Error(`Area registry entry not found: ${areaId}`);
+		const updated = {
+			...this.fixtures.areaRegistry[index],
+			...updates
+		};
+		this.fixtures.areaRegistry[index] = updated;
+		this.emitEvent({
+			event_type: "area_registry_updated",
+			data: {
+				action: "update",
+				area_id: areaId,
+				changes: updates
+			},
+			origin: "LOCAL",
+			time_fired: (/* @__PURE__ */ new Date()).toISOString(),
+			context: {
+				id: this.generateId(),
+				parent_id: null,
+				user_id: null
+			}
+		});
+	}
+	/**
+	* Simulate device registry update
+	*/
+	updateDeviceRegistry(deviceId, updates) {
+		const index = this.fixtures.deviceRegistry.findIndex((d) => d.id === deviceId);
+		if (index === -1) throw new Error(`Device registry entry not found: ${deviceId}`);
+		const updated = {
+			...this.fixtures.deviceRegistry[index],
+			...updates
+		};
+		this.fixtures.deviceRegistry[index] = updated;
+		this.emitEvent({
+			event_type: "device_registry_updated",
+			data: {
+				action: "update",
+				device_id: deviceId,
+				changes: updates
+			},
+			origin: "LOCAL",
+			time_fired: (/* @__PURE__ */ new Date()).toISOString(),
+			context: {
+				id: this.generateId(),
+				parent_id: null,
+				user_id: null
+			}
+		});
+	}
+	/**
+	* Emit custom event - sends proper WebSocket event messages to subscriptions
+	*/
+	emitEvent(event) {
+		for (const [subscriptionId, subscription] of this.subscriptions.entries()) if (!subscription.eventType || subscription.eventType === event.event_type) {
+			const eventMessage = {
+				id: subscriptionId,
+				type: "event",
+				event
+			};
+			for (const handler of this.messageHandlers) handler(eventMessage);
+		}
+		const specificHandlers = this.eventSubscriptions.get(event.event_type) || [];
+		for (const handler of specificHandlers) handler(event);
+		const wildcardHandlers = this.eventSubscriptions.get("*") || [];
+		for (const handler of wildcardHandlers) handler(event);
+	}
+	/**
+	* Handle subscribe_events command
+	*/
+	handleSubscribeEvents(message) {
+		this.subscriptions.set(message.id, { eventType: message.event_type });
+		return {};
+	}
+	/**
+	* Handle unsubscribe_events command
+	*/
+	handleUnsubscribeEvents(message) {
+		const { subscription } = message;
+		if (!this.subscriptions.has(subscription)) {
+			const error = new Error(`Subscription ${subscription} not found`);
+			error.code = ERROR_CODES.NOT_FOUND;
+			throw error;
+		}
+		this.subscriptions.delete(subscription);
+		return {};
+	}
+	/**
+	* Get current fixtures
+	*
+	* SyncLayer calls this to load fixtures into its store.
+	*/
+	getFixtures() {
+		return { ...this.fixtures };
+	}
+	/**
+	* Load new fixtures
+	*/
+	loadFixtures(fixtures) {
+		this.fixtures = {
+			...this.fixtures,
+			...fixtures
+		};
+	}
+	/**
+	* Clear tracking data
+	*/
+	clearTracking() {
+		this.serviceCalls = [];
+		this.sentCommands = [];
+	}
+	/**
+	* Get last service call
+	*/
+	getLastServiceCall() {
+		return this.serviceCalls[this.serviceCalls.length - 1];
+	}
+	/**
+	* Get last command
+	*/
+	getLastCommand() {
+		return this.sentCommands[this.sentCommands.length - 1];
+	}
+	async delay(ms) {
+		if (ms > 0) return new Promise((resolve) => setTimeout(resolve, ms));
+	}
+	sendResponse(id, result) {
+		for (const handler of this.messageHandlers) handler({
+			id,
+			type: "result",
+			success: true,
+			result
+		});
+	}
+	handleEntityUpdate(message) {
+		const entityId = message.entity_id;
+		const updates = { ...message };
+		delete updates.type;
+		delete updates.entity_id;
+		delete updates.id;
+		const index = this.fixtures.entityRegistry.findIndex((e) => e.entity_id === entityId);
+		if (index === -1) {
+			const error = new Error("Entity registry entry not found");
+			error.code = ERROR_CODES.NOT_FOUND;
+			throw error;
+		}
+		this.updateEntityRegistry(entityId, updates);
+		const updated = this.fixtures.entityRegistry[index];
+		if (!updated) throw new Error("Entity registry entry not found after update");
+		return updated;
+	}
+	handleServiceCall(message) {
+		const { domain, service, service_data, target, return_response } = message;
+		const context = {
+			id: this.generateId(),
+			parent_id: null,
+			user_id: null
+		};
+		if (this.autoReact) setTimeout(() => {
+			this.handleServiceReaction(domain, service, service_data, target, context);
+		}, this.reactionDelay);
+		if (domain === "weather" && service === "get_forecasts" && return_response) {
+			const entityId = target?.entity_id;
+			const forecastType = service_data?.type || "hourly";
+			if (!entityId) {
+				const error = new Error("Entity ID required for forecast");
+				error.code = ERROR_CODES.INVALID_FORMAT;
+				throw error;
+			}
+			if (!this.fixtures.entities[entityId]) {
+				const error = new Error(`Weather entity not found: ${entityId}`);
+				error.code = ERROR_CODES.NOT_FOUND;
+				throw error;
+			}
+			const forecast = this.fixtures.forecasts?.[entityId]?.[forecastType] || [];
+			return {
+				context,
+				response: { [entityId]: { forecast } }
+			};
+		}
+		if (return_response) return {
+			context,
+			response: {}
+		};
+		return { context };
+	}
+	/**
+	* Handle automatic reactions to service calls using behavior handlers
+	*/
+	handleServiceReaction(domain, service, serviceData, target, context) {
+		const entityIds = this.resolveTargetEntities(domain, target);
+		const handler = getBehaviorHandler(domain);
+		if (!handler) return;
+		for (const entityId of entityIds) {
+			const entity = this.fixtures.entities[entityId];
+			if (!entity) continue;
+			try {
+				const result = handler.handleService(entity, service, serviceData, context);
+				if (result.error) {
+					console.warn(`Mock behavior error for ${entityId}.${service}:`, result.error.message);
+					continue;
+				}
+				if (result.stateUpdate) this.setStateWithContext(entityId, result.stateUpdate, context);
+				if (result.additionalActions) for (const action of result.additionalActions) setTimeout(() => {
+					this.setStateWithContext(entityId, action.update, context);
+				}, action.delay);
+			} catch (error) {
+				console.error(`Mock behavior error for ${entityId}:`, error);
+			}
+		}
+	}
+	/**
+	* Resolve target entities from service call target
+	*/
+	resolveTargetEntities(domain, target) {
+		if (!target) return [];
+		const entityIds = [];
+		if (target.entity_id) if (Array.isArray(target.entity_id)) entityIds.push(...target.entity_id);
+		else entityIds.push(target.entity_id);
+		if (target.area_id) {
+			const areaId = target.area_id;
+			for (const entry of this.fixtures.entityRegistry) if (entry.area_id === areaId) {
+				const entity = this.fixtures.entities[entry.entity_id];
+				if (entity && entity.entity_id.startsWith(domain + ".")) entityIds.push(entry.entity_id);
+			}
+		}
+		if (target.device_id) {
+			const deviceId = target.device_id;
+			for (const entry of this.fixtures.entityRegistry) if (entry.device_id === deviceId) {
+				const entity = this.fixtures.entities[entry.entity_id];
+				if (entity && entity.entity_id.startsWith(domain + ".")) entityIds.push(entry.entity_id);
+			}
+		}
+		return entityIds;
+	}
+	/**
+	* Set state with custom context (internal use)
+	*/
+	setStateWithContext(entityId, updates, context) {
+		const current = this.fixtures.entities[entityId];
+		if (!current) throw new Error(`Entity not found: ${entityId}`);
+		const newState = {
+			...current,
+			...updates,
+			last_changed: updates.state !== current.state ? (/* @__PURE__ */ new Date()).toISOString() : current.last_changed,
+			last_updated: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		this.fixtures.entities[entityId] = newState;
+		for (const [, subscription] of this.subscriptions.entries()) if (subscription.isEntitySubscription && subscription.callback) {
+			const changeMsg = { c: { [entityId]: { "+": {
+				s: newState.state,
+				a: newState.attributes || {},
+				lc: Math.floor(new Date(newState.last_changed || Date.now()).getTime() / 1e3),
+				lu: Math.floor(new Date(newState.last_updated || Date.now()).getTime() / 1e3)
+			} } } };
+			subscription.callback(changeMsg);
+		}
+	}
+	/**
+	* Enable/disable automatic reactions
+	*/
+	setAutoReact(enabled) {
+		this.autoReact = enabled;
+	}
+	/**
+	* Set reaction delay (useful for testing timing)
+	*/
+	setReactionDelay(delay$1) {
+		this.reactionDelay = delay$1;
+	}
+	generateId() {
+		return `mock_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+	}
+};
+
+//#endregion
+//#region src/testing/fixtures.ts
+/**
+* Create a mock entity state
+*
+* @param entityId - Entity ID
+* @param overrides - Optional field overrides
+* @returns Mock entity state
+*
+* @example
+* ```typescript
+* const light = createEntity('light.kitchen', {
+*   state: 'on',
+*   attributes: { brightness: 255 },
+* });
+* ```
+*/
+function createEntity(entityId, overrides = {}) {
+	entityId.split(".");
+	return {
+		entity_id: entityId,
+		state: "unknown",
+		attributes: {},
+		last_changed: (/* @__PURE__ */ new Date()).toISOString(),
+		last_updated: (/* @__PURE__ */ new Date()).toISOString(),
+		context: {
+			id: generateId(),
+			parent_id: null,
+			user_id: null
+		},
+		...overrides
+	};
+}
+/**
+* Create a mock entity registry entry
+*
+* @param entityId - Entity ID
+* @param overrides - Optional field overrides
+* @returns Mock registry entry
+*
+* @example
+* ```typescript
+* const entry = createEntityRegistryEntry('light.kitchen', {
+*   name: 'Kitchen Light',
+*   area_id: 'kitchen',
+* });
+* ```
+*/
+function createEntityRegistryEntry(entityId, overrides = {}) {
+	const [, objectId] = entityId.split(".");
+	if (!objectId) throw new Error(`Invalid entity ID: ${entityId}`);
+	return {
+		entity_id: entityId,
+		name: overrides.name || objectId.replace(/_/g, " "),
+		icon: overrides.icon || null,
+		platform: overrides.platform || "mock",
+		area_id: overrides.area_id || null,
+		device_id: overrides.device_id || null,
+		disabled_by: overrides.disabled_by || null,
+		hidden_by: overrides.hidden_by || null,
+		entity_category: overrides.entity_category || null,
+		has_entity_name: overrides.has_entity_name || false,
+		original_name: overrides.original_name || null,
+		unique_id: overrides.unique_id || `mock_${entityId}`,
+		config_entry_id: overrides.config_entry_id || null,
+		labels: overrides.labels || [],
+		translation_key: overrides.translation_key || null,
+		...overrides
+	};
+}
+/**
+* Create a mock area registry entry
+*
+* @param areaId - Area ID
+* @param overrides - Optional field overrides
+* @returns Mock area entry
+*
+* @example
+* ```typescript
+* const area = createArea('kitchen', {
+*   name: 'Kitchen',
+*   floor_id: 'ground_floor',
+* });
+* ```
+*/
+function createArea(areaId, overrides = {}) {
+	return {
+		id: areaId,
+		name: overrides.name || areaId.replace(/_/g, " "),
+		normalized_name: areaId.toLowerCase(),
+		picture: overrides.picture || null,
+		floor_id: overrides.floor_id || null,
+		icon: overrides.icon || null,
+		aliases: overrides.aliases || [],
+		labels: overrides.labels || [],
+		created_at: overrides.created_at || (/* @__PURE__ */ new Date()).toISOString(),
+		modified_at: overrides.modified_at || (/* @__PURE__ */ new Date()).toISOString(),
+		humidity_entity_id: overrides.humidity_entity_id || null,
+		temperature_entity_id: overrides.temperature_entity_id || null,
+		...overrides
+	};
+}
+/**
+* Create a mock device registry entry
+*
+* @param deviceId - Device ID
+* @param overrides - Optional field overrides
+* @returns Mock device entry
+*
+* @example
+* ```typescript
+* const device = createDevice('device_123', {
+*   name: 'Smart Light',
+*   area_id: 'kitchen',
+* });
+* ```
+*/
+function createDevice(deviceId, overrides = {}) {
+	return {
+		id: deviceId,
+		name: overrides.name || "Mock Device",
+		area_id: overrides.area_id || null,
+		name_by_user: overrides.name_by_user || null,
+		disabled_by: overrides.disabled_by || null,
+		configuration_url: overrides.configuration_url || null,
+		manufacturer: overrides.manufacturer || "Mock Manufacturer",
+		model: overrides.model || "Mock Model",
+		sw_version: overrides.sw_version || "1.0.0",
+		hw_version: overrides.hw_version || null,
+		via_device_id: overrides.via_device_id || null,
+		entry_type: overrides.entry_type || null,
+		identifiers: overrides.identifiers || [[deviceId]],
+		connections: overrides.connections || [],
+		config_entries: overrides.config_entries || [],
+		config_entries_subentries: overrides.config_entries_subentries || {},
+		labels: overrides.labels || [],
+		created_at: overrides.created_at || (/* @__PURE__ */ new Date()).toISOString(),
+		modified_at: overrides.modified_at || (/* @__PURE__ */ new Date()).toISOString(),
+		model_id: overrides.model_id || null,
+		primary_config_entry: overrides.primary_config_entry || null,
+		serial_number: overrides.serial_number || null,
+		...overrides
+	};
+}
+/**
+* Create a mock floor registry entry
+*
+* @param floorId - Floor ID
+* @param overrides - Optional field overrides
+* @returns Mock floor entry
+*
+* @example
+* ```typescript
+* const floor = createFloor('ground_floor', {
+*   name: 'Ground Floor',
+*   level: 0,
+* });
+* ```
+*/
+function createFloor(floorId, overrides = {}) {
+	return {
+		floor_id: floorId,
+		name: overrides.name || floorId.replace(/_/g, " "),
+		level: overrides.level || 0,
+		icon: overrides.icon || null,
+		aliases: overrides.aliases || [],
+		...overrides
+	};
+}
+/**
+* Create a mock label registry entry
+*
+* @param labelId - Label ID
+* @param overrides - Optional field overrides
+* @returns Mock label entry
+*
+* @example
+* ```typescript
+* const label = createLabel('important', {
+*   name: 'Important',
+*   color: 'red',
+* });
+* ```
+*/
+function createLabel(labelId, overrides = {}) {
+	return {
+		label_id: labelId,
+		name: overrides.name || labelId.replace(/_/g, " "),
+		color: overrides.color || null,
+		icon: overrides.icon || null,
+		description: overrides.description || null,
+		...overrides
+	};
+}
+/**
+* Create a basic fixture set for testing
+*
+* @returns Complete fixture set with basic entities
+*
+* @example
+* ```typescript
+* const fixtures = createBasicFixtures();
+* const mock = initMockHA(fixtures);
+* ```
+*/
+function createBasicFixtures() {
+	const kitchen = createArea("kitchen", { name: "Kitchen" });
+	const livingRoom = createArea("living_room", { name: "Living Room" });
+	const bedroom = createArea("bedroom", { name: "Bedroom" });
+	const office = createArea("office", { name: "Office" });
+	const lightDevice = createDevice("device_light_1", {
+		name: "Kitchen Light Strip",
+		area_id: "kitchen"
+	});
+	const entities = {
+		"light.kitchen": createEntity("light.kitchen", {
+			state: "on",
+			attributes: {
+				brightness: 255,
+				friendly_name: "Kitchen Light"
+			}
+		}),
+		"light.living_room": createEntity("light.living_room", {
+			state: "off",
+			attributes: { friendly_name: "Living Room Light" }
+		}),
+		"light.bedroom": createEntity("light.bedroom", {
+			state: "on",
+			attributes: {
+				brightness: 128,
+				color_temp: 370,
+				friendly_name: "Bedroom Light"
+			}
+		}),
+		"switch.fan": createEntity("switch.fan", {
+			state: "off",
+			attributes: { friendly_name: "Ceiling Fan" }
+		}),
+		"switch.outlet": createEntity("switch.outlet", {
+			state: "on",
+			attributes: { friendly_name: "Living Room Outlet" }
+		}),
+		"button.doorbell": createEntity("button.doorbell", {
+			state: "unknown",
+			attributes: { friendly_name: "Doorbell" }
+		}),
+		"button.garage": createEntity("button.garage", {
+			state: "unknown",
+			attributes: { friendly_name: "Garage Door" }
+		}),
+		"cover.garage_door": createEntity("cover.garage_door", {
+			state: "closed",
+			attributes: {
+				friendly_name: "Garage Door",
+				current_position: 0,
+				device_class: "garage"
+			}
+		}),
+		"cover.blind": createEntity("cover.blind", {
+			state: "open",
+			attributes: {
+				friendly_name: "Living Room Blinds",
+				current_position: 75,
+				device_class: "blind"
+			}
+		}),
+		"media_player.living_room": createEntity("media_player.living_room", {
+			state: "playing",
+			attributes: {
+				friendly_name: "Living Room TV",
+				media_title: "Midnight Horizons",
+				media_artist: "Synthetic Dreams",
+				media_album_name: "Neon Nights",
+				entity_picture: "https://picsum.photos/seed/album1/300/300",
+				volume_level: .5,
+				is_volume_muted: false,
+				media_content_type: "music",
+				media_duration: 245,
+				media_position: 45,
+				supported_features: 16383,
+				device_class: "speaker"
+			}
+		}),
+		"media_player.bedroom": createEntity("media_player.bedroom", {
+			state: "paused",
+			attributes: {
+				friendly_name: "Bedroom Speaker",
+				media_title: "Electric Pulse",
+				media_artist: "Digital Waves",
+				media_album_name: "Synth Collection",
+				entity_picture: "https://picsum.photos/seed/album2/300/300",
+				volume_level: .3,
+				is_volume_muted: false,
+				media_content_type: "music",
+				media_duration: 198,
+				media_position: 67,
+				supported_features: 16383,
+				device_class: "speaker"
+			}
+		}),
+		"climate.thermostat": createEntity("climate.thermostat", {
+			state: "heat",
+			attributes: {
+				friendly_name: "Living Room Thermostat",
+				current_temperature: 22,
+				temperature: 23,
+				hvac_modes: [
+					"off",
+					"heat",
+					"cool",
+					"auto"
+				],
+				hvac_mode: "heat",
+				min_temp: 16,
+				max_temp: 30
+			}
+		}),
+		"climate.bedroom": createEntity("climate.bedroom", {
+			state: "cool",
+			attributes: {
+				friendly_name: "Bedroom AC",
+				current_temperature: 20,
+				temperature: 21,
+				hvac_modes: [
+					"off",
+					"heat",
+					"cool",
+					"auto"
+				],
+				hvac_mode: "cool",
+				min_temp: 16,
+				max_temp: 30
+			}
+		}),
+		"sensor.temperature": createEntity("sensor.temperature", {
+			state: "22.5",
+			attributes: {
+				unit_of_measurement: "°C",
+				device_class: "temperature",
+				friendly_name: "Temperature Sensor"
+			}
+		}),
+		"sensor.humidity": createEntity("sensor.humidity", {
+			state: "45",
+			attributes: {
+				unit_of_measurement: "%",
+				device_class: "humidity",
+				friendly_name: "Humidity Sensor"
+			}
+		}),
+		"sensor.motion": createEntity("sensor.motion", {
+			state: "on",
+			attributes: {
+				friendly_name: "Motion Sensor",
+				device_class: "motion"
+			}
+		}),
+		"sensor.battery_phone": createEntity("sensor.battery_phone", {
+			state: "85",
+			attributes: {
+				unit_of_measurement: "%",
+				device_class: "battery",
+				friendly_name: "Phone Battery"
+			}
+		}),
+		"sensor.battery_sensor": createEntity("sensor.battery_sensor", {
+			state: "92",
+			attributes: {
+				unit_of_measurement: "%",
+				device_class: "battery",
+				friendly_name: "Motion Sensor Battery"
+			}
+		}),
+		"sensor.battery_laptop": createEntity("sensor.battery_laptop", {
+			state: "78",
+			attributes: {
+				unit_of_measurement: "%",
+				device_class: "battery",
+				friendly_name: "Laptop Battery"
+			}
+		}),
+		"sensor.battery_tablet": createEntity("sensor.battery_tablet", {
+			state: "15",
+			attributes: {
+				unit_of_measurement: "%",
+				device_class: "battery",
+				friendly_name: "Tablet Battery"
+			}
+		}),
+		"sensor.battery_door_sensor": createEntity("sensor.battery_door_sensor", {
+			state: "100",
+			attributes: {
+				unit_of_measurement: "%",
+				device_class: "battery",
+				friendly_name: "Door Sensor Battery"
+			}
+		}),
+		"sensor.battery_window_sensor": createEntity("sensor.battery_window_sensor", {
+			state: "67",
+			attributes: {
+				unit_of_measurement: "%",
+				device_class: "battery",
+				friendly_name: "Window Sensor Battery"
+			}
+		}),
+		"camera.front_door": createEntity("camera.front_door", {
+			state: "idle",
+			attributes: {
+				friendly_name: "Front Door Camera",
+				entity_picture: "/api/camera_proxy/camera.front_door"
+			}
+		}),
+		"weather.home": createEntity("weather.home", {
+			state: "sunny",
+			attributes: {
+				friendly_name: "Home Weather",
+				temperature: 22,
+				temperature_unit: "°C",
+				humidity: 45,
+				pressure: 1013,
+				wind_speed: 5,
+				wind_bearing: 180,
+				condition: "sunny"
+			}
+		}),
+		"scene.movie_night": createEntity("scene.movie_night", {
+			state: "scening",
+			attributes: { friendly_name: "Movie Night" }
+		}),
+		"scene.relax": createEntity("scene.relax", {
+			state: "scening",
+			attributes: { friendly_name: "Relax" }
+		}),
+		"lock.front_door": createEntity("lock.front_door", {
+			state: "locked",
+			attributes: {
+				friendly_name: "Front Door Lock",
+				code_format: "number"
+			}
+		})
+	};
+	const entityRegistry = [
+		createEntityRegistryEntry("light.kitchen", {
+			area_id: "kitchen",
+			device_id: "device_light_1"
+		}),
+		createEntityRegistryEntry("light.living_room", { area_id: "living_room" }),
+		createEntityRegistryEntry("light.bedroom", { area_id: "bedroom" }),
+		createEntityRegistryEntry("switch.fan", { area_id: "bedroom" }),
+		createEntityRegistryEntry("switch.outlet", { area_id: "living_room" }),
+		createEntityRegistryEntry("button.doorbell", { area_id: "kitchen" }),
+		createEntityRegistryEntry("button.garage", { area_id: "kitchen" }),
+		createEntityRegistryEntry("cover.garage_door", { area_id: "kitchen" }),
+		createEntityRegistryEntry("cover.blind", { area_id: "living_room" }),
+		createEntityRegistryEntry("media_player.living_room", { area_id: "living_room" }),
+		createEntityRegistryEntry("media_player.bedroom", { area_id: "bedroom" }),
+		createEntityRegistryEntry("climate.thermostat", { area_id: "living_room" }),
+		createEntityRegistryEntry("climate.bedroom", { area_id: "bedroom" }),
+		createEntityRegistryEntry("sensor.temperature", { area_id: "kitchen" }),
+		createEntityRegistryEntry("sensor.humidity", { area_id: "kitchen" }),
+		createEntityRegistryEntry("sensor.motion", { area_id: "living_room" }),
+		createEntityRegistryEntry("sensor.battery_phone", { area_id: "bedroom" }),
+		createEntityRegistryEntry("sensor.battery_sensor", { area_id: "living_room" }),
+		createEntityRegistryEntry("sensor.battery_laptop", { area_id: "office" }),
+		createEntityRegistryEntry("sensor.battery_tablet", { area_id: "living_room" }),
+		createEntityRegistryEntry("sensor.battery_door_sensor", { area_id: "kitchen" }),
+		createEntityRegistryEntry("sensor.battery_window_sensor", { area_id: "bedroom" }),
+		createEntityRegistryEntry("camera.front_door", { area_id: "kitchen" }),
+		createEntityRegistryEntry("weather.home", { area_id: null }),
+		createEntityRegistryEntry("scene.movie_night", { area_id: "living_room" }),
+		createEntityRegistryEntry("scene.relax", { area_id: "bedroom" }),
+		createEntityRegistryEntry("lock.front_door", { area_id: "kitchen" })
+	];
+	return {
+		entities,
+		entityRegistry,
+		deviceRegistry: [lightDevice],
+		areaRegistry: [
+			kitchen,
+			livingRoom,
+			bedroom,
+			office
+		],
+		floorRegistry: [],
+		labelRegistry: []
+	};
+}
+/**
+* Load fixtures from JSON
+*
+* @param json - JSON string or object
+* @returns Parsed fixtures
+*
+* @example
+* ```typescript
+* const fixtures = loadFixture(`{
+*   "entities": { ... },
+*   "entityRegistry": [ ... ]
+* }`);
+* ```
+*/
+function loadFixture(json) {
+	if (typeof json === "string") return JSON.parse(json);
+	return json;
+}
+/**
+* Create a fixture set from partial data
+*
+* Fills in missing fields with defaults.
+*
+* @param partial - Partial fixture data
+* @returns Complete fixture set
+*/
+function createFixture(partial = {}) {
+	return {
+		entities: partial.entities || {},
+		entityRegistry: partial.entityRegistry || [],
+		deviceRegistry: partial.deviceRegistry || [],
+		areaRegistry: partial.areaRegistry || [],
+		floorRegistry: partial.floorRegistry || [],
+		labelRegistry: partial.labelRegistry || [],
+		history: partial.history || {}
+	};
+}
+/**
+* Create a history state point
+*
+* @param state - State value
+* @param timestamp - Unix timestamp in seconds
+* @param attributes - Optional attributes
+* @param lastChanged - Optional last changed timestamp (defaults to timestamp)
+* @returns History state point
+*
+* @example
+* ```typescript
+* const historyState = createHistoryState("20.5", Math.floor(Date.now() / 1000) - 3600, {
+*   unit_of_measurement: "°C",
+* });
+* ```
+*/
+function createHistoryState(state$1, timestamp, attributes = {}, lastChanged) {
+	return {
+		s: state$1,
+		lu: timestamp,
+		lc: lastChanged ?? timestamp,
+		a: attributes
+	};
+}
+/**
+* Generate a random ID
+*/
+function generateId() {
+	return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+}
+
+//#endregion
+//#region src/testing/helpers.ts
+/**
+* Wait for a condition to be true
+*
+* @param condition - Function that returns true when ready
+* @param timeout - Maximum wait time in ms
+* @param interval - Check interval in ms
+* @returns Promise that resolves when condition is true
+*
+* @example
+* ```typescript
+* await waitFor(() => entity('light.kitchen').get()?.state === 'on', 1000);
+* ```
+*/
+async function waitFor(condition, timeout = 1e3, interval = 1) {
+	const start = Date.now();
+	while (!condition()) {
+		if (Date.now() - start > timeout) throw new Error(`Timeout waiting for condition after ${timeout}ms`);
+		await delay(interval);
+	}
+}
+/**
+* Simulate state change event
+*
+* Updates entity state and emits event through mock connection.
+*
+* @param mockConnection - MockConnection instance
+* @param entityId - Entity ID
+* @param updates - State updates
+* @param options - Optional simulation options
+* @returns Promise that resolves when update completes
+*
+* @example
+* ```typescript
+* const mockConnection = new MockConnection(fixtures);
+* await simulateStateChange(mockConnection, 'light.kitchen', {
+*   state: 'on',
+*   attributes: { brightness: 255 },
+* });
+* ```
+*/
+async function simulateStateChange(mockConnection, entityId, updates, options) {
+	mockConnection.setState(entityId, updates);
+	await delay(options?.delay || 10);
+}
+/**
+* Simulate registry update event
+*
+* Updates entity registry and emits event through mock connection.
+*
+* @param mockConnection - MockConnection instance
+* @param entityId - Entity ID
+* @param updates - Registry updates
+* @param options - Optional simulation options
+* @returns Promise that resolves when update completes
+*
+* @example
+* ```typescript
+* const mockConnection = new MockConnection(fixtures);
+* await simulateRegistryUpdate(mockConnection, 'light.kitchen', {
+*   name: 'New Name',
+*   area_id: 'bedroom',
+* });
+* ```
+*/
+async function simulateRegistryUpdate(mockConnection, entityId, updates, options) {
+	mockConnection.updateEntityRegistry(entityId, updates);
+	await delay(options?.delay || 10);
+}
+/**
+* Simulate multiple state changes in sequence
+*
+* @param mockConnection - MockConnection instance
+* @param changes - Array of state change configurations
+* @param delayBetween - Delay between changes in ms
+* @returns Promise that resolves when all changes complete
+*
+* @example
+* ```typescript
+* const mockConnection = new MockConnection(fixtures);
+* await simulateStateChanges(mockConnection, [
+*   { entityId: 'light.kitchen', updates: { state: 'on' } },
+*   { entityId: 'light.living_room', updates: { state: 'on' } },
+* ], 100);
+* ```
+*/
+async function simulateStateChanges(mockConnection, changes, delayBetween = 0) {
+	for (const change of changes) {
+		await simulateStateChange(mockConnection, change.entityId, change.updates);
+		if (delayBetween > 0) await delay(delayBetween);
+	}
+}
+/**
+* Get current store state snapshot
+*
+* @returns Current store state
+*/
+function getStoreSnapshot() {
+	return state;
+}
+/**
+* Get entity from store
+*
+* @param entityId - Entity ID
+* @returns Entity state or undefined
+*/
+function getEntityFromStore(entityId) {
+	return state.entities[entityId];
+}
+/**
+* Get entity registry entry from store
+*
+* @param entityId - Entity ID
+* @returns Registry entry or undefined
+*/
+function getEntityRegistryFromStore(entityId) {
+	return state.entityRegistry[entityId];
+}
+/**
+* Check if entity exists in store
+*
+* @param entityId - Entity ID
+* @returns True if entity exists
+*/
+function entityExistsInStore(entityId) {
+	return entityId in state.entities;
+}
+/**
+* Delay for specified time
+*
+* @param ms - Milliseconds to delay
+* @returns Promise that resolves after delay
+*/
+function delay(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* Wait for mock connection to complete
+*
+* Helper to ensure fixtures are loaded before running tests.
+* Use after creating MockConnection and connecting.
+*
+* @example
+* ```typescript
+* const mockConnection = new MockConnection(fixtures);
+* await mockConnection.connect();
+* await waitForConnection();
+* // Now safe to run queries
+* ```
+*/
+function waitForConnection() {
+	return delay(10);
+}
+/**
+* Create a spy function for testing
+*
+* @returns Spy function with call tracking
+*
+* @example
+* ```typescript
+* const spy = createSpy();
+* entities().byDomain('light').subscribe(spy);
+* // Check spy.calls, spy.callCount, etc.
+* ```
+*/
+function createSpy() {
+	const calls = [];
+	const spy = (...args) => {
+		calls.push(args);
+	};
+	spy.calls = calls;
+	spy.reset = () => {
+		calls.length = 0;
+	};
+	Object.defineProperty(spy, "callCount", {
+		get: () => calls.length,
+		configurable: true
+	});
+	return spy;
+}
+
+//#endregion
+export { MockConnection, createArea, createBasicFixtures, createDemoFixtures, createDevice, createEntity, createEntityRegistryEntry, createFixture, createFloor, createHistoryState, createLabel, createSpy, delay, entityExistsInStore, getEntityFromStore, getEntityRegistryFromStore, getStoreSnapshot, loadFixture, simulateRegistryUpdate, simulateStateChange, simulateStateChanges, waitFor, waitForConnection };