@camstack/system 1.2.329 → 1.2.331

package/dist/{dist-CSs0cFDN.js → dist-DRUzy1SF.js}

@@ -1,6 +1,6 @@
 let zod = require("zod");
 require("node:crypto");
-//#region ../types/dist/event-category-C5xZWqz6.mjs
+//#region ../types/dist/event-category-BGmz_oxW.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -533,6 +533,15 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	*/
 	EventCategory["PipelineAudioInferenceResult"] = "pipeline.audio-inference-result";
 	EventCategory["DetectionPhaseTransition"] = "detection.phase-transition";
+	/**
+	* A camera provider's RAW onboard motion push (D673): the `MotionOnMotionChanged`
+	* data shape without `triggeredBy`, built by `providerMotionEvent`. Its one
+	* consumer is the orchestrator's camera-sensors bridge, which re-emits the
+	* camera's EFFECTIVE onboard motion as `MotionOnMotionChanged` (a pass-through
+	* for a camera with no attached sensor). Providers must not emit
+	* `MotionOnMotionChanged` themselves; `scripts/check-onboard-motion-emitters.ts`
+	* keeps it so (camera-grid is a named, deferred exception).
+	*/
 	EventCategory["ProviderMotion"] = "provider.motion";
 	EventCategory["ProviderDetection"] = "provider.detection";
 	EventCategory["EnrichmentEmbeddingStored"] = "enrichment.embedding.stored";
@@ -701,7 +710,7 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	return EventCategory;
 }({});
 //#endregion
-//#region ../types/dist/sleep-gU6hqv4_.mjs
+//#region ../types/dist/sleep-CDCONfkt.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -3512,7 +3521,7 @@ function errMsg(err) {
 	return String(err);
 }
 //#endregion
-//#region ../types/dist/composition-Dq42XWp0.mjs
+//#region ../types/dist/composition-43aqsZQj.mjs
 var AUDIO_ENCODER_BY_CODEC = {
 	opus: "libopus",
 	aac: "aac",
@@ -3961,13 +3970,12 @@ portable("linux64"), portable("linuxarm64"), portable("macarm64"), portable("mac
 * 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.
+* UNA tabella per tutti quelli che chiedono "questo device è ALTO?": il
+* trigger `RecordingTriggers.sensorDeviceIds` del recorder, i marker dei
+* sensori della post-analysis, il bridge camera-sensors dell'orchestratore e
+* le sorgenti di un campanello composto (`doorbellFeatureSources`, D671).
+* Una seconda copia divergerebbe alla prima cap aggiunta, e il sintomo — "il
+* sensore fa suonare il campanello ma non registra" — è esattamente D62.
 *
 * ⚠ 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
@@ -3994,53 +4002,6 @@ var SOURCE_CAP_ACTIVE_FIELD = {
 	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.
@@ -4066,65 +4027,6 @@ function evaluateSensorLevelEdge(input) {
 	};
 }
 /**
-* 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".
@@ -6370,7 +6272,7 @@ var RecordingTriggersSchema = zod.z.object({
 	*
 	* Cosa vuol dire "alto" dipende dal TIPO di device e non è deciso qui:
 	* `SOURCE_CAP_ACTIVE_FIELD` (`catalogs/sensor-active-state.ts`) è LA tabella,
-	* la stessa che il virtual-doorbell usa dal 2026-08-05. Ed è il FRONTE, non
+	* la stessa del campanello composto (D671). Ed è il FRONTE, non
 	* il livello: un contatto trovato già aperto al riavvio del runner non fa
 	* registrare.
 	*/
@@ -16056,8 +15958,8 @@ var deviceManagerCapability = {
 		* (`value` / `missing` / `failed`, see {@link WrapperActivationReadSchema}).
 		*
 		* The narrow read of the durable authority behind `getBindings`: a
-		* consumer that must know what the operator PERSISTED (virtual-doorbell,
-		* before it drops a press) asks this instead of pulling device-manager's
+		* consumer that must know what the operator PERSISTED (before it drops
+		* work on the strength of an unbind) asks this instead of pulling device-manager's
 		* whole addon store through `addonSettingsRaw.getGlobal` — which answered
 		* `{}` on every isolated-engine hub and so never worked (D675). It reads
 		* ONE row (the activation map, ~1.6 KB), never the ~625 KB store.
@@ -16347,120 +16249,14 @@ var deviceManagerCapability = {
 		}), zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.unknown().nullable())))
 	}
 };
