@camstack/system 1.2.314 → 1.2.315

package/dist/{dist-cH4t1ZEm.mjs → dist-MzYJVCLE.mjs}

@@ -701,7 +701,7 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	return EventCategory;
 }({});
 //#endregion
-//#region ../types/dist/sleep-jkRQgtSc.mjs
+//#region ../types/dist/sleep-E6eD4yQS.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -2777,6 +2777,10 @@ function toNodeId(idOrRunnerId) {
 	const head = idOrRunnerId.split("/")[0];
 	return head === void 0 || head.length === 0 ? idOrRunnerId : head;
 }
+z.object({
+	field: z.string().min(1),
+	on: z.literal("advance")
+});
 /**
 * Resolve the EFFECTIVE mount hint for a cap — the explicit `mount` when
 * present, else the scope/mode/deviceNative-derived default. Single source
@@ -3508,7 +3512,7 @@ function errMsg(err) {
 	return String(err);
 }
 //#endregion
-//#region ../types/dist/composition-CPFIlFfw.mjs
+//#region ../types/dist/composition-D5BQywfe.mjs
 var AUDIO_ENCODER_BY_CODEC = {
 	opus: "libopus",
 	aac: "aac",
@@ -3902,6 +3906,173 @@ function buildFfmpegArgs(inv) {
 	];
 }
 /**
+* LA tabella "quale booleano di questo tipo di device conta come ALTO", e il
+* valutatore puro del suo FRONTE.
+*
+* Viveva dentro il builtin virtual-doorbell
+* (`@camstack/system` — `builtins/doorbell/trigger-engine.ts`) e i suoi
+* predicati erano privati al modulo. Il recorder ne ha bisogno per il trigger
+* `RecordingTriggers.sensorDeviceIds`: copiarla avrebbe creato la SECONDA
+* tabella, che diverge alla prima cap aggiunta e il cui sintomo — "il sensore
+* fa suonare il campanello ma non registra" — è esattamente D62. Quindi si
+* SPOSTA qui e il doorbell la ri-esporta.
+*
+* ⚠ NON è `DEVICE_STATE_READERS` (`catalogs/device-state-vocabulary.ts`), e le
+* due non vanno unificate: quella risponde a "qual è la PAROLA di stato per una
+* regola" (e include `presence`, `cover`, `alarm-panel`), questa a "qual è il
+* booleano il cui FRONTE conta". Vocabolari deliberatamente diversi.
+*/
+/**
+* Known binary / switch source caps → the boolean slice field whose
+* false→true rise counts as ACTIVE. Every entry is "fire on active".
+* Sensors whose "active" reading is not a plain boolean (presence's string
+* state, connectivity's connected flag) are deliberately excluded — a
+* reconnect is not a doorbell press, and it is not a recording either.
+*/
+var SOURCE_CAP_ACTIVE_FIELD = {
+	contact: "entryOpen",
+	binary: "on",
+	switch: "on",
+	motion: "detected",
+	flood: "flooded",
+	gas: "detected",
+	smoke: "detected",
+	"carbon-monoxide": "detected",
+	vibration: "detected",
+	tamper: "tampered"
+};
+/**
+* The same caps → the slice field carrying the ms-epoch timestamp of the
+* last transition. Every source cap MUST appear here (guarded by a spec):
+* without a transition timestamp the evaluator cannot tell a genuine rise
+* from a boot-time hydration when the FIRST slice it ever sees is already
+* active, and errs towards silence — swallowing the rise.
+*
+* These timestamps are UPSTREAM ones, not ingest ones: the Home Assistant
+* provider derives them from `state.last_changed`, so they survive our own
+* restarts and correctly read as "hours ago" for a state that has been
+* active for hours. `motion` names its rise timestamp `lastDetectedAt`.
+*/
+var SOURCE_CAP_CHANGED_AT_FIELD = {
+	contact: "lastChangedAt",
+	binary: "lastChangedAt",
+	switch: "lastChangedAt",
+	motion: "lastDetectedAt",
+	flood: "lastChangedAt",
+	gas: "lastChangedAt",
+	smoke: "lastChangedAt",
+	"carbon-monoxide": "lastChangedAt",
+	vibration: "lastChangedAt",
+	tamper: "lastChangedAt"
+};
+/** Cap names whose presence in a device's bindings qualify it as a source. */
+var SOURCE_CAPS = Object.keys(SOURCE_CAP_ACTIVE_FIELD);
+/** True when a cap is a recognised binary/switch source. */
+function isSourceCap(capName) {
+	return Object.prototype.hasOwnProperty.call(SOURCE_CAP_ACTIVE_FIELD, capName);
+}
+/** Extract the "active" boolean a source cap's slice carries, or null when
+*  the cap is unknown or the field is missing / non-boolean. */
+function sliceActiveValue(capName, slice) {
+	const field = SOURCE_CAP_ACTIVE_FIELD[capName];
+	if (field === void 0) return null;
+	const raw = slice[field];
+	return typeof raw === "boolean" ? raw : null;
+}
+/** Ms-epoch transition timestamp a source cap's slice carries, or null when
+*  it is absent, non-numeric or the zero "never observed" sentinel. */
+function sliceChangedAt(capName, slice) {
+	const field = SOURCE_CAP_CHANGED_AT_FIELD[capName];
+	if (field === void 0) return null;
+	const raw = slice[field];
+	if (typeof raw !== "number" || !Number.isFinite(raw) || raw <= 0) return null;
+	return raw;
+}
+/**
+* How recent a source's own transition timestamp must be for a FIRST
+* sighting that is already active to count as a genuine rise rather than a
+* hydration of long-standing state.
+*/
+var DEFAULT_FIRST_SIGHTING_FRESHNESS_MS = 3e4;
+/**
+* The source-independent edge rule. The caller supplies an already extracted
+* boolean level and source timestamp; this function owns first-sighting
+* freshness and false-to-true detection.
+*/
+function evaluateSensorLevelEdge(input) {
+	const timestamp = input.changedAt;
+	const freshFloor = Math.max(input.startedAtMs, input.nowMs - input.firstSightingFreshnessMs);
+	const firstRise = input.priorLevel === void 0 && input.level && timestamp !== null && Number.isFinite(timestamp) && timestamp >= freshFloor;
+	const transitionRise = input.priorLevel === false && input.level && timestamp !== null && Number.isFinite(timestamp);
+	if ((firstRise || transitionRise) && timestamp !== null) return {
+		kind: "rise",
+		timestamp
+	};
+	return {
+		kind: "none",
+		nextPriorLevel: input.level
+	};
+}
+/**
+* IL fronte. Puro: nessun orologio proprio, nessuna memoria — il chiamante
+* porta `prior`, `nowMs` e il proprio `startedAtMs`.
+*
+* Il caso della PRIMA slice già attiva è trattato esplicitamente e vale come
+* fronte solo se il timestamp UPSTREAM della transizione è posteriore a
+* `startedAtMs` **e** entro `firstSightingFreshnessMs`. Entrambe le metà
+* servono: la sola freschezza scatterebbe su un'idratazione al boot di uno
+* stato flippato pochi secondi prima del riavvio, e il solo "dopo che abbiamo
+* iniziato" scatterebbe, su un processo di lunga vita, per una sorgente
+* adottata oggi il cui stato è cambiato ieri. Il caso ambiguo ERRA VERSO IL
+* SILENZIO e lo dichiara (`baseline-seeded-stale-active`).
+*/
+function evaluateSensorEdge(input) {
+	const value = sliceActiveValue(input.capName, input.slice);
+	if (value === null) return {
+		edge: "none",
+		value: null,
+		reason: isSourceCap(input.capName) ? "non-boolean-value" : "unknown-cap"
+	};
+	if (evaluateSensorLevelEdge({
+		level: value,
+		changedAt: sliceChangedAt(input.capName, input.slice),
+		priorLevel: input.prior,
+		startedAtMs: input.startedAtMs,
+		nowMs: input.nowMs,
+		firstSightingFreshnessMs: input.firstSightingFreshnessMs
+	}).kind === "rise") return {
+		edge: "rising",
+		value: true
+	};
+	if (input.prior === void 0) {
+		if (!value) return {
+			edge: "none",
+			value,
+			reason: "baseline-seeded-inactive"
+		};
+		return {
+			edge: "none",
+			value,
+			reason: "baseline-seeded-stale-active"
+		};
+	}
+	if (input.prior === value) return {
+		edge: "none",
+		value,
+		reason: "no-change"
+	};
+	if (!value) return {
+		edge: "none",
+		value,
+		reason: "falling-edge"
+	};
+	return {
+		edge: "none",
+		value,
+		reason: "missing-timestamp"
+	};
+}
+/**
 * Error types for the safe expression engine. Two distinct classes so callers
 * can tell a compile-time (grammar) failure from a runtime (evaluation)
 * failure — both are non-fatal to the host: read paths degrade to "skip link".
@@ -3924,6 +4095,9 @@ var ExpressionEvalError = class extends Error {
 		this.name = "ExpressionEvalError";
 	}
 };
+function isStatefulBuiltin(name) {
+	return name === "rose" || name === "count";
+}
 function asFiniteNumber(value, name, index) {
 	if (typeof value !== "number" || !Number.isFinite(value)) throw new ExpressionEvalError(`${name}: argument ${index + 1} must be a finite number`);
 	return value;
@@ -3959,6 +4133,37 @@ function toNumberOrNull(value) {
 	const parsed = Number(trimmed);
 	return Number.isFinite(parsed) ? parsed : null;
 }
+var DEFAULT_ROSE_DEBOUNCE_MS = 2e3;
+function evaluateRose(level, changedAt, debounceMs, call, field, env) {
+	const active = asBoolean(level, "rose", 0);
+	const timestamp = typeof changedAt === "number" && Number.isFinite(changedAt) ? changedAt : null;
+	const debounce = debounceMs === void 0 ? DEFAULT_ROSE_DEBOUNCE_MS : asFiniteNumber(debounceMs, "rose", 2);
+	if (debounce < 0) throw new ExpressionEvalError("rose: debounce must be a non-negative finite number");
+	const verdict = evaluateSensorLevelEdge({
+		level: active,
+		changedAt: timestamp,
+		priorLevel: call.priorLevel,
+		startedAtMs: env.startedAtMs,
+		nowMs: env.nowMs,
+		firstSightingFreshnessMs: DEFAULT_FIRST_SIGHTING_FRESHNESS_MS
+	});
+	call.priorLevel = verdict.kind === "rise" ? true : verdict.nextPriorLevel;
+	if (verdict.kind === "none") return env.currentOutput;
+	if (field.acceptedEdgeAt !== null && verdict.timestamp - field.acceptedEdgeAt < debounce) return env.currentOutput;
+	field.acceptedEdgeAt = verdict.timestamp;
+	return verdict.timestamp;
+}
+function evaluateCount(input, call, currentOutput) {
+	const currentCount = typeof currentOutput === "number" && Number.isFinite(currentOutput) && currentOutput >= 0 ? currentOutput : 0;
+	if (typeof input !== "number" || !Number.isFinite(input)) return currentCount;
+	if (call.highWater === null) {
+		call.highWater = input;
+		return currentCount;
+	}
+	if (input <= call.highWater) return currentCount;
+	call.highWater = input;
+	return currentCount + 1;
+}
 var INF = Number.POSITIVE_INFINITY;
 var table = {
 	min: {
@@ -4098,6 +4303,20 @@ var table = {
 			const present = args.flatMap((a, i) => a === null ? [] : [asFiniteNumber(a, "latest", i)]);
 			return present.length === 0 ? null : finiteResult(Math.max(...present), "latest");
 		}
+	},
+	rose: {
+		minArgs: 2,
+		maxArgs: 3,
+		apply: () => {
+			throw new ExpressionEvalError("rose: stateful evaluation context is required");
+		}
+	},
+	count: {
+		minArgs: 1,
+		maxArgs: 1,
+		apply: () => {
+			throw new ExpressionEvalError("count: stateful evaluation context is required");
+		}
 	}
 };
 /** Frozen, null-prototype builtin table. */
