@glasshome/sync-layer 0.6.0 → 0.7.0

package/dist/calendar/track.d.ts

@@ -0,0 +1,19 @@
+import type { EntityId } from "../core/types";
+import type { CalendarWindowOptions } from "./types";
+/**
+ * Start tracking live events for a calendar entity. Returns the untrack
+ * function. Safe while disconnected: the subscription activates on the next
+ * `forceResubscribeCalendars()` (called by the connection layer on connect
+ * and reconnect).
+ */
+export declare function trackCalendarEvents(entityId: EntityId, options?: CalendarWindowOptions): () => void;
+/**
+ * Reconcile every tracked calendar, dropping current subscription handles
+ * first. The connection layer calls this on connect and after reconnect:
+ * an unchanged window is no proof the old subscription is alive, so each
+ * tracked entity resubscribes (HA re-pushes the snapshot, refreshing the
+ * store through any missed changes).
+ */
+export declare function forceResubscribeCalendars(): Promise<void>;
+/** Test-only: drop all tracking state and timers. */
+export declare function resetCalendarTracking(): void;

package/dist/calendar/types.d.ts

@@ -0,0 +1,32 @@
+import type { EntityId } from "../core/types";
+/**
+ * One calendar event as HA serializes it over `calendar/event/subscribe`:
+ * dates/datetimes are ISO strings (date-only for all-day events), and
+ * None-valued fields are omitted.
+ */
+export interface CalendarEvent {
+    start: string;
+    end: string;
+    summary: string;
+    description?: string;
+    location?: string;
+    uid?: string;
+    recurrence_id?: string;
+    rrule?: string;
+}
+/** Live event window for one calendar entity, held in the store. */
+export interface CalendarEventsData {
+    entityId: EntityId;
+    events: CalendarEvent[];
+    /** True until the first snapshot for the current subscription arrives. */
+    loading: boolean;
+    error: Error | null;
+    /** Subscribed window bounds (ISO). */
+    start: string;
+    end: string;
+}
+/** Per-tracker window request, in whole days relative to now. */
+export interface CalendarWindowOptions {
+    daysBehind?: number;
+    daysAhead?: number;
+}

package/dist/core/store.d.ts

@@ -1,5 +1,6 @@
 /** Central reactive state store for sync-layer using SolidJS createStore. */
 import type { SetStoreFunction, Store } from "solid-js/store";
+import type { CalendarEventsData } from "../calendar/types";
 import type { CameraStreamData } from "../camera/types";
 import type { EntityHistoryData } from "../history/types";
 import type { WeatherForecastsData } from "../weather/types";
@@ -55,6 +56,8 @@ export interface GlassHomeState {
     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>;
 }

package/dist/index.d.ts

@@ -4,6 +4,16 @@
  * Type-safe, reactive state synchronization layer for Home Assistant
  * Uses SolidJS createStore for reactive state management.
  *
+ * 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.
+ *
  * @packageDocumentation
  */
 export type { ConnectionOptions } from "./connection/manager";
@@ -39,6 +49,7 @@ export { fetchStatisticsDuringPeriod, normalizeStatisticTime, } from "./history/
 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";

package/dist/index.js

