@camstack/types 1.2.283 → 1.2.285

package/dist/index.js

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-DCbD8sdg.js");
-const require_event_category = require("./event-category-MbnB-6AN.js");
-const require_composition = require("./composition-DG4jVTfB.js");
+const require_sleep = require("./sleep-G4F3X9X_.js");
+const require_event_category = require("./event-category-DmS_tLsU.js");
+const require_composition = require("./composition-w3gBWMer.js");
 const require_err_msg = require("./err-msg-Dx2Kor0g.js");
 const require_enums = require("./enums.js");
 let zod = require("zod");
@@ -2538,7 +2538,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.
 	*/
@@ -14541,8 +14541,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.
@@ -14833,107 +14833,6 @@ var deviceManagerCapability = {
 	}
 };
 //#endregion
-//#region src/capabilities/doorbell.cap.ts
-/**
-* 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: [require_err_msg.DeviceType.Camera],
-	sourceCaps: require_composition.SOURCE_CAPS,
-	cardinality: "many",
-	value: DoorbellSourceSlotValueSchema
-};
-var doorbellCapability = {
-	name: "doorbell",
-	scope: "device",
-	deviceNative: true,
-	mode: "singleton",
-	kind: "wrapper",
-	defaultActive: false,
-	deviceTypes: [require_err_msg.DeviceType.Button, require_err_msg.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"
-};
-//#endregion
 //#region src/generated/extension-slots.ts
 /**
 * AUTO-GENERATED by scripts/generate-extension-slots.ts — DO NOT EDIT.
@@ -14943,25 +14842,18 @@ onPressed: {
 * caps' descriptors and value schemas — never the caps barrel — so
 * `device-extension.cap.ts` can import this module without a cycle.
 *
-* Coverage: 2 slot(s).
+* Coverage: 1 slot(s).
 */
 /** Every declared slot id, in table order. */
-var EXTENSION_SLOT_IDS = ["doorbell-source", "linked-devices"];
+var EXTENSION_SLOT_IDS = ["linked-devices"];
 var ExtensionSlotIdSchema = zod.z.enum(EXTENSION_SLOT_IDS);