@@ -4551,22 +4770,28 @@ function step(ctx) {
 	ctx.steps += 1;
 	if (ctx.steps > ctx.maxSteps) throw new ExpressionEvalError("expression evaluation step budget exceeded");
 }
-function evalNode(node, ctx) {
+function childPath(path, child) {
+	return `${path}/${child}`;
+}
+function evalNode(node, ctx, path) {
 	step(ctx);
 	switch (node.kind) {
 		case "literal": return node.value;
 		case "identifier":
 			if (!(node.name in ctx.scope)) throw new ExpressionEvalError(`unknown identifier: ${node.name}`);
 			return ctx.scope[node.name];
-		case "unary": return evalUnary(node.op, evalNode(node.operand, ctx));
-		case "binary": return evalBinary(node.op, evalNode(node.left, ctx), evalNode(node.right, ctx));
+		case "unary": return evalUnary(node.op, evalNode(node.operand, ctx, childPath(path, "operand")));
+		case "binary": return evalBinary(node.op, evalNode(node.left, ctx, childPath(path, "left")), evalNode(node.right, ctx, childPath(path, "right")));
 		case "logical": {
-			const left = evalNode(node.left, ctx);
-			if (node.op === "&&") return truthy(left) ? evalNode(node.right, ctx) : left;
-			return truthy(left) ? left : evalNode(node.right, ctx);
+			const left = evalNode(node.left, ctx, childPath(path, "left"));
+			if (node.op === "&&") return truthy(left) ? evalNode(node.right, ctx, childPath(path, "right")) : left;
+			return truthy(left) ? left : evalNode(node.right, ctx, childPath(path, "right"));
+		}
+		case "conditional": return truthy(evalNode(node.test, ctx, childPath(path, "test"))) ? evalNode(node.consequent, ctx, childPath(path, "consequent")) : evalNode(node.alternate, ctx, childPath(path, "alternate"));
+		case "call": {
+			const args = node.args.map((arg, index) => evalNode(arg, ctx, childPath(path, `arg:${index}`)));
+			return invokeCall(node.callee, args, path, ctx);
 		}
-		case "conditional": return truthy(evalNode(node.test, ctx)) ? evalNode(node.consequent, ctx) : evalNode(node.alternate, ctx);
-		case "call": return evalCall(node.callee, node.args.map((a) => evalNode(a, ctx)), ctx.hooks);
 	}
 }
 function evalUnary(op, operand) {
@@ -4597,11 +4822,19 @@ function evalBinary(op, left, right) {
 			throw new ExpressionEvalError(`"${op}" requires two numbers or two strings`);
 	}
 }
-function evalCall(callee, args, hooks) {
+function invokeCall(callee, args, path, ctx) {
 	if (!Object.prototype.hasOwnProperty.call(EXPRESSION_BUILTINS, callee)) throw new ExpressionEvalError(`unknown function: ${callee}`);
 	const builtin = EXPRESSION_BUILTINS[callee];
 	if (args.length < builtin.minArgs || args.length > builtin.maxArgs) throw new ExpressionEvalError(`${callee}: wrong number of arguments (${args.length})`);
-	return builtin.apply(args, hooks);
+	if (isStatefulBuiltin(callee)) {
+		if (ctx.invokeStateful === void 0) throw new ExpressionEvalError(`${callee}: stateful evaluation context is required`);
+		return ctx.invokeStateful({
+			name: callee,
+			path,
+			args
+		});
+	}
+	return builtin.apply(args, ctx.hooks);
 }
 /** Evaluate an AST node against a scope. Throws `ExpressionEvalError` on any
 *  runtime failure (unknown identifier, type mismatch, non-finite result,
@@ -4611,8 +4844,44 @@ function evaluateAst(node, scope, opts) {
 		scope,
 		hooks: opts?.hooks ?? EMPTY_HOOKS,
 		maxSteps: opts?.maxSteps ?? 4096,
+		...opts?.invokeStateful === void 0 ? {} : { invokeStateful: opts.invokeStateful },
 		steps: 0
-	});
+	}, "root");
+}
+function createStatefulExpressionMemory() {
+	return {
+		calls: /* @__PURE__ */ new Map(),
+		acceptedEdgeAt: null
+	};
+}
+function cloneStatefulExpressionMemory(memory) {
+	return {
+		calls: new Map([...memory.calls].map(([path, call]) => [path, { ...call }])),
+		acceptedEdgeAt: memory.acceptedEdgeAt
+	};
+}
+function evaluateStatefulExpressionCall(invocation, memory, env) {
+	const existing = memory.calls.get(invocation.path);
+	switch (invocation.name) {
+		case "rose": {
+			const call = existing?.kind === "rose" ? existing : { kind: "rose" };
+			memory.calls.set(invocation.path, call);
+			const currentOutput = env.currentOutput === null || typeof env.currentOutput === "number" && Number.isFinite(env.currentOutput) ? env.currentOutput : null;
+			return evaluateRose(invocation.args[0], invocation.args[1], invocation.args[2], call, memory, {
+				currentOutput,
+				startedAtMs: env.startedAtMs,
+				nowMs: env.nowMs
+			});
+		}
+		case "count": {
+			const call = existing?.kind === "count" ? existing : {
+				kind: "count",
+				highWater: null
+			};
+			memory.calls.set(invocation.path, call);
+			return evaluateCount(invocation.args[0], call, env.currentOutput);
+		}
+	}
 }
 /**
 * Coerce an untrusted `getByPath` / mirror read to an `ExpressionValue`.
@@ -4653,9 +4922,10 @@ function validateExpressionSource(src) {
 /**
 * Shared read-path evaluation. Builds a null-proto scope from `bindingValues`
 * plus the injected `now` (supplied by the caller for determinism and
-* testability), compiles via the LRU, and evaluates. Any failure (parse or
-* eval) returns `{ ok: false }` — the caller treats that as "skip this
-* derivation", never as a throw that takes the pass down.
+* testability), compiles via the LRU, and evaluates. Stateful calls are
+* delegated through `opts.invokeStateful` with their stable AST path. Any
+* failure (parse or eval) returns `{ ok: false }` — the caller treats that as
+* "skip this derivation", never as a throw that takes the pass down.
 */
 function evaluateExpressionSource(expr, bindingValues, now, opts) {
 	const compiled = compileExpressionSafe(expr);
@@ -4787,6 +5057,7 @@ var CompositionItemEntrySchema = z.object({
 var CompositionFieldsFeatureSchema = z.object({
 	kind: z.literal("fields"),
 	cap: z.string().min(1),
+	enabled: z.boolean().optional(),
 	fields: z.record(z.string().min(1), CompositionFieldSourceSchema).refine((fields) => Object.keys(fields).length <= 32, { message: `at most 32 fields per capability` }),
 	/**
 	* Items of the cap's item array, keyed by item key (D663). Naming `items`
@@ -4800,9 +5071,14 @@ var CompositionFieldsFeatureSchema = z.object({
 var CompositionPassthroughFeatureSchema = z.object({
 	kind: z.literal("passthrough"),
 	cap: z.string().min(1),
+	enabled: z.boolean().optional(),
 	source: CompositionSourceRefSchema
 });
 var CompositionFeatureSchema = z.discriminatedUnion("kind", [CompositionFieldsFeatureSchema, CompositionPassthroughFeatureSchema]);
+/** Only an explicit `false` disables a feature; omitted preserves the existing wire default. */
+function compositionFeatureEnabled(feature) {
+	return feature.enabled !== false;
+}
 /**
 * A NEW device. It has no `name` of its own: the block's name IS the device's
 * name (2026-08-08). A second copy here would be a second writer of one string (D62).
@@ -11009,6 +11285,190 @@ function procedureAuthKey(auth) {
 function kebabToCamel(s) {
 	return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
 }
+/** Unwrap ZodNullable / ZodOptional / ZodDefault wrappers to reach the inner type.
+*  Zod v4 exposes `.unwrap()` on all three wrapper classes. */
+function unwrapSchema(schema) {
+	let s = schema;
+	while (s instanceof z.ZodNullable || s instanceof z.ZodOptional || s instanceof z.ZodDefault) s = s.unwrap();
+	return s;
+}
+function leafKind(schema) {
+	const s = unwrapSchema(schema);
+	if (s instanceof z.ZodEnum) return {
+		kind: "enum",
+		enumValues: s.options
+	};
+	if (s instanceof z.ZodNumber) return { kind: "number" };
+	if (s instanceof z.ZodString) return { kind: "string" };
+	if (s instanceof z.ZodBoolean) return { kind: "boolean" };
+	return null;
+}
+/** Walk a cap status schema into flat wireable leaf fields (dotted paths).
+*  Recurses into nested ZodObject (unwrapping nullable/optional/default first),
+*  so fields with null live values are still offered. Arrays / unknown shapes
+*  are skipped — never throws. */
+function enumerateSchemaFields(schema, prefix = "") {
+	const root = unwrapSchema(schema);
+	if (!(root instanceof z.ZodObject)) return [];
+	const out = [];
+	const shape = root.shape;
+	for (const [key, field] of Object.entries(shape)) {
+		const path = prefix ? `${prefix}.${key}` : key;
+		const inner = unwrapSchema(field);
+		if (inner instanceof z.ZodObject) {
+			out.push(...enumerateSchemaFields(inner, path));
+			continue;
+		}
+		const leaf = leafKind(field);
+		if (leaf) out.push({
+			path,
+			kind: leaf.kind,
+			...leaf.enumValues ? { enumValues: leaf.enumValues } : {}
+		});
+	}
+	return out;
+}
+/** Enumerate the per-item wireable fields of an item-array cap (see
+*  `CapabilityStatusItemArray`): the item schema's leaf fields, minus the
+*  `keyField` (the key comes from the link's `itemKey`, never from a wired
+*  source), each tagged `item: true` so the authoring UI collects an
+*  `itemKey` alongside the field. Never throws. */
+function enumerateItemArrayFields(itemArray) {
+	return enumerateSchemaFields(itemArray.itemSchema).filter((f) => f.path !== itemArray.keyField).map((f) => ({
+		...f,
+		item: true
+	}));
+}
+/**
+* What a capability's state field IS: kind, nullability, whether required. The
+* validator needs nullability, which `enumerateSchemaFields` does not report,
+* and that decides a field's unavailable mode (D393).
+*/
+function fieldAt(schema, path) {
+	let current = schema;
+	for (const segment of path.split(".")) {
+		const container = unwrapSchema(current);
+		if (!(container instanceof z.ZodObject)) return null;
+		const next = container.shape[segment];
+		if (!(next instanceof z.ZodType)) return null;
+		current = next;
+	}
+	return current;
+}
+function describeStateField(schema, path) {
+	const leaf = enumerateSchemaFields(schema).find((f) => f.path === path);
+	if (leaf === void 0) return null;
+	const field = fieldAt(schema, path);
+	if (field === null) return null;
+	return {
+		path,
+		kind: leaf.kind,
+		nullable: field.safeParse(null).success,
+		required: !field.safeParse(void 0).success,
+		...leaf.enumValues === void 0 ? {} : { enumValues: leaf.enumValues }
+	};
+}
+function describeTopLevelStateFields(schema) {
+	return new Map(enumerateSchemaFields(schema).filter((f) => !f.path.includes(".")).flatMap((f) => {
+		const described = describeStateField(schema, f.path);
+		return described === null ? [] : [[f.path, described]];
+	}));
+}
+/** Top-level keys a value MUST carry: those whose schema refuses `undefined`. */
+function requiredTopLevelKeys(schema) {
+	const root = unwrapSchema(schema);
+	if (!(root instanceof z.ZodObject)) return [];
+	return Object.entries(root.shape).flatMap(([key, field]) => field instanceof z.ZodType && !field.safeParse(void 0).success ? [key] : []);
+}
+/**
+* The proper prefixes of `path` whose schema accepts `undefined`: a required
+* leaf under one of them is required only once something writes that parent
+* (`remaining.unit` is required only when `remaining` is present).
+*/
+function optionalAncestors(schema, path) {
+	const segments = path.split(".");
+	return segments.slice(0, -1).flatMap((_, i) => {
+		const prefix = segments.slice(0, i + 1).join(".");
+		const field = fieldAt(schema, prefix);
+		return field !== null && field.safeParse(void 0).success ? [prefix] : [];
+	});
+}
+var EVENT_CATEGORIES = { "doorbell.onPressed": EventCategory.DoorbellOnPressed };
+var CompositionEventPlanSchema = z.object({
+	featureIndex: z.number().int().nonnegative(),
+	cap: z.string(),
+	eventName: z.string(),
+	category: z.enum(EventCategory),
+	stateField: z.string(),
+	fieldKey: z.string()
+});
+function eventProblem(code, path, message) {
+	return {
+		code,
+		path,
+		message
+	};
+}
+function payloadReason(error) {
+	return error.issues.map((issue) => `${issue.path.length === 0 ? "payload" : issue.path.join(".")}: ${issue.message}`).join("; ");
+}
+/**
+* Plan one capability's state-derived events after its feature mode and fields
+* are known. A native replacement never becomes a second event authority.
+*/
+function planCompositionEvents(def, feature, fields) {
+	if (feature.mode === "replace") return {
+		problems: [],
+		events: []
+	};
+	const problems = [];
+	const events = [];
+	for (const [eventName, declaration] of Object.entries(def.events ?? {})) {
+		const fromState = declaration.fromState;
+		if (fromState === void 0) continue;
+		const statePath = `features[${feature.featureIndex}].fields.${fromState.field}`;
+		const state = def.runtimeState ? describeStateField(def.runtimeState, fromState.field) : null;
+		if (state === null) {
+			problems.push(eventProblem("unknown-field", statePath, `\`${def.name}.${eventName}\` derives from missing state field \`${fromState.field}\``));
+			continue;
+		}
+		if (state.kind !== "number") {
+			problems.push(eventProblem("kind-mismatch", statePath, `\`${def.name}.${eventName}\` needs a numeric state field; \`${fromState.field}\` is ${state.kind}`));
+			continue;
+		}
+		const eventKey = `${def.name}.${eventName}`;
+		const category = EVENT_CATEGORIES[eventKey];
+		if (category === void 0) {
+			problems.push(eventProblem("not-composable", `features[${feature.featureIndex}].cap`, `\`${eventKey}\` has no explicit composition event-category mapping`));
+			continue;
+		}
+		const payload = declaration.data.safeParse({
+			deviceId: 1,
+			timestamp: 1
+		});
+		if (!payload.success) {
+			problems.push(eventProblem("not-composable", `features[${feature.featureIndex}].cap`, `\`${eventKey}\` cannot be derived from { deviceId, timestamp }: ${payloadReason(payload.error)}`));
+			continue;
+		}
+		const field = fields.find((candidate) => candidate.featureIndex === feature.featureIndex && candidate.cap === def.name && candidate.path === fromState.field && candidate.item === void 0);
+		if (field === void 0) {
+			problems.push(eventProblem("unknown-field", statePath, `\`${eventKey}\` derives from \`${fromState.field}\`, but that field is not composed`));
+			continue;
+		}
+		events.push({
+			featureIndex: feature.featureIndex,
+			cap: def.name,
+			eventName,
+			category,
+			stateField: fromState.field,
+			fieldKey: `${field.cap}.${field.path}`
+		});
+	}
+	return {
+		problems,
+		events
+	};
+}
 /**
 * What the validator says about a composition and what the composer says about
 * a running one: the wire shapes the API returns (D659).
@@ -11063,12 +11523,14 @@ var CompositionUnavailableModeSchema = z.enum([
 ]);
 /**
 * `derived` reads a source · `clock` reads only `now`, recomputed when a sibling
-* field of its cap changes value · `constant` reads nothing, computed once.
+* field of its cap changes value · `constant` reads nothing, computed once ·
+* `accumulator` advances from the target's seed/current output.
 */
 var CompositionFieldRoleSchema = z.enum([
 	"derived",
 	"clock",
-	"constant"
+	"constant",
+	"accumulator"
 ]);
 /** The item a planned field belongs to; its `path` is then the dotted path INSIDE the item. */
 var CompositionFieldItemSchema = z.object({
@@ -11109,6 +11571,7 @@ var CompositionFeatureModeSchema = z.enum([
 	"replace"
 ]);
 var CompositionFeaturePlanSchema = z.object({
+	/** Index in the stored feature array; disabled features are omitted rather than re-indexed. */
 	featureIndex: z.number().int().nonnegative(),
 	cap: z.string(),
 	mode: CompositionFeatureModeSchema
@@ -11117,7 +11580,8 @@ var CompositionValidationSchema = z.object({
 	ok: z.boolean(),
 	problems: z.array(CompositionProblemSchema),
 	fields: z.array(CompositionFieldPlanSchema),
-	features: z.array(CompositionFeaturePlanSchema)
+	features: z.array(CompositionFeaturePlanSchema),
+	events: z.array(CompositionEventPlanSchema)
 });
 /**
 * Mirrors `CoreBlockStatus`, pinned by `core-blocks-source.spec.ts`. `degraded`:
@@ -29024,148 +29488,6 @@ var videoclipsCapability = {
 	}
 };
 /**
-* LA tabella "quale booleano di questo tipo di device conta come ALTO", e il
-* valutatore puro del suo FRONTE.
-*
-* Viveva dentro il builtin virtual-doorbell
-* (`@camstack/system` — `builtins/doorbell/trigger-engine.ts`) e i suoi
-* predicati erano privati al modulo. Il recorder ne ha bisogno per il trigger
-* `RecordingTriggers.sensorDeviceIds`: copiarla avrebbe creato la SECONDA
-* tabella, che diverge alla prima cap aggiunta e il cui sintomo — "il sensore
-* fa suonare il campanello ma non registra" — è esattamente D62. Quindi si
-* SPOSTA qui e il doorbell la ri-esporta.
-*
-* ⚠ NON è `DEVICE_STATE_READERS` (`catalogs/device-state-vocabulary.ts`), e le
-* due non vanno unificate: quella risponde a "qual è la PAROLA di stato per una
-* regola" (e include `presence`, `cover`, `alarm-panel`), questa a "qual è il
-* booleano il cui FRONTE conta". Vocabolari deliberatamente diversi.
-*/
-/**
-* Known binary / switch source caps → the boolean slice field whose
-* false→true rise counts as ACTIVE. Every entry is "fire on active".
-* Sensors whose "active" reading is not a plain boolean (presence's string
-* state, connectivity's connected flag) are deliberately excluded — a
-* reconnect is not a doorbell press, and it is not a recording either.
-*/
-var SOURCE_CAP_ACTIVE_FIELD = {
-	contact: "entryOpen",
-	binary: "on",
-	switch: "on",
-	motion: "detected",
-	flood: "flooded",
-	gas: "detected",
-	smoke: "detected",
-	"carbon-monoxide": "detected",
-	vibration: "detected",
-	tamper: "tampered"
-};
-/**
-* The same caps → the slice field carrying the ms-epoch timestamp of the
-* last transition. Every source cap MUST appear here (guarded by a spec):
-* without a transition timestamp the evaluator cannot tell a genuine rise
-* from a boot-time hydration when the FIRST slice it ever sees is already
-* active, and errs towards silence — swallowing the rise.
-*
-* These timestamps are UPSTREAM ones, not ingest ones: the Home Assistant
-* provider derives them from `state.last_changed`, so they survive our own
-* restarts and correctly read as "hours ago" for a state that has been
-* active for hours. `motion` names its rise timestamp `lastDetectedAt`.
-*/
-var SOURCE_CAP_CHANGED_AT_FIELD = {
-	contact: "lastChangedAt",
-	binary: "lastChangedAt",
-	switch: "lastChangedAt",
-	motion: "lastDetectedAt",
-	flood: "lastChangedAt",
-	gas: "lastChangedAt",
-	smoke: "lastChangedAt",
-	"carbon-monoxide": "lastChangedAt",
-	vibration: "lastChangedAt",
-	tamper: "lastChangedAt"
-};
-/** Cap names whose presence in a device's bindings qualify it as a source. */
-var SOURCE_CAPS = Object.keys(SOURCE_CAP_ACTIVE_FIELD);
-/** True when a cap is a recognised binary/switch source. */
-function isSourceCap(capName) {
-	return Object.prototype.hasOwnProperty.call(SOURCE_CAP_ACTIVE_FIELD, capName);
-}
-/** Extract the "active" boolean a source cap's slice carries, or null when
-*  the cap is unknown or the field is missing / non-boolean. */
-function sliceActiveValue(capName, slice) {
-	const field = SOURCE_CAP_ACTIVE_FIELD[capName];
-	if (field === void 0) return null;
-	const raw = slice[field];
-	return typeof raw === "boolean" ? raw : null;
-}
-/** Ms-epoch transition timestamp a source cap's slice carries, or null when
-*  it is absent, non-numeric or the zero "never observed" sentinel. */
-function sliceChangedAt(capName, slice) {
-	const field = SOURCE_CAP_CHANGED_AT_FIELD[capName];
-	if (field === void 0) return null;
-	const raw = slice[field];
-	if (typeof raw !== "number" || !Number.isFinite(raw) || raw <= 0) return null;
-	return raw;
-}
-/**
-* How recent a source's own transition timestamp must be for a FIRST
-* sighting that is already active to count as a genuine rise rather than a
-* hydration of long-standing state.
-*/
-var DEFAULT_FIRST_SIGHTING_FRESHNESS_MS = 3e4;
-/**
-* IL fronte. Puro: nessun orologio proprio, nessuna memoria — il chiamante
-* porta `prior`, `nowMs` e il proprio `startedAtMs`.
-*
-* Il caso della PRIMA slice già attiva è trattato esplicitamente e vale come
-* fronte solo se il timestamp UPSTREAM della transizione è posteriore a
-* `startedAtMs` **e** entro `firstSightingFreshnessMs`. Entrambe le metà
-* servono: la sola freschezza scatterebbe su un'idratazione al boot di uno
-* stato flippato pochi secondi prima del riavvio, e il solo "dopo che abbiamo
-* iniziato" scatterebbe, su un processo di lunga vita, per una sorgente
-* adottata oggi il cui stato è cambiato ieri. Il caso ambiguo ERRA VERSO IL
-* SILENZIO e lo dichiara (`baseline-seeded-stale-active`).
-*/
-function evaluateSensorEdge(input) {
-	const value = sliceActiveValue(input.capName, input.slice);
-	if (value === null) return {
-		edge: "none",
-		value: null,
-		reason: isSourceCap(input.capName) ? "non-boolean-value" : "unknown-cap"
-	};
-	if (input.prior === void 0) {
-		if (!value) return {
-			edge: "none",
-			value,
-			reason: "baseline-seeded-inactive"
-		};
-		const changedAt = sliceChangedAt(input.capName, input.slice);
-		const floor = Math.max(input.startedAtMs, input.nowMs - input.firstSightingFreshnessMs);
-		if (changedAt === null || changedAt < floor) return {
-			edge: "none",
-			value,
-			reason: "baseline-seeded-stale-active"
-		};
-		return {
-			edge: "rising",
-			value: true
-		};
-	}
-	if (input.prior === value) return {
-		edge: "none",
-		value,
-		reason: "no-change"
-	};
-	if (!value) return {
-		edge: "none",
-		value,
-		reason: "falling-edge"
-	};
-	return {
-		edge: "rising",
-		value: true
-	};
-}
-/**
 * Doorbell button cap. Two kinds of providers coexist behind this cap
 * name (same pattern as `snapshot`):
 *
@@ -29238,7 +29560,13 @@ var doorbellCapability = {
 	* push (`ReolinkSimpleEvent.type === 'doorbell'`). There is no
 	* release/duration — it's a pulse.
 	*/
-onPressed: { data: DoorbellPressEventSchema } },
+onPressed: {
+		data: DoorbellPressEventSchema,
+		fromState: {
+			field: "lastPressedAt",
+			on: "advance"
+		}
+	} },
 	status: {
 		schema: DoorbellStatusSchema,
 		kind: "push"
@@ -42640,7 +42968,7 @@ function createDeviceExtensionProvider(options) {
 var CompositionGraphError = class extends Error {};
 /** `"cap.field"` of every field a peer writes — the same spelling as `compositionFieldKey`. */
 function writtenFields(peer) {
-	return new Set(peer.composition.features.flatMap((feature) => feature.kind !== "fields" ? [] : featureFieldEntries(feature).map(({ fieldPath }) => `${feature.cap}.${fieldPath}`)));
+	return new Set(peer.composition.features.flatMap((feature) => !compositionFeatureEnabled(feature) || feature.kind !== "fields" ? [] : featureFieldEntries(feature).map(({ fieldPath }) => `${feature.cap}.${fieldPath}`)));
 }
 /** A read of the peer's OWN device is an edge only when it reads the peer's own output (rule 5, D663). */
 function readsComposedValue(peer, written, read) {
@@ -42650,7 +42978,7 @@ function readsComposedValue(peer, written, read) {
 }
 function peerEdges(peer) {
 	const written = writtenFields(peer);
-	return peer.composition.features.flatMap((feature) => feature.kind !== "fields" ? [] : featureFieldEntries(feature).map(({ fieldPath, source }) => [compositionReadKey({
+	return peer.composition.features.flatMap((feature) => !compositionFeatureEnabled(feature) || feature.kind !== "fields" ? [] : featureFieldEntries(feature).map(({ fieldPath, source }) => [compositionReadKey({
 		source: peer.target,
 		cap: feature.cap,
 		fieldPath
@@ -42755,114 +43083,6 @@ function findCandidateCycles(candidate, stored) {
 		}];
 	});
 }
-/** Unwrap ZodNullable / ZodOptional / ZodDefault wrappers to reach the inner type.
-*  Zod v4 exposes `.unwrap()` on all three wrapper classes. */
-function unwrapSchema(schema) {
-	let s = schema;
-	while (s instanceof z.ZodNullable || s instanceof z.ZodOptional || s instanceof z.ZodDefault) s = s.unwrap();
-	return s;
-}
-function leafKind(schema) {
-	const s = unwrapSchema(schema);
-	if (s instanceof z.ZodEnum) return {
-		kind: "enum",
-		enumValues: s.options
-	};
-	if (s instanceof z.ZodNumber) return { kind: "number" };
-	if (s instanceof z.ZodString) return { kind: "string" };
-	if (s instanceof z.ZodBoolean) return { kind: "boolean" };
-	return null;
-}
-/** Walk a cap status schema into flat wireable leaf fields (dotted paths).
-*  Recurses into nested ZodObject (unwrapping nullable/optional/default first),
-*  so fields with null live values are still offered. Arrays / unknown shapes
-*  are skipped — never throws. */
-function enumerateSchemaFields(schema, prefix = "") {
-	const root = unwrapSchema(schema);
-	if (!(root instanceof z.ZodObject)) return [];
-	const out = [];
-	const shape = root.shape;
-	for (const [key, field] of Object.entries(shape)) {
-		const path = prefix ? `${prefix}.${key}` : key;
-		const inner = unwrapSchema(field);
-		if (inner instanceof z.ZodObject) {
-			out.push(...enumerateSchemaFields(inner, path));
-			continue;
-		}
-		const leaf = leafKind(field);
-		if (leaf) out.push({
-			path,
-			kind: leaf.kind,
-			...leaf.enumValues ? { enumValues: leaf.enumValues } : {}
-		});
-	}
-	return out;
-}
-/** Enumerate the per-item wireable fields of an item-array cap (see
-*  `CapabilityStatusItemArray`): the item schema's leaf fields, minus the
-*  `keyField` (the key comes from the link's `itemKey`, never from a wired
-*  source), each tagged `item: true` so the authoring UI collects an
-*  `itemKey` alongside the field. Never throws. */
-function enumerateItemArrayFields(itemArray) {
-	return enumerateSchemaFields(itemArray.itemSchema).filter((f) => f.path !== itemArray.keyField).map((f) => ({
-		...f,
-		item: true
-	}));
-}
-/**
-* What a capability's state field IS: kind, nullability, whether required. The
-* validator needs nullability, which `enumerateSchemaFields` does not report,
-* and that decides a field's unavailable mode (D393).
-*/
-function fieldAt(schema, path) {
-	let current = schema;
-	for (const segment of path.split(".")) {
-		const container = unwrapSchema(current);
-		if (!(container instanceof z.ZodObject)) return null;
-		const next = container.shape[segment];
-		if (!(next instanceof z.ZodType)) return null;
-		current = next;
-	}
-	return current;
-}
-function describeStateField(schema, path) {
-	const leaf = enumerateSchemaFields(schema).find((f) => f.path === path);
-	if (leaf === void 0) return null;
-	const field = fieldAt(schema, path);
-	if (field === null) return null;
-	return {
-		path,
-		kind: leaf.kind,
-		nullable: field.safeParse(null).success,
-		required: !field.safeParse(void 0).success,
-		...leaf.enumValues === void 0 ? {} : { enumValues: leaf.enumValues }
-	};
-}
-function describeTopLevelStateFields(schema) {
-	return new Map(enumerateSchemaFields(schema).filter((f) => !f.path.includes(".")).flatMap((f) => {
-		const described = describeStateField(schema, f.path);
-		return described === null ? [] : [[f.path, described]];
-	}));
-}
-/** Top-level keys a value MUST carry: those whose schema refuses `undefined`. */
-function requiredTopLevelKeys(schema) {
-	const root = unwrapSchema(schema);
-	if (!(root instanceof z.ZodObject)) return [];
-	return Object.entries(root.shape).flatMap(([key, field]) => field instanceof z.ZodType && !field.safeParse(void 0).success ? [key] : []);
-}
-/**
-* The proper prefixes of `path` whose schema accepts `undefined`: a required
-* leaf under one of them is required only once something writes that parent
-* (`remaining.unit` is required only when `remaining` is present).
-*/
-function optionalAncestors(schema, path) {
-	const segments = path.split(".");
-	return segments.slice(0, -1).flatMap((_, i) => {
-		const prefix = segments.slice(0, i + 1).join(".");
-		const field = fieldAt(schema, prefix);
-		return field !== null && field.safeParse(void 0).success ? [prefix] : [];
-	});
-}
 function problem(code, path, message) {
 	return {
 		code,
@@ -42874,7 +43094,8 @@ function refused(...problems) {
 	return {
 		problems,
 		fields: [],
-		features: []
+		features: [],
+		events: []
 	};
 }
 /** Where a planned field sits in the composition: `features[N].fields.<path>` or `features[N].items.<key>.fields.<path>`. */
@@ -42916,7 +43137,12 @@ var BUILTIN_RESULT_KINDS = Object.freeze({
 	number: {
 		kind: "fixed",
 		result: ["number", "null"]
-	}
+	},
+	rose: {
+		kind: "fixed",
+		result: ["number", "null"]
+	},
+	count: NUMBER
 });
 var KindInferenceError = class extends Error {};
 function kindOfValue(value) {
@@ -42975,6 +43201,21 @@ function kindsOf(node, bindings) {
 		case "call": return callKinds(node.callee, node.args.map((a) => kindsOf(a, bindings)));
 	}
 }
+function nodeContainsCall(node, callee) {
+	switch (node.kind) {
+		case "literal":
+		case "identifier": return false;
+		case "unary": return nodeContainsCall(node.operand, callee);
+		case "binary":
+		case "logical": return nodeContainsCall(node.left, callee) || nodeContainsCall(node.right, callee);
+		case "conditional": return nodeContainsCall(node.test, callee) || nodeContainsCall(node.consequent, callee) || nodeContainsCall(node.alternate, callee);
+		case "call": return node.callee === callee || node.args.some((arg) => nodeContainsCall(arg, callee));
+	}
+}
+function expressionContainsBuiltinCall(expr, callee) {
+	const compiled = compileExpressionSafe(expr);
+	return compiled.ok && nodeContainsCall(compiled.parsed.ast, callee);
+}
 function inferExpressionKinds(input) {
 	const compiled = compileExpressionSafe(input.expr);
 	if (!compiled.ok) return {
@@ -43095,6 +43336,7 @@ function enumLiteralProblem(cap, target, source, at) {
 }
 function roleOf(source) {
 	if (source.kind !== "expression") return "derived";
+	if (expressionContainsBuiltinCall(source.expr, "count")) return "accumulator";
 	if (fieldReads(source).length > 0) return "derived";
 	const compiled = compileExpressionSafe(source.expr);
 	return compiled.ok && compiled.parsed.identifiers.has("now") ? "clock" : "constant";
@@ -43106,13 +43348,13 @@ function roleOf(source) {
 * field that READS a source never gets `offline`.
 */
 function unavailableFor(tf, role, mode, cap, at) {
-	if (mode === "new" || role !== "derived") return {
+	if (mode === "replace" && (role === "derived" || role === "accumulator")) return {
 		ok: true,
-		unavailable: tf.nullable ? "null" : "offline"
+		unavailable: "release"
 	};
-	if (mode === "replace") return {
+	if (mode === "new" || role !== "derived") return {
 		ok: true,
-		unavailable: "release"
+		unavailable: tf.nullable ? "null" : "offline"
 	};
 	if (tf.nullable) return {
 		ok: true,
@@ -43185,7 +43427,8 @@ function planItemField(ctx, leaf) {
 	return {
 		problems: [...compatibility(capName, tf, kinds.kinds, at), ...enumProblem === null ? [] : [enumProblem]],
 		fields: [plan],
-		features: []
+		features: [],
+		events: []
 	};
 }
 function planItems(def, feature, featureIndex, lookupCap, mode = "new") {
@@ -43204,7 +43447,8 @@ function planItems(def, feature, featureIndex, lookupCap, mode = "new") {
 	const results = Object.entries(feature.items ?? {}).flatMap(([key, item]) => [{
 		problems: missingLeaves(ctx, item, `${at}.${key}`),
 		fields: [],
-		features: []
+		features: [],
+		events: []
 	}, ...Object.entries(item.fields).map(([path, source]) => planItemField(ctx, {
 		key,
 		label: item.label,
@@ -43214,7 +43458,8 @@ function planItems(def, feature, featureIndex, lookupCap, mode = "new") {
 	return {
 		problems: results.flatMap((r) => r.problems),
 		fields: results.flatMap((r) => r.fields),
-		features: []
+		features: [],
+		events: []
 	};
 }
 function describeRead(read) {
@@ -43238,7 +43483,7 @@ function fromReading(reading, read) {
 		deadline: null
 	};
 }
-function expressionOutcome(source, read, now) {
+function expressionOutcome(source, read, now, stateful) {
 	const values = {};
 	const staleReasons = [];
 	let fatalUnavailable = null;
@@ -43267,10 +43512,31 @@ function expressionOutcome(source, read, now) {
 		values[name] = reading.value;
 		if (reading.state === "stale") staleReasons.push(`\`${name}\`: ${reading.reason}`);
 	}
-	if (fatalUnavailable !== null) return fatalUnavailable;
-	if (nonFatalUnavailable !== null) return nonFatalUnavailable;
+	const unavailable = fatalUnavailable ?? nonFatalUnavailable;
+	if (unavailable !== null) {
+		if (stateful !== void 0 && stateful.currentOutput !== void 0 && expressionContainsBuiltinCall(source.expr, "count")) return {
+			state: "stale",
+			value: evaluateCount(null, {
+				kind: "count",
+				highWater: null
+			}, stateful.currentOutput),
+			reason: `${unavailable.reason}; holding the last accumulator value`,
+			deadline: null
+		};
+		return unavailable;
+	}
 	const deadlines = [];
-	const result = evaluateExpressionSource(source.expr, values, now, { hooks: { noteDeadline: (at) => deadlines.push(at) } });
+	const result = evaluateExpressionSource(source.expr, values, now, {
+		hooks: { noteDeadline: (at) => deadlines.push(at) },
+		...stateful === void 0 ? {} : { invokeStateful: (invocation) => evaluateStatefulExpressionCall(stateful.callPathPrefix === void 0 ? invocation : {
+			...invocation,
+			path: `${stateful.callPathPrefix}@${invocation.path}`
+		}, stateful.expressionMemory, {
+			currentOutput: stateful.currentOutput,
+			startedAtMs: stateful.startedAtMs,
+			nowMs: now
+		}) }
+	});
 	if (!result.ok) return {
 		state: "unavailable",
 		value: null,
@@ -43289,7 +43555,7 @@ function evaluateCompositionField(input) {
 	const { source } = input;
 	switch (source.kind) {
 		case "from": return fromReading(input.read(source), source);
-		case "expression": return expressionOutcome(source, input.read, input.now);
+		case "expression": return expressionOutcome(source, input.read, input.now, input.stateful);
 		case "code": return {
 			state: "unavailable",
 			value: null,
@@ -43367,7 +43633,8 @@ function planTopLevelField({ def, fields }, field, mode, lookupCap) {
 	return {
 		problems: [...compatibility(def.name, tf, kinds.kinds, fieldAt), ...enumProblem === null ? [] : [enumProblem]],
 		fields: [plan],
-		features: []
+		features: [],
+		events: []
 	};
 }
 function planFeature(feature, featureIndex, target, lookupCap) {
@@ -43383,14 +43650,22 @@ function planFeature(feature, featureIndex, target, lookupCap) {
 	}, target.mode, lookupCap));
 	const items = feature.items === void 0 ? [] : [planItems(cap.def, feature, featureIndex, lookupCap, target.mode)];
 	const all = [...perField, ...items];
+	const fields = all.flatMap((result) => result.fields);
+	const featurePlan = {
+		featureIndex,
+		cap: cap.def.name,
+		mode: target.mode
+	};
+	const eventPlan = planCompositionEvents(cap.def, featurePlan, fields);
 	return {
-		problems: [...capProblems, ...all.flatMap((r) => r.problems)],
-		fields: all.flatMap((r) => r.fields),
-		features: [{
-			featureIndex,
-			cap: cap.def.name,
-			mode: target.mode
-		}]
+		problems: [
+			...capProblems,
+			...all.flatMap((r) => r.problems),
+			...eventPlan.problems
+		],
+		fields,
+		features: [featurePlan],
+		events: eventPlan.events
 	};
 }
 /** A cap the device serves itself; one the composer grafted (an earlier ADD) is not native. */
@@ -43432,17 +43707,23 @@ function planComposition(composition, lookupCap, target) {
 	const planTarget = planTargetOf(composition, target);
 	if ("code" in planTarget) return refused(planTarget);
 	const results = composition.features.map((feature, index) => {
-		if (feature.kind === "passthrough") return refused(problem("reserved-variant", `features[${index}]`, `whole-capability passthrough of \`${feature.cap}\` arrives in slice 3`));
-		return planFeature(feature, index, featureTargetOf(planTarget, feature.cap), lookupCap);
+		const result = feature.kind === "passthrough" ? refused(problem("reserved-variant", `features[${index}]`, `whole-capability passthrough of \`${feature.cap}\` arrives in slice 3`)) : planFeature(feature, index, featureTargetOf(planTarget, feature.cap), lookupCap);
+		return compositionFeatureEnabled(feature) ? result : {
+			problems: result.problems,
+			fields: [],
+			features: [],
+			events: []
+		};
 	});
 	return {
 		problems: results.flatMap((r) => r.problems),
 		fields: results.flatMap((r) => r.fields),
-		features: results.flatMap((r) => r.features)
+		features: results.flatMap((r) => r.features),
+		events: results.flatMap((r) => r.events)
 	};
 }
 function compositionSourceRefs(composition) {
-	const refs = composition.features.flatMap((f) => f.kind === "fields" ? featureSources(f).flatMap(fieldReads).map((r) => r.source) : []);
+	const refs = composition.features.flatMap((f) => compositionFeatureEnabled(f) && f.kind === "fields" ? featureSources(f).flatMap(fieldReads).map((r) => r.source) : []);
 	return [...new Map(refs.map((r) => [compositionSourceKey(r), r])).values()];
 }
 /**
@@ -43577,7 +43858,8 @@ function validateComposition(composition, ctx) {
 		ok: problems.length === 0,
 		problems,
 		fields: [...plan.fields],
-		features: [...plan.features]
+		features: [...plan.features],
+		events: [...plan.events]
 	};
 }
 /**
@@ -57112,4 +57394,4 @@ function enumerateInferenceDevices(hw) {
 	return out;
 }
 //#endregion
-export { compositionFieldKey as $, expandCapMethods as $n, parseStreamParamsFormPatch as $t, RecordingStatusSchema as A, composedDeviceRef as An, isCollectionArrayMethod as At, addonPagesCapability as B, BaseAddon as Bn, localNetworkCapability as Bt, LocationIconIdSchema as C, validateComposition as Cn, expandContainer as Ct, RECORDING_SOURCE_CAMSTACK_ADDON as D, withLocationMode as Dn, formatMinutes as Dt, MOTION_CLOSE_AFTER_MS as E, vectorStoreCapability as En, foldSnapshotByFunction as Et, StorageCleanupJobSchema as F, toExpressionValue as Fn, isVoidInput as Ft, backupCapability as G, ReadinessTimeoutError as Gn, mayReadLocation as Gt, addonWidgetsCapability as H, DEVICE_SETTINGS_CONTRIBUTION_METHODS as Hn, logDestinationCapability as Ht, StorageLocationModeSchema as I, DeviceFeature as In, kebabToCamel as It, buildCapabilityLookup as J, asNumber as Jn, modeMayWrite as Jt, bareAddonId as K, WELL_KNOWN_TAB_MAP as Kn, mayWriteToLocation as Kt, StorageLocationTypeSchema as L, DeviceRole as Ln, legacyAutoLinkIds as Lt, STORAGE_ACCESS_FALLBACK as M, compositionItemFieldPath as Mn, isObjectInput as Mt, STREAM_PROFILE_META as N, compositionSliceKey as Nn, isSameAddonId as Nt, REDACTED_SECRET as O, COMPOSER_ADDON_ID as On, gbToBytes as Ot, ScopedTokenSchema as P, compositionSourceKey as Pn, isSourceCap as Pt, composerCapability as Q, emitReadiness as Qn, objectInputDeclaresRequiredDeviceId as Qt, StorageMigrationJobSchema as R, DeviceType as Rn, legacyModeOf as Rt, LegacyStorageLocationDefaultSchema as S, userManagementCapability as Sn, evictionPolicyOfLocation as St, MINUTES_PER_DAY as T, vectorIndexDimConflictError as Tn, filesystemBrowseCapability as Tt, alertsCapability as U, DEVICE_STATUS_METHOD as Un, logLevelAtMost as Ut, addonSettingsCapability as V, DATAPLANE_SECRET_HEADER as Vn, locationIconKey as Vt, authProviderCapability as W, ReadinessRegistry as Wn, looseSchema as Wt, cameraGridLayoutCapability as X, createEvent as Xn, normalizeUnit as Xt, buildStreamParamsConfigSchema as Y, asString$1 as Yn, motionCapability as Yt, collectSecretConfigKeys as Z, emitDownForOwnedCaps as Zn, objectInputDeclaresAddonId as Zt, DeviceStatusSchema as _, storageMigrationCapability as _n, enumerateInferenceDevices as _t, BatteryStatusSchema as a, replacedFieldKeys as an, parseJsonUnknown as ar, coreBlocksCapability as at, FieldClaimSchema as b, streamCatalogCapability as bn, evaluateCompositionField as bt, COMPOSED_ITEM_FIXED_FIELDS as c, resolveMethodAuth as cn, scopeKey as cr, declarationOwnerNodeId as ct, CORE_BLOCK_ADDON_PREFIX as d, scopesAllowDeviceCap as dn, deriveBatteryPresence as dt, planComposition as en, hydrateSchema as er, compositionSourceRefs as et, CoreBlockSchema as f, scoreRuntimes as fn, deviceExtensionCapability as ft, DeclaredDevices as g, storageCapability as gn, doorbellCapability as gt, DERIVED_CAMERA_SILENCED_CAP_NAMES as h, snapshotCapability as hn, deviceStatusCapability as ht, BaseDevice as i, reducePoints as in, parseJsonObject as ir, coreBlockSourceKind as it, SOURCE_CAPS as j, composedDeviceStableId as jn, isLocationEnabled as jt, RUNTIME_DEFAULTS as k, buildFfmpegArgs as kn, isArrayOutputSchema as kt, COMPOSER_RUNNER_ID as l, runtimeStatePolicyFor as ln, sleep as lr, decodeVectorBase64 as lt, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as m, siteZoneKey as mn, deviceStateCapability as mt, AlertSchema as n, procedureAuthKey as nn, isEvent as nr, coreBlockComposition as nt, CAMERA_SWITCH_ORDER as o, resolveBucketMs as on, readinessKey as or, createDeviceExtensionProvider as ot, DAY_NAMES as p, settingsStoreCapability as pn, deviceManagerCapability as pt, batteryCapability as q, asJsonObject as qn, metricsProviderCapability as qt, ApiKeyRecordSchema as r, ptzAutotrackCapability as rn, nodePin as rr, coreBlockIdFromAddonId as rt, CAP_NAMES_WITH_STATUS as s, resolveLocationMode as sn, resolveCapMount as sr, dataStoreProviderCapability as st, ALL_CAPABILITY_DEFINITIONS as t, platformProbeCapability as tn, isDeviceConfigCap as tr, coreBlockAddonId as tt, CORE_BLOCKS_ADDON_ID as u, scopesAllowAddon as un, EventCategory as ur, defineExtensionSlotProvider as ut, FIRST_LEVEL_MACRO_CLASSES as v, storageOccupancyCapability as vn, enumerateItemArrayFields as vt, METHOD_ACCESS_MAP as w, vectorDimFromBase64 as wn, extractNestedAddonId as wt, LOG_LEVEL_RANK as x, streamQualityLabel as xn, evaluateSensorEdge as xt, FieldClaimModeSchema as y, storageProviderCapability as yn, enumerateSchemaFields as yt, UserRecordSchema as z, errMsg as zn, lifecycleJobSchema as zt };
+export { coreBlockAddonId as $, asNumber as $n, ptzAutotrackCapability as $t, STORAGE_ACCESS_FALLBACK as A, cloneStatefulExpressionMemory as An, isSameAddonId as At, addonWidgetsCapability as B, toExpressionValue as Bn, looseSchema as Bt, METHOD_ACCESS_MAP as C, withLocationMode as Cn, foldSnapshotByFunction as Ct, REDACTED_SECRET as D, SOURCE_CAP_ACTIVE_FIELD as Dn, isCollectionArrayMethod as Dt, RECORDING_SOURCE_CAMSTACK_ADDON as E, SOURCE_CAPS as En, isArrayOutputSchema as Et, StorageLocationTypeSchema as F, compositionSliceKey as Fn, lifecycleJobSchema as Ft, batteryCapability as G, BaseAddon as Gn, motionCapability as Gt, authProviderCapability as H, DeviceRole as Hn, mayWriteToLocation as Ht, StorageMigrationJobSchema as I, compositionSourceKey as In, localNetworkCapability as It, cameraGridLayoutCapability as J, DEVICE_STATUS_METHOD as Jn, objectInputDeclaresRequiredDeviceId as Jt, buildCapabilityLookup as K, DATAPLANE_SECRET_HEADER as Kn, normalizeUnit as Kt, UserRecordSchema as L, createStatefulExpressionMemory as Ln, locationIconKey as Lt, ScopedTokenSchema as M, composedDeviceStableId as Mn, kebabToCamel as Mt, StorageCleanupJobSchema as N, compositionFeatureEnabled as Nn, legacyAutoLinkIds as Nt, RUNTIME_DEFAULTS as O, SOURCE_CAP_CHANGED_AT_FIELD as On, isLocationEnabled as Ot, StorageLocationModeSchema as P, compositionItemFieldPath as Pn, legacyModeOf as Pt, compositionSourceRefs as Q, asJsonObject as Qn, procedureAuthKey as Qt, addonPagesCapability as R, evaluateSensorEdge as Rn, logDestinationCapability as Rt, LocationIconIdSchema as S, vectorStoreCapability as Sn, filesystemBrowseCapability as St, MOTION_CLOSE_AFTER_MS as T, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as Tn, gbToBytes as Tt, backupCapability as U, DeviceType as Un, metricsProviderCapability as Ut, alertsCapability as V, DeviceFeature as Vn, mayReadLocation as Vt, bareAddonId as W, errMsg as Wn, modeMayWrite as Wt, composerCapability as X, ReadinessTimeoutError as Xn, planComposition as Xt, collectSecretConfigKeys as Y, ReadinessRegistry as Yn, parseStreamParamsFormPatch as Yt, compositionFieldKey as Z, WELL_KNOWN_TAB_MAP as Zn, platformProbeCapability as Zt, FIRST_LEVEL_MACRO_CLASSES as _, streamQualityLabel as _n, enumerateSchemaFields as _t, BatteryStatusSchema as a, runtimeStatePolicyFor as an, hydrateSchema as ar, dataStoreProviderCapability as at, LOG_LEVEL_RANK as b, vectorDimFromBase64 as bn, expandContainer as bt, COMPOSED_ITEM_FIXED_FIELDS as c, scoreRuntimes as cn, nodePin as cr, defineExtensionSlotProvider as ct, CORE_BLOCK_ADDON_PREFIX as d, snapshotCapability as dn, readinessKey as dr, deviceManagerCapability as dt, reducePoints as en, asString$1 as er, coreBlockComposition as et, CoreBlockSchema as f, storageCapability as fn, resolveCapMount as fr, deviceStateCapability as ft, DeviceStatusSchema as g, streamCatalogCapability as gn, enumerateItemArrayFields as gt, DeclaredDevices as h, storageProviderCapability as hn, EventCategory as hr, enumerateInferenceDevices as ht, BaseDevice as i, resolveMethodAuth as in, expandCapMethods as ir, createDeviceExtensionProvider as it, STREAM_PROFILE_META as j, composedDeviceRef as jn, isVoidInput as jt, RecordingStatusSchema as k, buildFfmpegArgs as kn, isObjectInput as kt, COMPOSER_RUNNER_ID as l, settingsStoreCapability as ln, parseJsonObject as lr, deriveBatteryPresence as lt, DERIVED_CAMERA_SILENCED_CAP_NAMES as m, storageOccupancyCapability as mn, sleep as mr, doorbellCapability as mt, AlertSchema as n, resolveBucketMs as nn, emitDownForOwnedCaps as nr, coreBlockSourceKind as nt, CAMERA_SWITCH_ORDER as o, scopesAllowAddon as on, isDeviceConfigCap as or, declarationOwnerNodeId as ot, DAY_NAMES as p, storageMigrationCapability as pn, scopeKey as pr, deviceStatusCapability as pt, buildStreamParamsConfigSchema as q, DEVICE_SETTINGS_CONTRIBUTION_METHODS as qn, objectInputDeclaresAddonId as qt, ApiKeyRecordSchema as r, resolveLocationMode as rn, emitReadiness as rr, coreBlocksCapability as rt, CAP_NAMES_WITH_STATUS as s, scopesAllowDeviceCap as sn, isEvent as sr, decodeVectorBase64 as st, ALL_CAPABILITY_DEFINITIONS as t, replacedFieldKeys as tn, createEvent as tr, coreBlockIdFromAddonId as tt, CORE_BLOCKS_ADDON_ID as u, siteZoneKey as un, parseJsonUnknown as ur, deviceExtensionCapability as ut, FieldClaimModeSchema as v, userManagementCapability as vn, evaluateCompositionField as vt, MINUTES_PER_DAY as w, COMPOSER_ADDON_ID as wn, formatMinutes as wt, LegacyStorageLocationDefaultSchema as x, vectorIndexDimConflictError as xn, extractNestedAddonId as xt, FieldClaimSchema as y, validateComposition as yn, evictionPolicyOfLocation as yt, addonSettingsCapability as z, isSourceCap as zn, logLevelAtMost as zt };