@glasshome/sync-layer 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 GlassHome Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,120 @@
+# @glasshome/sync-layer
+
+Type-safe, reactive state synchronization layer for Home Assistant.
+
+Provides connection management, entity querying, service calls, and reactive state via a SolidJS store — all with full TypeScript types powered by `@glasshome/ha-types`.
+
+## Install
+
+```bash
+npm install @glasshome/sync-layer @glasshome/ha-types
+# or
+bun add @glasshome/sync-layer @glasshome/ha-types
+```
+
+## Quick Start
+
+```typescript
+import {
+  initConnection,
+  getConnection,
+  state,
+  entity,
+  entities,
+  callService,
+} from "@glasshome/sync-layer";
+
+// Connect to Home Assistant
+await initConnection({
+  hassUrl: "http://homeassistant.local:8123",
+  token: "YOUR_LONG_LIVED_ACCESS_TOKEN",
+});
+
+// Access reactive state
+console.log(state.connectionState); // "connected"
+
+// Query a single entity
+const light = entity("light.living_room").get();
+
+// Query multiple entities by domain
+const allLights = entities().domain("light").list();
+
+// Call a service
+await callService("light", "turn_on", {
+  entity_id: "light.living_room",
+  brightness: 200,
+});
+```
+
+## Subpath Imports
+
+### `@glasshome/sync-layer/solid`
+
+SolidJS hooks for reactive UI integration. Requires `solid-js` as a peer dependency.
+
+```typescript
+import {
+  useEntity,
+  useEntities,
+  useConnection,
+  useStore,
+  useService,
+  useToggle,
+  useArea,
+  useCamera,
+  useEntityHistory,
+  useForecast,
+} from "@glasshome/sync-layer/solid";
+
+// Reactive entity access in SolidJS components
+const light = useEntity("light.living_room");
+const connection = useConnection();
+const toggle = useToggle("light.living_room");
+```
+
+### `@glasshome/sync-layer/testing`
+
+Mock utilities for testing without a live Home Assistant instance.
+
+```typescript
+import {
+  MockConnection,
+  createEntity,
+  createArea,
+  createBasicFixtures,
+  simulateStateChange,
+  waitForConnection,
+  getStoreSnapshot,
+} from "@glasshome/sync-layer/testing";
+
+const mock = new MockConnection();
+await mock.connect();
+
+simulateStateChange("light.test", { state: "on" });
+```
+
+### `@glasshome/sync-layer/demo`
+
+Demo mode provider for loading fixture data without a real backend.
+
+```typescript
+import {
+  loadDemoData,
+  unloadDemoData,
+  isDemoMode,
+  applyDemoServiceCall,
+} from "@glasshome/sync-layer/demo";
+
+await loadDemoData(); // Populates store with demo entities
+```
+
+## Peer Dependencies
+
+| Package | Required | Notes |
+|---------|----------|-------|
+| `@glasshome/ha-types` | Yes | TypeScript types for Home Assistant entities, services, and events |
+| `solid-js` | Only for `./solid` subpath | SolidJS reactive primitives used by the hooks adapter |
+
+## License
+
+MIT

package/dist/area-views-B-m8vwce.js

