@camstack/addon-provider-reolink 1.2.185 → 1.2.186

package/dist/addon.js

@@ -5424,7 +5424,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-BBF1iXUi.mjs
+//#region ../types/dist/sleep-DRqxtc0C.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -8297,6 +8297,24 @@ function collectZodSecretPaths(schema, prefix = "") {
 	}
 	return [...new Set(paths)];
 }
+object({
+	code: string().regex(/^[a-z][a-z0-9-]*(\.[a-z0-9-]+)+$/),
+	params: record(string(), union([string(), number()])).optional()
+});
+var CamstackError = class extends Error {
+	i18nCode;
+	i18nParams;
+	constructor(code, params, englishMessage) {
+		super(englishMessage);
+		this.name = "CamstackError";
+		this.i18nCode = code;
+		this.i18nParams = params;
+	}
+};
+/** `throw userError('device.not-found', { id }, 'Device 12 not found')` */
+function userError(code, params, englishFallback) {
+	return new CamstackError(code, params, englishFallback);
+}
 /**
 * Promise-based timer helpers — used everywhere the codebase needs to
 * wait, back off, or schedule a retry. Before these helpers landed, each
@@ -8322,7 +8340,7 @@ function sleep$2(ms) {
 	return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
 }
 //#endregion
-//#region ../types/dist/err-msg-DX6i_MY4.mjs
+//#region ../types/dist/err-msg-DLerKiVO.mjs
 var DeviceType = /* @__PURE__ */ function(DeviceType) {
 	DeviceType["Camera"] = "camera";
 	DeviceType["Hub"] = "hub";
@@ -8572,6 +8590,22 @@ var DeviceRole = /* @__PURE__ */ function(DeviceRole) {
 	DeviceRole["Nightvision"] = "nightvision";
 	DeviceRole["PrivacyMask"] = "privacy-mask";
 	DeviceRole["Doorbell"] = "doorbell";
+	/** Interior blind / shade / roller blind. HA `device_class: blind|shade`. */
+	DeviceRole["CoverBlind"] = "cover-blind";
+	/** Exterior roller shutter. HA `device_class: shutter`; Homematic BROLL. */
+	DeviceRole["CoverShutter"] = "cover-shutter";
+	/** Exterior awning. HA `device_class: awning`. */
+	DeviceRole["CoverAwning"] = "cover-awning";
+	/** Curtain / drape. HA `device_class: curtain`. */
+	DeviceRole["CoverCurtain"] = "cover-curtain";
+	/** Garage door. HA `device_class: garage`. A security actuator: exports gate it. */
+	DeviceRole["CoverGarage"] = "cover-garage";
+	/** Gate. HA `device_class: gate`. A security actuator: exports gate it. */
+	DeviceRole["CoverGate"] = "cover-gate";
+	/** Door. HA `device_class: door`. A security actuator: exports gate it. */
+	DeviceRole["CoverDoor"] = "cover-door";
+	/** Window. HA `device_class: window`. */
+	DeviceRole["CoverWindow"] = "cover-window";
 	/** Virtual HA toggle (input_boolean.*) — distinguishable from a
 	*  real Switch device for UI rendering / export adapters. */
 	DeviceRole["BinaryHelper"] = "binary-helper";
@@ -8642,7 +8676,7 @@ var DeviceRole = /* @__PURE__ */ function(DeviceRole) {
 	return DeviceRole;
 }({});
 //#endregion
-//#region ../types/dist/composition-C-WpVYTX.mjs
+//#region ../types/dist/composition-EQ9Ok0Ee.mjs
 /**
 * The ffmpeg build every CamStack node downloads, per platform and arch.
 *
@@ -12870,6 +12904,177 @@ var ConvertResultSchema = object({
 		files: array(string()).readonly()
 	})).readonly()
 });
+_enum(["new-session", "step-up"]);
+/** The languages the hub's app landing pages are written in (D858). */
+var AppPageLangSchema = _enum(["en", "it"]);
+/** How a native app starts one login method (D858), as `auth.listLoginMethods` reports it. */
+var AppLoginPathSchema = discriminatedUnion("kind", [object({ kind: literal("native") }), object({
+	kind: literal("browser"),
+	startPath: string().startsWith("/")
+})]);
+/**
+* Device certificates (D855) — the wire contract shared by the hub, the admin
+* UI and the native viewer.
+*
+* A device (a phone) generates its OWN P-256 key pair in hardware (Secure
+* Enclave / Android Keystore / a non-extractable WebCrypto key). The private
+* key never travels. The hub signs the PUBLIC key into an X.509 leaf under a
+* dedicated device CA; the device later proves possession of the key by
+* signing a hub-issued nonce, and the hub answers with the same session a
+* password login opens.
+*
+* Everything on the wire is a small string (a PEM, a base64url signature):
+* D613 is about bulk bytes, and a certificate is ~600 bytes.
+*/
+/** Signature algorithm of every device credential: ECDSA, curve P-256, SHA-256. */
+var DEVICE_CERT_SIGNATURE = "ecdsa-p256-sha256";
+/** First line of every signed message; a change of format bumps the version. */
+var DEVICE_SIGNATURE_MESSAGE_VERSION = "camstack-device-cert-v1";
+_enum([
+	"login",
+	"renew",
+	"revoke"
+]);
+var DevicePlatformSchema = _enum([
+	"ios",
+	"android",
+	"web",
+	"other"
+]);
+var Base64UrlSchema = string().min(1).max(4096).regex(/^[A-Za-z0-9_-]+$/);
+var PemSchema = string().min(1).max(16384);
+/**
+* Why a device-certificate endpoint said no. Distinct from a transport / 5xx
+* failure: those carry no reason and mean "try again", never "the credential is
+* dead". The viewer switches on this exhaustively.
+*/
+var DeviceRefusalReasonSchema = _enum([
+	"revoked",
+	"unknown-credential",
+	"expired",
+	"bad-signature",
+	"nonce-invalid",
+	"rate-limited",
+	"invalid-certificate",
+	"superseded",
+	"user-gone",
+	"unavailable",
+	"code-invalid",
+	"self-enrollment-disabled",
+	"step-up-required",
+	"bad-public-key"
+]);
+var DeviceRefusalSchema = object({
+	ok: literal(false),
+	reason: DeviceRefusalReasonSchema,
+	definitive: boolean(),
+	retryAfterSeconds: number().optional()
+});
+object({
+	code: string().min(1).max(256),
+	/** SubjectPublicKeyInfo DER of the device's P-256 public key, base64url. */
+	publicKeySpki: Base64UrlSchema,
+	deviceName: string().min(1).max(80).optional(),
+	platform: DevicePlatformSchema
+});
+discriminatedUnion("ok", [object({
+	credentialId: string(),
+	certPem: PemSchema,
+	/** The device CA certificate the leaf chains to. */
+	chainPem: PemSchema,
+	notAfter: number(),
+	user: object({
+		id: string(),
+		username: string()
+	})
+}).extend({ ok: literal(true) }), DeviceRefusalSchema]);
+object({
+	/** The single-use step-up proof (`auth.deviceEnrollProofFrom…`). */
+	proof: string().min(1).max(512),
+	publicKeySpki: Base64UrlSchema,
+	deviceName: string().min(1).max(80),
+	platform: DevicePlatformSchema
+});
+object({
+	proof: string(),
+	expiresAt: number()
+});
+discriminatedUnion("ok", [object({
+	nonce: string(),
+	/** The origin to put in the signed message. The app compares it to the hub it dialled. */
+	origin: string(),
+	expiresAt: number(),
+	signature: literal(DEVICE_CERT_SIGNATURE)
+}).extend({ ok: literal(true) }), DeviceRefusalSchema]);
+object({
+	certPem: PemSchema,
+	nonce: string().min(1).max(256),
+	/** ECDSA P-256 SHA-256 over {@link buildDeviceSignatureMessage}; raw r||s or DER, base64url. */
+	signature: Base64UrlSchema
+});
+discriminatedUnion("ok", [object({
+	credentialId: string(),
+	certPem: PemSchema,
+	chainPem: PemSchema,
+	notAfter: number()
+}).extend({ ok: literal(true) }), DeviceRefusalSchema]);
+discriminatedUnion("ok", [object({
+	ok: literal(true),
+	credentialId: string(),
+	sessionsEnded: number().int()
+}), DeviceRefusalSchema]);
+var DeviceCredentialStatusSchema = _enum([
+	"active",
+	"expired",
+	"revoked"
+]);
+var DeviceCredentialSchema = object({
+	id: string(),
+	userId: string(),
+	username: string().nullable(),
+	deviceName: string(),
+	platform: DevicePlatformSchema,
+	enrolledVia: _enum(["qr", "self"]),
+	/** SHA-256 of the leaf certificate DER, colon-hex. */
+	fingerprint: string(),
+	issuedAt: number(),
+	expiresAt: number(),
+	lastUsedAt: number().nullable(),
+	lastUsedFrom: string().nullable(),
+	revokedAt: number().nullable(),
+	/** `admin:<userId>` | `user:<userId>` | `device` | `user-deleted`. */
+	revokedBy: string().nullable(),
+	status: DeviceCredentialStatusSchema
+});
+var StartEnrollmentOutputSchema = object({
+	/** Shown once; only its hash is kept. */
+	code: string(),
+	expiresAt: number(),
+	/** `camstack://enroll?hub=…&code=…` — what the QR encodes. */
+	enrollUrl: string(),
+	/** The hub origin in the link, or `null` when the hub could not name one (the link then has no `hub`). */
+	hubOrigin: string().nullable(),
+	/** Every origin the apps may try (role `appConnections`). */
+	hubOrigins: array(string())
+});
+object({
+	kind: literal("device-certificate"),
+	id: literal("device-certificate"),
+	label: string(),
+	stage: literal("primary"),
+	/** tRPC paths under the hub's `auth` router, so a client names no literal. */
+	challengePath: literal("auth.getDeviceChallenge"),
+	revokePath: literal("auth.revokeOwnDeviceCertificate"),
+	enrollSelfPath: literal("auth.enrollSelf"),
+	loginPath: literal("auth.loginWithDeviceCertificate"),
+	renewPath: literal("auth.renewDeviceCertificate"),
+	signature: literal(DEVICE_CERT_SIGNATURE),
+	messageVersion: literal(DEVICE_SIGNATURE_MESSAGE_VERSION),
+	/** Which clients can execute it: a native app silently, a browser with a non-extractable WebCrypto key. */
+	clients: array(_enum(["native", "web"])),
+	/** The app executes it itself, silently (D858). */
+	app: AppLoginPathSchema.nullable()
+});
 var ExpressionBindingSourceSchema = union([
 	object({
 		kind: literal("field").optional(),
@@ -13198,7 +13403,9 @@ var ConfigTabDeclarationSchema = object({
 var ConfigSectionWithValuesSchema = object({
 	id: string(),
 	title: string(),
+	titleKey: string().optional(),
 	description: string().optional(),
+	descriptionKey: string().optional(),
 	style: _enum(["card", "accordion"]).optional(),
 	defaultCollapsed: boolean().optional(),
 	columns: union([
@@ -15694,7 +15901,11 @@ var cameraStreamsCapability = {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): none — `online` duplicates device-status.online (one authority); slot data is nested enum/string.
+	*/
+	history: "none"
 };
 EventCategory.DoorbellOnPressed;
 var CompositionEventPlanSchema = object({
@@ -16526,7 +16737,345 @@ method(object({
 }), method(object({ refs: RefListSchema }), KeychainResolveResultSchema, { auth: "admin" }), method(object({ refs: RefListSchema }), object({ deleted: number().int() }), {
 	kind: "mutation",
 	auth: "admin"
+}), method(object({ deviceId: number().int() }), object({ refs: array(string()).readonly() }), {
+	kind: "mutation",
+	auth: "admin"
 }), method(object({}), array(KeychainSecretMetaSchema).readonly(), { auth: "admin" }), method(object({}), KeychainStateSchema, { auth: "admin" });
+/**
+* device-history — the ONE mechanism for numeric history (D850).
+*
+* A device value is recorded because its capability says so (the `history`
+* block of a `*.cap.ts`, captured hub-side from `DeviceStateChanged`); any
+* other series is DECLARED by the addon that produces it and fed with points
+* (`record`) or closed five-minute buckets (`recordBuckets`). Rollups 5m / 1h /
+* 1d are computed here and nowhere else. Storage is `history.db` (D851).
+*
+* Who the PRODUCER is: `declareSeries`, `record` and `recordBuckets` are owner
+* checked against the `callerAddonId` the transport stamps into a call that
+* crossed a process (never in an input schema, so a session cannot supply it).
+* A call with no stamp is refused `not-owner`. The methods are `admin` so a
+* non-admin session never reaches them; an addon's `ctx.api` call bypasses the
+* tier by design.
+*/
+/** Whose history: a real device, or a cluster node (load, memory). */
+var DeviceHistorySubjectSchema = discriminatedUnion("kind", [object({
+	kind: literal("device"),
+	deviceId: number().int()
+}), object({
+	kind: literal("node"),
+	nodeId: string().min(1)
+})]);
+var DeviceHistoryKindSchema = _enum([
+	"gauge",
+	"counter",
+	"boolean"
+]);
+var DeviceHistoryResolutionSchema = _enum([
+	"raw",
+	"5m",
+	"1h",
+	"1d"
+]);
+/** Why a producer's point or bucket was not stored. Counted, never silent (D391). */
+var DeviceHistoryRefusalReasonSchema = _enum([
+	"undeclared",
+	"not-owner",
+	"opted-out",
+	"not-a-real-device",
+	"rate",
+	"ingest-mismatch",
+	"out-of-range"
+]);
+var RefusalSchema = object({
+	key: string(),
+	reason: DeviceHistoryRefusalReasonSchema,
+	count: number().int()
+});
+var IngestResultSchema = object({
+	accepted: number().int(),
+	refused: array(RefusalSchema).readonly()
+});
+var SeriesInfoSchema = object({
+	key: string(),
+	scope: string(),
+	kind: DeviceHistoryKindSchema,
+	/** `null` is unknown (a `unitFrom` series whose device does not state a unit right now), never a guess. */
+	unit: string().nullable(),
+	displayName: string(),
+	source: _enum(["cap", "addon"]),
+	firstTs: number(),
+	lastTs: number()
+});
+var QueryPointSchema = object({
+	/** Raw: the point's time. Rollup: the bucket start. */
+	t: number(),
+	samples: number().int(),
+	/** `sum / samples`. */
+	mean: number().nullable(),
+	/** Time-weighted mean (`tw_sum / tw_ms`); `null` for bucket-ingested series. For a boolean: the fraction of time true. */
+	twMean: number().nullable(),
+	min: number(),
+	max: number(),
+	/** `null` is unknown, never zero (D393). */
+	last: number().nullable()
+});
+var QuerySeriesSchema = object({
+	scope: string(),
+	/** The last point STRICTLY BEFORE `from` in the chosen tier, so a step chart can start at the held value. */
+	before: object({
+		t: number(),
+		value: number().nullable()
+	}).nullable(),
+	points: array(QueryPointSchema).readonly()
+});
+/** The window part of a query, shared by the device and node forms. */
+var QueryWindowShape = {
+	key: string(),
+	scope: string().optional(),
+	from: number(),
+	to: number(),
+	resolution: union([DeviceHistoryResolutionSchema, literal("auto")]).default("auto"),
+	maxPoints: number().int().positive().max(5e3).default(1e3)
+};
+var QueryResultSchema = object({
+	resolution: DeviceHistoryResolutionSchema,
+	series: array(QuerySeriesSchema).readonly(),
+	truncated: boolean()
+});
+var TierStatusSchema = object({
+	tier: DeviceHistoryResolutionSchema,
+	/** `null` until the first background count answered. */
+	rows: number().int().nullable(),
+	/** `rows` times a fixed per-row estimate — approximate, labelled so. */
+	approxBytes: number().nullable(),
+	countedAt: number().nullable()
+});
+/** Operator/diagnostic view: rows per tier, last runs, refusals and drops since boot. */
+var DeviceHistoryStatusSchema = object({
+	startedAt: number(),
+	/** The store is declared, series loaded and the first reconcile has answered. */
+	ready: boolean(),
+	series: number().int(),
+	metrics: number().int(),
+	optedOutDevices: number().int(),
+	tiers: array(TierStatusSchema).readonly(),
+	capture: object({
+		eventsSeen: number().int(),
+		pointsEmitted: number().int(),
+		pointsWritten: number().int(),
+		pointsDropped: number().int(),
+		bufferDepth: number().int(),
+		trailingEmitted: number().int(),
+		reconciledPoints: number().int(),
+		reconcileRuns: number().int(),
+		reconcileFailures: number().int(),
+		lastReconcileAt: number().nullable(),
+		lastFlushAt: number().nullable(),
+		flushFailures: number().int(),
+		skipped: record(string(), number().int())
+	}),
+	ingest: object({
+		accepted: number().int(),
+		refused: record(string(), number().int())
+	}),
+	rollup: object({
+		last5mAt: number().nullable(),
+		last1hAt: number().nullable(),
+		last1dAt: number().nullable(),
+		errors: number().int(),
+		dirty5m: number().int(),
+		dirty1h: number().int(),
+		dirty1d: number().int()
+	}),
+	retention: object({
+		lastRunAt: number().nullable(),
+		deleted: record(string(), number().int()),
+		purgedSeries: number().int()
+	}),
+	directory: object({
+		devices: number().int(),
+		lastRefreshAt: number().nullable()
+	})
+});
+method(object({ deviceId: number().int() }), array(SeriesInfoSchema).readonly()), method(object({ nodeId: string().min(1) }), array(SeriesInfoSchema).readonly(), { auth: "admin" }), method(object({
+	deviceId: number().int(),
+	...QueryWindowShape
+}), QueryResultSchema), method(object({
+	nodeId: string().min(1),
+	...QueryWindowShape
+}), QueryResultSchema, { auth: "admin" }), method(object({
+	name: string().regex(/^[a-z0-9-]+$/),
+	subjectKind: _enum(["device", "node"]),
+	kind: DeviceHistoryKindSchema,
+	unit: string().optional(),
+	displayName: string().min(1),
+	ingest: _enum(["points", "buckets"])
+}), object({ key: string() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ points: array(object({
+	key: string(),
+	subject: DeviceHistorySubjectSchema,
+	scope: string().default(""),
+	ts: number(),
+	value: number()
+})).max(5e3) }), IngestResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ buckets: array(object({
+	key: string(),
+	subject: DeviceHistorySubjectSchema,
+	scope: string().default(""),
+	bucketStart: number(),
+	samples: number().int().positive(),
+	sum: number(),
+	min: number(),
+	max: number(),
+	last: number().nullable(),
+	lastTs: number().nullable()
+})).max(5e3) }), IngestResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ deviceId: number().int() }), object({ enabled: boolean() })), method(object({
+	deviceId: number().int(),
+	enabled: boolean()
+}), object({ enabled: boolean() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({}), DeviceHistoryStatusSchema, { auth: "admin" });
+var DeviceCaStatusSchema = discriminatedUnion("state", [
+	object({ state: literal("absent") }),
+	object({
+		state: literal("ready"),
+		subject: string(),
+		fingerprintSha256: string(),
+		validTo: string()
+	}),
+	object({
+		state: literal("unavailable"),
+		reason: string()
+	})
+]);
+var DeviceCertificateSettingsSchema = object({ selfEnrollment: _enum(["allowed", "disabled"]) });
+method(object({
+	userId: string().min(1).optional(),
+	includeRevoked: boolean().default(false)
+}), array(DeviceCredentialSchema).readonly(), { auth: "admin" }), method(object({
+	userId: string().min(1),
+	deviceName: string().min(1).max(80)
+}), StartEnrollmentOutputSchema, {
+	kind: "mutation",
+	auth: "admin",
+	caller: "required"
+}), method(object({ id: string().min(1) }), object({
+	revoked: boolean(),
+	sessionsEnded: number().int(),
+	status: DeviceCredentialStatusSchema
+}), {
+	kind: "mutation",
+	auth: "admin",
+	caller: "required"
+}), method(object({}), DeviceCertificateSettingsSchema, { auth: "admin" }), method(DeviceCertificateSettingsSchema, DeviceCertificateSettingsSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ id: string().min(1) }), object({ result: _enum([
+	"deleted",
+	"live",
+	"unknown"
+]) }), {
+	kind: "mutation",
+	auth: "admin",
+	caller: "required"
+}), method(object({}), DeviceCaStatusSchema, { auth: "admin" }), method(object({
+	id: string().min(1),
+	deviceName: string().min(1).max(80)
+}), object({ renamed: boolean() }), {
+	kind: "mutation",
+	auth: "admin"
+});
+/**
+* `node-certificates` - what a node holds and the two renewals the hub drives
+* (D856): the node's MESH leaf (mutual TLS to the hub) and its HTTPS leaf (issued
+* from the hub's local CA so a device that trusts the hub root trusts the node).
+*
+* Provided by the AGENT RUNTIME (the synthetic `agent-runtime` addon id, like
+* `server-management`): the hub reaches it through the ordinary node-pinned
+* capability call - no new Moleculer action. The hub's own certificates are
+* handled in-process by the hub (`certificates` router), so this cap has no hub
+* provider.
+*
+* No private key ever crosses the mesh: the node generates its key pair, sends a
+* CSR, and the hub returns only the signed certificate.
+*/
+var MeshLeafInfoSchema = object({
+	cn: string(),
+	serial: string(),
+	fingerprintSha256: string(),
+	notBefore: number(),
+	notAfter: number()
+});
+var HttpsLeafInfoSchema = object({
+	fingerprintSha256: string(),
+	issuer: string(),
+	sans: array(string()),
+	notBefore: number(),
+	notAfter: number()
+});
+var NodeHttpsStateSchema = discriminatedUnion("state", [object({
+	state: literal("served"),
+	leaf: HttpsLeafInfoSchema
+}), object({
+	state: literal("not-issued"),
+	reason: string()
+})]);
+method(object({}), object({
+	nodeId: string(),
+	mesh: MeshLeafInfoSchema.nullable(),
+	https: NodeHttpsStateSchema
+}), { auth: "admin" }), method(object({}), object({ csrPem: string() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	certPem: string().min(1),
+	caCertPem: string().min(1),
+	confirmWithinMs: number().int().min(1e4).max(6e5)
+}), object({
+	fingerprintSha256: string(),
+	serial: string()
+}), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ fingerprintSha256: string() }), object({ confirmed: boolean() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({}), object({ rolledBack: boolean() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({}), object({
+	csrPem: string(),
+	hostnames: array(string()),
+	addresses: array(string()),
+	/** SHA-256 of the hub local CA this node pinned at its first install; `null` before one. */
+	pinnedCaFingerprintSha256: string().nullable()
+}), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({}), object({ ok: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	certPem: string().min(1),
+	caCertPem: string().min(1),
+	/**
+	* The hub signals that its local CA was rotated (D227) and this leaf chains to the NEW
+	* one. Only the hub, over the authenticated mesh, can say so; a leaf with a different CA
+	* and no signal is refused.
+	*/
+	caRotation: boolean().optional()
+}), HttpsLeafInfoSchema, {
+	kind: "mutation",
+	auth: "admin"
+});
 var KeychainKeySourceSchema = object({
 	kind: _enum([
 		"config-file",
@@ -17114,6 +17663,10 @@ var deviceDiscoveryCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "session",
+	/**
+	* History (D850): none — inventory.
+	*/
+	history: "none",
 	methods: {
 		/**
 		* Snapshot of the current `discovered` list. Returns the
@@ -37895,6 +38448,38 @@ var DeviceRegisterPayloadSchema = object({
 	*  omits it and the keyword backstop applies. */
 	secretConfigPaths: array(string()).optional()
 });
+/** One deleted device, kept by device-manager so an addon that missed the
+*  deletion can still learn of it (D865). Written by the delete path ONLY. */
+var DeviceTombstoneSchema = object({
+	deviceId: number().int().positive(),
+	/** Epoch ms the device was deleted. */
+	deletedAt: number(),
+	/** The addon that owned the device when it was deleted. */
+	providerAddonId: string()
+});
+/** Data held for one device that device-manager no longer knows. */
+var OrphanDeviceDataSchema = object({
+	deviceId: number().int().positive(),
+	/** Rows/files per store (`<addonId>:<store>`). */
+	stores: record(string(), number().int().nonnegative())
+});
+var CleanupDeletedDevicesResultSchema = object({
+	/**
+	* `skipped` — the absence check could not be trusted (a device-list read
+	* failed or the two reads disagreed); nothing was listed or deleted.
+	* `dry-run` — `devices` is what a confirmed run would delete.
+	* `cleaned` — `devices` is what was deleted.
+	*/
+	status: _enum([
+		"skipped",
+		"dry-run",
+		"cleaned"
+	]),
+	reason: string().nullable(),
+	devices: array(OrphanDeviceDataSchema),
+	/** Implementers that could not be asked (their stores are not in `devices`). */
+	unreachable: array(string())
+});
 var DeviceRemovePayloadSchema = object({ deviceId: number() });
 var DevicePersistConfigPayloadSchema = object({
 	deviceId: number(),
@@ -38133,6 +38718,9 @@ method(object({
 }), method(object({ deviceId: number() }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
+}), method(object({ sinceMs: number() }), array(DeviceTombstoneSchema).readonly(), { auth: "admin" }), method(object({ confirm: boolean() }), CleanupDeletedDevicesResultSchema, {
+	kind: "mutation",
+	auth: "admin"
 }), method(object({ integrationId: string() }), object({ removed: number() }), {
 	kind: "mutation",
 	auth: "admin"
@@ -38595,6 +39183,72 @@ method(object({
 	auth: "admin"
 });
 /**
+* `device-removal-hook` — the reliable way an addon learns a device was DELETED,
+* so it can delete what it keeps for that device (D865).
+*
+* ## Why an event was not enough
+*
+* `DeviceUnregistered` is telemetry and may be dropped (D8, D11). An addon that
+* hung its per-device clean-up on it left durable garbage whenever the event was
+* lost, the addon was down, or it was restarting at that moment — footage,
+* analytics rows and settings of device 4483 outlived the device. Loss of this
+* signal corrupts durable state, so it travels by RPC with a recorded fact
+* behind it (D8: "if loss would corrupt durable state, use RPC plus a reconcile").
+*
+* ## The three pieces
+*
+* 1. device-manager records a TOMBSTONE per deleted device
+*    (`deviceManager.listDeletedSince`). The tombstone is written by the delete
+*    path only — a device that is unregistered, offline or whose provider is
+*    restarting is NOT deleted and gets none.
+* 2. After a delete, device-manager calls `onDeviceRemoved` on EVERY provider of
+*    this collection, one by one, with bounded retries, logged.
+* 3. An implementer that was down asks `deviceManager.listDeletedSince` at start
+*    (and periodically) and runs its own `onDeviceRemoved` for each tombstone it
+*    may have missed. Reconcile is driven by tombstones, never by "the device is
+*    not in the current list": a failed or partial list read must not destroy data.
+*
+* ## Contract for an implementer
+*
+* - **Idempotent.** It is called again by a retry, by a reconcile and by the
+*   admin cleanup of data that predates tombstones. A device with nothing left
+*   answers zero counts.
+* - **One key per store** in `counts`, deleted rows/files per store, so the log
+*   line and the admin dry run can say where the data was.
+* - **Training datasets are NOT device data** and are never deleted by a hook.
+* - **Per-device SETTINGS are not hooked.** Configuration lives in the standard
+*   per-device store (`ctx.settings.*DeviceStore`), which device-manager clears
+*   for every addon centrally at delete time. This hook is for device DATA
+*   that is not settings: footage, event media, analytics rows, history.
+* - A provider that cannot tell is allowed to throw; the caller retries it.
+*
+* `listDeviceData` is the read side of the admin "Clean data of deleted devices"
+* action: which device ids this addon holds data for, and how much per store. It
+* never deletes. device-manager decides which of those ids are absent from the
+* fleet, from TWO consistent reads of the device list (D49).
+*/
+/** What a hook is told about the deletion. */
+var DeviceRemovedInputSchema = object({
+	deviceId: number().int().positive(),
+	/** Epoch ms the device was deleted (the tombstone's `deletedAt`). */
+	deletedAt: number(),
+	/** The addon that owned the device, as device-manager last knew it. */
+	providerAddonId: string()
+});
+/** Rows/files/refs deleted, per store this implementer owns. */
+var DeviceRemovedResultSchema = object({ counts: record(string(), number().int().nonnegative()) });
+/** One (store, device) pair an implementer holds data for. */
+var DeviceDataEntrySchema = object({
+	store: string(),
+	deviceId: number().int().positive(),
+	/** Rows (or files) held for the device in the store. */
+	count: number().int().nonnegative()
+});
+method(DeviceRemovedInputSchema, DeviceRemovedResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(_void(), array(DeviceDataEntrySchema).readonly(), { auth: "admin" });
+/**
 * `failure-contribution` — the capability an addon reports its OWN losses
 * through, per camera, with the denominator attached. It stores nothing.
 *
@@ -39602,7 +40256,13 @@ var LoginMethodContributionSchema = discriminatedUnion("kind", [
 		* `beginExternalLink` offer exactly the redirect methods that set this,
 		* whatever their id. Absent / false — a login button only.
 		*/
-		linkable: boolean().optional()
+		linkable: boolean().optional(),
+		/**
+		* How a NATIVE app starts this method (D858): `{ kind: 'browser', startPath }`
+		* when the route understands the app flow query (`app=1&code_challenge=…`),
+		* `null`/absent when there is no app path - the app hides the method.
+		*/
+		app: AppLoginPathSchema.nullable().optional()
 	}),
 	object({
 		kind: literal("widget"),
@@ -39614,7 +40274,9 @@ var LoginMethodContributionSchema = discriminatedUnion("kind", [
 		bundle: string(),
 		/** MF remote descriptor — `{ remoteName, exposedModule, componentKey }`. */
 		remote: WidgetRemoteSchema,
-		stage: LoginStageEnum
+		stage: LoginStageEnum,
+		/** Widgets are web ceremonies: no native app path (D858). Absent reads as `null`. */
+		app: AppLoginPathSchema.nullable().optional()
 	}),
 	object({
 		kind: literal("passkey"),
@@ -39626,7 +40288,9 @@ var LoginMethodContributionSchema = discriminatedUnion("kind", [
 		/** Effective WebAuthn RP ID (`resolveRpID()`) — the shell gates visibility on it. */
 		rpId: string(),
 		/** Effective expected origin (`resolveOrigin()`), null when unconfigured. */
-		origin: string().nullable()
+		origin: string().nullable(),
+		/** Set by the hub for the primary arm; a second-factor passkey has no app path (D858). */
+		app: AppLoginPathSchema.nullable().optional()
 	})
 ]);
 method(_void(), array(LoginMethodContributionSchema).readonly());
@@ -40136,7 +40800,21 @@ var NetworkEndpointSchema = object({
 	url: string(),
 	hostname: string(),
 	port: number(),
-	protocol: _enum(["http", "https"])
+	protocol: _enum(["http", "https"]),
+	/**
+	* Whether this address survives a restart of its provider. `false` = it is
+	* re-issued every time (a Quick tunnel's random `*.trycloudflare.com`); the
+	* hub never selects such an address AUTOMATICALLY for a role (D860), though
+	* it stays visible and an operator may still flag it. Absent = stable: every
+	* provider except a Quick tunnel owns a name that does not change.
+	*/
+	stable: boolean().optional()
+});
+object({
+	url: string(),
+	/** Mirrors {@link NetworkEndpointSchema} `stable`; absent = stable. */
+	stable: boolean().optional(),
+	updated: boolean().optional()
 });
 var NetworkAccessStatusSchema = object({
 	connected: boolean(),
@@ -41233,6 +41911,10 @@ var alarmPanelCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): none — enum state; arm/disarm history belongs in the events ledger.
+	*/
+	history: "none",
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastChangedAt"]
@@ -47884,7 +48566,11 @@ var zonesCapability = {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "restored"
+	durability: "restored",
+	/**
+	* History (D850): none — configuration arrays.
+	*/
+	history: "none"
 };
 /**
 * A bounding box in NORMALIZED [0,1] frame coordinates for `getNativeCrop`. The
@@ -50341,7 +51027,22 @@ var SsoBridgeClaimsSchema = object({
 	* request to present the matching cookie — a login bridge is useless in
 	* any other browser.
 	*/
-	browserBinding: string().optional()
+	browserBinding: string().optional(),
+	/**
+	* The native app that started this sign-in (D858): its PKCE challenge,
+	* `state`, purpose and allow-listed return URL, copied from the server-side
+	* pending OIDC state. A bridge carrying it is finished ONLY at
+	* `/api/auth/sso/finish-app` (which mints a handoff code, never a web
+	* session); `/api/auth/sso/finish` refuses it.
+	*/
+	app: object({
+		codeChallenge: string(),
+		state: string(),
+		purpose: _enum(["new-session", "step-up"]),
+		redirect: string(),
+		/** The page language the app asked for (D858); the confirm page speaks it. */
+		lang: _enum(["en", "it"]).optional()
+	}).optional()
 });
 method(object({
 	claims: SsoBridgeClaimsSchema,
@@ -50728,6 +51429,10 @@ var streamSignalsCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "session",
+	/**
+	* History (D850): none — array state.
+	*/
+	history: "none",
 	methods: { 
 	/**
 	* What this device can emit. Empty is a valid and common answer — most
@@ -52994,7 +53699,12 @@ var SearchResultSchema = object({
 	publishedAt: string(),
 	author: string(),
 	installed: boolean(),
-	installedVersion: string().optional()
+	installedVersion: string().optional(),
+	/**
+	* Capability names the package's addons declare (from its published
+	* manifest). `null` = the registry lookup failed — unknown, never `[]` (D393).
+	*/
+	capabilities: array(string()).readonly().nullable()
 });
 var AutoUpdateSettingsSchema = object({
 	channel: ChannelSchema,
@@ -53156,7 +53866,11 @@ method(object({ nodeId: string().optional() }).optional(), array(AddonListItemSc
 }), method(object({ packageName: string().optional() }), PackageInstallationsSchema, { auth: "admin" }), method(_void(), ReloadPackagesResultSchema, {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({ query: string().optional() }), array(SearchResultSchema)), method(object({ nodeId: string().optional() }), array(PackageUpdateSchema).readonly(), { auth: "admin" }), method(object({
+}), method(object({
+	query: string().optional(),
+	/** Only packages whose addons declare this capability (unknown ones excluded). */
+	capability: string().optional()
+}), array(SearchResultSchema)), method(object({ nodeId: string().optional() }), array(PackageUpdateSchema).readonly(), { auth: "admin" }), method(object({
 	name: string().min(1),
 	version: string().optional(),
 	nodeId: string().optional()
@@ -53292,6 +54006,36 @@ var airQualitySensorCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): recorded series.
+	*/
+	history: { fields: {
+		co2Ppm: {
+			kind: "gauge",
+			unit: "ppm",
+			deadband: 5
+		},
+		vocPpb: {
+			kind: "gauge",
+			unit: "ppb",
+			deadband: 5
+		},
+		pm25: {
+			kind: "gauge",
+			unit: "ug/m3",
+			deadband: 1
+		},
+		pm10: {
+			kind: "gauge",
+			unit: "ug/m3",
+			deadband: 1
+		},
+		aqi: {
+			kind: "gauge",
+			unit: "count",
+			deadband: 1
+		}
+	} },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastFetchedAt"]
@@ -53334,6 +54078,15 @@ var ambientLightSensorCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): recorded series. Wide range, so a RELATIVE deadband (10 %).
+	*/
+	history: { fields: { lux: {
+		kind: "gauge",
+		unit: "lx",
+		deadbandPct: 10,
+		minIntervalMs: 6e4
+	} } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastFetchedAt"]
@@ -53461,7 +54214,11 @@ var audioMetricsCapability = {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): none — the level is the addon series `pipeline-analytics/audio-level` (producer `record`); the other numbers move every inference window and duplicate it.
+	*/
+	history: "none"
 };
 /**
 * Automation-control cap. Models HA `automation.*` entities on
@@ -53530,7 +54287,11 @@ var automationControlCapability = {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): none — configuration and transient run state.
+	*/
+	history: "none"
 };
 /**
 * Battery status snapshot. Emitted by providers whose device is
@@ -53711,6 +54472,13 @@ onStatusChanged: { data: object({
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): recorded series. The generic capture replaces the `battery` series of `pipeline-analytics:stats-5m`.
+	*/
+	history: { fields: { percentage: {
+		kind: "gauge",
+		unit: "%"
+	} } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastUpdated"]
@@ -53750,6 +54518,10 @@ var binaryCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): recorded series.
+	*/
+	history: { fields: { on: { kind: "boolean" } } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastChangedAt"]
@@ -53812,7 +54584,15 @@ onBrightnessChanged: { data: object({
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): recorded series. Actuator tier: level keeps every change.
+	*/
+	history: { fields: { percentage: {
+		kind: "gauge",
+		unit: "%",
+		minIntervalMs: 0
+	} } }
 };
 DeviceType.Button, method(object({ deviceId: number().int().nonnegative() }), _void(), {
 	kind: "mutation",
@@ -54146,6 +54926,10 @@ var carbonMonoxideCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): recorded series.
+	*/
+	history: { fields: { detected: { kind: "boolean" } } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastChangedAt"]
@@ -54315,7 +55099,37 @@ var climateControlCapability = {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): recorded series. Celsius by contract; setpoints keep every change (`minIntervalMs: 0`).
+	*/
+	history: { fields: {
+		currentTemp: {
+			kind: "gauge",
+			unit: "°C",
+			deadband: .1
+		},
+		currentHumidity: {
+			kind: "gauge",
+			unit: "%",
+			deadband: .5
+		},
+		target: {
+			kind: "gauge",
+			unit: "°C",
+			minIntervalMs: 0
+		},
+		targetHigh: {
+			kind: "gauge",
+			unit: "°C",
+			minIntervalMs: 0
+		},
+		targetLow: {
+			kind: "gauge",
+			unit: "°C",
+			minIntervalMs: 0
+		}
+	} }
 };
 /**
 * Color-light cap. Coexists with `switch` (on/off) and `brightness`
@@ -54432,7 +55246,11 @@ onColorChanged: { data: object({
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): none — nested and cosmetic.
+	*/
+	history: "none"
 };
 var ConnectionTestOutcomeSchema = discriminatedUnion("outcome", [
 	object({
@@ -54498,6 +55316,10 @@ var connectivityCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): none — duplicates device-status.online (one authority for availability).
+	*/
+	history: "none",
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastChangedAt"]
@@ -54622,6 +55444,10 @@ reset: method(object({
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): none — `items` is an array keyed by runtime ids; a history path never enters it.
+	*/
+	history: "none",
 	/** Clocks, not content: a re-read that changed no item costs no commit. */
 	volatileStateFields: ["lastChangedAt", "lastFetchedAt"]
 };
@@ -54662,6 +55488,10 @@ var contactCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): recorded series.
+	*/
+	history: { fields: { entryOpen: { kind: "boolean" } } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastChangedAt"]
@@ -54777,7 +55607,11 @@ var controlCapability = {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): none — `value` is a number/string union; configuration entity.
+	*/
+	history: "none"
 };
 var CoverStatusSchema = object({
 	/** Lifecycle state of the cover. */
@@ -54846,6 +55680,14 @@ var coverCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): recorded series. Actuator tier: position keeps every tick of a movement.
+	*/
+	history: { fields: { position: {
+		kind: "gauge",
+		unit: "%",
+		minIntervalMs: 0
+	} } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastChangedAt"]
@@ -54950,6 +55792,10 @@ var dayNightCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): none — firmware configuration, not a measurement.
+	*/
+	history: "none",
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastFetchedAt"]
@@ -55007,6 +55853,10 @@ onStatusChanged: { data: object({
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): recorded series. The ONE availability series.
+	*/
+	history: { fields: { online: { kind: "boolean" } } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastChangedAt"]
@@ -55073,7 +55923,11 @@ onPressed: {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "restored"
+	durability: "restored",
+	/**
+	* History (D850): none — `pressCountSinceStart` resets with the addon, so it is not a monotonic meter; presses live in the events ledger.
+	*/
+	history: "none"
 };
 /**
 * Enum-state sensor — a string value picked from a finite option set.
@@ -55121,6 +55975,10 @@ var enumSensorCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): none — text/enum state has no history (non-goal).
+	*/
+	history: "none",
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastFetchedAt"]
@@ -55166,7 +56024,11 @@ var eventEmitterCapability = {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): none — `eventCountSinceStart` resets with the addon; events live in ledgers.
+	*/
+	history: "none"
 };
 var IdentitySchema = object({
 	id: string(),
@@ -55623,7 +56485,18 @@ var fanControlCapability = {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): recorded series. Actuator tier: speed keeps every change.
+	*/
+	history: { fields: {
+		percentage: {
+			kind: "gauge",
+			unit: "%",
+			minIntervalMs: 0
+		},
+		oscillating: { kind: "boolean" }
+	} }
 };
 /**
 * Per-device feature/identity probe slice. Holds the runtime-resolved
@@ -55706,7 +56579,11 @@ onProbeChanged: { data: object({
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): none — static identity and capability probe.
+	*/
+	history: "none"
 };
 /**
 * Water leak / moisture sensor. Boolean "is liquid currently
@@ -55741,6 +56618,10 @@ var floodCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): recorded series.
+	*/
+	history: { fields: { flooded: { kind: "boolean" } } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastChangedAt"]
@@ -55774,6 +56655,10 @@ var gasCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): recorded series.
+	*/
+	history: { fields: { detected: { kind: "boolean" } } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastChangedAt"]
@@ -55859,7 +56744,18 @@ var humidifierCapability = {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): recorded series.
+	*/
+	history: { fields: {
+		currentHumidity: {
+			kind: "gauge",
+			unit: "%",
+			deadband: .5
+		},
+		on: { kind: "boolean" }
+	} }
 };
 /**
 * Single-metric humidity reading. Drives Home Assistant `sensor`
@@ -55903,6 +56799,14 @@ var humiditySensorCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): recorded series.
+	*/
+	history: { fields: { percent: {
+		kind: "gauge",
+		unit: "%",
+		deadband: .5
+	} } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastFetchedAt"]
@@ -55950,7 +56854,11 @@ var imageCapability = {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): none — not numeric.
+	*/
+	history: "none"
 };
 /**
 * Vendor-neutral image / picture-adjustment cap — the per-camera config
@@ -56107,6 +57015,10 @@ var imageSettingsCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): none — camera image configuration (operator intent), not a trend.
+	*/
+	history: "none",
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastFetchedAt"]
@@ -56492,7 +57404,11 @@ var intercomCapability = {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): none — talk sessions are a ledger concern, not a trend.
+	*/
+	history: "none"
 };
 /**
 * Robotic lawn-mower cap. Models HA `lawn_mower.*` entities — anything
@@ -56573,7 +57489,15 @@ var lawnMowerControlCapability = {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): recorded series.
+	*/
+	history: { fields: { batteryLevel: {
+		kind: "gauge",
+		unit: "%",
+		deadband: 2
+	} } }
 };
 /**
 * local-network — hub-only singleton.
@@ -56700,7 +57624,13 @@ var ConnectionEndpointSchema = object({
 	* calls so the client can sort even if the cap returns a new
 	* ordering between polls.
 	*/
-	priority: number()
+	priority: number(),
+	/**
+	* `false` = the address changes on its own (a Quick tunnel, re-issued on
+	* every respawn). Automatic role resolution skips it (D860); an explicit
+	* operator flag still honours it. Absent = stable.
+	*/
+	stable: boolean().optional()
 });
 /**
 * Where the advertised local port came from. Ordered most → least
@@ -56980,6 +57910,10 @@ var lockControlCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): none — enum state; lock events belong in the events ledger.
+	*/
+	history: "none",
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastChangedAt"]
@@ -57151,7 +58085,11 @@ var mediaPlayerCapability = {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): none — `positionMs` moves continuously while playing; volume is transient.
+	*/
+	history: "none"
 };
 /**
 * mesh-network — collection cap for mesh-VPN providers.
@@ -57460,7 +58398,14 @@ onMotionChanged: { data: MotionOnMotionChangedDataSchema } },
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): recorded series. A PIR sensor is a series; a camera is not (its motion is an addon series and a ledger).
+	*/
+	history: { fields: { detected: {
+		kind: "boolean",
+		excludeDeviceTypes: [DeviceType.Camera]
+	} } }
 };
 /**
 * Motion-trigger toggle for accessory devices.
@@ -57532,7 +58477,11 @@ var motionTriggerCapability = {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): none — configuration switch.
+	*/
+	history: "none"
 };
 /**
 * Motion-zones share the same MaskShape vocabulary as privacy-mask — the
@@ -57607,6 +58556,10 @@ var motionZonesCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): none — configuration.
+	*/
+	history: "none",
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastFetchedAt"]
@@ -57736,6 +58689,10 @@ var nativeObjectDetectionCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): none — event-like and nested per class; detections live in the objects ledger.
+	*/
+	history: "none",
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastFetchedAt"]
@@ -58019,7 +58976,11 @@ var navigationCapability = {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): none — control state of a robotic camera, configuration-like.
+	*/
+	history: "none"
 };
 /**
 * Network-link snapshot. Same shape for every provider (a Reolink wifi
@@ -58119,6 +59080,23 @@ onStatusChanged: { data: object({
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): recorded series.
+	*/
+	history: { fields: {
+		signalPercent: {
+			kind: "gauge",
+			unit: "%",
+			deadband: 3,
+			minIntervalMs: 6e4
+		},
+		rssiDbm: {
+			kind: "gauge",
+			unit: "dBm",
+			deadband: 2,
+			minIntervalMs: 6e4
+		}
+	} },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastUpdated"]
@@ -58507,7 +59485,11 @@ onSent: { data: object({
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): none — `queueDepth` is outbox operational state, not a device trend.
+	*/
+	history: "none"
 };
 /**
 * Generic numeric sensor — last-resort fallback when no typed numeric
@@ -58558,6 +59540,14 @@ var numericSensorCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): recorded series. The unit is per device, read from the sibling `unit` field.
+	*/
+	history: { fields: { value: {
+		kind: "gauge",
+		unitFrom: "unit",
+		minIntervalMs: 3e4
+	} } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastFetchedAt"]
@@ -59034,7 +60024,24 @@ var petFeederCapability = {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): recorded series.
+	*/
+	history: { fields: {
+		foodLevel: { kind: "gauge" },
+		food1: { kind: "gauge" },
+		food2: { kind: "gauge" },
+		batteryPower: {
+			kind: "gauge",
+			unit: "%",
+			deadband: 2
+		},
+		desiccantLeftDays: {
+			kind: "gauge",
+			unit: "days"
+		}
+	} }
 };
 var VehicleSchema = object({
 	id: string(),
@@ -59412,6 +60419,47 @@ var powerMeterCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): recorded series. Gauges are floored at 30 s; `kwhTotal` is the one monotonic meter (counter).
+	*/
+	history: { fields: {
+		watts: {
+			kind: "gauge",
+			unit: "W",
+			deadband: 1,
+			minIntervalMs: 3e4
+		},
+		kwhTotal: {
+			kind: "counter",
+			unit: "kWh",
+			deadband: .01,
+			minIntervalMs: 6e4
+		},
+		volts: {
+			kind: "gauge",
+			unit: "V",
+			deadband: 1,
+			minIntervalMs: 3e4
+		},
+		amps: {
+			kind: "gauge",
+			unit: "A",
+			deadband: .05,
+			minIntervalMs: 3e4
+		},
+		va: {
+			kind: "gauge",
+			unit: "VA",
+			deadband: 1,
+			minIntervalMs: 3e4
+		},
+		powerFactor: {
+			kind: "gauge",
+			unit: "ratio",
+			deadband: .01,
+			minIntervalMs: 6e4
+		}
+	} },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastFetchedAt"]
@@ -59479,6 +60527,14 @@ var presenceCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): recorded series.
+	*/
+	history: { fields: { batteryPercent: {
+		kind: "gauge",
+		unit: "%",
+		deadband: 1
+	} } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastChangedAt"]
@@ -59525,6 +60581,14 @@ var pressureSensorCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): recorded series.
+	*/
+	history: { fields: { hpa: {
+		kind: "gauge",
+		unit: "hPa",
+		deadband: .1
+	} } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastFetchedAt"]
@@ -59684,6 +60748,10 @@ var privacyMaskCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): none — configuration.
+	*/
+	history: "none",
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastFetchedAt"]
@@ -60157,7 +61225,11 @@ var ptzAutotrackCapability = {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): none — configuration and capability.
+	*/
+	history: "none"
 };
 /**
 * reboot — device-scoped capability for "soft" device reboots (firmware
@@ -61612,6 +62684,10 @@ var recordingOnboardCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): none — SD-card configuration and window inventory; arrays.
+	*/
+	history: "none",
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastFetchedAt"]
@@ -61850,7 +62926,11 @@ getStatus: method(object({ deviceId: number() }), RecordingSignalStatusSchema) }
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): none — recording intent is already in the recordings ledger.
+	*/
+	history: "none"
 };
 /**
 * scene-monitor — device-scoped reference-region state cap. An operator marks
@@ -62223,7 +63303,11 @@ var sceneMonitorCapability = {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): none — nested configuration.
+	*/
+	history: "none"
 };
 /**
 * Per-stage gating mode applied to the zones a rule references.
@@ -62374,7 +63458,11 @@ var scriptRunnerCapability = {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): none — transient; run results belong in a ledger.
+	*/
+	history: "none"
 };
 /**
 * Smoke alarm sensor — boolean "is smoke currently detected" with
@@ -62409,6 +63497,10 @@ var smokeCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): recorded series.
+	*/
+	history: { fields: { detected: { kind: "boolean" } } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastChangedAt"]
@@ -62508,6 +63600,10 @@ var streamCatalogCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): none — stream inventory.
+	*/
+	history: "none",
 	/** Clock field: written, but excluded from the compare that decides whether
 	*  persisting is worth a SQLite commit — the descriptors are the value. */
 	volatileStateFields: ["lastFetchedAt"]
@@ -62657,6 +63753,10 @@ var streamParamsCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): none — encoder configuration.
+	*/
+	history: "none",
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastFetchedAt"]
@@ -62910,6 +64010,10 @@ var switchCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): recorded series.
+	*/
+	history: { fields: { on: { kind: "boolean" } } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastChangedAt"],
@@ -62924,6 +64028,21 @@ var switchCapability = {
 		}
 	}] }
 };
+/** C0 controls, DEL and the C1 range: none of them belongs in a name. */
+function hasControlCharacter(value) {
+	for (const char of value) {
+		const code = char.codePointAt(0) ?? 0;
+		if (code <= 31 || code >= 127 && code <= 159) return true;
+	}
+	return false;
+}
+string().transform((value) => value.trim()).pipe(string().min(1, "The server name cannot be empty").max(48, `The server name is at most 48 characters`).refine((value) => !hasControlCharacter(value), { message: "The server name cannot contain control characters" }));
+/** What every reader gets: the name to show, and whether the hub chose it itself. */
+var ServerNameInfoSchema = object({
+	name: string(),
+	/** `true` when nobody named the hub: `name` is the machine hostname. */
+	isDefault: boolean()
+});
 /**
 * system — system-scoped singleton capability exposing hub-level
 * health, feature flags, network interface enumeration, and the
@@ -62953,6 +64072,12 @@ var FeatureManifestSchema = object({
 	backup: boolean(),
 	repl: boolean()
 });
+/**
+* `system.info`: the feature flags plus the hub's human name (D861). The name is
+* `{ name, isDefault }` — `isDefault: true` means nobody named the hub and `name`
+* is the machine hostname.
+*/
+var SystemInfoSchema = FeatureManifestSchema.extend({ serverName: ServerNameInfoSchema });
 var HealthStatusSchema = object({
 	status: literal("ok"),
 	uptime: number()
@@ -63425,7 +64550,7 @@ var LoggingSettingsStateSchema = object({
 	opsLogRetentionDays: number().int().min(0),
 	persisted: boolean()
 });
-method(_void(), FeatureManifestSchema), method(_void(), HealthStatusSchema), method(_void(), FeatureManifestSchema), method(_void(), array(NetworkAddressSchema).readonly()), method(_void(), unknown().nullable(), { auth: "admin" }), method(record(string(), unknown()), _null(), {
+method(_void(), SystemInfoSchema), method(_void(), HealthStatusSchema), method(_void(), FeatureManifestSchema), method(_void(), array(NetworkAddressSchema).readonly()), method(_void(), unknown().nullable(), { auth: "admin" }), method(record(string(), unknown()), _null(), {
 	kind: "mutation",
 	auth: "admin"
 }), method(_void(), _void(), {
@@ -63471,6 +64596,10 @@ var tamperCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): recorded series.
+	*/
+	history: { fields: { tampered: { kind: "boolean" } } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastChangedAt"]
@@ -63526,6 +64655,14 @@ var temperatureSensorCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): recorded series.
+	*/
+	history: { fields: { celsius: {
+		kind: "gauge",
+		unit: "°C",
+		deadband: .1
+	} } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastFetchedAt"]
@@ -63604,7 +64741,11 @@ var updateCapability = {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): none — text and state.
+	*/
+	history: "none"
 };
 var UserSummarySchema = object({
 	id: string(),
@@ -63961,7 +65102,37 @@ var vacuumControlCapability = {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): recorded series. Tank levels are fixed-object paths (`cleanWater.level`, ...).
+	*/
+	history: { fields: {
+		batteryLevel: {
+			kind: "gauge",
+			unit: "%",
+			deadband: 2
+		},
+		"cleanWater.level": {
+			kind: "gauge",
+			unit: "%",
+			deadband: 2
+		},
+		"dirtyWater.level": {
+			kind: "gauge",
+			unit: "%",
+			deadband: 2
+		},
+		"detergent.level": {
+			kind: "gauge",
+			unit: "%",
+			deadband: 2
+		},
+		"dustBin.level": {
+			kind: "gauge",
+			unit: "%",
+			deadband: 2
+		}
+	} }
 };
 var ValveStatusSchema = object({
 	/** Lifecycle state of the valve. */
@@ -64020,7 +65191,15 @@ var valveCapability = {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): recorded series. Actuator tier: position keeps every change.
+	*/
+	history: { fields: { position: {
+		kind: "gauge",
+		unit: "%",
+		minIntervalMs: 0
+	} } }
 };
 /**
 * Vibration / shake / impact sensor. Drives Home Assistant
@@ -64050,6 +65229,10 @@ var vibrationCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
+	/**
+	* History (D850): recorded series.
+	*/
+	history: { fields: { detected: { kind: "boolean" } } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastChangedAt"]
@@ -64133,7 +65316,22 @@ var waterHeaterCapability = {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): recorded series. The schema carries no unit; providers publish Celsius. Setpoint keeps every change.
+	*/
+	history: { fields: {
+		currentTemp: {
+			kind: "gauge",
+			unit: "°C",
+			deadband: .5
+		},
+		targetTemp: {
+			kind: "gauge",
+			unit: "°C",
+			minIntervalMs: 0
+		}
+	} }
 };
 /**
 * Weather provider cap. Models HA `weather.*` entities — a read-only
@@ -64199,7 +65397,32 @@ var weatherCapability = {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): recorded series. Units follow the sibling `*Unit` fields.
+	*/
+	history: { fields: {
+		temperature: {
+			kind: "gauge",
+			unitFrom: "temperatureUnit",
+			deadband: .2
+		},
+		humidity: {
+			kind: "gauge",
+			unit: "%",
+			deadband: 1
+		},
+		pressure: {
+			kind: "gauge",
+			unitFrom: "pressureUnit",
+			deadband: .5
+		},
+		windSpeed: {
+			kind: "gauge",
+			unitFrom: "windSpeedUnit",
+			deadband: .5
+		}
+	} }
 };
 /**
 * Per-zone occupancy aggregation produced by the analytics frame
@@ -64441,7 +65664,11 @@ var zoneAnalyticsCapability = {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "session",
+	/**
+	* History (D850): none — occupancy is the addon series `pipeline-analytics/occupancy`; the rest is per-zone arrays keyed by runtime ids.
+	*/
+	history: "none"
 };
 /**
 * Stages a {@link ZoneRule} can apply to. Discriminator on the rules
@@ -64526,7 +65753,11 @@ var zoneRulesCapability = {
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "restored"
+	durability: "restored",
+	/**
+	* History (D850): none — configuration arrays.
+	*/
+	history: "none"
 };
 /**
 * `training-provider` — ONE cloud that can run the CamStack trainer.
@@ -68130,6 +69361,54 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"deviceCredentials.deleteDeviceCredential": {
+		capName: "device-credentials",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"deviceCredentials.getDeviceCaStatus": {
+		capName: "device-credentials",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceCredentials.getDeviceCertificateSettings": {
+		capName: "device-credentials",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceCredentials.listDeviceCredentials": {
+		capName: "device-credentials",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceCredentials.renameDeviceCredential": {
+		capName: "device-credentials",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"deviceCredentials.revokeDeviceCredential": {
+		capName: "device-credentials",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"deviceCredentials.setDeviceCertificateSettings": {
+		capName: "device-credentials",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"deviceCredentials.startEnrollment": {
+		capName: "device-credentials",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"deviceDiscovery.adoptDevice": {
 		capName: "device-discovery",
 		capScope: "device",
@@ -68232,6 +69511,66 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"deviceHistory.declareSeries": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"deviceHistory.getDeviceEnabled": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceHistory.getStatus": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceHistory.listNodeSeries": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceHistory.listSeries": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceHistory.query": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceHistory.queryNode": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceHistory.record": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"deviceHistory.recordBuckets": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"deviceHistory.setDeviceEnabled": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"deviceManager.addLocation": {
 		capName: "device-manager",
 		capScope: "system",
@@ -68310,6 +69649,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"deviceManager.cleanupDeletedDevicesData": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"deviceManager.createDevice": {
 		capName: "device-manager",
 		capScope: "system",
@@ -68490,6 +69835,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"deviceManager.listDeletedSince": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"deviceManager.listDeviceIdsByCaps": {
 		capName: "device-manager",
 		capScope: "system",
@@ -68898,6 +70249,18 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"deviceRemovalHook.listDeviceData": {
+		capName: "device-removal-hook",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceRemovalHook.onDeviceRemoved": {
+		capName: "device-removal-hook",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"deviceState.claimFields": {
 		capName: "device-state",
 		capScope: "system",
@@ -69330,6 +70693,12 @@ Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
+	"keychain.deleteDeviceScope": {
+		capName: "keychain",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
 	"keychain.getState": {
 		capName: "keychain",
 		capScope: "system",
@@ -70290,6 +71659,54 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"nodeCertificates.confirmMeshLeaf": {
+		capName: "node-certificates",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"nodeCertificates.forgetHub": {
+		capName: "node-certificates",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"nodeCertificates.getCertificates": {
+		capName: "node-certificates",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"nodeCertificates.installHttpsCertificate": {
+		capName: "node-certificates",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"nodeCertificates.installMeshLeaf": {
+		capName: "node-certificates",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"nodeCertificates.prepareHttpsCertificate": {
+		capName: "node-certificates",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"nodeCertificates.prepareMeshRenewal": {
+		capName: "node-certificates",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"nodeCertificates.rollbackMeshLeaf": {
+		capName: "node-certificates",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"nodes.clusterAddonStatus": {
 		capName: "nodes",
 		capScope: "system",
@@ -75133,6 +76550,26 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"deviceHistory.getDeviceEnabled": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceHistory.listSeries": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceHistory.query": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceHistory.setDeviceEnabled": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"deviceManager.adoptionRelease": [{
 		name: "camDeviceId",
 		form: "single",
@@ -75426,6 +76863,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"deviceRemovalHook.onDeviceRemoved": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"deviceState.claimFields": [{
 		name: "deviceId",
 		form: "single",
@@ -75615,6 +77057,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"keychain.deleteDeviceScope": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"lawnMowerControl.dock": [{
 		name: "deviceId",
 		form: "single",
@@ -77311,6 +78758,7 @@ Object.freeze({
 	"network-access": "ingress",
 	"smtp-provider": "email"
 });
+DeviceType.Camera;
 var G711_SCALE_CORRECTION_DB = {
 	PCMU: 20 * Math.log10(4),
 	PCMA: 20 * Math.log10(8)
@@ -77962,6 +79410,8 @@ new Set([
 	"audio-tools",
 	"audio-silence"
 ]);
+AppPageLangSchema.options;
+record(string().min(1), string());
 /**
 * TimelapseRule — the STANDALONE scheduled timelapse producer's rule model.
 *
@@ -185281,71 +186731,88 @@ var intercomFailureReport = new IntercomFailureReport();
 var SNAPSHOT_GROUPS = [
 	{
 		key: "imageSnapshot",
-		label: "Image (getVideoInput)"
+		label: "Image (getVideoInput)",
+		labelKey: "provider-reolink:snapshot_groups.imageSnapshot.label"
 	},
 	{
 		key: "motionSnapshot",
-		label: "Motion (getMotionAlarm)"
+		label: "Motion (getMotionAlarm)",
+		labelKey: "provider-reolink:snapshot_groups.motionSnapshot.label"
 	},
 	{
 		key: "aiSensitivitySnapshot",
-		label: "AI sensitivity (getAiDetectionFull)"
+		label: "AI sensitivity (getAiDetectionFull)",
+		labelKey: "provider-reolink:snapshot_groups.aiSensitivitySnapshot.label"
 	},
 	{
 		key: "encSnapshot",
-		label: "Encoder (getEnc)"
+		label: "Encoder (getEnc)",
+		labelKey: "provider-reolink:snapshot_groups.encSnapshot.label"
 	},
 	{
 		key: "encOptionsSnapshot",
-		label: "Encoder options (getEncOptions)"
+		label: "Encoder options (getEncOptions)",
+		labelKey: "provider-reolink:snapshot_groups.encOptionsSnapshot.label"
 	},
 	{
 		key: "maskSnapshot",
-		label: "Privacy mask (getMask)"
+		label: "Privacy mask (getMask)",
+		labelKey: "provider-reolink:snapshot_groups.maskSnapshot.label"
 	},
 	{
 		key: "audioNoiseSnapshot",
-		label: "Audio noise (getAudioNoise)"
+		label: "Audio noise (getAudioNoise)",
+		labelKey: "provider-reolink:snapshot_groups.audioNoiseSnapshot.label"
 	},
 	{
 		key: "autoFocusSnapshot",
-		label: "Auto-focus (getAutoFocus)"
+		label: "Auto-focus (getAutoFocus)",
+		labelKey: "provider-reolink:snapshot_groups.autoFocusSnapshot.label"
 	},
 	{
 		key: "netPortSnapshot",
-		label: "Network ports (getNetPort)"
+		label: "Network ports (getNetPort)",
+		labelKey: "provider-reolink:snapshot_groups.netPortSnapshot.label"
 	},
 	{
 		key: "ntpSnapshot",
-		label: "NTP (getNtp)"
+		label: "NTP (getNtp)",
+		labelKey: "provider-reolink:snapshot_groups.ntpSnapshot.label"
 	},
 	{
 		key: "systemGeneralSnapshot",
-		label: "System general (getSystemGeneral)"
+		label: "System general (getSystemGeneral)",
+		labelKey: "provider-reolink:snapshot_groups.systemGeneralSnapshot.label"
 	},
 	{
 		key: "osdSnapshot",
-		label: "OSD overlay (getOsd)"
+		label: "OSD overlay (getOsd)",
+		labelKey: "provider-reolink:snapshot_groups.osdSnapshot.label"
 	},
 	{
 		key: "ledSnapshot",
-		label: "LEDs (getIrLights)"
+		label: "LEDs (getIrLights)",
+		labelKey: "provider-reolink:snapshot_groups.ledSnapshot.label"
 	},
 	{
 		key: "pirSnapshot",
-		label: "PIR (getPirInfo)"
+		label: "PIR (getPirInfo)",
+		labelKey: "provider-reolink:snapshot_groups.pirSnapshot.label"
 	},
 	{
 		key: "autoRebootSnapshot",
-		label: "Auto reboot (getAutoReboot)"
+		label: "Auto reboot (getAutoReboot)",
+		labelKey: "provider-reolink:snapshot_groups.autoRebootSnapshot.label"
 	},
 	{
 		key: "emailConfigSnapshot",
-		label: "Email/SMTP (getEmail)"
+		label: "Email/SMTP (getEmail)",
+		labelKey: "provider-reolink:snapshot_groups.emailConfigSnapshot.label"
 	},
 	{
 		key: "capOptionsSnapshot",
-		label: "Cap option probes (getOptions)"
+		label: "Cap option probes (getOptions)",
+		labelKey: "provider-reolink:snapshot_groups.capOptionsSnapshot.label"
 	}
 ];
 /**
@@ -185429,12 +186896,15 @@ function buildSnapshotFreshnessSection(cache, opts) {
 		id: "snapshotFreshness",
 		tab: "advanced",
 		title: "Snapshot freshness",
+		titleKey: "provider-reolink:snapshotFreshnessSection.s_snapshotFreshness.title",
 		description: "When each cached camera reading was last fetched. Groups without a stamp were persisted before per-snapshot tracking — their age is unknown, not fresh. Use \"Refresh from camera\" (General) to re-read an awake camera.",
+		descriptionKey: "provider-reolink:snapshotFreshnessSection.s_snapshotFreshness.description",
 		columns: 1,
 		fields: [{
 			type: "info",
 			key: "snapshotFreshness",
 			label: "Per-snapshot read times",
+			labelKey: "provider-reolink:field.snapshotFreshness.label",
 			content: `${opts.sleeping ? "Camera is asleep — no group can refresh until it wakes; a sleeping battery camera is never woken to read settings.\n" : ""}${header}\n${lines.join("\n")}`
 		}]
 	};
@@ -186630,7 +188100,7 @@ function capDayNightModeToReolink(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");
+		case "schedule": throw userError("reolink.day-night-schedule-unsupported", void 0, "Reolink cameras do not support a scheduled day/night mode");
 	}
 }
 //#endregion
@@ -186925,6 +188395,7 @@ function buildOsdStateBanner(snapshot, opts) {
 		type: "info",
 		key: "osdSnapshotState",
 		label: "OSD state",
+		labelKey: "provider-reolink:osdStateBanner.osdSnapshotState.label",
 		variant: "warning",
 		content: snapshot === void 0 ? `Camera is asleep and its OSD state has never been read — the toggles below are unknown until it wakes; ${NEVER_WOKEN_SUFFIX}` : snapshot.fetchedAt !== void 0 ? `Camera is asleep — showing the OSD state last read ${new Date(snapshot.fetchedAt).toLocaleString()}. It refreshes when the camera wakes; ${NEVER_WOKEN_SUFFIX}` : `Camera is asleep — showing the last known OSD state (age unknown). It refreshes when the camera wakes; ${NEVER_WOKEN_SUFFIX}`
 	};
@@ -186932,6 +188403,7 @@ function buildOsdStateBanner(snapshot, opts) {
 		type: "info",
 		key: "osdSnapshotState",
 		label: "OSD state",
+		labelKey: "provider-reolink:osdStateBanner.osdSnapshotState.label",
 		variant: "warning",
 		content: "OSD state has not been read from this camera yet — unknown toggles are disabled until a read succeeds."
 	};
@@ -186981,7 +188453,9 @@ function buildOsdSection(snapshot, values, opts) {
 		id: "osd",
 		tab: "image",
 		title: "OSD overlay",
+		titleKey: "provider-reolink:osdSection.s_osd.title",
 		description: "On-screen overlays burned into the video by the camera. Read with `GetOsdDatetime` (cmd_id 44) and pushed with `SetOsdDatetime` (cmd_id 45). Positions are the four frame corners; an overlay the camera holds somewhere else keeps that placement unless a corner is chosen.",
+		descriptionKey: "provider-reolink:osdSection.s_osd.description",
 		columns: 2,
 		fields: [
 			...banner ? [banner] : [],
@@ -186991,7 +188465,9 @@ function buildOsdSection(snapshot, values, opts) {
 				type: "text",
 				key: "osdChannelName",
 				label: "Channel name",
+				labelKey: "provider-reolink:fields.osdChannelName.label",
 				description: "Text shown in the channel-name overlay.",
+				descriptionKey: "provider-reolink:fields.osdChannelName.description",
 				default: values.osdChannelName,
 				placeholder: "Front door"
 			},
@@ -187474,13 +188950,17 @@ var SirenAccessory = class extends BaseDevice {
 		return hydrateSchema({ sections: [{
 			id: "siren",
 			title: "Siren",
+			titleKey: "provider-reolink:schema.s_siren.title",
 			description: "Tone duration when triggered. Set to 0 for \"play until turned off\"; positive values pulse for that many seconds.",
+			descriptionKey: "provider-reolink:schema.s_siren.description",
 			columns: 1,
 			fields: [{
 				type: "number",
 				key: "sirenDurationS",
 				label: "Default duration (seconds)",
+				labelKey: "provider-reolink:schema.s_siren.sirenDurationS.label",
 				description: "Forwarded to `setSiren(on=true, duration)` (cmd_id 30) when the operator flips the switch.",
+				descriptionKey: "provider-reolink:schema.s_siren.sirenDurationS.description",
 				default: 0,
 				min: 0,
 				max: 300,
@@ -187489,13 +188969,17 @@ var SirenAccessory = class extends BaseDevice {
 		}, {
 			id: "motion-siren",
 			title: "Motion-triggered siren",
+			titleKey: "provider-reolink:schema.s_motion-siren.title",
 			description: "Detection classes that fire the siren when \"Trigger on motion\" is armed. Forwarded as a `typeScheduleList` to `setSirenOnMotion` (cmd_id 231). Saved values re-apply on every motion-trigger flip.",
+			descriptionKey: "provider-reolink:schema.s_motion-siren.description",
 			columns: 1,
 			fields: [{
 				type: "select",
 				key: "motionSirenDetectType",
 				label: "Detection classes",
+				labelKey: "provider-reolink:schema.s_motion-siren.motionSirenDetectType.label",
 				description: "Object/motion classes that arm the siren. `MD` = generic motion detection.",
+				descriptionKey: "provider-reolink:schema.s_motion-siren.motionSirenDetectType.description",
 				options: SIREN_DETECT_TYPE_CHOICES.map((v) => ({
 					value: v,
 					label: v.replace(/,/g, " + ").replace(/_/g, "+")
@@ -187958,13 +189442,17 @@ var FloodlightAccessory = class extends BaseDevice {
 		return hydrateSchema({ sections: [{
 			id: "motion-floodlight",
 			title: "Motion-triggered floodlight",
+			titleKey: "provider-reolink:schema.s_motion-floodlight.title",
 			description: "Pushed to the camera (`FloodlightTask`) when the \"Trigger on motion\" toggle is armed. Saved values also re-apply on every motion-trigger flip so the firmware always honours your preference.",
+			descriptionKey: "provider-reolink:schema.s_motion-floodlight.description",
 			columns: 2,
 			fields: [{
 				type: "number",
 				key: "motionLightDurationS",
 				label: "Light duration (s)",
+				labelKey: "provider-reolink:schema.s_motion-floodlight.motionLightDurationS.label",
 				description: "Seconds the floodlight stays lit after a motion event. Reolink range 1..600s.",
+				descriptionKey: "provider-reolink:schema.s_motion-floodlight.motionLightDurationS.description",
 				min: 1,
 				max: 600,
 				step: 1,
@@ -187973,7 +189461,9 @@ var FloodlightAccessory = class extends BaseDevice {
 				type: "select",
 				key: "motionLightDetectType",
 				label: "Detection classes",
+				labelKey: "provider-reolink:schema.s_motion-floodlight.motionLightDetectType.label",
 				description: "Object classes that turn the floodlight on. Composed values (e.g. \"people,vehicle\") fire when ANY listed class detects.",
+				descriptionKey: "provider-reolink:schema.s_motion-floodlight.motionLightDetectType.description",
 				options: FLOODLIGHT_DETECT_TYPE_CHOICES.map((v) => ({
 					value: v,
 					label: v.replace(/,/g, " + ").replace(/_/g, "+")
@@ -188212,14 +189702,18 @@ var PirAccessory = class extends BaseDevice {
 		return hydrateSchema({ sections: [{
 			id: "pir",
 			title: "PIR sensor",
+			titleKey: "provider-reolink:schema.s_pir.title",
 			description: "Hardware passive-infrared trigger configuration. Pushed via cmd_id 153 (SetPirInfo).",
+			descriptionKey: "provider-reolink:schema.s_pir.description",
 			columns: 2,
 			fields: [
 				{
 					type: "slider",
 					key: "pirSensitive",
 					label: "Sensitivity",
+					labelKey: "provider-reolink:schema.s_pir.pirSensitive.label",
 					description: "Higher value → triggers on smaller motion. Most cameras max at 100.",
+					descriptionKey: "provider-reolink:schema.s_pir.pirSensitive.description",
 					min: 1,
 					max: 100,
 					step: 1,
@@ -188230,6 +189724,7 @@ var PirAccessory = class extends BaseDevice {
 					type: "slider",
 					key: "pirIntervalS",
 					label: "Cooldown (seconds)",
+					labelKey: "provider-reolink:schema.s_pir.pirIntervalS.label",
 					description: `Minimum delay between consecutive PIR triggers. Reolink app range 5..${intervalMax}s; firmware clamps on push.`,
 					min: 5,
 					max: intervalMax,
@@ -188242,7 +189737,9 @@ var PirAccessory = class extends BaseDevice {
 					type: "boolean",
 					key: "pirReduceAlarm",
 					label: "Reduce false alarms",
+					labelKey: "provider-reolink:schema.s_pir.pirReduceAlarm.label",
 					description: "Trades detection range for fewer false positives. Maps to firmware `reduceAlarm` flag.",
+					descriptionKey: "provider-reolink:schema.s_pir.pirReduceAlarm.description",
 					...typeof reduceAlarm === "boolean" ? { default: reduceAlarm } : {},
 					style: "switch",
 					span: 2
@@ -189770,6 +191267,7 @@ function buildSessionsTabSections(snap, opts) {
 		type: "info",
 		key: "sessionsError",
 		label: "Refresh error",
+		labelKey: "provider-reolink:errorBanner.sessionsError.label",
 		content: snap.error,
 		variant: "danger"
 	}] : [];
@@ -189791,6 +191289,7 @@ function buildSessionsTabSections(snap, opts) {
 		id: "sessions-status",
 		title: opts.title ?? "Sessions",
 		description: "Diagnostics for the Baichuan control channel. Auto-refreshes when older than 1 minute; click Refresh to force.",
+		descriptionKey: "provider-reolink:sessionsTabSections.s_sessions-status.description",
 		tab: opts.tabId,
 		order: 0,
 		columns: 1,
@@ -189800,38 +191299,46 @@ function buildSessionsTabSections(snap, opts) {
 				type: "info",
 				key: "sessionsLastRefreshed",
 				label: "Last refreshed",
+				labelKey: "provider-reolink:sessionsTabSections.s_sessions-status.sessionsLastRefreshed.label",
 				content: ageInfo
 			},
 			{
 				type: "object-array",
 				key: "sessionsOnlineUsers",
 				label: "Online users (firmware)",
+				labelKey: "provider-reolink:sessionsTabSections.s_sessions-status.sessionsOnlineUsers.label",
 				description: "Active user sessions reported by the device (cmd_id 145). Includes other admins, mobile app, NVR linkups.",
+				descriptionKey: "provider-reolink:sessionsTabSections.s_sessions-status.sessionsOnlineUsers.description",
 				columns: [
 					{
 						key: "userName",
-						label: "User"
+						label: "User",
+						labelKey: "provider-reolink:sessionsTabSections.s_sessions-status.sessionsOnlineUsers.userName.label"
 					},
 					{
 						key: "ip",
 						label: "IP",
+						labelKey: "provider-reolink:sessionsTabSections.s_sessions-status.sessionsOnlineUsers.ip.label",
 						kind: "monospace",
 						width: "160px"
 					},
 					{
 						key: "sessionId",
 						label: "Session",
+						labelKey: "provider-reolink:sessionsTabSections.s_sessions-status.sessionsOnlineUsers.sessionId.label",
 						kind: "monospace",
 						width: "90px"
 					},
 					{
 						key: "level",
 						label: "Level",
+						labelKey: "provider-reolink:sessionsTabSections.s_sessions-status.sessionsOnlineUsers.level.label",
 						width: "80px"
 					},
 					{
 						key: "status",
 						label: "State",
+						labelKey: "provider-reolink:sessionsTabSections.s_sessions-status.sessionsOnlineUsers.status.label",
 						kind: "status",
 						width: "100px"
 					}
@@ -189843,14 +191350,18 @@ function buildSessionsTabSections(snap, opts) {
 				type: "object-array",
 				key: "sessionsSocketPool",
 				label: "Our socket pool",
+				labelKey: "provider-reolink:sessionsTabSections.s_sessions-status.sessionsSocketPool.label",
 				description: "Open Baichuan TCP/UDP sockets this process holds for the device. One row per pool tag.",
+				descriptionKey: "provider-reolink:sessionsTabSections.s_sessions-status.sessionsSocketPool.description",
 				columns: [{
 					key: "tag",
 					label: "Tag",
+					labelKey: "provider-reolink:sessionsTabSections.s_sessions-status.sessionsSocketPool.tag.label",
 					kind: "monospace"
 				}, {
 					key: "state",
 					label: "State",
+					labelKey: "provider-reolink:sessionsTabSections.s_sessions-status.sessionsSocketPool.state.label",
 					kind: "status",
 					width: "100px"
 				}],
@@ -189861,10 +191372,13 @@ function buildSessionsTabSections(snap, opts) {
 				type: "object-array",
 				key: "sessionsDedicated",
 				label: "Dedicated lib sessions",
+				labelKey: "provider-reolink:sessionsTabSections.s_sessions-status.sessionsDedicated.label",
 				description: "Internal lib-side dedicated sessions (streaming/talk channels). Older lib versions leave this list empty.",
+				descriptionKey: "provider-reolink:sessionsTabSections.s_sessions-status.sessionsDedicated.description",
 				columns: [{
 					key: "key",
 					label: "Session key",
+					labelKey: "provider-reolink:sessionsTabSections.s_sessions-status.sessionsDedicated.key.label",
 					kind: "monospace"
 				}],
 				value: dedicatedRows,
@@ -189874,12 +191388,14 @@ function buildSessionsTabSections(snap, opts) {
 				type: "info",
 				key: "sessionsCooldown",
 				label: "Reconnect cooldown",
+				labelKey: "provider-reolink:sessionsTabSections.s_sessions-status.sessionsCooldown.label",
 				content: cooldownText
 			},
 			{
 				type: "device-action-button",
 				key: "_refreshSessions",
 				label: "Refresh sessions",
+				labelKey: "provider-reolink:sessionsTabSections.s_sessions-status._refreshSessions.label",
 				buttonLabel: "Refresh now",
 				action: "refresh-sessions",
 				variant: "default"
@@ -191351,11 +192867,11 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 		});
 		if (!this.isEmailPushEligible) {
 			this.ctx.logger.warn("email-push: not eligible (hub-attached camera)", { tags: { deviceId: this.id } });
-			throw new Error("Email push is not available for hub-attached cameras");
+			throw userError("reolink.email-push-hub-attached", void 0, "Email push is not available for hub-attached cameras");
 		}
 		if (!this.emailPushParamsResolver) {
 			this.ctx.logger.warn("email-push: resolver not wired — restart the Reolink addon", { tags: { deviceId: this.id } });
-			throw new Error("Email Push Server is not wired — restart the Reolink addon");
+			throw userError("reolink.email-push-not-wired", void 0, "Email Push Server is not wired — restart the Reolink addon");
 		}
 		const params = await this.emailPushParamsResolver();
 		if (!params) {
@@ -191414,14 +192930,14 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 			this.ctx.logger.warn("baichuan-webhook: not eligible", { tags: { deviceId: this.id } });
 			throw new Error("HaCfg webhook Auto-configure is only available on standalone battery cameras");
 		}
-		if (!this.baichuanWebhookParamsResolver) throw new Error("HaCfg Webhook Server is not wired — restart the Reolink addon");
+		if (!this.baichuanWebhookParamsResolver) throw userError("reolink.webhook-not-wired", void 0, "HaCfg Webhook Server is not wired — restart the Reolink addon");
 		const params = await this.baichuanWebhookParamsResolver();
 		if (!params) throw new Error("Enable the HaCfg Webhook Server in the Reolink addon settings, and ensure this host has a reachable LAN address.");
 		await this.wakeIfSleeping();
 		const api = await this.ensureApi();
 		const supported = await api.probeBaichuanWebhookSupport();
 		this.baichuanWebhookSupportedCached = supported;
-		if (!supported) throw new Error("Camera firmware does not support Baichuan HaCfg webhook (cmd 806)");
+		if (!supported) throw userError("reolink.webhook-unsupported", void 0, "Camera firmware does not support Baichuan HaCfg webhook (cmd 806)");
 		this.ctx.logger.info("baichuan-webhook: auto-configuring camera", {
 			tags: { deviceId: this.id },
 			meta: { url: params.url }
@@ -192100,26 +193616,32 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 			id: "sleep-push",
 			tab: "motion",
 			title: "Battery motion (sleep push)",
+			titleKey: "provider-reolink:emailPushSection.s_sleep-push.title",
 			description: "Battery cameras sleep and can't be polled for motion. Prefer HaCfg webhook when the firmware supports it (cmd 806); otherwise use Email/SMTP. Enable the matching server under Integrations → Reolink, then Auto-configure. Only one path should be armed — the preference below gates which inbound source is accepted.",
+			descriptionKey: "provider-reolink:emailPushSection.s_sleep-push.description",
 			columns: 1,
 			fields: [
 				{
 					type: "select",
 					key: "batterySleepPushMethod",
 					label: "Preferred sleep-push path",
+					labelKey: "provider-reolink:emailPushSection.s_sleep-push.batterySleepPushMethod.label",
 					default: "auto",
 					options: [
 						{
 							value: "auto",
-							label: "Auto (webhook if supported, else email)"
+							label: "Auto (webhook if supported, else email)",
+							labelKey: "provider-reolink:emailPushSection.s_sleep-push.batterySleepPushMethod.o_auto.label"
 						},
 						{
 							value: "webhook",
-							label: "HaCfg webhook only"
+							label: "HaCfg webhook only",
+							labelKey: "provider-reolink:emailPushSection.s_sleep-push.batterySleepPushMethod.o_webhook.label"
 						},
 						{
 							value: "email",
-							label: "Email/SMTP only"
+							label: "Email/SMTP only",
+							labelKey: "provider-reolink:emailPushSection.s_sleep-push.batterySleepPushMethod.o_email.label"
 						}
 					]
 				},
@@ -192127,6 +193649,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 					type: "device-action-button",
 					key: "_autoConfigureBaichuanWebhook",
 					label: "HaCfg webhook",
+					labelKey: "provider-reolink:emailPushSection.s_sleep-push._autoConfigureBaichuanWebhook.label",
 					buttonLabel: "Auto-configure HaCfg webhook",
 					action: "auto-configure-baichuan-webhook",
 					variant: "default"
@@ -192135,6 +193658,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 					type: "device-action-button",
 					key: "_autoConfigureEmailPush",
 					label: "Email push",
+					labelKey: "provider-reolink:emailPushSection.s_sleep-push._autoConfigureEmailPush.label",
 					buttonLabel: "Auto-configure email push",
 					action: "auto-configure-email-push",
 					variant: "default"
@@ -192158,19 +193682,23 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 				id: "email-smtp",
 				tab: "email",
 				title: "SMTP server",
+				titleKey: "provider-reolink:emailTabSections.s_email-smtp.title",
 				description: "The camera's own outgoing-mail (SMTP) settings. Edit and save to write them to the camera, or use \"Auto-configure email push\" under Motion to point it at the built-in server. Leave the password blank to keep the current one.",
+				descriptionKey: "provider-reolink:emailTabSections.s_email-smtp.description",
 				columns: 2,
 				fields: [
 					{
 						type: "text",
 						key: "emailSmtpServer",
 						label: "SMTP server",
+						labelKey: "provider-reolink:emailTabSections.s_email-smtp.emailSmtpServer.label",
 						placeholder: "smtp.example.com"
 					},
 					{
 						type: "number",
 						key: "emailSmtpPort",
 						label: "SMTP port",
+						labelKey: "provider-reolink:emailTabSections.s_email-smtp.emailSmtpPort.label",
 						min: 1,
 						max: 65535,
 						step: 1
@@ -192179,12 +193707,14 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 						type: "text",
 						key: "emailUserName",
 						label: "Username / sender",
+						labelKey: "provider-reolink:emailTabSections.s_email-smtp.emailUserName.label",
 						placeholder: "cam@example.com"
 					},
 					{
 						type: "password",
 						key: "emailPassword",
 						label: "Password",
+						labelKey: "provider-reolink:emailTabSections.s_email-smtp.emailPassword.label",
 						showToggle: true,
 						placeholder: "leave blank to keep"
 					},
@@ -192192,12 +193722,14 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 						type: "boolean",
 						key: "emailSsl",
 						label: "SSL/TLS",
+						labelKey: "provider-reolink:emailTabSections.s_email-smtp.emailSsl.label",
 						style: "switch"
 					},
 					{
 						type: "text",
 						key: "emailSendNickname",
-						label: "Sender name"
+						label: "Sender name",
+						labelKey: "provider-reolink:emailTabSections.s_email-smtp.emailSendNickname.label"
 					}
 				]
 			},
@@ -192205,24 +193737,29 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 				id: "email-recipients",
 				tab: "email",
 				title: "Recipients",
+				titleKey: "provider-reolink:emailTabSections.s_email-recipients.title",
 				description: "Up to three recipient addresses the camera sends motion mail to.",
+				descriptionKey: "provider-reolink:emailTabSections.s_email-recipients.description",
 				columns: 1,
 				fields: [
 					{
 						type: "text",
 						key: "emailRecipient1",
 						label: "Recipient 1",
+						labelKey: "provider-reolink:emailTabSections.s_email-recipients.emailRecipient1.label",
 						placeholder: "alerts@example.com"
 					},
 					{
 						type: "text",
 						key: "emailRecipient2",
-						label: "Recipient 2"
+						label: "Recipient 2",
+						labelKey: "provider-reolink:emailTabSections.s_email-recipients.emailRecipient2.label"
 					},
 					{
 						type: "text",
 						key: "emailRecipient3",
-						label: "Recipient 3"
+						label: "Recipient 3",
+						labelKey: "provider-reolink:emailTabSections.s_email-recipients.emailRecipient3.label"
 					}
 				]
 			},
@@ -192230,12 +193767,15 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 				id: "email-schedule",
 				tab: "email",
 				title: "Alarm schedule",
+				titleKey: "provider-reolink:emailTabSections.s_email-schedule.title",
 				description: "Master enable for the camera's email alarm schedule (EmailTask).",
+				descriptionKey: "provider-reolink:emailTabSections.s_email-schedule.description",
 				columns: 1,
 				fields: [{
 					type: "boolean",
 					key: "emailScheduleEnabled",
 					label: "Email alarm schedule enabled",
+					labelKey: "provider-reolink:emailTabSections.s_email-schedule.emailScheduleEnabled.label",
 					style: "switch"
 				}]
 			}
@@ -194463,7 +196003,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 					const api = await this.ensureApi();
 					const channel = this.getChannel();
 					const id = Number(presetId);
-					if (!Number.isFinite(id)) throw new Error(`Invalid presetId: ${presetId}`);
+					if (!Number.isFinite(id)) throw userError("reolink.preset-invalid", { presetId: String(presetId) }, `Invalid presetId: ${presetId}`);
 					await api.moveToPtzPreset(channel, id);
 				},
 				savePreset: async ({ deviceId, presetId, name }) => {
@@ -194471,7 +196011,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 					const api = await this.ensureApi();
 					const channel = this.getChannel();
 					const id = Number(presetId);
-					if (!Number.isFinite(id)) throw new Error(`Invalid presetId: ${presetId}`);
+					if (!Number.isFinite(id)) throw userError("reolink.preset-invalid", { presetId: String(presetId) }, `Invalid presetId: ${presetId}`);
 					await api.setPtzPreset(channel, id, name);
 				},
 				deletePreset: async ({ deviceId, presetId }) => {
@@ -194479,7 +196019,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 					const api = await this.ensureApi();
 					const channel = this.getChannel();
 					const id = Number(presetId);
-					if (!Number.isFinite(id)) throw new Error(`Invalid presetId: ${presetId}`);
+					if (!Number.isFinite(id)) throw userError("reolink.preset-invalid", { presetId: String(presetId) }, `Invalid presetId: ${presetId}`);
 					await api.deletePtzPreset(channel, id);
 				},
 				getOptions: async ({ deviceId }) => {
@@ -194531,7 +196071,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 					}
 					if (home.source === "none" || home.presetId === null) throw new Error("No home preset configured for this camera, and it has no guard point set — set one in the PTZ settings, or place a guard point on the camera");
 					const id = Number(home.presetId);
-					if (!Number.isFinite(id)) throw new Error(`Configured home preset is not a Baichuan id: ${home.presetId}`);
+					if (!Number.isFinite(id)) throw userError("reolink.home-preset-not-baichuan", { presetId: String(home.presetId) }, `Configured home preset is not a Baichuan id: ${home.presetId}`);
 					const api = await this.ensureApi();
 					const channel = this.getChannel();
 					await api.moveToPtzPreset(channel, id);
@@ -196103,12 +197643,15 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 					id: "driver-refresh",
 					tab: "general",
 					title: "Camera data",
+					titleKey: "provider-reolink:schema.s_driver-refresh.title",
 					description: "Go and ask the camera now. Every other read here is deliberately cheap about a battery camera — it serves what it already knows and refreshes quietly behind you, and never wakes a sleeping camera just because you opened this tab. This button is the exception: it wakes the camera, re-reads everything, and tells you what it got. Use it after changing settings from the Reolink app, or whenever you want to be sure the form is showing the camera and not a memory of it.",
+					descriptionKey: "provider-reolink:schema.s_driver-refresh.description",
 					columns: 1,
 					fields: [{
 						type: "device-action-button",
 						key: "_refreshSettings",
 						label: "Refresh from camera",
+						labelKey: "provider-reolink:schema.s_driver-refresh._refreshSettings.label",
 						buttonLabel: "Refresh now",
 						action: "refresh-settings",
 						variant: "default",
@@ -196119,13 +197662,16 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 					id: "connection",
 					tab: "general",
 					title: "Connection",
+					titleKey: "provider-reolink:schema.s_connection.title",
 					description: "Baichuan protocol connection settings.",
+					descriptionKey: "provider-reolink:schema.s_connection.description",
 					columns: 2,
 					fields: [
 						{
 							type: "text",
 							key: "host",
 							label: "Camera IP",
+							labelKey: "provider-reolink:schema.s_connection.host.label",
 							required: true,
 							placeholder: "192.168.10.100"
 						},
@@ -196133,6 +197679,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "number",
 							key: "port",
 							label: "Port",
+							labelKey: "provider-reolink:schema.s_connection.port.label",
 							default: 9e3,
 							min: 1,
 							max: 65535,
@@ -196142,12 +197689,14 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "text",
 							key: "username",
 							label: "Username",
+							labelKey: "provider-reolink:schema.s_connection.username.label",
 							default: "admin"
 						},
 						{
 							type: "password",
 							key: "password",
 							label: "Password",
+							labelKey: "provider-reolink:schema.s_connection.password.label",
 							required: true,
 							showToggle: true
 						}
@@ -196157,13 +197706,16 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 					id: "network-ports",
 					tab: "network",
 					title: "Service ports",
+					titleKey: "provider-reolink:schema.s_network-ports.title",
 					description: "Per-protocol enable toggle + port number, pushed via Baichuan `SetNetPort` (cmd_id 36). The Baichuan control port is the Connection → Port field. Changing a port number breaks existing URLs for that protocol until consumers are reconfigured.",
+					descriptionKey: "provider-reolink:schema.s_network-ports.description",
 					columns: 2,
 					fields: [
 						{
 							type: "boolean",
 							key: "netHttpEnable",
 							label: "HTTP enabled",
+							labelKey: "provider-reolink:schema.s_network-ports.netHttpEnable.label",
 							default: netSnap.http?.enable ?? true,
 							style: "switch"
 						},
@@ -196171,6 +197723,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "number",
 							key: "netHttpPort",
 							label: "HTTP port",
+							labelKey: "provider-reolink:schema.s_network-ports.netHttpPort.label",
 							default: netSnap.http?.port ?? 80,
 							min: 1,
 							max: 65535,
@@ -196180,6 +197733,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "boolean",
 							key: "netHttpsEnable",
 							label: "HTTPS enabled",
+							labelKey: "provider-reolink:schema.s_network-ports.netHttpsEnable.label",
 							default: netSnap.https?.enable ?? false,
 							style: "switch"
 						},
@@ -196187,6 +197741,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "number",
 							key: "netHttpsPort",
 							label: "HTTPS port",
+							labelKey: "provider-reolink:schema.s_network-ports.netHttpsPort.label",
 							default: netSnap.https?.port ?? 443,
 							min: 1,
 							max: 65535,
@@ -196196,6 +197751,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "boolean",
 							key: "netRtspEnable",
 							label: "RTSP enabled",
+							labelKey: "provider-reolink:schema.s_network-ports.netRtspEnable.label",
 							default: netSnap.rtsp?.enable ?? true,
 							style: "switch"
 						},
@@ -196203,6 +197759,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "number",
 							key: "netRtspPort",
 							label: "RTSP port",
+							labelKey: "provider-reolink:schema.s_network-ports.netRtspPort.label",
 							default: netSnap.rtsp?.port ?? 554,
 							min: 1,
 							max: 65535,
@@ -196212,6 +197769,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "boolean",
 							key: "netRtmpEnable",
 							label: "RTMP enabled",
+							labelKey: "provider-reolink:schema.s_network-ports.netRtmpEnable.label",
 							default: netSnap.rtmp?.enable ?? true,
 							style: "switch"
 						},
@@ -196219,6 +197777,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "number",
 							key: "netRtmpPort",
 							label: "RTMP port",
+							labelKey: "provider-reolink:schema.s_network-ports.netRtmpPort.label",
 							default: netSnap.rtmp?.port ?? 1935,
 							min: 1,
 							max: 65535,
@@ -196228,6 +197787,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "boolean",
 							key: "netOnvifEnable",
 							label: "ONVIF enabled",
+							labelKey: "provider-reolink:schema.s_network-ports.netOnvifEnable.label",
 							default: netSnap.onvif?.enable ?? true,
 							style: "switch"
 						},
@@ -196235,6 +197795,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "number",
 							key: "netOnvifPort",
 							label: "ONVIF port",
+							labelKey: "provider-reolink:schema.s_network-ports.netOnvifPort.label",
 							default: netSnap.onvif?.port ?? 8e3,
 							min: 1,
 							max: 65535,
@@ -196246,14 +197807,18 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 					id: "time-ntp",
 					tab: "network",
 					title: "Time / NTP",
+					titleKey: "provider-reolink:schema.s_time-ntp.title",
 					description: "Network time synchronisation. The camera-side push goes through the native Baichuan NTP commands; until those land in the driver lib the values persist to the driver config and apply on the next lib update.",
+					descriptionKey: "provider-reolink:schema.s_time-ntp.description",
 					columns: 2,
 					fields: [
 						{
 							type: "timezone",
 							key: "timeZoneId",
 							label: "Timezone",
+							labelKey: "provider-reolink:schema.s_time-ntp.timeZoneId.label",
 							description: "Camera timezone. Selecting a zone pushes its standard UTC offset (Baichuan `SetSystemGeneral`, cmd 105) and DST rule (`SetDst`, cmd 107) to the camera — DST is handled automatically by the chosen zone, so summer/winter clocks track correctly without a separate toggle.",
+							descriptionKey: "provider-reolink:schema.s_time-ntp.timeZoneId.description",
 							default: this.config.get("timeZoneId") ?? reolinkTimeZoneToIana(this.config.get("deviceCache")?.systemGeneralSnapshot?.timeZone) ?? "",
 							span: 2
 						},
@@ -196261,6 +197826,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "boolean",
 							key: "ntpEnabled",
 							label: "NTP sync",
+							labelKey: "provider-reolink:schema.s_time-ntp.ntpEnabled.label",
 							default: ntpSnap.enabled ?? true,
 							style: "switch",
 							span: 2
@@ -196269,6 +197835,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "text",
 							key: "ntpServer",
 							label: "NTP server",
+							labelKey: "provider-reolink:schema.s_time-ntp.ntpServer.label",
 							default: ntpSnap.server ?? "pool.ntp.org",
 							placeholder: "pool.ntp.org",
 							span: 2
@@ -196277,6 +197844,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "number",
 							key: "ntpPort",
 							label: "NTP port",
+							labelKey: "provider-reolink:schema.s_time-ntp.ntpPort.label",
 							default: ntpSnap.port ?? 123,
 							min: 1,
 							max: 65535,
@@ -196286,6 +197854,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "number",
 							key: "ntpInterval",
 							label: "Sync interval (min)",
+							labelKey: "provider-reolink:schema.s_time-ntp.ntpInterval.label",
 							default: ntpSnap.interval ?? 1440,
 							min: 1,
 							max: 10080,
@@ -196297,13 +197866,17 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 					id: "motion",
 					tab: "motion",
 					title: "On-camera motion (MdAlarm)",
+					titleKey: "provider-reolink:schema.s_motion.title",
 					description: "Camera-side motion detection master switch + sensitivity. Pushed via Baichuan `SetMdAlarm` (cmd_id 47). Range 1..50 matches the Reolink mobile app + web UI; the driver inverts to the camera-side raw value (`51 - value`) before push.",
+					descriptionKey: "provider-reolink:schema.s_motion.description",
 					columns: 2,
 					fields: [{
 						type: "boolean",
 						key: "motionEnabled",
 						label: "Motion detection",
+						labelKey: "provider-reolink:schema.s_motion.motionEnabled.label",
 						description: "Master switch for the camera's on-board motion detector. Disabling stops the camera from emitting motion events on the alarm channel.",
+						descriptionKey: "provider-reolink:schema.s_motion.motionEnabled.description",
 						default: motionSnap.enabled ?? true,
 						style: "switch",
 						span: 2
@@ -196311,7 +197884,9 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 						type: "slider",
 						key: "motionSensitivity",
 						label: "Sensitivity",
+						labelKey: "provider-reolink:schema.s_motion.motionSensitivity.label",
 						description: "Higher = triggers on smaller motion. Reolink user-facing range 1..50.",
+						descriptionKey: "provider-reolink:schema.s_motion.motionSensitivity.description",
 						min: 1,
 						max: 50,
 						step: 1,
@@ -196325,7 +197900,9 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 					id: "ai-sensitivity",
 					tab: "motion",
 					title: "AI detection sensitivity",
+					titleKey: "provider-reolink:schema.s_ai-sensitivity.title",
 					description: "Per-class on-camera AI sensitivity, stay time (dwell) + min/max target-size gates. Pushed via `SetAiAlarm` (cmd_id 343) in one consolidated write. Sensitivity range 0..100; stay time is the seconds the camera keeps the alarm asserted after the object leaves; target-size gates are the fraction of the frame (0..1) an object must occupy to be considered. Each group appears only when the camera advertises the corresponding detector.",
+					descriptionKey: "provider-reolink:schema.s_ai-sensitivity.description",
 					columns: 2,
 					fields: [
 						[
@@ -196456,13 +198033,16 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 					id: "image",
 					tab: "image",
 					title: "Image",
+					titleKey: "provider-reolink:schema.s_image.title",
 					description: "Core image settings pushed via Baichuan `SetImage` (cmd_id 25). Each slider rearms the camera on save; defaults seed from a `GetVideoInput` probe at boot (refreshed on every `applySettingsPatch`). Range 0..255 — most Reolink models clamp to 0..100 internally.",
+					descriptionKey: "provider-reolink:schema.s_image.description",
 					columns: 2,
 					fields: [
 						{
 							type: "slider",
 							key: "imgBright",
 							label: "Brightness",
+							labelKey: "provider-reolink:schema.s_image.imgBright.label",
 							min: 0,
 							max: 255,
 							step: 1,
@@ -196474,6 +198054,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "slider",
 							key: "imgContrast",
 							label: "Contrast",
+							labelKey: "provider-reolink:schema.s_image.imgContrast.label",
 							min: 0,
 							max: 255,
 							step: 1,
@@ -196485,6 +198066,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "slider",
 							key: "imgSaturation",
 							label: "Saturation",
+							labelKey: "provider-reolink:schema.s_image.imgSaturation.label",
 							min: 0,
 							max: 255,
 							step: 1,
@@ -196496,6 +198078,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "slider",
 							key: "imgHue",
 							label: "Hue",
+							labelKey: "provider-reolink:schema.s_image.imgHue.label",
 							min: 0,
 							max: 255,
 							step: 1,
@@ -196507,6 +198090,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "slider",
 							key: "imgSharpen",
 							label: "Sharpness",
+							labelKey: "provider-reolink:schema.s_image.imgSharpen.label",
 							min: 0,
 							max: 255,
 							step: 1,
@@ -196521,19 +198105,25 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 					id: "isp",
 					tab: "image",
 					title: "Advanced (ISP)",
+					titleKey: "provider-reolink:schema.s_isp.title",
 					description: "Day/Night + exposure + HDR. Pushed via `SetIsp` (cmd_id 25). The day/night threshold uses cmd_id 297 (DayNightThreshold).",
+					descriptionKey: "provider-reolink:schema.s_isp.description",
 					columns: 2,
 					fields: [{
 						type: "text",
 						key: "ispDayNight",
 						label: "Day/Night mode",
+						labelKey: "provider-reolink:schema.s_isp.ispDayNight.label",
 						description: "Camera-specific values — common: `auto`, `color`, `blackAndWhite`. The driver normalizes case before push.",
+						descriptionKey: "provider-reolink:schema.s_isp.ispDayNight.description",
 						default: imgSnap.dayNight ?? "auto"
 					}, {
 						type: "text",
 						key: "ispExposure",
 						label: "Exposure",
+						labelKey: "provider-reolink:schema.s_isp.ispExposure.label",
 						description: "Common values: `auto`, `manual`. Lowercased before push.",
+						descriptionKey: "provider-reolink:schema.s_isp.ispExposure.description",
 						default: "auto"
 					}]
 				}] : [],
@@ -196541,26 +198131,32 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 					id: "ir-lights",
 					tab: "image",
 					title: "IR + status LED",
+					titleKey: "provider-reolink:schema.s_ir-lights.title",
 					description: "IR LED control + per-camera IR brightness. Pushed via `SetIrLights` (cmd_id 209). State `Auto` lets the camera switch IR on automatically at low light; `Off` forces colour-only mode.",
+					descriptionKey: "provider-reolink:schema.s_ir-lights.description",
 					columns: 2,
 					fields: [
 						{
 							type: "select",
 							key: "irLightsState",
 							label: "IR LED",
+							labelKey: "provider-reolink:schema.s_ir-lights.irLightsState.label",
 							default: "Auto",
 							options: [
 								{
 									value: "Auto",
-									label: "Auto (camera decides)"
+									label: "Auto (camera decides)",
+									labelKey: "provider-reolink:schema.s_ir-lights.irLightsState.o_Auto.label"
 								},
 								{
 									value: "On",
-									label: "Always on"
+									label: "Always on",
+									labelKey: "provider-reolink:schema.s_ir-lights.irLightsState.o_On.label"
 								},
 								{
 									value: "Off",
-									label: "Always off"
+									label: "Always off",
+									labelKey: "provider-reolink:schema.s_ir-lights.irLightsState.o_Off.label"
 								}
 							]
 						},
@@ -196568,7 +198164,9 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "slider",
 							key: "irLightsBrightness",
 							label: "IR brightness",
+							labelKey: "provider-reolink:schema.s_ir-lights.irLightsBrightness.label",
 							description: "Only applied when the camera advertises programmable IR brightness. 0..255 raw range; many models clamp to 0..100.",
+							descriptionKey: "provider-reolink:schema.s_ir-lights.irLightsBrightness.description",
 							min: 0,
 							max: 255,
 							step: 5,
@@ -196580,7 +198178,9 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "boolean",
 							key: "statusLedEnabled",
 							label: "Status LED",
+							labelKey: "provider-reolink:schema.s_ir-lights.statusLedEnabled.label",
 							description: "The visible status/power LED on the camera body. Pushed via `SetIrLights` (cmd_id 209) as `lightState`.",
+							descriptionKey: "provider-reolink:schema.s_ir-lights.statusLedEnabled.description",
 							default: cache?.ledSnapshot?.statusEnabled ?? true,
 							style: "switch",
 							span: cache?.ledSnapshot?.doorbellSupported === true ? 1 : 2
@@ -196589,7 +198189,9 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "boolean",
 							key: "doorbellLedEnabled",
 							label: "Doorbell LED",
+							labelKey: "provider-reolink:schema.s_ir-lights.doorbellLedEnabled.label",
 							description: "The doorbell button ring LED. Pushed via `SetIrLights` (cmd_id 209) as `doorbellLightState`.",
+							descriptionKey: "provider-reolink:schema.s_ir-lights.doorbellLedEnabled.description",
 							default: cache?.ledSnapshot?.doorbellEnabled ?? true,
 							style: "switch"
 						}] : []
@@ -196603,12 +198205,15 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 					id: "auto-focus",
 					tab: "image",
 					title: "Auto focus",
+					titleKey: "provider-reolink:schema.s_auto-focus.title",
 					description: "Toggles the lens auto-focus subsystem. Pushed via `SetAutoFocus` (cmd_id 225). Disabling locks the lens at its current focal position — useful for fixed-distance scenes where AF would hunt.",
+					descriptionKey: "provider-reolink:schema.s_auto-focus.description",
 					columns: 1,
 					fields: [{
 						type: "boolean",
 						key: "autoFocusEnabled",
 						label: "Auto focus",
+						labelKey: "provider-reolink:schema.s_auto-focus.autoFocusEnabled.label",
 						default: cache.autoFocusSnapshot?.enabled ?? true,
 						style: "switch"
 					}]
@@ -196617,13 +198222,16 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 					id: "audio",
 					tab: "audio",
 					title: "Audio output",
+					titleKey: "provider-reolink:schema.s_audio.title",
 					description: "Speaker volumes pushed via `SetAudioCfg` (cmd_id 265). All ranges 0..100. Doorbell models expose the visitor / talkAndReply channels — non-doorbell cameras ignore those without erroring.",
+					descriptionKey: "provider-reolink:schema.s_audio.description",
 					columns: 2,
 					fields: [
 						{
 							type: "slider",
 							key: "audioVolume",
 							label: "Speaker volume",
+							labelKey: "provider-reolink:schema.s_audio.audioVolume.label",
 							min: 0,
 							max: 100,
 							step: 5,
@@ -196635,7 +198243,9 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "slider",
 							key: "audioTalkAndReplyVolume",
 							label: "Talk + reply volume",
+							labelKey: "provider-reolink:schema.s_audio.audioTalkAndReplyVolume.label",
 							description: "Two-way audio + canned reply playback. Doorbell-only on most firmwares.",
+							descriptionKey: "provider-reolink:schema.s_audio.audioTalkAndReplyVolume.description",
 							min: 0,
 							max: 100,
 							step: 5,
@@ -196647,7 +198257,9 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "slider",
 							key: "audioVisitorVolume",
 							label: "Visitor volume",
+							labelKey: "provider-reolink:schema.s_audio.audioVisitorVolume.label",
 							description: "Visitor / chime playback channel. Doorbell-only on most firmwares.",
+							descriptionKey: "provider-reolink:schema.s_audio.audioVisitorVolume.description",
 							min: 0,
 							max: 100,
 							step: 5,
@@ -196662,13 +198274,17 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 					id: "audio-noise",
 					tab: "audio",
 					title: "Audio noise reduction",
+					titleKey: "provider-reolink:schema.s_audio-noise.title",
 					description: "On-camera AI denoise applied to the encoded audio track. Pushed via `SetAudioNoise` (cmd_id 440). 0 disables; 1..3 maps to the Reolink mobile app levels (low / mid / high).",
+					descriptionKey: "provider-reolink:schema.s_audio-noise.description",
 					columns: 1,
 					fields: [{
 						type: "slider",
 						key: "audioNoiseLevel",
 						label: "Noise reduction level",
+						labelKey: "provider-reolink:schema.s_audio-noise.audioNoiseLevel.label",
 						description: "0 = off · 1 = low · 2 = medium · 3 = high.",
+						descriptionKey: "provider-reolink:schema.s_audio-noise.audioNoiseLevel.description",
 						min: 0,
 						max: 3,
 						step: 1,
@@ -196681,14 +198297,18 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 					id: "intercom",
 					tab: "audio",
 					title: "Intercom",
+					titleKey: "provider-reolink:schema.s_intercom.title",
 					description: "Push-to-talk pipeline tuning. Settings take effect on the next talk session — restart any active session for changes to apply.",
+					descriptionKey: "provider-reolink:schema.s_intercom.description",
 					columns: 2,
 					fields: [
 						{
 							type: "slider",
 							key: "intercomBlocksPerPayload",
 							label: "Blocks per payload",
+							labelKey: "provider-reolink:schema.s_intercom.intercomBlocksPerPayload.label",
 							description: "Lower = lower latency (more sendAudio calls/sec). Higher = fewer calls, less per-call socket overhead. Range 1..8. Default 1 (lowest latency).",
+							descriptionKey: "provider-reolink:schema.s_intercom.intercomBlocksPerPayload.description",
 							min: 1,
 							max: 8,
 							step: 1,
@@ -196700,7 +198320,9 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "slider",
 							key: "intercomMaxBacklogMs",
 							label: "Max backlog (ms)",
+							labelKey: "provider-reolink:schema.s_intercom.intercomMaxBacklogMs.label",
 							description: "Maximum PCM backlog before dropping oldest samples to cap latency. Higher = more stable on slow systems but more latency. Range 20..5000. Default 120.",
+							descriptionKey: "provider-reolink:schema.s_intercom.intercomMaxBacklogMs.description",
 							min: 20,
 							max: 5e3,
 							step: 20,
@@ -196712,7 +198334,9 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "slider",
 							key: "intercomGain",
 							label: "Output gain",
+							labelKey: "provider-reolink:schema.s_intercom.intercomGain.label",
 							description: "Multiplier applied to PCM samples before IMA-ADPCM encode. 1.0 = neutral, 2.0 ≈ +6dB, 0.5 ≈ -6dB. Hard-clipped at int16 bounds.",
+							descriptionKey: "provider-reolink:schema.s_intercom.intercomGain.description",
 							min: .1,
 							max: 10,
 							step: .1,
@@ -196727,12 +198351,15 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 					id: "keyframe-gop",
 					tab: "advanced",
 					title: "Keyframe interval (GOP)",
+					titleKey: "provider-reolink:schema.s_keyframe-gop.title",
 					description: "Main-stream keyframe interval in seconds. Pushed via `SetEnc` (cmd_id 57) as `<gop><cur>`. Lower = more keyframes (faster seek/recovery, higher bitrate); higher = fewer keyframes (lower bitrate). The camera clamps to its supported range.",
+					descriptionKey: "provider-reolink:schema.s_keyframe-gop.description",
 					columns: 1,
 					fields: [{
 						type: "slider",
 						key: "gop",
 						label: "Keyframe interval (s)",
+						labelKey: "provider-reolink:schema.s_keyframe-gop.gop.label",
 						min: 1,
 						max: 10,
 						step: 1,
@@ -196745,12 +198372,15 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 					id: "pir-reduce-alarm",
 					tab: "advanced",
 					title: "PIR detection",
+					titleKey: "provider-reolink:schema.s_pir-reduce-alarm.title",
 					description: "Passive-infrared false-alarm filter. Pushed via `SetPirInfo` (cmd_id 213) as `reduceAlarm`. Enabling makes the camera require a stronger/longer PIR signal before triggering, cutting false motion alerts from heat/light flicker.",
+					descriptionKey: "provider-reolink:schema.s_pir-reduce-alarm.description",
 					columns: 1,
 					fields: [{
 						type: "boolean",
 						key: "pirReduceFalseAlarm",
 						label: "Reduce false alarms",
+						labelKey: "provider-reolink:schema.s_pir-reduce-alarm.pirReduceFalseAlarm.label",
 						default: cache.pirSnapshot.reduceFalseAlarm ?? false,
 						style: "switch"
 					}]
@@ -196759,13 +198389,16 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 					id: "auto-reboot",
 					tab: "advanced",
 					title: "Auto reboot",
+					titleKey: "provider-reolink:schema.s_auto-reboot.title",
 					description: "Scheduled automatic reboot. Pushed via `SetAutoReboot` (cmd_id 100). Useful for long-uptime stability. Choose a day (or every day) + time; the camera reboots once per matching window.",
+					descriptionKey: "provider-reolink:schema.s_auto-reboot.description",
 					columns: 2,
 					fields: [
 						{
 							type: "boolean",
 							key: "autoRebootEnabled",
 							label: "Auto reboot",
+							labelKey: "provider-reolink:schema.s_auto-reboot.autoRebootEnabled.label",
 							default: cache.autoRebootSnapshot.enabled ?? false,
 							style: "switch",
 							span: 2
@@ -196774,40 +198407,49 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "select",
 							key: "autoRebootWeekDay",
 							label: "Day",
+							labelKey: "provider-reolink:schema.s_auto-reboot.autoRebootWeekDay.label",
 							default: cache.autoRebootSnapshot.weekDay ?? "everyday",
 							span: 2,
 							options: [
 								{
 									value: "everyday",
-									label: "Every day"
+									label: "Every day",
+									labelKey: "provider-reolink:schema.s_auto-reboot.autoRebootWeekDay.o_everyday.label"
 								},
 								{
 									value: "Sunday",
-									label: "Sunday"
+									label: "Sunday",
+									labelKey: "provider-reolink:schema.s_auto-reboot.autoRebootWeekDay.o_Sunday.label"
 								},
 								{
 									value: "Monday",
-									label: "Monday"
+									label: "Monday",
+									labelKey: "provider-reolink:schema.s_auto-reboot.autoRebootWeekDay.o_Monday.label"
 								},
 								{
 									value: "Tuesday",
-									label: "Tuesday"
+									label: "Tuesday",
+									labelKey: "provider-reolink:schema.s_auto-reboot.autoRebootWeekDay.o_Tuesday.label"
 								},
 								{
 									value: "Wednesday",
-									label: "Wednesday"
+									label: "Wednesday",
+									labelKey: "provider-reolink:schema.s_auto-reboot.autoRebootWeekDay.o_Wednesday.label"
 								},
 								{
 									value: "Thursday",
-									label: "Thursday"
+									label: "Thursday",
+									labelKey: "provider-reolink:schema.s_auto-reboot.autoRebootWeekDay.o_Thursday.label"
 								},
 								{
 									value: "Friday",
-									label: "Friday"
+									label: "Friday",
+									labelKey: "provider-reolink:schema.s_auto-reboot.autoRebootWeekDay.o_Friday.label"
 								},
 								{
 									value: "Saturday",
-									label: "Saturday"
+									label: "Saturday",
+									labelKey: "provider-reolink:schema.s_auto-reboot.autoRebootWeekDay.o_Saturday.label"
 								}
 							]
 						},
@@ -196815,6 +198457,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "number",
 							key: "autoRebootHour",
 							label: "Hour (0-23)",
+							labelKey: "provider-reolink:schema.s_auto-reboot.autoRebootHour.label",
 							default: cache.autoRebootSnapshot.hour ?? 3,
 							min: 0,
 							max: 23,
@@ -196824,6 +198467,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 							type: "number",
 							key: "autoRebootMinute",
 							label: "Minute (0-59)",
+							labelKey: "provider-reolink:schema.s_auto-reboot.autoRebootMinute.label",
 							default: cache.autoRebootSnapshot.minute ?? 0,
 							min: 0,
 							max: 59,
@@ -196835,41 +198479,52 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 					id: "debug",
 					tab: "advanced",
 					title: "Debug",
+					titleKey: "provider-reolink:schema.s_debug.title",
 					description: "Lib-side Baichuan tracing. Changing these resets the control-channel client (active streams keep running) so new debug options take effect on the next dial.",
+					descriptionKey: "provider-reolink:schema.s_debug.description",
 					columns: 1,
 					fields: [{
 						type: "boolean",
 						key: "debugGeneral",
 						label: "General debug logs",
+						labelKey: "provider-reolink:schema.s_debug.debugGeneral.label",
 						description: "Forwards `DebugOptions.general=true` — verbose lib protocol logs.",
+						descriptionKey: "provider-reolink:schema.s_debug.debugGeneral.description",
 						default: false,
 						style: "switch"
 					}, {
 						type: "multiselect",
 						key: "debugSocketLogs",
 						label: "Socket trace categories",
+						labelKey: "provider-reolink:schema.s_debug.debugSocketLogs.label",
 						description: "Per-area lib tracing. Pick only what you need; each adds log volume.",
+						descriptionKey: "provider-reolink:schema.s_debug.debugSocketLogs.description",
 						default: [],
 						options: [
 							{
 								value: "debugRtsp",
-								label: "RTSP (proxy/server traffic)"
+								label: "RTSP (proxy/server traffic)",
+								labelKey: "provider-reolink:schema.s_debug.debugSocketLogs.o_debugRtsp.label"
 							},
 							{
 								value: "traceNativeStream",
-								label: "Native stream (cmd 3/4 + H.264/H.265 + param sets)"
+								label: "Native stream (cmd 3/4 + H.264/H.265 + param sets)",
+								labelKey: "provider-reolink:schema.s_debug.debugSocketLogs.o_traceNativeStream.label"
 							},
 							{
 								value: "traceRecordings",
-								label: "Recordings (FileInfoList, findAlarmVideo, download)"
+								label: "Recordings (FileInfoList, findAlarmVideo, download)",
+								labelKey: "provider-reolink:schema.s_debug.debugSocketLogs.o_traceRecordings.label"
 							},
 							{
 								value: "traceTalk",
-								label: "Talkback (cmd 10/11/201/202)"
+								label: "Talkback (cmd 10/11/201/202)",
+								labelKey: "provider-reolink:schema.s_debug.debugSocketLogs.o_traceTalk.label"
 							},
 							{
 								value: "traceEvents",
-								label: "Events (cmd 33 — AlarmEventList push)"
+								label: "Events (cmd 33 — AlarmEventList push)",
+								labelKey: "provider-reolink:schema.s_debug.debugSocketLogs.o_traceEvents.label"
 							}
 						]
 					}]
@@ -198344,13 +199999,16 @@ var ReolinkHub = class ReolinkHub extends BaseDevice {
 					id: "connection",
 					tab: "general",
 					title: "Connection",
+					titleKey: "provider-reolink:hub.s_connection.title",
 					description: "Baichuan protocol connection settings for the hub. The same socket fronts every adopted channel — child cameras inherit these credentials, no per-channel login needed.",
+					descriptionKey: "provider-reolink:hub.s_connection.description",
 					columns: 2,
 					fields: [
 						{
 							type: "text",
 							key: "host",
 							label: "Hub IP",
+							labelKey: "provider-reolink:hub.s_connection.host.label",
 							required: true,
 							placeholder: "192.168.10.100"
 						},
@@ -198358,6 +200016,7 @@ var ReolinkHub = class ReolinkHub extends BaseDevice {
 							type: "number",
 							key: "port",
 							label: "Port",
+							labelKey: "provider-reolink:hub.s_connection.port.label",
 							default: 9e3,
 							min: 1,
 							max: 65535,
@@ -198367,12 +200026,14 @@ var ReolinkHub = class ReolinkHub extends BaseDevice {
 							type: "text",
 							key: "username",
 							label: "Username",
+							labelKey: "provider-reolink:hub.s_connection.username.label",
 							default: "admin"
 						},
 						{
 							type: "password",
 							key: "password",
 							label: "Password",
+							labelKey: "provider-reolink:hub.s_connection.password.label",
 							required: true,
 							showToggle: true
 						}
@@ -198382,18 +200043,22 @@ var ReolinkHub = class ReolinkHub extends BaseDevice {
 					id: "identity",
 					tab: "general",
 					title: "Hub identity",
+					titleKey: "provider-reolink:hub.s_identity.title",
 					description: "Read-only summary from the autodetect probe. Channel count and model are persisted at first contact so the panel renders without re-probing.",
+					descriptionKey: "provider-reolink:hub.s_identity.description",
 					columns: 2,
 					fields: [{
 						type: "text",
 						key: "_model",
 						label: "Model",
+						labelKey: "provider-reolink:hub.s_identity._model.label",
 						default: cache?.model ?? "unknown",
 						disabled: true
 					}, {
 						type: "text",
 						key: "_channelCount",
 						label: "Total channels",
+						labelKey: "provider-reolink:hub.s_identity._channelCount.label",
 						default: String(cache?.channelCount ?? 0),
 						disabled: true
 					}]
@@ -198402,41 +200067,52 @@ var ReolinkHub = class ReolinkHub extends BaseDevice {
 					id: "debug",
 					tab: "advanced",
 					title: "Debug",
+					titleKey: "provider-reolink:hub.s_debug.title",
 					description: "Lib-side Baichuan tracing. Changing these resets the control-channel client (active streams keep running) so new debug options take effect on the next dial.",
+					descriptionKey: "provider-reolink:hub.s_debug.description",
 					columns: 1,
 					fields: [{
 						type: "boolean",
 						key: "debugGeneral",
 						label: "General debug logs",
+						labelKey: "provider-reolink:hub.s_debug.debugGeneral.label",
 						description: "Forwards `DebugOptions.general=true` — verbose lib protocol logs.",
+						descriptionKey: "provider-reolink:hub.s_debug.debugGeneral.description",
 						default: false,
 						style: "switch"
 					}, {
 						type: "multiselect",
 						key: "debugSocketLogs",
 						label: "Socket trace categories",
+						labelKey: "provider-reolink:hub.s_debug.debugSocketLogs.label",
 						description: "Per-area lib tracing. Pick only what you need; each adds log volume.",
+						descriptionKey: "provider-reolink:hub.s_debug.debugSocketLogs.description",
 						default: [],
 						options: [
 							{
 								value: "debugRtsp",
-								label: "RTSP (proxy/server traffic)"
+								label: "RTSP (proxy/server traffic)",
+								labelKey: "provider-reolink:hub.s_debug.debugSocketLogs.o_debugRtsp.label"
 							},
 							{
 								value: "traceNativeStream",
-								label: "Native stream (cmd 3/4 + H.264/H.265 + param sets)"
+								label: "Native stream (cmd 3/4 + H.264/H.265 + param sets)",
+								labelKey: "provider-reolink:hub.s_debug.debugSocketLogs.o_traceNativeStream.label"
 							},
 							{
 								value: "traceRecordings",
-								label: "Recordings (FileInfoList, findAlarmVideo, download)"
+								label: "Recordings (FileInfoList, findAlarmVideo, download)",
+								labelKey: "provider-reolink:hub.s_debug.debugSocketLogs.o_traceRecordings.label"
 							},
 							{
 								value: "traceTalk",
-								label: "Talkback (cmd 10/11/201/202)"
+								label: "Talkback (cmd 10/11/201/202)",
+								labelKey: "provider-reolink:hub.s_debug.debugSocketLogs.o_traceTalk.label"
 							},
 							{
 								value: "traceEvents",
-								label: "Events (cmd 33 — AlarmEventList push)"
+								label: "Events (cmd 33 — AlarmEventList push)",
+								labelKey: "provider-reolink:hub.s_debug.debugSocketLogs.o_traceEvents.label"
 							}
 						]
 					}]
@@ -199018,8 +200694,8 @@ var ReolinkHub = class ReolinkHub extends BaseDevice {
 			this.api = null;
 		}
 		const cfg = this.config.values;
-		if (!cfg.host) throw new Error("Reolink Hub: host not configured");
-		if (!cfg.password) throw new Error("Reolink Hub: password not configured");
+		if (!cfg.host) throw userError("reolink.hub-host-missing", void 0, "Reolink Hub: host not configured");
+		if (!cfg.password) throw userError("reolink.hub-password-missing", void 0, "Reolink Hub: password not configured");
 		const api = new ReolinkBaichuanApi({
 			host: cfg.host,
 			port: cfg.port,
@@ -199171,31 +200847,38 @@ function buildDiscoveryParamsFormSchema() {
 	return { sections: [{
 		id: "credentials",
 		title: "Credentials",
+		titleKey: "provider-reolink:discoveryParams.s_credentials.title",
 		description: "Used to probe the cameras and pre-filled into each result so you can add it in one click. Assumes all cameras share these credentials.",
+		descriptionKey: "provider-reolink:discoveryParams.s_credentials.description",
 		columns: 2,
 		fields: [{
 			type: "text",
 			key: "username",
 			label: "Username",
+			labelKey: "provider-reolink:discoveryParams.s_credentials.username.label",
 			default: "admin",
 			required: true
 		}, {
 			type: "password",
 			key: "password",
 			label: "Password",
+			labelKey: "provider-reolink:discoveryParams.s_credentials.password.label",
 			required: true,
 			showToggle: true
 		}]
 	}, {
 		id: "scan",
 		title: "Scan options",
+		titleKey: "provider-reolink:discoveryParams.s_scan.title",
 		description: "Leave the network blank to scan the local subnet. To find cameras on a different subnet, enter its CIDR (e.g. 192.168.20.0/24).",
+		descriptionKey: "provider-reolink:discoveryParams.s_scan.description",
 		columns: 1,
 		fields: [
 			{
 				type: "text",
 				key: "networkCidr",
 				label: "Network (CIDR)",
+				labelKey: "provider-reolink:discoveryParams.s_scan.networkCidr.label",
 				required: false,
 				placeholder: "192.168.20.0/24"
 			},
@@ -199203,12 +200886,14 @@ function buildDiscoveryParamsFormSchema() {
 				type: "boolean",
 				key: "enableOnvif",
 				label: "Include ONVIF discovery",
+				labelKey: "provider-reolink:discoveryParams.s_scan.enableOnvif.label",
 				default: true
 			},
 			{
 				type: "number",
 				key: "timeoutMs",
 				label: "Scan timeout (ms)",
+				labelKey: "provider-reolink:discoveryParams.s_scan.timeoutMs.label",
 				min: 1e3,
 				max: 3e4,
 				default: 5e3
@@ -199221,11 +200906,13 @@ function buildCreationFormSchema() {
 		{
 			id: "identity",
 			title: "Camera",
+			titleKey: "provider-reolink:creation.s_identity.title",
 			columns: 1,
 			fields: [{
 				type: "text",
 				key: "name",
 				label: "Name",
+				labelKey: "provider-reolink:creation.s_identity.name.label",
 				required: true,
 				placeholder: "Front Door"
 			}]
@@ -199233,18 +200920,22 @@ function buildCreationFormSchema() {
 		{
 			id: "credentials",
 			title: "Credentials",
+			titleKey: "provider-reolink:creation.s_credentials.title",
 			description: "Required for the autodetect probe — entered before the host so Test can run immediately.",
+			descriptionKey: "provider-reolink:creation.s_credentials.description",
 			columns: 2,
 			fields: [{
 				type: "text",
 				key: "username",
 				label: "Username",
+				labelKey: "provider-reolink:creation.s_credentials.username.label",
 				default: "admin",
 				required: true
 			}, {
 				type: "password",
 				key: "password",
 				label: "Password",
+				labelKey: "provider-reolink:creation.s_credentials.password.label",
 				required: true,
 				showToggle: true
 			}]
@@ -199252,27 +200943,34 @@ function buildCreationFormSchema() {
 		{
 			id: "connection",
 			title: "Connection",
+			titleKey: "provider-reolink:creation.s_connection.title",
 			description: "Click Test to auto-detect the device type (regular camera / NVR / battery / UDP-only). The detected type is then used at save time.",
+			descriptionKey: "provider-reolink:creation.s_connection.description",
 			columns: 2,
 			fields: [
 				{
 					type: "select",
 					key: "transport",
 					label: "Connection mode",
+					labelKey: "provider-reolink:creation.s_connection.transport.label",
 					default: "auto",
 					description: "Auto: try TCP first, fall back to UDP — best for unknown devices. UDP is required for battery cameras behind NAT.",
+					descriptionKey: "provider-reolink:creation.s_connection.transport.description",
 					options: [
 						{
 							value: "auto",
-							label: "Auto (recommended)"
+							label: "Auto (recommended)",
+							labelKey: "provider-reolink:creation.s_connection.transport.o_auto.label"
 						},
 						{
 							value: "tcp",
-							label: "TCP only"
+							label: "TCP only",
+							labelKey: "provider-reolink:creation.s_connection.transport.o_tcp.label"
 						},
 						{
 							value: "udp",
-							label: "UDP only (battery / cloud)"
+							label: "UDP only (battery / cloud)",
+							labelKey: "provider-reolink:creation.s_connection.transport.o_udp.label"
 						}
 					]
 				},
@@ -199280,20 +200978,24 @@ function buildCreationFormSchema() {
 					type: "probe",
 					key: "host",
 					label: "Host (IP / hostname / UID)",
+					labelKey: "provider-reolink:creation.s_connection.host.label",
 					required: true,
 					placeholder: "192.168.10.100",
 					description: "For UDP-only mode you can leave the host blank and supply the camera UID below — the library will discover it on the network.",
+					descriptionKey: "provider-reolink:creation.s_connection.host.description",
 					inputType: "text"
 				},
 				{
 					type: "number",
 					key: "port",
 					label: "Port",
+					labelKey: "provider-reolink:creation.s_connection.port.label",
 					default: 9e3,
 					min: 1,
 					max: 65535,
 					step: 1,
 					description: "Baichuan port. Default 9000 — applies to TCP. Ignored for UDP transport.",
+					descriptionKey: "provider-reolink:creation.s_connection.port.description",
 					showWhen: {
 						field: "transport",
 						notEquals: "udp"
@@ -199303,8 +201005,10 @@ function buildCreationFormSchema() {
 					type: "text",
 					key: "uid",
 					label: "Device UID",
+					labelKey: "provider-reolink:creation.s_connection.uid.label",
 					placeholder: "9527000XXXXXXXX",
 					description: "Required for battery / UDP cameras when not on the same LAN. Optional for local-direct UDP discovery and ignored for pure TCP.",
+					descriptionKey: "provider-reolink:creation.s_connection.uid.description",
 					showWhen: {
 						field: "transport",
 						notEquals: "tcp"
@@ -199843,25 +201547,30 @@ function buildEmailPushSettingsSchema(recommendedHost) {
 	return { sections: [{
 		id: "email-push",
 		title: "Battery-cam Motion (Email/SMTP Push)",
+		titleKey: "provider-reolink:emailPushSettings.s_email-push.title",
 		description: "Emulate an SMTP server that battery Reolink cameras push to on motion. Lets you capture motion from sleeping battery cams without polling them awake. Enable, then use \"Auto-configure email push\" on each battery camera.",
+		descriptionKey: "provider-reolink:emailPushSettings.s_email-push.description",
 		columns: 2,
 		fields: [
 			{
 				type: "boolean",
 				key: "emailPushEnabled",
 				label: "Enable Email Push Server",
+				labelKey: "provider-reolink:emailPushSettings.s_email-push.emailPushEnabled.label",
 				default: true
 			},
 			{
 				type: "info",
 				key: "emailPushRecommendedHost",
 				label: "Camera-facing host",
+				labelKey: "provider-reolink:emailPushSettings.s_email-push.emailPushRecommendedHost.label",
 				content: `Point cameras at this host: ${recommendedHost}`
 			},
 			{
 				type: "number",
 				key: "emailPushPort",
 				label: "SMTP Port",
+				labelKey: "provider-reolink:emailPushSettings.s_email-push.emailPushPort.label",
 				default: DEFAULT_EMAIL_PUSH_PORT,
 				min: 1,
 				max: 65535
@@ -199870,6 +201579,7 @@ function buildEmailPushSettingsSchema(recommendedHost) {
 				type: "text",
 				key: "emailPushDomain",
 				label: "Virtual Domain",
+				labelKey: "provider-reolink:emailPushSettings.s_email-push.emailPushDomain.label",
 				default: DEFAULT_EMAIL_PUSH_DOMAIN,
 				placeholder: DEFAULT_EMAIL_PUSH_DOMAIN
 			}
@@ -199877,24 +201587,29 @@ function buildEmailPushSettingsSchema(recommendedHost) {
 	}, {
 		id: "email-push-auth",
 		title: "Email Push Authentication",
+		titleKey: "provider-reolink:emailPushSettings.s_email-push-auth.title",
 		description: "AUTH credentials the camera must present. Reolink firmwares are more reliable with AUTH on. Random values are generated on first boot — re-run Auto-configure on cameras after changing them.",
+		descriptionKey: "provider-reolink:emailPushSettings.s_email-push-auth.description",
 		columns: 2,
 		fields: [
 			{
 				type: "boolean",
 				key: "emailPushRequireAuth",
 				label: "Require AUTH",
+				labelKey: "provider-reolink:emailPushSettings.s_email-push-auth.emailPushRequireAuth.label",
 				default: true
 			},
 			{
 				type: "text",
 				key: "emailPushAuthUsername",
-				label: "Auth Username"
+				label: "Auth Username",
+				labelKey: "provider-reolink:emailPushSettings.s_email-push-auth.emailPushAuthUsername.label"
 			},
 			{
 				type: "password",
 				key: "emailPushAuthPassword",
 				label: "Auth Password",
+				labelKey: "provider-reolink:emailPushSettings.s_email-push-auth.emailPushAuthPassword.label",
 				showToggle: true
 			}
 		]
@@ -200081,25 +201796,30 @@ function buildBaichuanWebhookSettingsSchema(recommendedHost) {
 	return { sections: [{
 		id: "baichuan-webhook",
 		title: "Battery-cam Motion (HaCfg Webhook)",
+		titleKey: "provider-reolink:baichuanWebhookSettings.s_baichuan-webhook.title",
 		description: "HTTP intake for Baichuan HaCfg wake/sleep push (cmd 806/807). Prefer this over SMTP when the camera firmware supports it — lower latency, no AUTH dance. Enable, then use \"Auto-configure HaCfg webhook\" on each battery camera (or set preference to Auto).",
+		descriptionKey: "provider-reolink:baichuanWebhookSettings.s_baichuan-webhook.description",
 		columns: 2,
 		fields: [
 			{
 				type: "boolean",
 				key: "baichuanWebhookEnabled",
 				label: "Enable HaCfg Webhook Server",
+				labelKey: "provider-reolink:baichuanWebhookSettings.s_baichuan-webhook.baichuanWebhookEnabled.label",
 				default: true
 			},
 			{
 				type: "info",
 				key: "baichuanWebhookRecommendedHost",
 				label: "Camera-facing host",
+				labelKey: "provider-reolink:baichuanWebhookSettings.s_baichuan-webhook.baichuanWebhookRecommendedHost.label",
 				content: `Point cameras at this host: ${recommendedHost}`
 			},
 			{
 				type: "number",
 				key: "baichuanWebhookPort",
 				label: "HTTP Port",
+				labelKey: "provider-reolink:baichuanWebhookSettings.s_baichuan-webhook.baichuanWebhookPort.label",
 				default: DEFAULT_BAICHUAN_WEBHOOK_PORT,
 				min: 1,
 				max: 65535
@@ -200108,8 +201828,10 @@ function buildBaichuanWebhookSettingsSchema(recommendedHost) {
 				type: "text",
 				key: "baichuanWebhookBindHost",
 				label: "Bind host",
+				labelKey: "provider-reolink:baichuanWebhookSettings.s_baichuan-webhook.baichuanWebhookBindHost.label",
 				default: "0.0.0.0",
-				description: "0.0.0.0 accepts on every interface (cameras on LAN)."
+				description: "0.0.0.0 accepts on every interface (cameras on LAN).",
+				descriptionKey: "provider-reolink:baichuanWebhookSettings.s_baichuan-webhook.baichuanWebhookBindHost.description"
 			}
 		]
 	}] };
@@ -200665,7 +202387,7 @@ var ReolinkProviderAddon = class extends BaseDeviceProvider {
 			},
 			wake: async (deviceId) => {
 				const device = this.ctx.kernel.deviceRegistry?.getById(deviceId);
-				if (!(device instanceof ReolinkCamera)) throw new Error(`clip refresh: device ${String(deviceId)} is not a Reolink camera here`);
+				if (!(device instanceof ReolinkCamera)) throw userError("reolink.clip-device-not-reolink", { deviceId: String(deviceId) }, `clip refresh: device ${String(deviceId)} is not a Reolink camera here`);
 				await device.wakeForClipCatalogRefresh();
 			},
 			prefetchStills: async (deviceId) => service.prefetchThumbnails(deviceId),