@glasshome/sync-layer 0.1.0

package/dist/testing/mock-behaviors/base.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Base types and interfaces for mock behavior handlers
+ *
+ * This file defines the contract that all domain behavior handlers must implement.
+ * Each domain handler simulates how Home Assistant would change entity states
+ * in response to service calls.
+ */
+import type { Domain, ServiceCall, ServiceName } from "@glasshome/ha-types";
+import type { HassEntity } from "../../core/types";
+/**
+ * Context from a service call or state change
+ * Matches HA's context structure
+ */
+export interface ServiceContext {
+    id: string;
+    parent_id: string | null;
+    user_id: string | null;
+}
+/**
+ * Result of a behavior handler processing a service call
+ */
+export interface BehaviorResult {
+    /** Updated entity state (null if no change) */
+    stateUpdate: Partial<HassEntity> | null;
+    /** Optional error to throw */
+    error?: {
+        code: string;
+        message: string;
+    };
+    /** Optional additional actions (for multi-step behaviors) */
+    additionalActions?: Array<{
+        delay: number;
+        update: Partial<HassEntity>;
+    }>;
+}
+/**
+ * Domain behavior handler interface
+ *
+ * Each domain (light, switch, cover, etc.) implements this interface
+ * to define how it reacts to service calls.
+ *
+ * Uses strongly-typed Domain and ServiceName from @glasshome/ha-types.
+ */
+export interface DomainBehavior<D extends Domain = Domain> {
+    /** Domain this handler manages (e.g., "light", "switch") */
+    readonly domain: D;
+    /**
+     * Handle a service call for an entity in this domain
+     *
+     * @param entity - Current entity state
+     * @param service - Service name (e.g., "turn_on", "set_temperature")
+     * @param serviceData - Service call data/parameters
+     * @param context - Service call context
+     * @returns Behavior result with state updates
+     */
+    handleService(entity: HassEntity, service: ServiceName<D>, serviceData: ServiceCall<D, ServiceName<D>> | undefined, context: ServiceContext): BehaviorResult;
+}
+/**
+ * Helper to create a simple state update result
+ */
+export declare function simpleStateUpdate(update: Partial<HassEntity>): BehaviorResult;
+/**
+ * Helper to create a no-change result
+ */
+export declare function noChange(): BehaviorResult;
+/**
+ * Helper to create an error result
+ */
+export declare function behaviorError(code: string, message: string): BehaviorResult;
+/**
+ * Helper to merge attributes safely
+ */
+export declare function mergeAttributes(current: Record<string, unknown>, updates: Record<string, unknown>): Record<string, unknown>;

package/dist/testing/mock-behaviors/climate.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Climate domain behavior handler
+ *
+ * Simulates Home Assistant's climate entity behavior for:
+ * - set_temperature: Set target temperature
+ * - set_hvac_mode: Change HVAC mode (heat, cool, auto, etc.)
+ * - set_preset_mode: Change preset (eco, comfort, etc.)
+ * - set_fan_mode: Change fan mode
+ * - set_humidity: Set target humidity
+ * - turn_on: Turn on to last mode (or heat)
+ * - turn_off: Turn off
+ *
+ * Uses strongly-typed ClimateService from @glasshome/ha-types.
+ */
+import type { ServiceCall, ServiceName } from "@glasshome/ha-types";
+import type { HassEntity } from "../../core/types";
+import type { BehaviorResult, DomainBehavior, ServiceContext } from "./base";
+export declare class ClimateBehavior implements DomainBehavior<"climate"> {
+    readonly domain: "climate";
+    handleService(entity: HassEntity, service: ServiceName<"climate">, serviceData: ServiceCall<"climate", ServiceName<"climate">> | undefined, _context: ServiceContext): BehaviorResult;
+    private handleSetTemperature;
+}

