@camstack/system 1.1.51 → 1.1.52

package/dist/builtins/doorbell/index.d.ts

@@ -0,0 +1,2 @@
+export { VirtualDoorbellAddon } from './virtual-doorbell.addon.js';
+export { VirtualDoorbellAddon as default } from './virtual-doorbell.addon.js';

package/dist/builtins/doorbell/index.js

@@ -0,0 +1,8 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+require("../../chunk-Cek0wNdY.js");
+const require_builtins_doorbell_virtual_doorbell_addon = require("./virtual-doorbell.addon.js");
+exports.VirtualDoorbellAddon = require_builtins_doorbell_virtual_doorbell_addon.VirtualDoorbellAddon;
+exports.default = require_builtins_doorbell_virtual_doorbell_addon.VirtualDoorbellAddon;

package/dist/builtins/doorbell/index.mjs

@@ -0,0 +1,2 @@
+import { VirtualDoorbellAddon } from "./virtual-doorbell.addon.mjs";
+export { VirtualDoorbellAddon, VirtualDoorbellAddon as default };

package/dist/builtins/doorbell/trigger-engine.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Pure trigger logic for the virtual-doorbell builtin — edge detection
+ * over runtime-state slices, event-emitter matching, and per-camera
+ * debounce. Extracted from the addon class (mirrors the
+ * `snapshot-coalescing.ts` split) so the behaviour is unit-testable
+ * without instantiating the addon or mocking the event bus.
+ */
+/** Trigger kinds an operator can configure per camera. */
+export type DoorbellTrigger = 'contact-open' | 'contact-close' | 'switch-on' | 'event';
+export declare const DOORBELL_TRIGGERS: readonly DoorbellTrigger[];
+/** Type guard for {@link DoorbellTrigger}. */
+export declare function isDoorbellTrigger(value: unknown): value is DoorbellTrigger;
+/**
+ * One camera's virtual-doorbell wiring: which source device drives it,
+ * on which trigger, and (for `trigger: 'event'`) which event type.
+ */
+export interface DoorbellAssignment {
+    readonly cameraId: number;
+    readonly sourceDeviceId: number;
+    readonly trigger: DoorbellTrigger;
+    /** Only meaningful when `trigger === 'event'` — matched verbatim
+     *  against the event-emitter `onEvent` payload `eventType`. */
+    readonly eventType: string | null;
+}
+/** Debounce window guarding against sensor chatter (reed-switch bounce,
+ *  duplicate HA state pushes). One ring per camera per window. */
+export declare const DEFAULT_DEBOUNCE_MS = 2000;
+/**
+ * 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.
+ */
+export declare class DoorbellTriggerEngine {
+    private assignments;
+    /** Last observed binary value keyed by `${deviceId}:${capName}`. */
+    private readonly lastValues;
+    /** Last fire timestamp per camera — debounce bookkeeping. */
+    private readonly lastFiredAt;
+    private readonly debounceMs;
+    private readonly now;
+    constructor(options?: {
+        readonly debounceMs?: number;
+        readonly now?: () => number;
+    });
+    /** Replace the full assignment set (rebuilt whenever settings change). */
+    setAssignments(assignments: readonly DoorbellAssignment[]): void;
+    getAssignments(): readonly DoorbellAssignment[];
+    /** True when any assignment references `deviceId` as its source. */
+    hasSource(deviceId: number): boolean;
+    /**
+     * Feed one `DeviceStateChanged` slice. Returns the camera ids whose
+     * doorbell should ring (already debounced). Baseline-only sightings
+     * and non-transitions return an empty array.
+     */
+    onStateSlice(deviceId: number, capName: string, slice: Record<string, unknown>): number[];
+    /**
+     * 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: number, eventType: string): number[];
+    private matchAndDebounce;
+}

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

@@ -0,0 +1,87 @@
+import { ProviderRegistration, BaseAddon } from '@camstack/types';
+interface VirtualDoorbellAddonConfig {
+    /** Per-camera debounce window (ms) against sensor chatter. */
+    readonly debounceMs: number;
+}
+/**
+ * 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:
+ *
+ *   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).
+ *   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.
+ *
+ * Fires ONLY for cameras where the wrapper is BOUND (checked against
+ * `deviceManager.getBindings`) and a source device is configured.
+ */
+export declare class VirtualDoorbellAddon extends BaseAddon<VirtualDoorbellAddonConfig> {
+    private readonly engine;
+    /** Monotonic guard: assignments are reloaded lazily on trigger traffic. */
+    private assignmentsLoadedAt;
+    private assignmentsLoading;
+    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
+     * canonical `deviceState.setCapSlice` write, and emit the typed
+     * `DoorbellOnPressed` event with the CAMERA as source — byte-shaped
+     * like a native firmware ring so every downstream consumer (UI
+     * toast, notifier rules, exporters) is agnostic to the origin.
+     */
+    private fireDoorbell;
+    /** True when THIS wrapper is the active `doorbell` binding for the camera. */
+    private isWrapperBound;
+    /**
+     * Lazily (re)build the camera→source assignment set from every
+     * camera's device store. TTL-bounded so devices/settings appearing
+     * after boot are picked up without a settings save; invalidated
+     * eagerly by `applyDeviceSettingsPatch`.
+     */
+    private ensureAssignments;
+    private loadAssignments;
+    private invalidateAssignments;
+    /**
+     * Status from the kernel-managed `doorbell` runtime-state slice —
+     * the wrapper keeps NO parallel counter fields (the slice is the
+     * single source of truth, persisted across restarts).
+     */
+    private getStatus;
+    private readDeviceSettings;
+    /**
+     * Single-trip, non-throwing device lookup (mirrors snapshot's
+     * `lookupDeviceMeta`). Null on any failure — callers fall back to
+     * rendering the section (better a spurious section than a thrown
+     * aggregator entry).
+     */
+    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.
+     */
+    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.
+     */
+    private listSourceDeviceOptions;
+    private saveDeviceSettingsPatch;
+}
+export default VirtualDoorbellAddon;

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