@@ -0,0 +1,321 @@
+import { state } from "./store-B1sbyexX.js";
+import { extractDomain } from "./types-Csog0nqk.js";
+import { callService } from "home-assistant-js-websocket";
+
+//#region src/commands/service.ts
+/**
+* Call a Home Assistant service
+*/
+async function callService$1(domain, service, serviceData = {}, target = {}) {
+	const connection = state.conn;
+	if (!connection) throw new Error("Not connected to Home Assistant. Call initConnection() first.");
+	try {
+		const mockConnection = connection;
+		if (mockConnection && typeof mockConnection.callService === "function") await mockConnection.callService(domain, service, serviceData, target);
+		else await callService(connection, domain, service, serviceData, target);
+	} catch (error) {
+		throw new Error(`Service call failed: ${error.message || String(error)}`);
+	}
+}
+/**
+* Turn on entity or entities
+*/
+async function turnOn(entityId, serviceData = {}) {
+	const firstEntityId = Array.isArray(entityId) ? entityId[0] : entityId;
+	if (!firstEntityId) throw new Error("Entity ID is required");
+	const domain = firstEntityId.split(".")[0];
+	if (!domain) throw new Error(`Invalid entity ID: ${firstEntityId}`);
+	await callService$1(domain, "turn_on", serviceData, { entity_id: entityId });
+}
+/**
+* Turn off entity or entities
+*/
+async function turnOff(entityId, serviceData = {}) {
+	const firstEntityId = Array.isArray(entityId) ? entityId[0] : entityId;
+	if (!firstEntityId) throw new Error("Entity ID is required");
+	const domain = firstEntityId.split(".")[0];
+	if (!domain) throw new Error(`Invalid entity ID: ${firstEntityId}`);
+	await callService$1(domain, "turn_off", serviceData, { entity_id: entityId });
+}
+/**
+* Toggle entity or entities
+*/
+async function toggle(entityId, serviceData = {}) {
+	const firstEntityId = Array.isArray(entityId) ? entityId[0] : entityId;
+	if (!firstEntityId) throw new Error("Entity ID is required");
+	const domain = firstEntityId.split(".")[0];
+	if (!domain) throw new Error(`Invalid entity ID: ${firstEntityId}`);
+	await callService$1(domain, "toggle", serviceData, { entity_id: entityId });
+}
+/**
+* Update entity registry entry
+*/
+async function updateEntity(entityId, updates) {
+	const connection = state.conn;
+	if (!connection) throw new Error("Not connected to Home Assistant. Call initConnection() first.");
+	try {
+		const result = await connection.sendMessagePromise({
+			type: "config/entity_registry/update",
+			entity_id: entityId,
+			...updates
+		});
+		if (result && typeof result === "object" && "_mockError" in result) throw new Error(`Entity registry entry not found: ${entityId}`);
+		return result;
+	} catch (error) {
+		if (error?.message && error.message.includes("Entity registry entry not found")) throw error;
+		throw new Error(`Entity update failed: ${error.message || String(error)}`);
+	}
+}
+/**
+* Send a generic WebSocket command
+*/
+async function sendCommand(command) {
+	const connection = state.conn;
+	if (!connection) throw new Error("Not connected");
+	try {
+		return await connection.sendMessagePromise(command);
+	} catch (error) {
+		throw new Error(`Command failed: ${error.message || String(error)}`);
+	}
+}
+/**
+* Execute multiple service calls in parallel
+*/
+async function batchServiceCalls(calls) {
+	await Promise.all(calls.map((call) => callService$1(call.domain, call.service, call.serviceData, call.target)));
+}
+/**
+* Execute multiple entity updates in parallel
+*/
+async function batchEntityUpdates(updates) {
+	return Promise.all(updates.map((u) => updateEntity(u.entityId, u.updates)));
+}
+
+//#endregion
+//#region src/entities/index.ts
+/**
+* Get all entity IDs
+*/
+function getAllEntityIds() {
+	return Object.keys(state.entities);
+}
+/**
+* Get entities by domain
+*/
+function getEntitiesByDomain(domain) {
+	return Object.keys(state.entities).filter((id) => extractDomain(id) === domain);
+}
+/**
+* Get entities via devices in area
+*
+* Only includes entities that inherit area from device (entity.area_id is null).
+*/
+function getEntitiesViaDevices(areaId) {
+	const devicesInArea = Object.values(state.devices).filter((device) => device.area_id === areaId);
+	const entityIds = [];
+	for (const device of devicesInArea) {
+		const deviceEntities = getEntitiesByDevice(device.id);
+		for (const entityId of deviceEntities) {
+			const registry = state.entityRegistry[entityId];
+			if (!registry?.area_id) entityIds.push(entityId);
+		}
+	}
+	return entityIds;
+}
+/**
+* Get entities by area
+*
+* Returns entities with direct area_id assignments and entities that inherit their area from devices.
+*/
+function getEntitiesByArea(areaId) {
+	const directEntityIds = [];
+	for (const [entityId, entry] of Object.entries(state.entityRegistry)) if (entry.area_id === areaId) directEntityIds.push(entityId);
+	const deviceEntityIds = getEntitiesViaDevices(areaId);
+	return Array.from(new Set([...directEntityIds, ...deviceEntityIds]));
+}
+/**
+* Get entities by device
+*/
+function getEntitiesByDevice(deviceId) {
+	const entityIds = [];
+	for (const [entityId, entry] of Object.entries(state.entityRegistry)) if (entry.device_id === deviceId) entityIds.push(entityId);
+	return entityIds;
+}
+/**
+* Get entities by floor
+*/
+function getEntitiesByFloor(floorId) {
+	const entityIds = [];
+	const areasOnFloor = Object.values(state.areas).filter((area) => area.floor_id === floorId);
+	for (const area of areasOnFloor) {
+		const areaEntities = getEntitiesByArea(area.id);
+		entityIds.push(...areaEntities);
+	}
+	return entityIds;
+}
+/**
+* Get entities by label
+*/
+function getEntitiesByLabel(labelId) {
+	const entityIds = [];
+	for (const [entityId, entry] of Object.entries(state.entityRegistry)) if (entry.labels?.includes(labelId)) entityIds.push(entityId);
+	return entityIds;
+}
+
+//#endregion
+//#region src/entities/views.ts
+/**
+* Get icon for an entity from registry or attributes
+*/
+function resolveIcon(entity, registry) {
+	if (registry?.icon) return {
+		icon: registry.icon,
+		source: "registry"
+	};
+	if (entity.attributes?.icon) return {
+		icon: entity.attributes.icon,
+		source: "attribute"
+	};
+	return null;
+}
+/**
+* Build an EntityView from runtime state and registry metadata
+*/
+function buildEntityView(entity, registry) {
+	const domain = extractDomain(entity.entity_id);
+	const friendlyName = entity.attributes.friendly_name ?? registry?.name ?? entity.entity_id;
+	const name = registry?.name ?? friendlyName;
+	const iconResolution = resolveIcon(entity, registry);
+	let areaId = registry?.area_id ?? null;
+	if (areaId === null && registry?.device_id) {
+		const device = state.devices[registry.device_id];
+		if (device) areaId = device.area_id ?? null;
+	}
+	return {
+		id: entity.entity_id,
+		domain,
+		state: entity.state,
+		attributes: entity.attributes,
+		lastChanged: new Date(entity.last_changed),
+		lastUpdated: new Date(entity.last_updated),
+		context: {
+			id: entity.context.id,
+			parentId: entity.context.parent_id,
+			userId: entity.context.user_id
+		},
+		name,
+		friendlyName,
+		areaId,
+		deviceId: registry?.device_id ?? null,
+		platform: registry?.platform ?? "unknown",
+		uniqueId: registry?.unique_id ?? null,
+		isDisabled: registry?.disabled_by !== null && registry?.disabled_by !== void 0,
+		isHidden: registry?.hidden_by !== null && registry?.hidden_by !== void 0,
+		icon: iconResolution?.icon ?? null,
+		iconSource: iconResolution?.source ?? "default",
+		entityCategory: registry?.entity_category ?? null,
+		labels: registry?.labels ?? [],
+		aliases: registry?.aliases ?? [],
+		deviceClass: registry?.device_class ?? entity.attributes.device_class ?? null,
+		unitOfMeasurement: registry?.unit_of_measurement ?? entity.attributes.unit_of_measurement ?? null,
+		supportedFeatures: registry?.supported_features ?? entity.attributes.supported_features
+	};
+}
+/**
+* Get or build an EntityView
+*/
+function getEntityView(entityId) {
+	const entity = state.entities[entityId];
+	if (!entity) return void 0;
+	const registry = state.entityRegistry[entityId];
+	return buildEntityView(entity, registry);
+}
+/**
+* Get multiple entity views
+*/
+function getEntityViews(entityIds) {
+	const views = [];
+	for (const id of entityIds) {
+		const view = getEntityView(id);
+		if (view) views.push(view);
+	}
+	return views;
+}
+/**
+* Get all entity views
+*/
+function getAllEntityViews() {
+	return getEntityViews(Object.keys(state.entities));
+}
+
+//#endregion
+//#region src/entities/area-views.ts
+/**
+* Build a DeviceView from registry data
+*/
+function buildDeviceView(device) {
+	return {
+		id: device.id,
+		name: device.name ?? "",
+		nameByUser: device.name_by_user ?? null,
+		manufacturer: device.manufacturer ?? null,
+		model: device.model ?? null,
+		swVersion: device.sw_version ?? null,
+		areaId: device.area_id ?? null,
+		configEntries: device.config_entries ?? [],
+		connections: device.connections ?? [],
+		identifiers: device.identifiers ?? [],
+		disabledBy: device.disabled_by ?? null
+	};
+}
+/**
+* Build an AreaView from registry data using query engine
+*/
+function buildAreaView(areaId) {
+	const area = state.areas[areaId];
+	if (!area) throw new Error(`Area ${areaId} not found`);
+	const directEntityIds = [];
+	for (const [entityId, entry] of Object.entries(state.entityRegistry)) if (entry.area_id === areaId) directEntityIds.push(entityId);
+	const deviceEntityIds = getEntitiesViaDevices(areaId);
+	const allEntityIds = Array.from(new Set([...directEntityIds, ...deviceEntityIds]));
+	const areaEntities = allEntityIds.length > 0 ? getEntityViews(allEntityIds) : [];
+	const devicesInArea = Object.values(state.devices).filter((device) => device.area_id === areaId);
+	const devices = devicesInArea.map((device) => buildDeviceView(device));
+	return {
+		id: areaId,
+		name: area.name,
+		normalizedName: area.normalized_name ?? area.name.toLowerCase(),
+		aliases: Array.isArray(area.aliases) ? area.aliases : [],
+		floorId: area.floor_id ?? null,
+		icon: area.icon ?? null,
+		picture: area.picture ?? null,
+		labels: Array.isArray(area.labels) ? area.labels : [],
+		temperatureEntityId: area.temperature_entity_id ?? null,
+		humidityEntityId: area.humidity_entity_id ?? null,
+		createdAt: area.created_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+		modifiedAt: area.modified_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+		entities: areaEntities,
+		devices,
+		entityIds: allEntityIds,
+		deviceIds: devices.map((d) => d.id)
+	};
+}
+/**
+* Get all area views
+*/
+function getAreaViews() {
+	return Object.keys(state.areas).map((areaId) => buildAreaView(areaId));
+}
+/**
+* Get area view
+*/
+function getAreaView(areaId) {
+	try {
+		return buildAreaView(areaId);
+	} catch {
+		return void 0;
+	}
+}
+
+//#endregion
+export { batchEntityUpdates, batchServiceCalls, buildAreaView, buildDeviceView, buildEntityView, callService$1 as callService, getAllEntityIds, getAllEntityViews, getAreaView, getAreaViews, getEntitiesByArea, getEntitiesByDevice, getEntitiesByDomain, getEntitiesByFloor, getEntitiesByLabel, getEntityView, getEntityViews, sendCommand, toggle, turnOff, turnOn, updateEntity };