package/dist/testing/mock-behaviors/cover.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Cover domain behavior handler
+ *
+ * Simulates Home Assistant's cover entity behavior for:
+ * - open_cover: Open cover fully
+ * - close_cover: Close cover fully
+ * - stop_cover: Stop cover movement
+ * - set_cover_position: Set to specific position
+ * - open_cover_tilt: Open tilt fully
+ * - close_cover_tilt: Close tilt fully
+ * - set_cover_tilt_position: Set tilt to specific position
+ * - toggle: Toggle open/closed
+ *
+ * Uses strongly-typed CoverService from @glasshome/ha-types.
+ */
+import type { ServiceCall, ServiceName } from "@glasshome/ha-types";
+import type { HassEntity } from "../../core/types";
+import type { BehaviorResult, DomainBehavior, ServiceContext } from "./base";
+export declare class CoverBehavior implements DomainBehavior<"cover"> {
+    readonly domain: "cover";
+    handleService(entity: HassEntity, service: ServiceName<"cover">, serviceData: ServiceCall<"cover", ServiceName<"cover">> | undefined, _context: ServiceContext): BehaviorResult;
+}

package/dist/testing/mock-behaviors/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Mock Behaviors - Export all behavior handlers and utilities
+ */
+export * from "./base";
+export { ClimateBehavior } from "./climate";
+export { CoverBehavior } from "./cover";
+export { LightBehavior } from "./light";
+export { LockBehavior } from "./lock";
+export { MediaPlayerBehavior } from "./media_player";
+export * from "./registry";
+export { SwitchBehavior } from "./switch";

package/dist/testing/mock-behaviors/light.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Light domain behavior handler
+ *
+ * Simulates Home Assistant's light entity behavior for:
+ * - turn_on: Turn on with optional brightness, color, etc.
+ * - turn_off: Turn off with optional transition
+ * - toggle: Toggle state
+ *
+ * Uses strongly-typed LightService and ServiceCall from @glasshome/ha-types.
+ */
+import type { ServiceCall, ServiceName } from "@glasshome/ha-types";
+import type { HassEntity } from "../../core/types";
+import type { BehaviorResult, DomainBehavior, ServiceContext } from "./base";
+export declare class LightBehavior implements DomainBehavior<"light"> {
+    readonly domain: "light";
+    handleService(entity: HassEntity, service: ServiceName<"light">, serviceData: ServiceCall<"light", ServiceName<"light">> | undefined, _context: ServiceContext): BehaviorResult;
+    private handleTurnOn;
+    private handleTurnOff;
+    private handleToggle;
+}

package/dist/testing/mock-behaviors/lock.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Lock domain behavior handler
+ *
+ * Simulates Home Assistant's lock entity behavior for:
+ * - lock: Lock the lock
+ * - unlock: Unlock the lock
+ * - open: Open the lock (unlocks and opens door)
+ *
+ * Uses strongly-typed LockService from @glasshome/ha-types.
+ */
+import type { ServiceCall, ServiceName } from "@glasshome/ha-types";
+import type { HassEntity } from "../../core/types";
+import type { BehaviorResult, DomainBehavior, ServiceContext } from "./base";
+export declare class LockBehavior implements DomainBehavior<"lock"> {
+    readonly domain: "lock";
+    handleService(entity: HassEntity, service: ServiceName<"lock">, _serviceData: ServiceCall<"lock", ServiceName<"lock">> | undefined, _context: ServiceContext): BehaviorResult;
+    private handleLock;
+    private handleUnlock;
+    private handleOpen;
+}

package/dist/testing/mock-behaviors/media_player.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Media Player domain behavior handler
+ *
+ * Simulates Home Assistant's media player entity behavior for:
+ * - media_play: Start playback
+ * - media_pause: Pause playback
+ * - media_play_pause: Toggle play/pause
+ * - media_stop: Stop playback
+ * - media_next_track: Skip to next track
+ * - media_previous_track: Skip to previous track
+ * - media_seek: Seek to position
+ * - volume_up: Increase volume
+ * - volume_down: Decrease volume
+ * - set_volume_level: Set volume level
+ * - mute_volume: Mute/unmute
+ * - turn_on: Turn on media player
+ * - turn_off: Turn off media player
+ * - toggle: Toggle power
+ *
+ * Uses strongly-typed MediaPlayerService from @glasshome/ha-types.
+ */
+import type { ServiceCall, ServiceName } from "@glasshome/ha-types";
+import type { HassEntity } from "../../core/types";
+import type { BehaviorResult, DomainBehavior, ServiceContext } from "./base";
+export declare class MediaPlayerBehavior implements DomainBehavior<"media_player"> {
+    readonly domain: "media_player";
+    handleService(entity: HassEntity, service: ServiceName<"media_player">, serviceData: ServiceCall<"media_player", ServiceName<"media_player">> | undefined, _context: ServiceContext): BehaviorResult;
+    private handlePlay;
+    private handlePause;
+    private handlePlayPause;
+    private handleStop;
+    private handleNextTrack;
+    private handlePreviousTrack;
+    private handleSeek;
+    private handleVolumeUp;
+    private handleVolumeDown;
+    private handleSetVolumeLevel;
+    private handleMuteVolume;
+    private handleTurnOn;
+    private handleTurnOff;
+    private handleToggle;
+}