-var EXTENSION_SLOTS = {
-	"doorbell-source": {
-		descriptor: DOORBELL_SOURCE_SLOT,
-		declaringCap: "doorbell",
-		hostDeviceTypes: [require_err_msg.DeviceType.Camera]
-	},
-	"linked-devices": {
-		descriptor: LINKED_DEVICES_SLOT,
-		declaringCap: "device-manager",
-		hostDeviceTypes: [require_err_msg.DeviceType.Camera]
-	}
-};
+var EXTENSION_SLOTS = { "linked-devices": {
+	descriptor: LINKED_DEVICES_SLOT,
+	declaringCap: "device-manager",
+	hostDeviceTypes: [require_err_msg.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 = [require_err_msg.DeviceType.Camera];
 //#endregion
@@ -14970,8 +14862,8 @@ var EXTENSION_HOST_DEVICE_TYPES = [require_err_msg.DeviceType.Camera];
 * `device-extension` — ONE place to see and author what a device is extended
 * with by OTHER devices (D648).
 *
-* **A contract, not a store.** Every slot (`linked-devices`, `doorbell-source`)
-* is declared by the cap that owns the function (`extensionSlots` in its
+* **A contract, not a store.** Every slot (today one: `linked-devices`) is
+* declared by the cap that owns the function (`extensionSlots` in its
 * `*.cap.ts`, D4) and SERVED by the addon that already owns its store, over
 * that store and its existing write path. This cap persists nothing and has no config method (guarded by
 * `scripts/check-extension-slots.ts`): D62 applied to the whole feature, and
@@ -14980,7 +14872,7 @@ var EXTENSION_HOST_DEVICE_TYPES = [require_err_msg.DeviceType.Camera];
 * **Shape.** A device-scoped wrapper COLLECTION, the D554 shape `videoclips`
 * uses: `resolveCapMount` gives it the `device-scoped` mount and
 * `requireDeviceCollection` dispatches it. Its providers are the slot owners
-* (device-manager, virtual-doorbell, …), and a device's sources are its
+* (today device-manager alone), and a device's sources are its
 * bindings (step 0 of `getBindings`, derived, persisted nowhere).
 *
 *  - `listSources` — one row per provider, the D554 source-listing convention
@@ -15040,10 +14932,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([
@@ -15060,7 +14953,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,
@@ -15264,8 +15157,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:
@@ -21390,6 +21283,41 @@ var NcSnoozeSuppressedSchema = zod.z.object({
 	firstAt: zod.z.number(),
 	lastAt: zod.z.number()
 });
+/** The bounds every alarm delay field carries — settings, per-mode overrides, both editors. */
+var NC_ALARM_DELAY_MAX_SEC = 600;
+var NC_ALARM_TRIGGERED_MAX_SEC = 3600;
+/** At most this many ids on one mode's non-blocking list. */
+var NC_ALARM_NONBLOCKING_MAX = 200;
+var NcAlarmDelaySecSchema = zod.z.number().int().min(0).max(600);
+var NcAlarmTriggeredSecSchema = zod.z.number().int().min(0).max(NC_ALARM_TRIGGERED_MAX_SEC);
+var uniqueModes = (entries) => new Set(entries.map((e) => e.mode)).size === entries.length;
+/** One mode's OVERRIDES. An absent field inherits the global value (D697). */
+var NcAlarmModeDelaysSchema = zod.z.object({
+	mode: AlarmArmModeSchema,
+	exitDelaySec: NcAlarmDelaySecSchema.optional(),
+	entryDelaySec: NcAlarmDelaySecSchema.optional(),
+	triggeredDurationSec: NcAlarmTriggeredSecSchema.optional()
+});
+var NcAlarmModeDelaysListSchema = zod.z.array(NcAlarmModeDelaysSchema).max(8).refine(uniqueModes, { message: "modeDelays: at most one entry per arm mode" });
+/**
+* One mode's EDIT in a patch: a number sets the override, `null` removes it (the mode inherits
+* again), an absent field leaves it alone. Per field, so two editors changing two different
+* delays of one mode never undo each other.
+*/
+var NcAlarmModeDelaysEditSchema = zod.z.object({
+	mode: AlarmArmModeSchema,
+	exitDelaySec: NcAlarmDelaySecSchema.nullable().optional(),
+	entryDelaySec: NcAlarmDelaySecSchema.nullable().optional(),
+	triggeredDurationSec: NcAlarmTriggeredSecSchema.nullable().optional()
+});
+var NcAlarmModeDelaysEditListSchema = zod.z.array(NcAlarmModeDelaysEditSchema).max(8).refine(uniqueModes, { message: "modeDelays: at most one edit per arm mode" });
+/** One switch of the alarm table: put ONE device on, or take it off, ONE mode's list. */
+var NcAlarmNonBlockingEditSchema = zod.z.object({
+	mode: AlarmArmModeSchema,
+	deviceId: zod.z.number().int().positive(),
+	/** true = on the list (may be open, does not block); false = off the list (blocks). */
+	nonBlocking: zod.z.boolean()
+});
 /**
 * One arm mode's non-blocking list: devices that may be open when that mode
 * arms, without the arm being refused.
@@ -21403,10 +21331,10 @@ var NcAlarmNonBlockingSchema = zod.z.object({
 * meaning a reader could agree on (union? the last one?), so they are refused
 * at the boundary rather than interpreted.
 */
-var NcAlarmNonBlockingListSchema = zod.z.array(NcAlarmNonBlockingSchema).max(8).refine((lists) => new Set(lists.map((l) => l.mode)).size === lists.length, { message: "nonBlocking: at most one list per arm mode" });
+var NcAlarmNonBlockingListSchema = zod.z.array(NcAlarmNonBlockingSchema).max(8).refine(uniqueModes, { message: "nonBlocking: at most one list per arm mode" });
 /**
-* The three durations the panel's state machine runs on, who hears about its
-* transitions, and which openings each mode tolerates.
+* The three durations — global, and per mode since D697 — the panel's state
+* machine runs on, who hears about its transitions, and which openings each mode tolerates.
 *
 * They live on the NOTIFICATION-RULES cap, not on `alarm-panel`, on purpose:
 * `alarm-panel` is `deviceNative` and its other provider mirrors somebody
@@ -21416,15 +21344,15 @@ var NcAlarmNonBlockingListSchema = zod.z.array(NcAlarmNonBlockingSchema).max(8).
 */
 var NcAlarmSettingsSchema = zod.z.object({
 	/** Grace period between arming and the mode taking effect. 0 = immediate. */
-	exitDelaySec: zod.z.number().int().min(0).max(600),
+	exitDelaySec: NcAlarmDelaySecSchema,
 	/** Grace period between a trigger and the alarm firing. 0 = immediate. */
-	entryDelaySec: zod.z.number().int().min(0).max(600),
+	entryDelaySec: NcAlarmDelaySecSchema,
 	/**
 	* How long `triggered` lasts before the panel re-arms itself.
 	* **0 = until an operator disarms it** — the behaviour before this field
 	* existed, and therefore what an untouched install keeps doing.
 	*/
-	triggeredDurationSec: zod.z.number().int().min(0).max(3600),
+	triggeredDurationSec: NcAlarmTriggeredSecSchema,
 	/**
 	* Deprecated by D630 — every transition is announced. Parsed, never read;
 	* remove after one release. Optional so an older admin's patch (which still
@@ -21447,17 +21375,30 @@ var NcAlarmSettingsSchema = zod.z.object({
 	* per mode is meaningful. Defaulted to `[]` so a blob stored before D630
 	* parses as "every opening blocks" — the behaviour it was written under.
 	*/
-	nonBlocking: NcAlarmNonBlockingListSchema.default([])
+	nonBlocking: NcAlarmNonBlockingListSchema.default([]),
+	/**
+	* Per arm mode, the delays that mode OVERRIDES (D697). A mode with no entry, or an entry
+	* without a field, uses the global value above — so `[]`, the default, is exactly the
+	* behaviour of a blob stored before this field existed. Read through `resolveModeDelays`.
+	*/
+	modeDelays: NcAlarmModeDelaysListSchema.default([])
 });
 /**
 * Every field optional — a tab edits one control at a time.
 *
-* `nonBlocking` is re-declared WITHOUT its default: `.partial()` does not
-* remove an inner `.default()`, so a patch that never named the field would
-* parse to `nonBlocking: []` and wipe every mode's list on an unrelated edit
-* (the same trap {@link NcRulePatchSchema} documents).
+* `nonBlocking` and `modeDelays` are re-declared WITHOUT their defaults:
+* `.partial()` does not remove an inner `.default()`, so a patch that never
+* named the field would parse to `[]` and wipe every mode's list on an
+* unrelated edit (the same trap {@link NcRulePatchSchema} documents). Here
+* `modeDelays` means EDITS, not the stored overrides.
 */
-var NcAlarmSettingsPatchSchema = NcAlarmSettingsSchema.extend({ nonBlocking: NcAlarmNonBlockingListSchema }).partial();
+var NcAlarmSettingsPatchSchema = NcAlarmSettingsSchema.extend({
+	nonBlocking: NcAlarmNonBlockingListSchema,
+	/** Per-mode, per-field edits — NOT the whole list (see NcAlarmModeDelaysEditSchema). */
+	modeDelays: NcAlarmModeDelaysEditListSchema,
+	/** ONE membership change; the panel applies it to the list it holds at its turn. */
+	nonBlockingEdit: NcAlarmNonBlockingEditSchema
+}).partial().refine((p) => p.nonBlocking === void 0 || p.nonBlockingEdit === void 0, { message: "nonBlocking and nonBlockingEdit are exclusive — send the whole lists or one edit" });
 /**
 * What one arm mode actually arms, DERIVED from the enabled rules gated on it.
 * Never authored, never stored — see `alarm-mode-coverage.ts` for why a stored
@@ -21557,6 +21498,30 @@ var NcAlarmConfigSchema = zod.z.object({
 	*/
 	live: NcAlarmLiveSchema.optional()
 });
+/** At most this many ids in one `getAlarmSensors` call — a validation bound, not a target. */
+var NC_ALARM_SENSORS_MAX = 500;
+var NcAlarmSensorReadingSchema = zod.z.enum([
+	"open",
+	"closed",
+	"unknown",
+	"not-opening"
+]);
+/** One device's state as the alarm reads it — the classifier the arm check uses. */
+var NcAlarmSensorStateSchema = zod.z.object({
+	deviceId: zod.z.number().int().positive(),
+	reading: NcAlarmSensorReadingSchema,
+	/** The word as read (`open`, `closed`, `unlocked`, `stopped`, …); null when unknown / not an opening. */
+	state: zod.z.string().nullable(),
+	/** Why `unknown`: the read failed, or the slice holds no word its cap defines (a placeholder included). */
+	unknownWhy: zod.z.enum(["read-failed", "unknown-word"]).nullable(),
+	/** The device manager's liveness as the centre mirrors it; null = not known. */
+	online: zod.z.boolean().nullable()
+});
+var NcAlarmSensorsInputSchema = zod.z.object({ deviceIds: zod.z.array(zod.z.number().int().positive()).max(500) });
+var NcAlarmSensorsSchema = zod.z.object({
+	sensors: zod.z.array(NcAlarmSensorStateSchema),
+	readAt: zod.z.number().int().nonnegative()
+});
 /**
 * The most seconds of footage any notification rule may ask a camera to retain.
 *
@@ -21816,8 +21781,9 @@ var notificationRulesCapability = {
 		*/
 		getAlarmConfig: require_sleep.method(zod.z.object({}), NcAlarmConfigSchema, { auth: "admin" }),
 		/**
-		* Patch the settings (durations, recipients, per-mode non-blocking lists;
-		* `announceArm` is accepted and ignored — D630). Returns the WHOLE config,
+		* Patch the settings (durations — global and per mode —, recipients,
+		* per-mode non-blocking lists or one membership edit; `announceArm` is
+		* accepted and ignored — D630). Returns the WHOLE config,
 		* coverage and `live` included, so a
 		* client never has to guess what the server settled on — the panel clamps
 		* and normalises, and a form that re-rendered from its own input would
@@ -21826,7 +21792,15 @@ var notificationRulesCapability = {
 		setAlarmConfig: require_sleep.method(zod.z.object({ patch: NcAlarmSettingsPatchSchema }), NcAlarmConfigSchema, {
 			kind: "mutation",
 			auth: "admin"
-		})
+		}),
+		/**
+		* The CURRENT state of each asked device as the alarm reads it (D697) — open, closed,
+		* unknown (why) or not an opening, plus liveness. Classified by the same table the arm
+		* check uses (`alarm-openings.ts`), so the editor and the arm can never disagree. The
+		* caller names the ids (the household openings it already holds); at most
+		* `NC_ALARM_SENSORS_MAX`.
+		*/
+		getAlarmSensors: require_sleep.method(NcAlarmSensorsInputSchema, NcAlarmSensorsSchema, { auth: "admin" })
 	}
 };
 //#endregion
@@ -22215,12 +22189,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);
@@ -22232,39 +22221,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()
 	})
