@camstack/addon-provider-reolink 1.1.17 → 1.1.19

package/dist/addon.js

@@ -4655,7 +4655,7 @@ function _instanceof(cls, params = {}) {
 	return inst;
 }
 //#endregion
-//#region ../types/dist/sleep-BiDFW0E7.mjs
+//#region ../types/dist/sleep-CZDdRBua.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -7453,7 +7453,16 @@ var DecoderStatsSchema = object({
 	inputFps: number(),
 	outputFps: number(),
 	avgDecodeTimeMs: number(),
-	droppedFrames: number()
+	droppedFrames: number(),
+	/**
+	* Pull-mode adaptive-fps telemetry (optional — only pull sessions run the
+	* lag-driven controller; push sessions omit these). `lagMs` is the EWMA of
+	* the decoder's real-time drift (rising = falling behind live); `adaptiveFps`
+	* is the current lag-throttled emit rate (≤ `effectiveFps` ceiling).
+	*/
+	lagMs: number().optional(),
+	effectiveFps: number().optional(),
+	adaptiveFps: number().optional()
 });
 var DecoderSessionConfigSchema = object({
 	codec: string(),
@@ -7494,7 +7503,15 @@ var DecoderSessionConfigSchema = object({
 	*   other — `pullFrames` returns nothing for an `'shm'` session and
 	*   `pullHandles` returns nothing for a `'callback'` session.
 	*/
-	frameSink: _enum(["callback", "shm"]).default("callback")
+	frameSink: _enum(["callback", "shm"]).default("callback"),
+	/**
+	* Per-camera decoder DEBUG facility. When `true`, a pull-mode session emits
+	* a throttled (~1Hz) structured `decoder debug` line (effective/adaptive fps,
+	* real-time lag, dropped-frame delta, avg decode time, hwaccel). Mirrors the
+	* stream-broker's `streamingDebug` gate — off by default so production logs
+	* stay quiet and the emit path pays zero per-frame cost when disabled.
+	*/
+	debug: boolean().optional()
 });
 var EncodeProfileSchema = object({
 	video: object({
@@ -10558,6 +10575,100 @@ var coverCapability = {
 	runtimeState: CoverStatusSchema
 };
 /**
+* Vendor-neutral day/night (IR-cut) control — the per-camera config cap
+* shared by reolink / hikvision / amcrest. Models the common firmware
+* surface: the IR-cut switching MODE plus the two knobs that gate it
+* (photocell `sensitivity` + `switchDelaySec`). Each vendor maps these
+* onto its own ISAPI / Baichuan / Dahua-CGI fields; the cap standardises
+* the shape so ONE derived-form renders every camera.
+*
+* Follows the D14 `deviceConfig` archetype (see `stream-params.cap.ts`):
+* `getOptions` advertises per-camera availability, `getStatus` (auto-
+* injected from `status`) reports the live values, and a single
+* `setSettings` mutation applies a partial change. No hand-written
+* settings-contribution methods — the framework derives the UI + save
+* routing from this surface.
+*/
+/** IR-cut switching mode. `schedule` = time-of-day table configured on the camera. */
+var DayNightModeSchema = _enum([
+	"auto",
+	"day",
+	"night",
+	"schedule"
+]);
+/** Normalized numeric range descriptor — `{ min, max, step }` per the
+*  getOptions availability convention. Normalized values are 0–100. */
+var NormalizedRangeSchema$1 = object({
+	min: number(),
+	max: number(),
+	step: number()
+});
+/**
+* Current day/night state. Optional fields are absent when the camera
+* does not expose that knob (a photocell-less model reports no
+* `sensitivity`). `lastFetchedAt` feeds the runtime-state bridge.
+*/
+var DayNightStatusSchema = object({
+	mode: DayNightModeSchema,
+	/** IR-cut trigger sensitivity, NORMALIZED 0–100 (higher = switches to night sooner). */
+	sensitivity: number().optional(),
+	/** Delay before the IR-cut filter flips, in seconds. */
+	switchDelaySec: number().optional(),
+	lastFetchedAt: number()
+});
+/**
+* Per-camera availability descriptor — drives which controls the admin UI
+* renders. Booleans as `supportsX`; numeric ranges as `{ min, max, step }`
+* (normalized 0–100); the mode choice-set as an array. A provider returns
+* honest, camera-probed values — never hardcoded.
+*/
+var DayNightOptionsSchema = object({
+	/** Modes this camera accepts. Empty → the camera has no configurable day/night mode. */
+	modes: array(DayNightModeSchema),
+	supportsSensitivity: boolean(),
+	/** Present when `supportsSensitivity` — the normalized 0–100 range. */
+	sensitivity: NormalizedRangeSchema$1.optional(),
+	supportsSwitchDelay: boolean(),
+	/** Present when `supportsSwitchDelay` — the allowed delay range in seconds. */
+	switchDelaySec: NormalizedRangeSchema$1.optional()
+});
+/**
+* Partial change to the day/night config — every field optional. A
+* provider ignores fields it does not support.
+*/
+var DayNightSettingsPatchSchema = object({
+	mode: DayNightModeSchema.optional(),
+	sensitivity: number().optional(),
+	switchDelaySec: number().optional()
+});
+var dayNightCapability = {
+	name: "day-night",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [DeviceType.Camera],
+	deviceConfig: { ui: {
+		kind: "derived-form",
+		builderId: "day-night",
+		tab: "image"
+	} },
+	methods: {
+		getOptions: method(object({ deviceId: number() }), DayNightOptionsSchema),
+		setSettings: method(object({
+			deviceId: number(),
+			settings: DayNightSettingsPatchSchema
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		})
+	},
+	status: {
+		schema: DayNightStatusSchema,
+		kind: "poll"
+	},
+	runtimeState: DayNightStatusSchema
+};
+/**
 * Identity envelope for a device's upstream-system metadata.
 *
 * Two jobs:
@@ -11216,6 +11327,155 @@ var imageCapability = {
 	runtimeState: ImageStatusSchema
 };
 /**
+* Vendor-neutral image / picture-adjustment cap — the per-camera config
+* cap shared by reolink / hikvision / amcrest. Models the common ISP
+* surface: the four picture sliders (brightness / contrast / saturation /
+* sharpness), orientation (mirror / flip / rotate), white-balance,
+* exposure and backlight-compensation modes.
+*
+* NORMALIZATION: every slider is a normalized int 0–100. Vendors expose
+* these natively as 0–100 or 0–255 (or other ranges); each provider maps
+* its native range to/from this normalized 0–100 space so the cap surface
+* (and the derived form) is identical across cameras. `warmth` (manual
+* white-balance) is likewise normalized 0–100.
+*
+* Follows the D14 `deviceConfig` archetype (see `stream-params.cap.ts`):
+* `getOptions` advertises per-camera availability, `getStatus` (auto-
+* injected from `status`) reports the live values, and a single
+* `setSettings` mutation applies a partial change. No hand-written
+* settings-contribution methods — the framework derives the UI + save
+* routing from this surface.
+*/
+/** Sensor/image rotation, degrees clockwise. */
+var ImageRotateSchema = _enum([
+	"0",
+	"90",
+	"180",
+	"270"
+]);
+/** White-balance mode. `manual` unlocks the normalized `warmth` knob. */
+var WhiteBalanceModeSchema = _enum(["auto", "manual"]);
+/** Exposure mode. */
+var ExposureModeSchema = _enum(["auto", "manual"]);
+/**
+* Backlight-compensation mode:
+*   - `off` — disabled
+*   - `blc` — backlight compensation
+*   - `wdr` — wide dynamic range
+*   - `hlc` — highlight compensation
+*/
+var BacklightModeSchema = _enum([
+	"off",
+	"blc",
+	"wdr",
+	"hlc"
+]);
+/** Normalized numeric range descriptor — `{ min, max, step }` per the
+*  getOptions availability convention. Slider values are normalized 0–100. */
+var NormalizedRangeSchema = object({
+	min: number(),
+	max: number(),
+	step: number()
+});
+/**
+* Current image-adjustment state. Every field optional — absent when the
+* camera does not expose that control. Slider values are NORMALIZED 0–100.
+* `lastFetchedAt` feeds the runtime-state bridge.
+*/
+var ImageSettingsStatusSchema = object({
+	/** Normalized 0–100. */
+	brightness: number().optional(),
+	/** Normalized 0–100. */
+	contrast: number().optional(),
+	/** Normalized 0–100. */
+	saturation: number().optional(),
+	/** Normalized 0–100. */
+	sharpness: number().optional(),
+	mirror: boolean().optional(),
+	flip: boolean().optional(),
+	rotate: ImageRotateSchema.optional(),
+	whiteBalance: WhiteBalanceModeSchema.optional(),
+	/** Manual white-balance warmth, NORMALIZED 0–100. Meaningful only when `whiteBalance === 'manual'`. */
+	warmth: number().optional(),
+	exposureMode: ExposureModeSchema.optional(),
+	backlightMode: BacklightModeSchema.optional(),
+	lastFetchedAt: number()
+});
+/**
+* Per-camera availability descriptor — drives which controls the admin UI
+* renders. Booleans as `supportsX`; numeric ranges as `{ min, max, step }`
+* (the normalized 0–100 range); enums as arrays of supported values (empty
+* array → control hidden). A provider returns honest, camera-probed values
+* — never hardcoded.
+*/
+var ImageSettingsOptionsSchema = object({
+	supportsBrightness: boolean(),
+	brightness: NormalizedRangeSchema.optional(),
+	supportsContrast: boolean(),
+	contrast: NormalizedRangeSchema.optional(),
+	supportsSaturation: boolean(),
+	saturation: NormalizedRangeSchema.optional(),
+	supportsSharpness: boolean(),
+	sharpness: NormalizedRangeSchema.optional(),
+	supportsMirror: boolean(),
+	supportsFlip: boolean(),
+	/** Supported rotation values. Empty → rotation not configurable. */
+	rotateOptions: array(ImageRotateSchema),
+	/** Supported white-balance modes. Empty → white-balance not configurable. */
+	whiteBalanceModes: array(WhiteBalanceModeSchema),
+	supportsWarmth: boolean(),
+	/** Present when `supportsWarmth` — the normalized 0–100 range. */
+	warmth: NormalizedRangeSchema.optional(),
+	/** Supported exposure modes. Empty → exposure not configurable. */
+	exposureModes: array(ExposureModeSchema),
+	/** Supported backlight modes. Empty → backlight-compensation not configurable. */
+	backlightModes: array(BacklightModeSchema)
+});
+/**
+* Partial change to the image config — every field optional. Slider values
+* are normalized 0–100. A provider ignores fields it does not support.
+*/
+var ImageSettingsPatchSchema = object({
+	brightness: number().optional(),
+	contrast: number().optional(),
+	saturation: number().optional(),
+	sharpness: number().optional(),
+	mirror: boolean().optional(),
+	flip: boolean().optional(),
+	rotate: ImageRotateSchema.optional(),
+	whiteBalance: WhiteBalanceModeSchema.optional(),
+	warmth: number().optional(),
+	exposureMode: ExposureModeSchema.optional(),
+	backlightMode: BacklightModeSchema.optional()
+});
+var imageSettingsCapability = {
+	name: "image-settings",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [DeviceType.Camera],
+	deviceConfig: { ui: {
+		kind: "derived-form",
+		builderId: "image-settings",
+		tab: "image"
+	} },
+	methods: {
+		getOptions: method(object({ deviceId: number() }), ImageSettingsOptionsSchema),
+		setSettings: method(object({
+			deviceId: number(),
+			settings: ImageSettingsPatchSchema
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		})
+	},
+	status: {
+		schema: ImageSettingsStatusSchema,
+		kind: "poll"
+	},
+	runtimeState: ImageSettingsStatusSchema
+};
+/**
 * Robotic lawn-mower cap. Models HA `lawn_mower.*` entities — anything
 * with a mowing lifecycle plus a dock action.
 *
@@ -12214,6 +12474,16 @@ var RunnerCameraConfigSchema = object({
 	* this gate is bypassed.
 	*/
 	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
+	* `occupancyRecheckSec` / `occupancyRecheckFrames` sliders only take effect
+	* (and only render) when this is enabled.
+	*/
+	occupancyRecheckEnabled: boolean().default(false),
 	occupancyRecheckSec: number().min(occupancyRecheckSecField.min).max(occupancyRecheckSecField.max).default(occupancyRecheckSecField.default),
 	occupancyRecheckFrames: number().min(occupancyRecheckFramesField.min).max(occupancyRecheckFramesField.max).default(occupancyRecheckFramesField.default),
 	/**
@@ -14219,6 +14489,7 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	contact: contactCapability,
 	control: controlCapability,
 	cover: coverCapability,
+	dayNight: dayNightCapability,
 	deviceDiscovery: deviceDiscoveryCapability,
 	deviceStatus: deviceStatusCapability,
 	doorbell: doorbellCapability,
@@ -14231,6 +14502,7 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	humidifier: humidifierCapability,
 	humiditySensor: humiditySensorCapability,
 	image: imageCapability,
+	imageSettings: imageSettingsCapability,
 	lawnMowerControl: lawnMowerControlCapability,
 	lockControl: lockControlCapability,
 	mediaPlayer: mediaPlayerCapability,
@@ -16157,7 +16429,9 @@ method(object({ codec: string() }), boolean()), method(_void(), object({
 	id: string(),
 	name: string(),
 	isPullMode: boolean().optional(),
-	priority: number().optional()
+	priority: number().optional(),
+	hwaccel: string().optional(),
+	probedBestHwaccel: string().optional()
 })), method(DecoderSessionConfigSchema, object({
 	sessionId: string(),
 	nodeId: string()
@@ -18071,7 +18345,17 @@ var AgentAddonConfigSchema = object({
 });
 var AgentPipelineSettingsSchema = object({
 	addonDefaults: record(string(), AgentAddonConfigSchema).readonly(),
-	maxCameras: number().int().nonnegative().nullable().default(null)
+	maxCameras: number().int().nonnegative().nullable().default(null),
+	/** Per-node detection weight (relative share for the quota balancer). */
+	detectWeight: number().positive().optional(),
+	/** Node is eligible to run the detection pipeline (decode + inference). */
+	detect: boolean().optional(),
+	/** Node is eligible to host decoder sessions. */
+	decode: boolean().optional(),
+	/** Node is eligible to run audio-analyzer sessions. */
+	audio: boolean().optional(),
+	/** Node is eligible to be the ingest / source-owner (serve the restream). */
+	ingest: boolean().optional()
 });
 var CameraPipelineForAgentSchema = object({
 	steps: array(PipelineStepInputSchema).readonly(),
@@ -18377,6 +18661,21 @@ method(object({
 }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
+}), method(object({
+	agentNodeId: string(),
+	detectWeight: number().positive().nullable()
+}), object({ success: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	agentNodeId: string(),
+	detect: boolean().nullable().optional(),
+	decode: boolean().nullable().optional(),
+	audio: boolean().nullable().optional(),
+	ingest: boolean().nullable().optional()
+}), object({ success: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
 }), method(object({ deviceId: number() }), CameraPipelineSettingsSchema.nullable()), method(object({
 	deviceId: number(),
 	addonId: string(),
@@ -22496,6 +22795,18 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"dayNight.getOptions": {
+		capName: "day-night",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"dayNight.setSettings": {
+		capName: "day-night",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"decoder.createSession": {
 		capName: "decoder",
 		capScope: "system",
@@ -23426,6 +23737,18 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"imageSettings.getOptions": {
+		capName: "image-settings",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"imageSettings.setSettings": {
+		capName: "image-settings",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"integrations.create": {
 		capName: "integrations",
 		capScope: "system",
@@ -24608,6 +24931,18 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.setAgentCapabilities": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"pipelineOrchestrator.setAgentDetectWeight": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.setAgentMaxCameras": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -214519,6 +214854,118 @@ function buildRawState(reader) {
 	};
 }
 //#endregion
+//#region src/day-night-mapping.ts
+/**
+* Maps between the vendor-neutral `day-night` cap's `DayNightMode` and
+* Reolink's raw `VideoInput.dayNight` / `InputAdvanceCfg.DayNight.mode`
+* string (Baichuan cmdId 25/26 via `setIsp`/`getVideoInput`). Firmwares
+* report/accept camel-cased values such as `auto`, `color`,
+* `blackAndWhite` — case varies by model; the lib's `normalizeDayNightMode`
+* lower-cases the first letter before push, so the mapping here works off
+* a case-insensitive compare.
+*
+* There is no on-camera "schedule" mode in the Baichuan protocol — the
+* `day-night` cap's `getOptions.modes` never advertises `'schedule'` for
+* a Reolink device.
+*/
+var NIGHT_TOKENS = new Set([
+	"blackandwhite",
+	"black&white",
+	"bw",
+	"night",
+	"blackwhite"
+]);
+var DAY_TOKENS = new Set([
+	"color",
+	"colour",
+	"day"
+]);
+/**
+* Map the camera's raw `dayNight` string to the cap's normalized mode.
+* Falls back to `'auto'` for an unrecognized or missing value — every
+* Reolink camera defaults to auto IR-cut switching out of the box.
+*/
+function reolinkDayNightModeToCap(raw) {
+	if (typeof raw !== "string" || raw.length === 0) return "auto";
+	const normalized = raw.toLowerCase();
+	if (normalized === "auto") return "auto";
+	if (NIGHT_TOKENS.has(normalized)) return "night";
+	if (DAY_TOKENS.has(normalized)) return "day";
+	return "auto";
+}
+/**
+* Map the cap's normalized mode to the raw value Reolink's `setIsp`
+* expects. `'schedule'` has no Reolink equivalent — `getOptions.modes`
+* never advertises it, so a well-behaved caller never passes it here;
+* guard defensively in case one does anyway.
+*/
+function capDayNightModeToReolink(mode) {
+	switch (mode) {
+		case "auto": return "auto";
+		case "day": return "color";
+		case "night": return "blackAndWhite";
+		case "schedule": throw new Error("Reolink cameras do not support a scheduled day/night mode");
+	}
+}
+//#endregion
+//#region src/image-settings-mapping.ts
+/**
+* Reolink's `InputAdvanceCfg.Exposure.mode` (Baichuan cmdId 25/26, via
+* `setIsp`/`getIsp`) uses the same two values as the `image-settings`
+* cap's `ExposureMode` (`'auto' | 'manual'`), modulo case — firmwares
+* report it in varying case. Returns `undefined` for any other/missing
+* value so the caller can omit the field rather than report a lie.
+*/
+function reolinkExposureModeToCap(raw) {
+	if (typeof raw !== "string") return void 0;
+	const normalized = raw.toLowerCase();
+	return normalized === "auto" || normalized === "manual" ? normalized : void 0;
+}
+//#endregion
+//#region src/image-value-normalization.ts
+/**
+* Generic native-range <-> normalized-0-100 conversion shared by the
+* `day-night` (sensitivity) and `image-settings` (brightness / contrast /
+* saturation / sharpness) native caps. Both caps' vendor-neutral contract
+* normalizes every slider to an integer 0-100 scale; each provider maps
+* its own native range (Reolink's image sliders are 0..255, the day/night
+* threshold range is camera-probed) to/from that scale here.
+*/
+/** Map a native value inside `[min, max]` to the normalized 0-100 scale. */
+function normalizeToPercent(value, min, max) {
+	if (max <= min) return 0;
+	const percent = (value - min) / (max - min) * 100;
+	return Math.max(0, Math.min(100, Math.round(percent)));
+}
+/** Map a normalized 0-100 value back to the native `[min, max]` range. */
+function denormalizeFromPercent(percent, min, max) {
+	return Math.round(min + Math.max(0, Math.min(100, percent)) / 100 * (max - min));
+}
+//#endregion
+//#region src/native-sdp-overlay.ts
+/**
+* Return a new descriptor list in which every native `pull-rfc4571` entry with
+* a live upstream server carries that server's real `tcp://` URL + real SDP.
+* Pure + immutable: non-native or cold entries pass through unchanged;
+* upgraded entries are fresh objects and sibling metadata keys are preserved.
+*/
+function overlayLiveNativeRfc4571Sdp(descriptors, liveServerFor) {
+	return descriptors.map((descriptor) => {
+		if (descriptor.kind !== "pull-rfc4571") return descriptor;
+		const live = liveServerFor(descriptor.camStreamId);
+		if (!live) return descriptor;
+		const auth = `${encodeURIComponent(live.username)}:${encodeURIComponent(live.password)}`;
+		return {
+			...descriptor,
+			url: `tcp://${auth}@${live.host}:${live.port}`,
+			metadata: {
+				...descriptor.metadata,
+				sdp: live.sdp
+			}
+		};
+	});
+}
+//#endregion
 //#region src/accessory-probe-flags.ts
 var FLAG_KEYS = [
 	"hasBattery",
@@ -218729,6 +219176,8 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 		});
 		this.registerMotionZonesCap();
 		this.registerPrivacyMaskCap();
+		this.registerDayNightCap();
+		this.registerImageSettingsCap();
 		this.registerStreamCatalogProvider();
 		this.registerNativeObjectDetectionCap();
 		const cache = this.config.get("deviceCache");
@@ -218769,6 +219218,10 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 	*  cached from `getMotionAlarm` so `setZone` can re-encode a patch's
 	*  `cells` without an extra GET round-trip. */
 	motionZonesGrid = null;
+	/** Single-flight guard for the `day-night` cap refresh. */
+	dayNightRefreshInFlight = null;
+	/** Single-flight guard for the `image-settings` cap refresh. */
+	imageSettingsRefreshInFlight = null;
 	/**
 	* Single-flight guard for snapshot fetches (Slice 10). When two
 	* consumers hit `getSnapshot` concurrently we issue ONE Baichuan
@@ -220030,6 +220483,244 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 		this.ctx.logger.info("Reolink privacy-mask cap registered (read + enable + zone write)", { tags: { deviceId: this.id } });
 	}
 	/**
+	* Register the vendor-neutral `day-night` cap.
+	*
+	* Mirrors `registerMotionZonesCap`: the trampoline pattern over
+	* `createRuntimeStateBridge`, with a single-flight `refresh` that
+	* round-trips `getVideoInput` (mode) + `getDayNightThreshold`
+	* (sensitivity). Both are Baichuan cmdId 25/26/297 reads already used
+	* elsewhere in this file (`refreshParentSettingsSnapshot`,
+	* `applySettingsPatch`'s ISP section) — this cap just wraps them
+	* behind the shared `getOptions`/`getStatus`/`setSettings` surface
+	* instead of the legacy settings-form blob.
+	*
+	* - `getStatus`  — slice-driven via bridge (stale → refresh).
+	* - `getOptions` — on-demand probe; `modes` is gated on the camera
+	*   actually reporting a `dayNight` value, `supportsSensitivity` on a
+	*   successful `getDayNightThreshold` probe. Reolink has no
+	*   switch-delay knob, so `supportsSwitchDelay` is always `false`.
+	* - `setSettings` — read-modify-write via `setIsp`; `sensitivity` is
+	*   denormalized against the camera's OWN probed threshold range
+	*   (never a hardcoded 0..255 guess).
+	*/
+	registerDayNightCap() {
+		const channel = this.getChannel();
+		const CAP_NAME = "day-night";
+		const STALE_MS = 1e4;
+		/** Round-trip `getVideoInput` + `getDayNightThreshold`, map into the
+		*  cap status schema, write slice. */
+		const refreshFromCamera = async () => {
+			if (this.dayNightRefreshInFlight) return this.dayNightRefreshInFlight;
+			const promise = (async () => {
+				try {
+					const api = await this.ensureApi();
+					const vi = (await api.getVideoInput(channel))?.body?.VideoInput;
+					const next = {
+						mode: reolinkDayNightModeToCap(vi?.dayNight),
+						lastFetchedAt: Date.now()
+					};
+					try {
+						const range = (await api.getDayNightThreshold(channel))?.body?.DayNightThreshold?.thresholdval;
+						if (typeof range?.min === "number" && typeof range?.max === "number" && typeof range?.cur === "number") next.sensitivity = normalizeToPercent(range.cur, range.min, range.max);
+					} catch (err) {
+						this.ctx.logger.debug("day-night threshold probe failed", {
+							tags: { deviceId: this.id },
+							meta: { error: err instanceof Error ? err.message : String(err) }
+						});
+					}
+					this.runtimeState.setCapState(CAP_NAME, next);
+				} catch (err) {
+					this.ctx.logger.debug("day-night refresh failed — keeping last slice", {
+						tags: { deviceId: this.id },
+						meta: { error: err instanceof Error ? err.message : String(err) }
+					});
+				}
+			})();
+			this.dayNightRefreshInFlight = promise;
+			try {
+				await promise;
+			} finally {
+				this.dayNightRefreshInFlight = null;
+			}
+		};
+		const provider = {
+			getStatus: createRuntimeStateBridge({
+				runtimeState: this.runtimeState,
+				cap: dayNightCapability,
+				ownDeviceId: this.id,
+				refresh: refreshFromCamera,
+				staleMs: STALE_MS,
+				empty: () => ({
+					mode: "auto",
+					lastFetchedAt: 0
+				})
+			}).getStatus,
+			getOptions: async ({ deviceId }) => {
+				if (deviceId !== this.id) throw new Error(`ReolinkCamera: deviceId mismatch, expected ${this.id}, got ${deviceId}`);
+				const api = await this.ensureApi();
+				const modes = ((await api.getVideoInput(channel))?.body?.VideoInput)?.dayNight !== void 0 ? [
+					"auto",
+					"day",
+					"night"
+				] : [];
+				let supportsSensitivity = false;
+				let sensitivityRange;
+				try {
+					const range = (await api.getDayNightThreshold(channel))?.body?.DayNightThreshold?.thresholdval;
+					if (typeof range?.min === "number" && typeof range?.max === "number") {
+						supportsSensitivity = true;
+						sensitivityRange = {
+							min: 0,
+							max: 100,
+							step: 1
+						};
+					}
+				} catch (err) {
+					this.ctx.logger.debug("day-night threshold options probe failed", {
+						tags: { deviceId: this.id },
+						meta: { error: err instanceof Error ? err.message : String(err) }
+					});
+				}
+				return {
+					modes,
+					supportsSensitivity,
+					...sensitivityRange !== void 0 ? { sensitivity: sensitivityRange } : {},
+					supportsSwitchDelay: false
+				};
+			},
+			setSettings: async ({ deviceId, settings }) => {
+				if (deviceId !== this.id) return;
+				const api = await this.ensureApi();
+				const ispPatch = {};
+				if (settings.mode !== void 0) ispPatch.dayNight = capDayNightModeToReolink(settings.mode);
+				if (settings.sensitivity !== void 0) {
+					const range = (await api.getDayNightThreshold(channel))?.body?.DayNightThreshold?.thresholdval;
+					const min = typeof range?.min === "number" ? range.min : 0;
+					const max = typeof range?.max === "number" ? range.max : 100;
+					ispPatch.dayNightThreshold = denormalizeFromPercent(settings.sensitivity, min, max);
+				}
+				if (Object.keys(ispPatch).length > 0) await api.setIsp(channel, ispPatch);
+				await refreshFromCamera();
+			}
+		};
+		this.ctx.registerNativeCap(dayNightCapability, provider);
+		this.ctx.logger.info("Reolink day-night cap registered", { tags: { deviceId: this.id } });
+	}
+	/**
+	* Register the vendor-neutral `image-settings` cap.
+	*
+	* Mirrors `registerDayNightCap` / `registerMotionZonesCap`: the
+	* trampoline pattern over `createRuntimeStateBridge`, with a
+	* single-flight `refresh` that round-trips `getIsp` (cmdId 26 — the
+	* merged `VideoInput` + `InputAdvanceCfg` blob covers brightness /
+	* contrast / saturation / sharpness AND the exposure mode in one
+	* call). Sliders are normalized against Reolink's native 0..255 image
+	* range; `exposureMode` maps 1:1 onto the cap's `'auto' | 'manual'`.
+	*
+	* Reolink's Baichuan API (`@apocaliss92/nodelink-js` 0.6.7) has no
+	* write path for mirror / flip / rotate / white-balance / warmth, and
+	* `InputAdvanceCfg.BLC` (backlight) has no matching setter — those
+	* fields are honestly reported as unsupported (`false` / `[]`) rather
+	* than rendering dead controls. TODO: revisit if nodelink-js adds
+	* setters for any of these.
+	*/
+	registerImageSettingsCap() {
+		const channel = this.getChannel();
+		const CAP_NAME = "image-settings";
+		const STALE_MS = 1e4;
+		const SLIDER_MIN = 0;
+		const SLIDER_MAX = 255;
+		const NORMALIZED_RANGE = {
+			min: 0,
+			max: 100,
+			step: 1
+		};
+		/** Round-trip `getIsp`, map into the cap status schema, write slice. */
+		const refreshFromCamera = async () => {
+			if (this.imageSettingsRefreshInFlight) return this.imageSettingsRefreshInFlight;
+			const promise = (async () => {
+				try {
+					const isp = await (await this.ensureApi()).getIsp(channel);
+					const vi = isp?.body?.VideoInput;
+					const exposureRaw = isp?.body?.InputAdvanceCfg?.Exposure?.mode;
+					const next = { lastFetchedAt: Date.now() };
+					if (typeof vi?.bright === "number") next.brightness = normalizeToPercent(vi.bright, SLIDER_MIN, SLIDER_MAX);
+					if (typeof vi?.contrast === "number") next.contrast = normalizeToPercent(vi.contrast, SLIDER_MIN, SLIDER_MAX);
+					if (typeof vi?.saturation === "number") next.saturation = normalizeToPercent(vi.saturation, SLIDER_MIN, SLIDER_MAX);
+					if (typeof vi?.sharpen === "number") next.sharpness = normalizeToPercent(vi.sharpen, SLIDER_MIN, SLIDER_MAX);
+					const exposureMode = reolinkExposureModeToCap(typeof exposureRaw === "string" ? exposureRaw : void 0);
+					if (exposureMode !== void 0) next.exposureMode = exposureMode;
+					this.runtimeState.setCapState(CAP_NAME, next);
+				} catch (err) {
+					this.ctx.logger.debug("image-settings refresh failed — keeping last slice", {
+						tags: { deviceId: this.id },
+						meta: { error: err instanceof Error ? err.message : String(err) }
+					});
+				}
+			})();
+			this.imageSettingsRefreshInFlight = promise;
+			try {
+				await promise;
+			} finally {
+				this.imageSettingsRefreshInFlight = null;
+			}
+		};
+		const provider = {
+			getStatus: createRuntimeStateBridge({
+				runtimeState: this.runtimeState,
+				cap: imageSettingsCapability,
+				ownDeviceId: this.id,
+				refresh: refreshFromCamera,
+				staleMs: STALE_MS,
+				empty: () => ({ lastFetchedAt: 0 })
+			}).getStatus,
+			getOptions: async ({ deviceId }) => {
+				if (deviceId !== this.id) throw new Error(`ReolinkCamera: deviceId mismatch, expected ${this.id}, got ${deviceId}`);
+				const isp = await (await this.ensureApi()).getIsp(channel);
+				const vi = isp?.body?.VideoInput;
+				const exposureRaw = isp?.body?.InputAdvanceCfg?.Exposure?.mode;
+				const supportsBrightness = typeof vi?.bright === "number";
+				const supportsContrast = typeof vi?.contrast === "number";
+				const supportsSaturation = typeof vi?.saturation === "number";
+				const supportsSharpness = typeof vi?.sharpen === "number";
+				const exposureModes = typeof exposureRaw === "string" ? ["auto", "manual"] : [];
+				return {
+					supportsBrightness,
+					...supportsBrightness ? { brightness: NORMALIZED_RANGE } : {},
+					supportsContrast,
+					...supportsContrast ? { contrast: NORMALIZED_RANGE } : {},
+					supportsSaturation,
+					...supportsSaturation ? { saturation: NORMALIZED_RANGE } : {},
+					supportsSharpness,
+					...supportsSharpness ? { sharpness: NORMALIZED_RANGE } : {},
+					supportsMirror: false,
+					supportsFlip: false,
+					rotateOptions: [],
+					whiteBalanceModes: [],
+					supportsWarmth: false,
+					exposureModes,
+					backlightModes: []
+				};
+			},
+			setSettings: async ({ deviceId, settings }) => {
+				if (deviceId !== this.id) return;
+				const api = await this.ensureApi();
+				const imagePatch = {};
+				if (settings.brightness !== void 0) imagePatch.bright = denormalizeFromPercent(settings.brightness, SLIDER_MIN, SLIDER_MAX);
+				if (settings.contrast !== void 0) imagePatch.contrast = denormalizeFromPercent(settings.contrast, SLIDER_MIN, SLIDER_MAX);
+				if (settings.saturation !== void 0) imagePatch.saturation = denormalizeFromPercent(settings.saturation, SLIDER_MIN, SLIDER_MAX);
+				if (settings.sharpness !== void 0) imagePatch.sharpen = denormalizeFromPercent(settings.sharpness, SLIDER_MIN, SLIDER_MAX);
+				if (Object.keys(imagePatch).length > 0) await api.setImage(channel, imagePatch);
+				const ispPatch = {};
+				if (settings.exposureMode !== void 0) ispPatch.exposure = settings.exposureMode;
+				if (Object.keys(ispPatch).length > 0) await api.setIsp(channel, ispPatch);
+				await refreshFromCamera();
+			}
+		};
+		this.ctx.registerNativeCap(imageSettingsCapability, provider);
+		this.ctx.logger.info("Reolink image-settings cap registered", { tags: { deviceId: this.id } });
+	}
+	/**
 	* Register the `native-object-detection` cap.
 	*
 	* The runtimeState holds three fields:
@@ -220060,6 +220751,12 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 			}
 			return classes;
 		};
+		const buildEmptyState = () => ({
+			enabled: false,
+			lastByClass: {},
+			supportedClasses: buildSupportedClasses(),
+			lastFetchedAt: 0
+		});
 		const provider = {
 			getStatus: createRuntimeStateBridge({
 				runtimeState: this.runtimeState,
@@ -220067,12 +220764,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 				ownDeviceId: this.id,
 				refresh: async () => {},
 				staleMs: Infinity,
-				empty: () => ({
-					enabled: false,
-					lastByClass: {},
-					supportedClasses: buildSupportedClasses(),
-					lastFetchedAt: 0
-				})
+				empty: buildEmptyState
 			}).getStatus,
 			setEnabled: async ({ deviceId, enabled }) => {
 				if (deviceId !== this.id) return;
@@ -220086,6 +220778,10 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 			}
 		};
 		this.ctx.registerNativeCap(nativeObjectDetectionCapability, provider);
+		if (this.runtimeState.getCapState(CAP_NAME) === void 0) this.runtimeState.setCapState(CAP_NAME, {
+			...buildEmptyState(),
+			lastFetchedAt: Date.now()
+		});
 		this.ctx.logger.info("Reolink native-object-detection cap registered", { tags: { deviceId: this.id } });
 	}
 	/**
@@ -220529,17 +221225,39 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 	* session or touches the broker.
 	*/
 	async buildStreamCatalog() {
-		if (this.cachedStreamDescriptors?.length) return this.cachedStreamDescriptors;
-		if (this.buildStreamCatalogInFlight) return this.buildStreamCatalogInFlight;
+		if (this.cachedStreamDescriptors?.length) return this.withLiveNativeSdp(this.cachedStreamDescriptors);
+		if (this.buildStreamCatalogInFlight) return this.withLiveNativeSdp(await this.buildStreamCatalogInFlight);
 		const build = this.buildStreamCatalogUncached();
 		this.buildStreamCatalogInFlight = build;
 		try {
-			return await build;
+			return this.withLiveNativeSdp(await build);
 		} finally {
 			this.buildStreamCatalogInFlight = null;
 		}
 	}
 	/**
+	* Upgrade native `pull-rfc4571` descriptors to the live upstream server's
+	* real `tcp://` URL + real (sprop-bearing) SDP whenever a server is
+	* currently listening in `this.active`. The synthetic catalog SDP omits
+	* `sprop-parameter-sets`, which the raw ffmpeg decode reader cannot recover
+	* (it has no in-band SPS/PPS merge) — so a decode-path consumer that pulls
+	* the catalog after `materializeStreamSocket` must still see the real SDP.
+	* See `native-sdp-overlay.ts`.
+	*/
+	withLiveNativeSdp(descriptors) {
+		return overlayLiveNativeRfc4571Sdp(descriptors, (camStreamId) => {
+			const server = this.active.get(camStreamId)?.server;
+			if (!server?.server?.listening) return null;
+			return {
+				host: server.host,
+				port: server.port,
+				username: server.username,
+				password: server.password,
+				sdp: server.sdp
+			};
+		});
+	}
+	/**
 	* Synthesize the HTTP-FLV pull URL for a (channel, profile) pair. FLV is
 	* served off the Reolink Baichuan media port (default 1935, app `bcs`) as
 	* `channel<channel>_<profile>.bcs` — the same shape Frigate/go2rtc use. The
@@ -220763,13 +221481,16 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 		}
 		const url = `tcp://${`${encodeURIComponent(server.username)}:${encodeURIComponent(server.password)}`}@${server.host}:${server.port}`;
 		const codec = server.videoType === "H265" ? "h265" : "h264";
+		const descriptor = this.cachedStreamDescriptors?.find((d) => d.camStreamId === camStreamId);
 		await this.publishOne({
 			camStreamId,
 			kind: "pull-rfc4571",
-			label: camStreamId,
+			label: descriptor?.label ?? camStreamId,
 			url,
 			codec,
 			autoEligible: true,
+			...descriptor?.resolution ? { resolution: descriptor.resolution } : {},
+			...descriptor?.fps !== void 0 ? { fps: descriptor.fps } : {},
 			metadata: { sdp: server.sdp }
 		});
 		this.ctx.logger.info("materialized rfc4571 stream socket on broker demand", {