@camstack/system 1.1.53 → 1.1.54

package/dist/builtins/doorbell/virtual-doorbell.addon.d.ts

@@ -6,26 +6,29 @@ interface VirtualDoorbellAddonConfig {
 /**
  * VirtualDoorbellAddon — WRAPPER over the `doorbell` capability.
  *
- * Turns any binary-ish device (contact sensor, switch, event emitter,
- * flood/gas/CO sensor) into a doorbell for a camera:
+ * Turns any binary sensor or switch (contact, motion, flood/gas/CO/smoke,
+ * vibration, tamper, generic binary, or a switch) into a doorbell for a
+ * camera:
  *
  *   1. The operator binds the wrapper to a camera in the bindings UI
  *      (`defaultActive: false` — never auto-bound).
- *   2. Per-camera settings pick the SOURCE device + trigger
- *      (`contact-open` / `contact-close` / `switch-on` / `event`
- *      with an event-type match).
+ *   2. In the camera's GENERAL settings (next to "Linked devices") the
+ *      operator picks one or more SOURCE devices from a searchable list —
+ *      that is the ONLY choice. The reaction is derived automatically per
+ *      device type: a binary sensor rings when it goes active, a switch
+ *      rings when it turns on (see `trigger-engine.ts`). The persisted
+ *      shape (`doorbellSources: [{deviceId}]`) stays extensible for a
+ *      future custom-trigger override.
  *   3. At runtime the addon watches `EventCategory.DeviceStateChanged`
- *      (contact/switch slice transitions — EDGE detected per trigger)
- *      and `EventCategory.EventEmitted` (event-emitter firings). On a
- *      matching, debounced trigger it emits
- *      `EventCategory.DoorbellOnPressed` with the CAMERA as source
- *      (`{deviceId: cameraId, timestamp}` — the same shape Reolink's
- *      native `emitDoorbellPressed` produces) and bumps the camera's
- *      `doorbell` runtime-state counters via the standard
- *      `deviceState.setCapSlice` plumbing.
+ *      (binary/switch slice transitions — false→true edge detected). On a
+ *      matching, debounced rise it emits `EventCategory.DoorbellOnPressed`
+ *      with the CAMERA as source (`{deviceId: cameraId, timestamp}` — the
+ *      same shape Reolink's native `emitDoorbellPressed` produces) and
+ *      bumps the camera's `doorbell` runtime-state counters via the
+ *      standard `deviceState.setCapSlice` plumbing.
  *
  * Fires ONLY for cameras where the wrapper is BOUND (checked against
- * `deviceManager.getBindings`) and a source device is configured.
+ * `deviceManager.getBindings`) and at least one source device is configured.
  */
 export declare class VirtualDoorbellAddon extends BaseAddon<VirtualDoorbellAddonConfig> {
     private readonly engine;
@@ -35,7 +38,6 @@ export declare class VirtualDoorbellAddon extends BaseAddon<VirtualDoorbellAddon
     constructor();
     protected onInitialize(): Promise<ProviderRegistration[]>;
     private handleStateChanged;
-    private handleEmitterEvent;
     /**
      * Ring the camera's virtual doorbell: verify the wrapper is BOUND to
      * the camera, bump the `doorbell` runtime-state counters through the
@@ -62,7 +64,11 @@ export declare class VirtualDoorbellAddon extends BaseAddon<VirtualDoorbellAddon
      * single source of truth, persisted across restarts).
      */
     private getStatus;
-    private readDeviceSettings;
+    /**
+     * The camera's configured doorbell sources, parsed tolerantly (new
+     * `doorbellSources` shape + legacy single-source migration).
+     */
+    private readDeviceSources;
     /**
      * Single-trip, non-throwing device lookup (mirrors snapshot's
      * `lookupDeviceMeta`). Null on any failure — callers fall back to
@@ -71,15 +77,26 @@ export declare class VirtualDoorbellAddon extends BaseAddon<VirtualDoorbellAddon
      */
     private lookupDevice;
     /**
-     * Settings section for the device-detail page. Camera-only — the
-     * doorbell cap also applies to Button accessories (native providers),
-     * where a virtual-source picker is meaningless.
+     * Settings section for the device-detail page — contributed into the
+     * GENERAL settings surface (no `tab`, so it lands in the same tab as
+     * "Linked devices", ordered just after it). Camera-only: the doorbell
+     * cap also applies to Button accessories (native providers) where a
+     * virtual-source picker is meaningless.
+     *
+     * A SINGLE `multiselect` field lists every eligible binary/switch
+     * device; at ≥8 options the admin-ui form-builder auto-swaps it for the
+     * searchable multi-select (same idiom as "Linked devices"). The reaction
+     * is derived automatically per device type — no trigger/eventType
+     * controls.
      */
     private buildDeviceSettingsContribution;
     /**
-     * Cluster-wide picker options: every device whose BINDINGS expose one
-     * of the binary-ish source caps. Binding-sourced (not feature-flag
-     * sourced) because cap names are exactly what the runtime consumes.
+     * Cluster-wide picker options: every device whose BINDINGS expose one of
+     * the recognised binary/switch source caps. Binding-sourced (not
+     * feature-flag sourced) because cap names are exactly what the runtime
+     * consumes. Labelled `Name (Location)` (id carried in the option value)
+     * so the searchable multi-select matches on name, location, or id — the
+     * same shape "Linked devices" uses.
      */
     private listSourceDeviceOptions;
     private saveDeviceSettingsPatch;

package/dist/builtins/doorbell/virtual-doorbell.addon.js

@@ -3,44 +3,62 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-BNro5CRu.js");
+const require_dist = require("../../dist-B5C4dVvO.js");
 //#region src/builtins/doorbell/trigger-engine.ts
-var DOORBELL_TRIGGERS = [
-	"contact-open",
-	"contact-close",
-	"switch-on",
-	"event"
-];
-/** Type guard for {@link DoorbellTrigger}. */
-function isDoorbellTrigger(value) {
-	return typeof value === "string" && DOORBELL_TRIGGERS.includes(value);
-}
-/** Cap slices the engine understands as binary trigger sources. */
-var CONTACT_CAP = "contact";
-var SWITCH_CAP = "switch";
 /**
-* Map an observed boolean transition on a source cap to the trigger it
-* satisfies. `null` when the transition has no configured meaning
-* (e.g. switch turning OFF).
+* Pure trigger logic for the virtual-doorbell builtin — edge detection over
+* runtime-state slices with per-camera debounce. Extracted from the addon
+* class so the behaviour is unit-testable without instantiating the addon or
+* mocking the event bus.
+*
+* REACTION MODEL (simplified — operator picks a source, the system reacts
+* with a sensible default): a source device rings a camera's doorbell when a
+* known binary / switch cap on it RISES to its active state (false→true) — a
+* contact opening, a switch turning on, an alarm sensor firing. There is no
+* per-source trigger configuration today; the shape stays extensible for a
+* future custom-trigger override (see `doorbell-settings.ts`).
 */
-function edgeToTrigger(capName, value) {
-	if (capName === CONTACT_CAP) return value ? "contact-open" : "contact-close";
-	if (capName === SWITCH_CAP) return value ? "switch-on" : null;
-	return null;
+/**
+* Known binary / switch source caps → the boolean slice field whose
+* false→true rise rings the doorbell. Every entry is "ring on active".
+* Sensors whose "active" reading is not a plain boolean (presence's string
+* state, connectivity's connected flag) are deliberately excluded — a
+* reconnect is not a doorbell press.
+*/
+var SOURCE_CAP_ACTIVE_FIELD = {
+	contact: "entryOpen",
+	binary: "on",
+	switch: "on",
+	motion: "detected",
+	flood: "flooded",
+	gas: "detected",
+	smoke: "detected",
+	"carbon-monoxide": "detected",
+	vibration: "detected",
+	tamper: "tampered"
+};
+/** 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 doorbell source. */
+function isSourceCap(capName) {
+	return Object.prototype.hasOwnProperty.call(SOURCE_CAP_ACTIVE_FIELD, capName);
 }
-/** Extract the binary state carried by a contact / switch slice. */
-function sliceBinaryValue(capName, slice) {
-	const raw = capName === CONTACT_CAP ? slice["entryOpen"] : slice["on"];
+/** 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;
 }
 /**
 * Stateful (but side-effect-free towards the outside) trigger engine.
 *
 * Tracks the last observed binary value per (sourceDevice, cap) so a
-* `DeviceStateChanged` re-emission (the slice's `lastChangedAt` moves
-* while the binary value does not) never double-fires, and the FIRST
-* observation after boot only seeds the baseline — a state hydration
-* at startup must not ring anybody's doorbell.
+* `DeviceStateChanged` re-emission (the slice's `lastChangedAt` moves while
+* the binary value does not) never double-fires, and the FIRST observation
+* after boot only seeds the baseline — a state hydration at startup must not
+* ring anybody's doorbell.
 */
 var DoorbellTriggerEngine = class {
 	assignments = [];
@@ -67,30 +85,19 @@ var DoorbellTriggerEngine = class {
 	}
 	/**
 	* Feed one `DeviceStateChanged` slice. Returns the camera ids whose
-	* doorbell should ring (already debounced). Baseline-only sightings
-	* and non-transitions return an empty array.
+	* doorbell should ring (already debounced). Only a false→true rise on a
+	* recognised source cap fires; baseline-only sightings, re-emissions, and
+	* the falling edge return an empty array.
 	*/
 	onStateSlice(deviceId, capName, slice) {
-		if (capName !== CONTACT_CAP && capName !== SWITCH_CAP) return [];
-		const value = sliceBinaryValue(capName, slice);
+		const value = sliceActiveValue(capName, slice);
 		if (value === null) return [];
 		const key = `${deviceId}:${capName}`;
 		const prior = this.lastValues.get(key);
 		this.lastValues.set(key, value);
 		if (prior === void 0 || prior === value) return [];
-		const trigger = edgeToTrigger(capName, value);
-		if (!trigger) return [];
-		return this.matchAndDebounce((a) => a.sourceDeviceId === deviceId && a.trigger === trigger);
-	}
-	/**
-	* Feed one event-emitter `onEvent` firing. Returns the camera ids to
-	* ring — assignments with `trigger: 'event'`, a matching source and a
-	* verbatim `eventType` match. An assignment with no configured
-	* eventType never matches (misconfiguration must not ring on every
-	* event the device emits).
-	*/
-	onEmitterEvent(deviceId, eventType) {
-		return this.matchAndDebounce((a) => a.trigger === "event" && a.sourceDeviceId === deviceId && a.eventType !== null && a.eventType.length > 0 && a.eventType === eventType);
+		if (!value) return [];
+		return this.matchAndDebounce((a) => a.sourceDeviceId === deviceId);
 	}
 	matchAndDebounce(predicate) {
 		const now = this.now();
@@ -106,37 +113,102 @@ var DoorbellTriggerEngine = class {
 	}
 };
 //#endregion
-//#region src/builtins/doorbell/virtual-doorbell.addon.ts
-/** Device-store keys (namespaced to avoid collisions in merged stores). */
-var KEY_SOURCE = "doorbellSourceDeviceId";
-var KEY_TRIGGER = "doorbellTrigger";
-var KEY_EVENT_TYPE = "doorbellEventType";
-var DEFAULT_TRIGGER = "contact-open";
+//#region src/builtins/doorbell/doorbell-settings.ts
+/**
+* Pure per-camera settings parsing/normalization for the virtual-doorbell
+* builtin. Kept separate from the addon class (and the runtime trigger
+* engine) so the persisted-shape handling — including tolerant migration of
+* the legacy single-source blob — is unit-testable in isolation.
+*
+* PERSISTED SHAPE (extensible by design):
+*   doorbellSources: Array<{ deviceId: number }>
+*
+* The source is an OBJECT rather than a bare id so future per-source options
+* (a custom trigger override, an event-type match, a per-source debounce)
+* can be added without another migration. Today only `deviceId` is stored;
+* the reaction is DERIVED at runtime from the source device's cap (see
+* `trigger-engine.ts`).
+*/
+/** Device-store key holding the source list. */
+var KEY_SOURCES = "doorbellSources";
+/**
+* Legacy device-store keys from the pre-simplification shape (single source
+* device + explicit trigger + event type). Retained ONLY for tolerant
+* migration on read and cleanup on write — never written afresh.
+*/
+var LEGACY_KEY_SOURCE = "doorbellSourceDeviceId";
+var LEGACY_KEY_TRIGGER = "doorbellTrigger";
+var LEGACY_KEY_EVENT_TYPE = "doorbellEventType";
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Coerce a persisted / form-supplied id (number or numeric string) to a
+*  positive integer device id, or null when it is not a usable id. */
+function coerceDeviceId(value) {
+	if (typeof value === "number" && Number.isInteger(value) && value > 0) return value;
+	if (typeof value === "string" && value !== "none" && value.trim().length > 0) {
+		const parsed = Number(value);
+		if (Number.isInteger(parsed) && parsed > 0) return parsed;
+	}
+	return null;
+}
+/** Fold a raw list of ids / source records into a deduped source array. */
+function collectSources(items) {
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const item of items) {
+		const id = isRecord$1(item) ? coerceDeviceId(item["deviceId"]) : coerceDeviceId(item);
+		if (id !== null && !seen.has(id)) {
+			seen.add(id);
+			out.push({ deviceId: id });
+		}
+	}
+	return out;
+}
 /**
-* Caps whose presence in a device's bindings marks it as a usable
-* doorbell SOURCE — anything with a binary-ish surface. Deliberately
-* not gated on device linking: which device rings which camera is an
-* operator decision.
+* Parse the persisted doorbell sources for one camera. Tolerant of BOTH:
+*   - the new `doorbellSources: [{deviceId}]` shape (ids may arrive as
+*     numbers, numeric strings, or `{deviceId}` records); and
+*   - the legacy single `doorbellSourceDeviceId` scalar, mapped onto one
+*     source (the old trigger/eventType are dropped — the reaction is now
+*     derived at runtime).
+*
+* Never throws on malformed data — unknown entries are skipped.
+*/
+function parseDoorbellSources(blob) {
+	const raw = blob[KEY_SOURCES];
+	const fromNew = Array.isArray(raw) ? collectSources(raw) : [];
+	if (fromNew.length > 0) return fromNew;
+	return collectSources([blob[LEGACY_KEY_SOURCE]]);
+}
+/**
+* Normalize a settings-patch value for the `doorbellSources` multiselect
+* (a `string[]` of device ids from the form, or an already-shaped
+* `{deviceId}[]` / `number[]`) into the persisted extensible shape.
+*/
+function normalizeDoorbellSources(value) {
+	if (!Array.isArray(value)) return [];
+	return collectSources(value);
+}
+/**
+* Produce the next device-store blob after applying a doorbell-sources
+* patch: writes the normalized new shape and strips every legacy key so a
+* migrated camera never carries stale single-source fields.
 */
-var SOURCE_CAPS = [
-	"contact",
-	"flood",
-	"gas",
-	"carbon-monoxide",
-	"enum-sensor",
-	"event-emitter",
-	"switch"
-];
+function applyDoorbellSourcesPatch(current, patchValue) {
+	const next = { ...current };
+	delete next[LEGACY_KEY_SOURCE];
+	delete next[LEGACY_KEY_TRIGGER];
+	delete next[LEGACY_KEY_EVENT_TYPE];
+	next[KEY_SOURCES] = normalizeDoorbellSources(patchValue);
+	return next;
+}
+//#endregion
+//#region src/builtins/doorbell/virtual-doorbell.addon.ts
 /** Reload the camera→source assignment map at most this often (lazily,
 *  on trigger traffic). Covers devices/settings appearing after boot
 *  without a settings save. */
 var ASSIGNMENTS_TTL_MS = 6e4;
-var TRIGGER_LABELS = {
-	"contact-open": "Contact opens",
-	"contact-close": "Contact closes",
-	"switch-on": "Switch turns on",
-	event: "Device event"
-};
 /** Structural narrowing helper for untrusted bus payloads. */
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -171,26 +243,29 @@ function parseDoorbellSlice(slice) {
 /**
 * VirtualDoorbellAddon — WRAPPER over the `doorbell` capability.
 *
-* Turns any binary-ish device (contact sensor, switch, event emitter,
-* flood/gas/CO sensor) into a doorbell for a camera:
+* Turns any binary sensor or switch (contact, motion, flood/gas/CO/smoke,
+* vibration, tamper, generic binary, or a switch) into a doorbell for a
+* camera:
 *
 *   1. The operator binds the wrapper to a camera in the bindings UI
 *      (`defaultActive: false` — never auto-bound).
-*   2. Per-camera settings pick the SOURCE device + trigger
-*      (`contact-open` / `contact-close` / `switch-on` / `event`
-*      with an event-type match).
+*   2. In the camera's GENERAL settings (next to "Linked devices") the
+*      operator picks one or more SOURCE devices from a searchable list —
+*      that is the ONLY choice. The reaction is derived automatically per
+*      device type: a binary sensor rings when it goes active, a switch
+*      rings when it turns on (see `trigger-engine.ts`). The persisted
+*      shape (`doorbellSources: [{deviceId}]`) stays extensible for a
+*      future custom-trigger override.
 *   3. At runtime the addon watches `EventCategory.DeviceStateChanged`
-*      (contact/switch slice transitions — EDGE detected per trigger)
-*      and `EventCategory.EventEmitted` (event-emitter firings). On a
-*      matching, debounced trigger it emits
-*      `EventCategory.DoorbellOnPressed` with the CAMERA as source
-*      (`{deviceId: cameraId, timestamp}` — the same shape Reolink's
-*      native `emitDoorbellPressed` produces) and bumps the camera's
-*      `doorbell` runtime-state counters via the standard
-*      `deviceState.setCapSlice` plumbing.
+*      (binary/switch slice transitions — false→true edge detected). On a
+*      matching, debounced rise it emits `EventCategory.DoorbellOnPressed`
+*      with the CAMERA as source (`{deviceId: cameraId, timestamp}` — the
+*      same shape Reolink's native `emitDoorbellPressed` produces) and
+*      bumps the camera's `doorbell` runtime-state counters via the
+*      standard `deviceState.setCapSlice` plumbing.
 *
 * Fires ONLY for cameras where the wrapper is BOUND (checked against
-* `deviceManager.getBindings`) and a source device is configured.
+* `deviceManager.getBindings`) and at least one source device is configured.
 */
 var VirtualDoorbellAddon = class extends require_dist.BaseAddon {
 	engine;
@@ -208,9 +283,6 @@ var VirtualDoorbellAddon = class extends require_dist.BaseAddon {
 			if (!data) return;
 			this.handleStateChanged(data);
 		});
-		this.subscribe({ category: require_dist.EventCategory.EventEmitted }, (event) => {
-			this.handleEmitterEvent(event.data.deviceId, event.data.eventType);
-		});
 		return [{
 			capability: require_dist.doorbellCapability,
 			provider: {
@@ -222,16 +294,11 @@ var VirtualDoorbellAddon = class extends require_dist.BaseAddon {
 		}];
 	}
 	async handleStateChanged(data) {
-		if (data.capName !== "contact" && data.capName !== "switch") return;
+		if (!isSourceCap(data.capName)) return;
 		await this.ensureAssignments();
 		const cameraIds = this.engine.onStateSlice(data.deviceId, data.capName, data.slice);
 		for (const cameraId of cameraIds) await this.fireDoorbell(cameraId, Date.now());
 	}
-	async handleEmitterEvent(sourceDeviceId, eventType) {
-		await this.ensureAssignments();
-		const cameraIds = this.engine.onEmitterEvent(sourceDeviceId, eventType);
-		for (const cameraId of cameraIds) await this.fireDoorbell(cameraId, Date.now());
-	}
 	/**
 	* Ring the camera's virtual doorbell: verify the wrapper is BOUND to
 	* the camera, bump the `doorbell` runtime-state counters through the
@@ -312,13 +379,10 @@ var VirtualDoorbellAddon = class extends require_dist.BaseAddon {
 		const cameras = (await this.ctx.api.deviceManager.listAll.query({})).filter((d) => d.type === require_dist.DeviceType.Camera);
 		const assignments = [];
 		for (const camera of cameras) {
-			const settings = await this.readDeviceSettings(camera.id);
-			if (settings.sourceDeviceId === null) continue;
-			assignments.push({
+			const sources = await this.readDeviceSources(camera.id);
+			for (const source of sources) assignments.push({
 				cameraId: camera.id,
-				sourceDeviceId: settings.sourceDeviceId,
-				trigger: settings.trigger,
-				eventType: settings.eventType.length > 0 ? settings.eventType : null
+				sourceDeviceId: source.deviceId
 			});
 		}
 		this.engine.setAssignments(assignments);
@@ -346,21 +410,13 @@ var VirtualDoorbellAddon = class extends require_dist.BaseAddon {
 			return null;
 		}
 	}
-	async readDeviceSettings(deviceId) {
-		if (!this.ctx.settings) return {
-			sourceDeviceId: null,
-			trigger: DEFAULT_TRIGGER,
-			eventType: ""
-		};
-		const raw = await this.ctx.settings.readDeviceStore(deviceId);
-		const sourceRaw = raw[KEY_SOURCE];
-		const triggerRaw = raw[KEY_TRIGGER];
-		const eventTypeRaw = raw[KEY_EVENT_TYPE];
-		return {
-			sourceDeviceId: typeof sourceRaw === "number" && Number.isFinite(sourceRaw) && sourceRaw > 0 ? sourceRaw : null,
-			trigger: isDoorbellTrigger(triggerRaw) ? triggerRaw : DEFAULT_TRIGGER,
-			eventType: typeof eventTypeRaw === "string" ? eventTypeRaw : ""
-		};
+	/**
+	* The camera's configured doorbell sources, parsed tolerantly (new
+	* `doorbellSources` shape + legacy single-source migration).
+	*/
+	async readDeviceSources(deviceId) {
+		if (!this.ctx.settings) return [];
+		return parseDoorbellSources(await this.ctx.settings.readDeviceStore(deviceId));
 	}
 	/**
 	* Single-trip, non-throwing device lookup (mirrors snapshot's
@@ -381,109 +437,69 @@ var VirtualDoorbellAddon = class extends require_dist.BaseAddon {
 		}
 	}
 	/**
-	* Settings section for the device-detail page. Camera-only — the
-	* doorbell cap also applies to Button accessories (native providers),
-	* where a virtual-source picker is meaningless.
+	* Settings section for the device-detail page — contributed into the
+	* GENERAL settings surface (no `tab`, so it lands in the same tab as
+	* "Linked devices", ordered just after it). Camera-only: the doorbell
+	* cap also applies to Button accessories (native providers) where a
+	* virtual-source picker is meaningless.
+	*
+	* A SINGLE `multiselect` field lists every eligible binary/switch
+	* device; at ≥8 options the admin-ui form-builder auto-swaps it for the
+	* searchable multi-select (same idiom as "Linked devices"). The reaction
+	* is derived automatically per device type — no trigger/eventType
+	* controls.
 	*/
 	async buildDeviceSettingsContribution(deviceId) {
 		const device = await this.lookupDevice(deviceId);
 		if (device && device.type !== require_dist.DeviceType.Camera) return null;
-		const current = await this.readDeviceSettings(deviceId);
+		const sources = await this.readDeviceSources(deviceId);
 		return { sections: [{
 			id: "virtual-doorbell",
-			title: "Virtual Doorbell",
-			tab: "doorbell",
-			order: 70,
-			fields: [
-				{
-					type: "select",
-					key: KEY_SOURCE,
-					label: "Source device",
-					description: "Device whose state change rings this camera’s doorbell (contact, switch, sensor, event emitter).",
-					options: await this.listSourceDeviceOptions(),
-					required: true,
-					value: current.sourceDeviceId === null ? "none" : String(current.sourceDeviceId)
-				},
-				{
-					type: "select",
-					key: KEY_TRIGGER,
-					label: "Trigger",
-					description: "Which transition of the source device counts as a ring.",
-					options: DOORBELL_TRIGGERS.map((t) => ({
-						value: t,
-						label: TRIGGER_LABELS[t]
-					})),
-					required: true,
-					value: current.trigger
-				},
-				{
-					type: "text",
-					key: KEY_EVENT_TYPE,
-					label: "Event type",
-					description: "Only used when Trigger is 'Device event' — matched verbatim against the source device's emitted event type (e.g. press_short).",
-					value: current.eventType
-				}
-			]
+			title: "Virtual doorbell",
+			description: "Ring this camera’s doorbell when a chosen device becomes active — a contact opening, a switch turning on, or a sensor firing. Pick any binary sensor or switch below; the reaction is automatic per device type.",
+			order: 71,
+			fields: [{
+				type: "multiselect",
+				key: KEY_SOURCES,
+				label: "Trigger devices",
+				description: "Any of these becoming active rings this camera. Binary sensors ring when they go active; switches ring when they turn on.",
+				options: await this.listSourceDeviceOptions(),
+				value: sources.map((s) => String(s.deviceId))
+			}]
 		}] };
 	}
 	/**
-	* Cluster-wide picker options: every device whose BINDINGS expose one
-	* of the binary-ish source caps. Binding-sourced (not feature-flag
-	* sourced) because cap names are exactly what the runtime consumes.
+	* Cluster-wide picker options: every device whose BINDINGS expose one of
+	* the recognised binary/switch source caps. Binding-sourced (not
+	* feature-flag sourced) because cap names are exactly what the runtime
+	* consumes. Labelled `Name (Location)` (id carried in the option value)
+	* so the searchable multi-select matches on name, location, or id — the
+	* same shape "Linked devices" uses.
 	*/
 	async listSourceDeviceOptions() {
-		const none = {
-			value: "none",
-			label: "None"
-		};
 		try {
 			const [devices, allBindings] = await Promise.all([this.ctx.api.deviceManager.listAll.query({}), this.ctx.api.deviceManager.getAllBindings.query({})]);
 			const eligibleIds = /* @__PURE__ */ new Set();
 			for (const deviceBindings of allBindings) if (deviceBindings.entries.some((e) => SOURCE_CAPS.includes(e.capName))) eligibleIds.add(deviceBindings.deviceId);
-			return [none, ...devices.filter((d) => eligibleIds.has(d.id)).map((d) => ({
+			return devices.filter((d) => eligibleIds.has(d.id)).map((d) => ({
 				value: String(d.id),
-				label: `${d.name} (#${d.id})`
-			})).toSorted((a, b) => a.label.localeCompare(b.label))];
+				label: typeof d.location === "string" && d.location.length > 0 ? `${d.name} (${d.location})` : d.name
+			})).toSorted((a, b) => a.label.localeCompare(b.label));
 		} catch (err) {
 			this.ctx.logger.warn("virtual-doorbell: source-device enumeration failed", { meta: { error: require_dist.errMsg(err) } });
-			return [none];
+			return [];
 		}
 	}
 	async saveDeviceSettingsPatch(deviceId, patch) {
 		if (!this.ctx.settings) throw new Error("[virtual-doorbell] settings store unavailable — cannot persist per-device settings");
-		const next = { ...await this.ctx.settings.readDeviceStore(deviceId) };
-		if (KEY_SOURCE in patch) {
-			const parsed = parseSourceDeviceId(patch[KEY_SOURCE]);
-			if (parsed === null) delete next[KEY_SOURCE];
-			else next[KEY_SOURCE] = parsed;
+		if ("doorbellSources" in patch) {
+			const next = applyDoorbellSourcesPatch(await this.ctx.settings.readDeviceStore(deviceId), patch[KEY_SOURCES]);
+			await this.ctx.settings.writeDeviceStore(deviceId, next);
+			this.invalidateAssignments();
 		}
-		if (KEY_TRIGGER in patch) {
-			const v = patch[KEY_TRIGGER];
-			if (isDoorbellTrigger(v)) next[KEY_TRIGGER] = v;
-			else delete next[KEY_TRIGGER];
-		}
-		if (KEY_EVENT_TYPE in patch) {
-			const v = patch[KEY_EVENT_TYPE];
-			next[KEY_EVENT_TYPE] = typeof v === "string" ? v.trim() : "";
-		}
-		await this.ctx.settings.writeDeviceStore(deviceId, next);
-		this.invalidateAssignments();
 		return { success: true };
 	}
 };
-/**
-* Coerce the select value ('none' | numeric string | number) back to a
-* device id. The select field surfaces string values; a stored value
-* round-trips as a number.
-*/
-function parseSourceDeviceId(value) {
-	if (typeof value === "number" && Number.isFinite(value) && value > 0) return value;
-	if (typeof value === "string" && value !== "none" && value.trim().length > 0) {
-		const parsed = Number(value);
-		if (Number.isFinite(parsed) && parsed > 0) return parsed;
-	}
-	return null;
-}
 //#endregion
 exports.VirtualDoorbellAddon = VirtualDoorbellAddon;
 exports.default = VirtualDoorbellAddon;