@@ -22277,17 +22268,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()
 	})
 ]);
 /** What a camera reads before its first settings read ANSWERED (D315). */
@@ -26631,8 +26654,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"]),
 	/**
@@ -26997,7 +27022,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
@@ -34859,6 +34892,72 @@ onStatusChanged: { data: zod.z.object({
 	volatileStateFields: ["lastChangedAt"]
 };
 //#endregion
+//#region src/capabilities/doorbell.cap.ts
+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: [require_err_msg.DeviceType.Button, require_err_msg.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"
+};
+//#endregion
 //#region src/capabilities/enum-sensor.cap.ts
 /**
 * Enum-state sensor — a string value picked from a finite option set.
@@ -37306,11 +37405,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.
@@ -37321,9 +37420,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
 	*
@@ -37341,34 +37440,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.
+	* ## Who writes it (D696)
 	*
-	* ### The phase machine is CANONICAL, not sole — and that is a defect
+	* - **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.
 	*
-	* 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.
+	* `scripts/check-onboard-motion-emitters.ts` refuses any other writer of a
+	* `motion` slice; each sensor writer is a named exemption.
 	*
-	* 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.
+	* 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()
 });
@@ -37440,11 +37536,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`.
@@ -40427,8 +40524,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:
@@ -40436,7 +40532,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
@@ -46659,10 +46755,10 @@ function feederCustomizationExample(sources) {
 //#endregion
 //#region src/composition/presets/doorbell-feature.ts
 /**
-* 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".
+* The doorbell of a camera as a customization (D671). ONE builder: the admin
+* UI's Customize → Doorbell card writes every doorbell feature through it, and
+* edits one only when it is exactly what this builds (`isDoorbellPresetFeature`)
+* — a composed doorbell has one canonical shape.
 */
 /** A rise closer than this to the previous one is the same press (D671). */
 var DOORBELL_RISE_DEBOUNCE_MS = 2e3;
