@camstack/addon-export-hap 1.2.26 → 1.2.28

package/dist/hap-export.addon.mjs

@@ -3070,6 +3070,9 @@ function handlePipeResult(left, next, ctx) {
 		fallback: left.fallback
 	}, ctx);
 }
+var $ZodPreprocess = /*@__PURE__*/ $constructor("$ZodPreprocess", (inst, def) => {
+	$ZodPipe.init(inst, def);
+});
 var $ZodReadonly = /*@__PURE__*/ $constructor("$ZodReadonly", (inst, def) => {
 	$ZodType.init(inst, def);
 	defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
@@ -5255,6 +5258,10 @@ function pipe(in_, out) {
 		out
 	});
 }
+var ZodPreprocess = /*@__PURE__*/ $constructor("ZodPreprocess", (inst, def) => {
+	ZodPipe.init(inst, def);
+	$ZodPreprocess.init(inst, def);
+});
 var ZodReadonly = /*@__PURE__*/ $constructor("ZodReadonly", (inst, def) => {
 	$ZodReadonly.init(inst, def);
 	ZodType.init(inst, def);
@@ -5313,6 +5320,13 @@ function _instanceof(cls, params = {}) {
 	};
 	return inst;
 }
+function preprocess(fn, schema) {
+	return new ZodPreprocess({
+		type: "pipe",
+		in: transform(fn),
+		out: schema
+	});
+}
 //#endregion
 //#region ../../node_modules/zod/v4/classic/compat.js
 /** @deprecated Use the raw string literal codes instead, e.g. "invalid_type". */
@@ -7589,7 +7603,7 @@ import { errMsg } from '@camstack/types'
 * Extract a human-readable message from an unknown error value.
 * Replaces the ubiquitous `errMsg(err)` pattern.
 */
-function errMsg$12(err) {
+function errMsg$15(err) {
 	if (err instanceof Error) return err.message;
 	if (typeof err === "string") return err;
 	return String(err);
@@ -13726,11 +13740,33 @@ var NotificationFormatSchema = _enum([
 * Named by INTENT, never by glyph. "check" would tie the vocabulary to one
 * renderer's icon set; "acknowledge" survives an adapter that draws it
 * differently.
+*
+* ── A TOKEN IS NOT A WIRE VALUE ─────────────────────────────────────
+*
+* These names are for US. **No adapter may forward one verbatim.** Each maps
+* the whole set onto its own renderer's vocabulary through a
+* `Record<NotificationActionIcon, string>` — a Record, never a lookup with a
+* fallback, so adding a member here fails every adapter's build until someone
+* decides its glyph, which is the only place that decision can be made
+* honestly.
+*
+* This paragraph is the bug. Zentik declared `actionIcons: true` and passed
+* `disarm` straight through; iOS feeds that string to
+* `UNNotificationActionIcon(systemImageName:)`, `disarm` is not an SF Symbol,
+* and every snooze and alarm button arrived BLANK. A pass-through is not a
+* mapping, and "the field is documented" is not "the value renders".
+*
+* Adding a member is TRAIN-BOUND. The enum lives in the published
+* `@camstack/server` closure and the cap seam validates against the HUB's copy,
+* so an addon that emits a token the running hub does not know does not lose an
+* icon — its whole `send` fails Zod validation and the notification never
+* arrives. Never emit a new token from an addon before the train carrying it.
 */
 var NotificationActionIconSchema = _enum([
 	"acknowledge",
 	"dismiss",
 	"silence",
+	"snooze",
 	"view",
 	"play",
 	"open",
@@ -13738,9 +13774,13 @@ var NotificationActionIconSchema = _enum([
 	"lock",
 	"unlock",
 	"arm",
+	"arm-home",
+	"arm-away",
+	"arm-night",
 	"disarm",
 	"light",
-	"alert"
+	"alert",
+	"camera"
 ]);
 /** A single tap-through action button. */
 var NotificationActionSchema = object({
@@ -13940,6 +13980,24 @@ method(object({}), array(TargetKindSchema)), method(object({}), array(TargetSche
 	targetId: string(),
 	enabled: boolean()
 }), _void(), { kind: "mutation" });
+new Set([
+	{
+		id: "person",
+		name: "Person"
+	},
+	{
+		id: "vehicle",
+		name: "Vehicle"
+	},
+	{
+		id: "animal",
+		name: "Animal"
+	},
+	{
+		id: "package",
+		name: "Package"
+	}
+].map((l) => l.id));
 var COCO_TO_MACRO = {
 	mapping: {
 		person: "person",
@@ -14737,6 +14795,8 @@ var NcSystemEventKindSchema = _enum([
 	"alarm-triggered",
 	"alarm-armed",
 	"alarm-disarmed",
+	"alarm-arming",
+	"alarm-arm-refused",
 	"camera-online",
 	"camera-offline",
 	"camera-disabled",
@@ -15945,7 +16005,87 @@ var MethodAccessSchema = _enum([
 var AllowedProviderSchema = union([literal("*"), array(string())]);
 var AllowedDevicesSchema = record(string(), union([literal("*"), array(string())]));
 var CapScopeSchema = _enum(["device", "system"]);
-var TokenScopeSchema = discriminatedUnion("type", [
+/**
+* DeviceSelector (scope model v3 — 2026-08-12).
+*
+* A `device` grant no longer carries a frozen list of deviceIds. It carries
+* a SELECTOR the matcher resolves against the live fleet, so the grant can be
+* DYNAMIC: a `types:['camera']` selector automatically covers a camera added
+* AFTER the grant was minted — no re-grant, no re-login.
+*
+*   - `all`       — every device in the deployment. The broad viewer/operator
+*     lever without a `category` grant (a `category` grant also covers device
+*     caps that carry no deviceId; `all` is specifically the device set).
+*   - `ids`       — an explicit deviceId list. This is what a v2 `device:[…]`
+*     grant migrates to (see {@link TokenScopeSchema}); STATIC — a new camera
+*     is NOT covered until the grant is edited.
+*   - `types`     — every device of a `DeviceType` (e.g. every `camera`).
+*     DYNAMIC. A device that changes type, or a new device of the type,
+*     re-resolves on the next request.
+*   - `locations` — every device whose operator-assigned `location` label is
+*     in the set (e.g. "Garden", "Front door"). DYNAMIC. A device with a
+*     null/unset location matches NO `locations` selector.
+*/
+var DeviceSelectorSchema = discriminatedUnion("kind", [
+	object({ kind: literal("all") }),
+	object({
+		kind: literal("ids"),
+		ids: array(number().int()).min(1)
+	}),
+	object({
+		kind: literal("types"),
+		types: array(_enum(DeviceType)).min(1)
+	}),
+	object({
+		kind: literal("locations"),
+		locations: array(string().min(1)).min(1)
+	})
+]);
+var DeviceTokenScopeSchema = object({
+	type: literal("device"),
+	/** The device SET this grant covers — resolved against the live fleet. */
+	selector: DeviceSelectorSchema,
+	access: array(MethodAccessSchema).min(1),
+	/**
+	* Whether a grant on a PARENT device transparently covers its accessory
+	* CHILDREN (siren / floodlight / PIR) via the persisted-parentage walk.
+	* Direction is parent → children ONLY.
+	*
+	* Absent → the matcher DERIVES it from the access flavour: `view`
+	* inherits (a camera viewer sees the camera's accessories), `create` /
+	* `delete` do NOT (actuating/removing a child is an explicit act the
+	* operator must grant on the child, not inherit from the parent). Set it
+	* explicitly to override that default per grant.
+	*/
+	includeLinked: boolean().optional()
+});
+/**
+* v2 → v3 lazy migration. A pre-v3 `device` grant carried
+* `targets: string[]` (stringified deviceIds); it rewrites to the equivalent
+* `selector: {kind:'ids', ids}`. Applied as a `preprocess` so it runs on
+* EVERY parse path — stored records AND the JWT-carried scope arrays
+* normalised at the request boundary ({@link normalizeTokenScopes} in
+* `device-selector.ts`). Chosen over a one-time DB migration because a
+* migration cannot reach a JWT already in a client's hands; parse-time
+* migration covers both without a flag day. No cast — the raw object is read
+* through `Reflect.get` (its static type is `unknown`).
+*/
+function migrateLegacyTokenScope(raw) {
+	if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return raw;
+	if (Reflect.get(raw, "type") !== "device") return raw;
+	if (Reflect.get(raw, "selector") !== void 0) return raw;
+	const targets = Reflect.get(raw, "targets");
+	if (!Array.isArray(targets)) return raw;
+	return {
+		type: "device",
+		selector: {
+			kind: "ids",
+			ids: targets.map((t) => typeof t === "string" ? Number(t) : t).filter((n) => typeof n === "number" && Number.isInteger(n))
+		},
+		access: Reflect.get(raw, "access")
+	};
+}
+var TokenScopeSchema = preprocess(migrateLegacyTokenScope, discriminatedUnion("type", [
 	object({
 		type: literal("category"),
 		target: CapScopeSchema,
@@ -15961,18 +16101,8 @@ var TokenScopeSchema = discriminatedUnion("type", [
 		target: string(),
 		access: array(MethodAccessSchema).min(1)
 	}),
-	object({
-		type: literal("device"),
-		/**
-		* One or more deviceIds (serialised as strings for wire-format
-		* consistency with the rest of the union). Matcher accepts if
-		* `input.deviceId` ∈ `targets`. Array shape avoids the row-explosion
-		* of one scope-per-device when granting access to a set of cameras.
-		*/
-		targets: array(string()).min(1),
-		access: array(MethodAccessSchema).min(1)
-	})
-]);
+	DeviceTokenScopeSchema
+]));
 object({
 	id: string(),
 	username: string(),
@@ -17969,10 +18099,26 @@ var detectionFpsField = {
 	default: 10,
 	step: 1
 };
+/**
+* The occupancy re-check interval. DEFAULT 300 s (2026-08-13 — was 30 s).
+*
+* The recheck is now on by default (a parked car is invisible to occupancy
+* rules until the stationary registry has been rebuilt by motion, which after a
+* restart may be never on a quiet camera). Each cycle re-subscribes a detection
+* session — an RTSP re-dial — so the switch is only affordable at a WIDE
+* interval: 300 s is ~12 re-dials an hour per camera, against 120 at the old
+* 30 s. A parked car is therefore counted within 5 minutes of a restart.
+*
+* Why not wider: `max` is 300 and raising it is TRAIN-BOUND, not addon-bound —
+* the host validates `attachCamera` against ITS copy of this schema, so a
+* runner asked for 600 would be rejected by the hub until a `@camstack/server`
+* carrying the wider bound is installed everywhere. 300 is the widest value
+* that ships with an addon deploy.
+*/
 var occupancyRecheckSecField = {
 	min: 0,
 	max: 300,
-	default: 30,
+	default: 300,
 	step: 5
 };
 var occupancyRecheckFramesField = {
@@ -18170,15 +18316,21 @@ var RunnerCameraConfigSchema = object({
 	*/
 	onboardMotionDrivesAnalyzer: boolean().default(true),
 	/**
-	* Master toggle for the occupancy re-check. When `false` (DEFAULT) the runner
-	* never arms the periodic recheck timer, regardless of `occupancyRecheckSec` —
-	* this is off by default because the recheck re-subscribes a detection session
-	* every N seconds while `watching`, a major source of pull-decoder re-dial
-	* churn (each cycle creates+tears a session → RTSP re-dial → latency). The
+	* Master toggle for the occupancy re-check. When `false` the runner never arms
+	* the periodic recheck timer, regardless of `occupancyRecheckSec`; the
 	* `occupancyRecheckSec` / `occupancyRecheckFrames` sliders only take effect
 	* (and only render) when this is enabled.
-	*/
-	occupancyRecheckEnabled: boolean().default(false),
+	*
+	* DEFAULT `true` since 2026-08-13 (was `false`). It was off because the
+	* recheck re-subscribes a detection session every N seconds while `watching`
+	* — each cycle creates+tears a session ⇒ an RTSP re-dial ⇒ latency, a major
+	* pull-decoder churn source. What that bought was a blind spot: a STATIONARY
+	* object is counted only while the stationary registry holds it, and the
+	* registry rebuilds from motion, so after a restart a parked car was invisible
+	* to every occupancy rule until something moved in front of it. The churn is
+	* now paid on the interval instead — see `occupancyRecheckSecField`.
+	*/
+	occupancyRecheckEnabled: boolean().default(true),
 	occupancyRecheckSec: number().min(occupancyRecheckSecField.min).max(occupancyRecheckSecField.max).default(occupancyRecheckSecField.default),
 	occupancyRecheckFrames: number().min(occupancyRecheckFramesField.min).max(occupancyRecheckFramesField.max).default(occupancyRecheckFramesField.default),
 	/**
@@ -20579,7 +20731,11 @@ object({
 	precision: number().int().min(0).max(10).optional()
 });
 DeviceType.Sensor;
-object({
+/**
+* Ambient illuminance reading in lux. Drives Home Assistant `sensor`
+* entries with `device_class: illuminance`.
+*/
+var AmbientLightSensorStatusSchema = object({
 	/** Current illuminance in lux (lx). */
 	lux: number().min(0),
 	/** Ms epoch when the slice was last updated. */
@@ -20852,7 +21008,11 @@ DeviceType.Camera, method(object({ deviceId: number() }), CameraCredentialsSchem
 	kind: "query",
 	auth: "admin"
 });
-object({
+/**
+* Carbon-monoxide alarm sensor. Drives Home Assistant `binary_sensor`
+* entries with `device_class: carbon_monoxide`. Push-driven.
+*/
+var CarbonMonoxideStatusSchema = object({
 	detected: boolean(),
 	/** Ms epoch of the last transition. 0 if never observed. */
 	lastChangedAt: number()
@@ -21140,7 +21300,19 @@ Object.values(DeviceType), method(object({
 	kind: "mutation",
 	auth: "admin"
 }), ConsumablesStatusSchema.extend({ lastFetchedAt: number() });
-object({
+/**
+* Door / window / opening / garage / valve contact sensor. Boolean
+* "is the entry currently open" with the timestamp of the last
+* transition. Drives Home Assistant `binary_sensor` entries whose
+* `device_class` is `door`, `window`, `opening`, `garage`, or
+* `garage_door` — and any future native integration that needs
+* the same semantics.
+*
+* Push-driven: providers update the slice on transition events from
+* the upstream source (HA WebSocket `state_changed`, ZWave
+* `notification` …). Consumers read the slice; no polling.
+*/
+var ContactStatusSchema = object({
 	/** True when the entry is open; false when closed. */
 	entryOpen: boolean(),
 	/** Ms epoch of the last open↔closed transition. 0 if never observed. */
@@ -21739,7 +21911,15 @@ object({
 	deviceId: number(),
 	status: FeatureProbeStatusSchema
 });
-object({
+/**
+* Water leak / moisture sensor. Boolean "is liquid currently
+* detected" with the timestamp of the last transition. Drives Home
+* Assistant `binary_sensor` entries with `device_class: moisture`,
+* and any future native flood sensor.
+*
+* Push-driven from the upstream source.
+*/
+var FloodStatusSchema = object({
 	/** True when leak is currently detected. */
 	flooded: boolean(),
 	/** Ms epoch of the last flooded↔dry transition. 0 if never observed. */
@@ -21793,7 +21973,15 @@ DeviceType.Humidifier, method(object({
 	kind: "mutation",
 	auth: "admin"
 });
-object({
+/**
+* Single-metric humidity reading. Drives Home Assistant `sensor`
+* entries with `device_class: humidity`.
+*
+* Unit normalisation: percent. The canonical display unit (`%`) is a
+* descriptor constant in the UI (ROLE_DESCRIPTOR), not stored in
+* `sourceInfo`.
+*/
+var HumiditySensorStatusSchema = object({
 	/** Current relative humidity, 0..100. */
 	percent: number().min(0).max(100),
 	/** Ms epoch when the slice was last updated. */
@@ -22415,7 +22603,7 @@ method(_void(), ListResultSchema), method(_void(), PreferredSchema), method(obje
 	*  tunnel always emits `https://` regardless. */
 	scheme: _enum(["http", "https"]).optional()
 }), GetConnectionEndpointsResultSchema), method(_void(), NotificationEndpointSchema), method(object({ baseUrl: string().nullable() }), NotificationEndpointSchema, { kind: "mutation" }), method(_void(), AllowedAddressesSchema), method(AllowedAddressesSchema, object({ success: literal(true) }), { kind: "mutation" }), method(_void(), AllowedAddressesSchema, { kind: "mutation" });
-object({
+var LockControlStatusSchema = object({
 	/** Lifecycle state of the lock. `jammed` means the motor reported
 	*  failure to reach the target — operator intervention required. */
 	state: _enum([
@@ -22753,7 +22941,19 @@ authKey: string().optional() }), object({
 	/** Human-readable error when `ok: false`. */
 	error: string().optional()
 }), { kind: "mutation" });
-object({
+/**
+* Hardware / firmware motion sensor cap — binary detected state plus
+* a timestamp of the last observation. Distinct from
+* `motion-detection.cap.ts` which owns the LOCAL ML motion pipeline;
+* `motion` is the lightweight readout from on-camera motion (Reolink
+* `GetMdState`, Baichuan push `type: motion`, ONVIF analytics).
+*
+* Native-motion providers also fan out to `detection.camera-native`
+* with `source: 'onboard'` so cross-cutting system services
+* (alert-center, advanced-notifier) can subscribe once and receive
+* motion from every camera.
+*/
+var MotionStatusSchema = object({
 	detected: boolean(),
 	/** Ms epoch of the last detected-true observation. Null if never detected. */
 	lastDetectedAt: number().nullable(),
@@ -23865,7 +24065,7 @@ var GpsLocationSchema = object({
 	/** Reported accuracy in meters (lower = better). */
 	accuracyMeters: number().nonnegative()
 });
-object({
+var PresenceStatusSchema = object({
 	/** `home` / `not_home` / any user-defined zone name. */
 	state: string(),
 	/** Optional textual location label (zone name, city, address). Null
@@ -24281,7 +24481,7 @@ method(object({
 	toMs: number()
 }), RecordingAvailabilitySchema, {
 	kind: "query",
-	auth: "admin"
+	auth: "protected"
 }), method(object({
 	deviceId: number(),
 	fromMs: number(),
@@ -24289,14 +24489,14 @@ method(object({
 	tzOffsetMinutes: number()
 }), RecordingDaysSchema, {
 	kind: "query",
-	auth: "admin"
+	auth: "protected"
 }), method(object({
 	deviceId: number(),
 	fromMs: number(),
 	toMs: number()
 }), RecordingManifestSchema, {
 	kind: "query",
-	auth: "admin"
+	auth: "protected"
 }), method(object({}), RecordingStorageUsageSchema, {
 	kind: "query",
 	auth: "admin"
@@ -24825,7 +25025,16 @@ DeviceType.Script, method(object({
 	kind: "mutation",
 	auth: "admin"
 });
-object({
+/**
+* Smoke alarm sensor — boolean "is smoke currently detected" with
+* timestamp of the last transition. Drives Home Assistant
+* `binary_sensor` entries with `device_class: smoke`.
+*
+* Push-driven: a smoke event is critical, so the slice updates
+* immediately on the upstream signal. Auto-clearing back to false is
+* provider-controlled (some alarms latch until manually reset).
+*/
+var SmokeStatusSchema = object({
 	detected: boolean(),
 	/** Ms epoch of the last transition. 0 if never observed. */
 	lastChangedAt: number()
@@ -25034,7 +25243,23 @@ object({
 	lastChangedAt: number()
 });
 DeviceType.Sensor;
-object({
+/**
+* Single-metric temperature reading. Drives Home Assistant `sensor`
+* entries with `device_class: temperature` and any future native
+* thermometer.
+*
+* Unit normalisation: providers convert to Celsius before storing.
+* The slice value is always Celsius so cross-cap aggregators
+* (climate-control's `currentTemp`, energy analytics) can compose
+* without per-source unit fixups. The canonical display unit (`°C`) is
+* a descriptor constant in the UI (ROLE_DESCRIPTOR), not stored in
+* `sourceInfo`.
+*
+* Status `lastFetchedAt` lets staleness-aware consumers detect a
+* frozen feed (provider hung) distinct from a "temperature hasn't
+* changed" steady state.
+*/
+var TemperatureSensorStatusSchema = object({
 	/** Current temperature in Celsius. */
 	celsius: number(),
 	/** Ms epoch when the slice was last updated (push or poll). */
@@ -31295,6 +31520,1678 @@ Object.freeze({
 		access: "create"
 	}
 });
+Object.freeze({
+	"accessories.setChildHidden": [{
+		name: "childDeviceId",
+		form: "single",
+		optional: false
+	}, {
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"addonSettings.getDeviceSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"addonSettings.updateDeviceSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"alarmPanel.arm": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"alarmPanel.disarm": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"alarmPanel.trigger": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"audioAnalysis.resolveDeviceSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"audioAnalyzer.classify": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"audioMetrics.getCurrentSnapshot": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"audioMetrics.getHistory": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"automationControl.disable": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"automationControl.enable": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"automationControl.trigger": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"battery.wakeForStream": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"brightness.setBrightness": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"button.press": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"cameraCredentials.getCredentials": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"cameraStreams.getBrokerStreams": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"cameraStreams.getCameraStreams": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"cameraStreams.getProfileRtspEntries": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"cameraStreams.getRtspEntries": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"cameraStreams.pickStream": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"climateControl.setFanMode": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"climateControl.setMode": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"climateControl.setPreset": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"climateControl.setSwingHorizontal": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"climateControl.setSwingVertical": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"climateControl.setTarget": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"climateControl.setTargetHumidity": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"climateControl.setTargetRange": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"color.setColor": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"consumables.reset": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"control.setValue": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"cover.close": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"cover.open": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"cover.setPosition": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"cover.setTiltPosition": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"cover.stop": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"dayNight.getOptions": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"dayNight.setSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"decoder.createSession": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"deviceAdoption.release": [{
+		name: "camDeviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceAdoption.resync": [{
+		name: "camDeviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceDiscovery.adoptDevice": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceDiscovery.listDiscovered": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceDiscovery.refreshDiscovery": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceDiscovery.releaseDevice": [{
+		name: "childDeviceId",
+		form: "single",
+		optional: false
+	}, {
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.adoptionRelease": [{
+		name: "camDeviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.adoptionResync": [{
+		name: "camDeviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.applyInitialMeta": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}, {
+		name: "linkDeviceId",
+		form: "single",
+		optional: true
+	}],
+	"deviceManager.disable": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.enable": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.getBindings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.getChildren": [{
+		name: "parentDeviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.getConfigSchema": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.getDevice": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.getDeviceAggregate": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.getDeviceLiveInfoAggregate": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.getDeviceSettingsAggregate": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.getDeviceStatusAggregate": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.getDeviceStatusAggregateBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
+	"deviceManager.getLinkedDevices": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.getSettingsSchema": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.getStreamProfileMap": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.getStreamSources": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.getWireableFields": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.loadConfig": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.loadMeta": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.loadRuntimeState": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.persistConfig": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.probeStreams": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.registerDevice": [{
+		name: "parentDeviceId",
+		form: "single",
+		optional: true
+	}],
+	"deviceManager.remove": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.removeDevice": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.runDeviceAction": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.setChildLayout": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.setDisabled": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.setDisplay": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.setIntegrationId": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.setLinkDeviceId": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}, {
+		name: "linkDeviceId",
+		form: "single",
+		optional: true
+	}],
+	"deviceManager.setLocation": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.setMetadata": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.setName": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.setPrimaryChildEntityId": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.setRole": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.setStreamProfileMap": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.setType": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.setWrapperActive": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.testField": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.updateConfig": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.updateDeviceField": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.updateDeviceFieldsBatch": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceOps.getConfigEntries": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceOps.getRawState": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceOps.getSettingsSchema": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceOps.getStreamSources": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceOps.removeDevice": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceOps.runAction": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceOps.setConfig": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceState.getCapSlice": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceState.getSnapshot": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceState.setCapSlice": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"events.getEventClipUrl": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"events.getEvents": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"events.getEventThumbnail": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"faceGallery.getFaceByTrack": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"faceGallery.listRecentFaces": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"fanControl.setDirection": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"fanControl.setOscillating": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"fanControl.setPercentage": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"fanControl.setPreset": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"humidifier.setMode": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"humidifier.setOn": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"humidifier.setTargetHumidity": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"imageSettings.getOptions": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"imageSettings.setSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"intercom.endTalkSession": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"intercom.handleAnswer": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"intercom.pushTalkAudio": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"intercom.startSession": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"intercom.startTalkSession": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"intercom.stopSession": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"lawnMowerControl.dock": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"lawnMowerControl.pause": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"lawnMowerControl.startMowing": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"lockControl.lock": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"lockControl.open": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"lockControl.unlock": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.next": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.pause": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.play": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.playMedia": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.previous": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.seek": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.selectSource": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.setMute": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.setRepeat": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.setShuffle": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.setVolume": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.stop": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"motion.isDetected": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"motionDetection.analyze": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"motionDetection.removeCamera": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"motionTrigger.setMotionTrigger": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"motionZones.getOptions": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"motionZones.setZone": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"nativeObjectDetection.setEnabled": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"networkQuality.getDeviceStats": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"networkQuality.reportClientStats": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"notificationRules.setDeviceMuted": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"notifier.cancel": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"notifier.send": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"osd.setOverlay": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"osdManager.clearSlotBinding": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"osdManager.copyDeviceConfiguration": [{
+		name: "sourceDeviceId",
+		form: "single",
+		optional: false
+	}, {
+		name: "targetDeviceId",
+		form: "single",
+		optional: false
+	}],
+	"osdManager.getDeviceOsd": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"osdManager.getSourceCatalog": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"osdManager.previewSlot": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"osdManager.renderDevice": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"osdManager.setSlotBinding": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"petFeeder.callPet": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"petFeeder.cancelFeed": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"petFeeder.feed": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"petFeeder.markFoodReplenished": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"petFeeder.playSound": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"petFeeder.resetDesiccant": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"petFeeder.setChildLock": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"petFeeder.setFeedSound": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"petFeeder.setIndicatorLight": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"petFeeder.setVolume": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.clearTracks": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.completeRetrainTrack": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.deleteDeviceEvents": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.deleteTracks": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.deselectRetrainFrame": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.getActiveTracks": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.getAudioEvents": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.getEventDensity": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.getKeyEvents": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.getMotionEvents": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.getObjectEvents": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.getRetrainExportUrl": [{
+		name: "deviceIds",
+		form: "array",
+		optional: true
+	}],
+	"pipelineAnalytics.getSensorEvents": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.getTrack": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.getTrainingExportSummary": [{
+		name: "deviceIds",
+		form: "array",
+		optional: true
+	}],
+	"pipelineAnalytics.getTrainingExportUrl": [{
+		name: "deviceIds",
+		form: "array",
+		optional: true
+	}],
+	"pipelineAnalytics.listEventKinds": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.listEventKindsBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
+	"pipelineAnalytics.listOpsLog": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"pipelineAnalytics.listRecentTracks": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
+	"pipelineAnalytics.listRetrainStaging": [{
+		name: "deviceIds",
+		form: "array",
+		optional: true
+	}],
+	"pipelineAnalytics.listTracks": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.proposeRetrainAnnotations": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.pruneEventsBefore": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.pruneTracksBefore": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.rebuildObjectEmbeddings": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"pipelineAnalytics.restageRetrainTrack": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.saveRetrainAnnotations": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.searchObjectEvents": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"pipelineAnalytics.selectRetrainFrames": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.setTrackFlags": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.wipeAllAnalytics": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineExecutor.runPipeline": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"pipelineExecutor.runPipelineBatch": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"pipelineOrchestrator.assignAudio": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.assignPipeline": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.getAudioAssignment": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.getCameraMetrics": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.getCameraSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.getCameraStatus": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.getCameraStatuses": [{
+		name: "deviceIds",
+		form: "array",
+		optional: true
+	}],
+	"pipelineOrchestrator.getCameraStepOverrides": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.getCameraSwitches": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.getPipelineAssignment": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.getPipelineDevicePin": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.resolvePipeline": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.setCameraPipelineForAgent": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.setCameraStepOverride": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.setCameraStepToggle": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.setCameraSwitch": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.setPipelineDevicePin": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.unassignAudio": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.unassignPipeline": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineRunner.attachCamera": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineRunner.detachCamera": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineRunner.getCameraMetrics": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineRunner.reportMotion": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineRunner.runDetailSubtree": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineRunner.runStatelessStep": [{
+		name: "sourceDeviceId",
+		form: "single",
+		optional: false
+	}],
+	"plateGallery.getPlateByTrack": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"plateGallery.listPlates": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"privacyMask.getOptions": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"privacyMask.setAudioEnabled": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"privacyMask.setMask": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptz.continuousMove": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptz.deletePreset": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptz.getOptions": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptz.getPosition": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptz.getPresets": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptz.goHome": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptz.goToPreset": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptz.move": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptz.savePreset": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptz.setAutofocus": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptz.stop": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptzAutotrack.getSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptzAutotrack.getStatus": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptzAutotrack.setEnabled": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptzAutotrack.setSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"reboot.reboot": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.deleteFootprint": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.getAvailability": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.getDaysWithRecordings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.getDeviceConfig": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.getPlaybackManifest": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.listOpsLog": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"recording.locateSegment": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.pruneFootage": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.readGopBytes": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.readSegmentBytes": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.relocateFootage": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"recording.renderClip": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.renderGif": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.rescanStorage": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.setDeviceConfig": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.startStorageMigrationMove": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"recordingExport.createExport": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recordingExport.listExports": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"sceneMonitor.captureReference": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"sceneMonitor.createScene": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"sceneMonitor.deleteReference": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"sceneMonitor.deleteScene": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"sceneMonitor.listScenes": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"sceneMonitor.recheckNow": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"sceneMonitor.updateScene": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"scriptRunner.run": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"scriptRunner.stop": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"snapshot.getSnapshot": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"snapshot.getSnapshotOverview": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
+	"snapshot.invalidateCache": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamBroker.acquireEgressTranscode": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamBroker.assignProfile": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamBroker.getDeviceAudioMute": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamBroker.getStreamWithCodec": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamBroker.produceEventMedia": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamBroker.publishCameraStream": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamBroker.renderPreBufferClip": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamBroker.restartProfile": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamBroker.retractCameraStream": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamBroker.setDeviceAudioMute": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamBroker.unassignProfile": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamCatalog.getCatalog": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamParams.getConfigSchema": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamParams.getOptions": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamParams.setProfile": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"switch.setState": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"vacuumControl.locate": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"vacuumControl.pause": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"vacuumControl.returnToBase": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"vacuumControl.setFanSpeed": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"vacuumControl.start": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"vacuumControl.stop": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"valve.close": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"valve.open": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"valve.setPosition": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"valve.stop": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"videoclips.getClipPlayback": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"videoclips.listClips": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"waterHeater.setAway": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"waterHeater.setOperationMode": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"waterHeater.setTargetTemp": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"webrtcSession.addIceCandidate": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"webrtcSession.closeSession": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"webrtcSession.createSession": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"webrtcSession.getIceCandidates": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"webrtcSession.getSessionState": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"webrtcSession.handleAnswer": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"webrtcSession.handleOffer": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"webrtcSession.hasAdaptiveBitrate": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"webrtcSession.listStreams": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"zoneAnalytics.getCameraHistory": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"zoneAnalytics.getCurrentSnapshot": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"zoneAnalytics.getUnzonedHistory": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"zoneAnalytics.getZoneHistory": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"zoneRules.listRules": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"zoneRules.setRules": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"zones.addZone": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"zones.listZones": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"zones.removeZone": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"zones.updateZone": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}]
+});
 Object.freeze({
 	"broker": "broker",
 	"device-export": "device-export",
@@ -32014,7 +33911,7 @@ var Fmp4FragmentChild = class {
 				meta: {
 					sourceId: this.args.sourceId,
 					decodeHwAccel: requested,
-					error: errMsg$12(err)
+					error: errMsg$15(err)
 				}
 			});
 			this.killChild();
@@ -32193,7 +34090,7 @@ var Fmp4FragmentChild = class {
 				tags: { deviceId: this.args.deviceId },
 				meta: {
 					sourceId: this.args.sourceId,
-					error: errMsg$12(err)
+					error: errMsg$15(err)
 				}
 			});
 		}
@@ -78538,7 +80435,7 @@ function clearPairingFiles(accessoryUuid, logger) {
 }
 //#endregion
 //#region src/hap-setup-uri.ts
-function errMsg$11(e) {
+function errMsg$14(e) {
 	return e instanceof Error ? e.message : String(e);
 }
 /**
@@ -78565,11 +80462,79 @@ function firstExposedAccessorySetupUri(exposed, logger) {
 		try {
 			return first.setupURI();
 		} catch (err) {
-			logger.debug("export-hap: setupURI failed on first exposed accessory", { meta: { error: errMsg$11(err) } });
+			logger.debug("export-hap: setupURI failed on first exposed accessory", { meta: { error: errMsg$14(err) } });
 			return;
 		}
 	}
 }
+//#endregion
+//#region src/mappers/builders/accessory-info.ts
+/**
+* `Service.AccessoryInformation` — the manufacturer / model / firmware /
+* serial block every HomeKit accessory carries.
+*
+* One implementation for both accessory shapes (camera and generic): the
+* fields come from the device's own metadata either way, and a second copy
+* would be a second answer to "what serial does this device publish".
+* Metadata is best-effort — a device that cannot answer still publishes.
+*/
+async function populateAccessoryInfo(accessory, proxy, displayName, modelFallback) {
+	const info = accessory.getService(import_dist.Service.AccessoryInformation);
+	if (!info) return;
+	try {
+		const device = await proxy.deviceManager?.getDevice({});
+		const metadata = readMetadata(device);
+		info.setCharacteristic(import_dist.Characteristic.Name, device?.name ?? displayName);
+		info.setCharacteristic(import_dist.Characteristic.Manufacturer, stringOr(metadata?.manufacturer, "CamStack"));
+		info.setCharacteristic(import_dist.Characteristic.Model, stringOr(metadata?.model, modelFallback));
+		info.setCharacteristic(import_dist.Characteristic.FirmwareRevision, stringOr(metadata?.firmware, "0.0.0"));
+		info.setCharacteristic(import_dist.Characteristic.SerialNumber, stringOr(metadata?.sn, `camstack-${proxy.deviceId}`));
+	} catch {}
+}
+/** The four fields this module reads, or `null` — the device record's
+*  `metadata` is an open bag and nothing else here depends on its shape. */
+function readMetadata(device) {
+	const metadata = device?.metadata;
+	if (metadata === null || typeof metadata !== "object") return {};
+	const entries = new Map(Object.entries(metadata));
+	return {
+		model: stringOrNull(entries.get("model")),
+		manufacturer: stringOrNull(entries.get("manufacturer")),
+		firmware: stringOrNull(entries.get("firmware")),
+		sn: stringOrNull(entries.get("sn"))
+	};
+}
+function stringOrNull(value) {
+	return typeof value === "string" ? value : null;
+}
+function stringOr(value, fallback) {
+	return typeof value === "string" && value.length > 0 ? value : fallback;
+}
+//#endregion
+//#region src/mappers/builders/generic/characteristic-update.ts
+/**
+* Parse `status` with the capability's OWN Zod schema and turn it into
+* characteristic writes.
+*
+* Duck-typing the payload here would be the second source of truth about what a
+* cap reports; the schema is the first and only one. A payload that does not
+* match yields NO updates — never a partial or invented value — and the caller
+* logs the drop, because a sensor that silently stops moving is
+* indistinguishable from a sensor that never changed.
+*
+* Rows `.pick()` only the fields they read, so a provider omitting a timestamp
+* cannot silence a sensor.
+*/
+function reader(schema, toUpdates) {
+	return (status) => {
+		const parsed = schema.safeParse(status);
+		return parsed.success ? toUpdates(parsed.data) : [];
+	};
+}
+/** Push every update onto `service`. */
+function applyUpdates(service, updates) {
+	for (const update of updates) service.updateCharacteristic(update.characteristic, update.value);
+}
 /**
 * hap-nodejs' `checkName` regex, verbatim.
 *
@@ -78706,6 +80671,92 @@ function titleCase(raw) {
 	return raw.split(/[-_\s]+/u).filter((part) => part.length > 0).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
 }
 //#endregion
+//#region src/mappers/builders/service-label.ts
+/**
+* The ONE place a secondary service on the camera accessory gets its label.
+*
+* A "secondary service" here is a Switch or Lightbulb published alongside the
+* camera on the same accessory — the privacy switch, each accessory child
+* (siren, floodlight), each PTZ action. iOS Home renders these as their own
+* controls, and the operator has seen them as "Interruttore 1", "Interruttore
+* 2" through three separate rounds of fixes.
+*
+* ## Why `Name` alone cannot rename anything
+*
+* Two facts about hap-nodejs 2.1.7, both measured against the installed copy
+* rather than reasoned about:
+*
+*  1. `accessory.addService(Type, displayName, subtype)` ALREADY writes
+*     `displayName` to `Characteristic.Name` (`Service` constructor). So every
+*     round of this bug — including the one that moved the label onto
+*     `ConfiguredName` — shipped with `Name` correctly set. "iOS had no name
+*     to render" was never true.
+*  2. The mDNS configuration number (`c#`) is a sha1 over
+*     `internalHAPRepresentation(false)`, which OMITS characteristic VALUES.
+*     Changing the string in `Name` therefore does not bump `c#`, a paired
+*     controller gets no signal to re-read `/accessories`, and the name it
+*     cached at first enumeration stands forever.
+*
+* `Name` is also declared `pr` only — paired read, no write, no notify. It is
+* the seed a controller seeds its database from once; it is not a channel.
+*
+* ## Why `ConfiguredName`
+*
+* `ConfiguredName` (`000000E3`) is declared `pr | pw | ev` — the only name
+* characteristic a controller may write and may subscribe to. It is what iOS
+* 16+ reads for a service the user can rename, and adding it CHANGES the
+* accessory structure, so `c#` does bump and the controller re-reads.
+*
+* It was removed once because hap-nodejs logged
+*
+* ```
+* Characteristic not in required or optional characteristic section for
+* service Switch. Adding anyway.
+* ```
+*
+* That line is a WARNING, not a rejection: `Service.getCharacteristic` calls
+* `addCharacteristic` unconditionally and only then emits the warning. The
+* characteristic was always present and always published. hap-nodejs'
+* per-service optional lists simply predate `ConfiguredName` being valid on
+* any service.
+*
+* Registering it with {@link Service.addOptionalCharacteristic} first takes
+* the branch above the warning, so the accessory still builds with ZERO
+* characteristic warnings — which is what `service-naming.spec.ts` asserts.
+*
+* ## Scope: EVERY service, including the sensors
+*
+* An earlier round applied this to Switch- and Lightbulb-shaped services only,
+* on the theory that `Service.MotionSensor` and `Service.Battery` are not
+* separately named tiles in iOS Home and that naming them would be a guess.
+*
+* That theory was never measured, and it had a cost: it left services on the
+* accessory whose name a paired controller could never be told about, and it
+* made "did `ConfiguredName` fix the operator's 'Interruttore N'?" unanswerable
+* — a negative result on a partial application proves nothing about the
+* mechanism. Every service this addon publishes now carries both
+* characteristics, on the camera accessory and on the generic one.
+*
+* The reasoning above is mechanism, not measurement: it says why `Name` alone
+* CANNOT work and why `ConfiguredName` is the only characteristic that can. It
+* does not prove iOS renders it on every service shape. That is an observation
+* only a re-paired controller can make — and after a change like this one, the
+* controller must be re-paired, because a cached accessory database is exactly
+* what the whole mechanism is about.
+*/
+/**
+* Publish `name` as both the immutable `Name` and the controller-visible
+* `ConfiguredName` of `service`.
+*
+* `name` must already be HAP-valid — build it with `service-names.ts`, which
+* cannot return a string hap-nodejs' `checkName` would warn about.
+*/
+function applyServiceLabel(service, name) {
+	service.setCharacteristic(import_dist.Characteristic.Name, name);
+	if (!service.optionalCharacteristics.some((characteristic) => characteristic.UUID === import_dist.Characteristic.ConfiguredName.UUID)) service.addOptionalCharacteristic(import_dist.Characteristic.ConfiguredName);
+	service.setCharacteristic(import_dist.Characteristic.ConfiguredName, name);
+}
+//#endregion
 //#region src/mappers/builders/battery.ts
 /**
 * Battery builder — surfaces a battery-operated camera's power state
@@ -78715,34 +80766,56 @@ function titleCase(raw) {
 * subscribes to the runtime-state slice so iOS Home reflects level /
 * charging changes pushed by the firmware without a poll loop.
 *
+* The status→characteristic mapping is {@link batteryCharacteristicUpdates},
+* exported because the generic (non-camera) export path publishes the same
+* `Service.Battery` from the same cap — one derivation, two accessory shapes.
+*
+* Skipped silently when the `battery` cap is not bound — caller checks
+* cap presence before invoking this builder (see `camera-accessory.ts`).
+*/
+var LOW_BATTERY_THRESHOLD_PCT = 20;
+/**
 * Mapping:
 *  - `BatteryStatus.percentage` (0..100) → `Characteristic.BatteryLevel`
 *  - `BatteryStatus.charging`:
 *      `'none'` → `ChargingState.NOT_CHARGING`
 *      `'dc' | 'solar'` → `ChargingState.CHARGING`
 *  - `percentage <= LOW_BATTERY_THRESHOLD_PCT` → `StatusLowBattery.LOW`
-*
-* Skipped silently when the `battery` cap is not bound — caller checks
-* cap presence before invoking this builder (see `camera-accessory.ts`).
 */
-var LOW_BATTERY_THRESHOLD_PCT = 20;
+var batteryCharacteristicUpdates = reader(BatteryStatusSchema.pick({ percentage: true }).extend({ charging: BatteryStatusSchema.shape.charging.optional() }), (status) => {
+	const pct = Math.max(0, Math.min(100, Math.round(status.percentage)));
+	return [
+		{
+			characteristic: import_dist.Characteristic.BatteryLevel,
+			value: pct
+		},
+		...status.charging === void 0 ? [] : [{
+			characteristic: import_dist.Characteristic.ChargingState,
+			value: status.charging === "none" ? import_dist.Characteristic.ChargingState.NOT_CHARGING : import_dist.Characteristic.ChargingState.CHARGING
+		}],
+		{
+			characteristic: import_dist.Characteristic.StatusLowBattery,
+			value: pct <= LOW_BATTERY_THRESHOLD_PCT ? import_dist.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW : import_dist.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL
+		}
+	];
+});
 async function buildBattery(bctx) {
 	const { ctx, accessory, proxy, numericDeviceId, displayName } = bctx;
 	const log = ctx.logger.withTags({ deviceId: numericDeviceId });
-	const service = accessory.addService(import_dist.Service.Battery, hapServiceName([displayName], `Camera ${numericDeviceId}`));
+	const label = hapServiceName([displayName], `Camera ${numericDeviceId}`);
+	const service = accessory.addService(import_dist.Service.Battery, label);
+	applyServiceLabel(service, label);
 	try {
 		const status = await proxy.battery?.getStatus({});
-		if (status) applyToService(service, status);
+		if (status !== void 0 && status !== null) applyToService(service, status);
 	} catch (err) {
-		log.debug("export-hap: battery getStatus hydrate failed (non-fatal)", { meta: { error: errMsg$10(err) } });
+		log.debug("export-hap: battery getStatus hydrate failed (non-fatal)", { meta: { error: errMsg$13(err) } });
 	}
 	const unsubscribes = [];
 	if (proxy.state.battery) {
 		const unsub = proxy.state.battery.subscribe((value) => {
 			if (!value) return;
-			const status = value;
-			if (typeof status.percentage !== "number") return;
-			applyToService(service, status);
+			applyToService(service, value);
 		});
 		unsubscribes.push(unsub);
 	}
@@ -78753,14 +80826,9 @@ async function buildBattery(bctx) {
 	} };
 }
 function applyToService(service, status) {
-	const pct = Math.max(0, Math.min(100, Math.round(status.percentage)));
-	service.updateCharacteristic(import_dist.Characteristic.BatteryLevel, pct);
-	const chargingState = status.charging === "none" ? import_dist.Characteristic.ChargingState.NOT_CHARGING : import_dist.Characteristic.ChargingState.CHARGING;
-	service.updateCharacteristic(import_dist.Characteristic.ChargingState, chargingState);
-	const lowBattery = pct <= LOW_BATTERY_THRESHOLD_PCT ? import_dist.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW : import_dist.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
-	service.updateCharacteristic(import_dist.Characteristic.StatusLowBattery, lowBattery);
+	applyUpdates(service, batteryCharacteristicUpdates(status));
 }
-function errMsg$10(err) {
+function errMsg$13(err) {
 	return err instanceof Error ? err.message : String(err);
 }
 //#endregion
@@ -89512,7 +91580,7 @@ var VIDEO_LOOPBACK_RCVBUF_BYTES = 8 * 1024 * 1024;
 * not burst size.
 */
 var AUDIO_LOOPBACK_RCVBUF_BYTES = 1024 * 1024;
-function errMsg$9(err) {
+function errMsg$12(err) {
 	return err instanceof Error ? err.message : String(err);
 }
 /**
@@ -89527,13 +91595,13 @@ function applyReceiveBuffer(socket, requestedBytes) {
 	try {
 		socket.setRecvBufferSize(requestedBytes);
 	} catch (err) {
-		error = errMsg$9(err);
+		error = errMsg$12(err);
 	}
 	let effectiveBytes = null;
 	try {
 		effectiveBytes = socket.getRecvBufferSize();
 	} catch (err) {
-		if (error === null) error = errMsg$9(err);
+		if (error === null) error = errMsg$12(err);
 	}
 	return {
 		requestedBytes,
@@ -89793,20 +91861,20 @@ function buildCameraStreamingDelegate(bctx, advertised) {
 		delegate: {
 			handleSnapshotRequest(request, callback) {
 				handleSnapshot(bctx, request).then((buf) => callback(void 0, buf)).catch((err) => {
-					log.warn("export-hap: snapshot failed", { meta: { error: errMsg$8(err) } });
-					callback(err instanceof Error ? err : new Error(errMsg$8(err)));
+					log.warn("export-hap: snapshot failed", { meta: { error: errMsg$11(err) } });
+					callback(err instanceof Error ? err : new Error(errMsg$11(err)));
 				});
 			},
 			prepareStream(request, callback) {
 				prepareStream(request, sessions, bctx).then((resp) => callback(void 0, resp)).catch((err) => {
-					log.warn("export-hap: prepareStream failed", { meta: { error: errMsg$8(err) } });
-					callback(err instanceof Error ? err : new Error(errMsg$8(err)));
+					log.warn("export-hap: prepareStream failed", { meta: { error: errMsg$11(err) } });
+					callback(err instanceof Error ? err : new Error(errMsg$11(err)));
 				});
 			},
 			handleStreamRequest(request, callback) {
 				handleStreamRequest(request, sessions, bctx, advertised).then(() => callback()).catch((err) => {
-					log.warn("export-hap: handleStreamRequest failed", { meta: { error: errMsg$8(err) } });
-					callback(err instanceof Error ? err : new Error(errMsg$8(err)));
+					log.warn("export-hap: handleStreamRequest failed", { meta: { error: errMsg$11(err) } });
+					callback(err instanceof Error ? err : new Error(errMsg$11(err)));
 				});
 			}
 		},
@@ -89922,7 +91990,7 @@ async function prepareStream(request, sessions, bctx) {
 		closeSocket(audioUdp);
 		closeSocket(videoLoopUdp);
 		closeSocket(audioLoopUdp);
-		throw new Error(`export-hap: outbound SrtpSession init failed: ${errMsg$8(err)}`, { cause: err });
+		throw new Error(`export-hap: outbound SrtpSession init failed: ${errMsg$11(err)}`, { cause: err });
 	}
 	let upstreamAudioSrtp = null;
 	try {
@@ -89936,7 +92004,7 @@ async function prepareStream(request, sessions, bctx) {
 			profile: import_src.ProtectionProfileAes128CmHmacSha1_80
 		});
 	} catch (err) {
-		bctx.ctx.logger.withTags({ deviceId: bctx.numericDeviceId }).warn("export-hap: SrtpSession init failed (upstream audio decrypt disabled)", { meta: { error: errMsg$8(err) } });
+		bctx.ctx.logger.withTags({ deviceId: bctx.numericDeviceId }).warn("export-hap: SrtpSession init failed (upstream audio decrypt disabled)", { meta: { error: errMsg$11(err) } });
 	}
 	const videoSsrc = randomSsrc();
 	const audioSsrc = randomSsrc();
@@ -90053,7 +92121,7 @@ async function prepareStream(request, sessions, bctx) {
 	});
 	audioUdp.on("message", (packet, rinfo) => {
 		handleIncomingAudioRtp(session, packet, rinfo.address, bctx).catch((err) => {
-			bctx.ctx.logger.withTags({ deviceId: bctx.numericDeviceId }).debug("export-hap: incoming-audio handler error (dropped)", { meta: { error: errMsg$8(err) } });
+			bctx.ctx.logger.withTags({ deviceId: bctx.numericDeviceId }).debug("export-hap: incoming-audio handler error (dropped)", { meta: { error: errMsg$11(err) } });
 		});
 	});
 	logLoopbackBuffer(tagLog, request.sessionID, "video", videoLoop.buffer);
@@ -90249,7 +92317,7 @@ function readControllerRtcp(session, leg, packet, log) {
 	} catch (err) {
 		drop(session, "inbound-rtcp-decrypt-failed");
 		storeReceiverReports(session, leg, recordUnreadableRtcp(tally));
-		logUnreadableRtcp(session, leg, `decrypt: ${errMsg$8(err)}`, log);
+		logUnreadableRtcp(session, leg, `decrypt: ${errMsg$11(err)}`, log);
 		return;
 	}
 	const outcome = ingestDecryptedRtcp(plaintext, tally);
@@ -91015,7 +93083,7 @@ async function handleIncomingAudioRtp(session, packet, sourceAddress, bctx) {
 		session.upstreamRtpDecryptFailures += 1;
 		if (session.upstreamRtpDecryptFailures % 100 === 1) log.debug("export-hap: SRTP decrypt failed (rate-limited)", { meta: {
 			failures: session.upstreamRtpDecryptFailures,
-			error: errMsg$8(err)
+			error: errMsg$11(err)
 		} });
 		return;
 	}
@@ -91029,7 +93097,7 @@ async function handleIncomingAudioRtp(session, packet, sourceAddress, bctx) {
 		rtpPayloadType = parsedRtp.header.payloadType;
 	} catch (err) {
 		drop(session, "upstream-parse-failed");
-		log.debug("export-hap: RTP parse failed after decrypt", { meta: { error: errMsg$8(err) } });
+		log.debug("export-hap: RTP parse failed after decrypt", { meta: { error: errMsg$11(err) } });
 		return;
 	}
 	const negotiatedAudioPt = session.lastStartParams?.audioPt;
@@ -91053,7 +93121,7 @@ async function handleIncomingAudioRtp(session, packet, sourceAddress, bctx) {
 	if (session.intercomTalkSessionId === null) {
 		session.intercomTalkSessionId = "";
 		const opened = await openIntercomTalkSession(bctx).catch((err) => {
-			log.warn("export-hap: intercom.startTalkSession failed", { meta: { error: errMsg$8(err) } });
+			log.warn("export-hap: intercom.startTalkSession failed", { meta: { error: errMsg$11(err) } });
 			return null;
 		});
 		if (opened) {
@@ -91080,7 +93148,7 @@ async function handleIncomingAudioRtp(session, packet, sourceAddress, bctx) {
 		drop(session, "upstream-push-failed");
 		log.debug("export-hap: intercom.pushTalkAudio failed (will re-open on next frame)", { meta: {
 			sequenceNumber: session.intercomPcmSequence,
-			error: errMsg$8(err)
+			error: errMsg$11(err)
 		} });
 		session.intercomTalkSessionId = null;
 	}
@@ -91112,7 +93180,7 @@ async function closeIntercomTalkSession(session, bctx) {
 	} catch (err) {
 		log.debug("export-hap: intercom.endTalkSession failed (continuing)", { meta: {
 			sessionId,
-			error: errMsg$8(err)
+			error: errMsg$11(err)
 		} });
 	}
 }
@@ -91137,7 +93205,7 @@ function closeSocket(udp) {
 function randomSsrc() {
 	return Math.floor(Math.random() * 2147483646) + 1 | 0;
 }
-function errMsg$8(err) {
+function errMsg$11(err) {
 	return err instanceof Error ? err.message : String(err);
 }
 //#endregion
@@ -91221,14 +93289,14 @@ async function buildDoorbell(input) {
 			}
 			log.info("export-hap: doorbell SINGLE_PRESS pushed to HomeKit", { meta: { ...delivery } });
 		} catch (err) {
-			log.warn("export-hap: ringDoorbell() failed", { meta: { error: errMsg$7(err) } });
+			log.warn("export-hap: ringDoorbell() failed", { meta: { error: errMsg$10(err) } });
 		}
 	});
 	return { async dispose() {
 		unsubscribe();
 	} };
 }
-function errMsg$7(err) {
+function errMsg$10(err) {
 	return err instanceof Error ? err.message : String(err);
 }
 //#endregion
@@ -91268,13 +93336,15 @@ var RESET_DEBOUNCE_MS = 5e3;
 */
 async function buildMotionSensor(bctx, existing = null) {
 	const { ctx, accessory, proxy, numericDeviceId, displayName } = bctx;
-	const motionService = existing ?? accessory.addService(import_dist.Service.MotionSensor, hapServiceName([displayName], `Camera ${numericDeviceId}`));
+	const label = hapServiceName([displayName], `Camera ${numericDeviceId}`);
+	const motionService = existing ?? accessory.addService(import_dist.Service.MotionSensor, label);
+	applyServiceLabel(motionService, label);
 	motionService.setCharacteristic(import_dist.Characteristic.MotionDetected, false);
 	try {
 		const detected = await proxy.motion?.isDetected({});
 		if (typeof detected === "boolean") motionService.updateCharacteristic(import_dist.Characteristic.MotionDetected, detected);
 	} catch (err) {
-		ctx.logger.withTags({ deviceId: numericDeviceId }).debug("export-hap: initial motion hydrate failed (non-fatal)", { meta: { error: errMsg$6(err) } });
+		ctx.logger.withTags({ deviceId: numericDeviceId }).debug("export-hap: initial motion hydrate failed (non-fatal)", { meta: { error: errMsg$9(err) } });
 	}
 	let resetTimer = null;
 	const armReset = () => {
@@ -91308,82 +93378,10 @@ async function buildMotionSensor(bctx, existing = null) {
 		}
 	} };
 }
-function errMsg$6(err) {
+function errMsg$9(err) {
 	return err instanceof Error ? err.message : String(err);
 }
 //#endregion
-//#region src/mappers/builders/service-label.ts
-/**
-* The ONE place a secondary service on the camera accessory gets its label.
-*
-* A "secondary service" here is a Switch or Lightbulb published alongside the
-* camera on the same accessory — the privacy switch, each accessory child
-* (siren, floodlight), each PTZ action. iOS Home renders these as their own
-* controls, and the operator has seen them as "Interruttore 1", "Interruttore
-* 2" through three separate rounds of fixes.
-*
-* ## Why `Name` alone cannot rename anything
-*
-* Two facts about hap-nodejs 2.1.7, both measured against the installed copy
-* rather than reasoned about:
-*
-*  1. `accessory.addService(Type, displayName, subtype)` ALREADY writes
-*     `displayName` to `Characteristic.Name` (`Service` constructor). So every
-*     round of this bug — including the one that moved the label onto
-*     `ConfiguredName` — shipped with `Name` correctly set. "iOS had no name
-*     to render" was never true.
-*  2. The mDNS configuration number (`c#`) is a sha1 over
-*     `internalHAPRepresentation(false)`, which OMITS characteristic VALUES.
-*     Changing the string in `Name` therefore does not bump `c#`, a paired
-*     controller gets no signal to re-read `/accessories`, and the name it
-*     cached at first enumeration stands forever.
-*
-* `Name` is also declared `pr` only — paired read, no write, no notify. It is
-* the seed a controller seeds its database from once; it is not a channel.
-*
-* ## Why `ConfiguredName`
-*
-* `ConfiguredName` (`000000E3`) is declared `pr | pw | ev` — the only name
-* characteristic a controller may write and may subscribe to. It is what iOS
-* 16+ reads for a service the user can rename, and adding it CHANGES the
-* accessory structure, so `c#` does bump and the controller re-reads.
-*
-* It was removed once because hap-nodejs logged
-*
-* ```
-* Characteristic not in required or optional characteristic section for
-* service Switch. Adding anyway.
-* ```
-*
-* That line is a WARNING, not a rejection: `Service.getCharacteristic` calls
-* `addCharacteristic` unconditionally and only then emits the warning. The
-* characteristic was always present and always published. hap-nodejs'
-* per-service optional lists simply predate `ConfiguredName` being valid on
-* any service.
-*
-* Registering it with {@link Service.addOptionalCharacteristic} first takes
-* the branch above the warning, so the accessory still builds with ZERO
-* characteristic warnings — which is what `service-naming.spec.ts` asserts.
-*
-* ## Scope
-*
-* Switch- and Lightbulb-shaped services only. `Service.MotionSensor` on a
-* camera accessory is not a separately named tile in iOS Home, so giving it a
-* writable name would be a guess, and this module does not guess.
-*/
-/**
-* Publish `name` as both the immutable `Name` and the controller-visible
-* `ConfiguredName` of `service`.
-*
-* `name` must already be HAP-valid — build it with `service-names.ts`, which
-* cannot return a string hap-nodejs' `checkName` would warn about.
-*/
-function applyServiceLabel(service, name) {
-	service.setCharacteristic(import_dist.Characteristic.Name, name);
-	if (!service.optionalCharacteristics.some((characteristic) => characteristic.UUID === import_dist.Characteristic.ConfiguredName.UUID)) service.addOptionalCharacteristic(import_dist.Characteristic.ConfiguredName);
-	service.setCharacteristic(import_dist.Characteristic.ConfiguredName, name);
-}
-//#endregion
 //#region src/mappers/builders/privacy-switch.ts
 /**
 * Privacy-mask switch builder — turns the camstack `privacy-mask` cap's
@@ -91411,7 +93409,7 @@ async function buildPrivacySwitch(bctx) {
 		const status = await proxy.privacyMask?.getStatus({});
 		if (status && typeof status.enabled === "boolean") service.updateCharacteristic(import_dist.Characteristic.On, status.enabled);
 	} catch (err) {
-		log.debug("export-hap: privacy-mask getStatus hydrate failed (non-fatal)", { meta: { error: errMsg$5(err) } });
+		log.debug("export-hap: privacy-mask getStatus hydrate failed (non-fatal)", { meta: { error: errMsg$8(err) } });
 	}
 	service.getCharacteristic(import_dist.Characteristic.On).onSet(async (value) => {
 		const enabled = value === true;
@@ -91420,7 +93418,7 @@ async function buildPrivacySwitch(bctx) {
 		} catch (err) {
 			log.warn("export-hap: privacy-mask setMask failed", { meta: {
 				enabled,
-				error: errMsg$5(err)
+				error: errMsg$8(err)
 			} });
 		}
 	});
@@ -91438,7 +93436,7 @@ async function buildPrivacySwitch(bctx) {
 		} catch {}
 	} };
 }
-function errMsg$5(err) {
+function errMsg$8(err) {
 	return err instanceof Error ? err.message : String(err);
 }
 //#endregion
@@ -91529,7 +93527,7 @@ async function buildPtz(bctx) {
 			} catch (err) {
 				log.warn("export-hap: ptz.goToPreset failed", { meta: {
 					presetId: preset.id,
-					error: errMsg$4(err)
+					error: errMsg$7(err)
 				} });
 			}
 			armReset(() => service.updateCharacteristic(import_dist.Characteristic.On, false), MOMENTARY_RESET_MS);
@@ -91547,14 +93545,14 @@ async function buildPtz(bctx) {
 					try {
 						await proxy.ptz?.stop({});
 					} catch (err) {
-						log.debug("export-hap: ptz.stop failed (non-fatal)", { meta: { error: errMsg$4(err) } });
+						log.debug("export-hap: ptz.stop failed (non-fatal)", { meta: { error: errMsg$7(err) } });
 					}
 					service.updateCharacteristic(import_dist.Characteristic.On, false);
 				}, options.ptzPulseMs);
 			} catch (err) {
 				log.warn("export-hap: ptz.continuousMove failed", { meta: {
 					dir: dir.label,
-					error: errMsg$4(err)
+					error: errMsg$7(err)
 				} });
 				service.updateCharacteristic(import_dist.Characteristic.On, false);
 			}
@@ -91577,7 +93575,7 @@ async function readPresets(bctx) {
 			name: p.name
 		}));
 	} catch (err) {
-		ctx.logger.withTags({ deviceId: numericDeviceId }).debug("export-hap: ptz.getPresets failed (non-fatal)", { meta: { error: errMsg$4(err) } });
+		ctx.logger.withTags({ deviceId: numericDeviceId }).debug("export-hap: ptz.getPresets failed (non-fatal)", { meta: { error: errMsg$7(err) } });
 		return [];
 	}
 }
@@ -91592,7 +93590,7 @@ async function tryBuildAutotrack(bctx) {
 		const status = await proxy.ptzAutotrack.getStatus({});
 		if (status && typeof status.enabled === "boolean") service.updateCharacteristic(import_dist.Characteristic.On, status.enabled);
 	} catch (err) {
-		log.debug("export-hap: ptzAutotrack.getStatus failed (non-fatal)", { meta: { error: errMsg$4(err) } });
+		log.debug("export-hap: ptzAutotrack.getStatus failed (non-fatal)", { meta: { error: errMsg$7(err) } });
 	}
 	service.getCharacteristic(import_dist.Characteristic.On).onSet(async (value) => {
 		const enabled = value === true;
@@ -91601,13 +93599,13 @@ async function tryBuildAutotrack(bctx) {
 		} catch (err) {
 			log.warn("export-hap: ptzAutotrack.setEnabled failed", { meta: {
 				enabled,
-				error: errMsg$4(err)
+				error: errMsg$7(err)
 			} });
 		}
 	});
 	return { async dispose() {} };
 }
-function errMsg$4(err) {
+function errMsg$7(err) {
 	return err instanceof Error ? err.message : String(err);
 }
 //#endregion
@@ -92638,13 +94636,13 @@ async function buildChildSwitch(bctx, subtype, deviceType) {
 		const switchStatus = await proxy.switch?.getStatus({});
 		if (switchStatus && typeof switchStatus.on === "boolean") service.updateCharacteristic(import_dist.Characteristic.On, switchStatus.on);
 	} catch (err) {
-		log.debug("export-hap: child switch.getStatus failed (non-fatal)", { meta: { error: errMsg$3(err) } });
+		log.debug("export-hap: child switch.getStatus failed (non-fatal)", { meta: { error: errMsg$6(err) } });
 	}
 	if (useLightbulb) try {
 		const status = await proxy.brightness?.getStatus({});
 		if (status && typeof status.percentage === "number") service.updateCharacteristic(import_dist.Characteristic.Brightness, status.percentage);
 	} catch (err) {
-		log.debug("export-hap: child brightness.getStatus failed (non-fatal)", { meta: { error: errMsg$3(err) } });
+		log.debug("export-hap: child brightness.getStatus failed (non-fatal)", { meta: { error: errMsg$6(err) } });
 	}
 	if (hasSwitch) service.getCharacteristic(import_dist.Characteristic.On).onSet(async (value) => {
 		const on = value === true;
@@ -92653,7 +94651,7 @@ async function buildChildSwitch(bctx, subtype, deviceType) {
 		} catch (err) {
 			log.warn("export-hap: child switch.setState failed", { meta: {
 				on,
-				error: errMsg$3(err)
+				error: errMsg$6(err)
 			} });
 		}
 	});
@@ -92665,7 +94663,7 @@ async function buildChildSwitch(bctx, subtype, deviceType) {
 		} catch (err) {
 			log.warn("export-hap: child brightness.setBrightness failed", { meta: {
 				percentage,
-				error: errMsg$3(err)
+				error: errMsg$6(err)
 			} });
 		}
 	});
@@ -92688,7 +94686,7 @@ async function buildChildSwitch(bctx, subtype, deviceType) {
 		} catch {}
 	} };
 }
-function errMsg$3(err) {
+function errMsg$6(err) {
 	return err instanceof Error ? err.message : String(err);
 }
 //#endregion
@@ -92715,7 +94713,7 @@ async function buildChildServicesFor(input) {
 		for (const h of handles) try {
 			await h.dispose();
 		} catch (err) {
-			ctx.logger.withTags({ deviceId: parentNumericId }).debug("export-hap: child service dispose failed (continuing)", { meta: { error: errMsg$2(err) } });
+			ctx.logger.withTags({ deviceId: parentNumericId }).debug("export-hap: child service dispose failed (continuing)", { meta: { error: errMsg$5(err) } });
 		}
 	} };
 }
@@ -92731,7 +94729,7 @@ async function listChildren(ctx, parentNumericId) {
 			features: Array.isArray(c.features) ? c.features.filter((f) => typeof f === "string") : []
 		}));
 	} catch (err) {
-		ctx.logger.withTags({ deviceId: parentNumericId }).debug("export-hap: deviceManager.getChildren failed (non-fatal)", { meta: { error: errMsg$2(err) } });
+		ctx.logger.withTags({ deviceId: parentNumericId }).debug("export-hap: deviceManager.getChildren failed (non-fatal)", { meta: { error: errMsg$5(err) } });
 		return [];
 	}
 }
@@ -92747,10 +94745,76 @@ function asDeviceType(raw) {
 	for (const value of Object.values(DeviceType)) if (value === lower) return value;
 	return DeviceType.Generic;
 }
-function errMsg$2(err) {
+function errMsg$5(err) {
 	return err instanceof Error ? err.message : String(err);
 }
 //#endregion
+//#region src/mappers/kind.ts
+/**
+* Which orchestrator a device gets, which device types the picker offers, and
+* what a device's HomeKit accessory is called on the wire.
+*
+* Separate from `index.ts` (the factory registry) only so the orchestrators can
+* import the uuid convention without importing the registry that imports them.
+*/
+var SUPPORTED_MAPPER_KINDS = ["camera", "generic"];
+/**
+* The device types the Export picker offers, and the answer to the cap's
+* `listSupportedDeviceKinds`.
+*
+* A UI FILTER, nothing more. Whether a device actually exports anything is
+* decided by its capabilities (`rowsForCaps` in the capability table) — the
+* doctrine the HA exporter writes down, and the thing that confined the
+* previous exporter to cameras when it was ignored.
+*
+* Tier A: the types whose HomeKit services exist today and need no
+* feature-dependent shape. `cover`, `climate`, `fan`, `valve`, `humidifier`,
+* `water-heater`, `alarm-panel`, `button` and `media-player` are deliberately
+* absent — each needs a service whose semantics the table cannot yet honour,
+* and offering the tab before the mapping exists is how an operator gets an
+* accessory that pairs and does nothing.
+*/
+var HAP_EXPORTABLE_DEVICE_TYPES = [
+	DeviceType.Camera,
+	DeviceType.Light,
+	DeviceType.Switch,
+	DeviceType.Siren,
+	DeviceType.Sensor,
+	DeviceType.Lock,
+	DeviceType.Presence,
+	DeviceType.Generic
+];
+/**
+* Resolve the orchestrator for a device from its TYPE.
+*
+* `null` means "no Export tab": the picker must not offer a type no
+* orchestrator can build. An UNKNOWN type (the device-manager read failed) maps
+* to `camera` — that is what every entry persisted before this function existed
+* carries, and a transient API failure must never re-shape an exposed camera.
+*/
+function pickMapperKind(deviceType) {
+	if (deviceType === null || deviceType === void 0 || deviceType.length === 0) return "camera";
+	if (deviceType === DeviceType.Camera) return "camera";
+	return HAP_EXPORTABLE_DEVICE_TYPES.find((type) => type === deviceType) === void 0 ? null : "generic";
+}
+/**
+* The deterministic HAP accessory UUID for a device.
+*
+* One function, because three call sites depend on the answer agreeing: the
+* orchestrator that builds the accessory, `unexposeDevice` (which wipes
+* hap-nodejs' pairing blobs by uuid, on a device whose mapper is already gone)
+* and the export sync state that records it.
+*
+* The camera namespace is FROZEN — every camera paired to date derives its MAC
+* from `sha256("camstack:hap:" + uuid)` of this exact string, and changing it
+* would make every paired camera a stranger. Generic devices get their own
+* namespace so a switch and a camera that happen to share a device id are not
+* the same HomeKit accessory.
+*/
+function accessoryUuidFor(kind, deviceId) {
+	return import_dist.uuid.generate(kind === "camera" ? `camstack:camera:${deviceId}` : `camstack:device:${deviceId}`);
+}
+//#endregion
 //#region src/mappers/camera-accessory.ts
 /**
 * Camera accessory orchestrator — given a camstack deviceId, builds one
@@ -92783,9 +94847,9 @@ async function buildCameraAccessory(input) {
 	const capNames = new Set(proxy.binding?.entries.map((e) => e.capName) ?? []);
 	const isDoorbell = capNames.has("doorbell");
 	const category = isDoorbell ? import_dist.Categories.VIDEO_DOORBELL : import_dist.Categories.IP_CAMERA;
-	const accessory = new import_dist.Accessory(displayName, import_dist.uuid.generate(`camstack:camera:${numericId}`));
+	const accessory = new import_dist.Accessory(displayName, accessoryUuidFor("camera", numericId));
 	accessory.category = category;
-	await populateAccessoryInfo(accessory, proxy, displayName);
+	await populateAccessoryInfo(accessory, proxy, displayName, "Camera");
 	const bctx = {
 		ctx,
 		accessory,
@@ -92843,55 +94907,462 @@ async function buildCameraAccessory(input) {
 			for (const h of handles) try {
 				await h.dispose();
 			} catch (err) {
-				log.debug("export-hap: builder dispose failed (continuing)", { meta: { error: errMsg$1(err) } });
+				log.debug("export-hap: builder dispose failed (continuing)", { meta: { error: errMsg$4(err) } });
 			}
 			try {
 				await streams.dispose();
 			} catch (err) {
-				log.debug("export-hap: streams dispose failed", { meta: { error: errMsg$1(err) } });
+				log.debug("export-hap: streams dispose failed", { meta: { error: errMsg$4(err) } });
 			}
 		}
 	};
 }
-async function populateAccessoryInfo(accessory, proxy, displayName) {
-	const info = accessory.getService(import_dist.Service.AccessoryInformation);
-	if (!info) return;
+function errMsg$4(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+//#endregion
+//#region src/mappers/builders/generic/lock.ts
+/**
+* `lock-control` → `Service.LockMechanism`.
+*
+* Not a sensor row: HomeKit models a lock as two characteristics, a CURRENT
+* state the accessory owns and a TARGET state the controller writes, and the
+* cap's five states do not map onto either one alone.
+*
+* ```
+*  cap state    LockCurrentState   LockTargetState
+*  locked       SECURED            SECURED
+*  unlocked     UNSECURED          UNSECURED
+*  locking      UNKNOWN            SECURED      (in flight — do not claim SECURED)
+*  unlocking    UNKNOWN            UNSECURED
+*  jammed       JAMMED             unchanged    (the controller's intent stands)
+* ```
+*
+* Reporting SECURED while the bolt is still moving is the failure worth naming:
+* iOS renders the lock as closed, the operator walks away, and the motor stalls
+* behind them. `UNKNOWN` is the honest answer for an in-flight transition.
+*
+* `open` (the cap's third method, for locks with a latch/buzzer) has no HomeKit
+* counterpart on this service and is deliberately not wired — a Switch that
+* silently buzzes a door open would be a second knob nobody asked for.
+*/
+var SUBTYPE = "lock-control";
+var readLock = reader(LockControlStatusSchema.pick({ state: true }), (status) => {
+	const current = status.state === "locked" ? import_dist.Characteristic.LockCurrentState.SECURED : status.state === "unlocked" ? import_dist.Characteristic.LockCurrentState.UNSECURED : status.state === "jammed" ? import_dist.Characteristic.LockCurrentState.JAMMED : import_dist.Characteristic.LockCurrentState.UNKNOWN;
+	const target = status.state === "locked" || status.state === "locking" ? import_dist.Characteristic.LockTargetState.SECURED : status.state === "unlocked" || status.state === "unlocking" ? import_dist.Characteristic.LockTargetState.UNSECURED : null;
+	return [{
+		characteristic: import_dist.Characteristic.LockCurrentState,
+		value: current
+	}, ...target === null ? [] : [{
+		characteristic: import_dist.Characteristic.LockTargetState,
+		value: target
+	}]];
+});
+async function buildLockMechanism(bctx) {
+	const { ctx, accessory, proxy, numericDeviceId, displayName } = bctx;
+	const log = ctx.logger.withTags({ deviceId: numericDeviceId });
+	const label = hapServiceName([displayName], `Lock ${numericDeviceId}`);
+	const service = accessory.addService(import_dist.Service.LockMechanism, label, SUBTYPE);
+	applyServiceLabel(service, label);
+	const apply = (status, source) => {
+		const updates = readLock(status);
+		if (updates.length === 0) {
+			log.debug("export-hap: lock status did not match the cap schema — no update", { meta: { source } });
+			return;
+		}
+		applyUpdates(service, updates);
+	};
 	try {
-		const device = await proxy.deviceManager?.getDevice({});
-		const metadata = device?.metadata ?? null;
-		info.setCharacteristic(import_dist.Characteristic.Name, device?.name ?? displayName);
-		info.setCharacteristic(import_dist.Characteristic.Manufacturer, stringOr(metadata?.manufacturer, "CamStack"));
-		info.setCharacteristic(import_dist.Characteristic.Model, stringOr(metadata?.model, "Camera"));
-		info.setCharacteristic(import_dist.Characteristic.FirmwareRevision, stringOr(metadata?.firmware, "0.0.0"));
-		info.setCharacteristic(import_dist.Characteristic.SerialNumber, stringOr(metadata?.sn, `camstack-${proxy.deviceId}`));
-	} catch {}
+		const status = await proxy.lockControl?.getStatus({});
+		if (status !== void 0 && status !== null) apply(status, "getStatus");
+	} catch (err) {
+		log.debug("export-hap: lock getStatus hydrate failed (non-fatal)", { meta: { error: errMsg$3(err) } });
+	}
+	service.getCharacteristic(import_dist.Characteristic.LockTargetState).onSet(async (value) => {
+		const secure = value === import_dist.Characteristic.LockTargetState.SECURED;
+		try {
+			if (secure) await proxy.lockControl?.lock({});
+			else await proxy.lockControl?.unlock({});
+		} catch (err) {
+			log.warn("export-hap: lock command failed", { meta: {
+				secure,
+				error: errMsg$3(err)
+			} });
+		}
+	});
+	const unsubscribe = proxy.state.lockControl?.subscribe((value) => {
+		if (value === void 0 || value === null) return;
+		apply(value, "slice");
+	}) ?? null;
+	return { async dispose() {
+		try {
+			unsubscribe?.();
+		} catch {}
+	} };
 }
-function stringOr(value, fallback) {
-	return typeof value === "string" && value.length > 0 ? value : fallback;
+function errMsg$3(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+//#endregion
+//#region src/mappers/builders/generic/sensor-service.ts
+async function buildSensorService(input) {
+	const { bctx, spec, name, subtype } = input;
+	const { ctx, accessory, proxy, numericDeviceId } = bctx;
+	const log = ctx.logger.withTags({ deviceId: numericDeviceId });
+	const label = hapServiceName([name], spec.label);
+	const service = spec.addService(accessory, label, subtype);
+	applyServiceLabel(service, label);
+	const apply = (status, source) => {
+		const updates = spec.read(status);
+		if (updates.length === 0) {
+			log.debug("export-hap: sensor status did not match the cap schema — no update", { meta: {
+				subtype,
+				source
+			} });
+			return;
+		}
+		applyUpdates(service, updates);
+	};
+	try {
+		const status = await spec.getStatus(proxy);
+		if (status !== void 0 && status !== null) apply(status, "getStatus");
+	} catch (err) {
+		log.debug("export-hap: sensor getStatus hydrate failed (non-fatal)", { meta: {
+			subtype,
+			error: errMsg$2(err)
+		} });
+	}
+	const unsubscribe = spec.subscribe(proxy, (value) => {
+		if (value === void 0 || value === null) return;
+		apply(value, "slice");
+	});
+	return { async dispose() {
+		try {
+			unsubscribe?.();
+		} catch {}
+	} };
+}
+function errMsg$2(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+//#endregion
+//#region src/mappers/builders/generic/cap-service-table.ts
+/**
+* The capability→HomeKit-service TABLE for non-camera devices.
+*
+* This is the whole coverage decision for the generic export path, and it is
+* deliberately a table rather than a `switch` on `DeviceType`. The doctrine is
+* the one the Home Assistant exporter already writes down: *coverage is decided
+* by a device's capabilities, not its type — restricting the picker by type is
+* what confined the previous exporter to cameras.* A `DeviceType` here is only
+* ever a UI filter (`HAP_EXPORTABLE_DEVICE_TYPES`) or an icon
+* (`ACCESSORY_CATEGORY_BY_TYPE`); it never decides whether something exports.
+*
+* The shape mirrors `CAP_ENTITY_MAP` in
+* `packages/addon-provider-homeassistant/src/ha-export/entity-catalog.ts` so
+* the two can be unified later — one row per capability, keyed by the cap name
+* exactly as it appears in `proxy.binding.entries[].capName`.
+*
+* ## Reading a status
+*
+* Every row parses the cap's OWN Zod status schema rather than duck-typing the
+* payload, and it `.pick()`s only the fields it reads: a provider that omits a
+* timestamp must not silence a sensor, and a provider that sends the wrong
+* shape must not write a garbage characteristic. A parse that fails yields no
+* updates, and the builder that owns the service logs the drop — silence reads
+* as "the sensor never changed".
+*
+* ## Tier
+*
+* Tier A only: the caps whose HomeKit service exists today and needs no
+* feature-dependent shape (`cover` needs `cover-positionable`, `climate-control`
+* needs the dual-setpoint split, `alarm-panel` must survive a refused `arm`).
+* Those are a separate task; adding a row here must never mean adding a service
+* whose semantics this file cannot fully honour.
+*/
+/** HomeKit's floor for `CurrentAmbientLightLevel`; 0 lux is out of range. */
+var MIN_LUX = 1e-4;
+var SENSOR_SPECS = {
+	contact: {
+		label: "Contact",
+		addService: (accessory, name, subtype) => accessory.addService(import_dist.Service.ContactSensor, name, subtype),
+		getStatus: (proxy) => proxy.contact?.getStatus({}),
+		subscribe: (proxy, onValue) => proxy.state.contact?.subscribe(onValue) ?? null,
+		read: reader(ContactStatusSchema.pick({ entryOpen: true }), (status) => [{
+			characteristic: import_dist.Characteristic.ContactSensorState,
+			value: status.entryOpen ? import_dist.Characteristic.ContactSensorState.CONTACT_NOT_DETECTED : import_dist.Characteristic.ContactSensorState.CONTACT_DETECTED
+		}])
+	},
+	motion: {
+		label: "Motion",
+		addService: (accessory, name, subtype) => accessory.addService(import_dist.Service.MotionSensor, name, subtype),
+		getStatus: (proxy) => proxy.motion?.getStatus({}),
+		subscribe: (proxy, onValue) => proxy.state.motion?.subscribe(onValue) ?? null,
+		read: reader(MotionStatusSchema.pick({ detected: true }), (status) => [{
+			characteristic: import_dist.Characteristic.MotionDetected,
+			value: status.detected
+		}])
+	},
+	presence: {
+		label: "Presence",
+		addService: (accessory, name, subtype) => accessory.addService(import_dist.Service.OccupancySensor, name, subtype),
+		getStatus: (proxy) => proxy.presence?.getStatus({}),
+		subscribe: (proxy, onValue) => proxy.state.presence?.subscribe(onValue) ?? null,
+		read: reader(PresenceStatusSchema.pick({ state: true }), (status) => [{
+			characteristic: import_dist.Characteristic.OccupancyDetected,
+			value: status.state === "home" ? import_dist.Characteristic.OccupancyDetected.OCCUPANCY_DETECTED : import_dist.Characteristic.OccupancyDetected.OCCUPANCY_NOT_DETECTED
+		}])
+	},
+	smoke: {
+		label: "Smoke",
+		addService: (accessory, name, subtype) => accessory.addService(import_dist.Service.SmokeSensor, name, subtype),
+		getStatus: (proxy) => proxy.smoke?.getStatus({}),
+		subscribe: (proxy, onValue) => proxy.state.smoke?.subscribe(onValue) ?? null,
+		read: reader(SmokeStatusSchema.pick({ detected: true }), (status) => [{
+			characteristic: import_dist.Characteristic.SmokeDetected,
+			value: status.detected ? import_dist.Characteristic.SmokeDetected.SMOKE_DETECTED : import_dist.Characteristic.SmokeDetected.SMOKE_NOT_DETECTED
+		}])
+	},
+	"carbon-monoxide": {
+		label: "Carbon monoxide",
+		addService: (accessory, name, subtype) => accessory.addService(import_dist.Service.CarbonMonoxideSensor, name, subtype),
+		getStatus: (proxy) => proxy.carbonMonoxide?.getStatus({}),
+		subscribe: (proxy, onValue) => proxy.state.carbonMonoxide?.subscribe(onValue) ?? null,
+		read: reader(CarbonMonoxideStatusSchema.pick({ detected: true }), (status) => [{
+			characteristic: import_dist.Characteristic.CarbonMonoxideDetected,
+			value: status.detected ? import_dist.Characteristic.CarbonMonoxideDetected.CO_LEVELS_ABNORMAL : import_dist.Characteristic.CarbonMonoxideDetected.CO_LEVELS_NORMAL
+		}])
+	},
+	flood: {
+		label: "Leak",
+		addService: (accessory, name, subtype) => accessory.addService(import_dist.Service.LeakSensor, name, subtype),
+		getStatus: (proxy) => proxy.flood?.getStatus({}),
+		subscribe: (proxy, onValue) => proxy.state.flood?.subscribe(onValue) ?? null,
+		read: reader(FloodStatusSchema.pick({ flooded: true }), (status) => [{
+			characteristic: import_dist.Characteristic.LeakDetected,
+			value: status.flooded ? import_dist.Characteristic.LeakDetected.LEAK_DETECTED : import_dist.Characteristic.LeakDetected.LEAK_NOT_DETECTED
+		}])
+	},
+	"temperature-sensor": {
+		label: "Temperature",
+		addService: (accessory, name, subtype) => accessory.addService(import_dist.Service.TemperatureSensor, name, subtype),
+		getStatus: (proxy) => proxy.temperatureSensor?.getStatus({}),
+		subscribe: (proxy, onValue) => proxy.state.temperatureSensor?.subscribe(onValue) ?? null,
+		read: reader(TemperatureSensorStatusSchema.pick({ celsius: true }), (status) => [{
+			characteristic: import_dist.Characteristic.CurrentTemperature,
+			value: status.celsius
+		}])
+	},
+	"humidity-sensor": {
+		label: "Humidity",
+		addService: (accessory, name, subtype) => accessory.addService(import_dist.Service.HumiditySensor, name, subtype),
+		getStatus: (proxy) => proxy.humiditySensor?.getStatus({}),
+		subscribe: (proxy, onValue) => proxy.state.humiditySensor?.subscribe(onValue) ?? null,
+		read: reader(HumiditySensorStatusSchema.pick({ percent: true }), (status) => [{
+			characteristic: import_dist.Characteristic.CurrentRelativeHumidity,
+			value: status.percent
+		}])
+	},
+	"ambient-light-sensor": {
+		label: "Light level",
+		addService: (accessory, name, subtype) => accessory.addService(import_dist.Service.LightSensor, name, subtype),
+		getStatus: (proxy) => proxy.ambientLightSensor?.getStatus({}),
+		subscribe: (proxy, onValue) => proxy.state.ambientLightSensor?.subscribe(onValue) ?? null,
+		read: reader(AmbientLightSensorStatusSchema.pick({ lux: true }), (status) => [{
+			characteristic: import_dist.Characteristic.CurrentAmbientLightLevel,
+			value: Math.max(MIN_LUX, status.lux)
+		}])
+	}
+};
+/**
+* The `battery` row reads like a sensor but writes three characteristics from
+* one status, and the camera path publishes the SAME service from the same cap.
+* The derivation therefore lives once, in `battery.ts`, and both callers read
+* it from there.
+*/
+var BATTERY_SPEC = {
+	label: "Battery",
+	addService: (accessory, name, subtype) => accessory.addService(import_dist.Service.Battery, name, subtype),
+	getStatus: (proxy) => proxy.battery?.getStatus({}),
+	subscribe: (proxy, onValue) => proxy.state.battery?.subscribe(onValue) ?? null,
+	read: batteryCharacteristicUpdates
+};
+function sensorRow(capName, spec) {
+	return {
+		caps: [capName],
+		label: spec.label,
+		build: ({ bctx, name }) => buildSensorService({
+			bctx,
+			spec,
+			name,
+			subtype: capName
+		})
+	};
+}
+/**
+* THE table. Order matters only for one thing: the first row that matches a
+* device decides the accessory's category when the device's own type does not.
+*/
+var HAP_CAP_SERVICES = [
+	{
+		caps: ["switch", "brightness"],
+		label: "Power",
+		build: ({ bctx, name, deviceType }) => buildChildSwitch({
+			...bctx,
+			displayName: name
+		}, "switch", deviceType)
+	},
+	{
+		caps: ["lock-control"],
+		label: "Lock",
+		build: ({ bctx, name }) => buildLockMechanism({
+			...bctx,
+			displayName: name
+		})
+	},
+	{
+		caps: ["battery"],
+		label: BATTERY_SPEC.label,
+		build: ({ bctx, name }) => buildSensorService({
+			bctx,
+			spec: BATTERY_SPEC,
+			name,
+			subtype: "battery"
+		})
+	},
+	...Object.entries(SENSOR_SPECS).map(([capName, spec]) => sensorRow(capName, spec))
+];
+/**
+* The rows a device's bound capabilities select, in table order.
+*
+* A row matches when ANY of its caps is bound: a lamp with `switch` but no
+* `brightness` is still a Lightbulb-shaped row, and the builder degrades on its
+* own.
+*/
+function rowsForCaps(capNames) {
+	return HAP_CAP_SERVICES.filter((row) => row.caps.some((cap) => capNames.has(cap)));
+}
+/**
+* The HomeKit accessory category per camstack device type — the icon iOS Home
+* draws and nothing else. Absent = `OTHER`, which is a valid accessory that
+* simply gets the generic tile.
+*
+* This is NOT a coverage decision. `HAP_EXPORTABLE_DEVICE_TYPES` (in
+* `mappers/index.ts`) filters the picker; whether a device exports anything is
+* decided by `rowsForCaps`.
+*/
+var ACCESSORY_CATEGORY_BY_TYPE = {
+	[DeviceType.Switch]: import_dist.Categories.SWITCH,
+	[DeviceType.Light]: import_dist.Categories.LIGHTBULB,
+	[DeviceType.Siren]: import_dist.Categories.SWITCH,
+	[DeviceType.Lock]: import_dist.Categories.DOOR_LOCK,
+	[DeviceType.Sensor]: import_dist.Categories.SENSOR,
+	[DeviceType.Presence]: import_dist.Categories.SENSOR
+};
+function accessoryCategoryFor(deviceType) {
+	return ACCESSORY_CATEGORY_BY_TYPE[deviceType] ?? import_dist.Categories.OTHER;
+}
+//#endregion
+//#region src/mappers/generic-accessory.ts
+/**
+* Generic accessory orchestrator — every camstack device that is NOT a camera.
+*
+* Same three steps as the camera orchestrator, and deliberately nothing more:
+*  1. resolve the typed `DeviceProxy`,
+*  2. select rows from the capability→service table with the device's BOUND
+*     capabilities (never its type — see `builders/generic/cap-service-table.ts`),
+*  3. let each row add its service to one `Accessory`.
+*
+* It publishes standalone, like the camera path: one accessory, one mDNS
+* advertisement, one pairing, the shared setup code. This addon is not a
+* bridge — that decision predates this file and is not re-litigated here.
+*
+* ## It REFUSES rather than publishing an empty tile
+*
+* A device whose capabilities select no row throws. The alternative is an
+* accessory carrying nothing but `AccessoryInformation`: it pairs, it appears
+* in the Home app, it does nothing, and the operator has no way to tell that
+* from a broken integration. The Export tab is gated on the same question
+* (`hap-export.addon.ts`), so reaching this throw means the device changed
+* shape between the tab rendering and the toggle landing.
+*/
+async function buildGenericAccessory(input) {
+	const { ctx, deviceId, displayName, options } = input;
+	const numericId = Number.parseInt(deviceId, 10);
+	if (!Number.isFinite(numericId)) throw new Error(`export-hap: cannot map device '${deviceId}' — id is not numeric`);
+	const log = ctx.logger.withTags({ deviceId: numericId });
+	const proxy = await ctx.fetchDevice(numericId);
+	const capNames = new Set(proxy.binding?.entries.map((e) => e.capName) ?? []);
+	const rows = rowsForCaps(capNames);
+	if (rows.length === 0) throw new Error(`export-hap: device ${numericId} carries no capability HomeKit can export (bound: ${[...capNames].toSorted().join(", ") || "none"})`);
+	const deviceType = await resolveDeviceType(proxy);
+	const accessory = new import_dist.Accessory(displayName, accessoryUuidFor("generic", numericId));
+	accessory.category = accessoryCategoryFor(deviceType);
+	await populateAccessoryInfo(accessory, proxy, displayName, "Accessory");
+	const bctx = {
+		ctx,
+		accessory,
+		proxy,
+		numericDeviceId: numericId,
+		displayName,
+		options
+	};
+	const handles = [];
+	for (const row of rows) {
+		const name = rows.length === 1 ? displayName : row.label;
+		handles.push(await row.build({
+			bctx,
+			name,
+			deviceType
+		}));
+	}
+	log.info("export-hap: built generic accessory", { meta: {
+		deviceType,
+		services: rows.map((row) => row.caps[0]).join(",")
+	} });
+	return {
+		accessory,
+		accessories: [accessory],
+		async dispose() {
+			for (const handle of handles) try {
+				await handle.dispose();
+			} catch (err) {
+				log.debug("export-hap: generic builder dispose failed (continuing)", { meta: { error: errMsg$1(err) } });
+			}
+		}
+	};
+}
+/**
+* The device's own type, or `Generic`.
+*
+* Used ONLY where one capability has two HomeKit shapes — a siren's
+* `brightness` is alarm volume, not luminosity — and for the accessory's icon.
+* `Generic` is the safe reading: it is the shape `child-switch.ts` already
+* treats as "a lamp if it dims, a switch otherwise".
+*/
+async function resolveDeviceType(proxy) {
+	try {
+		const device = await proxy.deviceManager?.getDevice({});
+		const raw = typeof device?.type === "string" ? device.type.toLowerCase() : "";
+		return Object.values(DeviceType).find((value) => value === raw) ?? DeviceType.Generic;
+	} catch {
+		return DeviceType.Generic;
+	}
 }
 function errMsg$1(err) {
 	return err instanceof Error ? err.message : String(err);
 }
 //#endregion
 //#region src/mappers/index.ts
-var SUPPORTED_MAPPER_KINDS = ["camera"];
-var REGISTRY = { camera: buildCameraAccessory };
+var REGISTRY = {
+	camera: buildCameraAccessory,
+	generic: buildGenericAccessory
+};
 function getMapperFactory(kind) {
 	const factory = REGISTRY[kind];
 	if (!factory) throw new Error(`export-hap: no mapper registered for kind '${kind}'`);
 	return factory;
 }
-/**
-* Resolve the best-fit mapper kind. With Round 2, the operator just
-* picks a camera and the orchestrator does the rest — the single
-* `camera` kind is returned unconditionally. We keep the function
-* signature for backwards-compat with the addon's existing
-* `exposeDevice` flow and to leave room for future device types (NVR,
-* climate sensor, ...).
-*/
-function pickMapperKind(_capabilities) {
-	return "camera";
-}
 //#endregion
 //#region src/mappers/builders/stream-hwaccel-memo.ts
 /**
@@ -93029,8 +95500,8 @@ function syncStateToJson(map) {
 //#endregion
 //#region src/hap-export.addon.ts
 /**
-* HomeKit (HAP) export addon — publishes a single HAP bridge process
-* that exposes selected camstack devices as HomeKit accessories.
+* HomeKit (HAP) export addon — publishes selected camstack devices as
+* standalone HomeKit accessories.
 *
 * Operator flow:
 *   1. Install + enable the addon (hub-only, group `export-hap`).
@@ -93041,10 +95512,10 @@ function syncStateToJson(map) {
 *   3. The setup URI (`X-HM://…`) is logged AND surfaced via the
 *      `getStatus` cap method so the wizard UI can render the QR.
 *   4. Operator opens iOS Home → + → scan QR → enter pincode.
-*   5. Operator hits "Expose to HomeKit" on individual camstack
-*      devices; the addon attaches a MotionSensor accessory (MVP)
-*      to the bridge and persists the choice via the same
-*      `updateGlobalSettings` path.
+*   5. Operator hits "Expose to HomeKit" on individual camstack devices.
+*      Each exposed device is published as its OWN accessory with its own
+*      mDNS advertisement, sharing one setup code — cameras cannot be
+*      bridged, so nothing is.
 *
 * Exception — the hap-nodejs library's own `HAPStorage` lives under
 * `ctx.dataDir/hap-store/`. That directory is library-internal: the
@@ -93053,23 +95524,20 @@ function syncStateToJson(map) {
 * I/O for addon-owned data") explicitly scopes itself to OUR own data;
 * library-managed blobs are out of scope.
 *
-* Round 2 scope: full camera bridge. `exposeDevice({deviceId})` builds
-* one HomeKit Accessory per camstack camera with auto-detected feature
-* services driven by the device's capability binding:
-*   - `camera-streams` cap → CameraRTPStreamManagement via ffmpeg
-*   - `intercom` cap → Microphone + Speaker (audio bridge wiring is a
-*     Round 3 follow-up — services are declared so iOS Home shows the
-*     talk-back button, but PCM upload is not yet routed)
-*   - `doorbell` cap → DoorbellController + Doorbell service
-*   - `motion-detection` cap → MotionSensor service
-*   - `ptz` cap → preset switches + 4 directional momentary switches
-*   - `ptz-autotrack` cap → stateful "Autotrack" switch
-* Children (siren, floodlight, spotlight, …) become independent
-* accessories under the same Bridge — see `mappers/child-accessory.ts`.
-*
-* What's deferred to Round 3+: cam→browser audio Opus transcode,
-* intercom upload bridge, HomeKit Secure Video, recording, native
-* H.264 stream tap (currently uses RTSP + ffmpeg copy).
+* ## Two accessory shapes, one rule about coverage
+*
+* `exposeDevice({deviceId})` resolves the device's TYPE to a mapper kind
+* (`mappers/kind.ts`) and hands off:
+*
+*  - a camera → `mappers/camera-accessory.ts`: streams, HKSV recording,
+*    doorbell, motion, intercom, PTZ, battery, privacy and every accessory
+*    child, all as services on one accessory;
+*  - anything else → `mappers/generic-accessory.ts`, driven by the
+*    capability→service table in `mappers/builders/generic/`.
+*
+* The type only picks the SHAPE. What a device publishes is decided by the
+* capabilities bound to it — restricting coverage by type is precisely what
+* confined this exporter to cameras for its first three rounds.
 */
 var DEFAULT_DEVICE_SETTINGS = {
 	streamPreference: "auto",
@@ -93112,7 +95580,6 @@ var DEFAULT_CONFIG = {
 	fixedPin: "",
 	interfaceName: "",
 	ptzPulseMs: 400,
-	hksvPreview: false,
 	identity: {
 		username: "",
 		pincode: "",
@@ -93228,7 +95695,7 @@ var ExportHapAddon = class extends BaseAddon {
 						...setup ? { setup } : {}
 					};
 				},
-				listSupportedDeviceKinds: async () => [...SUPPORTED_MAPPER_KINDS],
+				listSupportedDeviceKinds: async () => [...HAP_EXPORTABLE_DEVICE_TYPES],
 				listExposedDevices: async () => Array.from(this.exposed.entries()).map(([deviceId, m]) => {
 					const entry = this.config.exposed.find((e) => e.deviceId === deviceId);
 					return {
@@ -93313,9 +95780,10 @@ var ExportHapAddon = class extends BaseAddon {
 			log.debug("export-hap: device already exposed — refreshing capabilities");
 			await this.detachMapper(deviceId);
 		}
-		const mapperKind = pickMapperKind(capabilities);
-		if (!mapperKind) throw new Error(`export-hap: no mapper for capabilities ${JSON.stringify(capabilities ?? [])}`);
-		const displayName = await this.resolveDisplayName(deviceId);
+		const summary = await this.fetchDeviceSummary(numericId);
+		const mapperKind = pickMapperKind(summary?.type);
+		if (!mapperKind) throw new Error(`export-hap: device ${numericId} has type '${summary?.type ?? "unknown"}', which HomeKit export does not support`);
+		const displayName = summary?.name ?? `Device ${deviceId}`;
 		const previous = this.config.exposed.find((e) => e.deviceId === deviceId);
 		const baseEntry = carryForward({
 			deviceId,
@@ -93345,10 +95813,11 @@ var ExportHapAddon = class extends BaseAddon {
 	async unexposeDevice(deviceId, options = {}) {
 		const numericId = Number.parseInt(deviceId, 10);
 		const log = this.ctx.logger.withTags({ deviceId: numericId });
+		const mapperKind = this.findEntry(numericId)?.mapperKind ?? "camera";
 		await this.detachMapper(deviceId);
 		const next = this.config.exposed.filter((e) => e.deviceId !== deviceId);
 		if (next.length !== this.config.exposed.length) await this.updateGlobalSettings({ exposed: next });
-		if (options.clearPairing !== false) clearPairingFiles(import_dist.uuid.generate(`camstack:camera:${numericId}`), this.ctx.logger);
+		if (options.clearPairing !== false) clearPairingFiles(accessoryUuidFor(mapperKind, numericId), this.ctx.logger);
 		await this.forgetFingerprint(numericId);
 		log.info("export-hap: unexposed device");
 	}
@@ -93398,10 +95867,10 @@ var ExportHapAddon = class extends BaseAddon {
 	/** Pending rebuild timers per deviceId — used to debounce. Cleared
 	*  on detach so stale timers can't republish a removed accessory. */
 	pendingRebuildTimers = /* @__PURE__ */ new Map();
-	/** Deterministic HAP accessory UUID for a device (matches `buildCameraAccessory`
-	*  and `unexposeDevice`). */
+	/** Deterministic HAP accessory UUID for a device — the same one the
+	*  orchestrator built it with (`mappers/kind.ts`). */
 	hapAccessoryUuid(deviceId) {
-		return import_dist.uuid.generate(`camstack:camera:${deviceId}`);
+		return accessoryUuidFor(this.findEntry(deviceId)?.mapperKind ?? "camera", deviceId);
 	}
 	/**
 	* Export fingerprint of a device from its PERSISTED features + type
@@ -93560,31 +96029,79 @@ var ExportHapAddon = class extends BaseAddon {
 			log.warn("export-hap: reconcile rebuild failed", { meta: { error: errMsg(err) } });
 		}
 	}
-	async resolveDisplayName(deviceId) {
-		const numeric = Number.parseInt(deviceId, 10);
-		if (!Number.isFinite(numeric)) return `Device ${deviceId}`;
+	/**
+	* The device's name and type, or `null` when the registry cannot answer.
+	*
+	* `null` is NOT "no such device" — it also covers a transient API failure,
+	* and every caller treats it as "keep doing what was already being done"
+	* rather than re-shaping an exposed accessory on incomplete information.
+	*/
+	async fetchDeviceSummary(deviceId) {
+		if (!Number.isFinite(deviceId)) return null;
 		try {
-			const device = await this.ctx.api.deviceManager?.getDevice.query({ deviceId: numeric });
-			if (device?.name) return device.name;
+			const device = await this.ctx.api.deviceManager?.getDevice.query({ deviceId });
+			if (!device) return null;
+			return {
+				name: device.name,
+				type: device.type
+			};
 		} catch (err) {
-			this.ctx.logger.withTags({ deviceId: numeric }).debug("export-hap: deviceManager.getDevice failed", { meta: { error: errMsg(err) } });
+			this.ctx.logger.withTags({ deviceId }).debug("export-hap: deviceManager.getDevice failed", { meta: { error: errMsg(err) } });
+			return null;
+		}
+	}
+	/**
+	* Which accessory shape this device would get, or `null` for "no Export tab".
+	*
+	* Two questions, in this order, because they fail differently:
+	*  1. the TYPE — a type with no orchestrator is refused outright;
+	*  2. for a non-camera, the CAPABILITIES — a device carrying nothing the
+	*     table maps would publish an accessory that pairs and does nothing, and
+	*     the operator cannot tell that from a broken integration.
+	*
+	* A camera skips (2): the camera orchestrator has always published on type
+	* alone, and adding a cap gate here would be a new way for an existing camera
+	* to lose its Export tab. A registry that cannot answer at all also resolves
+	* to `camera`, which is what every persisted entry predating this method
+	* carries.
+	*/
+	async resolveExportKind(deviceId) {
+		const summary = await this.fetchDeviceSummary(deviceId);
+		const kind = pickMapperKind(summary?.type);
+		if (kind === null) return null;
+		if (kind === "camera") return "camera";
+		try {
+			const proxy = await this.ctx.fetchDevice(deviceId);
+			const capNames = new Set(proxy.binding?.entries.map((entry) => entry.capName) ?? []);
+			if (rowsForCaps(capNames).length > 0) return "generic";
+			this.ctx.logger.withTags({ deviceId }).debug("export-hap: no Export tab — no mapped caps", { meta: {
+				type: summary?.type,
+				caps: [...capNames].toSorted().join(",")
+			} });
+			return null;
+		} catch (err) {
+			this.ctx.logger.withTags({ deviceId }).debug("export-hap: no Export tab — capability read failed", { meta: {
+				type: summary?.type,
+				error: errMsg(err)
+			} });
+			return null;
 		}
-		return `Device ${deviceId}`;
 	}
 	globalSettingsSchema() {
 		return this.schema({ sections: [{
 			id: "export-hap",
 			title: "HomeKit Export",
-			description: "Publishes a HomeKit bridge. After the addon boots, scan the pairing QR (or enter the setup code) from the Exported devices panel in the iOS Home app. After pairing, mark individual devices as \"Expose to HomeKit\" on each device's settings page.",
+			description: "Publishes each exposed device as its own HomeKit accessory, sharing one setup code. Mark a device \"Expose to HomeKit\" on its settings page, then add it in the iOS Home app (+ → Add Accessory) and enter the setup code shown there.",
 			columns: 1,
 			fields: [
 				this.field({
 					type: "text",
 					key: "bridgeName",
-					label: "Bridge name",
-					description: "Name shown in iOS Home and in the Bonjour advertisement.",
+					label: "Installation name",
+					description: "Legacy. Every exposed device is published STANDALONE, under its own camstack device name — HomeKit cameras cannot be bridged, so nothing is bridged. This string only seeds the identity generated on first boot and is not shown in iOS Home.",
 					default: DEFAULT_CONFIG.bridgeName,
-					requiresRestart: true
+					requiresRestart: true,
+					placement: { tab: "advanced" }
 				}),
 				this.field({
 					type: "number",
@@ -93620,21 +96137,13 @@ var ExportHapAddon = class extends BaseAddon {
 					description: "Duration of a single pan/tilt momentary command issued by the PTZ direction switches in Apple Home. Lower = finer steps; higher = bigger sweeps per tap. Defaults to 400ms.",
 					default: DEFAULT_CONFIG.ptzPulseMs,
 					placement: { tab: "advanced" }
-				}),
-				this.field({
-					type: "boolean",
-					key: "hksvPreview",
-					label: "HKSV Developer Preview (experimental)",
-					description: "Advertise Apple's HomeKit Secure Video Developer Preview services — HEVC streaming and the WebRTC stream-management surface — alongside the classic camera profile. Apple published this specification on 2026-06-03 and no shipping controller is known to negotiate it yet. Leave off unless you are testing against a preview build: advertising unknown services to a paired controller can disturb the classic path that works today.",
-					default: DEFAULT_CONFIG.hksvPreview,
-					requiresRestart: true,
-					placement: { tab: "advanced" }
 				})
 			]
 		}] });
 	}
 	async buildDeviceSettingsContribution(deviceId) {
-		if (!await this.isCameraDevice(deviceId)) return null;
+		const kind = await this.resolveExportKind(deviceId);
+		if (kind === null) return null;
 		const entry = this.findEntry(deviceId);
 		const settings = entry?.settings ?? DEFAULT_DEVICE_SETTINGS;
 		const enabled = entry !== null;
@@ -93651,6 +96160,32 @@ var ExportHapAddon = class extends BaseAddon {
 		} catch (err) {
 			this.ctx.logger.withTags({ deviceId }).debug("export-hap: setupURI failed for per-device contribution", { meta: { error: errMsg(err) } });
 		}
+		const cameraFields = kind !== "camera" ? [] : [{
+			type: "select",
+			key: streamPreferenceKey,
+			label: "Source stream (HomeKit)",
+			description: "Which camstack profile slot HomeKit pulls. Auto = the broker picks the slot closest to 1080p at session start.",
+			options: HAP_STREAM_PREFERENCE_OPTIONS,
+			required: true,
+			value: settings.streamPreference,
+			showWhen: {
+				field: enabledKey,
+				equals: true
+			},
+			immediate: true
+		}, {
+			type: "boolean",
+			key: hksvKey,
+			label: "HomeKit recording (Secure Video)",
+			description: "Offer “Stream and Allow Recording” in iOS Home. Requires iCloud+ and a home hub. Keeps a continuous 8s prebuffer for this camera (~0.7% of one CPU core, H.264 sources only).",
+			style: "switch",
+			value: resolveHksvRecording(settings),
+			showWhen: {
+				field: enabledKey,
+				equals: true
+			},
+			immediate: true
+		}];
 		return {
 			tabs: [{
 				id: "export",
@@ -93661,7 +96196,7 @@ var ExportHapAddon = class extends BaseAddon {
 			sections: [{
 				id: "export-hap",
 				title: "HomeKit Export",
-				description: "Mirror this camera into the HomeKit bridge so iOS Home can pair with it.",
+				description: kind === "camera" ? "Publish this camera as its own HomeKit accessory so iOS Home can pair with it." : "Publish this device as its own HomeKit accessory. Its capabilities decide which controls iOS Home shows.",
 				tab: "export",
 				columns: 1,
 				order: 10,
@@ -93677,7 +96212,7 @@ var ExportHapAddon = class extends BaseAddon {
 						type: "qr-code",
 						key: "__hap-pair-qr",
 						label: paired ? "Pairing QR (already paired)" : "Pairing QR",
-						caption: paired ? `Already paired with at least one device. Scan from another iPhone / iPad to add it there too. Setup code: ${this.config.identity.pincode}.` : `Scan with the iOS Camera app to pair this camera in HomeKit. Setup code: ${this.config.identity.pincode}.`,
+						caption: paired ? `Already paired with at least one device. Scan from another iPhone / iPad to add it there too. Setup code: ${this.config.identity.pincode}.` : `Scan with the iOS Camera app to pair this accessory in HomeKit. Setup code: ${this.config.identity.pincode}.`,
 						value: qrValue,
 						size: 192,
 						alt: `HomeKit pairing QR for ${name}`,
@@ -93690,38 +96225,12 @@ var ExportHapAddon = class extends BaseAddon {
 						type: "boolean",
 						key: enabledKey,
 						label: "Expose to HomeKit",
-						description: "Toggle to publish this camera onto the HAP bridge.",
+						description: "Toggle to publish this device as a HomeKit accessory.",
 						style: "switch",
 						value: enabled,
 						immediate: true
 					},
-					{
-						type: "select",
-						key: streamPreferenceKey,
-						label: "Source stream (HomeKit)",
-						description: "Which camstack profile slot HomeKit pulls. Auto = the broker picks the slot closest to 1080p at session start.",
-						options: HAP_STREAM_PREFERENCE_OPTIONS,
-						required: true,
-						value: settings.streamPreference,
-						showWhen: {
-							field: enabledKey,
-							equals: true
-						},
-						immediate: true
-					},
-					{
-						type: "boolean",
-						key: hksvKey,
-						label: "HomeKit recording (Secure Video)",
-						description: "Offer “Stream and Allow Recording” in iOS Home. Requires iCloud+ and a home hub. Keeps a continuous 8s prebuffer for this camera (~0.7% of one CPU core, H.264 sources only).",
-						style: "switch",
-						value: resolveHksvRecording(settings),
-						showWhen: {
-							field: enabledKey,
-							equals: true
-						},
-						immediate: true
-					}
+					...cameraFields
 				]
 			}]
 		};
@@ -93787,23 +96296,6 @@ var ExportHapAddon = class extends BaseAddon {
 		}
 		return { success: true };
 	}
-	/**
-	* Camera-only gate — HomeKit export only knows how to mirror cameras
-	* today. Mirrors the snapshot addon's source-side filter so the
-	* device-details page doesn't render an "Export" tab on lights /
-	* switches / sensors.
-	*/
-	async isCameraDevice(deviceId) {
-		const api = this.ctx.api;
-		if (!api.deviceManager) return true;
-		try {
-			const dev = await api.deviceManager.getDevice.query({ deviceId });
-			if (!dev) return true;
-			return dev.type === DeviceType.Camera;
-		} catch {
-			return true;
-		}
-	}
 	findEntry(deviceId) {
 		const id = String(deviceId);
 		return this.config.exposed.find((e) => e.deviceId === id) ?? null;