@@ -1,5 +1,5 @@
-import { applyDemoServiceCall, batchEntityUpdates, batchServiceCalls, buildAreaView, buildDeviceView, buildEntityView, callService, createDemoFixtures, demoEnergyPreferences, entityViewEquals, extractDomain, fetchStatisticsDuringPeriod, forceResubscribe, getAllEntityViews, getAreaView, getAreaViews, getEntityView, getEntityViews, isDemoMode, isEnergyEntity, loadDemoData, normalizeStatisticTime, privilegedConn, registerEntity, sendCommand, setManagerConnection, setPrivilegedConn, setResubscribeHandler, setState, startDemoEnergyTicker, state, stopDemoEnergyTicker, synthesizeEnergyHistory, toggle, turnOff, turnOn, unloadDemoData, updateEntity } from "./statistics-C6JQBDVf.js";
-import { runHaBridgeWorker } from "./worker-main-DTbzEKor.js";
+import { applyDemoServiceCall, batchEntityUpdates, batchServiceCalls, buildAreaView, buildDeviceView, buildEntityView, callService, createDemoFixtures, demoEnergyPreferences, entityViewEquals, extractDomain, fetchStatisticsDuringPeriod, forceResubscribe, forceResubscribeCalendars, getAllEntityViews, getAreaView, getAreaViews, getEntityView, getEntityViews, isDemoMode, isEnergyEntity, loadDemoData, normalizeStatisticTime, privilegedConn, registerEntity, sendCommand, setManagerConnection, setPrivilegedConn, setResubscribeHandler, setState, startDemoEnergyTicker, state, stopDemoEnergyTicker, synthesizeEnergyHistory, toggle, turnOff, turnOn, unloadDemoData, updateEntity } from "./statistics-CtRfIF6D.js";
+import { runHaBridgeWorker } from "./worker-main-C-3QM4di.js";
 import { createConnection, getAuth } from "home-assistant-js-websocket";
 import { produce } from "solid-js/store";
 
@@ -2055,6 +2055,7 @@ async function attachBridgeToStore(bridge, hassUrl, mediaProxyBase) {
 	}));
 	await loadInitialData(bridge.conn);
 	await subscribeToUpdates(bridge.conn);