@@ -0,0 +1,489 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+require("../../chunk-Cek0wNdY.js");
+const require_dist = require("../../dist-BduBhv6N.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).
+*/
+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;
+}
+/** Extract the binary state carried by a contact / switch slice. */
+function sliceBinaryValue(capName, slice) {
+	const raw = capName === CONTACT_CAP ? slice["entryOpen"] : slice["on"];
+	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.
+*/
+var DoorbellTriggerEngine = class {
+	assignments = [];
+	/** Last observed binary value keyed by `${deviceId}:${capName}`. */
+	lastValues = /* @__PURE__ */ new Map();
+	/** Last fire timestamp per camera — debounce bookkeeping. */
+	lastFiredAt = /* @__PURE__ */ new Map();
+	debounceMs;
+	now;
+	constructor(options) {
+		this.debounceMs = options?.debounceMs ?? 2e3;
+		this.now = options?.now ?? Date.now;
+	}
+	/** Replace the full assignment set (rebuilt whenever settings change). */
+	setAssignments(assignments) {
+		this.assignments = [...assignments];
+	}
+	getAssignments() {
+		return this.assignments;
+	}
+	/** True when any assignment references `deviceId` as its source. */
+	hasSource(deviceId) {
+		return this.assignments.some((a) => a.sourceDeviceId === deviceId);
+	}
+	/**
+	* Feed one `DeviceStateChanged` slice. Returns the camera ids whose
+	* doorbell should ring (already debounced). Baseline-only sightings
+	* and non-transitions return an empty array.
+	*/
+	onStateSlice(deviceId, capName, slice) {
+		if (capName !== CONTACT_CAP && capName !== SWITCH_CAP) return [];
+		const value = sliceBinaryValue(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);
+	}
+	matchAndDebounce(predicate) {
+		const now = this.now();
+		const fired = [];
+		for (const assignment of this.assignments) {
+			if (!predicate(assignment)) continue;
+			const last = this.lastFiredAt.get(assignment.cameraId);
+			if (last !== void 0 && now - last < this.debounceMs) continue;
+			this.lastFiredAt.set(assignment.cameraId, now);
+			fired.push(assignment.cameraId);
+		}
+		return fired;
+	}
+};
+//#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";
+/**
+* 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.
+*/
+var SOURCE_CAPS = [
+	"contact",
+	"flood",
+	"gas",
+	"carbon-monoxide",
+	"enum-sensor",
+	"event-emitter",
+	"switch"
+];
+/** 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);
+}
+/**
+* Cast-free narrowing of the untyped `device.state-changed` payload
+* (the category is not part of the typed EventCatalog — subscribers
+* validate at the boundary).
+*/
+function parseDeviceStateChanged(data) {
+	if (!isRecord(data)) return null;
+	const deviceId = data["deviceId"];
+	const capName = data["capName"];
+	const slice = data["slice"];
+	if (typeof deviceId !== "number" || typeof capName !== "string") return null;
+	if (!isRecord(slice)) return null;
+	return {
+		deviceId,
+		capName,
+		slice
+	};
+}
+/** Narrow a raw `doorbell` runtime-state slice to counters (defaults on absence). */
+function parseDoorbellSlice(slice) {
+	const lastPressedAtRaw = slice?.["lastPressedAt"];
+	const countRaw = slice?.["pressCountSinceStart"];
+	return {
+		lastPressedAt: typeof lastPressedAtRaw === "number" ? lastPressedAtRaw : null,
+		pressCountSinceStart: typeof countRaw === "number" && Number.isFinite(countRaw) && countRaw >= 0 ? countRaw : 0
+	};
+}
+/**
+* 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:
+*
+*   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).
+*   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.
+*
+* Fires ONLY for cameras where the wrapper is BOUND (checked against
+* `deviceManager.getBindings`) and a source device is configured.
+*/
+var VirtualDoorbellAddon = class extends require_dist.BaseAddon {
+	engine;
+	/** Monotonic guard: assignments are reloaded lazily on trigger traffic. */
+	assignmentsLoadedAt = 0;
+	assignmentsLoading = null;
+	constructor() {
+		super({ debounceMs: 2e3 });
+		this.engine = new DoorbellTriggerEngine({ debounceMs: 2e3 });
+	}
+	async onInitialize() {
+		this.ctx.logger.info("Virtual doorbell wrapper initialized");
+		this.subscribe({ category: require_dist.EventCategory.DeviceStateChanged }, (event) => {
+			const data = parseDeviceStateChanged(event.data);
+			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: {
+				getStatus: (input) => this.getStatus(input.deviceId),
+				getDeviceSettingsContribution: (input) => this.buildDeviceSettingsContribution(input.deviceId),
+				getDeviceLiveContribution: async () => null,
+				applyDeviceSettingsPatch: (input) => this.saveDeviceSettingsPatch(input.deviceId, input.patch)
+			}
+		}];
+	}
+	async handleStateChanged(data) {
+		if (data.capName !== "contact" && data.capName !== "switch") 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
+	* canonical `deviceState.setCapSlice` write, and emit the typed
+	* `DoorbellOnPressed` event with the CAMERA as source — byte-shaped
+	* like a native firmware ring so every downstream consumer (UI
+	* toast, notifier rules, exporters) is agnostic to the origin.
+	*/
+	async fireDoorbell(cameraId, timestamp) {
+		if (!await this.isWrapperBound(cameraId)) {
+			this.ctx.logger.debug("virtual-doorbell: trigger matched but wrapper not bound — skipping", { tags: { deviceId: cameraId } });
+			return;
+		}
+		try {
+			const next = {
+				lastPressedAt: timestamp,
+				pressCountSinceStart: parseDoorbellSlice(await this.ctx.api.deviceState.getCapSlice.query({
+					deviceId: cameraId,
+					capName: require_dist.doorbellCapability.name
+				})).pressCountSinceStart + 1
+			};
+			await this.ctx.api.deviceState.setCapSlice.mutate({
+				deviceId: cameraId,
+				capName: require_dist.doorbellCapability.name,
+				slice: next
+			});
+		} catch (err) {
+			this.ctx.logger.warn("virtual-doorbell: runtime-state update failed", {
+				tags: { deviceId: cameraId },
+				meta: { error: require_dist.errMsg(err) }
+			});
+		}
+		this.ctx.eventBus.emit(require_dist.createEvent(require_dist.EventCategory.DoorbellOnPressed, {
+			type: "device",
+			id: cameraId,
+			deviceId: cameraId,
+			addonId: this.ctx.id
+		}, {
+			deviceId: cameraId,
+			timestamp
+		}));
+		this.ctx.logger.info("virtual-doorbell: pressed", {
+			tags: { deviceId: cameraId },
+			meta: { timestamp }
+		});
+	}
+	/** True when THIS wrapper is the active `doorbell` binding for the camera. */
+	async isWrapperBound(cameraId) {
+		try {
+			return (await this.ctx.api.deviceManager.getBindings.query({ deviceId: cameraId })).entries.some((entry) => entry.capName === require_dist.doorbellCapability.name && entry.kind === "wrapped" && entry.providerAddonId === this.ctx.id);
+		} catch (err) {
+			this.ctx.logger.debug("virtual-doorbell: getBindings failed — treating as unbound", {
+				tags: { deviceId: cameraId },
+				meta: { error: require_dist.errMsg(err) }
+			});
+			return false;
+		}
+	}
+	/**
+	* Lazily (re)build the camera→source assignment set from every
+	* camera's device store. TTL-bounded so devices/settings appearing
+	* after boot are picked up without a settings save; invalidated
+	* eagerly by `applyDeviceSettingsPatch`.
+	*/
+	async ensureAssignments() {
+		if (Date.now() - this.assignmentsLoadedAt < ASSIGNMENTS_TTL_MS) return;
+		if (this.assignmentsLoading) return this.assignmentsLoading;
+		this.assignmentsLoading = this.loadAssignments().then(() => {
+			this.assignmentsLoadedAt = Date.now();
+		}).catch((err) => {
+			this.ctx.logger.warn("virtual-doorbell: assignment reload failed", { meta: { error: require_dist.errMsg(err) } });
+		}).finally(() => {
+			this.assignmentsLoading = null;
+		});
+		return this.assignmentsLoading;
+	}
+	async loadAssignments() {
+		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({
+				cameraId: camera.id,
+				sourceDeviceId: settings.sourceDeviceId,
+				trigger: settings.trigger,
+				eventType: settings.eventType.length > 0 ? settings.eventType : null
+			});
+		}
+		this.engine.setAssignments(assignments);
+		this.ctx.logger.debug("virtual-doorbell: assignments loaded", { meta: { count: assignments.length } });
+	}
+	invalidateAssignments() {
+		this.assignmentsLoadedAt = 0;
+	}
+	/**
+	* Status from the kernel-managed `doorbell` runtime-state slice —
+	* the wrapper keeps NO parallel counter fields (the slice is the
+	* single source of truth, persisted across restarts).
+	*/
+	async getStatus(deviceId) {
+		try {
+			return parseDoorbellSlice(await this.ctx.api.deviceState.getCapSlice.query({
+				deviceId,
+				capName: require_dist.doorbellCapability.name
+			}));
+		} catch (err) {
+			this.ctx.logger.debug("virtual-doorbell: getCapSlice failed during getStatus", {
+				tags: { deviceId },
+				meta: { error: require_dist.errMsg(err) }
+			});
+			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 : ""
+		};
+	}
+	/**
+	* Single-trip, non-throwing device lookup (mirrors snapshot's
+	* `lookupDeviceMeta`). Null on any failure — callers fall back to
+	* rendering the section (better a spurious section than a thrown
+	* aggregator entry).
+	*/
+	async lookupDevice(deviceId) {
+		try {
+			const found = await this.ctx.api.deviceManager.getDevice.query({ deviceId });
+			return found ? { type: found.type } : null;
+		} catch (err) {
+			this.ctx.logger.debug("virtual-doorbell: getDevice failed during contribution", {
+				tags: { deviceId },
+				meta: { error: require_dist.errMsg(err) }
+			});
+			return null;
+		}
+	}
+	/**
+	* 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.
+	*/
+	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);
+		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
+				}
+			]
+		}] };
+	}
+	/**
+	* 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.
+	*/
+	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) => ({
+				value: String(d.id),
+				label: `${d.name} (#${d.id})`
+			})).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];
+		}
+	}
+	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 (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;