-/**
-* Doorbell button cap. Two kinds of providers coexist behind this cap
-* name (same pattern as `snapshot`):
-*
-*   - **Native** providers: registered per-device by device-driver
-*     addons via `ctx.registerNativeCap` — either on a
-*     `DeviceType.Button` accessory with `role: DeviceRole.Doorbell`,
-*     or directly on the camera (Reolink registers at camera level).
-*     Emits an `onPressed` event every time the firmware pushes a
-*     ring; status tracks the last press and a pressCount since start
-*     (diagnostic).
-*
-*   - **Wrapper** provider: the `virtual-doorbell` system builtin
-*     (`@camstack/system/builtins/doorbell`). Turns ANY binary-ish
-*     device (contact / switch / event-emitter …) into a doorbell for
-*     a camera. `defaultActive: false` — the operator explicitly binds
-*     it per camera in the device-bindings UI, then picks the source
-*     device + trigger in the per-device settings.
-*
-* The DeviceEventPropagator re-emits `onPressed` on the camera parent
-* — subscribers listening at the camera level receive ring events
-* with `via[]` populated. No code on the parent needed.
-*/
-var DoorbellStatusSchema = zod.z.object({
-	/** Ms epoch of the last press. null = never observed since this provider started. */
-	lastPressedAt: zod.z.number().nullable(),
-	/** Counter since provider start. Resets on reboot. Useful for metrics/debug. */
-	pressCountSinceStart: zod.z.number()
-});
-var DoorbellPressEventSchema = zod.z.object({
-	deviceId: zod.z.number(),
-	timestamp: zod.z.number()
-});
-/**
-* The `doorbell-source` extension slot's editable value (D648): the camera's
-* virtual-doorbell trigger devices, exactly what the wrapper's
-* `doorbellSources` persists (as `{ deviceId }` records).
-*/
-var DoorbellSourceSlotValueSchema = zod.z.object({ deviceIds: zod.z.array(zod.z.number().int().positive()) });
-/**
-* The `doorbell-source` slot — which devices ring this camera's VIRTUAL
-* doorbell, owned by the `virtual-doorbell` wrapper over its
-* `doorbellSources` store (D648). A source rings when one of its
-* `SOURCE_CAPS` rises. Whether the wrapper is bound to the camera at all is a
-* different authority (`deviceManager.setWrapperActive`, D62) — the slot
-* reports it, it never writes it.
-*/
-var DOORBELL_SOURCE_SLOT = {
-	id: "doorbell-source",
-	label: "Doorbell trigger devices",
-	description: "Any of these becoming active rings this camera's virtual doorbell: a binary sensor when it goes active, a switch when it turns on.",
-	shape: "association",
-	hostDeviceTypes: [DeviceType.Camera],
-	sourceCaps: SOURCE_CAPS,
-	cardinality: "many",
-	value: DoorbellSourceSlotValueSchema
-};
-var doorbellCapability = {
-	name: "doorbell",
-	scope: "device",
-	deviceNative: true,
-	mode: "singleton",
-	kind: "wrapper",
-	defaultActive: false,
-	deviceTypes: [DeviceType.Button, DeviceType.Camera],
-	extensionSlots: [DOORBELL_SOURCE_SLOT],
-	methods: {},
-	events: { 
-	/**
-	* Fires once per physical press. Reolink delivers via Baichuan
-	* push (`ReolinkSimpleEvent.type === 'doorbell'`). There is no
-	* release/duration — it's a pulse.
-	*/
-onPressed: {
-		data: DoorbellPressEventSchema,
-		fromState: {
-			field: "lastPressedAt",
-			on: "advance"
-		}
-	} },
-	status: {
-		schema: DoorbellStatusSchema,
-		kind: "push"
-	},
-	/**
-	* Runtime-state slice — last press timestamp + lifetime press count.
-	* Mirrored by the kernel and readable via
-	* `device.state.doorbell.value`. UIs can show "last ring 5m ago"
-	* without subscribing.
-	*/
-	runtimeState: DoorbellStatusSchema,
-	/**
-	* Runtime-state durability: **restored** — a monotonic accumulator: the slice IS the record. `lastPressedAt` is content here, not a clock, so it is deliberately NOT volatile.
-	*
-	* See `RuntimeStateDurability`. Enforced by
-	* `scripts/check-runtime-state-durability.ts`.
-	*/
-	durability: "restored"
-};
-var ExtensionSlotIdSchema = zod.z.enum(["doorbell-source", "linked-devices"]);
-var EXTENSION_SLOTS = {
-	"doorbell-source": {
-		descriptor: DOORBELL_SOURCE_SLOT,
-		declaringCap: "doorbell",
-		hostDeviceTypes: [DeviceType.Camera]
-	},
-	"linked-devices": {
-		descriptor: LINKED_DEVICES_SLOT,
-		declaringCap: "device-manager",
-		hostDeviceTypes: [DeviceType.Camera]
-	}
-};
+var ExtensionSlotIdSchema = zod.z.enum(["linked-devices"]);
+var EXTENSION_SLOTS = { "linked-devices": {
+	descriptor: LINKED_DEVICES_SLOT,
+	declaringCap: "device-manager",
+	hostDeviceTypes: [DeviceType.Camera]
+} };
 /** A slot's editable value, discriminated on `slot`. */