package/dist/camera/fetch.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Camera Stream Fetching
+ *
+ * @packageDocumentation
+ */
+import type { EntityId } from "../core/types";
+import type { CameraStreamData, StreamFormat, StreamQueryOptions } from "./types";
+/**
+ * Fetch stream for a camera entity
+ */
+export declare function fetchStream(entityId: EntityId, format?: StreamFormat): Promise<string | null>;
+/**
+ * Fetch stream data for a camera entity
+ */
+export declare function fetchStreamData(entityId: EntityId, options?: StreamQueryOptions): Promise<CameraStreamData>;

package/dist/camera/query.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Camera Stream Query Builder
+ *
+ * @packageDocumentation
+ */
+import type { EntityId } from "../core/types";
+import type { CameraStreamData, EntityStreamQueryOptions, StreamFormat } from "./types";
+/**
+ * Get stream for a camera entity
+ */
+export declare function getStream(entityId: EntityId, options?: EntityStreamQueryOptions): Promise<CameraStreamData>;
+/**
+ * Refresh stream for a camera entity
+ */
+export declare function refreshStream(entityId: EntityId, format?: StreamFormat): Promise<CameraStreamData>;

package/dist/camera/types.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Camera Types
+ *
+ * Type definitions for camera stream data.
+ *
+ * @packageDocumentation
+ */
+import type { EntityId } from "../core/types";
+/**
+ * Stream format
+ * Supported stream formats from Home Assistant Camera API
+ */
+export type StreamFormat = "hls" | "webrtc" | "mjpeg";
+/**
+ * Camera stream data
+ */
+export interface CameraStream {
+    /** Stream URL */
+    url: string | null;
+    /** Loading state */
+    loading: boolean;
+    /** Error if any */
+    error: Error | null;
+    /** Last fetched timestamp */
+    lastFetched: number | null;
+    /** Stream format */
+    format: StreamFormat;
+    /** Stream expiration time (if available) */
+    expiresAt?: number | null;
+}
+/**
+ * Camera stream data for an entity
+ */
+export interface CameraStreamData {
+    /** Entity ID */
+    entityId: EntityId;
+    /** Stream data */
+    stream: CameraStream;
+    /** Loading state */
+    loading: boolean;
+    /** Error if any */
+    error: Error | null;
+    /** Last fetched timestamp */
+    lastFetched: number | null;
+}
+/**
+ * Camera stream data for multiple entities
+ */
+export interface CameraStreams {
+    /** Entity ID -> Stream data */
+    [entityId: EntityId]: CameraStreamData;
+}
+/**
+ * Options for stream queries
+ */
+export interface StreamQueryOptions {
+    /** Stream format (default: "hls") */
+    format?: StreamFormat;
+    /** Auto-refresh stream before expiration */
+    autoRefresh?: boolean;
+    /** Stream refresh interval in milliseconds (default: 5 minutes) */
+    refreshInterval?: number;
+}
+/**
+ * Single entity stream query options
+ */
+export interface EntityStreamQueryOptions {
+    /** Stream format (default: "hls") */
+    format?: StreamFormat;
+    /** Auto-refresh stream before expiration */
+    autoRefresh?: boolean;
+    /** Stream refresh interval in milliseconds (default: 5 minutes) */
+    refreshInterval?: number;
+}
+/**
+ * Stream query result
+ */
+export interface StreamResult {
+    /** Stream data */
+    data: CameraStreamData | null;
+    /** Loading state */
+    loading: boolean;
+    /** Error if any */
+    error: Error | null;
+}