@@ -46679,7 +46775,7 @@ function doorbellFeatureSources(source, boundCaps) {
 		}];
 	});
 }
-/** The D671 feature, byte for byte what the migration writes. Throws on zero sources. */
+/** The canonical D671 doorbell feature. 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");
@@ -56409,6 +56505,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"notificationRules.getAlarmSensors": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"notificationRules.getClipRetentionAsks": {
 		capName: "notification-rules",
 		capScope: "system",
@@ -61229,6 +61331,11 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"notificationRules.getAlarmSensors": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
 	"notificationRules.setDeviceMuted": [{
 		name: "deviceId",
 		form: "single",
@@ -62467,6 +62574,7 @@ var SYSTEM_SCOPE_DEVICE_METHODS = [
 	"faceGallery.listRecentFaces",
 	"networkQuality.getDeviceStats",
 	"networkQuality.reportClientStats",
+	"notificationRules.getAlarmSensors",
 	"notificationRules.setDeviceMuted",
 	"osdManager.clearSlotBinding",
 	"osdManager.copyDeviceConfiguration",
@@ -63407,7 +63515,8 @@ function createSystemProxy(api) {
 			createSnooze: (input) => dispatch("notificationRules", "createSnooze", "mutation", input),
 			cancelSnooze: (input) => dispatch("notificationRules", "cancelSnooze", "mutation", input),
 			getAlarmConfig: (input) => dispatch("notificationRules", "getAlarmConfig", "query", input),
-			setAlarmConfig: (input) => dispatch("notificationRules", "setAlarmConfig", "mutation", input)
+			setAlarmConfig: (input) => dispatch("notificationRules", "setAlarmConfig", "mutation", input),
+			getAlarmSensors: (input) => dispatch("notificationRules", "getAlarmSensors", "query", input)
 		},
 		osdManager: {
 			getConditionSupport: (input) => dispatch("osdManager", "getConditionSupport", "query", input),
@@ -65442,6 +65551,176 @@ function sensorTransitionNeverFires(rule) {
 /** The warning an editor shows for {@link sensorTransitionNeverFires}. */
 var NC_SENSOR_TRANSITION_NEVER_FIRES_WARNING = "This rule belongs to the alarm, and an alarm rule fires only when an opening OPENS. Set to “only when it clears”, it can never fire.";
 //#endregion
