@camstack/system 1.2.485 → 1.2.487

package/dist/builtins/composer/composer.addon.mjs

@@ -1,19 +1,19 @@
-import { $n as planComposition, Br as COMPOSER_ADDON_ID, Gi as createEvent, Gr as compositionFeatureEnabled, Hr as cloneStatefulExpressionMemory, It as composerCapability, Jr as compositionSourceKey, Kr as compositionItemFieldPath, Lt as compositionFieldKey, N as DeclaredDevices, Ot as buildCapabilityLookup, Ur as composedDeviceRef, Wr as composedDeviceStableId, Xr as disarmRoseMemory, Yr as createStatefulExpressionMemory, Zr as toExpressionValue, a as BaseDevice, cn as evaluateCompositionField, d as COMPOSED_ITEM_FIXED_FIELDS, dn as expressionContainsBuiltinCall, ei as DeviceType, ja as EventCategory, ni as BaseAddon, qr as compositionSliceKey, r as ALL_CAPABILITY_DEFINITIONS, ti as errMsg } from "../../dist-Df6c0RX_.mjs";
-import { n as normalizedNativeOwner } from "../../composition-sources-BnZpIA8u.mjs";
-import { i as DAY_MS, m as capSeriesKey, t as DEFAULT_RETENTION } from "../../retention-DfCW-dZS.mjs";
+import { $r as cloneStatefulExpressionMemory, Ar as sharedLightCaps, At as buildCapabilityLookup, Bt as compositionFieldKey, Cn as groupTemplate, Cr as runFanOut, Ha as EventCategory, N as DeclaredDevices, Rt as colorCapability, Sn as groupCommandsCapability, Ur as switchCapability, Zn as motionCapability, Zr as COMPOSER_ADDON_ID, a as BaseDevice, ai as compositionSourceKey, ci as toExpressionValue, d as COMPOSED_ITEM_FIXED_FIELDS, di as DeviceType, dn as evaluateCompositionField, ei as composedDeviceRef, fi as errMsg, gn as fanOutTargets, ii as compositionSliceKey, kr as sharedColorModes, kt as brightnessCapability, mn as expressionContainsBuiltinCall, na as createEvent, ni as compositionFeatureEnabled, oi as createStatefulExpressionMemory, or as planComposition, pi as BaseAddon, r as ALL_CAPABILITY_DEFINITIONS, ri as compositionItemFieldPath, rr as parseColorInput, si as disarmRoseMemory, ti as composedDeviceStableId, z as GroupCommandResultSchema, zt as composerCapability } from "../../dist-Dfwxsc_Y.mjs";
+import { n as normalizedNativeOwner } from "../../composition-sources-BA2e5vh_.mjs";
+import { i as DAY_MS, m as capSeriesKey, t as DEFAULT_RETENTION } from "../../retention-Dz5t6cWO.mjs";
 import { z } from "zod";
 //#region src/builtins/shared/device-state-changed.ts
 /** Structural narrowing helper for untrusted bus payloads. */