package/dist/testing/mock-behaviors/registry.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Behavior Registry
+ *
+ * Manages and provides access to all domain behavior handlers.
+ * Automatically discovers and registers handlers.
+ */
+import type { DomainBehavior } from "./base";
+/**
+ * Central registry of all domain behavior handlers
+ */
+export declare class BehaviorRegistry {
+    private handlers;
+    constructor();
+    /**
+     * Register all built-in domain handlers
+     */
+    private registerDefaultHandlers;
+    /**
+     * Register a domain behavior handler
+     */
+    register(handler: DomainBehavior): void;
+    /**
+     * Get handler for a specific domain
+     */
+    getHandler(domain: string): DomainBehavior | undefined;
+    /**
+     * Check if a domain has a registered handler
+     */
+    hasHandler(domain: string): boolean;
+    /**
+     * Get all registered domains
+     */
+    getRegisteredDomains(): string[];
+    /**
+     * Clear all handlers (useful for testing)
+     */
+    clear(): void;
+    /**
+     * Reset to default handlers
+     */
+    reset(): void;
+}
+/**
+ * Global behavior registry instance
+ */
+export declare const behaviorRegistry: BehaviorRegistry;
+/**
+ * Get behavior handler for a domain
+ */
+export declare function getBehaviorHandler(domain: string): DomainBehavior | undefined;
+/**
+ * Register a custom behavior handler
+ * Useful for tests or custom mock scenarios
+ */
+export declare function registerBehaviorHandler(handler: DomainBehavior): void;

package/dist/testing/mock-behaviors/switch.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Switch domain behavior handler
+ *
+ * Simulates Home Assistant's switch entity behavior for:
+ * - turn_on: Turn on switch
+ * - turn_off: Turn off switch
+ * - toggle: Toggle state
+ *
+ * Uses strongly-typed SwitchService from @glasshome/ha-types.
+ */
+import type { ServiceCall, ServiceName } from "@glasshome/ha-types";
+import type { HassEntity } from "../../core/types";
+import type { BehaviorResult, DomainBehavior, ServiceContext } from "./base";
+export declare class SwitchBehavior implements DomainBehavior<"switch"> {
+    readonly domain: "switch";
+    handleService(entity: HassEntity, service: ServiceName<"switch">, _serviceData: ServiceCall<"switch", ServiceName<"switch">> | undefined, _context: ServiceContext): BehaviorResult;
+}

package/dist/testing/mock.d.ts