+	await forceResubscribeCalendars();
 }
 /** Map worker connection-state messages onto the store. */
 function applyBridgeConnState(state$1) {
@@ -2067,6 +2068,7 @@ function applyBridgeConnState(state$1) {
 async function reloadAfterBridgeReconnect(bridge) {
 	await loadInitialData(bridge.conn);
 	await forceResubscribe();
+	await forceResubscribeCalendars();
 }
 /** Detach on shutdown; the caller terminates the worker itself. */
 function detachBridgeFromStore() {

package/dist/solid/hooks.d.ts

@@ -14,6 +14,7 @@ import type { HassConfig, HassUnitSystem } from "@glasshome/ha-types";
 import type { Accessor, Resource } from "solid-js";
 import type { AreaView, CameraStreamData, ConnectionState, EntityHistoryData, EntityView, GlassHomeState, HassEntity, StatisticsQueryOptions, StatisticValue, WeatherForecastsData } from "@glasshome/sync-layer";
 import { callService, toggle, turnOff, turnOn } from "../commands/service";
+import type { CalendarEventsData, CalendarWindowOptions } from "../calendar/types";
 /**
  * Get a reactive EntityView for an entity ID.
  *
@@ -97,6 +98,15 @@ export declare function useCamera(entityId: Accessor<string> | string): {
     stream: Accessor<CameraStreamData | null>;
     refresh: () => void;
 };
+/**
+ * Live calendar events for one calendar entity.
+ *
+ * Tracks the entity on mount (opening or joining the shared
+ * `calendar/event/subscribe`) and untracks on cleanup; HA pushes the initial
+ * snapshot and every later change, so the accessor is reactive with no
+ * polling. `undefined` until the subscription is established.
+ */
+export declare function useCalendarEvents(entityId: Accessor<string> | string, options?: CalendarWindowOptions): Accessor<CalendarEventsData | undefined>;
 /**
  * Get reactive weather forecast data.
  */

package/dist/solid/index.d.ts

@@ -6,5 +6,5 @@
  *
  * @packageDocumentation
  */
-export { useArea, useAreas, useCamera, useConnection, useCurrency, useEntities, useEntity, useEntityHistory, useEntityState, useEntityStatistics, useForecast, useHassConfig, useLocale, useService, useStore, useTemperatureUnit, useToggle, useTurnOff, useTurnOn, useUnitSystem, } from "./hooks";
+export { useArea, useAreas, useCalendarEvents, useCamera, useConnection, useCurrency, useEntities, useEntity, useEntityHistory, useEntityState, useEntityStatistics, useForecast, useHassConfig, useLocale, useService, useStore, useTemperatureUnit, useToggle, useTurnOff, useTurnOn, useUnitSystem, } from "./hooks";
 export { allEntityIds, byArea, byDevice, byDomain, byFloor, byLabel, } from "./indices";

package/dist/solid/index.js

@@ -1,4 +1,4 @@
-import { buildAreaView, callService, entityViewEquals, extractDomain, fetchStatisticsDuringPeriod, getAreaViews, getEntityView, isDemoMode, privilegedConn, registerEntity, state, toggle, turnOff, turnOn } from "../statistics-C6JQBDVf.js";
+import { buildAreaView, callService, entityViewEquals, extractDomain, fetchStatisticsDuringPeriod, getAreaViews, getEntityView, isDemoMode, privilegedConn, registerEntity, state, toggle, trackCalendarEvents, turnOff, turnOn } from "../statistics-CtRfIF6D.js";
 import { createEffect, createMemo, createResource, onCleanup } from "solid-js";
 
 //#region src/solid/hooks.ts
@@ -203,6 +203,24 @@ function useCamera(entityId) {
 	};
 }
 /**
+* Live calendar events for one calendar entity.
+*
+* Tracks the entity on mount (opening or joining the shared
+* `calendar/event/subscribe`) and untracks on cleanup; HA pushes the initial
+* snapshot and every later change, so the accessor is reactive with no
+* polling. `undefined` until the subscription is established.
+*/
+function useCalendarEvents(entityId, options) {
+	const getId = typeof entityId === "function" ? entityId : () => entityId;
+	createEffect(() => {
+		const id = getId();
+		if (!id) return;
+		const untrack = trackCalendarEvents(id, options);
+		onCleanup(untrack);
+	});
+	return createMemo(() => state.calendars[getId()]);
+}
+/**
 * Get reactive weather forecast data.
 */
 function useForecast(entityId) {
@@ -256,4 +274,4 @@ const byLabel = () => {
 const allEntityIds = () => Object.keys(state.entities);
 
 //#endregion
-export { allEntityIds, byArea, byDevice, byDomain, byFloor, byLabel, useArea, useAreas, useCamera, useConnection, useCurrency, useEntities, useEntity, useEntityHistory, useEntityState, useEntityStatistics, useForecast, useHassConfig, useLocale, useService, useStore, useTemperatureUnit, useToggle, useTurnOff, useTurnOn, useUnitSystem };
+export { allEntityIds, byArea, byDevice, byDomain, byFloor, byLabel, useArea, useAreas, useCalendarEvents, useCamera, useConnection, useCurrency, useEntities, useEntity, useEntityHistory, useEntityState, useEntityStatistics, useForecast, useHassConfig, useLocale, useService, useStore, useTemperatureUnit, useToggle, useTurnOff, useTurnOn, useUnitSystem };

package/dist/{statistics-C6JQBDVf.js → statistics-CtRfIF6D.js}

@@ -17,6 +17,7 @@ const initialState = {
 	statisticsMetadata: {},
 	history: {},
 	forecasts: {},
+	calendars: {},
 	streams: {}
 };
 if (globalThis.__GH_SYNC_LAYER_STORE__) console.error("[@glasshome/sync-layer] DUPLICATE store module instantiated. This means @glasshome/sync-layer was bundled into >1 chunk. Reads and writes will hit different singletons. Check vendor build externals and relative-vs-bare imports across entry points.");
@@ -25,6 +26,206 @@ const storeTuple = createStore(initialState);
 const state = storeTuple[0];
 const setState = storeTuple[1];
 
+//#endregion
+//#region src/core/privileged-conn.ts
+let privileged = null;
+/** Read the live connection. Null before connect and after disconnect. */
+function privilegedConn() {
+	return privileged;
+}
+/** Set by the connection layer on connect/disconnect. Host-side callers only. */
+function setPrivilegedConn(conn$1) {
+	privileged = conn$1;
+}
+
+//#endregion
+//#region src/calendar/track.ts
+/**
+* Ref-counted live calendar tracking, the per-entity analog of
+* `connection/subscription-manager`. Each tracked calendar entity holds one
+* upstream `calendar/event/subscribe` (HA pushes an initial snapshot, then
+* debounced updates); trackers declare desired windows and a reconciler keeps
+* the subscription matched to the union. Data lands in `state.calendars`;
+* read-scoping for widget consumers arrives with WS-8 like every other store
+* read.
+*/
+const DEFAULT_DAYS_BEHIND = 7;
+const DEFAULT_DAYS_AHEAD = 35;
+/** Debounce for untrack, so dashboard switches don't churn subscriptions. */
+const UNTRACK_FLUSH_DELAY_MS = 5e3;
+const DAY_MS = 24 * 60 * 60 * 1e3;
+const trackers = /* @__PURE__ */ new Map();
+const active = /* @__PURE__ */ new Map();
+/** Per-entity reconcile chain; serializes subscribe/unsubscribe per calendar. */
+const chains = /* @__PURE__ */ new Map();
+let untrackTimer = null;
+let rollTimer = null;
+/** Day-quantized union of all tracker windows, so equal requests within a day
+reconcile to the same subscription instead of churning. */
+function windowFor(list) {
+	let behind = 0;
+	let ahead = 0;
+	for (const t of list) {
+		if (t.daysBehind > behind) behind = t.daysBehind;
+		if (t.daysAhead > ahead) ahead = t.daysAhead;
+	}
+	const dayStart = /* @__PURE__ */ new Date();
+	dayStart.setHours(0, 0, 0, 0);
+	return {
+		start: new Date(dayStart.getTime() - behind * DAY_MS).toISOString(),
+		end: new Date(dayStart.getTime() + (ahead + 1) * DAY_MS).toISOString()
+	};
+}
+/**
+* Start tracking live events for a calendar entity. Returns the untrack
+* function. Safe while disconnected: the subscription activates on the next
+* `forceResubscribeCalendars()` (called by the connection layer on connect
+* and reconnect).
+*/
+function trackCalendarEvents(entityId, options) {
+	const tracker = {
+		daysBehind: options?.daysBehind ?? DEFAULT_DAYS_BEHIND,
+		daysAhead: options?.daysAhead ?? DEFAULT_DAYS_AHEAD
+	};
+	const list = trackers.get(entityId) ?? [];
+	list.push(tracker);
+	trackers.set(entityId, list);
+	scheduleFlush$1();
+	ensureRollTimer();
+	let untracked = false;
+	return () => {
+		if (untracked) return;
+		untracked = true;
+		untrackCalendarEvents(entityId, tracker);
+	};
+}
+function untrackCalendarEvents(entityId, tracker) {
+	const list = trackers.get(entityId);
+	if (!list) return;
+	const i = list.indexOf(tracker);
+	if (i !== -1) list.splice(i, 1);
+	if (list.length === 0) trackers.delete(entityId);
+	if (untrackTimer) return;
+	untrackTimer = setTimeout(() => {
+		untrackTimer = null;
+		flushAll();
+	}, UNTRACK_FLUSH_DELAY_MS);
+}
+/**
+* Reconcile every tracked calendar, dropping current subscription handles
+* first. The connection layer calls this on connect and after reconnect:
+* an unchanged window is no proof the old subscription is alive, so each
+* tracked entity resubscribes (HA re-pushes the snapshot, refreshing the
+* store through any missed changes).
+*/
+async function forceResubscribeCalendars() {
+	for (const entry of active.values()) {
+		const dead = entry.unsub;
+		entry.unsub = null;
+		if (dead) Promise.resolve().then(dead).catch(() => {});
+	}
+	await flushAll();
+}
+function scheduleFlush$1() {
+	queueMicrotask(() => {
+		flushAll();
+	});
+}
+async function flushAll() {
+	const ids = new Set([...trackers.keys(), ...active.keys()]);
+	await Promise.all([...ids].map(reconcileEntity));
+	if (trackers.size === 0) stopRollTimer();
+}
+function reconcileEntity(entityId) {
+	const next = (chains.get(entityId) ?? Promise.resolve()).then(() => runReconcile(entityId));
+	chains.set(entityId, next.catch(() => {}));
+	return next;
+}
+async function runReconcile(entityId) {
+	const list = trackers.get(entityId);
+	const current = active.get(entityId);
+	if (!list || list.length === 0) {
+		if (current) {
+			active.delete(entityId);
+			try {
+				await current.unsub?.();
+			} catch {}
+		}
+		chains.delete(entityId);
+		setState(produce((s) => {
+			delete s.calendars[entityId];
+		}));
+		return;
+	}
+	const conn$1 = privilegedConn();
+	if (!conn$1) return;
+	const win = windowFor(list);
+	if (current?.unsub && current.start === win.start && current.end === win.end) return;
+	setState(produce((s) => {
+		s.calendars[entityId] = {
+			entityId,
+			events: s.calendars[entityId]?.events ?? [],
+			loading: true,
+			error: null,
+			start: win.start,
+			end: win.end
+		};
+	}));
+	const old = current?.unsub ?? null;
+	const entry = {
+		start: win.start,
+		end: win.end,
+		unsub: null
+	};
+	active.set(entityId, entry);
+	try {
+		entry.unsub = await conn$1.subscribeMessage((msg) => {
+			setState(produce((s) => {
+				const rec = s.calendars[entityId];
+				if (!rec) return;
+				rec.events = msg.events ?? [];
+				rec.loading = false;
+				rec.error = null;
+			}));
+		}, {
+			type: "calendar/event/subscribe",
+			entity_id: entityId,
+			start: win.start,
+			end: win.end
+		});
+	} catch (err) {
+		active.delete(entityId);
+		setState(produce((s) => {
+			const rec = s.calendars[entityId];
+			if (!rec) return;
+			rec.loading = false;
+			rec.error = err instanceof Error ? err : new Error(String(err));
+		}));
+	}
+	if (old) try {
+		await old();
+	} catch {}
+}
+/** One timer for the whole module: at local midnight the day-quantized
+windows shift, so a reconcile slides every subscription forward. Only
+armed while something is tracked — an idle app holds no timer. */
+function ensureRollTimer() {
+	if (rollTimer || trackers.size === 0) return;
+	const now$1 = /* @__PURE__ */ new Date();
+	const next = new Date(now$1);
+	next.setHours(24, 0, 30, 0);
+	rollTimer = setTimeout(() => {
+		rollTimer = null;
+		flushAll().then(ensureRollTimer);
+	}, next.getTime() - now$1.getTime());
+}
+function stopRollTimer() {
+	if (rollTimer) {
+		clearTimeout(rollTimer);
+		rollTimer = null;
+	}
+}
+
 //#endregion
 //#region src/connection/subscription-manager.ts
 if (globalThis.__GH_SYNC_LAYER_SUB_MGR__) console.error("[@glasshome/sync-layer] DUPLICATE subscription-manager module instantiated. registerEntity() and the connection setter will hit different singletons → subscribe_entities will never be sent. Cause: relative import of subscription-manager from a separate entry point.");
@@ -1032,6 +1233,18 @@ function createDemoFixtures() {
 		device_class: "battery",
 		unit_of_measurement: "%"
 	});
+	add(makeEntity("sensor.electricity_maps_co2_intensity", "214", {
+		unit_of_measurement: "gCO2eq/kWh",
+		state_class: "measurement"
+	}), { unit_of_measurement: "gCO2eq/kWh" });
+	add(makeEntity("sensor.electricity_maps_fossil_fuel_percentage", "31", {
+		unit_of_measurement: "%",
+		state_class: "measurement"
+	}), { unit_of_measurement: "%" });
+	add(makeEntity("sensor.nordpool_current_price", "0.18", {
+		unit_of_measurement: "EUR/kWh",
+		state_class: "measurement"
+	}), { unit_of_measurement: "EUR/kWh" });
 	add(makeEntity("binary_sensor.front_door", "off", { device_class: "door" }), {
 		device_id: "door_sensor",
 		area_id: "entry",
@@ -1571,18 +1784,6 @@ function applyTurnOff(e, domain) {
 	} else e.state = "off";
 }
 
-//#endregion
-//#region src/core/privileged-conn.ts
-let privileged = null;
-/** Read the live connection. Null before connect and after disconnect. */
-function privilegedConn() {
-	return privileged;
-}
-/** Set by the connection layer on connect/disconnect. Host-side callers only. */
-function setPrivilegedConn(conn$1) {
-	privileged = conn$1;
-}
-
 //#endregion
 //#region src/commands/service.ts
 /**
@@ -1971,4 +2172,4 @@ async function fetchStatisticsDuringPeriod(connection, statisticIds, options) {
 }
 
 //#endregion
-export { applyDemoServiceCall, batchEntityUpdates, batchServiceCalls, buildAreaView, buildDeviceView, buildEntityView, callService, createDemoFixtures, demoEnergyPreferences, entityViewEquals, extractDomain, fetchStatisticsDuringPeriod, forceResubscribe, getAllEntityViews, getAreaView, getAreaViews, getEntityView, getEntityViews, isDemoMode, isEnergyEntity, loadDemoData, normalizeStatisticTime, privilegedConn, registerEntity, sendCommand, setManagerConnection, setPrivilegedConn, setResubscribeHandler, setState, startDemoEnergyTicker, state, stopDemoEnergyTicker, synthesizeEnergyHistory, toggle, turnOff, turnOn, unloadDemoData, updateEntity };
+export { applyDemoServiceCall, batchEntityUpdates, batchServiceCalls, buildAreaView, buildDeviceView, buildEntityView, callService, createDemoFixtures, demoEnergyPreferences, entityViewEquals, extractDomain, fetchStatisticsDuringPeriod, forceResubscribe, forceResubscribeCalendars, getAllEntityViews, getAreaView, getAreaViews, getEntityView, getEntityViews, isDemoMode, isEnergyEntity, loadDemoData, normalizeStatisticTime, privilegedConn, registerEntity, sendCommand, setManagerConnection, setPrivilegedConn, setResubscribeHandler, setState, startDemoEnergyTicker, state, stopDemoEnergyTicker, synthesizeEnergyHistory, toggle, trackCalendarEvents, turnOff, turnOn, unloadDemoData, updateEntity };

package/dist/worker/protocol.d.ts

@@ -113,10 +113,14 @@ export interface WidgetServiceCall {
     service: string;
     data?: Record<string, unknown>;
     target?: Record<string, unknown>;
+    /** Opt in to HA's service response (return_response). Only set for services
+        that support/require it; HA errors otherwise. */
+    returnResponse?: boolean;
 }
 export type WidgetServiceResult = {
     id: number;
     ok: true;
+    result?: unknown;
 } | {
     id: number;
     ok: false;

package/dist/worker/worker-main.js

@@ -1,3 +1,3 @@
-import { runHaBridgeWorker } from "../worker-main-DTbzEKor.js";
+import { runHaBridgeWorker } from "../worker-main-C-3QM4di.js";
 
 export { runHaBridgeWorker };

package/dist/{worker-main-DTbzEKor.js → worker-main-C-3QM4di.js}

@@ -239,16 +239,18 @@ function runHaBridgeWorker(scope) {
 				return;
 			}
 			try {
-				await conn.sendMessagePromise({
+				const res = await conn.sendMessagePromise({
 					type: "call_service",
 					domain: call.domain,
 					service: call.service,
 					service_data: call.data ?? {},
-					...call.target ? { target: call.target } : {}
+					...call.target ? { target: call.target } : {},
+					...call.returnResponse ? { return_response: true } : {}
 				});
 				reply({
 					id: call.id,
-					ok: true
+					ok: true,
+					...call.returnResponse ? { result: res.response } : {}
 				});
 			} catch (err) {
 				reply({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glasshome/sync-layer",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Type-safe, reactive state synchronization layer for Home Assistant",
   "repository": {
     "type": "git",