-function isRecord$2(value) {
+function isRecord$3(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseDeviceStateChanged(data) {
-	if (!isRecord$2(data)) return null;
+	if (!isRecord$3(data)) return null;
 	const deviceId = data["deviceId"];
 	const capName = data["capName"];
 	const slice = data["slice"];
 	if (typeof deviceId !== "number" || typeof capName !== "string") return null;
-	if (!isRecord$2(slice)) return null;
+	if (!isRecord$3(slice)) return null;
 	return {
 		deviceId,
 		capName,
@@ -21,15 +21,51 @@ function parseDeviceStateChanged(data) {
 	};
 }
 //#endregion
+//#region src/builtins/composer/actuator-invoke.ts
+/**
+* Turn one fan-out call into the member's existing cap method. A bad argument
+* fails that member only — the caller still attempts the rest.
+*/
+async function invokeActuatorCall(api, call) {
+	if (call.cap === "switch" && call.method === "setState") {
+		const on = call.args.on;
+		if (typeof on !== "boolean") throw new Error("switch.setState needs a boolean on");
+		await api.switchSetState(call.deviceId, on);
+		return;
+	}
+	if (call.cap === "brightness" && call.method === "setBrightness") {
+		const percentage = call.args.percentage;
+		if (typeof percentage !== "number" || !Number.isFinite(percentage)) throw new Error("brightness.setBrightness needs a finite percentage");
+		await api.setBrightness(call.deviceId, percentage);
+		return;
+	}
+	if (call.cap === "color" && call.method === "setColor") {
+		const color = parseColorInput(call.args.color);
+		if (color === null) throw new Error("color.setColor needs a colour mode");
+		await api.setColor(call.deviceId, color);
+		return;
+	}
+	throw new Error(`no fan-out for ${call.cap}.${call.method}`);
+}
+//#endregion
+//#region src/builtins/composer/actuator-dispatch.ts
+var dispatcher = null;
+function setActuatorDispatcher(next) {
+	dispatcher = next;
+}
+function actuatorDispatcher() {
+	return dispatcher;
+}
+//#endregion
 //#region src/builtins/composer/composed-device.ts
 /**
 * A composed device: an ordinary `BaseDevice` whose caps are served by the
 * composer (D659). Every consumer (exporters, NC, UI, HomeKit) reads it
 * through its bindings, unchanged.
 *
-* It serves NO command method: slice 1 refuses any cap with one
-* (`has-commands`), and commands arrive with `forward` in slice 3. So each
-* composed cap is registered with an EMPTY native provider, and `getStatus`
+* A reading group serves no command. An actuator helper's `switch` (and, on
+* a light, `brightness` / `color` when every member binds them) fans the
+* call out through `actuatorDispatcher` (D944). `getStatus`
 * (R4) is the kernel's: `registerNativeCap` installs a default that reads the
 * device's runtime slice for any cap declaring both `status` and
 * `runtimeState` (`device-cap-proxy.ts`, "Default `getStatus`"), on the
@@ -45,13 +81,112 @@ function parseDeviceStateChanged(data) {
 * declaration is the authority for what this device is.
 */
 var COMPOSED_DEVICE_CONFIG_SCHEMA = z.object({});
+function priorResults(slice) {
+	if (!isRecord$2(slice) || !Array.isArray(slice.results)) return [];
+	return slice.results.flatMap((row) => {
+		const parsed = GroupCommandResultSchema.safeParse(row);
+		return parsed.success ? [parsed.data] : [];
+	});
+}
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Unknown is a throw, never `false` (D393). */
+function sliceBoolean(slice, field) {
+	if (isRecord$2(slice)) {
+		const value = slice[field];
+		if (typeof value === "boolean") return value;
+	}
+	throw new Error(`composed ${field} is unknown — not a stand-in value`);
+}
 var ComposedDevice = class extends BaseDevice {
-	features = [];
+	sharedFeatures = [];
+	extraCaps = /* @__PURE__ */ new Set();
+	get features() {
+		return this.sharedFeatures;
+	}
 	constructor(ctx, type, caps) {
 		super(ctx, COMPOSED_DEVICE_CONFIG_SCHEMA, { type });
-		for (const cap of caps) ctx.registerNativeCap(cap, {});
+		for (const cap of caps) {
+			if (cap.name === motionCapability.name) {
+				const read = () => this.runtimeState.getCapState(motionCapability.name);
+				ctx.registerNativeCap(motionCapability, { isDetected: async () => sliceBoolean(read(), "detected") });
+				continue;
+			}
+			if (cap.name === switchCapability.name) {
+				ctx.registerNativeCap(switchCapability, { setState: async (input) => {
+					await this.dispatch("switch", "setState", { on: input.on });
+				} });
+				continue;
+			}
+			ctx.registerNativeCap(cap, {});
+		}
+		if (type === DeviceType.Switch || type === DeviceType.Light) ctx.registerNativeCap(groupCommandsCapability, {});
 		this.markOnline(false);
 	}
+	/**
+	* Register or drop brightness and colour, and publish the shared colour
+	* modes. Switch stays: it is the active state, registered with the device.
+	*/
+	syncShared(caps, modes) {
+		this.ensureExtra(brightnessCapability.name, caps.includes(brightnessCapability.name), () => {
+			this.ctx.registerNativeCap(brightnessCapability, { setBrightness: async (input) => {
+				await this.dispatch("brightness", "setBrightness", { percentage: input.percentage });
+			} });
+		});
+		this.ensureExtra(colorCapability.name, caps.includes(colorCapability.name), () => {
+			this.ctx.registerNativeCap(colorCapability, { setColor: async (input) => {
+				await this.dispatch("color", "setColor", { color: input.color });
+			} });
+		});
+		this.sharedFeatures = [...modes];
+		this.refreshFeatures();
+	}
+	/** Keep each member's latest attempt. A later command replaces that member only. */
+	recordCommands(incoming) {
+		const prior = priorResults(this.runtimeState.getCapState(groupCommandsCapability.name));
+		const byDevice = new Map(prior.map((row) => [row.deviceId, row]));
+		for (const row of incoming) byDevice.set(row.deviceId, row);
+		try {
+			this.runtimeState.setCapState(groupCommandsCapability.name, { results: [...byDevice.values()] });
+		} catch (err) {
+			this.ctx.logger.error("actuator group could not store command results", {
+				tags: { deviceId: this.id },
+				meta: { error: errMsg(err) }
+			});
+		}
+	}
+	ensureExtra(capName, want, register) {
+		const has = this.extraCaps.has(capName);
+		if (want && !has) {
+			register();
+			this.extraCaps = new Set([...this.extraCaps, capName]);
+			return;
+		}
+		if (!want && has) {
+			this.ctx.unregisterNativeCap?.(capName);
+			this.extraCaps = new Set([...this.extraCaps].filter((name) => name !== capName));
+		}
+	}
+	async dispatch(cap, method, args) {
+		const run = actuatorDispatcher();
+		if (run === null) {
+			this.ctx.logger.warn("actuator group command was not sent — fan-out is not attached", {
+				tags: { deviceId: this.id },
+				meta: {
+					cap,
+					method
+				}
+			});
+			throw new Error("actuator fan-out is not attached");
+		}
+		await run({
+			groupDeviceId: this.id,
+			cap,
+			method,
+			args
+		});
+	}
 	seed(capName, slice) {
 		try {
 			this.runtimeState.setCapState(capName, { ...slice });
@@ -221,6 +356,223 @@ var ClaimGate = class {
 	}
 };
 //#endregion
+//#region src/builtins/composer/actuator-groups.ts
+/**
+* Live actuator helpers (D944). State is the aggregate the composer already
+* runs. Commands are fanned out here: every member that binds the cap,
+* including one that is offline, and a failure on one does not cancel the rest.
+* A light's brightness and colour are registered only while every member binds
+* them, and recomputed when a member's bindings change.
+*/
+function isActuatorGroupDevice(device) {
+	return "syncShared" in device && "recordCommands" in device && "id" in device;
+}
+var ActuatorGroups = class {
+	deps;
+	groups = /* @__PURE__ */ new Map();
+	bound;
+	constructor(deps) {
+		this.deps = deps;
+		this.bound = (input) => this.command(input);
+		setActuatorDispatcher(this.bound);
+	}
+	shutdown() {
+		setActuatorDispatcher(null);
+	}
+	async sync(blocks) {
+		const next = /* @__PURE__ */ new Map();
+		for (const block of blocks) {
+			const remembered = await this.remember(block);
+			if (remembered !== null) next.set(block.id, remembered);
+		}
+		this.groups = next;
+	}
+	async onMemberBindings(deviceId) {
+		const hit = [...this.groups.values()].filter((group) => group.fanOut.some((member) => member.deviceId === deviceId));
+		if (hit.length === 0) return;
+		const next = new Map(this.groups);
+		for (const group of hit) {
+			const block = {
+				id: group.blockId,
+				helper: {
+					kind: "group",
+					templateId: group.templateId,
+					aggregate: "any",
+					active: "at-least-one",
+					members: group.members.map(copyMember)
+				}
+			};
+			const remembered = await this.remember(block);
+			if (remembered !== null) next.set(group.blockId, remembered);
+		}
+		this.groups = next;
+	}
+	async remember(block) {
+		const spec = block.helper;
+		if (spec === void 0) return null;
+		const template = groupTemplate(spec.templateId);
+		if (template === null || template.family !== "actuator") return null;
+		if (template.id !== "switch" && template.id !== "light") return null;
+		const device = this.deps.deviceOf(block.id);
+		if (device === null) return null;
+		const viewed = await this.viewMembers(spec.members, device.id);
+		const shared = sharedOf(template.id, viewed);
+		const previous = this.groups.get(block.id)?.shared;
+		if (template.id === "light" && previous !== void 0) this.logCapChange(device.id, previous, shared, viewed);
+		const modes = template.id === "light" && shared.includes("color") ? sharedColorModes(viewed.featureLists) : [];
+		device.syncShared(shared, modes);
+		return {
+			blockId: block.id,
+			templateId: template.id,
+			groupDeviceId: device.id,
+			members: spec.members.map(copyMember),
+			fanOut: viewed.fanOut,
+			shared
+		};
+	}
+	async viewMembers(members, groupDeviceId) {
+		const fanOut = [];
+		const capLists = [];
+		const featureLists = [];
+		let complete = true;
+		for (const member of members) {
+			const resolved = this.deps.resolve(member.source);
+			if (resolved.kind !== "found") {
+				complete = false;
+				this.deps.logger.warn("actuator group left a member out of shared commands — its device was not resolved", {
+					tags: { deviceId: groupDeviceId },
+					meta: { source: `${member.source.addonId}/${member.source.stableId}` }
+				});
+				continue;
+			}
+			const read = await this.deps.readMember(resolved.deviceId);
+			if (read.kind !== "ready") {
+				complete = false;
+				fanOut.push({
+					deviceId: resolved.deviceId,
+					caps: [],
+					online: true
+				});
+				this.deps.logger.warn("actuator group left a member out of shared commands — its capabilities could not be read", {
+					tags: { deviceId: resolved.deviceId },
+					meta: {
+						groupDeviceId,
+						error: read.error
+					}
+				});
+				continue;
+			}
+			capLists.push(read.caps);
+			featureLists.push(read.features);
+			fanOut.push({
+				deviceId: resolved.deviceId,
+				caps: read.caps,
+				online: true
+			});
+		}
+		return {
+			fanOut,
+			capLists: complete ? capLists : null,
+			featureLists
+		};
+	}
+	logCapChange(groupDeviceId, previous, shared, viewed) {
+		for (const cap of ["brightness", "color"]) {
+			const had = previous.includes(cap);
+			const has = shared.includes(cap);
+			if (had === has) continue;
+			if (has) {
+				this.deps.logger.info("light group gained a shared capability", {
+					tags: { deviceId: groupDeviceId },
+					meta: { cap }
+				});
+				continue;
+			}
+			this.deps.logger.warn("light group dropped a capability a member does not bind", {
+				tags: { deviceId: groupDeviceId },
+				meta: { cap }
+			});
+			for (const member of viewed.fanOut) {
+				if (member.caps.includes(cap)) continue;
+				this.deps.logger.warn("light group dropped a capability this member does not bind", {
+					tags: { deviceId: member.deviceId },
+					meta: {
+						groupDeviceId,
+						cap
+					}
+				});
+			}
+		}
+	}
+	async command(input) {
+		const group = [...this.groups.values()].find((item) => item.groupDeviceId === input.groupDeviceId);
+		if (group === void 0) {
+			this.deps.logger.warn("actuator command dropped — this device is not a live helper group", {
+				tags: { deviceId: input.groupDeviceId },
+				meta: {
+					cap: input.cap,
+					method: input.method
+				}
+			});
+			throw new Error("actuator group is not live");
+		}
+		if (!group.shared.includes(input.cap)) {
+			this.deps.logger.warn("actuator command dropped — the group does not share that capability", {
+				tags: { deviceId: input.groupDeviceId },
+				meta: {
+					cap: input.cap,
+					method: input.method
+				}
+			});
+			throw new Error(`group does not share ${input.cap}`);
+		}
+		const results = await runFanOut(fanOutTargets(group.fanOut, input.cap, input.method, input.args), (call) => this.deps.invoke(call));
+		const failed = results.flatMap((result) => result.ok ? [] : [result]);
+		for (const result of failed) this.deps.logger.warn("actuator group command failed on a member — the others were still attempted", {
+			tags: { deviceId: result.deviceId },
+			meta: {
+				groupDeviceId: input.groupDeviceId,
+				cap: input.cap,
+				method: input.method,
+				error: result.error
+			}
+		});
+		if (failed.length > 0) this.deps.logger.warn("actuator group command finished with member failures", {
+			tags: { deviceId: input.groupDeviceId },
+			meta: {
+				failed: failed.length,
+				attempted: results.length,
+				cap: input.cap
+			}
+		});
+		const at = this.deps.now();
+		this.deps.deviceOf(group.blockId)?.recordCommands(results.map((result) => ({
+			deviceId: result.deviceId,
+			cap: input.cap,
+			method: input.method,
+			ok: result.ok,
+			...result.ok ? {} : { error: result.error },
+			at
+		})));
+	}
+};
+function sharedOf(templateId, viewed) {
+	if (templateId === "switch") return ["switch"];
+	if (viewed.capLists === null) return ["switch"];
+	const shared = sharedLightCaps(viewed.capLists);
+	return shared.includes("switch") ? shared : ["switch", ...shared];
+}
+function copyMember(member) {
+	return {
+		source: {
+			addonId: member.source.addonId,
+			stableId: member.source.stableId
+		},
+		cap: member.cap,
+		fieldPath: member.fieldPath
+	};
+}
+//#endregion
 //#region src/builtins/composer/composed-device-set.ts
 /**
 * The composed devices the composer DECLARED (D659): one row per `new`-target
@@ -1290,7 +1642,9 @@ function writable(record) {
 	switch (record.plan.unavailable) {
 		case "null": return null;
 		case "unknown": return "unknown";
-		default: return;
+		case "omit":
+		case "offline":
+		case "release": return;
 	}
 }
 function errorText(error) {
@@ -2013,7 +2367,16 @@ var CompositionRuntime = class {
 		this.seeded = new Set([...this.seeded, cap]);
 		this.markWritten(cap, entries);
 	}
+	/** An omitted optional reading must leave the slice, not keep the previous number (D944). */
+	clearsOmitted(cap) {
+		return this.recordsOf(cap).some((record) => record.plan.unavailable === "omit" && record.outcome?.state === "unavailable");
+	}
 	patchCap(cap, touched) {
+		if (this.clearsOmitted(cap)) {
+			const entries = this.entriesFor(cap, this.recordsOf(cap));
+			if (this.write(cap, "seed", entries)) this.markWritten(cap, entries);
+			return;
+		}
 		const entries = this.entriesFor(cap, this.recordsOf(cap).filter((r) => touched.has(fieldKey(r.plan)) && (!r.hasWritten || writable(r) !== r.written)));
 		if (entries.length === 0) return;
 		if (this.write(cap, "patch", entries)) this.markWritten(cap, entries);
@@ -3241,6 +3604,7 @@ var Composer = class {
 	claimGate;
 	targets;
 	grafts;
+	actuators;
 	/** The rows the composer owns, read ONCE before its first withdrawal decision. */
 	rowSeed;
 	/**
@@ -3272,6 +3636,7 @@ var Composer = class {
 			this.grafts.describing(deviceId);
 			return deps.describeTarget(deviceId);
 		});
+		this.actuators = this.attachActuators(deps);
 		this.waits = new ApplyWaits(deps.logger);
 		this.rowSeed = composedRowSeed({
 			logger: deps.logger,
@@ -3323,9 +3688,33 @@ var Composer = class {
 		this.targets.invalidate(data.deviceId);
 		this.grafts.onBindingsChanged(data);
 		this.dispatch(await this.deps.tracker.onBindingsChanged(data.deviceId, data.capName, data.reason));
+		await this.chained(() => this.actuators?.onMemberBindings(data.deviceId));
 	}
 	shutdown() {
 		for (const entry of this.live.values()) entry.runtime?.stop();
+		this.actuators?.shutdown();
+	}
+	attachActuators(deps) {
+		const read = deps.readActuatorMember;
+		const invoke = deps.invokeActuator;
+		if (read === void 0 || invoke === void 0) return null;
+		return new ActuatorGroups({
+			logger: deps.logger.child("actuators"),
+			now: deps.now,
+			resolve: (ref) => {
+				const found = deps.tracker.resolution(ref);
+				return found.kind === "found" ? {
+					kind: "found",
+					deviceId: found.deviceId
+				} : { kind: "other" };
+			},
+			readMember: read,
+			deviceOf: (blockId) => {
+				const device = this.composed.get(composedDeviceStableId(blockId));
+				return device !== null && isActuatorGroupDevice(device) ? device : null;
+			},
+			invoke
+		});
 	}
 	/** Run `work` after every apply already queued, whether that settled or failed. */
 	chained(work) {
@@ -3359,6 +3748,10 @@ var Composer = class {
 		await Promise.all(rebuilt.stopped.map((runtime) => runtime.quiesce()));
 		const unreleasedClaims = await this.releaseConfirmed(releasing);
 		await this.syncSources(rebuilt);
+		await this.actuators?.sync(input.blocks.map((block) => ({
+			id: block.id,
+			helper: block.composition.helper
+		})));
 		await this.reconcileClaims();
 		return {
 			blocks: planned.map((p) => this.verdict(p.block.id)),
@@ -3741,8 +4134,21 @@ var NodeDeadlineTimer = class {
 function unanswered(def) {
 	return Object.entries(def.methods).filter(([name, m]) => m.systemOnly !== true && def.composedMethods?.[name] === void 0).map(([name]) => name);
 }
-function composedMethod(answer) {
+function isSliceRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** A slice field that is present. Unknown throws — it is not false or 0 (D393). */
+function sliceField(slice, field) {
+	const value = slice?.[field];
+	if (typeof value === "boolean" || typeof value === "number" || typeof value === "string") return value;
+	throw new Error(`composed ${field} is unknown — not a stand-in value`);
+}
+function composedMethod(answer, readSlice) {
 	if (answer.kind === "answer") return async () => answer.value;
+	if (answer.kind === "slice") {
+		const field = answer.field;
+		return async () => sliceField(await readSlice(), field);
+	}
 	return async () => {
 		throw new Error(answer.reason);
 	};
@@ -3860,7 +4266,11 @@ var GraftHost = class {
 		return ctx;
 	}
 	providerFor(deviceId, def) {
-		const answers = Object.entries(def.composedMethods ?? {}).map(([name, answer]) => [name, composedMethod(answer)]);
+		const readSlice = async () => {
+			const slice = await this.readMerged(deviceId, def.name);
+			return isSliceRecord(slice) ? slice : null;
+		};
+		const answers = Object.entries(def.composedMethods ?? {}).map(([name, answer]) => [name, composedMethod(answer, readSlice)]);
 		const withStatus = def.status === void 0 && def.runtimeState === void 0 ? [] : [["getStatus", async () => this.readMerged(deviceId, def.name)]];
 		return Object.fromEntries([...answers, ...withStatus]);
 	}
@@ -3937,7 +4347,7 @@ function entriesOf(request) {
 	}))];
 }
 function valueAtPath(slice, path) {
-	return path.split(".").reduce((node, segment) => isRecord$2(node) ? node[segment] : void 0, slice);
+	return path.split(".").reduce((node, segment) => isRecord$3(node) ? node[segment] : void 0, slice);
 }
 function onlineOf(slice) {
 	const online = slice["online"];
@@ -4604,12 +5014,12 @@ var DECLARED_INTEGRATION_NAME_UNUSED = "Blocks";
 var PULSE_HISTORY_MAX_POINTS = 5e3;
 /** The owner-only shadow payload is not in the typed catalog: narrowed at the boundary, like `device.state-changed`. */
 function parseNativeShadowChanged(data) {
-	if (!isRecord$2(data)) return null;
+	if (!isRecord$3(data)) return null;
 	const deviceId = data["deviceId"];
 	const capName = data["capName"];
 	const native = data["native"];
 	if (typeof deviceId !== "number" || typeof capName !== "string") return null;
-	if (!isRecord$2(native)) return null;
+	if (!isRecord$3(native)) return null;
 	return {
 		deviceId,
 		capName,
@@ -4773,7 +5183,43 @@ var ComposerAddon = class extends BaseAddon {
 			describeTarget: readBoundCaps,
 			grafts,
 			now: () => Date.now(),
-			newTimer: () => new NodeDeadlineTimer(() => Date.now())
+			newTimer: () => new NodeDeadlineTimer(() => Date.now()),
+			readActuatorMember: async (deviceId) => {
+				try {
+					const bindings = await api.deviceManager.getBindings.query({ deviceId });
+					const found = await api.deviceManager.getDevice.query({ deviceId });
+					return {
+						kind: "ready",
+						caps: bindings.entries.map((entry) => entry.capName),
+						features: found === null ? [] : [...found.features]
+					};
+				} catch (err) {
+					return {
+						kind: "unreadable",
+						error: errMsg(err)
+					};
+				}
+			},
+			invokeActuator: (call) => invokeActuatorCall({
+				switchSetState: async (deviceId, on) => {
+					await api.switch.setState.mutate({
+						deviceId,
+						on
+					});
+				},
+				setBrightness: async (deviceId, percentage) => {
+					await api.brightness.setBrightness.mutate({
+						deviceId,
+						percentage
+					});
+				},
+				setColor: async (deviceId, color) => {
+					await api.color.setColor.mutate({
+						deviceId,
+						color
+					});
+				}
+			}, call)
 		});
 		this.subscribe({ category: EventCategory.DeviceStateChanged }, (event) => {
 			const data = parseDeviceStateChanged(event.data);

package/dist/builtins/composer/composer.d.ts

@@ -47,8 +47,9 @@
 * (where a runtime writes and how it reads) and `composer-live-set.ts` (the
 * pure reads of the live set: tracked sources, reset keys, wanted claims).
 */
-import { type CapabilityLookup, type ComposerApplyInput, type ComposerApplyResult, type CompositionBlockState, type IScopedLogger } from "@camstack/types";
+import { type CapabilityLookup, type ComposerApplyInput, type ComposerApplyResult, type FanOutCall, type CompositionBlockState, type IScopedLogger } from "@camstack/types";
 import type { DeviceStateChangedData } from "../shared/device-state-changed.js";
+import { type ActuatorMemberLookup } from "./actuator-groups.js";
 import { type ComposerDeclare, type ComposerDevicePorts } from "./composed-device-set.js";
 import { type PersistedComposedRow } from "./composition-declarations.js";
 import type { CompositionEventEmitter, DeadlineTimer } from "./composition-runtime.js";
@@ -96,6 +97,13 @@ export interface ComposerDeps {
 	readonly grafts?: ComposerGraftPorts;
 	readonly now: () => number;
 	readonly newTimer: () => DeadlineTimer;
+	/**
+	* Member capabilities and the command that reaches one member. Absent in
+	* tests that predate actuator groups: those compositions still aggregate,
+	* and a command names that fan-out was not attached.
+	*/
+	readonly readActuatorMember?: (deviceId: number) => Promise<ActuatorMemberLookup>;
+	readonly invokeActuator?: (call: FanOutCall) => Promise<void>;
 }
 export declare class Composer {
 	private readonly deps;
@@ -108,6 +116,7 @@ export declare class Composer {
 	private readonly claimGate;
 	private readonly targets;
 	private readonly grafts;
+	private readonly actuators;
 	/** The rows the composer owns, read ONCE before its first withdrawal decision. */
 	private readonly rowSeed;
 	/**
@@ -134,6 +143,7 @@ export declare class Composer {
 	onDeviceUnregistered(deviceId: number): Promise<void>;
 	onBindingsChanged(data: DeviceBindingsChangedData): Promise<void>;
 	shutdown(): void;
+	private attachActuators;
 	/** Run `work` after every apply already queued, whether that settled or failed. */
 	private chained;
 	private applyNow;

package/dist/builtins/composer/composition-runtime.d.ts

@@ -156,6 +156,8 @@ export declare class CompositionRuntime {
 	/** One info line per field per direction, never one per pass. */
 	private logReleaseTransitions;
 	private seedCap;
+	/** An omitted optional reading must leave the slice, not keep the previous number (D944). */
+	private clearsOmitted;
 	private patchCap;
 	/**
 	* After a failed write nothing is known about what landed, and after a

package/dist/builtins/console-logging/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-xCNJAQMh.js");
+const require_dist = require("../../dist-CrsVjBbk.js");
 const require_formatter = require("../../formatter-xbxeV4GD.js");
 //#region src/builtins/console-logging/console-destination.ts
 var LEVEL_RANK = {

package/dist/builtins/console-logging/index.mjs

@@ -1,4 +1,4 @@
-import { Ln as logDestinationCapability, ni as BaseAddon } from "../../dist-Df6c0RX_.mjs";
+import { Un as logDestinationCapability, pi as BaseAddon } from "../../dist-Dfwxsc_Y.mjs";
 import { t as formatLogLine } from "../../formatter-DkYZ4LXp.mjs";
 //#region src/builtins/console-logging/console-destination.ts
 var LEVEL_RANK = {