@@ -0,0 +1,191 @@
+/**
+ * Mock Home Assistant connection
+ *
+ * Provides a mock implementation for testing without a real HA instance.
+ *
+ * @packageDocumentation
+ */
+import type { EntityRegistryEntry, HAEvent } from "@glasshome/ha-types";
+import type { SyncLayerConnection } from "../connection/types";
+import type { HassEntity } from "../core/types";
+import type { AreaRegistryEntry, DeviceRegistryEntry, Fixtures } from "./types";
+/**
+ * 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.
+ */
+export declare class MockConnection implements SyncLayerConnection {
+    private connected;
+    authState: "pending" | "authenticated" | "failed";
+    private messageHandlers;
+    private eventSubscriptions;
+    private subscriptions;
+    private latency;
+    private fixtures;
+    private mockVersion;
+    private messageIdCounter;
+    private autoReact;
+    private reactionDelay;
+    serviceCalls: Array<{
+        domain: string;
+        service: string;
+        serviceData?: Record<string, any>;
+        target?: any;
+        timestamp: number;
+    }>;
+    sentCommands: Array<{
+        type: string;
+        data?: any;
+        timestamp: number;
+    }>;
+    constructor(fixtures: Fixtures, latency?: number, options?: {
+        /** Enable automatic state reactions to service calls (default: true) */
+        autoReact?: boolean;
+        /** Delay before emitting entity update events after service calls in ms (default: 0) */
+        reactionDelay?: number;
+    });
+    /**
+     * Get connected state
+     */
+    get connected$(): boolean;
+    /**
+     * Simulate connection - sends auth_required per WebSocket spec
+     */
+    connect(): Promise<void>;
+    /**
+     * Register message handler for auth and other server messages
+     */
+    addEventListener(handler: (message: any) => void): () => void;
+    /**
+     * Handle authentication message (from client)
+     */
+    authenticate(_accessToken: string): Promise<void>;
+    /**
+     * Send auth_required message (server-initiated)
+     */
+    private sendAuthRequired;
+    /**
+     * Simulate disconnection
+     */
+    disconnect(): void;
+    /**
+     * Close connection (alias for disconnect for compatibility)
+     */
+    close(): void;
+    /**
+     * Send a message (mock implementation)
+     */
+    sendMessage(message: any): Promise<void>;
+    /**
+     * Call a service (mock implementation)
+     */
+    callService(domain: string, service: string, serviceData?: Record<string, any>, target?: any): Promise<any>;
+    /**
+     * Send a message and wait for response - returns proper WebSocket result format
+     */
+    sendMessagePromise<T>(message: any): Promise<T>;
+    /**
+     * Handle different message types and return appropriate data
+     */
+    private handleMessage;
+    /**
+     * Subscribe to events
+     */
+    subscribeEvents(callback: (event: any) => void, eventType?: string): Promise<() => void>;
+    /**
+     * 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
+     */
+    subscribeMessage<T>(callback: (message: T) => void, message: {
+        type: string;
+        [key: string]: unknown;
+    }): Promise<() => Promise<void>>;
+    /**
+     * Simulate state change
+     */
+    setState(entityId: string, updates: Partial<HassEntity>): void;
+    /**
+     * Simulate entity registry update
+     */
+    updateEntityRegistry(entityId: string, updates: Partial<EntityRegistryEntry>): void;
+    /**
+     * Simulate area registry update
+     */
+    updateAreaRegistry(areaId: string, updates: Partial<AreaRegistryEntry>): void;
+    /**
+     * Simulate device registry update
+     */
+    updateDeviceRegistry(deviceId: string, updates: Partial<DeviceRegistryEntry>): void;
+    /**
+     * Emit custom event - sends proper WebSocket event messages to subscriptions
+     */
+    emitEvent(event: HAEvent<any>): void;
+    /**
+     * Handle subscribe_events command
+     */
+    private handleSubscribeEvents;
+    /**
+     * Handle unsubscribe_events command
+     */
+    private handleUnsubscribeEvents;
+    /**
+     * Get current fixtures
+     *
+     * SyncLayer calls this to load fixtures into its store.
+     */
+    getFixtures(): Fixtures;
+    /**
+     * Load new fixtures
+     */
+    loadFixtures(fixtures: Partial<Fixtures>): void;
+    /**
+     * Clear tracking data
+     */
+    clearTracking(): void;
+    /**
+     * Get last service call
+     */
+    getLastServiceCall(): (typeof this.serviceCalls)[number] | undefined;
+    /**
+     * Get last command
+     */
+    getLastCommand(): (typeof this.sentCommands)[number] | undefined;
+    private delay;
+    private sendResponse;
+    private handleEntityUpdate;
+    private handleServiceCall;
+    /**
+     * Handle automatic reactions to service calls using behavior handlers
+     */
+    private handleServiceReaction;
+    /**
+     * Resolve target entities from service call target
+     */
+    private resolveTargetEntities;
+    /**
+     * Set state with custom context (internal use)
+     */
+    private setStateWithContext;
+    /**
+     * Enable/disable automatic reactions
+     */
+    setAutoReact(enabled: boolean): void;
+    /**
+     * Set reaction delay (useful for testing timing)
+     */
+    setReactionDelay(delay: number): void;
+    private generateId;
+}
+/**
+ * Export types
+ */
+export type { Fixtures };

