@glasshome/sync-layer 0.7.1 → 0.8.0

package/dist/index.d.ts

@@ -1,60 +1,1297 @@
+import { A as HassEntity, C as DeviceRegistryEntry, D as EntityView, E as EntityId, F as StatisticData, I as StatisticMetadata, L as UnsubscribeFunc, M as LabelRegistryEntry, N as MapFunc, O as FloorId, P as PredicateFunc, R as extractDomain, S as DeviceId, T as EntityDomain, _ as AreaId, a as toggle, b as Callback, c as updateEntity, d as EntityUpdateFields, f as ServiceCallContext, g as CalendarWindowOptions, h as CalendarEventsData, i as sendCommand, j as LabelId, k as FloorRegistryEntry, l as CommandOptions, m as CalendarEvent, n as batchServiceCalls, o as turnOff, p as ServiceTarget, r as callService, s as turnOn, t as batchEntityUpdates, u as CommandResult, v as AreaRegistryEntry, w as DeviceView, x as ConnectionState, y as AreaView } from "./service-C8H42I-Q.js";
+import { WorkerScope, runHaBridgeWorker } from "./worker/worker-main.js";
+import { Auth, ConnectionOptions as ConnectionOptions$1 } from "home-assistant-js-websocket";
+import { Store } from "solid-js/store";
+import { CapabilityGrant } from "@glasshome/widget-contract";
+import { CallServiceRequest, CoreEventType, Domain, EntityCategory, EntityRegistryEntry, EntityRegistryEntry as EntityRegistryEntry$1, EventStateChangedData, HAEvent, HAEvent as HAEvent$1, HassConfig, HassUnitSystem, RegistryEntryDisabler, RegistryEntryHider, ServiceCall, ServiceName, WsCommandType, WsResult } from "@glasshome/ha-types";
+//#region src/camera/types.d.ts
 /**
- * @glasshome/sync-layer
+ * Stream format
+ * Supported stream formats from Home Assistant Camera API
+ */
+type StreamFormat = "hls" | "webrtc" | "mjpeg";
+/**
+ * Camera stream data
+ */
+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
+ */
+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
+ */
+interface CameraStreams {
+  /** Entity ID -> Stream data */
+  [entityId: EntityId]: CameraStreamData;
+}
+/**
+ * Options for stream queries
+ */
+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
+ */
+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
+ */
+interface StreamResult {
+  /** Stream data */
+  data: CameraStreamData | null;
+  /** Loading state */
+  loading: boolean;
+  /** Error if any */
+  error: Error | null;
+}
+//#endregion
+//#region src/history/types.d.ts
+/**
+ * History states record
+ * Maps entity IDs to their history state arrays
+ *
+ * Based on HA frontend: HistoryStates
+ */
+type HistoryStates = Record<string, EntityHistoryState[]>;
+/**
+ * Entity history state point
+ * Represents a single point in entity history from Home Assistant
+ *
+ * Based on HA frontend: EntityHistoryState
+ */
+interface EntityHistoryState {
+  /** State value (compressed format from HA) */
+  s: string;
+  /** Attributes */
+  a: Record<string, any>;
+  /** Last changed timestamp (Unix timestamp in seconds, optional; if set, also applies to lu) */
+  lc?: number;
+  /** Last updated timestamp (Unix timestamp in seconds) */
+  lu: number;
+}
+/**
+ * Timeline state point
+ * Represents a point in the timeline with full data
+ */
+interface TimelineState {
+  /** Timestamp (Unix timestamp in seconds) */
+  timestamp: number;
+  /** State value */
+  state: string;
+  /** Attributes */
+  attributes?: Record<string, any>;
+  /** Last changed timestamp */
+  lastChanged?: number;
+  /** Last updated timestamp */
+  lastUpdated: number;
+}
+/**
+ * History data for a single entity
+ */
+interface EntityHistoryData {
+  /** Entity ID */
+  entityId: EntityId;
+  /** Timeline data points */
+  timeline: TimelineState[];
+  /** Compressed history states (from HA API) */
+  entityHistory: EntityHistoryState[];
+  /** Loading state */
+  loading: boolean;
+  /** Error if any */
+  error: Error | null;
+  /** Last fetched timestamp */
+  lastFetched: number | null;
+}
+/**
+ * History data for multiple entities
+ */
+interface HistoryData {
+  /** Entity ID -> History data */
+  [entityId: EntityId]: EntityHistoryData;
+}
+/**
+ * Options for history queries
+ *
+ * Based on HA frontend fetchDateWS parameters
+ */
+interface HistoryQueryOptions {
+  /** Start time (required) */
+  startTime: Date;
+  /** End time (optional, defaults to now) */
+  endTime?: Date;
+  /** Entity IDs to query (optional, defaults to all) */
+  entityIds?: EntityId[];
+  /** Include start time state */
+  includeStartTimeState?: boolean;
+  /** Only significant changes */
+  significantChangesOnly?: boolean;
+  /** Minimal response (defaults to true, matching HA frontend) */
+  minimalResponse?: boolean;
+  /** No attributes (if not provided, automatically determined based on entity domains) */
+  noAttributes?: boolean;
+}
+/**
+ * Single entity history query options
+ */
+interface EntityHistoryQueryOptions {
+  /** Start time (required) */
+  startTime: Date;
+  /** End time (optional, defaults to now) */
+  endTime?: Date;
+  /** Include start time state */
+  includeStartTimeState?: boolean;
+  /** Only significant changes */
+  significantChangesOnly?: boolean;
+  /** Minimal response (no attributes) */
+  minimalResponse?: boolean;
+  /** No attributes */
+  noAttributes?: boolean;
+}
+/**
+ * History query result
+ */
+interface HistoryResult {
+  /** History data for each entity */
+  data: HistoryData;
+  /** Loading state */
+  loading: boolean;
+  /** Error if any */
+  error: Error | null;
+}
+/**
+ * Single entity history result
+ */
+interface EntityHistoryResult {
+  /** History data */
+  data: EntityHistoryData | null;
+  /** Loading state */
+  loading: boolean;
+  /** Error if any */
+  error: Error | null;
+}
+//#endregion
+//#region src/weather/types.d.ts
+/**
+ * Forecast type
+ * Supported forecast types from Home Assistant Weather API
+ */
+type ForecastType = "hourly" | "daily" | "twice_daily";
+/**
+ * Weather forecast entry
+ * Represents a single forecast point from Home Assistant
+ */
+interface WeatherForecast {
+  /** Forecast datetime (ISO 8601) */
+  datetime: string;
+  /** Temperature (in unit system) */
+  temperature?: number;
+  /** Temperature low (for daily forecasts) */
+  temp_low?: number;
+  /** Temperature high (for daily forecasts) */
+  temp_high?: number;
+  /** Humidity percentage */
+  humidity?: number;
+  /** Wind bearing (degrees) */
+  wind_bearing?: number;
+  /** Wind speed (in unit system) */
+  wind_speed?: number;
+  /** Precipitation probability (0-100) */
+  precipitation?: number;
+  /** Precipitation amount (in unit system) */
+  precipitation_probability?: number;
+  /** Condition (e.g., "sunny", "cloudy", "rainy") */
+  condition?: string;
+  /** Pressure (in unit system) */
+  pressure?: number;
+  /** Cloud coverage (0-100) */
+  cloud_coverage?: number;
+  /** UV index */
+  uv_index?: number;
+  /** Additional forecast data */
+  [key: string]: any;
+}
+/**
+ * Weather forecast data for a single type
+ */
+interface WeatherForecastData {
+  /** Entity ID */
+  entityId: EntityId;
+  /** Forecast type */
+  type: ForecastType;
+  /** Forecast entries */
+  forecast: WeatherForecast[];
+  /** Loading state */
+  loading: boolean;
+  /** Error if any */
+  error: Error | null;
+  /** Last fetched timestamp */
+  lastFetched: number | null;
+}
+/**
+ * Weather forecast data for multiple types
+ */
+interface WeatherForecastsData {
+  /** Entity ID */
+  entityId: EntityId;
+  /** Forecast data by type */
+  forecasts: Partial<Record<ForecastType, WeatherForecast[]>>;
+  /** Loading states by type */
+  loading: Partial<Record<ForecastType, boolean>>;
+  /** Errors by type */
+  errors: Partial<Record<ForecastType, Error | null>>;
+  /** Last fetched timestamps by type */
+  lastFetched: Partial<Record<ForecastType, number | null>>;
+}
+/**
+ * Weather forecast data for multiple entities
+ */
+interface WeatherForecasts {
+  /** Entity ID -> Forecast data */
+  [entityId: EntityId]: WeatherForecastsData;
+}
+/**
+ * Options for forecast queries
+ */
+interface ForecastQueryOptions {
+  /** Forecast type(s) to fetch */
+  type?: ForecastType;
+  /** Multiple forecast types to fetch */
+  types?: ForecastType[];
+}
+/**
+ * Single entity forecast query options
+ */
+interface EntityForecastQueryOptions {
+  /** Forecast type(s) to fetch */
+  type?: ForecastType;
+  /** Multiple forecast types to fetch */
+  types?: ForecastType[];
+}
+/**
+ * Forecast query result for a single type
+ */
+interface ForecastResult {
+  /** Forecast data */
+  data: WeatherForecastData | null;
+  /** Loading state */
+  loading: boolean;
+  /** Error if any */
+  error: Error | null;
+}
+/**
+ * Forecast query result for multiple types
+ */
+interface ForecastsResult {
+  /** Forecast data */
+  data: WeatherForecastsData | null;
+  /** Loading states by type */
+  loading: Partial<Record<ForecastType, boolean>>;
+  /** Errors by type */
+  errors: Partial<Record<ForecastType, Error | null>>;
+}
+//#endregion
+//#region src/core/store.d.ts
+interface GlassHomeState {
+  /** Current connection state */
+  connectionState: ConnectionState;
+  /** Connection error (if any) */
+  connectionError: Error | null;
+  /** Home Assistant base URL */
+  hassUrl: string | null;
+  /** Same-origin prefix for the HA media proxy (e.g. "/ha-proxy/media"), or null
+   *  to resolve media directly against hassUrl. Set by the host at connect. */
+  mediaProxyBase: string | null;
+  /** Home Assistant core config (unit system, locale, currency); null until loaded */
+  config: import("@glasshome/ha-types").HassConfig | null;
+  /** Live entity state (keyed by entity_id) */
+  entities: Record<EntityId, HassEntity>;
+  /** Entity registry entries (keyed by entity_id) */
+  entityRegistry: Record<EntityId, import("@glasshome/ha-types").EntityRegistryEntry>;
+  /** Device registry entries (keyed by device ID) */
+  devices: Record<DeviceId, DeviceRegistryEntry>;
+  /** Area registry entries (keyed by area ID) */
+  areas: Record<AreaId, AreaRegistryEntry>;
+  /** Floor registry entries (keyed by floor ID) */
+  floors: Record<FloorId, FloorRegistryEntry>;
+  /** Label registry entries (keyed by label ID) */
+  labels: Record<LabelId, LabelRegistryEntry>;
+  /** Statistics data (keyed by statistic_id) */
+  statistics: Record<string, StatisticData[]>;
+  /** Statistics metadata (keyed by statistic_id) */
+  statisticsMetadata: Record<string, StatisticMetadata>;
+  /** Entity history data (keyed by entity ID) */
+  history: Record<EntityId, EntityHistoryData>;
+  /** Weather forecasts data (keyed by entity ID) */
+  forecasts: Record<EntityId, WeatherForecastsData>;
+  /** Live calendar events (keyed by entity ID), maintained by calendar/track */
+  calendars: Record<EntityId, CalendarEventsData>;
+  /** Camera stream data (keyed by entity ID) */
+  streams: Record<EntityId, CameraStreamData>;
+}
+/**
+ * Module-level SolidJS createStore singleton
+ *
+ * `state` is a read-only reactive proxy.
+ * `setState` is used for mutations via produce() or direct path setting.
+ *
+ * @example
+ * ```typescript
+ * import { state, setState } from '@glasshome/sync-layer/core/store';
+ *
+ * // Read state (auto-tracked in SolidJS reactive contexts)
+ * const entities = state.entities;
+ *
+ * // Mutate via produce
+ * setState(produce((s) => {
+ *   s.entities['light.living_room'] = newEntity;
+ * }));
+ *
+ * // Bulk replace
+ * setState("entities", reconcile(newEntities));
+ * ```
+ */
+declare global {
+  var __GH_SYNC_LAYER_STORE__: boolean | undefined;
+}
+declare const state: Store<GlassHomeState>;
+//#endregion
+//#region src/connection/auth.d.ts
+/**
+ * Options for OAuth authentication flow
+ */
+interface OAuthOptions {
+  /**
+   * Home Assistant instance URL
+   * (e.g., "https://homeassistant.local:8123")
+   */
+  url: string;
+  /**
+   * Client ID for OAuth
+   * Typically the same as the Home Assistant URL
+   */
+  clientId: string;
+  /**
+   * Redirect URI after OAuth authorization
+   * (e.g., "https://myapp.com/auth/callback")
+   */
+  redirectUri?: string;
+  /**
+   * Optional authorization code if already obtained
+   * If provided, will be used directly instead of starting OAuth flow
+   */
+  authCode?: string;
+  /**
+   * Optional function to get authorization code
+   * If provided, will be called to get the code before token exchange
+   */
+  getAuthCode?: () => Promise<string>;
+  /**
+   * Optional function to save auth data
+   * Useful for persisting auth tokens
+   */
+  saveAuth?: (auth: Auth) => void | Promise<void>;
+  /**
+   * Optional function to load saved auth data
+   */
+  loadAuth?: () => Promise<Auth | null>;
+  /**
+   * Optional flag to limit to specific Home Assistant instance
+   */
+  limitHassInstance?: boolean;
+}
+//#endregion
+//#region src/connection/manager.d.ts
+/**
+ * Options for initializing a connection
+ */
+interface ConnectionOptions {
+  url: string;
+  auth: Auth | string | OAuthOptions;
+  createSocket?: ConnectionOptions$1["createSocket"];
+  onConnect?: () => void;
+  onDisconnect?: () => void;
+  onReconnect?: () => void;
+  onError?: (error: Error) => void;
+}
+/**
+ * Disconnect from Home Assistant
+ */
+declare function disconnect(): void;
+/**
+ * Check if currently connected
+ */
+declare function isConnected(): boolean;
+/**
+ * Get the underlying socket's connected flag.
+ *
+ * Exposed so apps can render a connection indicator in the UI. Distinct from
+ * `isConnected()` which reflects the manager's internal lifecycle state.
+ */
+declare function getConnectionState(): boolean;
+//#endregion
+//#region src/connection/types.d.ts
+/**
+ * Unified connection interface for Home Assistant connections
  *
- * Type-safe, reactive state synchronization layer for Home Assistant
- * Uses SolidJS createStore for reactive state management.
+ * This interface is implemented by both:
+ * - MockConnection (for testing)
+ * - Wrapped HA Connection (for production)
  *
- * THIS ENTRY IS AN ACCESS-CONTROL SURFACE, not an ordinary barrel. The host
- * import map serves it to every untrusted widget bundle, so anything exported
- * here is callable by widget code. Before adding an export, ask who outside
- * this package needs it: in-package callers use relative imports and need
- * nothing here, host-only lifecycle belongs on claimHostApi(), and widget
- * hooks belong on the ./solid subpath. Types are always safe; they carry no
- * authority. scripts/check-widget-reachable-surface.ts guards this, but it is
- * a DENYLIST of known-dangerous names and is blind to any handle invented
- * after it was written — it cannot be relied on to catch a new mistake.
+ * @example
+ * ```typescript
+ * // In tests
+ * const mockConn: SyncLayerConnection = new MockConnection(fixtures);
+ * await syncLayer.connect({ connection: mockConn });
+ *
+ * // In production
+ * const haConn = await createConnection({ auth });
+ * const wrappedConn: SyncLayerConnection = wrapHAConnection(haConn);
+ * await syncLayer.connect({ connection: wrappedConn });
+ * ```
+ */
+interface SyncLayerConnection {
+  /**
+   * Connect to Home Assistant (or mock)
+   *
+   * Establishes the WebSocket connection. For real HA connections,
+   * this is called automatically by createConnection. For mock connections,
+   * this simulates the connection process.
+   *
+   * @returns Promise that resolves when connection is established
+   */
+  connect(): Promise<void>;
+  /**
+   * Disconnect from Home Assistant
+   *
+   * Closes the WebSocket connection and cleans up resources.
+   */
+  disconnect(): void;
+  /**
+   * Check if connection is currently active
+   *
+   * @returns true if connected, false otherwise
+   */
+  get connected$(): boolean;
+  /**
+   * Authenticate with Home Assistant
+   *
+   * Sends authentication credentials. For real HA connections,
+   * authentication is handled during connection creation. For mock connections,
+   * this simulates the authentication process.
+   *
+   * @param accessToken - Access token for authentication
+   * @returns Promise that resolves when authentication completes
+   */
+  authenticate(accessToken: string): Promise<void>;
+  /**
+   * Get current authentication state
+   *
+   * @returns Authentication state: "pending", "authenticated", or "failed"
+   */
+  get authState(): "pending" | "authenticated" | "failed";
+  /**
+   * Subscribe to Home Assistant events
+   *
+   * Registers a callback to receive events of a specific type (or all events).
+   *
+   * @param callback - Function called when events are received
+   * @param eventType - Optional event type filter (e.g., "entity_registry_updated")
+   * @returns Promise resolving to unsubscribe function
+   *
+   * @example
+   * ```typescript
+   * const unsubscribe = await connection.subscribeEvents((event) => {
+   *   console.log("Event received:", event);
+   * }, "entity_registry_updated");
+   *
+   * // Later, unsubscribe
+   * await unsubscribe();
+   * ```
+   */
+  subscribeEvents(callback: (event: HAEvent$1<any>) => void, eventType?: string): Promise<() => void>;
+  /**
+   * Subscribe to message stream
+   *
+   * Used for streaming subscriptions like history/stream.
+   * Sends a subscription message and receives streaming responses.
+   *
+   * @param callback - Function called when messages are received
+   * @param message - Subscription message (e.g., { type: "history/stream", ... })
+   * @returns Promise resolving to unsubscribe function
+   *
+   * @example
+   * ```typescript
+   * const unsubscribe = await connection.subscribeMessage((message) => {
+   *   console.log("Stream message:", message);
+   * }, {
+   *   type: "history/stream",
+   *   entity_ids: ["sensor.temperature"],
+   *   start_time: startTime.toISOString(),
+   * });
+   *
+   * // Later, unsubscribe
+   * await unsubscribe();
+   * ```
+   */
+  subscribeMessage<T>(callback: (message: T) => void, message: any): Promise<() => Promise<void>>;
+  /**
+   * Send a message and wait for response
+   *
+   * Sends a WebSocket message and returns a promise that resolves
+   * with the response.
+   *
+   * @param message - Message to send
+   * @returns Promise resolving to the response data
+   *
+   * @example
+   * ```typescript
+   * const states = await connection.sendMessagePromise({
+   *   type: "get_states",
+   * });
+   * ```
+   */
+  sendMessagePromise<T>(message: any): Promise<T>;
+  /**
+   * Add event listener for WebSocket messages
+   *
+   * Registers a handler for all WebSocket messages (not just events).
+   * Useful for listening to auth messages, connection status, etc.
+   *
+   * @param handler - Function called when any message is received
+   * @returns Unsubscribe function
+   *
+   * @example
+   * ```typescript
+   * const unsubscribe = connection.addEventListener((message) => {
+   *   console.log("Any message:", message);
+   * });
+   *
+   * // Later, unsubscribe
+   * unsubscribe();
+   * ```
+   */
+  addEventListener(handler: (message: any) => void): () => void;
+}
+//#endregion
+//#region src/connection/subscription-manager.d.ts
+declare global {
+  var __GH_SYNC_LAYER_SUB_MGR__: boolean | undefined;
+}
+/**
+ * Register an entity for live updates. Returns an unregister function.
+ * Call from useEntity/useEntities hooks via onCleanup.
+ */
+declare function registerEntity(entityId: EntityId): () => void;
+//#endregion
+//#region src/query/area-builder.d.ts
+interface AreaQueryBuilder$1 {
+  byFloor(floorId: FloorId): AreaQueryBuilder$1;
+  byLabel(labelId: LabelId): AreaQueryBuilder$1;
+  where(predicate: PredicateFunc<AreaView>): AreaQueryBuilder$1;
+  orderBy(key: keyof AreaView | string, direction?: "asc" | "desc"): AreaQueryBuilder$1;
+  get(): AreaView[];
+  first(): AreaView | undefined;
+  subscribe(callback: Callback<AreaView[]>): UnsubscribeFunc;
+}
+/**
+ * Create a query builder for areas
+ */
+declare function areas(): AreaQueryBuilder$1;
+/**
+ * Create a query for a single area
+ */
+declare function area(areaId: AreaId): AreaView | undefined;
+//#endregion
+//#region src/query/types.d.ts
+/**
+ * Main query builder interface for multiple entities
+ *
+ * Provides a fluent API for filtering, sorting, projecting, and subscribing.
+ *
+ * @template T - The result type (defaults to EntityView)
+ */
+interface EntitiesQueryBuilder<T = EntityView> {
+  /**
+   * Filter by area
+   *
+   * @param areaId - Area ID to filter by
+   * @returns Query builder for chaining
+   */
+  byArea(areaId: AreaId): EntitiesQueryBuilder<T>;
+  /**
+   * Filter by domain
+   *
+   * @param domain - Domain to filter by (e.g., "light", "sensor")
+   * @returns Query builder for chaining
+   */
+  byDomain(domain: EntityDomain): EntitiesQueryBuilder<T>;
+  /**
+   * Filter by device
+   *
+   * @param deviceId - Device ID to filter by
+   * @returns Query builder for chaining
+   */
+  byDevice(deviceId: DeviceId): EntitiesQueryBuilder<T>;
+  /**
+   * Filter by floor
+   *
+   * @param floorId - Floor ID to filter by
+   * @returns Query builder for chaining
+   */
+  byFloor(floorId: FloorId): EntitiesQueryBuilder<T>;
+  /**
+   * Filter by label
+   *
+   * @param labelId - Label ID to filter by
+   * @returns Query builder for chaining
+   */
+  byLabel(labelId: LabelId): EntitiesQueryBuilder<T>;
+  /**
+   * Filter with custom predicate
+   *
+   * @param predicate - Function to test each entity
+   * @returns Query builder for chaining
+   */
+  where(predicate: PredicateFunc<EntityView>): EntitiesQueryBuilder<T>;
+  /**
+   * Search entities by text (searches id, name, friendlyName)
+   *
+   * @param searchText - Text to search for
+   * @returns Query builder for chaining
+   */
+  search(searchText: string): EntitiesQueryBuilder<T>;
+  /**
+   * Sort results
+   *
+   * @param key - Property key or dot-path (e.g., "name", "attributes.brightness")
+   * @param direction - Sort direction ("asc" or "desc")
+   * @returns Query builder for chaining
+   */
+  orderBy(key: string, direction?: "asc" | "desc"): EntitiesQueryBuilder<T>;
+  /**
+   * Project to entity IDs only
+   *
+   * @returns Query builder for entity IDs
+   */
+  ids(): EntitiesQueryBuilder<EntityId>;
+  /**
+   * Pick specific fields
+   *
+   * @param keys - Array of field names to include
+   * @returns Query builder with picked fields
+   */
+  pick<K extends keyof EntityView>(keys: K[]): EntitiesQueryBuilder<Pick<EntityView, K>>;
+  /**
+   * Extract a single field from each entity
+   *
+   * @param key - Field name to extract
+   * @returns Query builder for field values
+   */
+  pluck<K extends keyof EntityView>(key: K): EntitiesQueryBuilder<EntityView[K]>;
+  /**
+   * Map entities to new values
+   *
+   * @param mapper - Function to transform each entity
+   * @returns Query builder for mapped values
+   */
+  map<R>(mapper: MapFunc<EntityView, R>): EntitiesQueryBuilder<R>;
+  /**
+   * Limit the number of results
+   *
+   * @param limit - Maximum number of results to return
+   * @returns Query builder for chaining
+   */
+  take(limit: number): EntitiesQueryBuilder<T>;
+  /**
+   * Skip a number of results (for pagination)
+   *
+   * @param count - Number of results to skip
+   * @returns Query builder for chaining
+   */
+  skip(count: number): EntitiesQueryBuilder<T>;
+  /**
+   * Get distinct values by a key
+   *
+   * @param key - Field name or dot-path to get distinct values for
+   * @returns Query builder for distinct values
+   */
+  distinct(key: string): EntitiesQueryBuilder<T>;
+  /**
+   * Execute query and return results
+   *
+   * @returns Array of results
+   */
+  get(): T[];
+  /**
+   * Get first result
+   *
+   * @returns First result or undefined
+   */
+  first(): T | undefined;
+  /**
+   * Subscribe to query results
+   *
+   * Receives updates when entities matching the query change.
+   *
+   * @param callback - Function called with results
+   * @returns Unsubscribe function
+   */
+  subscribe(callback: Callback<T[]>): UnsubscribeFunc;
+}
+/**
+ * Query builder interface for areas
+ */
+interface AreaQueryBuilder {
+  /**
+   * Filter areas by floor
+   */
+  byFloor(floorId: FloorId): AreaQueryBuilder;
+  /**
+   * Filter areas by label
+   */
+  byLabel(labelId: LabelId): AreaQueryBuilder;
+  /**
+   * Filter areas using a predicate
+   */
+  where(predicate: PredicateFunc<AreaView>): AreaQueryBuilder;
+  /**
+   * Order results by a key
+   */
+  orderBy(key: keyof AreaView | string, direction?: "asc" | "desc"): AreaQueryBuilder;
+  /**
+   * Execute query and get results
+   */
+  get(): AreaView[];
+  /**
+   * Get first result
+   */
+  first(): AreaView | undefined;
+  /**
+   * Subscribe to query results
+   */
+  subscribe(callback: Callback<AreaView[]>): UnsubscribeFunc;
+}
+/**
+ * Query builder interface for a single entity
+ */
+interface EntityQueryBuilder {
+  /**
+   * Get entity view
+   *
+   * @returns Entity view or undefined
+   */
+  get(): EntityView | undefined;
+  /**
+   * Extract a single field
+   *
+   * @param key - Field name to extract
+   * @returns Field value or undefined
+   */
+  pluck<K extends keyof EntityView>(key: K): EntityView[K] | undefined;
+  /**
+   * Subscribe to entity changes
+   *
+   * @param callback - Function called with entity view
+   * @returns Unsubscribe function
+   */
+  subscribe(callback: Callback<EntityView | undefined>): UnsubscribeFunc;
+}
+//#endregion
+//#region src/query/builder.d.ts
+/**
+ * Create a query builder for multiple entities
+ */
+declare function entities(): EntitiesQueryBuilder<EntityView>;
+/**
+ * Create a query builder for a single entity
+ */
+declare function entity(entityId: EntityId): EntityQueryBuilder;
+//#endregion
+//#region src/query/helpers.d.ts
+/**
+ * Create a search query builder
+ */
+declare function searchEntities(searchText: string): EntitiesQueryBuilder<EntityView>;
+/**
+ * Create a query for entities in an area by domain
+ */
+declare function entitiesByAreaAndDomain(areaId: AreaId, domain: EntityDomain): EntitiesQueryBuilder<EntityView>;
+/**
+ * Create a query for entities matching a predicate
+ */
+declare function entitiesWhere(predicate: (entity: EntityView) => boolean): EntitiesQueryBuilder<EntityView>;
+//#endregion
+//#region src/camera/fetch.d.ts
+/**
+ * Fetch stream for a camera entity.
+ * Returns a public demo HLS stream when not connected.
+ */
+declare function fetchStream(entityId: EntityId, format?: StreamFormat): Promise<string | null>;
+/**
+ * Fetch stream data for a camera entity
+ */
+declare function fetchStreamData(entityId: EntityId, options?: StreamQueryOptions): Promise<CameraStreamData>;
+//#endregion
+//#region src/camera/query.d.ts
+/**
+ * Get stream for a camera entity
+ */
+declare function getStream(entityId: EntityId, options?: EntityStreamQueryOptions): Promise<CameraStreamData>;
+/**
+ * Refresh stream for a camera entity
+ */
+declare function refreshStream(entityId: EntityId, format?: StreamFormat): Promise<CameraStreamData>;
+//#endregion
+//#region src/energy/prefs.d.ts
+/**
+ * An energy source entry. Only the fields the widgets read are typed; the
+ * rest is passthrough. HA emits one of several shapes keyed by `type`:
+ * - grid: `flow_from[].stat_energy_from`, `flow_to[].stat_energy_to`
+ * - solar: `stat_energy_from`
+ * - battery: `stat_energy_from`, `stat_energy_to`
+ */
+interface EnergySource {
+  type: "grid" | "solar" | "battery" | "gas" | "water" | string;
+  stat_energy_from?: string;
+  stat_energy_to?: string;
+  flow_from?: Array<{
+    stat_energy_from: string;
+    [key: string]: unknown;
+  }>;
+  flow_to?: Array<{
+    stat_energy_to: string;
+    [key: string]: unknown;
+  }>;
+  [key: string]: unknown;
+}
+/** A device tracked on the energy dashboard. */
+interface EnergyDeviceConsumption {
+  stat_consumption: string;
+  name?: string;
+  [key: string]: unknown;
+}
+/**
+ * HA energy dashboard preferences.
+ *
+ * Based on HA frontend: EnergyPreferences.
+ */
+interface EnergyPreferences {
+  energy_sources: EnergySource[];
+  device_consumption: EnergyDeviceConsumption[];
+  [key: string]: unknown;
+}
+/** Connection surface used by energy prefs fetching. */
+type EnergyConnection = Pick<SyncLayerConnection, "sendMessagePromise">;
+/**
+ * Fetch the HA energy dashboard preferences.
+ *
+ * Returns `null` when no energy dashboard is configured (HA raises an error
+ * for `energy/get_prefs` in that case); callers treat `null` as "not
+ * configured".
+ */
+declare function fetchEnergyPreferences(connection: EnergyConnection): Promise<EnergyPreferences | null>;
+//#endregion
+//#region src/media/url.d.ts
+/**
+ * Resolve an HA media reference (e.g. an entity's `entity_picture`, a camera
+ * proxy path) to a URL the page can actually load.
+ *
+ * HA gives these as origin-relative paths (`/api/media_player_proxy/...?token=`)
+ * carrying their own signed token. A bare `<img src>` would resolve them against
+ * the dash origin and 404. When the host set `mediaProxyBase`, route through the
+ * same-origin media proxy so the page CSP (`img-src 'self'`) covers it in every
+ * mode, LAN and remote. Otherwise fall back to prefixing `hassUrl` directly
+ * (the LAN-only path, used until a transport sets the proxy base).
+ *
+ * Absolute URLs and non-path values pass through untouched.
+ */
+declare function hassMediaUrl(path: string | null | undefined): string | undefined;
+//#endregion
+//#region src/camera/webrtc.d.ts
+/** 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
+ */
+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().
+ */
+declare function startWebRtcSession(entityId: EntityId, sdpOffer: string, onCandidate: (candidate: RtcIceCandidateInit) => void): Promise<{
+  answer: string;
+  session: WebRtcSession;
+}>;
+/**
+ * Send a local ICE candidate to HA
+ */
+declare function sendWebRtcCandidate(entityId: EntityId, sessionId: string, candidate: RtcIceCandidateInit): Promise<void>;
+//#endregion
+//#region src/entities/area-views.d.ts
+/**
+ * Build a DeviceView from registry data
+ */
+declare function buildDeviceView(device: DeviceRegistryEntry): DeviceView;
+/**
+ * Build an AreaView for a single area from registry data.
+ */
+declare function buildAreaView(areaId: AreaId): AreaView;
+/**
+ * Get all area views. Membership is resolved in a single registry pass; entity
+ * views stay lazy per area (see `assembleAreaView`).
+ */
+declare function getAreaViews(): AreaView[];
+/**
+ * Get area view
+ */
+declare function getAreaView(areaId: AreaId): AreaView | undefined;
+//#endregion
+//#region src/entities/views.d.ts
+/**
+ * Build an EntityView from runtime state and registry metadata
+ */
+declare function buildEntityView(entity: HassEntity, registry: EntityRegistryEntry$1 | undefined): EntityView;
+/**
+ * Get or build an EntityView
+ */
+declare function getEntityView(entityId: EntityId): EntityView | undefined;
+/**
+ * Get multiple entity views
+ */
+declare function getEntityViews(entityIds: EntityId[]): EntityView[];
+/**
+ * Get all entity views
+ */
+declare function getAllEntityViews(): EntityView[];
+/**
+ * Shallow equality check for EntityView.
+ * Compares fields that affect rendering; skips lastUpdated (heartbeat noise).
+ */
+declare function entityViewEquals(a: EntityView | undefined, b: EntityView | undefined): boolean;
+//#endregion
+//#region src/history/constants.d.ts
+declare const DOMAINS_USE_LAST_UPDATED: readonly ["climate", "humidifier", "water_heater"];
+declare const NEED_ATTRIBUTE_DOMAINS: readonly ["climate", "humidifier", "input_datetime", "water_heater", "person", "device_tracker"];
+declare const LINE_ATTRIBUTES_TO_KEEP: readonly ["temperature", "current_temperature", "target_temp_low", "target_temp_high", "hvac_action", "humidity", "mode", "action", "current_humidity"];
+/**
+ * Check if an entity needs attributes in history response
+ */
+declare function entityIdHistoryNeedsAttributes(entityId: EntityId): boolean;
+//#endregion
+//#region src/history/fetch.d.ts
+/**
+ * Fetch history for entities during a time period
+ */
+declare function fetchHistory(options: HistoryQueryOptions): Promise<Record<EntityId, EntityHistoryState[]>>;
+/**
+ * Fetch history for a single entity
+ */
+declare function fetchEntityHistory(entityId: EntityId, options: EntityHistoryQueryOptions): Promise<EntityHistoryData>;
+/**
+ * Convert compressed history state to timeline state
+ */
+declare function historyStateToTimeline(s: EntityHistoryState): TimelineState;
+//#endregion
+//#region src/history/query.d.ts
+interface HistoryPoint {
+  entityId: EntityId;
+  stateValue: string;
+  attributes: Record<string, unknown>;
+  lastUpdated: number;
+  lastChanged?: number;
+}
+/** Hard cap on retained points per entity timeline. */
+declare const MAX_HISTORY_POINTS = 5760;
+/** Check if an entity has active history tracking. */
+declare function isHistoryTracked(entityId: EntityId): boolean;
+/** Start tracking history for an entity. Fetches initial backfill. */
+declare function trackEntityHistory(entityId: EntityId, options: EntityHistoryQueryOptions): Promise<EntityHistoryData>;
+/** Release one tracker. The entity's data is cleared only when the last one goes. */
+declare function untrackEntityHistory(entityId: EntityId): void;
+/**
+ * Append a state change to an entity's history.
+ * Called by the entity subscription handler when a tracked entity changes.
+ */
+declare function appendHistoryPoint(entityId: EntityId, stateValue: string, attributes: Record<string, unknown>, lastUpdated: number, lastChanged?: number): void;
+/**
+ * Append multiple history points in a single setState(produce(...)).
+ * Called by the rAF-batched subscription flush.
+ */
+declare function bulkAppendHistoryPoints(points: HistoryPoint[]): void;
+//#endregion
+//#region src/history/statistics.d.ts
+/**
+ * A single statistics bucket for one statistic id.
+ *
+ * HA 2023.6+ omits columns that were not requested and may omit null
+ * columns, so every value field is optional. `start`/`end` are normalized
+ * to ms epoch numbers regardless of the version's wire format.
+ */
+interface StatisticValue {
+  /** Bucket start (ms epoch) */
+  start: number;
+  /** Bucket end (ms epoch) */
+  end: number;
+  mean?: number;
+  sum?: number;
+  min?: number;
+  max?: number;
+  state?: number;
+  change?: number;
+}
+/** Aggregation period for statistics buckets. */
+type StatisticsPeriod = "5minute" | "hour" | "day" | "week" | "month";
+/**
+ * Options for {@link fetchStatisticsDuringPeriod}.
+ */
+interface StatisticsQueryOptions {
+  /** Start time (required) */
+  startTime: Date;
+  /** End time (optional, defaults to now on the HA side) */
+  endTime?: Date;
+  /** Aggregation period */
+  period: StatisticsPeriod;
+}
+/** Connection surface used by statistics fetching. */
+type StatisticsConnection = Pick<SyncLayerConnection, "sendMessagePromise">;
+/**
+ * HA returns start/end as ISO strings or ms numbers depending on version.
+ * Normalize both shapes to ms epoch numbers; unparseable values become NaN.
+ */
+declare function normalizeStatisticTime(value: unknown): number;
+/**
+ * Fetch long-term statistics for one or more statistic ids during a period.
+ *
+ * Statistic ids with no data are returned as empty arrays so callers never
+ * hit `undefined`.
+ */
+declare function fetchStatisticsDuringPeriod(connection: StatisticsConnection, statisticIds: string[], options: StatisticsQueryOptions): Promise<Record<string, StatisticValue[]>>;
+//#endregion
+//#region src/weather/fetch.d.ts
+/**
+ * Fetch forecast for a single entity and type
+ */
+declare function fetchForecast(entityId: EntityId, type: ForecastType): Promise<WeatherForecast[]>;
+/**
+ * Fetch forecasts for a single entity and multiple types
+ */
+declare function fetchForecasts(entityId: EntityId, types: ForecastType[]): Promise<WeatherForecastsData>;
+/**
+ * Fetch forecast data with error handling
+ */
+declare function fetchForecastData(entityId: EntityId, type: ForecastType): Promise<WeatherForecastData>;
+//#endregion
+//#region src/weather/query.d.ts
+/**
+ * Get forecast for a single entity and type
+ */
+declare function getForecast(entityId: EntityId, type: ForecastType): Promise<WeatherForecastData>;
+/**
+ * Get forecasts for a single entity and multiple types
+ */
+declare function getForecasts(entityId: EntityId, types: ForecastType[]): Promise<WeatherForecastsData>;
+/**
+ * Refresh forecast
+ */
+declare function refreshForecast(entityId: EntityId, type: ForecastType): Promise<WeatherForecastData>;
+/**
+ * Refresh forecasts
+ */
+declare function refreshForecasts(entityId: EntityId, types: ForecastType[]): Promise<WeatherForecastsData>;
+//#endregion
+//#region src/demo/demo-data.d.ts
+interface DemoFixtures {
+  entities: Record<string, HassEntity>;
+  entityRegistry: Record<string, EntityRegistryEntry$1>;
+  areas: Record<string, AreaRegistryEntry>;
+  devices: Record<string, DeviceRegistryEntry>;
+}
+/**
+ * Create ~30 curated apartment entity fixtures.
+ *
+ * Entities span lights, sensors, binary sensors, climate, covers,
+ * locks, switches, media player, weather, camera, scenes, and buttons
+ * across 6 areas: living_room, bedroom, kitchen, entry, utility, garage.
+ */
+declare function createDemoFixtures(): DemoFixtures;
+//#endregion
+//#region src/demo/demo-provider.d.ts
+/**
+ * Demo Mode Provider
+ *
+ * Loads demo fixtures into the SolidJS store and provides
+ * optimistic local state updates for service calls (toggle, turnOn, turnOff).
  *
  * @packageDocumentation
  */
