@camstack/addon-provider-amcrest 0.2.61 → 0.2.63

package/dist/addon.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
 //#endregion
 let node_crypto = require("node:crypto");
+let node_http = require("node:http");
+let node_https = require("node:https");
 let node_os = require("node:os");
 //#region ../types/dist/event-category-BZL-fdNj.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
@@ -12749,7 +12751,26 @@ var DiscoveryCandidateSchema = object({
 	* identity ahead of adoption. Rendering metadata (unit, precision)
 	* flows live through the cap STATUS SLICE after adoption.
 	*/
-	sourceInfo: SourceInfoSchema.optional()
+	sourceInfo: SourceInfoSchema.optional(),
+	/**
+	* Set when this candidate is a device the provider ALREADY owns.
+	*
+	* A scan cannot generally produce the identity a device was onboarded under
+	* (Reolink keys on `mac-<mac>`, learned at adopt time), so a stableId
+	* comparison never matches and an owned device looks addable. Re-adopting one
+	* overwrites its config with scan-derived values — that is how a Home Hub's
+	* Baichuan port was overwritten with its ONVIF port, taking the hub and its
+	* three child cameras offline for four hours.
+	*
+	* A provider that can recognise its own devices says so here. Absent means
+	* "not recognised", which is not the same as "known to be new" — a provider
+	* that cannot tell simply never sets it.
+	*/
+	alreadyOnboarded: boolean().optional(),
+	/** Numeric id of the device this candidate was matched to. Set with `alreadyOnboarded`. */
+	onboardedDeviceId: number().optional(),
+	/** Operator-facing name of the matched device, so the UI can say WHICH one it is. */
+	onboardedName: string().optional()
 });
 /**
 * Flat device summary returned by `createDevice` / `adoptDiscoveredDevice`.
@@ -28711,6 +28732,26 @@ var privacyMaskCapability = {
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastFetchedAt"]
 };
+/**
+* Collapse a camera's PER-PROFILE audio flags into the one answer
+* {@link PrivacyMaskStatusSchema.shape.audioEnabled} promises.
+*
+* Both firmwares this cap talks to store the flag per stream profile, and
+* both let those profiles disagree. The rule is `some`, not `every`: privacy
+* is only satisfied when NOTHING is carrying sound, so a camera whose sub
+* stream is still audible must read as `true` and be switchable off — not as
+* `false` because the main stream happens to be muted already.
+*
+* An empty list is `null` ("this camera reported no audio flag at all"),
+* never `false`.
+*
+* Lives here rather than in each provider so the rule the schema documents
+* and the rule the providers apply cannot drift apart.
+*/
+function summarisePrivacyAudio(profiles) {
+	if (profiles.length === 0) return null;
+	return profiles.some((p) => p.audioEnabled);
+}
 var PtzPresetSchema = object({
 	id: string(),
 	name: string()
@@ -33377,6 +33418,22 @@ var BaseDeviceProvider = class extends BaseAddon {
 	* failed — logged at ERROR with `tags.deviceId` and surfaced via
 	* `getStatus().error`.
 	*/
+	/**
+	* Repair a row's PERSISTED config blob immediately before it is restored.
+	* Default: no-op — most providers have nothing to heal.
+	*
+	* This exists because a restored device self-hydrates from the DB: `create()`
+	* passes `{}` and `BaseDevice` parses the stored blob against the device
+	* schema. A blob that lost a REQUIRED field therefore fails restore forever,
+	* and no later pass revisits it — a hub-adopted Reolink camera whose blob had
+	* been emptied failed all four bounded attempts against fields
+	* (`host`, `password`) it inherits from its parent and never dials itself.
+	*
+	* Implementations get every saved row, so a child can read its parent's blob.
+	* A heal that throws is treated like any other restore failure: retried under
+	* the bound, then reported — never swallowed.
+	*/
+	async healSavedConfig(_saved, _allSaved) {}
 	async onRestoreDevices(savedDevices) {
 		const restored = /* @__PURE__ */ new Set();
 		const failures = [];
@@ -33385,6 +33442,7 @@ var BaseDeviceProvider = class extends BaseAddon {
 			const Class = this.deviceClasses[saved.type];
 			if (!Class) throw new Error(`no device class registered for type "${saved.type}"`);
 			if (saved.parentDeviceId !== null && !restored.has(saved.parentDeviceId)) throw new Error(`parent device ${saved.parentDeviceId} not restored`);
+			await this.healSavedConfig(saved, savedDevices);
 			await this.ctx.kernel.devices.create(saved.stableId, Class, {}, saved.parentDeviceId);
 			restored.add(saved.id);
 		};
@@ -42251,6 +42309,17 @@ var AmcrestCgiClient = class AmcrestCgiClient {
 		return AmcrestCgiClient.parseTable(await this.getText(`/cgi-bin/configManager.cgi?action=getConfig&name=${encodeURIComponent(name)}`));
 	}
 	/**
+	* Read SEVERAL named config blocks in one round-trip — the Dahua CGI
+	* accepts repeated `name=` params and concatenates the tables
+	* (verified live: `getConfig&name=LightGlobal&name=NTP` returns both).
+	* Keys across blocks never collide (each is prefixed with its table
+	* name), so one flat map holds them all.
+	*/
+	async getConfigs(names) {
+		const query = names.map((n) => `name=${encodeURIComponent(n)}`).join("&");
+		return AmcrestCgiClient.parseTable(await this.getText(`/cgi-bin/configManager.cgi?action=getConfig&${query}`));
+	}
+	/**
 	* Write config values. Keys are raw Dahua paths (e.g.
 	* `VideoColor[0][0].Brightness`); brackets are passed through unescaped
 	* (Dahua requires them literal) and only values are URL-encoded.
@@ -42273,40 +42342,63 @@ var AmcrestCgiClient = class AmcrestCgiClient {
 	*/
 	async openEventStream(codes, signal) {
 		const path = `/cgi-bin/eventManager.cgi?action=attach&codes=${codes}`;
-		const url = `${this.scheme}://${this.host}:${this.port}${path}`;
-		const firstHeader = buildAuthHeader({
+		const first = await this.dialEventStream(path, signal);
+		if (first.res.statusCode !== 401) return first;
+		first.res.resume();
+		const challenge = parseChallenge(first.res.headers["www-authenticate"] ?? null);
+		if (!challenge) return first;
+		this.digestState.challenge = challenge;
+		this.digestState.nc = 0;
+		return this.dialEventStream(path, signal);
+	}
+	/**
+	* One `node:http` GET for the long-poll attach stream.
+	*
+	* Deliberately NOT `fetch`. Two things this needs that the fetch path could
+	* not give: the raw socket, so `setKeepAlive` can be armed (a silently
+	* half-open long-poll is indistinguishable from a quiet camera), and a
+	* connection that is never taken from the shared keep-alive pool the other
+	* CGI calls use. Measured 2026-09-04 against an IP4M-1041B: with `fetch`
+	* the request answered 200 with a valid multipart boundary and the socket
+	* stayed ESTABLISHED, yet not one byte of body ever arrived — while two
+	* hand-rolled subscriptions to the SAME camera, with the same `codes`
+	* filter and at the same moment, both received the events.
+	*/
+	dialEventStream(path, signal) {
+		const authHeader = buildAuthHeader({
 			state: this.digestState,
 			method: "GET",
 			uri: path,
 			username: this.username,
 			password: this.password
 		});
-		let res = await fetch(url, {
-			method: "GET",
-			headers: firstHeader ? { authorization: firstHeader } : {},
-			signal
-		});
-		if (res.status === 401) {
-			await res.body?.cancel().catch(() => {});
-			const challenge = parseChallenge(res.headers.get("www-authenticate"));
-			if (challenge) {
-				this.digestState.challenge = challenge;
-				this.digestState.nc = 0;
-				const retryHeader = buildAuthHeader({
-					state: this.digestState,
-					method: "GET",
-					uri: path,
-					username: this.username,
-					password: this.password
-				});
-				res = await fetch(url, {
-					method: "GET",
-					headers: retryHeader ? { authorization: retryHeader } : {},
-					signal
+		const headers = { connection: "keep-alive" };
+		if (authHeader) headers["authorization"] = authHeader;
+		const doRequest = this.scheme === "https" ? node_https.request : node_http.request;
+		return new Promise((resolve, reject) => {
+			const req = doRequest({
+				host: this.host,
+				port: this.port,
+				path,
+				method: "GET",
+				headers,
+				timeout: 0,
+				...this.scheme === "https" ? { rejectUnauthorized: false } : {}
+			}, (res) => {
+				resolve({
+					res,
+					statusCode: res.statusCode ?? 0,
+					contentType: res.headers["content-type"] ?? ""
 				});
-			}
-		}
-		return res;
+			});
+			req.on("socket", (socket) => {
+				socket.setKeepAlive(true, 1e4);
+				socket.setNoDelay(true);
+			});
+			req.on("error", (err) => reject(err));
+			signal.addEventListener("abort", () => req.destroy(), { once: true });
+			req.end();
+		});
 	}
 	async getEncodeConfig() {
 		return this.getConfig("Encode");
@@ -42396,19 +42488,20 @@ function subscribeAmcrestEvents(client, codes, handlers) {
 	const controller = new AbortController();
 	(async () => {
 		try {
-			const res = await client.openEventStream(codes, controller.signal);
-			if (!res.ok || !res.body) {
-				handlers.onError(/* @__PURE__ */ new Error(`event stream HTTP ${res.status} ${res.statusText}`));
+			const opened = await client.openEventStream(codes, controller.signal);
+			if (opened.statusCode < 200 || opened.statusCode >= 300) {
+				opened.res.resume();
+				handlers.onError(/* @__PURE__ */ new Error(`event stream HTTP ${opened.statusCode}`));
 				return;
 			}
-			const ct = res.headers.get("content-type") ?? "";
+			const ct = opened.contentType;
 			const boundary = parseBoundary(ct);
 			if (!boundary) {
 				handlers.onError(/* @__PURE__ */ new Error(`event stream missing multipart boundary in Content-Type: "${ct}"`));
 				return;
 			}
 			handlers.onConnected?.();
-			await pumpEventStream(res.body, boundary, handlers);
+			await pumpEventStream(opened.res, boundary, handlers);
 			if (!controller.signal.aborted) handlers.onError(/* @__PURE__ */ new Error("event stream ended"));
 		} catch (err) {
 			if (controller.signal.aborted) return;
@@ -42422,28 +42515,34 @@ function parseBoundary(contentType) {
 	return m ? m[1].trim() : null;
 }
 async function pumpEventStream(stream, boundary, handlers) {
-	const reader = stream.getReader();
 	const dashBoundary = `--${boundary}`;
 	let bufferedBytes = new Uint8Array(0);
+	let preambleConsumed = false;
 	try {
-		while (true) {
-			const { value, done } = await reader.read();
-			if (done) break;
-			if (!value || value.byteLength === 0) continue;
+		for await (const chunk of stream) {
+			const value = chunk instanceof Uint8Array ? chunk : new Uint8Array(0);
+			if (value.byteLength === 0) continue;
+			handlers.onBytes?.(value.byteLength, new TextDecoder().decode(value.slice(0, 120)));
 			bufferedBytes = concatBytes(bufferedBytes, value);
-			const parts = splitOnBoundary(bufferedBytes, dashBoundary);
+			const parts = splitOnBoundary(bufferedBytes, dashBoundary, preambleConsumed);
+			if (parts.blocks.length > 0 || parts.tail !== bufferedBytes) preambleConsumed = true;
 			bufferedBytes = parts.tail;
 			for (const block of parts.blocks) {
 				const parsed = parseMultipartBlock(block);
-				if (!parsed) continue;
+				if (!parsed) {
+					handlers.onUnparsedBlock?.("block", new TextDecoder().decode(block).slice(0, 160));
+					continue;
+				}
 				const ev = parseAmcrestEventBody(parsed.bodyText);
-				if (ev) handlers.onEvent(ev);
+				if (!ev) {
+					handlers.onUnparsedBlock?.("body", parsed.bodyText.slice(0, 160));
+					continue;
+				}
+				handlers.onEvent(ev);
 			}
 		}
 	} finally {
-		try {
-			reader.releaseLock();
-		} catch {}
+		stream.destroy();
 	}
 }
 function concatBytes(a, b) {
@@ -42452,14 +42551,32 @@ function concatBytes(a, b) {
 	out.set(b, a.byteLength);
 	return out;
 }
-function splitOnBoundary(buf, dashBoundary) {
+/**
+* Split the running buffer on the multipart boundary.
+*
+* `preambleConsumed` is NOT optional bookkeeping. RFC 1521 says the bytes before
+* the FIRST boundary are a preamble to discard — but that is true exactly once
+* per stream. This function used to `shift()` unconditionally on every pump
+* cycle, and from the second cycle on the leading fragment is not a preamble at
+* all: it is the body of the part the newly-arrived boundary just CLOSED. So
+* every completed block was thrown away as preamble, `blocks` came back empty
+* forever, and the caller's loop never ran — no event, and no dropped-block
+* warning either, because there was nothing in the array to warn about.
+*
+* Cost of that one line: this camera's onboard motion never reached the
+* pipeline. It streamed video fine, reported `enabled: true`, held an
+* ESTABLISHED socket, and delivered `--myboundary` chunks that were parsed into
+* nothing. Two hand-rolled probes against the same camera worked throughout —
+* because they regex the raw lines and never split on the boundary at all.
+*/
+function splitOnBoundary(buf, dashBoundary, preambleConsumed) {
 	const parts = Buffer.from(buf).toString("binary").split(dashBoundary);
 	if (parts.length <= 1) return {
 		blocks: [],
 		tail: buf
 	};
 	const tail = Buffer.from(parts.pop(), "binary");
-	parts.shift();
+	if (!preambleConsumed) parts.shift();
 	return {
 		blocks: parts.filter((p) => p.length > 0 && !p.startsWith("--")).map((p) => Buffer.from(p, "binary")),
 		tail
@@ -42506,6 +42623,466 @@ function parseAmcrestEventBody(body) {
 		raw: body
 	};
 }
+var DAY_NIGHT_NATIVE_TO_CAP = {
+	Brightness: "auto",
+	Color: "day",
+	BlackWhite: "night"
+};
+var DAY_NIGHT_CAP_TO_NATIVE = {
+	auto: "Brightness",
+	day: "Color",
+	night: "BlackWhite",
+	schedule: void 0
+};
+/** Native `Mode` token → cap mode. Unknown tokens read as `auto` — the
+*  status must never throw on firmware drift, and `auto` is the only
+*  mode every Dahua ships in. */
+function amcrestDayNightModeToCap(raw) {
+	if (raw === void 0) return "auto";
+	return DAY_NIGHT_NATIVE_TO_CAP[raw] ?? "auto";
+}
+/** Cap mode → native token, or `undefined` when no verified native
+*  exists (the caller warns and skips rather than guessing). */
+function capDayNightModeToAmcrest(mode) {
+	return DAY_NIGHT_CAP_TO_NATIVE[mode];
+}
+/** Native 0..7 → normalized 0..100. */
+function dayNightSensitivityToPercent(native) {
+	return Math.round(native / 7 * 100);
+}
+/** Normalized 0..100 → native 0..7, clamped to what the firmware accepts. */
+function percentToDayNightSensitivity(percent) {
+	const native = Math.round(percent / 100 * 7);
+	return Math.max(0, Math.min(7, native));
+}
+/** Clamp a requested switch delay into the firmware's 2..10 s window —
+*  an out-of-window write is rejected wholesale (HTTP 400), which would
+*  silently drop the ROUND TRIP, not just this field. */
+function clampDayNightDelaySec(sec) {
+	return Math.max(2, Math.min(10, Math.round(sec)));
+}
+/** Native `Rotate90` int → cap degrees-clockwise. 1 was verified live
+*  (snapshot flipped to 1440×2560); 2 is the documented counterpart
+*  (90° ccw = 270° cw). Anything else (the field stores e.g. `3`
+*  verbatim) has no defined meaning → `undefined`. */
+function amcrestRotateToCap(raw) {
+	if (raw === 0) return "0";
+	if (raw === 1) return "90";
+	if (raw === 2) return "270";
+}
+/** Cap rotation → native `Rotate90` int. `'180'` has no Dahua
+*  equivalent on this family (the vendor UI composes mirror+flip) —
+*  `undefined` tells the caller to skip the write. */
+function capRotateToAmcrest(rotate) {
+	if (rotate === "0") return 0;
+	if (rotate === "90") return 1;
+	if (rotate === "270") return 2;
+}
+var BACKLIGHT_NATIVE_TO_CAP = {
+	Off: "off",
+	Backlight: "blc",
+	WideDynamic: "wdr",
+	GlareInhibition: "hlc"
+};
+var BACKLIGHT_CAP_TO_NATIVE = {
+	off: "Off",
+	blc: "Backlight",
+	wdr: "WideDynamic",
+	hlc: "GlareInhibition"
+};
+/** Native backlight token → cap mode. The field is NOT validated by the
+*  firmware (a bogus token is stored verbatim), so an unknown read maps
+*  to `undefined` — reported as "no answer", never guessed. */
+function amcrestBacklightToCap(raw) {
+	if (raw === void 0) return void 0;
+	return BACKLIGHT_NATIVE_TO_CAP[raw];
+}
+function capBacklightToAmcrest(mode) {
+	return BACKLIGHT_CAP_TO_NATIVE[mode];
+}
+/** Native exposure mode int → cap mode. The field IS validated by the
+*  firmware (99 → HTTP 400). 0=Auto, 4=Manual (verified functionally:
+*  Mode=4 + Value1/2=1 ms produced a near-black frame). The natives in
+*  between are vendor presets (low-noise / low-motion-blur) the cap's
+*  two-value enum cannot express → `undefined`, so the UI shows the
+*  select unset instead of lying `auto`. */
+function amcrestExposureModeToCap(raw) {
+	if (raw === 0) return "auto";
+	if (raw === 4) return "manual";
+}
+function capExposureModeToAmcrest(mode) {
+	return mode === "manual" ? 4 : 0;
+}
+//#endregion
+//#region src/extra-settings.ts
+/**
+* Driver-authored device-settings sections for the camera facts that no
+* vendor-neutral cap models: the IR illuminator, the status LED, NTP /
+* timezone, and the auto-reboot schedule. Taxonomy (section ids + tabs)
+* matches the Reolink driver (`ir-lights` on `image`, `time-ntp` on
+* `network`, `auto-reboot` on `advanced`) so the operator sees the same
+* layout regardless of vendor.
+*
+* D62 discipline: none of these keys is stored in the device config —
+* the CAMERA is the authority. `applySettingsPatch` maps them onto
+* `configManager.cgi?action=setConfig` writes (via
+* {@link extrasPatchToCgiParams}) and re-reads the camera into the
+* `deviceCache.extras` snapshot; `config.setAll` strips them because
+* they are not in the schema.
+*
+* Every Dahua key, token and bound below was verified against the live
+* IP4M-1041B (firmware 2.800.1ENN001.0.R) on 2026-09-04:
+*   - `Lighting[0][0].Mode` — Auto/Manual/Off. The firmware stores ANY
+*     string verbatim (even `TotallyBogusMode`), so THIS module is the
+*     validator. `Manual` + `MiddleLight[0].Light=100` was proven
+*     functionally: with the IR-cut forced open, the dark half of the
+*     frame lit up; `Off` left it dark.
+*   - `LightGlobal[0].Enable` — status-LED switch, boolean round-trip.
+*   - `NTP.*` — `TimeZone` accepts 0..33 (60 → HTTP 400); `Enable`,
+*     `Address`, `Port`, `UpdatePeriod` (minutes) all round-trip.
+*   - `AutoMaintain.AutoReboot{Enable,Day,Hour,Minute}` — `Day` accepts
+*     -1..7 (8 → HTTP 400); 0..6 = Sunday..Saturday, 7 = every day.
+*/
+/** Read-projection of the four extras config tables. All fields optional
+*  — a table the camera omitted stays absent (unknown, never fabricated). */
+var amcrestExtrasSnapshotSchema = object({
+	/** `Lighting[0][0].Mode` — only the verified enum; an unknown stored
+	*  token reads as absent. */
+	irLightMode: _enum([
+		"Auto",
+		"Manual",
+		"Off"
+	]),
+	/** `Lighting[0][0].MiddleLight[0].Light` 0..100. */
+	irLightBrightness: number(),
+	/** `LightGlobal[0].Enable`. */
+	statusLedEnabled: boolean(),
+	ntpEnabled: boolean(),
+	ntpServer: string(),
+	ntpPort: number(),
+	/** `NTP.UpdatePeriod`, minutes. */
+	ntpUpdatePeriodMin: number(),
+	/** Dahua timezone index (`NTP.TimeZone`), 0..33. */
+	ntpTimeZoneIndex: number(),
+	autoRebootEnabled: boolean(),
+	/** 0..6 = Sunday..Saturday, 7 = every day. */
+	autoRebootDay: number(),
+	autoRebootHour: number(),
+	autoRebootMinute: number(),
+	/** Wall-clock ms of the read that produced this snapshot. */
+	fetchedAt: number()
+}).partial();
+/** The config tables one multi-name `getConfig` call reads to build the
+*  snapshot (the CGI accepts repeated `name=` params — verified live). */
+var AMCREST_EXTRAS_CONFIG_NAMES = [
+	"Lighting",
+	"LightGlobal",
+	"NTP",
+	"AutoMaintain"
+];
+var IR_LIGHT_MODES = [
+	"Auto",
+	"Manual",
+	"Off"
+];
+function isIrLightMode(value) {
+	return IR_LIGHT_MODES.includes(value);
+}
+function intOrUndefined(raw) {
+	if (raw === void 0) return void 0;
+	const n = Number.parseInt(raw, 10);
+	return Number.isFinite(n) ? n : void 0;
+}
+function boolOrUndefined(raw) {
+	if (raw === "true") return true;
+	if (raw === "false") return false;
+}
+/** Project the flat Dahua table (multi-name getConfig result) into the
+*  extras snapshot. Absent keys stay absent. */
+function parseExtrasSnapshot(table, now) {
+	const out = { fetchedAt: now };
+	const modeRaw = table.get("Lighting[0][0].Mode");
+	if (modeRaw !== void 0 && isIrLightMode(modeRaw)) out.irLightMode = modeRaw;
+	const light = intOrUndefined(table.get("Lighting[0][0].MiddleLight[0].Light"));
+	if (light !== void 0) out.irLightBrightness = light;
+	const led = boolOrUndefined(table.get("LightGlobal[0].Enable"));
+	if (led !== void 0) out.statusLedEnabled = led;
+	const ntpEnabled = boolOrUndefined(table.get("NTP.Enable"));
+	if (ntpEnabled !== void 0) out.ntpEnabled = ntpEnabled;
+	const ntpServer = table.get("NTP.Address");
+	if (ntpServer !== void 0) out.ntpServer = ntpServer;
+	const ntpPort = intOrUndefined(table.get("NTP.Port"));
+	if (ntpPort !== void 0) out.ntpPort = ntpPort;
+	const period = intOrUndefined(table.get("NTP.UpdatePeriod"));
+	if (period !== void 0) out.ntpUpdatePeriodMin = period;
+	const tz = intOrUndefined(table.get("NTP.TimeZone"));
+	if (tz !== void 0) out.ntpTimeZoneIndex = tz;
+	const rebootEnabled = boolOrUndefined(table.get("AutoMaintain.AutoRebootEnable"));
+	if (rebootEnabled !== void 0) out.autoRebootEnabled = rebootEnabled;
+	const rebootDay = intOrUndefined(table.get("AutoMaintain.AutoRebootDay"));
+	if (rebootDay !== void 0) out.autoRebootDay = rebootDay;
+	const rebootHour = intOrUndefined(table.get("AutoMaintain.AutoRebootHour"));
+	if (rebootHour !== void 0) out.autoRebootHour = rebootHour;
+	const rebootMinute = intOrUndefined(table.get("AutoMaintain.AutoRebootMinute"));
+	if (rebootMinute !== void 0) out.autoRebootMinute = rebootMinute;
+	return out;
+}
+/**
+* Build the three extras sections from the last camera read. NO snapshot
+* → NO sections: rendering fabricated defaults for a camera nobody has
+* reached would make not-yet-known look like known (D337-shape), and a
+* Save against those phantoms would overwrite real camera state.
+*/
+function buildExtrasSections(snap) {
+	if (snap === void 0) return [];
+	return [
+		{
+			id: "ir-lights",
+			tab: "image",
+			title: "IR + status LED",
+			description: "IR illuminator (`Lighting[0][0]`, separate from the IR-cut filter on the Image tab) + the visible status LED (`LightGlobal[0].Enable`). `Auto` lets the camera drive the IR LEDs from ambient light; `Manual` forces them on at the set brightness; `Off` disables them. All pushed over Dahua CGI `setConfig` on save.",
+			columns: 2,
+			fields: [
+				{
+					type: "select",
+					key: "irLightMode",
+					label: "IR illuminator",
+					default: snap.irLightMode ?? "Auto",
+					options: [
+						{
+							value: "Auto",
+							label: "Auto (camera decides)"
+						},
+						{
+							value: "Manual",
+							label: "Always on"
+						},
+						{
+							value: "Off",
+							label: "Always off"
+						}
+					]
+				},
+				{
+					type: "slider",
+					key: "irLightBrightness",
+					label: "IR brightness",
+					description: "IR LED output (`MiddleLight[0].Light`, 0–100). Applied in Auto and Manual modes.",
+					min: 0,
+					max: 100,
+					step: 5,
+					default: snap.irLightBrightness ?? 50,
+					showValue: true,
+					showStepper: true
+				},
+				{
+					type: "boolean",
+					key: "statusLedEnabled",
+					label: "Status LED",
+					description: "The visible indicator LED on the camera body (`LightGlobal[0].Enable`).",
+					default: snap.statusLedEnabled ?? true,
+					style: "switch",
+					span: 2
+				}
+			]
+		},
+		{
+			id: "time-ntp",
+			tab: "network",
+			title: "Time / NTP",
+			description: "Network time sync (`NTP.*` over Dahua CGI). The timezone is the Dahua numeric index (0–33) exactly as listed in the camera web UI — 26 is the GMT+8 factory default. NOTE: with NTP disabled this camera drifts badly (it currently believes the year is 2000).",
+			columns: 2,
+			fields: [
+				{
+					type: "boolean",
+					key: "ntpEnabled",
+					label: "NTP sync",
+					default: snap.ntpEnabled ?? false,
+					style: "switch",
+					span: 2
+				},
+				{
+					type: "text",
+					key: "ntpServer",
+					label: "NTP server",
+					default: snap.ntpServer ?? "pool.ntp.org",
+					placeholder: "pool.ntp.org",
+					span: 2
+				},
+				{
+					type: "number",
+					key: "ntpPort",
+					label: "NTP port",
+					default: snap.ntpPort ?? 123,
+					min: 1,
+					max: 65535,
+					step: 1
+				},
+				{
+					type: "number",
+					key: "ntpUpdatePeriodMin",
+					label: "Sync interval (min)",
+					default: snap.ntpUpdatePeriodMin ?? 10,
+					min: 1,
+					max: 65535,
+					step: 1
+				},
+				{
+					type: "number",
+					key: "ntpTimeZoneIndex",
+					label: "Timezone index (Dahua, 0–33)",
+					description: "Numeric index from the camera web UI timezone list — the firmware rejects anything above 33. Not an IANA zone: the Dahua CGI only speaks this index. 26 = GMT+8 (factory default).",
+					default: snap.ntpTimeZoneIndex ?? 26,
+					min: 0,
+					max: 33,
+					step: 1,
+					span: 2
+				}
+			]
+		},
+		{
+			id: "auto-reboot",
+			tab: "advanced",
+			title: "Auto reboot",
+			description: "Scheduled automatic reboot (`AutoMaintain.AutoReboot*`). Choose a day (or every day) + time; the camera reboots once per matching window.",
+			columns: 2,
+			fields: [
+				{
+					type: "boolean",
+					key: "autoRebootEnabled",
+					label: "Auto reboot",
+					default: snap.autoRebootEnabled ?? false,
+					style: "switch",
+					span: 2
+				},
+				{
+					type: "select",
+					key: "autoRebootDay",
+					label: "Day",
+					default: String(snap.autoRebootDay ?? 7),
+					span: 2,
+					options: [
+						{
+							value: "7",
+							label: "Every day"
+						},
+						{
+							value: "0",
+							label: "Sunday"
+						},
+						{
+							value: "1",
+							label: "Monday"
+						},
+						{
+							value: "2",
+							label: "Tuesday"
+						},
+						{
+							value: "3",
+							label: "Wednesday"
+						},
+						{
+							value: "4",
+							label: "Thursday"
+						},
+						{
+							value: "5",
+							label: "Friday"
+						},
+						{
+							value: "6",
+							label: "Saturday"
+						}
+					]
+				},
+				{
+					type: "number",
+					key: "autoRebootHour",
+					label: "Hour (0-23)",
+					default: snap.autoRebootHour ?? 2,
+					min: 0,
+					max: 23,
+					step: 1
+				},
+				{
+					type: "number",
+					key: "autoRebootMinute",
+					label: "Minute (0-59)",
+					default: snap.autoRebootMinute ?? 30,
+					min: 0,
+					max: 59,
+					step: 1
+				}
+			]
+		}
+	];
+}
+function clampInt(value, min, max) {
+	return Math.max(min, Math.min(max, Math.round(value)));
+}
+/** Coerce a select/number value that may arrive as a numeric string. */
+function asNumber(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string" && value.trim() !== "") {
+		const n = Number(value);
+		if (Number.isFinite(n)) return n;
+	}
+}
+/**
+* Map an extras settings patch onto Dahua `setConfig` params. Wrongly
+* typed values are DROPPED, and every numeric is clamped into its
+* live-verified writable window — an out-of-window value would fail the
+* whole multi-key CGI write with HTTP 400, silently losing the other
+* fields in the same save.
+*/
+function extrasPatchToCgiParams(patch) {
+	const params = {};
+	const handled = [];
+	const consume = (key) => {
+		if (key in patch) handled.push(key);
+	};
+	consume("irLightMode");
+	const irMode = patch["irLightMode"];
+	if (typeof irMode === "string" && isIrLightMode(irMode)) params["Lighting[0][0].Mode"] = irMode;
+	consume("irLightBrightness");
+	const irBrightness = asNumber(patch["irLightBrightness"]);
+	if (irBrightness !== void 0) params["Lighting[0][0].MiddleLight[0].Light"] = clampInt(irBrightness, 0, 100);
+	consume("statusLedEnabled");
+	const led = patch["statusLedEnabled"];
+	if (typeof led === "boolean") params["LightGlobal[0].Enable"] = led ? "true" : "false";
+	consume("ntpEnabled");
+	const ntpEnabled = patch["ntpEnabled"];
+	if (typeof ntpEnabled === "boolean") params["NTP.Enable"] = ntpEnabled ? "true" : "false";
+	consume("ntpServer");
+	const ntpServer = patch["ntpServer"];
+	if (typeof ntpServer === "string" && ntpServer.trim() !== "") params["NTP.Address"] = ntpServer.trim();
+	consume("ntpPort");
+	const ntpPort = asNumber(patch["ntpPort"]);
+	if (ntpPort !== void 0) params["NTP.Port"] = clampInt(ntpPort, 1, 65535);
+	consume("ntpUpdatePeriodMin");
+	const ntpPeriod = asNumber(patch["ntpUpdatePeriodMin"]);
+	if (ntpPeriod !== void 0) params["NTP.UpdatePeriod"] = clampInt(ntpPeriod, 1, 65535);
+	consume("ntpTimeZoneIndex");
+	const tz = asNumber(patch["ntpTimeZoneIndex"]);
+	if (tz !== void 0) params["NTP.TimeZone"] = clampInt(tz, 0, 33);
+	consume("autoRebootEnabled");
+	const rebootEnabled = patch["autoRebootEnabled"];
+	if (typeof rebootEnabled === "boolean") params["AutoMaintain.AutoRebootEnable"] = rebootEnabled ? "true" : "false";
+	consume("autoRebootDay");
+	const rebootDay = asNumber(patch["autoRebootDay"]);
+	if (rebootDay !== void 0) params["AutoMaintain.AutoRebootDay"] = clampInt(rebootDay, 0, 7);
+	consume("autoRebootHour");
+	const rebootHour = asNumber(patch["autoRebootHour"]);
+	if (rebootHour !== void 0) params["AutoMaintain.AutoRebootHour"] = clampInt(rebootHour, 0, 23);
+	consume("autoRebootMinute");
+	const rebootMinute = asNumber(patch["autoRebootMinute"]);
+	if (rebootMinute !== void 0) params["AutoMaintain.AutoRebootMinute"] = clampInt(rebootMinute, 0, 59);
+	return {
+		params,
+		handled
+	};
+}
 //#endregion
 //#region src/schema.ts
 /** Addon id — must match `package.json`'s `camstack.addons[0].id`. */
@@ -42525,7 +43102,14 @@ var amcrestDeviceCacheSchema = object({
 	processor: string(),
 	mac: string(),
 	hasPtz: boolean(),
-	probedAt: number()
+	probedAt: number(),
+	/**
+	* Last camera read of the driver-authored extras (IR illuminator,
+	* status LED, NTP, auto-reboot). Seeds the settings-form defaults —
+	* the CAMERA stays the authority (D62): saves write CGI and re-read
+	* into this snapshot, never into standalone config keys.
+	*/
+	extras: amcrestExtrasSnapshotSchema
 }).partial();
 /**
 * Amcrest/Dahua camera hardware config. `name`/`location` are base
@@ -42612,6 +43196,8 @@ var AmcrestCamera = class AmcrestCamera extends BaseDevice {
 	static MOTION_KEEPALIVE_MS = 1e4;
 	/** Active event-stream subscription; aborted on dispose / conn change. */
 	eventStreamController = null;
+	/** Dedicated CGI client for the long-poll — see {@link ensureEventClient}. */
+	eventClient = null;
 	/** Reconnect attempt counter — drives exponential backoff. */
 	eventStreamReconnectAttempts = 0;
 	/** Pending reconnect timer. */
@@ -42640,23 +43226,77 @@ var AmcrestCamera = class AmcrestCamera extends BaseDevice {
 	}
 	ensureClient() {
 		if (this.client) return this.client;
+		this.client = this.buildClient();
+		return this.client;
+	}
+	/**
+	* A SECOND client, used only by the event-stream long-poll.
+	*
+	* `AmcrestCgiClient` carries one `DigestState` — a nonce plus a monotonic
+	* nonce-count — and reuses it across every request so a warm session skips
+	* the 401 round-trip. That is right for the ~20 short CGI calls this device
+	* makes (snapshot, encode config, PTZ caps, OSD, …) and wrong for a
+	* subscription that must stay authenticated for hours: the short calls keep
+	* advancing `nc` on the shared state underneath it.
+	*
+	* The long-poll therefore gets its own client and its own digest state, which
+	* is the last remaining difference between the provider's subscription and
+	* the hand-rolled probes that DID receive events from this camera — same
+	* host, same `codes` filter, same moment, three connections, only ours silent.
+	*/
+	ensureEventClient() {
+		if (this.eventClient) return this.eventClient;
+		this.eventClient = this.buildClient();
+		return this.eventClient;
+	}
+	buildClient() {
 		const https = this.config.get("https") ?? false;
-		this.client = new AmcrestCgiClient({
+		return new AmcrestCgiClient({
 			host: this.config.get("host"),
 			port: this.config.get("port") ?? (https ? 443 : 80),
 			https,
 			username: this.config.get("username") ?? "admin",
 			password: this.config.get("password")
 		});
-		return this.client;
 	}
-	/** Drop the cached CGI client so the next call rebuilds it from the
-	*  (possibly just-edited) credentials/host. */
+	/**
+	* Settings-save dispatcher. Two kinds of keys arrive here:
+	*
+	*   - Extras keys (IR illuminator / status LED / NTP / auto-reboot) —
+	*     camera-authoritative (D62). They are pushed to the camera over
+	*     CGI `setConfig` and re-read into `deviceCache.extras`; they are
+	*     NOT in the config schema, so `config.setAll` strips them and no
+	*     second store ever exists.
+	*   - Config keys (host / credentials / channel) — persisted by the
+	*     base path; a connection-shape change additionally drops the
+	*     cached CGI clients so the next call rebuilds them.
+	*/
 	async applySettingsPatch(patch) {
+		const { params: extrasParams, handled: extrasKeys } = extrasPatchToCgiParams(patch);
+		if (Object.keys(extrasParams).length > 0) {
+			await this.ensureClient().setConfig(extrasParams);
+			this.ctx.logger.info("amcrest: extras settings written to camera", {
+				tags: { deviceId: this.id },
+				meta: {
+					keys: extrasKeys,
+					cgiKeys: Object.keys(extrasParams)
+				}
+			});
+			await this.refreshExtrasSnapshot().catch((err) => {
+				this.ctx.logger.warn("amcrest: extras snapshot re-read after save failed", {
+					tags: { deviceId: this.id },
+					meta: { error: err instanceof Error ? err.message : String(err) }
+				});
+			});
+		} else if (extrasKeys.length > 0) this.ctx.logger.warn("amcrest: extras settings patch carried no writable value — dropped", {
+			tags: { deviceId: this.id },
+			meta: { keys: extrasKeys }
+		});
 		await super.applySettingsPatch(patch);
 		if ("host" in patch || "port" in patch || "https" in patch || "username" in patch || "password" in patch) {
 			this.clearPtzAutoStop();
 			this.client = null;
+			this.eventClient = null;
 			const hadStream = this.eventStreamController !== null || this.eventStreamReconnectTimer !== null;
 			this.teardownEventSubscription();
 			if (hadStream) this.ensureEventSubscription();
@@ -42699,14 +43339,42 @@ var AmcrestCamera = class AmcrestCamera extends BaseDevice {
 	/** Idempotently open the eventManager attach stream. */
 	ensureEventSubscription() {
 		if (this.eventStreamController) return;
-		const client = this.ensureClient();
+		const client = this.ensureEventClient();
 		this.eventStreamController = subscribeAmcrestEvents(client, AmcrestCamera.MOTION_EVENT_CODES, {
 			onConnected: () => {
 				this.eventStreamReconnectAttempts = 0;
 				if (this.motionActive) this.onMotionStop(Date.now());
 				this.ctx.logger.info("amcrest: event stream connected", { tags: { deviceId: this.id } });
 			},
-			onEvent: (ev) => this.handleAmcrestEvent(ev),
+			onEvent: (ev) => {
+				this.ctx.logger.info("amcrest: firmware event received", {
+					tags: { deviceId: this.id },
+					meta: {
+						code: ev.code,
+						action: ev.action,
+						index: ev.index
+					}
+				});
+				this.handleAmcrestEvent(ev);
+			},
+			onBytes: (byteLength, preview) => {
+				this.ctx.logger.info("amcrest: event stream bytes", {
+					tags: { deviceId: this.id },
+					meta: {
+						byteLength,
+						preview
+					}
+				});
+			},
+			onUnparsedBlock: (reason, preview) => {
+				this.ctx.logger.warn("amcrest: event block dropped — could not be parsed", {
+					tags: { deviceId: this.id },
+					meta: {
+						reason,
+						preview
+					}
+				});
+			},
 			onError: (err) => {
 				this.ctx.logger.warn("amcrest: event stream error — will reconnect", {
 					tags: { deviceId: this.id },
@@ -42797,6 +43465,133 @@ var AmcrestCamera = class AmcrestCamera extends BaseDevice {
 	async onActivate() {
 		this.ensureEventSubscription();
 		this.startReachabilityPolling();
+		this.refreshExtrasSnapshot().catch(() => {});
+	}
+	/** Single-flight guard for the extras snapshot refresh. */
+	extrasRefreshInFlight = null;
+	/** Debounce for the serve-and-revalidate kick on form open. */
+	lastExtrasRevalidateKickAt = 0;
+	static EXTRAS_REVALIDATE_MIN_MS = 3e4;
+	/**
+	* Read the four extras tables in one multi-name CGI round-trip and
+	* persist the projection into `deviceCache.extras`. The camera stays
+	* the authority — this snapshot only seeds form defaults (D62/D224).
+	*/
+	async refreshExtrasSnapshot() {
+		if (this.extrasRefreshInFlight) return this.extrasRefreshInFlight;
+		const promise = (async () => {
+			try {
+				const extras = parseExtrasSnapshot(await this.ensureClient().getConfigs([...AMCREST_EXTRAS_CONFIG_NAMES]), Date.now());
+				const cache = this.config.get("deviceCache") ?? {};
+				await this.config.setAll({ deviceCache: {
+					...cache,
+					extras
+				} });
+			} catch (err) {
+				this.ctx.logger.warn("amcrest: extras snapshot refresh failed — keeping last snapshot", {
+					tags: { deviceId: this.id },
+					meta: { error: err instanceof Error ? err.message : String(err) }
+				});
+			}
+		})();
+		this.extrasRefreshInFlight = promise;
+		try {
+			await promise;
+		} finally {
+			this.extrasRefreshInFlight = null;
+		}
+	}
+	/**
+	* Driver settings form: the Connection card (same taxonomy as the
+	* Hikvision/Reolink drivers) + the extras sections built from the last
+	* camera read. Extras values are served from the persisted snapshot
+	* and revalidated BEHIND the open (serve-and-revalidate, D224) — this
+	* method is sync and must never dial the camera on the render path.
+	*/
+	getSettingsUISchema() {
+		const extras = this.config.get("deviceCache")?.extras;
+		const now = Date.now();
+		if ((extras?.fetchedAt === void 0 || now - extras.fetchedAt > 6e5) && now - this.lastExtrasRevalidateKickAt > AmcrestCamera.EXTRAS_REVALIDATE_MIN_MS) {
+			this.lastExtrasRevalidateKickAt = now;
+			this.refreshExtrasSnapshot().catch(() => {});
+		}
+		const schema = { sections: [{
+			id: "connection",
+			tab: "general",
+			title: "Connection",
+			description: "Dahua CGI HTTP(S) endpoint + Digest credentials. RTSP is always port 554.",
+			columns: 2,
+			fields: [
+				{
+					type: "text",
+					key: "host",
+					label: "Camera IP",
+					required: true,
+					placeholder: "192.168.1.100"
+				},
+				{
+					type: "number",
+					key: "port",
+					label: "Port",
+					default: 80,
+					min: 1,
+					max: 65535,
+					step: 1
+				},
+				{
+					type: "boolean",
+					key: "https",
+					label: "Use HTTPS",
+					default: false,
+					style: "switch"
+				},
+				{
+					type: "number",
+					key: "channel",
+					label: "Channel (1-based)",
+					default: 1,
+					min: 1,
+					max: 64,
+					step: 1
+				},
+				{
+					type: "text",
+					key: "username",
+					label: "Username",
+					default: "admin"
+				},
+				{
+					type: "password",
+					key: "password",
+					label: "Password",
+					required: true,
+					showToggle: true
+				}
+			]
+		}, ...buildExtrasSections(extras)] };
+		const values = {
+			host: this.config.get("host"),
+			port: this.config.get("port"),
+			https: this.config.get("https"),
+			channel: this.config.get("channel"),
+			username: this.config.get("username"),
+			password: this.config.get("password")
+		};
+		if (extras !== void 0) {
+			if (extras.irLightMode !== void 0) values["irLightMode"] = extras.irLightMode;
+			if (extras.irLightBrightness !== void 0) values["irLightBrightness"] = extras.irLightBrightness;
+			if (extras.statusLedEnabled !== void 0) values["statusLedEnabled"] = extras.statusLedEnabled;
+			if (extras.ntpEnabled !== void 0) values["ntpEnabled"] = extras.ntpEnabled;
+			if (extras.ntpServer !== void 0) values["ntpServer"] = extras.ntpServer;
+			if (extras.ntpPort !== void 0) values["ntpPort"] = extras.ntpPort;
+			if (extras.ntpUpdatePeriodMin !== void 0) values["ntpUpdatePeriodMin"] = extras.ntpUpdatePeriodMin;
+			if (extras.ntpTimeZoneIndex !== void 0) values["ntpTimeZoneIndex"] = extras.ntpTimeZoneIndex;
+			if (extras.autoRebootEnabled !== void 0) values["autoRebootEnabled"] = extras.autoRebootEnabled;
+			if (extras.autoRebootDay !== void 0) values["autoRebootDay"] = String(extras.autoRebootDay);
+			if (extras.autoRebootHour !== void 0) values["autoRebootHour"] = extras.autoRebootHour;
+			if (extras.autoRebootMinute !== void 0) values["autoRebootMinute"] = extras.autoRebootMinute;
+		}
+		return hydrateSchema(schema, values);
 	}
 	/** Start the control-plane reachability poll: a Dahua CGI `getDeviceInfo`
 	*  round-trip every 30s drives `device.online`, with hysteresis. Replaces
@@ -43435,7 +44230,7 @@ var AmcrestCamera = class AmcrestCamera extends BaseDevice {
 			if (this.privacyMaskRefreshInFlight) return this.privacyMaskRefreshInFlight;
 			const promise = (async () => {
 				try {
-					const table = await this.ensureClient().getConfig("PrivacyMasking");
+					const table = await this.ensureClient().getConfigs(["PrivacyMasking", "Encode"]);
 					const regions = [];
 					for (let i = 0; i < maxRegions; i++) {
 						const prefix = `PrivacyMasking[0][${i}]`;
@@ -43456,10 +44251,11 @@ var AmcrestCamera = class AmcrestCamera extends BaseDevice {
 							}
 						});
 					}
+					const audioProfiles = collectAudioEnableKeys(table).map((key) => ({ audioEnabled: table.get(key) === "true" }));
 					const next = {
 						enabled: regions.length > 0,
 						regions,
-						audioEnabled: null,
+						audioEnabled: summarisePrivacyAudio(audioProfiles),
 						lastFetchedAt: Date.now()
 					};
 					this.runtimeState.setCapState(CAP_NAME, next);
@@ -43500,10 +44296,27 @@ var AmcrestCamera = class AmcrestCamera extends BaseDevice {
 					supportsAudioMute: false
 				};
 				if (deviceId !== this.id) return cold;
-				return cold;
+				return {
+					...cold,
+					supportsAudioMute: true
+				};
 			},
-			setAudioEnabled: async () => {
-				throw new Error(`device ${String(this.id)}: the amcrest provider does not implement the camera microphone switch`);
+			setAudioEnabled: async ({ deviceId, enabled }) => {
+				if (deviceId !== this.id) return;
+				const client = this.ensureClient();
+				const keys = collectAudioEnableKeys(await client.getEncodeConfig());
+				if (keys.length === 0) throw new Error(`device ${String(this.id)}: camera reported no Encode AudioEnable flags — microphone switch unavailable`);
+				const params = {};
+				for (const key of keys) params[key] = enabled ? "true" : "false";
+				await client.setConfig(params);
+				this.ctx.logger.info("amcrest: camera microphone flags written", {
+					tags: { deviceId: this.id },
+					meta: {
+						enabled,
+						profileCount: keys.length
+					}
+				});
+				await refreshFromCamera();
 			},
 			setMask: async ({ deviceId, patch }) => {
 				if (deviceId !== this.id) return;
@@ -43602,8 +44415,6 @@ var AmcrestCamera = class AmcrestCamera extends BaseDevice {
 		});
 		this.ctx.logger.info("amcrest: osd cap registered", { tags: { deviceId: this.id } });
 	}
-	static DAY_NIGHT_SENSITIVITY_NATIVE_MAX = 3;
-	static DAY_NIGHT_DELAY_MAX_SEC = 600;
 	registerDayNightCap() {
 		const CAP_NAME = "day-night";
 		const STALE_MS = 1e4;
@@ -43615,10 +44426,10 @@ var AmcrestCamera = class AmcrestCamera extends BaseDevice {
 					const sensitivityNative = parseIntOrUndefined(table.get("VideoInDayNight[0][0].Sensitivity"));
 					const delaySec = parseIntOrUndefined(table.get("VideoInDayNight[0][0].Delay"));
 					const next = {
-						mode: "auto",
+						mode: amcrestDayNightModeToCap(table.get("VideoInDayNight[0][0].Mode")),
 						lastFetchedAt: Date.now()
 					};
-					if (sensitivityNative !== void 0) next.sensitivity = Math.round(sensitivityNative / AmcrestCamera.DAY_NIGHT_SENSITIVITY_NATIVE_MAX * 100);
+					if (sensitivityNative !== void 0) next.sensitivity = dayNightSensitivityToPercent(sensitivityNative);
 					if (delaySec !== void 0) next.switchDelaySec = delaySec;
 					this.runtimeState.setCapState(CAP_NAME, next);
 				} catch (err) {
@@ -43656,7 +44467,11 @@ var AmcrestCamera = class AmcrestCamera extends BaseDevice {
 				};
 				if (deviceId !== this.id) return cold;
 				return {
-					modes: ["auto"],
+					modes: [
+						"auto",
+						"day",
+						"night"
+					],
 					supportsSensitivity: true,
 					sensitivity: {
 						min: 0,
@@ -43665,8 +44480,8 @@ var AmcrestCamera = class AmcrestCamera extends BaseDevice {
 					},
 					supportsSwitchDelay: true,
 					switchDelaySec: {
-						min: 0,
-						max: AmcrestCamera.DAY_NIGHT_DELAY_MAX_SEC,
+						min: 2,
+						max: 10,
 						step: 1
 					}
 				};
@@ -43674,13 +44489,16 @@ var AmcrestCamera = class AmcrestCamera extends BaseDevice {
 			setSettings: async ({ deviceId, settings }) => {
 				if (deviceId !== this.id) return;
 				const params = {};
-				if (settings.mode !== void 0 && settings.mode !== "auto") this.ctx.logger.warn("amcrest: day-night mode other than \"auto\" is not wired (unverified Dahua enum) — ignored", {
-					tags: { deviceId: this.id },
-					meta: { requestedMode: settings.mode }
-				});
-				else if (settings.mode === "auto") params["VideoInDayNight[0][0].Mode"] = "Brightness";
-				if (settings.sensitivity !== void 0) params["VideoInDayNight[0][0].Sensitivity"] = Math.round(settings.sensitivity / 100 * AmcrestCamera.DAY_NIGHT_SENSITIVITY_NATIVE_MAX);
-				if (settings.switchDelaySec !== void 0) params["VideoInDayNight[0][0].Delay"] = settings.switchDelaySec;
+				if (settings.mode !== void 0) {
+					const nativeMode = capDayNightModeToAmcrest(settings.mode);
+					if (nativeMode === void 0) this.ctx.logger.warn("amcrest: day-night mode has no verified Dahua token — ignored", {
+						tags: { deviceId: this.id },
+						meta: { requestedMode: settings.mode }
+					});
+					else params["VideoInDayNight[0][0].Mode"] = nativeMode;
+				}
+				if (settings.sensitivity !== void 0) params["VideoInDayNight[0][0].Sensitivity"] = percentToDayNightSensitivity(settings.sensitivity);
+				if (settings.switchDelaySec !== void 0) params["VideoInDayNight[0][0].Delay"] = clampDayNightDelaySec(settings.switchDelaySec);
 				if (Object.keys(params).length > 0) await this.ensureClient().setConfig(params);
 				await refreshFromCamera();
 			}
@@ -43700,15 +44518,34 @@ var AmcrestCamera = class AmcrestCamera extends BaseDevice {
 			if (this.imageSettingsRefreshInFlight) return this.imageSettingsRefreshInFlight;
 			const promise = (async () => {
 				try {
-					const table = await this.ensureClient().getConfig("VideoColor");
+					const table = await this.ensureClient().getConfigs([
+						"VideoColor",
+						"VideoInSharpness",
+						"VideoInOptions",
+						"VideoImageControl",
+						"VideoInExposure",
+						"VideoInBacklight"
+					]);
 					const brightness = parseIntOrUndefined(table.get("VideoColor[0][0].Brightness"));
 					const contrast = parseIntOrUndefined(table.get("VideoColor[0][0].Contrast"));
 					const saturation = parseIntOrUndefined(table.get("VideoColor[0][0].Saturation"));
+					const sharpness = parseIntOrUndefined(table.get("VideoInSharpness[0][0].Sharpness"));
+					const mirror = parseBoolOrUndefined(table.get("VideoInOptions[0].Mirror"));
+					const flip = parseBoolOrUndefined(table.get("VideoInOptions[0].Flip"));
+					const rotate = amcrestRotateToCap(parseIntOrUndefined(table.get("VideoImageControl[0].Rotate90")));
+					const exposureMode = amcrestExposureModeToCap(parseIntOrUndefined(table.get("VideoInExposure[0][0].Mode")));
+					const backlightMode = amcrestBacklightToCap(table.get("VideoInBacklight[0][0].Mode"));
 					if (brightness === void 0 && contrast === void 0 && saturation === void 0) return;
 					const next = {
 						...brightness !== void 0 ? { brightness } : {},
 						...contrast !== void 0 ? { contrast } : {},
 						...saturation !== void 0 ? { saturation } : {},
+						...sharpness !== void 0 ? { sharpness } : {},
+						...mirror !== void 0 ? { mirror } : {},
+						...flip !== void 0 ? { flip } : {},
+						...rotate !== void 0 ? { rotate } : {},
+						...exposureMode !== void 0 ? { exposureMode } : {},
+						...backlightMode !== void 0 ? { backlightMode } : {},
 						lastFetchedAt: Date.now()
 					};
 					this.runtimeState.setCapState(CAP_NAME, next);
@@ -43758,7 +44595,23 @@ var AmcrestCamera = class AmcrestCamera extends BaseDevice {
 					supportsContrast: true,
 					contrast: NORMALIZED_RANGE,
 					supportsSaturation: true,
-					saturation: NORMALIZED_RANGE
+					saturation: NORMALIZED_RANGE,
+					supportsSharpness: true,
+					sharpness: NORMALIZED_RANGE,
+					supportsMirror: true,
+					supportsFlip: true,
+					rotateOptions: [
+						"0",
+						"90",
+						"270"
+					],
+					exposureModes: ["auto", "manual"],
+					backlightModes: [
+						"off",
+						"blc",
+						"wdr",
+						"hlc"
+					]
 				};
 			},
 			setSettings: async ({ deviceId, settings }) => {
@@ -43767,6 +44620,19 @@ var AmcrestCamera = class AmcrestCamera extends BaseDevice {
 				if (settings.brightness !== void 0) params["VideoColor[0][0].Brightness"] = settings.brightness;
 				if (settings.contrast !== void 0) params["VideoColor[0][0].Contrast"] = settings.contrast;
 				if (settings.saturation !== void 0) params["VideoColor[0][0].Saturation"] = settings.saturation;
+				if (settings.sharpness !== void 0) params["VideoInSharpness[0][0].Sharpness"] = settings.sharpness;
+				if (settings.mirror !== void 0) params["VideoInOptions[0].Mirror"] = settings.mirror ? "true" : "false";
+				if (settings.flip !== void 0) params["VideoInOptions[0].Flip"] = settings.flip ? "true" : "false";
+				if (settings.rotate !== void 0) {
+					const native = capRotateToAmcrest(settings.rotate);
+					if (native === void 0) this.ctx.logger.warn("amcrest: rotate value has no Dahua equivalent — ignored", {
+						tags: { deviceId: this.id },
+						meta: { requestedRotate: settings.rotate }
+					});
+					else params["VideoImageControl[0].Rotate90"] = native;
+				}
+				if (settings.exposureMode !== void 0) params["VideoInExposure[0][0].Mode"] = capExposureModeToAmcrest(settings.exposureMode);
+				if (settings.backlightMode !== void 0) params["VideoInBacklight[0][0].Mode"] = capBacklightToAmcrest(settings.backlightMode);
 				if (Object.keys(params).length > 0) await this.ensureClient().setConfig(params);
 				await refreshFromCamera();
 			}
@@ -43789,6 +44655,23 @@ function parseIntOrUndefined(raw) {
 	const n = Number.parseInt(raw, 10);
 	return Number.isFinite(n) ? n : void 0;
 }
+function parseBoolOrUndefined(raw) {
+	if (raw === "true") return true;
+	if (raw === "false") return false;
+}
+/**
+* Every `Encode[0].*.AudioEnable` key present in an `Encode` table read
+* — the per-profile microphone flags (`MainFormat[0..2]` +
+* `ExtraFormat[0..2]` on the IP4M-1041B, but the slot count is
+* firmware-defined so the keys are DISCOVERED, never enumerated).
+* Feeds `summarisePrivacyAudio` on the read path and names the exact
+* keys the mute write must cover.
+*/
+function collectAudioEnableKeys(table) {
+	const out = [];
+	for (const key of table.keys()) if (/^Encode\[0\]\.(?:MainFormat|ExtraFormat)\[\d+\]\.AudioEnable$/.test(key)) out.push(key);
+	return out.toSorted();
+}
 //#endregion
 //#region ../../node_modules/xml2js/lib/defaults.js
 var require_defaults = /* @__PURE__ */ __commonJSMin(((exports) => {