package/dist/testing/types.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Testing types
+ *
+ * Type definitions for testing utilities and mocks.
+ *
+ * @packageDocumentation
+ */
+import type { AreaEntry, DeviceEntry, EntityRegistryEntry } from "@glasshome/ha-types";
+import type { HassEntity } from "../core/types";
+import type { EntityHistoryState } from "../history/types";
+import type { WeatherForecast } from "../weather/types";
+/**
+ * Area registry entry
+ *
+ * @alias AreaEntry
+ * @note AreaEntry uses 'id' field, not 'area_id'
+ */
+export type AreaRegistryEntry = AreaEntry;
+/**
+ * Device registry entry
+ *
+ * @alias DeviceEntry
+ */
+export type DeviceRegistryEntry = DeviceEntry;
+/**
+ * Floor registry entry
+ */
+export interface FloorRegistryEntry {
+    floor_id: string;
+    name: string;
+    level: number;
+    icon: string | null;
+    aliases: string[];
+    created_at: string;
+    modified_at: string;
+}
+/**
+ * Label registry entry
+ */
+export interface LabelRegistryEntry {
+    label_id: string;
+    name: string;
+    color: string | null;
+    icon: string | null;
+    description: string | null;
+    created_at: string;
+    modified_at: string;
+}
+/**
+ * Fixture data for testing
+ */
+export interface Fixtures {
+    /** Entity states */
+    entities: Record<string, HassEntity>;
+    /** Entity registry */
+    entityRegistry: EntityRegistryEntry[];
+    /** Device registry */
+    deviceRegistry: DeviceRegistryEntry[];
+    /** Area registry */
+    areaRegistry: AreaRegistryEntry[];
+    /** Floor registry */
+    floorRegistry: FloorRegistryEntry[];
+    /** Label registry */
+    labelRegistry: LabelRegistryEntry[];
+    /** History data for entities (entityId -> history states array) */
+    history?: Record<string, EntityHistoryState[]>;
+    /** Weather forecasts data (entityId -> forecastType -> forecast array) */
+    forecasts?: Record<string, Record<string, WeatherForecast[]>>;
+}
+/**
+ * Options for simulating state changes
+ */
+export interface StateChangeOptions {
+    /** Delay before emitting (ms) */
+    delay?: number;
+    /** Only update specific attributes */
+    attributesOnly?: boolean;
+}
+/**
+ * Options for simulating registry updates
+ */
+export interface RegistryUpdateOptions {
+    /** Delay before emitting (ms) */
+    delay?: number;
+    /** Emit event immediately */
+    immediate?: boolean;
+}

package/dist/types-Csog0nqk.js

@@ -0,0 +1,10 @@
+//#region src/core/types.ts
+/**
+* Extract domain from entity ID
+*/
+function extractDomain(entityId) {
+	return entityId.split(".")[0] ?? "";
+}
+
+//#endregion
+export { extractDomain };

package/dist/weather/fetch.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Weather Forecast Fetching
+ *
+ * @packageDocumentation
+ */
+import type { EntityId } from "../core/types";
+import type { ForecastType, WeatherForecast, WeatherForecastData, WeatherForecastsData } from "./types";
+/**
+ * Fetch forecast for a single entity and type
+ */
+export declare function fetchForecast(entityId: EntityId, type: ForecastType): Promise<WeatherForecast[]>;
+/**
+ * Fetch forecasts for a single entity and multiple types
+ */
+export declare function fetchForecasts(entityId: EntityId, types: ForecastType[]): Promise<WeatherForecastsData>;
+/**
+ * Fetch forecast data with error handling
+ */
+export declare function fetchForecastData(entityId: EntityId, type: ForecastType): Promise<WeatherForecastData>;

package/dist/weather/query.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Weather Forecast Query Builder
+ *
+ * @packageDocumentation
+ */
+import type { EntityId } from "../core/types";
+import type { ForecastType, WeatherForecastData, WeatherForecastsData } from "./types";
+/**
+ * Get forecast for a single entity and type
+ */
+export declare function getForecast(entityId: EntityId, type: ForecastType): Promise<WeatherForecastData>;
+/**
+ * Get forecasts for a single entity and multiple types
+ */
+export declare function getForecasts(entityId: EntityId, types: ForecastType[]): Promise<WeatherForecastsData>;
+/**
+ * Refresh forecast
+ */
+export declare function refreshForecast(entityId: EntityId, type: ForecastType): Promise<WeatherForecastData>;
+/**
+ * Refresh forecasts
+ */
+export declare function refreshForecasts(entityId: EntityId, types: ForecastType[]): Promise<WeatherForecastsData>;