-export type { ConnectionOptions } from "./connection/manager";
-export { getConnectionState, isConnected } from "./connection/manager";
-export { registerEntity } from "./connection/subscription-manager";
-export type { SyncLayerConnection } from "./connection/types";
-export type { OAuthOptions } from "./connection/auth";
-export { area, areas } from "./query/area-builder";
-export { entities, entity } from "./query/builder";
-export { entitiesByAreaAndDomain, entitiesWhere, searchEntities, } from "./query/helpers";
-export type { AreaQueryBuilder, EntitiesQueryBuilder, EntityQueryBuilder, UnsubscribeFunc, } from "./query/types";
-export { batchEntityUpdates, batchServiceCalls, callService, sendCommand, toggle, turnOff, turnOn, updateEntity, } from "./commands/service";
-export type { CommandOptions, CommandResult, EntityUpdateFields, ServiceCallContext, ServiceTarget, } from "./commands/types";
-export type { GlassHomeState } from "./core/store";
-export type { AreaId, AreaView, ConnectionState, DeviceId, DeviceView, EntityDomain, EntityId, EntityView, HassEntity, } from "./core/types";
-export { extractDomain } from "./core/types";
-export { state } from "./core/store";
-export type { CallServiceRequest, CoreEventType, Domain, EntityCategory, EntityRegistryEntry, EventStateChangedData, HAEvent, HassConfig, HassUnitSystem, RegistryEntryDisabler, RegistryEntryHider, ServiceCall, ServiceName, WsCommandType, WsResult, } from "@glasshome/ha-types";
-export { fetchStream, fetchStreamData } from "./camera/fetch";
-export { getStream, refreshStream } from "./camera/query";
-export { fetchEnergyPreferences } from "./energy/prefs";
-export { hassMediaUrl } from "./media/url";
-export type { EnergyDeviceConsumption, EnergyPreferences, EnergySource, } from "./energy/prefs";
-export type { CameraStream, CameraStreamData, CameraStreams, EntityStreamQueryOptions, StreamFormat, StreamQueryOptions, StreamResult, } from "./camera/types";
-export { getWebRtcClientConfig, sendWebRtcCandidate, startWebRtcSession, } from "./camera/webrtc";
-export { buildAreaView, buildDeviceView, getAreaView, getAreaViews, } from "./entities/area-views";
-export { buildEntityView, entityViewEquals, getAllEntityViews, getEntityView, getEntityViews, } from "./entities/views";
-export { DOMAINS_USE_LAST_UPDATED, entityIdHistoryNeedsAttributes, LINE_ATTRIBUTES_TO_KEEP, NEED_ATTRIBUTE_DOMAINS, } from "./history/constants";
-export { fetchEntityHistory, fetchHistory, historyStateToTimeline } from "./history/fetch";
-export { appendHistoryPoint, bulkAppendHistoryPoints, isHistoryTracked, MAX_HISTORY_POINTS, trackEntityHistory, untrackEntityHistory, } from "./history/query";
-export type { HistoryPoint } from "./history/query";
-export { fetchStatisticsDuringPeriod, normalizeStatisticTime, } from "./history/statistics";
-export type { StatisticsPeriod, StatisticsQueryOptions, StatisticValue, } from "./history/statistics";
-export type { EntityHistoryData, EntityHistoryQueryOptions, EntityHistoryResult, EntityHistoryState, HistoryData, HistoryQueryOptions, HistoryResult, HistoryStates, TimelineState, } from "./history/types";
-export { fetchForecast, fetchForecastData, fetchForecasts } from "./weather/fetch";
-export type { CalendarEvent, CalendarEventsData, CalendarWindowOptions } from "./calendar/types";
-export { getForecast, getForecasts, refreshForecast, refreshForecasts } from "./weather/query";
-export type { EntityForecastQueryOptions, ForecastQueryOptions, ForecastResult, ForecastsResult, ForecastType, WeatherForecast, WeatherForecastData, WeatherForecasts, WeatherForecastsData, } from "./weather/types";
-export { applyDemoServiceCall, createDemoFixtures, isDemoMode, startDemoEnergyTicker, stopDemoEnergyTicker, } from "./demo/demo-provider";
-export declare const VERSION = "0.2.1";
-export { BridgeNeedsAuthError, type BridgeConnectOptions, type BridgeEvents, type HaBridge, } from "./worker/bridge-client";
-export { claimHostApi, type HostApi } from "./host-api";
-export type { AuthMode, ConnState, OAuthTokenData } from "./worker/protocol";
-export { runHaBridgeWorker, type WorkerScope } from "./worker/worker-main";
+/**
+ * Whether demo mode is currently active.
+ */
+declare function isDemoMode(): boolean;
+/**
+ * Load demo fixtures into the SolidJS store.
+ *
+ * Populates entities, entity registry, areas, and devices.
+ * Sets connection state to "connected" (pretend connected).
+ */
+declare function loadDemoData(): Promise<void>;
+/**
+ * Unload demo data and reset to disconnected state.
+ */
+declare function unloadDemoData(): void;
+/**
+ * Start the demo energy ticker. Updates the energy sensors and `sun.sun`
+ * every 5 seconds. Idempotent: clears any prior interval first. SSR-safe.
+ */
+declare function startDemoEnergyTicker(): void;
+/** Stop the demo energy ticker if running. */
+declare function stopDemoEnergyTicker(): void;
+/**
+ * Apply an optimistic state update for demo mode.
+ *
+ * When a service call is made in demo mode, this updates the entity
+ * state locally (no WebSocket message sent). State resets on page refresh.
+ */
+declare function applyDemoServiceCall(_domain: string, service: string, _serviceData?: Record<string, any>, target?: {
+  entity_id?: string | string[];
+}): void;
+//#endregion
+//#region src/worker/protocol.d.ts
+type ConnState = "connected" | "disconnected" | "reconnecting";
+//#endregion
+//#region src/worker/bridge-client.d.ts
+/**
+ * Main-thread side of the HA bridge. Wraps the Worker and exposes:
+ * - a SyncLayerConnection facade so the existing store/subscription/command
+ *   code runs unchanged, with all HA traffic tunneled through the worker
+ * - registerWidget(), which mints the per-widget MessagePort the SDK's
+ *   service hooks call through (capability-checked in the worker)
+ *
+ * The Worker reference and its privileged channel live in this module's
+ * closures only.
+ */
+interface BridgeConnectOptions {
+  url: string;
+  proxyWsPath: string;
+  proxyTicket?: string;
+}
+interface BridgeEvents {
+  onConnState?: (state: ConnState) => void;
+  onReadyAfterReconnect?: () => void;
+  onInvalidAuth?: () => void;
+  onDenial?: (denial: {
+    widgetId: string;
+    domain: string;
+    service: string;
+    entityIds: string[];
+    message: string;
+  }) => void;
+}
+interface HaBridge {
+  /** Resolves on socket-up; rejects with BridgeInvalidAuthError when the relay or HA refused the handshake. */
+  connect(opts: BridgeConnectOptions): Promise<void>;
+  disconnect(): void;
+  reconnect(): void;
+  conn: SyncLayerConnection;
+  registerWidget(widgetId: string, caps: CapabilityGrant[]): MessagePort;
+  unregisterWidget(widgetId: string): void;
+  /** Forward visibility/pageshow so the worker can drive suspend/reconnect. Returns teardown. */
+  forwardLifecycle(): () => void;
+  terminate(): void;
+}
+declare class BridgeInvalidAuthError extends Error {
+  constructor();
+}
+declare function createHaBridge(worker: Worker, events?: BridgeEvents): HaBridge;
+//#endregion
+//#region src/connection/bridged.d.ts
+/**
+ * Wire an HA bridge (worker-backed connection) into the store. The bridge's
+ * facade rides the same load/subscribe pipeline as a direct socket; only the
+ * lifecycle signals differ — they arrive as worker messages instead of
+ * Connection events.
+ *
+ * Call after bridge.connect() resolved. Returns when initial data is loaded.
+ */
+declare function attachBridgeToStore(bridge: HaBridge, hassUrl: string, mediaProxyBase?: string): Promise<void>;
+/** Map worker connection-state messages onto the store. */
+declare function applyBridgeConnState(state: "connected" | "disconnected" | "reconnecting"): void;
+/** Re-sync after the worker reports a completed reconnect. */
+declare function reloadAfterBridgeReconnect(bridge: HaBridge): Promise<void>;
+/** Detach on shutdown; the caller terminates the worker itself. */
+declare function detachBridgeFromStore(): void;
+//#endregion
+//#region src/host-api.d.ts
+interface HostApi {
+  attachBridgeToStore: typeof attachBridgeToStore;
+  detachBridgeFromStore: typeof detachBridgeFromStore;
+  applyBridgeConnState: typeof applyBridgeConnState;
+  reloadAfterBridgeReconnect: typeof reloadAfterBridgeReconnect;
+  createHaBridge: typeof createHaBridge;
+  disconnect: typeof disconnect;
+  loadDemoData: typeof loadDemoData;
+  unloadDemoData: typeof unloadDemoData;
+}
+/**
+ * Take the host-only surface. Returns it once; null on every later call.
+ *
+ * Call it exactly once, during host boot, and keep the result in a module the
+ * import map does not serve. Calling it from anywhere else is what this guards
+ * against, so a null return means something already claimed it — treat that as
+ * a fatal misconfiguration, not a retry.
+ */
+declare function claimHostApi(): HostApi | null;
+//#endregion
+//#region src/index.d.ts
+declare const VERSION = "0.2.1";
+//#endregion
+export { type AreaId, type AreaQueryBuilder, type AreaView, type BridgeConnectOptions, type BridgeEvents, BridgeInvalidAuthError, type CalendarEvent, type CalendarEventsData, type CalendarWindowOptions, type CallServiceRequest, type CameraStream, type CameraStreamData, type CameraStreams, type CommandOptions, type CommandResult, type ConnState, type ConnectionOptions, type ConnectionState, type CoreEventType, DOMAINS_USE_LAST_UPDATED, type DeviceId, type DeviceView, type Domain, type EnergyDeviceConsumption, type EnergyPreferences, type EnergySource, type EntitiesQueryBuilder, type EntityCategory, type EntityDomain, type EntityForecastQueryOptions, type EntityHistoryData, type EntityHistoryQueryOptions, type EntityHistoryResult, type EntityHistoryState, type EntityId, type EntityQueryBuilder, type EntityRegistryEntry, type EntityStreamQueryOptions, type EntityUpdateFields, type EntityView, type EventStateChangedData, type ForecastQueryOptions, type ForecastResult, type ForecastType, type ForecastsResult, type GlassHomeState, type HAEvent, type HaBridge, type HassConfig, type HassEntity, type HassUnitSystem, type HistoryData, type HistoryPoint, type HistoryQueryOptions, type HistoryResult, type HistoryStates, type HostApi, LINE_ATTRIBUTES_TO_KEEP, MAX_HISTORY_POINTS, NEED_ATTRIBUTE_DOMAINS, type RegistryEntryDisabler, type RegistryEntryHider, type ServiceCall, type ServiceCallContext, type ServiceName, type ServiceTarget, type StatisticValue, type StatisticsPeriod, type StatisticsQueryOptions, type StreamFormat, type StreamQueryOptions, type StreamResult, type SyncLayerConnection, type TimelineState, type UnsubscribeFunc, VERSION, type WeatherForecast, type WeatherForecastData, type WeatherForecasts, type WeatherForecastsData, type WorkerScope, type WsCommandType, type WsResult, appendHistoryPoint, applyDemoServiceCall, area, areas, batchEntityUpdates, batchServiceCalls, buildAreaView, buildDeviceView, buildEntityView, bulkAppendHistoryPoints, callService, claimHostApi, createDemoFixtures, entities, entitiesByAreaAndDomain, entitiesWhere, entity, entityIdHistoryNeedsAttributes, entityViewEquals, extractDomain, fetchEnergyPreferences, fetchEntityHistory, fetchForecast, fetchForecastData, fetchForecasts, fetchHistory, fetchStatisticsDuringPeriod, fetchStream, fetchStreamData, getAllEntityViews, getAreaView, getAreaViews, getConnectionState, getEntityView, getEntityViews, getForecast, getForecasts, getStream, getWebRtcClientConfig, hassMediaUrl, historyStateToTimeline, isConnected, isDemoMode, isHistoryTracked, normalizeStatisticTime, refreshForecast, refreshForecasts, refreshStream, registerEntity, runHaBridgeWorker, searchEntities, sendCommand, sendWebRtcCandidate, startDemoEnergyTicker, startWebRtcSession, state, stopDemoEnergyTicker, toggle, trackEntityHistory, turnOff, turnOn, untrackEntityHistory, updateEntity };