-var ExtensionSlotValueSchema = zod.z.discriminatedUnion("slot", [DoorbellSourceSlotValueSchema.extend({ slot: zod.z.literal("doorbell-source") }), LinkedDevicesSlotValueSchema.extend({ slot: zod.z.literal("linked-devices") })]);
+var ExtensionSlotValueSchema = zod.z.discriminatedUnion("slot", [LinkedDevicesSlotValueSchema.extend({ slot: zod.z.literal("linked-devices") })]);
 /** Every device type at least one slot is offered on — `device-extension`'s `deviceTypes`. */
 var EXTENSION_HOST_DEVICE_TYPES = [DeviceType.Camera];
 var ExtensionSourceAvailabilitySchema = zod.z.discriminatedUnion("state", [zod.z.object({ state: zod.z.literal("ok") }), zod.z.object({
@@ -16498,10 +16294,11 @@ var ExtensionSlotSourceSchema = zod.z.object({
 });
 /**
 * A DIFFERENT authority that gates whether the slot's sources do anything —
-* reported read-only, named, never written through this contract (D62). The
-* virtual doorbell's sources ring only while the wrapper is bound to the
-* camera, and that binding belongs to `deviceManager.setWrapperActive`.
-* `unknown` means the gate could not be read; it is not "inactive" (D315).
+* reported read-only, named, never written through this contract (D62) — e.g.
+* a slot whose sources act only while a wrapper is bound to the host, a
+* binding that belongs to `deviceManager.setWrapperActive`. No slot reports
+* one today (`linked-devices` answers `null`). `unknown` means the gate could
+* not be read; it is not "inactive" (D315).
 */
 var ExtensionSlotActivationSchema = zod.z.object({
 	state: zod.z.enum([
@@ -16518,7 +16315,7 @@ var ExtensionSlotStateSchema = zod.z.object({
 	/** `<source>:<slotId>` — the routing key for `listCandidates` / `setSlot`. */
 	slotRef: zod.z.string(),
 	slot: ExtensionSlotIdSchema,
-	/** Names the store written (D62), e.g. `virtual-doorbell:doorbellSources`. */
+	/** Names the store written (D62), e.g. `device-manager:_linkedDeviceIds`. */
 	authority: zod.z.string(),
 	activation: ExtensionSlotActivationSchema.nullable(),
 	value: ExtensionSlotValueSchema,
@@ -16712,8 +16509,8 @@ var deviceStateCapability = {
 		* Canonical cross-layer WRITE for one cap-keyed slice. Used by
 		* everyone who needs to publish runtime state for a device:
 		* device providers (via `BaseDevice.runtimeState.setCapState`
-		* which delegates here), system-scope addons (e.g. the pipeline
-		* runner writing the `motion` slice on phase transitions), and
+		* which delegates here), system-scope addons (e.g. the orchestrator
+		* writing a camera's effective `motion` slice, D696), and
 		* direct cap-router callers in tests.
 		*
 		* Behavior on the hub:
@@ -20128,17 +19925,25 @@ var NcScheduleSchema = zod.z.object({
 */
 var NcSystemEventDeliveryModeSchema = zod.z.enum(["instant", "summary"]);
 /**
+* How a summary window is SENT (D698): `rule` (absent) = ONE notification with
+* every section; `section` = one notification per section with something to
+* say (an unavailable section included), each titled by its section.
+*/
+var NcStateSummarySplitSchema = zod.z.enum(["rule", "section"]);
+/**
 * `summary`: the rule sends NOTHING per event. When a window of `schedule`
 * CLOSES, it sends one notification with the current state of its kinds
 * (low batteries, consumables to replace, devices offline, updates
-* available, ...), after its own filters. Nothing to report sends nothing.
+* available, ...), after its own filters — or, with `split: 'section'`
+* (D698), one notification per section. Nothing to report sends nothing.
 * The schedule is the ordinary `NcSchedule` (weekly windows, IANA timezone,
 * midnight crossing); the send time is each window's END. Refused on the
 * `alarm` family, which stays instant (`systemEventDeliveryProblems`).
 */
 var NcSystemEventDeliverySchema = zod.z.discriminatedUnion("mode", [zod.z.object({ mode: zod.z.literal("instant") }), zod.z.object({
 	mode: zod.z.literal("summary"),
-	schedule: NcScheduleSchema
+	schedule: NcScheduleSchema,
+	split: NcStateSummarySplitSchema.optional()
 })]);
 /** Fuzzy plate matcher — OCR noise makes exact match useless (spec row 12/13). */
 var NcPlateMatcherSchema = zod.z.object({
@@ -21137,11 +20942,23 @@ var NcStateSummaryPreviewSectionSchema = zod.z.object({
 	reason: zod.z.string().optional()
 });
 /**
+* One notification a previewed summary would send (D698): the whole summary on
+* a `rule` split (no `section`), one section's on a `section` split.
+*/
+var NcStateSummaryPreviewRowSchema = zod.z.object({
+	section: zod.z.string().optional(),
+	/** The section's name on a per-section row; every reported section's, joined, on a combined one. */
+	title: zod.z.string(),
+	text: zod.z.string(),
+	count: zod.z.number().int().nonnegative()
+});
+/**
 * The summary a rule would send now. `empty` = nothing to report and every
 * section read: such a summary is NOT sent. `dropped` counts the open states
 * the rule's own filters (or a camera mute) left out, by reason.
 * `excludedGroups` names the kind groups selected that have no state to report
-* (backups & exports).
+* (backups & exports). `split` and `rows` (D698) say how it would be sent —
+* optional, so an older hub's answer still parses.
 */
 var NcStateSummaryPreviewSchema = zod.z.object({
 	empty: zod.z.boolean(),
@@ -21149,7 +20966,9 @@ var NcStateSummaryPreviewSchema = zod.z.object({
 	text: zod.z.string(),
 	sections: zod.z.array(NcStateSummaryPreviewSectionSchema),
 	dropped: zod.z.record(zod.z.string(), zod.z.number().int().nonnegative()),
-	excludedGroups: zod.z.array(zod.z.string())
+	excludedGroups: zod.z.array(zod.z.string()),
+	split: NcStateSummarySplitSchema.optional(),
+	rows: zod.z.array(NcStateSummaryPreviewRowSchema).optional()
 });
 var NcTestResultSchema = zod.z.object({
 	recordId: zod.z.string(),
@@ -22360,12 +22179,27 @@ var CameraSensorRefSchema = zod.z.object({
 function cameraSensorRefKey(ref) {
 	return `${ref.addonId}/${ref.stableId}`;
 }
-/** CS-1 accepts exactly one mode; CS-2 (D673) widens it to confirm / replace. */
-var CameraSensorsModeSchema = zod.z.enum(["in-addition"]);
-var CameraSensorsConfigSchema = zod.z.object({
-	mode: CameraSensorsModeSchema,
-	sensors: zod.z.array(CameraSensorRefSchema).min(1).max(8)
-}).superRefine((value, ctx) => {
+/**
+* A sensor's mode (D673). `in-addition`: its motion is the camera's motion too.
+* `replace`: its motion is the camera's, and while one is READY the camera's
+* own motion no longer counts on its own. `confirm`: while one is READY the
+* camera's own motion counts only while a confirm sensor is active — with or
+* without a replace sensor (spec C2, the controller's ruling on Q1).
+*/
+var CameraSensorModeSchema = zod.z.enum([
+	"in-addition",
+	"confirm",
+	"replace"
+]);
+/** A stored sensor with no mode — every CS-1 row — is in addition. */
+var DEFAULT_CAMERA_SENSOR_MODE = "in-addition";
+var CameraSensorEntrySchema = CameraSensorRefSchema.extend({ mode: CameraSensorModeSchema.default(DEFAULT_CAMERA_SENSOR_MODE) });
+/**
+* A camera's attached sensors. A CS-1 row carried an envelope
+* `mode: 'in-addition'`: `z.object` drops it on parse, and the PARSED value is
+* what the write stores (D672 rule 3), so it is never written again.
+*/
+var CameraSensorsConfigSchema = zod.z.object({ sensors: zod.z.array(CameraSensorEntrySchema).min(1).max(8) }).superRefine((value, ctx) => {
 	const seen = /* @__PURE__ */ new Set();
 	value.sensors.forEach((ref, index) => {
 		const key = cameraSensorRefKey(ref);
@@ -22377,39 +22211,41 @@ var CameraSensorsConfigSchema = zod.z.object({
 		seen.add(key);
 	});
 });
-var RefFields = {
+/** Every attachment names its mode; an older orchestrator that does not is in addition. */
+var AttachmentFields = {
 	addonId: zod.z.string(),
-	stableId: zod.z.string()
+	stableId: zod.z.string(),
+	mode: CameraSensorModeSchema.default(DEFAULT_CAMERA_SENSOR_MODE)
 };
 var CameraSensorAttachmentSchema = zod.z.discriminatedUnion("state", [
 	zod.z.object({
-		...RefFields,
+		...AttachmentFields,
 		state: zod.z.literal("ready"),
 		deviceId: zod.z.number(),
 		name: zod.z.string(),
 		caps: zod.z.array(zod.z.string()).readonly()
 	}),
 	zod.z.object({
-		...RefFields,
+		...AttachmentFields,
 		state: zod.z.literal("offline"),
 		deviceId: zod.z.number(),
 		name: zod.z.string(),
 		reason: zod.z.enum(["offline", "disabled"])
 	}),
 	zod.z.object({
-		...RefFields,
+		...AttachmentFields,
 		state: zod.z.literal("missing"),
 		reason: zod.z.string()
 	}),
 	zod.z.object({
-		...RefFields,
+		...AttachmentFields,
 		state: zod.z.literal("unsupported"),
 		deviceId: zod.z.number(),
 		name: zod.z.string(),
 		reason: zod.z.string()
 	}),
 	zod.z.object({
-		...RefFields,
+		...AttachmentFields,
 		state: zod.z.literal("unreadable"),
 		reason: zod.z.string()
 	})
@@ -22422,17 +22258,49 @@ var CameraSensorAttachmentSchema = zod.z.discriminatedUnion("state", [
 * say.
 */
 var CameraSensorsNotForwardedSchema = zod.z.enum(["onboard-not-listed", "no-active-detection"]);
+/** Whether the camera's OWN motion counts on its own (D673 C2), from its READY sensors (C3). */
+var CameraOwnMotionSchema = zod.z.enum([
+	"always",
+	"when-confirmed",
+	"never"
+]);
+/** Confirm / Replace cannot suppress this camera's motion: its provider still emits it directly (D673 C13). */
+var CameraSensorsNotEnforcedSchema = zod.z.enum(["provider-not-split"]);
+/**
+* The camera's OWN onboard motion (D696): the raw input the bridge combines,
+* never the effective value. The camera's `motion` slice is the effective one,
+* so a view of the camera's own row reads this.
+* - `atMs`: when the bridge received the camera's last own edge.
+* - `detected`: evaluated WHEN THE STATUS IS ASKED — the last edge said `true`
+*   AND it is younger than the window the bridge counts the camera's own motion
+*   for (`motionCooldownMs`, floored at two sustain ticks). A camera that never
+*   sends a clear (heartbeats only) therefore reads `false` once no push came
+*   within the window; a status read is a snapshot, so a live view re-asks.
+* Absent = this orchestrator has not received the camera's own motion since it
+* started (unknown, never "quiet"), or an orchestrator older than D696.
+*/
+var CameraRawLevelSchema = zod.z.object({
+	detected: zod.z.boolean(),
+	atMs: zod.z.number()
+});
 var CameraSensorsStatusSchema = zod.z.discriminatedUnion("state", [
-	zod.z.object({ state: zod.z.literal("not-configured") }),
+	zod.z.object({
+		state: zod.z.literal("not-configured"),
+		cameraLevel: CameraRawLevelSchema.optional()
+	}),
 	zod.z.object({
 		state: zod.z.literal("unreadable"),
-		reason: zod.z.string()
+		reason: zod.z.string(),
+		cameraLevel: CameraRawLevelSchema.optional()
 	}),
 	zod.z.object({
 		state: zod.z.literal("configured"),
-		mode: CameraSensorsModeSchema,
+		cameraLevel: CameraRawLevelSchema.optional(),
 		sensors: zod.z.array(CameraSensorAttachmentSchema).readonly(),
-		notForwarded: CameraSensorsNotForwardedSchema.optional()
+		/** Absent = an orchestrator older than CS-2: it does not say (D315). */
+		cameraMotion: CameraOwnMotionSchema.optional(),
+		notForwarded: CameraSensorsNotForwardedSchema.optional(),
+		notEnforced: CameraSensorsNotEnforcedSchema.optional()
 	})
 ]);
 Object.freeze({
@@ -26528,8 +26396,10 @@ var RunnerCameraConfigSchema = zod.z.object({
 	* - `analyzer`: ML/frame-diff motion detection (motion-wasm or other
 	*   analyzer providers) running on decoded frames in this runner.
 	* - `onboard`: camera-native motion pushes (Reolink Baichuan, ONVIF
-	*   analytics). The provider emits ProviderMotion
-	*   events; the orchestrator forwards to `reportMotion`.
+	*   analytics). The provider emits its raw push as `ProviderMotion`
+	*   (D673); the orchestrator's camera-sensors bridge re-emits the camera's
+	*   effective motion as `MotionOnMotionChanged`, which is what reaches
+	*   `reportMotion`.
 	*/
 	motionSources: MotionSourcesSchema.default(["analyzer"]),
 	/**
@@ -26706,7 +26576,15 @@ var RunnerLocalLoadSchema = zod.z.object({
 		hasGpu: zod.z.boolean(),
 		inferenceBackend: zod.z.string().optional(),
 		cpuCores: zod.z.number().optional()
-	})
+	}),
+	/**
+	* Who writes a camera's `motion` runtime slice (D696). `'orchestrator'`: this
+	* runner never writes it. ABSENT = a runner older than D696, which still
+	* writes the slice from its phase machine; the orchestrator does not write
+	* while any runner node is absent-or-unanswered, so one slice never has two
+	* writers.
+	*/
+	motionSliceWriter: zod.z.literal("orchestrator").optional()
 });
 /**
 * Aggregate runtime metrics for the runner's whole local pool. Mirrors the
@@ -34030,6 +33908,70 @@ onStatusChanged: { data: zod.z.object({
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastChangedAt"]
 };
+var DoorbellStatusSchema = zod.z.object({
+	/** Ms epoch of the last press. null = never observed since this provider started. */
+	lastPressedAt: zod.z.number().nullable(),
+	/** Counter since provider start. Resets on reboot. Useful for metrics/debug. */
+	pressCountSinceStart: zod.z.number()
+});
+var DoorbellPressEventSchema = zod.z.object({
+	deviceId: zod.z.number(),
+	timestamp: zod.z.number()
+});
+/**
+* Doorbell button cap. Two kinds of provider serve it, and to every consumer
+* they are the same cap:
+*
+*   - **Native** providers, registered per device by a driver addon through
+*     `ctx.registerNativeCap` — a `DeviceType.Button` accessory with
+*     `role: DeviceRole.Doorbell`, or the camera itself (Reolink registers at
+*     camera level). They emit `onPressed` on every firmware ring.
+*   - **A composed doorbell** (D670, D671): a camera's customization gives it
+*     the cap, its `lastPressedAt` rising from the sources the operator
+*     assigned in Customize → Doorbell, and the composer emits `onPressed`
+*     from that field's advance (`fromState`).
+*
+* The DeviceEventPropagator re-emits `onPressed` on the camera parent.
+*/
+var doorbellCapability = {
+	name: "doorbell",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [DeviceType.Button, DeviceType.Camera],
+	methods: {},
+	events: { 
+	/**
+	* Fires once per physical press. Reolink delivers via Baichuan
+	* push (`ReolinkSimpleEvent.type === 'doorbell'`). There is no
+	* release/duration — it's a pulse.
+	*/
+onPressed: {
+		data: DoorbellPressEventSchema,
+		fromState: {
+			field: "lastPressedAt",
+			on: "advance"
+		}
+	} },
+	status: {
+		schema: DoorbellStatusSchema,
+		kind: "push"
+	},
+	/**
+	* Runtime-state slice — last press timestamp + lifetime press count.
+	* Mirrored by the kernel and readable via
+	* `device.state.doorbell.value`. UIs can show "last ring 5m ago"
+	* without subscribing.
+	*/
+	runtimeState: DoorbellStatusSchema,
+	/**
+	* Runtime-state durability: **restored** — a monotonic accumulator: the slice IS the record. `lastPressedAt` is content here, not a clock, so it is deliberately NOT volatile.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "restored"
+};
 /**
 * Enum-state sensor — a string value picked from a finite option set.
 * Drives HA `sensor` entries with `state_class: enum` (HVAC action
@@ -36440,11 +36382,11 @@ authKey: zod.z.string().optional() }), zod.z.object({
 /**
 * How long after a camera's last rising edge `pipeline-analytics` closes the
 * motion EPISODE row it kept open for it (D475) — "il delay della cap", in
-* the operator's words. One authority for the whole system: every provider
-* that seeds `autoClearAfterMs` on a `Camera` device writes this SAME
-* constant while `detected: true` (never its own number — Hikvision used to
-* seed its internal 3 s inactivity timer here, which is a different clock for
-* a different purpose), and `MotionEpisodeTracker` imports it directly rather
+* the operator's words. One authority for the whole system: the writer of a
+* `Camera` device's slice (the orchestrator, D696) writes this SAME constant
+* in `autoClearAfterMs` while `detected: true` (never a camera's own clock —
+* Hikvision used to seed its internal 3 s inactivity timer here, a different
+* clock for a different purpose), and `MotionEpisodeTracker` imports it directly rather
 * than reading the live cap value on the hot path. A `Sensor` device (HA
 * binary sensor, Homematic) gets a genuine push both ways and has no episode
 * to close on a timer, so it writes `null`, never this constant.
@@ -36455,9 +36397,9 @@ var MotionStatusSchema = zod.z.object({
 	/** Ms epoch of the last detected-true observation. Null if never detected. */
 	lastDetectedAt: zod.z.number().nullable(),
 	/**
-	* `MOTION_CLOSE_AFTER_MS` while `detected: true` on a `Camera` device,
-	* `null` while false and on every `Sensor` device (D475) — see that
-	* constant's doc for the one-authority rule.
+	* `MOTION_CLOSE_AFTER_MS` while `detected: true` on a `Camera` device (the
+	* orchestrator writes it, D696), `null` while false and on every `Sensor`
+	* device (D475) — see that constant's doc for the one-authority rule.
 	*
 	* ## Reading this field still arms nothing
 	*
@@ -36475,34 +36417,31 @@ var MotionStatusSchema = zod.z.object({
 	* `addon-export-alexa/src/motion-clear-hold.ts` and
 	* `addon-export-hap`'s `RESET_DEBOUNCE_MS` both do.
 	*
-	* ## Who writes it
-	*
-	* - **Cameras** — the runner's phase machine, `active → watching` on
-	*   `cooldown_expired`, which then writes this slice with
-	*   `detected: false` (`handlePhaseChanged` in
-	*   `pipeline-runner/index.ts`). It produces the FALLING edge, which
-	*   matters most for the sources that only ever push a rising one:
-	*   Reolink emits `MotionOnMotionChanged { detected: true }` and never
-	*   a false.
-	* - **Sensors** (Home Assistant binary sensors, Homematic) — the
-	*   provider pushes the false itself, from the upstream system's own
-	*   state change. No phase machine is involved.
-	*
-	* ### The phase machine is CANONICAL, not sole — and that is a defect
-	*
-	* An earlier revision of this docblock (mine, 2026-09-12) claimed the
-	* phase machine is the sole writer for a camera. It is not.
-	* `hikvision-camera.ts:3464` and `amcrest-camera.ts:445` both call
-	* `setCapSlice(motionCapability, …)` on their own rising edge, and
-	* Hikvision's comment says why: it read THIS docblock, agreed the
-	* runner is canonical, and wrote anyway to avoid per-tick churn. So
-	* two authorities can disagree about one slice, which this repo
-	* forbids, and the doc said otherwise — which is worse than saying
-	* nothing, because it reads as verification.
-	*
-	* This predates D475 and is not fixed there: the fix touches every
-	* camera provider. Recorded in D475's Consequences. Do not restore the
-	* "sole writer" wording without also removing the other writers.
+	* ## Who writes it (D696)
+	*
+	* - **Cameras** — the orchestrator, and nothing else. It writes the camera's
+	*   EFFECTIVE motion (`addon-pipeline-orchestrator`
+	*   `camera-sensors/motion-slice.ts`), alongside the effective
+	*   `MotionOnMotionChanged` it emits or receives: the camera-sensors bridge
+	*   for a split camera, an unsplit emitter's direct event, the analyzer and
+	*   device activity, as the camera's `motionSources` counts them. A source
+	*   that never sends a clear falls one window after its last `true`.
+	*   `lastDetectedAt` moves only on an effective rise. No camera provider
+	*   writes this slice (not even a boot seed), and neither does the runner's
+	*   phase machine: its phase is "a session is attached" for every on-motion
+	*   session, not motion, and it now has its own `DetectionPhaseTransition`.
+	*   A provider's `isDetected` answers from the hub's slice.
+	* - **Sensors** (Home Assistant binary sensors, Homematic, Matter, Alexa
+	*   imports) — the provider pushes both edges itself, from the upstream
+	*   system's own state change. That is the sensor's own fact.
+	*
+	* `scripts/check-onboard-motion-emitters.ts` refuses any other writer of a
+	* `motion` slice; each sensor writer is a named exemption.
+	*
+	* This replaces the D475 §4 rule ("the phase machine is the sole writer").
+	* That rule was never true: Hikvision and Amcrest wrote the slice raw beside
+	* it, every provider seeded it at boot, and every session left it
+	* `detected: true` after its detach.
 	*/
 	autoClearAfterMs: zod.z.number().nullable()
 });
@@ -36574,11 +36513,12 @@ onMotionChanged: { data: MotionOnMotionChangedDataSchema } },
 	*/
 	runtimeState: MotionStatusSchema,
 	/**
-	* Runtime-state durability: **session** — every writer of this slice
+	* Runtime-state durability: **session** — the writer of this slice
 	* writes only on an EDGE, so a restored `detected: true` would stay
 	* frozen until the next one instead of being corrected. The next edge
-	* re-publishes the real state. (On who the writers are, and why there
-	* is more than one, see `autoClearAfterMs` above.)
+	* re-publishes the real state, and the orchestrator re-publishes every
+	* camera when it starts writing (D696; on who writes it, see
+	* `autoClearAfterMs` above).
 	*
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
@@ -39294,8 +39234,7 @@ var ptzAutotrackCapability = {
 	deviceNative: true,
 	mode: "singleton",
 	/**
-	* Two kinds of provider behind one name, the same shape `snapshot` and
-	* `doorbell` use:
+	* Two kinds of provider behind one name, the same shape `snapshot` uses:
 	*
 	*  - **Native**: the camera's own firmware autotrack, registered per device by
 	*    the driver when the probe says it exists (Reolink: yes; Hikvision:
@@ -39303,7 +39242,7 @@ var ptzAutotrackCapability = {
 	*  - **Wrapper**: the emulated implementation (`@camstack/system`'s `autotrack` builtin),
 	*    which follows a subject with `ptz.move` pulses driven by the detection
 	*    pipeline. `defaultActive: false` — the operator binds it per camera in
-	*    the bindings UI, exactly as `virtual-doorbell` is bound.
+	*    the bindings UI.
 	*
 	* The binding chooses WHICH implementation answers; `setEnabled` stays the
 	* one switch for the function either way. A camera never has both driving its
@@ -44675,72 +44614,6 @@ function evaluateCompositionField(input) {
 	}
 }
 /**
-* The doorbell of a camera as a customization (D671). ONE builder: the
-* virtual-doorbell migration and the admin UI's "Use as doorbell" preset both
-* call it, so a preset can never write a shape the migration would refuse as
-* "an unrelated existing block".
-*/
-/** A rise closer than this to the previous one is the same press (D671). */
-var DOORBELL_RISE_DEBOUNCE_MS = 2e3;
-/** Every source cap of `source` that `SOURCE_CAP_ACTIVE_FIELD` knows AND the device has bound. */
-function doorbellFeatureSources(source, boundCaps) {
-	return Object.keys(SOURCE_CAP_ACTIVE_FIELD).filter((cap) => Object.hasOwn(SOURCE_CAP_CHANGED_AT_FIELD, cap) && boundCaps.includes(cap)).toSorted().flatMap((cap) => {
-		const activeField = SOURCE_CAP_ACTIVE_FIELD[cap];
-		const changedAtField = SOURCE_CAP_CHANGED_AT_FIELD[cap];
-		return activeField === void 0 || changedAtField === void 0 ? [] : [{
-			source,
-			cap,
-			activeField,
-			changedAtField
-		}];
-	});
-}
-/** The D671 feature, byte for byte what the migration writes. Throws on zero sources. */
-function buildDoorbellCompositionFeature(input) {
-	const sources = [...input.sources].toSorted((a, b) => `${a.source.addonId}/${a.source.stableId}#${a.cap}`.localeCompare(`${b.source.addonId}/${b.source.stableId}#${b.cap}`));
-	if (sources.length === 0) throw new Error("doorbell composition needs at least one source");
-	const edgeBindings = {};
-	sources.forEach((entry, index) => {
-		edgeBindings[`active${index}`] = {
-			kind: "from",
-			source: entry.source,
-			cap: entry.cap,
-			fieldPath: entry.activeField
-		};
-		edgeBindings[`changed${index}`] = {
-			kind: "from",
-			source: entry.source,
-			cap: entry.cap,
-			fieldPath: entry.changedAtField
-		};
-	});
-	return {
-		kind: "fields",
-		cap: "doorbell",
-		enabled: input.enabled,
-		fields: {
-			lastPressedAt: {
-				kind: "expression",
-				expr: `latest(${sources.map((_, index) => `rose(active${index}, changed${index}, ${DOORBELL_RISE_DEBOUNCE_MS})`).join(", ")})`,
-				bindings: edgeBindings
-			},
-			pressCountSinceStart: {
-				kind: "expression",
-				expr: "count(lastPressedAt)",
-				bindings: { lastPressedAt: {
-					kind: "from",
-					source: {
-						addonId: input.camera.addonId,
-						stableId: input.camera.stableId
-					},
-					cap: "doorbell",
-					fieldPath: "lastPressedAt"
-				} }
-			}
-		}
-	};
-}
-/**
 * Runtime defaults -- used by ConfigManager.get() for backward compatibility
 * until Plan B wires all runtime settings to the system_settings SQL table.
 *
@@ -57682,6 +57555,18 @@ var STATE_SUMMARY_VARS = [
 		systemEventKinds: [...SUMMARISABLE],
 		systemEventDeliveries: ["summary"]
 	},
+	{
+		name: "summarySection",
+		label: "Summary: this section",
+		description: "The section a per-section summary row is about (D698); on a summary sent as one message, every section it reports, comma-separated.",
+		example: "Batterie scariche",
+		group: "system",
+		families: ["rule"],
+		fields: [...RULE_TEXT],
+		kinds: ["system"],
+		systemEventKinds: [...SUMMARISABLE],
+		systemEventDeliveries: ["summary"]
+	},
 	...STATE_SUMMARY_SECTION_VARS.map((v) => ({
 		name: v.name,
 		label: v.label,
@@ -58020,6 +57905,7 @@ TimelapseRuleInputSchema.extend({
 	createdAt: zod.z.number(),
 	updatedAt: zod.z.number()
 });
+MotionOnMotionChangedDataSchema.omit({ triggeredBy: true });
 zod.z.object({
 	/**
 	* Fraction of the box's own size added on EACH side before cutting.
@@ -58219,8 +58105,8 @@ DEFAULT_NATIVE_LEASE_SETTINGS.admission;
 * So `entry.providerAddonId === this.ctx.id` is silently, permanently false
 * for a builtin — and only for a builtin, which is why it survives a green
 * suite whose fake supplies the bare id. That is exactly how camera 615's
-* virtual doorbell latched `unbound` for twelve hours on 2026-08-07 while its
-* binding was intact ([D72](../../../../docs/decisions/adr-0072.md)).
+* virtual doorbell (retired since, D671) latched `unbound` for twelve hours on
+* 2026-08-07 while its binding was intact ([D72](../../../../docs/decisions/adr-0072.md)).
 *
 * Route every comparison between `ctx.id` and a registry/store addon id
 * through {@link isSameAddonId}. `scripts/check-addon-id-comparison.ts`
@@ -58232,10 +58118,6 @@ var ADDON_ID_PREFIX = "addon:";
 function bareAddonId(id) {
 	return id.startsWith(ADDON_ID_PREFIX) ? id.slice(6) : id;
 }
-/** True when both ids name the same addon, prefixed or not. */
-function isSameAddonId(a, b) {
-	return bareAddonId(a) === bareAddonId(b);
-}
 var MB = 1024 * 1024;
 1024 * MB, 3072 * MB;
 /**
@@ -58484,12 +58366,6 @@ Object.defineProperty(exports, "DAY_NAMES", {
 		return DAY_NAMES;
 	}
 });
-Object.defineProperty(exports, "DEFAULT_FIRST_SIGHTING_FRESHNESS_MS", {
-	enumerable: true,
-	get: function() {
-		return DEFAULT_FIRST_SIGHTING_FRESHNESS_MS;
-	}
-});
 Object.defineProperty(exports, "DERIVED_CAMERA_SILENCED_CAP_NAMES", {
 	enumerable: true,
 	get: function() {
@@ -58634,12 +58510,6 @@ Object.defineProperty(exports, "RecordingStatusSchema", {
 		return RecordingStatusSchema;
 	}
 });
-Object.defineProperty(exports, "SOURCE_CAPS", {
-	enumerable: true,
-	get: function() {
-		return SOURCE_CAPS;
-	}
-});
 Object.defineProperty(exports, "STORAGE_ACCESS_FALLBACK", {
 	enumerable: true,
 	get: function() {
@@ -58766,12 +58636,6 @@ Object.defineProperty(exports, "buildCapabilityLookup", {
 		return buildCapabilityLookup;
 	}
 });
-Object.defineProperty(exports, "buildDoorbellCompositionFeature", {
-	enumerable: true,
-	get: function() {
-		return buildDoorbellCompositionFeature;
-	}
-});
 Object.defineProperty(exports, "buildFfmpegArgs", {
 	enumerable: true,
 	get: function() {
@@ -58970,18 +58834,6 @@ Object.defineProperty(exports, "deviceStatusCapability", {
 		return deviceStatusCapability;
 	}
 });
-Object.defineProperty(exports, "doorbellCapability", {
-	enumerable: true,
-	get: function() {
-		return doorbellCapability;
-	}
-});
-Object.defineProperty(exports, "doorbellFeatureSources", {
-	enumerable: true,
-	get: function() {
-		return doorbellFeatureSources;
-	}
-});
 Object.defineProperty(exports, "emitDownForOwnedCaps", {
 	enumerable: true,
 	get: function() {
@@ -59024,12 +58876,6 @@ Object.defineProperty(exports, "evaluateCompositionField", {
 		return evaluateCompositionField;
 	}
 });
-Object.defineProperty(exports, "evaluateSensorEdge", {
-	enumerable: true,
-	get: function() {
-		return evaluateSensorEdge;
-	}
-});
 Object.defineProperty(exports, "evictionPolicyOfLocation", {
 	enumerable: true,
 	get: function() {
@@ -59120,18 +58966,6 @@ Object.defineProperty(exports, "isObjectInput", {
 		return isObjectInput;
 	}
 });
-Object.defineProperty(exports, "isSameAddonId", {
-	enumerable: true,
-	get: function() {
-		return isSameAddonId;
-	}
-});
-Object.defineProperty(exports, "isSourceCap", {
-	enumerable: true,
-	get: function() {
-		return isSourceCap;
-	}
-});
 Object.defineProperty(exports, "isVoidInput", {
 	enumerable: true,
 	get: function() {