package/dist/camera/webrtc.d.ts

@@ -0,0 +1,31 @@
+import type { EntityId } from "../core/types";
+/** Minimal RTC types for sync-layer (no DOM lib dependency) */
+type RtcConfiguration = Record<string, unknown>;
+type RtcIceCandidateInit = Record<string, unknown>;
+interface WebRtcClientConfig {
+    configuration: RtcConfiguration;
+    dataChannel?: string;
+}
+interface WebRtcSession {
+    sessionId: string | null;
+    unsubscribe: (() => Promise<void>) | null;
+}
+/**
+ * Get WebRTC client configuration (STUN/TURN servers) from HA
+ */
+export declare function getWebRtcClientConfig(entityId: EntityId): Promise<WebRtcClientConfig>;
+/**
+ * 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().
+ */
+export declare function startWebRtcSession(entityId: EntityId, sdpOffer: string, onCandidate: (candidate: RtcIceCandidateInit) => void): Promise<{
+    answer: string;
+    session: WebRtcSession;
+}>;
+/**
+ * Send a local ICE candidate to HA
+ */
+export declare function sendWebRtcCandidate(entityId: EntityId, sessionId: string, candidate: RtcIceCandidateInit): Promise<void>;
+export {};

package/dist/commands/service.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Service calls and commands
+ *
+ * Type-safe wrappers for Home Assistant service calls and commands.
+ *
+ * @packageDocumentation
+ */
+import type { Domain, ServiceCall, ServiceName, WsCommandType } from "@glasshome/ha-types";
+import type { EntityId } from "../core/types";
+import type { EntityUpdateFields, ServiceTarget } from "./types";
+/**
+ * Call a Home Assistant service
+ */
+export declare function callService(domain: Domain, service: ServiceName<Domain>, serviceData?: ServiceCall<Domain, ServiceName<Domain>>, target?: ServiceTarget): Promise<void>;
+/**
+ * Turn on entity or entities
+ */
+export declare function turnOn(entityId: EntityId | EntityId[], serviceData?: Record<string, any>): Promise<void>;
+/**
+ * Turn off entity or entities
+ */
+export declare function turnOff(entityId: EntityId | EntityId[], serviceData?: Record<string, any>): Promise<void>;
+/**
+ * Toggle entity or entities
+ */
+export declare function toggle(entityId: EntityId | EntityId[], serviceData?: Record<string, any>): Promise<void>;
+/**
+ * Update entity registry entry
+ */
+export declare function updateEntity(entityId: EntityId, updates: EntityUpdateFields): Promise<any>;
+/**
+ * Send a generic WebSocket command
+ */
+export declare function sendCommand<T = unknown>(command: {
+    type: WsCommandType | string;
+    [key: string]: unknown;
+}): Promise<T>;
+/**
+ * Execute multiple service calls in parallel
+ */
+export declare function batchServiceCalls(calls: Array<{
+    domain: Domain;
+    service: ServiceName<Domain>;
+    serviceData?: ServiceCall<Domain, ServiceName<Domain>>;
+    target?: ServiceTarget;
+}>): Promise<void>;
+/**
+ * Execute multiple entity updates in parallel
+ */
+export declare function batchEntityUpdates(updates: Array<{
+    entityId: EntityId;
+    updates: EntityUpdateFields;
+}>): Promise<any[]>;