+//#region src/notification/alarm-settings.ts
+var NC_ALARM_DELAY_FIELDS = [
+	"exitDelaySec",
+	"entryDelaySec",
+	"triggeredDurationSec"
+];
+/** The mode's value when it overrides the field, else the global one. */
+function pick(override, global) {
+	return override === void 0 ? {
+		value: global,
+		source: "default"
+	} : {
+		value: override,
+		source: "mode"
+	};
+}
+/** What `mode` actually runs on: its own overrides, the global value for every other field. */
+function resolveModeDelays(settings, mode) {
+	const entry = (settings.modeDelays ?? []).find((e) => e.mode === mode);
+	const exit = pick(entry?.exitDelaySec, settings.exitDelaySec);
+	const entryDelay = pick(entry?.entryDelaySec, settings.entryDelaySec);
+	const triggered = pick(entry?.triggeredDurationSec, settings.triggeredDurationSec);
+	return {
+		exitDelaySec: exit.value,
+		entryDelaySec: entryDelay.value,
+		triggeredDurationSec: triggered.value,
+		source: {
+			exitDelaySec: exit.source,
+			entryDelaySec: entryDelay.source,
+			triggeredDurationSec: triggered.source
+		}
+	};
+}
+/** One field of an entry after an edit: number sets, null clears, undefined keeps. */
+function edited(current, edit) {
+	if (edit === void 0) return current;
+	return edit === null ? void 0 : edit;
+}
+/**
+* Apply per-field edits to the stored overrides. Returns new arrays, never mutates the input;
+* an entry with no field left is dropped (the mode inherits everything again).
+*/
+function applyModeDelaysEdits(current, edits) {
+	const out = current.map((e) => ({ ...e }));
+	for (const edit of edits) {
+		const at = out.findIndex((e) => e.mode === edit.mode);
+		const base = at >= 0 ? out[at] ?? { mode: edit.mode } : { mode: edit.mode };
+		const next = { mode: edit.mode };
+		const exit = edited(base.exitDelaySec, edit.exitDelaySec);
+		const entry = edited(base.entryDelaySec, edit.entryDelaySec);
+		const triggered = edited(base.triggeredDurationSec, edit.triggeredDurationSec);
+		if (exit !== void 0) next.exitDelaySec = exit;
+		if (entry !== void 0) next.entryDelaySec = entry;
+		if (triggered !== void 0) next.triggeredDurationSec = triggered;
+		if (at >= 0) out[at] = next;
+		else out.push(next);
+	}
+	return out.filter((e) => e.exitDelaySec !== void 0 || e.entryDelaySec !== void 0 || e.triggeredDurationSec !== void 0);
+}
+/**
+* Put ONE device on, or take it off, ONE mode's list. A no-op answers `changed: false`; an add
+* to a full list is REFUSED by reason (never silently dropped); an emptied list drops its entry.
+*/
+function applyNonBlockingEdit(lists, edit) {
+	const copy = lists.map((l) => ({
+		mode: l.mode,
+		deviceIds: [...l.deviceIds]
+	}));
+	const at = copy.findIndex((l) => l.mode === edit.mode);
+	const held = at >= 0 ? copy[at]?.deviceIds ?? [] : [];
+	const present = held.includes(edit.deviceId);
+	if (edit.nonBlocking === present) return {
+		kind: "applied",
+		lists: copy,
+		changed: false
+	};
+	if (edit.nonBlocking) {
+		if (held.length >= 200) return {
+			kind: "refused",
+			reason: "list-full",
+			mode: edit.mode,
+			max: 200
+		};
+		const next = {
+			mode: edit.mode,
+			deviceIds: [...held, edit.deviceId]
+		};
+		if (at >= 0) copy[at] = next;
+		else copy.push(next);
+	} else {
+		const next = {
+			mode: edit.mode,
+			deviceIds: held.filter((id) => id !== edit.deviceId)
+		};
+		if (at >= 0) copy[at] = next;
+	}
+	return {
+		kind: "applied",
+		lists: copy.filter((l) => l.deviceIds.length > 0),
+		changed: true
+	};
+}
+function sameSet(a, b) {
+	const sa = new Set(a);
+	const sb = new Set(b);
+	return sa.size === sb.size && [...sa].every((x) => sb.has(x));
+}
+/** Per-mode id sets of a lists value, empty lists ignored. */
+function listsByMode(lists) {
+	const out = /* @__PURE__ */ new Map();
+	for (const l of lists) if (l.deviceIds.length > 0) out.set(l.mode, new Set(l.deviceIds));
+	return out;
+}
+function sameLists(a, b) {
+	const ma = listsByMode(a);
+	const mb = listsByMode(b);
+	if (ma.size !== mb.size) return false;
+	for (const [mode, ids] of ma) {
+		const other = mb.get(mode);
+		if (other === void 0 || !sameSet([...ids], [...other])) return false;
+	}
+	return true;
+}
+/** The returned entry's value for one field of a mode-delays edit. */
+function fieldOf(entry, field) {
+	if (entry === void 0) return void 0;
+	switch (field) {
+		case "exitDelaySec": return entry.exitDelaySec;
+		case "entryDelaySec": return entry.entryDelaySec;
+		case "triggeredDurationSec": return entry.triggeredDurationSec;
+	}
+}
+/** The edit's value for one field. */
+function editFieldOf(edit, field) {
+	switch (field) {
+		case "exitDelaySec": return edit.exitDelaySec;
+		case "entryDelaySec": return edit.entryDelaySec;
+		case "triggeredDurationSec": return edit.triggeredDurationSec;
+	}
+}
+/**
+* True iff every key the patch sent is reflected in what the host returned. A host older than
+* this build strips the keys it does not know; this is how a client tells "saved" from "parsed
+* and dropped". `announceArm` is ignored (parsed, never read). A `null` clear "lands" on a host
+* that stripped the key (it lacks the field) — harmless, because such a host stores no overrides.
+* A whole-list `nonBlocking` naming a mode the panel does not offer reads as "not landed" (the host
+* drops it); only older clients and the prune send whole lists, and they do not call this.
+*/
+function alarmPatchLanded(patch, returned) {
+	if (patch.exitDelaySec !== void 0 && patch.exitDelaySec !== returned.exitDelaySec) return false;
+	if (patch.entryDelaySec !== void 0 && patch.entryDelaySec !== returned.entryDelaySec) return false;
+	if (patch.triggeredDurationSec !== void 0 && patch.triggeredDurationSec !== returned.triggeredDurationSec) return false;
+	if (patch.announceTargets !== void 0 && !sameSet(patch.announceTargets, returned.announceTargets)) return false;
+	if (patch.nonBlocking !== void 0 && !sameLists(patch.nonBlocking, returned.nonBlocking ?? [])) return false;
+	for (const edit of patch.modeDelays ?? []) {
+		const entry = (returned.modeDelays ?? []).find((e) => e.mode === edit.mode);
+		for (const field of NC_ALARM_DELAY_FIELDS) {
+			const want = editFieldOf(edit, field);
+			if (want === void 0) continue;
+			const got = fieldOf(entry, field);
+			if (want === null ? got !== void 0 : got !== want) return false;
+		}
+	}
+	if (patch.nonBlockingEdit !== void 0) {
+		const e = patch.nonBlockingEdit;
+		if (((returned.nonBlocking ?? []).find((l) => l.mode === e.mode)?.deviceIds.includes(e.deviceId) ?? false) !== e.nonBlocking) return false;
+	}
+	return true;
+}
+//#endregion
 //#region src/notification/sensor-raised.ts
 /**
 * WHICH WAY A BOOLEAN SENSOR MOVED — read off the one slice a sensor event
@@ -67150,6 +67429,35 @@ function readTimelapseGeneratedAt(rule, deviceId) {
 	return rule.lastGeneratedAt ?? 0;
 }
 //#endregion
+//#region src/pipeline/motion-ownership.ts
+function cameraOwnsMotionViaSensor(motionSources) {
+	return motionSources.some((s) => s !== "analyzer");
+}
+//#endregion
+//#region src/device/hub-motion-read.ts
+async function readHubMotionDetected(deviceState, deviceId) {
+	let slice;
+	try {
+		slice = await deviceState.getCapSlice.query({
+			deviceId,
+			capName: "motion"
+		});
+	} catch (err) {
+		const reason = err instanceof Error ? err.message : String(err);
+		throw new Error(`motion state of device ${deviceId} is unreadable: ${reason}`, { cause: err });
+	}
+	const detected = slice?.["detected"];
+	if (typeof detected !== "boolean") throw new Error(`motion state of device ${deviceId} is not published yet (unknown)`);
+	return detected;
+}
+//#endregion
+//#region src/pipeline/provider-motion.ts
+/** The motion event's data without `triggeredBy`: only the bridge names a trigger. */
+var ProviderMotionDataSchema = MotionOnMotionChangedDataSchema.omit({ triggeredBy: true });
+function providerMotionEvent(source, data) {
+	return require_sleep.createEvent(require_event_category.EventCategory.ProviderMotion, source, data);
+}
+//#endregion
 //#region src/pipeline/step-format-runnable.ts
 /** True when `model` ships a build for `format`. */
 function hasBuild(model, format) {
@@ -68039,8 +68347,8 @@ function bestLocationMatch(externalName, existing, threshold = .8) {
 * 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`
@@ -69466,12 +69774,16 @@ exports.CameraMetricsSchema = CameraMetricsSchema;
 exports.CameraMetricsWithDeviceIdSchema = CameraMetricsWithDeviceIdSchema;
 exports.CameraMotionStatusSchema = CameraMotionStatusSchema;
 exports.CameraOccupancySnapshotForDeviceSchema = CameraOccupancySnapshotForDeviceSchema;
+exports.CameraOwnMotionSchema = CameraOwnMotionSchema;
+exports.CameraRawLevelSchema = CameraRawLevelSchema;
 exports.CameraRecordingModeSchema = CameraRecordingModeSchema;
 exports.CameraRecordingStatusSchema = CameraRecordingStatusSchema;
 exports.CameraSensorAttachmentSchema = CameraSensorAttachmentSchema;
+exports.CameraSensorEntrySchema = CameraSensorEntrySchema;
+exports.CameraSensorModeSchema = CameraSensorModeSchema;
 exports.CameraSensorRefSchema = CameraSensorRefSchema;
 exports.CameraSensorsConfigSchema = CameraSensorsConfigSchema;
-exports.CameraSensorsModeSchema = CameraSensorsModeSchema;
+exports.CameraSensorsNotEnforcedSchema = CameraSensorsNotEnforcedSchema;
 exports.CameraSensorsNotForwardedSchema = CameraSensorsNotForwardedSchema;
 exports.CameraSensorsStatusSchema = CameraSensorsStatusSchema;
 exports.CameraSourceStatusSchema = CameraSourceStatusSchema;
@@ -69611,6 +69923,7 @@ exports.DECLARED_DEVICE_SWEEP_LIMIT = DECLARED_DEVICE_SWEEP_LIMIT;
 exports.DECLARED_INTEGRATION_FIXED_KEY = DECLARED_INTEGRATION_FIXED_KEY;
 exports.DEFAULT_ADDON_PLACEMENT = DEFAULT_ADDON_PLACEMENT;
 exports.DEFAULT_AUDIO_ANALYZER_CONFIG = DEFAULT_AUDIO_ANALYZER_CONFIG;
+exports.DEFAULT_CAMERA_SENSOR_MODE = DEFAULT_CAMERA_SENSOR_MODE;
 exports.DEFAULT_CLUSTER_STEP_MODELS = DEFAULT_CLUSTER_STEP_MODELS;
 exports.DEFAULT_CLUSTER_STEP_SETTINGS = DEFAULT_CLUSTER_STEP_SETTINGS;
 exports.DEFAULT_DECODER_HWACCEL_CONFIG = DEFAULT_DECODER_HWACCEL_CONFIG;
@@ -69652,7 +69965,6 @@ exports.DISPLAY_ICON_KEYS = DISPLAY_ICON_KEYS;
 exports.DISPLAY_ICON_OFFERED_KEYS = DISPLAY_ICON_OFFERED_KEYS;
 exports.DISPLAY_ICON_VOCABULARY = DISPLAY_ICON_VOCABULARY;
 exports.DOORBELL_RISE_DEBOUNCE_MS = DOORBELL_RISE_DEBOUNCE_MS;
-exports.DOORBELL_SOURCE_SLOT = DOORBELL_SOURCE_SLOT;
 exports.DataStoreEngineInfoSchema = EngineInfoSchema;
 exports.DatabaseSnapshotResultSchema = DatabaseSnapshotResultSchema;
 exports.DatabaseSnapshotTableSchema = DatabaseSnapshotTableSchema;
@@ -69697,7 +70009,6 @@ exports.DiscoveredTargetSchema = DiscoveredTargetSchema;
 exports.DiskReconcileJobSchema = DiskReconcileJobSchema;
 exports.DisposerChain = require_sleep.DisposerChain;
 exports.DoorbellPressEventSchema = DoorbellPressEventSchema;
-exports.DoorbellSourceSlotValueSchema = DoorbellSourceSlotValueSchema;
 exports.DoorbellStatusSchema = DoorbellStatusSchema;
 exports.EMBEDDING_MODEL_FAILED = EMBEDDING_MODEL_FAILED;
 exports.EMBEDDING_REQUIREMENTS_FAILED = EMBEDDING_REQUIREMENTS_FAILED;
@@ -70037,8 +70348,13 @@ exports.NATIVE_LEASE_TILE_BUDGET_KEY = NATIVE_LEASE_TILE_BUDGET_KEY;
 exports.NAVIGATION_ACTION_CATALOG = NAVIGATION_ACTION_CATALOG;
 exports.NAVIGATION_LIGHT_LEVEL_MAX = NAVIGATION_LIGHT_LEVEL_MAX;
 exports.NAVIGATION_LIGHT_LEVEL_MIN = NAVIGATION_LIGHT_LEVEL_MIN;
+exports.NC_ALARM_DELAY_FIELDS = NC_ALARM_DELAY_FIELDS;
+exports.NC_ALARM_DELAY_MAX_SEC = NC_ALARM_DELAY_MAX_SEC;
+exports.NC_ALARM_NONBLOCKING_MAX = NC_ALARM_NONBLOCKING_MAX;
 exports.NC_ALARM_OPENING_EVENT_KINDS = NC_ALARM_OPENING_EVENT_KINDS;
+exports.NC_ALARM_SENSORS_MAX = NC_ALARM_SENSORS_MAX;
 exports.NC_ALARM_SYSTEM_EVENT_KINDS = NC_ALARM_SYSTEM_EVENT_KINDS;
+exports.NC_ALARM_TRIGGERED_MAX_SEC = NC_ALARM_TRIGGERED_MAX_SEC;
 exports.NC_AUDIO_CONFIRM_HITS_DEFAULT = NC_AUDIO_CONFIRM_HITS_DEFAULT;
 exports.NC_AUDIO_CONFIRM_HITS_MAX = NC_AUDIO_CONFIRM_HITS_MAX;
 exports.NC_AUDIO_CONFIRM_HITS_MIN = NC_AUDIO_CONFIRM_HITS_MIN;
@@ -70126,6 +70442,13 @@ exports.NavigationRuntimeStateSchema = NavigationRuntimeStateSchema;
 exports.NavigationStatusSchema = NavigationStatusSchema;
 exports.NcAlarmConfigSchema = NcAlarmConfigSchema;
 exports.NcAlarmModeCoverageSchema = NcAlarmModeCoverageSchema;
+exports.NcAlarmModeDelaysEditSchema = NcAlarmModeDelaysEditSchema;
+exports.NcAlarmModeDelaysSchema = NcAlarmModeDelaysSchema;
+exports.NcAlarmNonBlockingEditSchema = NcAlarmNonBlockingEditSchema;
+exports.NcAlarmSensorReadingSchema = NcAlarmSensorReadingSchema;
+exports.NcAlarmSensorStateSchema = NcAlarmSensorStateSchema;
+exports.NcAlarmSensorsInputSchema = NcAlarmSensorsInputSchema;
+exports.NcAlarmSensorsSchema = NcAlarmSensorsSchema;
 exports.NcAlarmSettingsPatchSchema = NcAlarmSettingsPatchSchema;
 exports.NcAlarmSettingsSchema = NcAlarmSettingsSchema;
 exports.NcAlarmSkipReasonSchema = NcAlarmSkipReasonSchema;
@@ -70290,6 +70613,7 @@ exports.PrivacyMaskStatusSchema = PrivacyMaskStatusSchema;
 exports.ProfileRtspEntrySchema = require_sleep.ProfileRtspEntrySchema;
 exports.ProfileSlotSchema = require_sleep.ProfileSlotSchema;
 exports.ProfileSlotStatusSchema = require_sleep.ProfileSlotStatusSchema;
+exports.ProviderMotionDataSchema = ProviderMotionDataSchema;
 exports.ProviderStatusSchema = ProviderStatusSchema;
 exports.PtzAutotrackRuntimeStateSchema = PtzAutotrackRuntimeStateSchema;
 exports.PtzAutotrackSettingsSchema = PtzAutotrackSettingsSchema;
@@ -70697,8 +71021,11 @@ exports.addonsCapability = addonsCapability;
 exports.adminUiCapability = require_sleep.adminUiCapability;
 exports.airQualitySensorCapability = airQualitySensorCapability;
 exports.alarmPanelCapability = alarmPanelCapability;
+exports.alarmPatchLanded = alarmPatchLanded;
 exports.alertsCapability = alertsCapability;
 exports.ambientLightSensorCapability = ambientLightSensorCapability;
+exports.applyModeDelaysEdits = applyModeDelaysEdits;
+exports.applyNonBlockingEdit = applyNonBlockingEdit;
 exports.asBoolean = require_sleep.asBoolean;
 exports.asJsonArray = require_sleep.asJsonArray;
 exports.asJsonObject = require_sleep.asJsonObject;
@@ -70745,6 +71072,7 @@ exports.builtCapabilityBlockers = builtCapabilityBlockers;
 exports.buttonCapability = buttonCapability;
 exports.cameraCredentialsCapability = cameraCredentialsCapability;
 exports.cameraGridLayoutCapability = cameraGridLayoutCapability;
+exports.cameraOwnsMotionViaSensor = cameraOwnsMotionViaSensor;
 exports.cameraPipelineConfigCapability = cameraPipelineConfigCapability;
 exports.cameraSensorRefKey = cameraSensorRefKey;
 exports.cameraStreamsCapability = cameraStreamsCapability;
@@ -71119,6 +71447,7 @@ exports.pressureSensorCapability = pressureSensorCapability;
 exports.principalMayReachAddon = principalMayReachAddon;
 exports.privacyMaskCapability = privacyMaskCapability;
 exports.procedureAuthKey = procedureAuthKey;
+exports.providerMotionEvent = providerMotionEvent;
 exports.ptzAutotrackCapability = ptzAutotrackCapability;
 exports.ptzCapability = ptzCapability;
 exports.publicEventCategories = require_event_category.publicEventCategories;
@@ -71128,6 +71457,7 @@ exports.readClusterStepModels = readClusterStepModels;
 exports.readClusterStepSettings = readClusterStepSettings;
 exports.readDetailCropConvention = readDetailCropConvention;
 exports.readDeviceStateFrom = readDeviceStateFrom;
+exports.readHubMotionDetected = readHubMotionDetected;
 exports.readMotionTriggeredBy = readMotionTriggeredBy;
 exports.readNativeLeaseOverride = readNativeLeaseOverride;
 exports.readNodePin = require_sleep.readNodePin;
@@ -71164,6 +71494,7 @@ exports.resolveHydratedFieldValue = require_sleep.resolveHydratedFieldValue;
 exports.resolveLocationIcon = resolveLocationIcon;
 exports.resolveLocationMode = resolveLocationMode;
 exports.resolveMethodAuth = resolveMethodAuth;
+exports.resolveModeDelays = resolveModeDelays;
 exports.resolveMutate = resolveMutate;
 exports.resolvePoolMemoryPolicy = resolvePoolMemoryPolicy;
 exports.resolveRecordingProfiles = resolveRecordingProfiles;