@camstack/addon-provider-homematic 1.2.117 → 1.2.118

package/dist/addon.js

@@ -5369,7 +5369,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-i3eUVc-d.mjs
+//#region ../types/dist/sleep-pM_J7YnY.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -6505,6 +6505,24 @@ function normalizeAddonInitResult(result) {
 	if (Array.isArray(result)) return { providers: result };
 	return result;
 }
+/** The wire shape of {@link PeerBytesTicket} — see the type for what it is. */
+var PeerBytesTicketSchema = object({
+	/** `http://127.0.0.1:<port>/<token>`. One `GET` takes it. */
+	url: string().min(1),
+	/**
+	* The HOST node this URL means something on — the hub or a named agent,
+	* never a runner. {@link AddonPeerBytes.open} compares it to its own and
+	* refuses `cross-node` by name when they differ, without dialling.
+	*/
+	hostNodeId: string().min(1),
+	expiresAtMs: number().int().nonnegative(),
+	/**
+	* What the producer DECLARED the body to be, when it knows — `null` when it
+	* does not. Never `0` for unknown (D393): a consumer sizing a bound off this
+	* must be able to tell "the producer did not say" from "the body is empty".
+	*/
+	declaredBytes: number().int().nonnegative().nullable()
+});
 /** Shared Zod schemas used across streaming capabilities. */
 var CamProfileSchema = _enum([
 	"high",
@@ -7650,7 +7668,7 @@ var AdoptionJobSchema = object({
 * component's original options — detection to the detection-pipeline wrapper
 * binding, audio analysis to its own, recording to `RecordingConfig.enabled`
 * (which was always first-class; the switch was a veneer over
-* `recording.setDeviceConfig`), notifications to a notification-center
+* `recordingArchive.setDeviceConfig`), notifications to a notification-center
 * per-device setting, the two camera planes to their own components.
 *
 * What survives is {@link composeSwitchedOff}: `CameraStatus.switchedOff`, the
@@ -7676,7 +7694,7 @@ var AdoptionJobSchema = object({
 * | `stream-broker` | `deviceManager.setDisabled` | `StreamBrokerManager.reconcileAllCatalogs` releases the brokers; `ensureBroker` refuses re-creation |
 * | `object-detection` | `deviceManager.setWrapperActive('detection-pipeline')` | `PipelineSettingsStore.resolvePipelineForDevice` returns `{ steps: [], audio: null }` |
 * | `audio-analysis` | `deviceManager.setWrapperActive('audio-analysis')` | `AudioSubscriptionController.subscribeAudioStream` returns `null` before opening the stream |
-* | `recording` | `recording.setDeviceConfig` → `RecordingConfig.enabled` | `band-decision.shouldRecord` returns false; the controller detaches the device |
+* | `recording` | `recordingArchive.setDeviceConfig` → `RecordingConfig.enabled` | `band-decision.shouldRecord` returns false; the controller detaches the device |
 * | `notifications` | `notificationRules.setDeviceMuted` | `NotificationCenter.evaluateAndEnqueue` returns before any rule is evaluated |
 * | `privacy-mask` | `privacyMask.setMask({ enabled })` → the CAMERA | the camera blanks the masked regions itself; every stream and recording carries the black boxes |
 * | `device-audio` | `privacyMask.setAudioEnabled` → the CAMERA | the camera stops encoding an audio track at all; every consumer sees silent video |
@@ -11623,87 +11641,6 @@ var brokerCapability = {
 	}
 };
 DeviceType.Camera;
-/**
-* The signals a device can emit to WAKE its own stream.
-*
-* A camera whose stream is built on demand sleeps until something asks for it,
-* and "something" cannot be a consumer that is merely attached — a Frigate-style
-* puller holds a session open for ever, and treating that as demand would keep
-* a battery camera awake for ever, which is the whole thing the battery is for
-* (D173). So the wake has to come from the CAMERA: an event it noticed by
-* itself, with no stream running.
-*
-* ## The vocabulary is the PROVIDER'S, not ours
-*
-* Like `consumables`, this cap declares no vocabulary of its own. A provider
-* names each signal with a `code` it chooses and a `label` an operator reads.
-* Reolink offers motion and camera-native detection; another provider may offer
-* a tamper, a doorbell press, a PIR, or something no camera in this fleet has
-* yet. A fixed enum here would mean every new signal is a framework release.
-*
-* It is deliberately NOT derived from the caps a device already binds. Whether
-* a camera CAN push firmware motion is expressed by `motionSources` containing
-* `'onboard'`, and whether it does AI on-camera by the `native-object-detection`
-* binding — but both answer "what drives the detection pipeline", which is a
-* different question from "what may wake a sleeping stream". A camera can do
-* the first and not be trusted with the second, and the operator picks per
-* camera. Two questions, two authorities.
-*
-* ## Availability is not permission
-*
-* `listSignals` says what the device CAN emit. Whether a given signal actually
-* wakes the stream is the operator's per-camera choice, held by the broker
-* alongside the cooldown — see the stream-broker cap's wake settings. A
-* provider declaring a signal is not a provider enabling it.
-*/
-/** One signal a device can emit. */
-var StreamSignalSchema = object({
-	/** Stable id chosen by the provider, e.g. `'motion'`, `'person'`, `'tamper'`. */
-	code: string().min(1),
-	/** What an operator reads in the picker. The provider's own wording. */
-	label: string().min(1),
-	/**
-	* Whether the provider recommends this signal ON when a camera is first set
-	* up. A provider knows which of its signals are cheap and reliable; an
-	* operator should not have to discover that by trial. Reolink recommends
-	* both of its own.
-	*/
-	recommended: boolean()
-});
-var StreamSignalsStatusSchema = object({
-	signals: array(StreamSignalSchema),
-	lastFetchedAt: number()
-});
-var streamSignalsCapability = {
-	name: "stream-signals",
-	scope: "device",
-	deviceNative: true,
-	mode: "singleton",
-	deviceTypes: Object.values(DeviceType),
-	runtimeState: StreamSignalsStatusSchema,
-	/**
-	* Runtime-state durability: **session** — mirrored in RAM, never written.
-	*
-	* The slice holds what the DEVICE says it can emit. That is a probed fact,
-	* not an operator choice: the provider re-declares it on every registration,
-	* so losing it loses nothing and persisting it would freeze an answer the
-	* camera is entitled to change. Measured the same day on the sibling case —
-	* `native-object-detection.supportedClasses` was persisted, and a firmware
-	* class the camera really detected stayed missing for the life of the row
-	* because the fix could not reach it.
-	*
-	* See `RuntimeStateDurability`. Enforced by
-	* `scripts/check-runtime-state-durability.ts`.
-	*/
-	durability: "session",
-	methods: { 
-	/**
-	* What this device can emit. Empty is a valid and common answer — most
-	* cameras have nothing to offer here, and an empty list is what makes the
-	* broker's picker show nothing rather than a false choice.
-	*/
-listSignals: method(_void(), array(StreamSignalSchema).readonly()) }
-};
 /** Stream delivery format. (Relocated from the retired `streaming-engine` cap.) */
 var StreamFormatSchema = _enum([
 	"webrtc",
@@ -13169,6 +13106,210 @@ method(object({ codec: string() }), boolean()), method(_void(), object({
 });
 DeviceType.Camera;
 /**
+* device-admin-link — "this device has a management page of its own, and here
+* is its address".
+*
+* ## Why this is not a `deviceConfig` cap
+*
+* There is nothing to edit. A `deviceConfig` cap (D14) exists so the framework
+* can DERIVE a settings form from `getOptions` + `getStatus` and route a flat
+* patch back through a setter; it costs a `builderId` reducer in
+* `device-config-contribution.ts` and a `*-config-schema.ts` beside it, and it
+* renders a form section. This cap answers ONE question with ONE read and
+* renders a button. Nothing about it is a form, so it carries no `deviceConfig`
+* block, no `settings`, no `runtimeState` and no reducer — exactly like
+* `reboot`, the other pure-RPC device-native cap.
+*
+* ## Absent, and the difference between "no page" and "we cannot say"
+*
+* The two are answered at DIFFERENT layers, on purpose:
+*
+*  - **"We cannot say"** → the provider never registers the cap for that
+*    device. A VeSync humidifier, a Petkit feeder, a Dreame vacuum and a Dreo
+*    fan are reached only through a vendor cloud; there is no address to hand
+*    out and no page to open. A Tuya plug, a Wyze camera and a Gree air
+*    conditioner DO have a LAN IP, and still have no HTTP management page
+*    behind it. None of them register, so `deviceManager.getBindings` never
+*    lists the cap and no surface asks.
+*  - **"This device has no page, and I know that"** → the provider registers
+*    and `getAdminLink` returns `null`. This is the answer for a device whose
+*    sibling DOES have a page: a Reolink battery camera reached over UDP by
+*    `uid` with a blank `host`, an Ecowitt gateway configured in `listener`
+*    transport, a Home Assistant broker authenticated by supervisor token
+*    (which carries no `baseUrl` at all).
+*
+* Both draw NOTHING. A button that opens a browser error is worse than no
+* button, and D62 is the same rule from the other side: an off switch is
+* reported off, never made to look broken. There is no third state where the
+* UI renders a disabled button "because the device might have a page".
+*
+* ## The URL never carries credentials
+*
+* Not in userinfo, not in a query string. Every provider builds through
+* `buildDeviceAdminUrl` (`device-admin-link-url.ts`), which takes host, port,
+* scheme and path as separate arguments — there is no parameter a secret could
+* arrive in — and re-checks its own output for the `scheme://user:pass@` shape
+* that `scripts/check-no-credential-urls-in-fixtures.ts` bans from recorded
+* output. `scripts/check-admin-link-builder-is-the-only-url-source.ts` is what
+* keeps providers from hand-rolling one anyway.
+*
+* This matters here more than anywhere else in the repo, because every provider
+* that knows a device's host knows its PASSWORD too: `{ host, port, username,
+* password }` sit in one object on Hikvision, Amcrest, Reolink and ONVIF alike,
+* and `http://admin:hunter2@192.168.50.139/` is a URL a browser accepts. The
+* camera's own page will ask for its own login. That is correct, and pre-
+* filling it is the operator's business, not ours.
+*
+* ## It is a LAN fact
+*
+* The URL addresses the device where the NODE can see it. It is not proxied,
+* not made reachable from outside, and not sent anywhere. A surface renders it
+* as a link the operator's own browser follows, on the operator's own network,
+* or renders nothing.
+*/
+/**
+* Whose page is it. The distinction is for the OPERATOR, who needs to know
+* before clicking whether he is about to land on a camera's own web server or
+* inside Home Assistant.
+*/
+var AdminLinkTargetEnum = _enum(["device", "integration"]);
+var DeviceAdminLinkSchema = object({
+	/**
+	* Absolute `http(s)://` URL. Built by `buildDeviceAdminUrl` and therefore
+	* free of userinfo and of any credential-shaped query key.
+	*/
+	url: string(),
+	/**
+	* What the surface calls it — "Web UI", "Home Assistant", "UniFi controller".
+	* The PROVIDER names it, because only the provider knows what the page is;
+	* a UI that invented the label from the addon id would call the Home
+	* Assistant device page "Provider Homeassistant".
+	*/
+	label: string(),
+	target: AdminLinkTargetEnum,
+	/**
+	* Host the URL points at, without scheme, port or path — for the tooltip, so
+	* an operator can see WHERE the button goes before he follows it. Redundant
+	* with `url` by construction; carried separately so no surface has to parse
+	* a URL to show it.
+	*/
+	host: string()
+});
+var deviceAdminLinkCapability = {
+	name: "device-admin-link",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	methods: { 
+	/**
+	* The device's management page, or `null` when this device has none.
+	*
+	* `auth: 'admin'` deliberately. This is administration, not actuation —
+	* the same bucket as `reboot` and `camera-credentials`, and explicitly NOT
+	* the actuation set `scripts/check-actuation-not-admin.ts` protects (D403).
+	* The URL is also a statement about the LAN, which a household member with
+	* a `view` grant on a light has no reason to be handed.
+	*
+	* The surfaces gate on the QUERY, never on a role they guessed: a caller
+	* without the right loses the query and draws nothing, which is the same
+	* thing a device with no page draws. There is no path on which a button
+	* appears and then fails — the D403 failure mode, from the other end.
+	*/
+getAdminLink: method(object({ deviceId: number().int().nonnegative() }), DeviceAdminLinkSchema.nullable(), { auth: "admin" }) }
+};
+/**
+* Query keys that may never appear on an admin link. A credential smuggled as
+* `?password=` is the same leak as userinfo, in a form the userinfo check
+* cannot see: it survives copy-paste, referrer headers and proxy logs
+* identically.
+*/
+var CREDENTIAL_QUERY_KEYS = [
+	"password",
+	"passwd",
+	"pwd",
+	"pass",
+	"user",
+	"username",
+	"usr",
+	"login",
+	"token",
+	"access_token",
+	"auth",
+	"authorization",
+	"apikey",
+	"api_key",
+	"secret",
+	"credential",
+	"credentials",
+	"session",
+	"sessionid",
+	"key"
+];
+/**
+* The same userinfo shape `scripts/check-no-credential-urls-in-fixtures.ts`
+* scans recorded fixtures for, applied to what we are about to EMIT. Kept
+* structurally identical on purpose: a URL this function returns is a URL that
+* guard would pass.
+*/
+var CREDENTIAL_URL = /[a-z][a-z0-9+.-]*:\/\/[^/\s:@'"]+:[^/\s:@'"]+@/i;
+/** A host that is safe to place in an authority component verbatim. */
+var PLAIN_HOST = /^[a-zA-Z0-9._-]+$/;
+/** A bracketed IPv6 literal, the only other authority form we emit. */
+var IPV6_HOST = /^\[[0-9a-fA-F:.]+\]$/;
+function defaultPortFor(scheme) {
+	return scheme === "https" ? 443 : 80;
+}
+/**
+* Build the admin-page URL, or refuse by name.
+*
+* The refusal is never thrown: a provider answering "no page for this device"
+* is an ordinary answer (`getAdminLink` → `null`), and a throw here would turn
+* a missing host on one device into a failed query for the whole surface.
+*/
+function buildDeviceAdminUrl(parts) {
+	const host = parts.host.trim();
+	if (host.length === 0) return {
+		ok: false,
+		reason: "empty-host"
+	};
+	if (host.includes("@")) return {
+		ok: false,
+		reason: "host-carries-userinfo"
+	};
+	if (!PLAIN_HOST.test(host) && !IPV6_HOST.test(host)) return {
+		ok: false,
+		reason: "host-not-plain"
+	};
+	if (parts.port !== null) {
+		if (!Number.isInteger(parts.port) || parts.port < 1 || parts.port > 65535) return {
+			ok: false,
+			reason: "port-out-of-range"
+		};
+	}
+	if (!parts.path.startsWith("/")) return {
+		ok: false,
+		reason: "path-not-absolute"
+	};
+	const query = parts.query ?? {};
+	for (const key of Object.keys(query)) if (CREDENTIAL_QUERY_KEYS.includes(key.toLowerCase())) return {
+		ok: false,
+		reason: "credential-query-key"
+	};
+	const authority = parts.port === null || parts.port === defaultPortFor(parts.scheme) ? host : `${host}:${String(parts.port)}`;
+	const search = new URLSearchParams();
+	for (const [key, value] of Object.entries(query)) search.append(key, value);
+	const suffix = search.size > 0 ? `?${search.toString()}` : "";
+	const url = `${parts.scheme}://${authority}${parts.path}${suffix}`;
+	if (CREDENTIAL_URL.test(url)) return {
+		ok: false,
+		reason: "userinfo-in-result"
+	};
+	return {
+		ok: true,
+		url
+	};
+}
+/**
 * Identity envelope for a device's upstream-system metadata.
 *
 * Two jobs:
@@ -13620,210 +13761,6 @@ var deviceAdoptionCapability = {
 	}
 };
 /**
-* device-admin-link — "this device has a management page of its own, and here
-* is its address".
-*
-* ## Why this is not a `deviceConfig` cap
-*
-* There is nothing to edit. A `deviceConfig` cap (D14) exists so the framework
-* can DERIVE a settings form from `getOptions` + `getStatus` and route a flat
-* patch back through a setter; it costs a `builderId` reducer in
-* `device-config-contribution.ts` and a `*-config-schema.ts` beside it, and it
-* renders a form section. This cap answers ONE question with ONE read and
-* renders a button. Nothing about it is a form, so it carries no `deviceConfig`
-* block, no `settings`, no `runtimeState` and no reducer — exactly like
-* `reboot`, the other pure-RPC device-native cap.
-*
-* ## Absent, and the difference between "no page" and "we cannot say"
-*
-* The two are answered at DIFFERENT layers, on purpose:
-*
-*  - **"We cannot say"** → the provider never registers the cap for that
-*    device. A VeSync humidifier, a Petkit feeder, a Dreame vacuum and a Dreo
-*    fan are reached only through a vendor cloud; there is no address to hand
-*    out and no page to open. A Tuya plug, a Wyze camera and a Gree air
-*    conditioner DO have a LAN IP, and still have no HTTP management page
-*    behind it. None of them register, so `deviceManager.getBindings` never
-*    lists the cap and no surface asks.
-*  - **"This device has no page, and I know that"** → the provider registers
-*    and `getAdminLink` returns `null`. This is the answer for a device whose
-*    sibling DOES have a page: a Reolink battery camera reached over UDP by
-*    `uid` with a blank `host`, an Ecowitt gateway configured in `listener`
-*    transport, a Home Assistant broker authenticated by supervisor token
-*    (which carries no `baseUrl` at all).
-*
-* Both draw NOTHING. A button that opens a browser error is worse than no
-* button, and D62 is the same rule from the other side: an off switch is
-* reported off, never made to look broken. There is no third state where the
-* UI renders a disabled button "because the device might have a page".
-*
-* ## The URL never carries credentials
-*
-* Not in userinfo, not in a query string. Every provider builds through
-* `buildDeviceAdminUrl` (`device-admin-link-url.ts`), which takes host, port,
-* scheme and path as separate arguments — there is no parameter a secret could
-* arrive in — and re-checks its own output for the `scheme://user:pass@` shape
-* that `scripts/check-no-credential-urls-in-fixtures.ts` bans from recorded
-* output. `scripts/check-admin-link-builder-is-the-only-url-source.ts` is what
-* keeps providers from hand-rolling one anyway.
-*
-* This matters here more than anywhere else in the repo, because every provider
-* that knows a device's host knows its PASSWORD too: `{ host, port, username,
-* password }` sit in one object on Hikvision, Amcrest, Reolink and ONVIF alike,
-* and `http://admin:hunter2@192.168.50.139/` is a URL a browser accepts. The
-* camera's own page will ask for its own login. That is correct, and pre-
-* filling it is the operator's business, not ours.
-*
-* ## It is a LAN fact
-*
-* The URL addresses the device where the NODE can see it. It is not proxied,
-* not made reachable from outside, and not sent anywhere. A surface renders it
-* as a link the operator's own browser follows, on the operator's own network,
-* or renders nothing.
-*/
-/**
-* Whose page is it. The distinction is for the OPERATOR, who needs to know
-* before clicking whether he is about to land on a camera's own web server or
-* inside Home Assistant.
-*/
-var AdminLinkTargetEnum = _enum(["device", "integration"]);
-var DeviceAdminLinkSchema = object({
-	/**
-	* Absolute `http(s)://` URL. Built by `buildDeviceAdminUrl` and therefore
-	* free of userinfo and of any credential-shaped query key.
-	*/
-	url: string(),
-	/**
-	* What the surface calls it — "Web UI", "Home Assistant", "UniFi controller".
-	* The PROVIDER names it, because only the provider knows what the page is;
-	* a UI that invented the label from the addon id would call the Home
-	* Assistant device page "Provider Homeassistant".
-	*/
-	label: string(),
-	target: AdminLinkTargetEnum,
-	/**
-	* Host the URL points at, without scheme, port or path — for the tooltip, so
-	* an operator can see WHERE the button goes before he follows it. Redundant
-	* with `url` by construction; carried separately so no surface has to parse
-	* a URL to show it.
-	*/
-	host: string()
-});
-var deviceAdminLinkCapability = {
-	name: "device-admin-link",
-	scope: "device",
-	deviceNative: true,
-	mode: "singleton",
-	methods: { 
-	/**
-	* The device's management page, or `null` when this device has none.
-	*
-	* `auth: 'admin'` deliberately. This is administration, not actuation —
-	* the same bucket as `reboot` and `camera-credentials`, and explicitly NOT
-	* the actuation set `scripts/check-actuation-not-admin.ts` protects (D403).
-	* The URL is also a statement about the LAN, which a household member with
-	* a `view` grant on a light has no reason to be handed.
-	*
-	* The surfaces gate on the QUERY, never on a role they guessed: a caller
-	* without the right loses the query and draws nothing, which is the same
-	* thing a device with no page draws. There is no path on which a button
-	* appears and then fails — the D403 failure mode, from the other end.
-	*/
-getAdminLink: method(object({ deviceId: number().int().nonnegative() }), DeviceAdminLinkSchema.nullable(), { auth: "admin" }) }
-};
-/**
-* Query keys that may never appear on an admin link. A credential smuggled as
-* `?password=` is the same leak as userinfo, in a form the userinfo check
-* cannot see: it survives copy-paste, referrer headers and proxy logs
-* identically.
-*/
-var CREDENTIAL_QUERY_KEYS = [
-	"password",
-	"passwd",
-	"pwd",
-	"pass",
-	"user",
-	"username",
-	"usr",
-	"login",
-	"token",
-	"access_token",
-	"auth",
-	"authorization",
-	"apikey",
-	"api_key",
-	"secret",
-	"credential",
-	"credentials",
-	"session",
-	"sessionid",
-	"key"
-];
-/**
-* The same userinfo shape `scripts/check-no-credential-urls-in-fixtures.ts`
-* scans recorded fixtures for, applied to what we are about to EMIT. Kept
-* structurally identical on purpose: a URL this function returns is a URL that
-* guard would pass.
-*/
-var CREDENTIAL_URL = /[a-z][a-z0-9+.-]*:\/\/[^/\s:@'"]+:[^/\s:@'"]+@/i;
-/** A host that is safe to place in an authority component verbatim. */
-var PLAIN_HOST = /^[a-zA-Z0-9._-]+$/;
-/** A bracketed IPv6 literal, the only other authority form we emit. */
-var IPV6_HOST = /^\[[0-9a-fA-F:.]+\]$/;
-function defaultPortFor(scheme) {
-	return scheme === "https" ? 443 : 80;
-}
-/**
-* Build the admin-page URL, or refuse by name.
-*
-* The refusal is never thrown: a provider answering "no page for this device"
-* is an ordinary answer (`getAdminLink` → `null`), and a throw here would turn
-* a missing host on one device into a failed query for the whole surface.
-*/
-function buildDeviceAdminUrl(parts) {
-	const host = parts.host.trim();
-	if (host.length === 0) return {
-		ok: false,
-		reason: "empty-host"
-	};
-	if (host.includes("@")) return {
-		ok: false,
-		reason: "host-carries-userinfo"
-	};
-	if (!PLAIN_HOST.test(host) && !IPV6_HOST.test(host)) return {
-		ok: false,
-		reason: "host-not-plain"
-	};
-	if (parts.port !== null) {
-		if (!Number.isInteger(parts.port) || parts.port < 1 || parts.port > 65535) return {
-			ok: false,
-			reason: "port-out-of-range"
-		};
-	}
-	if (!parts.path.startsWith("/")) return {
-		ok: false,
-		reason: "path-not-absolute"
-	};
-	const query = parts.query ?? {};
-	for (const key of Object.keys(query)) if (CREDENTIAL_QUERY_KEYS.includes(key.toLowerCase())) return {
-		ok: false,
-		reason: "credential-query-key"
-	};
-	const authority = parts.port === null || parts.port === defaultPortFor(parts.scheme) ? host : `${host}:${String(parts.port)}`;
-	const search = new URLSearchParams();
-	for (const [key, value] of Object.entries(query)) search.append(key, value);
-	const suffix = search.size > 0 ? `?${search.toString()}` : "";
-	const url = `${parts.scheme}://${authority}${parts.path}${suffix}`;
-	if (CREDENTIAL_URL.test(url)) return {
-		ok: false,
-		reason: "userinfo-in-result"
-	};
-	return {
-		ok: true,
-		url
-	};
-}
-/**
 * `device-export` — collection cap for addons that export camstack
 * devices to external ecosystems (HomeAssistant via MQTT discovery,
 * HomeKit/HAP, Alexa Smart Home, …).
@@ -17091,6 +17028,7 @@ sub("presence", "sensor", "sensor", "#22c55e", "presence", "Presence");
 sub("enum-sensor", "sensor", "sensor", TAXONOMY_COLORS.sensor, "generic", "Sensor state");
 sub("device-event", "sensor", "sensor", "#10b981", "button", "Device event");
 sub("lock", "control", "control", "#0ea5e9", "lock", "Lock");
+sub("cover", "control", "control", "#0ea5e9", "door", "Cover");
 sub("switch", "control", "control", TAXONOMY_COLORS.control, "switch", "Switch");
 sub("siren", "control", "control", "#dc2626", "siren", "Siren");
 sub("button", "control", "control", "#10b981", "button", "Button");
@@ -17409,6 +17347,10 @@ var NcSystemEventKindSchema = _enum([
 	"alarm-disarmed",
 	"alarm-arming",
 	"alarm-arm-refused",
+	"alarm-pending",
+	"alarm-rearmed",
+	"alarm-sensor-bypass",
+	"alarm-check-failed",
 	"addon-updated",
 	"server-updated",
 	"export-completed",
@@ -18004,6 +17946,19 @@ var NcMediaFrameSchema = _enum([
 	"full",
 	"boxed"
 ]);
+/**
+* How a SENSOR notification shows the cameras that link the sensor.
+*
+* `mosaic` — one image composed of every linked camera's photograph, taken at
+* the trigger. `each` — one image per camera where the target takes several
+* attachments; a target that takes one keeps the first camera's (the degrade
+* engine drops the rest by order). Either way ONE notification per event.
+* Absent = `mosaic`, applied by the Notification Center and deliberately NOT
+* a Zod default (see NcRulePatchSchema: a default materialises on every
+* partial patch). Meaningless for a rule whose subject is not a sensor, and a
+* sensor linked to one camera ships that camera's plain snapshot either way.
+*/
+var NcLinkedCameraModeSchema = _enum(["mosaic", "each"]);
 var NcMediaPolicySchema = object({
 	attach: _enum([
 		"best",
@@ -18049,7 +18004,9 @@ var NcMediaPolicySchema = object({
 	* A profile that is not assigned falls back to the cheapest, and the render
 	* reports which one actually ran.
 	*/
-	profile: CamProfileSchema.optional()
+	profile: CamProfileSchema.optional(),
+	/** See {@link NcLinkedCameraModeSchema}. */
+	linkedCameras: NcLinkedCameraModeSchema.optional()
 });
 /**
 * Cooldown GRANULARITY over the subject's class — how much a fired
@@ -18169,7 +18126,7 @@ var NcRuleInputSchema = object({
 		cooldownSec: 60,
 		scope: "rule-device"
 	}),
-	/** `{{var}}` templating over camera/class/label/zones/confidence/time. */
+	/** `{{var}}` title/body. The variables are declared in `NC_TEMPLATE_VARS` (@camstack/types) and depend on the rule kind — see `templateVarsFor`. */
 	template: object({
 		title: string().max(500).optional(),
 		body: string().max(2e3).optional()
@@ -18349,6 +18306,22 @@ var NcRulePatchSchema = NcRuleInputSchema.partial().extend({
 	throttle: NcThrottleSchema.optional(),
 	priority: number().int().min(1).max(5).optional()
 });
+var NcRuleClearableKeySchema = _enum([
+	"template",
+	"schedule",
+	"targetUsers",
+	"snoozeOptions",
+	"snoozeAllowGlobal",
+	"waitForEnhancement",
+	"actions",
+	"confirm",
+	"groupIdleSec"
+]);
+var NcRuleUpdateInputSchema = object({
+	ruleId: string(),
+	patch: NcRulePatchSchema,
+	clear: array(NcRuleClearableKeySchema).optional()
+});
 /** A persisted rule. */
 var NcRuleSchema = NcRuleInputSchema.extend({
 	id: string(),
@@ -18380,6 +18353,85 @@ var NcTestResultSchema = object({
 	className: string().optional(),
 	label: string().optional()
 });
+/** The five rule kinds, as data. `NcRuleKind` in `notification/rule-kinds.ts`
+*  is the same union; the template-vars spec pins the two together. */
+var NcRuleKindSchema = _enum([
+	"detection",
+	"sensor",
+	"occupancy",
+	"sound",
+	"system"
+]);
+/** Which producer renders a template: an ordinary rule, a timelapse, a digest. */
+var NcTemplateFamilySchema = _enum([
+	"rule",
+	"timelapse",
+	"summary"
+]);
+/** Which text field of that producer. `previewText` is the timelapse frame
+*  caption, `captionText` the digest mosaic caption — both see fewer vars. */
+var NcTemplateFieldSchema = _enum([
+	"title",
+	"body",
+	"previewText",
+	"captionText"
+]);
+var NcTemplateVarGroupSchema = _enum([
+	"subject",
+	"place",
+	"time",
+	"rule",
+	"occupancy",
+	"sound",
+	"sensor",
+	"system",
+	"digest",
+	"ai"
+]);
+/**
+* ONE `{{var}}` a notification template may name.
+*
+* `families` / `fields` / `kinds` / `deliveries` / `systemEventKinds` say WHERE
+* it has a value; absent = no restriction on that axis. `systemEventKinds` is
+* read only for a `system` rule. `dynamic` declares a FAMILY of names
+* (`count_<class>`): the descriptor's `name` is the example member.
+*/
+var NcTemplateVarDescriptorSchema = object({
+	name: string().regex(/^\w+$/),
+	label: string(),
+	description: string().optional(),
+	example: string(),
+	group: NcTemplateVarGroupSchema,
+	families: array(NcTemplateFamilySchema).min(1),
+	fields: array(NcTemplateFieldSchema).optional(),
+	kinds: array(NcRuleKindSchema).optional(),
+	deliveries: array(NcDeliverySchema).optional(),
+	systemEventKinds: array(NcSystemEventKindSchema).optional(),
+	dynamic: object({
+		prefix: literal("count_"),
+		from: literal("classes")
+	}).optional()
+});
+/** Input to `previewTemplate` — the editor's own context, plus the draft text. */
+var NcTemplatePreviewInputSchema = object({
+	context: object({
+		family: NcTemplateFamilySchema,
+		field: NcTemplateFieldSchema,
+		kind: NcRuleKindSchema.optional(),
+		delivery: NcDeliverySchema.optional(),
+		systemEventKinds: array(NcSystemEventKindSchema).optional()
+	}),
+	template: object({
+		title: string().max(500).optional(),
+		body: string().max(2e3).optional()
+	})
+});
+var NcTemplatePreviewSchema = object({
+	title: string().nullable(),
+	body: string().nullable(),
+	/** Names the template uses that this context never fills — they render empty. */
+	unknown: array(string())
+});
 var NcConditionDescriptorSchema = object({
 	/** Field id inside `NcConditions` (or `'schedule'` for the rule-level group). */
 	id: string(),
@@ -18645,8 +18697,17 @@ object({
 	lastAt: number()
 });
 /**
-* The three durations the panel's state machine runs on, plus who hears about
-* an arm.
+* The per-mode lists, at most one per mode. Two lists for one mode have no
+* meaning a reader could agree on (union? the last one?), so they are refused
+* at the boundary rather than interpreted.
+*/
+var NcAlarmNonBlockingListSchema = array(object({
+	mode: AlarmArmModeSchema,
+	deviceIds: array(number().int()).max(200)
+})).max(8).refine((lists) => new Set(lists.map((l) => l.mode)).size === lists.length, { message: "nonBlocking: at most one list per arm mode" });
+/**
+* The three durations the panel's state machine runs on, who hears about its
+* transitions, and which openings each mode tolerates.
 *
 * They live on the NOTIFICATION-RULES cap, not on `alarm-panel`, on purpose:
 * `alarm-panel` is `deviceNative` and its other provider mirrors somebody
@@ -18665,21 +18726,39 @@ var NcAlarmSettingsSchema = object({
 	* existed, and therefore what an untouched install keeps doing.
 	*/
 	triggeredDurationSec: number().int().min(0).max(3600),
-	/** Send a notification when a mode takes effect. */
-	announceArm: boolean(),
 	/**
-	* Where that notification goes. Target ids from `notification-output`.
+	* Deprecated by D630 — every transition is announced. Parsed, never read;
+	* remove after one release. Optional so an older admin's patch (which still
+	* sends it) parses rather than failing the whole save.
+	*/
+	announceArm: boolean().optional(),
+	/**
+	* Target ids from `notification-output`: every alarm transition goes here.
 	*
-	* Explicit rather than "everyone": an arm announcement is a household
+	* Explicit rather than "everyone": an alarm announcement is a household
 	* message, and broadcasting it to every configured endpoint (including a
 	* webhook wired to something else) is not a default anybody would choose.
-	* Empty with `announceArm: true` sends nothing, and the server logs that —
-	* silence must be attributable.
+	* Empty sends nothing, and the server logs that — silence must be
+	* attributable.
+	*/
+	announceTargets: array(string().min(1)).max(16),
+	/**
+	* Per arm mode, the covered devices whose being OPEN does not refuse the
+	* arm (a window left ajar for the cat under `home`, say). At most one entry
+	* per mode is meaningful. Defaulted to `[]` so a blob stored before D630
+	* parses as "every opening blocks" — the behaviour it was written under.
 	*/
-	announceTargets: array(string().min(1)).max(16)
+	nonBlocking: NcAlarmNonBlockingListSchema.default([])
 });
-/** Every field optional — a tab edits one control at a time. */
-var NcAlarmSettingsPatchSchema = NcAlarmSettingsSchema.partial();
+/**
+* Every field optional — a tab edits one control at a time.
+*
+* `nonBlocking` is re-declared WITHOUT its default: `.partial()` does not
+* remove an inner `.default()`, so a patch that never named the field would
+* parse to `nonBlocking: []` and wipe every mode's list on an unrelated edit
+* (the same trap {@link NcRulePatchSchema} documents).
+*/
+var NcAlarmSettingsPatchSchema = NcAlarmSettingsSchema.extend({ nonBlocking: NcAlarmNonBlockingListSchema }).partial();
 /**
 * What one arm mode actually arms, DERIVED from the enabled rules gated on it.
 * Never authored, never stored — see `alarm-mode-coverage.ts` for why a stored
@@ -18724,6 +18803,36 @@ var NcAlarmModeCoverageSchema = object({
 	*/
 	skippedDevices: array(NcAlarmSkippedDeviceSchema).default([])
 });
+/** One covered device that reads open, and whether that refuses the arm. */
+var NcAlarmOpeningSchema = object({
+	deviceId: number().int(),
+	name: string(),
+	/** The device's state word as read (`open`, `unlocked`, …). */
+	state: string(),
+	/** False when the mode's non-blocking list names this device. */
+	blocking: boolean()
+});
+/** A device the panel is currently ignoring, and which side of it it is on. */
+var NcAlarmExclusionViewSchema = object({
+	deviceId: number().int(),
+	name: string(),
+	phase: _enum(["open", "closed"])
+});
+/** One mode's openings: devices read open, plus those whose state is unknown. */
+var NcAlarmModeOpeningsSchema = object({
+	mode: AlarmArmModeSchema,
+	devices: array(NcAlarmOpeningSchema),
+	/** Covered devices whose state could not be read (D49): neither open nor closed. */
+	unknown: array(number().int())
+});
+var NcAlarmLiveSchema = object({
+	state: AlarmStateSchema,
+	/** The mode being armed into (exit delay) or held; null when disarmed. */
+	targetMode: AlarmArmModeSchema.nullable(),
+	availableModes: array(AlarmArmModeSchema),
+	openings: array(NcAlarmModeOpeningsSchema),
+	exclusions: array(NcAlarmExclusionViewSchema)
+});
 var NcAlarmConfigSchema = object({
 	/**
 	* The panel's device id, or null when this install has no panel (the ensure
@@ -18733,7 +18842,13 @@ var NcAlarmConfigSchema = object({
 	*/
 	deviceId: number().int().nullable(),
 	settings: NcAlarmSettingsSchema,
-	coverage: array(NcAlarmModeCoverageSchema)
+	coverage: array(NcAlarmModeCoverageSchema),
+	/**
+	* The panel as it is NOW — state, what each mode would find open, what is
+	* excluded. Optional: a panel-less hub answers without it, and a client
+	* must not read its absence as "nothing is open".
+	*/
+	live: NcAlarmLiveSchema.optional()
 });
 /**
 * ONE rule's demand on ONE camera's clip ring.
@@ -18781,10 +18896,7 @@ method(object({}), object({ rules: array(NcRuleSchema) }), { auth: "admin" }), m
 	kind: "mutation",
 	auth: "admin",
 	caller: "required"
-}), method(object({
-	ruleId: string(),
-	patch: NcRulePatchSchema
-}), object({ rule: NcRuleSchema }), {
+}), method(NcRuleUpdateInputSchema, object({ rule: NcRuleSchema }), {
 	kind: "mutation",
 	auth: "admin",
 	caller: "required"
@@ -18812,7 +18924,10 @@ method(object({}), object({ rules: array(NcRuleSchema) }), { auth: "admin" }), m
 }), method(object({}), object({
 	catalog: array(NcConditionDescriptorSchema),
 	taxonomy: NcTaxonomySchema.optional()
-})), method(object({ filter: NcHistoryFilterSchema.default({ limit: 100 }) }), object({ entries: array(NcHistoryEntrySchema) }), { auth: "admin" }), method(object({ artifactId: string().min(1) }), object({ url: string().nullable() }), { auth: "admin" }), method(object({}), object({ snoozes: array(NcSnoozeSchema) }), { caller: "required" }), method(object({ snooze: NcSnoozeInputSchema }), object({ snooze: NcSnoozeSchema }), {
+})), method(object({}), object({ vars: array(NcTemplateVarDescriptorSchema) })), method(NcTemplatePreviewInputSchema, NcTemplatePreviewSchema, {
+	kind: "mutation",
+	access: "view"
+}), method(object({ filter: NcHistoryFilterSchema.default({ limit: 100 }) }), object({ entries: array(NcHistoryEntrySchema) }), { auth: "admin" }), method(object({ artifactId: string().min(1) }), object({ url: string().nullable() }), { auth: "admin" }), method(object({}), object({ snoozes: array(NcSnoozeSchema) }), { caller: "required" }), method(object({ snooze: NcSnoozeInputSchema }), object({ snooze: NcSnoozeSchema }), {
 	kind: "mutation",
 	caller: "required"
 }), method(object({ snoozeId: string() }), object({ success: literal(true) }), {
@@ -23285,6 +23400,7 @@ var CAP_TO_KIND = {
 	"enum-sensor": "enum-sensor",
 	"event-emitter": "device-event",
 	"lock-control": "lock",
+	cover: "cover",
 	switch: "switch",
 	button: "button",
 	doorbell: "doorbell"
@@ -24102,6 +24218,87 @@ method(_void(), ProviderInfoSchema, { auth: "admin" }), method(object({ config:
 	kind: "mutation",
 	auth: "admin"
 });
+/**
+* The signals a device can emit to WAKE its own stream.
+*
+* A camera whose stream is built on demand sleeps until something asks for it,
+* and "something" cannot be a consumer that is merely attached — a Frigate-style
+* puller holds a session open for ever, and treating that as demand would keep
+* a battery camera awake for ever, which is the whole thing the battery is for
+* (D173). So the wake has to come from the CAMERA: an event it noticed by
+* itself, with no stream running.
+*
+* ## The vocabulary is the PROVIDER'S, not ours
+*
+* Like `consumables`, this cap declares no vocabulary of its own. A provider
+* names each signal with a `code` it chooses and a `label` an operator reads.
+* Reolink offers motion and camera-native detection; another provider may offer
+* a tamper, a doorbell press, a PIR, or something no camera in this fleet has
+* yet. A fixed enum here would mean every new signal is a framework release.
+*
+* It is deliberately NOT derived from the caps a device already binds. Whether
+* a camera CAN push firmware motion is expressed by `motionSources` containing
+* `'onboard'`, and whether it does AI on-camera by the `native-object-detection`
+* binding — but both answer "what drives the detection pipeline", which is a
+* different question from "what may wake a sleeping stream". A camera can do
+* the first and not be trusted with the second, and the operator picks per
+* camera. Two questions, two authorities.
+*
+* ## Availability is not permission
+*
+* `listSignals` says what the device CAN emit. Whether a given signal actually
+* wakes the stream is the operator's per-camera choice, held by the broker
+* alongside the cooldown — see the stream-broker cap's wake settings. A
+* provider declaring a signal is not a provider enabling it.
+*/
+/** One signal a device can emit. */
+var StreamSignalSchema = object({
+	/** Stable id chosen by the provider, e.g. `'motion'`, `'person'`, `'tamper'`. */
+	code: string().min(1),
+	/** What an operator reads in the picker. The provider's own wording. */
+	label: string().min(1),
+	/**
+	* Whether the provider recommends this signal ON when a camera is first set
+	* up. A provider knows which of its signals are cheap and reliable; an
+	* operator should not have to discover that by trial. Reolink recommends
+	* both of its own.
+	*/
+	recommended: boolean()
+});
+var StreamSignalsStatusSchema = object({
+	signals: array(StreamSignalSchema),
+	lastFetchedAt: number()
+});
+var streamSignalsCapability = {
+	name: "stream-signals",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: Object.values(DeviceType),
+	runtimeState: StreamSignalsStatusSchema,
+	/**
+	* Runtime-state durability: **session** — mirrored in RAM, never written.
+	*
+	* The slice holds what the DEVICE says it can emit. That is a probed fact,
+	* not an operator choice: the provider re-declares it on every registration,
+	* so losing it loses nothing and persisting it would freeze an answer the
+	* camera is entitled to change. Measured the same day on the sibling case —
+	* `native-object-detection.supportedClasses` was persisted, and a firmware
+	* class the camera really detected stayed missing for the life of the row
+	* because the fix could not reach it.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "session",
+	methods: { 
+	/**
+	* What this device can emit. Empty is a valid and common answer — most
+	* cameras have nothing to offer here, and an empty list is what makes the
+	* broker's picker show nothing rather than a false choice.
+	*/
+listSignals: method(_void(), array(StreamSignalSchema).readonly()) }
+};
 /** Profile-exported FormBuilder schema. Shape is ConfigUISchema at the UI. */
 var ProfileSettingsSchemaBridge = unknown().nullable();
 var ProfileSettingsBagSchema = record(string(), unknown());
@@ -24674,6 +24871,7 @@ _enum([
 	"sleeping",
 	"camera-refused",
 	"no-keyframe",
+	"decode-failed",
 	"no-catalog-row",
 	"unsupported",
 	"unknown-device",
@@ -24948,6 +25146,32 @@ var ClipBytesSchema = object({
 	durationMs: number().positive().optional()
 });
 /**
+* Where a clip's finished bytes can be TAKEN (D613) — the answer to
+* {@link videoclipsCapability.methods.offerClipBytes}.
+*
+* Everything {@link ClipBytesSchema} carries except the bytes themselves, plus
+* the one-shot ticket that leads to them. The metadata is answered BEFORE the
+* transfer on purpose: a consumer learns which twin it got, what to call the
+* file and how long the clip runs without having to read a byte, so a decision
+* it would make on that metadata (a wrong twin, an implausible duration) costs
+* no transfer at all.
+*/
+var ClipBytesOfferSchema = object({
+	/**
+	* One shot, seconds-long, loopback, on the PROVIDER's own host. Open it with
+	* `ctx.peerBytes.open(...)`, which refuses a ticket from another node by
+	* name rather than dialling a port that means something else here.
+	*/
+	ticket: PeerBytesTicketSchema,
+	contentType: string(),
+	/** Suggested filename, extension included. */
+	name: string(),
+	/** Which twin was actually served — see {@link ClipBytesSchema.served}. */
+	served: CamProfileSchema,
+	/** See {@link ClipBytesSchema.durationMs}. Absent when nothing measured it. */
+	durationMs: number().positive().optional()
+});
+/**
 * Where a clip's STREAM can be dialled (D597) — the answer to
 * {@link videoclipsCapability.methods.dialClipStream}.
 *
@@ -25023,6 +25247,44 @@ var ClipStreamDialSchema = object({
 	/** Why `servedAudio` is `none` although sound was asked for. */
 	audioReason: ClipStreamAudioReasonSchema.optional()
 });
+/**
+* What a surface may DRAW for this provider's clips — the answer to
+* {@link videoclipsCapability.methods.getPlaybackOptions} (D612).
+*
+* The envelope is a PROVIDER fact, not a clip fact, and that is measured, not
+* assumed: the broker's `chooseClipPath` reads exactly two inputs — whether
+* `dialClipStream` and `readClipBytes` are wired — and both are constants of
+* the broker's own closure over the provider's methods. The `profile` it is
+* handed is explicitly not read. So every clip of a provider is served the
+* same way, and a per-clip channel carried a value that could not vary. The
+* per-clip `clipTransport` server message was removed for exactly that reason.
+*
+* Queried per camera, before a clip is picked, so a control is rendered or
+* DISABLED rather than offered and refused at play time (D62: a disabled
+* control reads as unavailable, one that undoes the gesture reads as broken).
+*/
+var ClipPlaybackOptionsSchema = object({
+	/**
+	* How this provider's clips reach the player. `stream` is the provider's
+	* forward-only fMP4 (D597); `file` is one bounded by-handle fetch of the
+	* whole clip, `stbl` indexed (D575).
+	*/
+	transport: _enum(["stream", "file"]),
+	/** `forward` = only ahead of the playhead. `free` = anywhere. */
+	seek: _enum(["forward", "free"]),
+	/** Frame-step BACKWARD is meaningful. Forward always is. */
+	stepBack: boolean(),
+	/** Whether the scrub gesture is served, as opposed to refused by name. */
+	scrub: boolean(),
+	/**
+	* The rates that can be delivered, ascending, always containing `1`. The
+	* viewer draws its picker from this and from nothing else — a constant it
+	* keeps instead is the second authority that produced the defect: `8` and
+	* `16` were offered, the broker clamped them to `4`, and no line anywhere
+	* said so. `0` is not a member: pause is the absence of a rate.
+	*/
+	rates: array(number().positive()).min(1).readonly()
+});
 var ClipSourceAvailabilitySchema = object({
 	state: _enum([
 		"ok",
@@ -25182,6 +25444,29 @@ DeviceType.Camera, method(object({
 }), ClipBytesSchema, {
 	kind: "query",
 	auth: "protected"
+}), optionalMethod(object({
+	deviceId: number(),
+	clipId: string().min(1),
+	/** WHICH provider holds the bytes — see `readClipBytes.provider`. */
+	provider: string().min(1),
+	/** Which twin — `low | mid` → the sub file, `high` → the main twin. */
+	profile: CamProfileSchema.optional(),
+	/**
+	* The CALLER's byte bound, so an over-size clip is refused before the
+	* camera is touched rather than after. Capped by
+	* {@link VIDEOCLIPS_MAX_OFFER_BYTES} whatever is passed; absent means
+	* that ceiling.
+	*/
+	maxBytes: number().int().positive().optional(),
+	/**
+	* The operator's authorisation to wake a sleeping camera for this
+	* read. Absent — the default — means a sleeping standalone battery
+	* camera is REFUSED by name, before any session is opened.
+	*/
+	wake: ClipWakeSchema.optional()
+}), ClipBytesOfferSchema, {
+	kind: "query",
+	auth: "protected"
 }), optionalMethod(object({
 	deviceId: number(),
 	clipId: string().min(1),
@@ -25203,6 +25488,15 @@ DeviceType.Camera, method(object({
 }), ClipStreamDialSchema, {
 	kind: "query",
 	auth: "protected"
+}), optionalMethod(object({
+	deviceId: number(),
+	/** WHICH provider to ask — the `addonId` a {@link ClipSourceSchema}
+	*  row carries. Required for the same reason `listClips` requires it:
+	*  a collection cap has no "the bound one" to resolve to (D554). */
+	provider: string().min(1)
+}), ClipPlaybackOptionsSchema, {
+	kind: "query",
+	auth: "protected"
 });
 /**
 * Optional client-side hints sent at session creation to help the provider
@@ -26563,6 +26857,143 @@ DeviceType.Camera, method(object({ deviceId: number() }), CameraCredentialsSchem
 	auth: "admin"
 });
 /**
+* camera-grid-layout — the geometry of a COMPOSITE camera, on the camera's own
+* page.
+*
+* ## Why this is a capability and not an addon settings schema
+*
+* It was one, and it did not render. The addon declared the editor as a
+* `type: 'widget'` field inside its own `deviceSettingsSchema()`; the hub
+* returned that section correctly and `ConfigFormField` renders `type:'widget'`
+* perfectly well — and nothing ever asked camera-grid for it. The Cluster →
+* Pipeline → Device Overrides page interrogates a HAND-WRITTEN list of four
+* addons (`PIPELINE_CLUSTER_DEVICE_ADDONS`), whose own comment says an addon
+* not on it "falls off silently".
+*
+* Adding a fifth name to that list would have been the wrong fix twice over:
+* that page is per-camera DETECTION tuning, and a grid's geometry belongs
+* beside PTZ and motion zones on the camera itself. The device page is
+* BINDING-driven (D12), so the way in is a capability bound to the device —
+* and this cap carries its section the way `recording` does, by RETURNING it
+* from `getDeviceSettingsContribution`.
+*
+* Seven other widgets are still declared the other way, through a
+* `deviceConfig.ui` block the framework derives a section from. That route
+* gives the addon no say in where its own panel lands and no way to decline
+* for a device the panel does not suit, which is why this one does not use it.
+*
+* ## Why one addon may implement it
+*
+* It is a device-scoped NATIVE cap, registered by the grid camera device
+* itself. Nothing else declares a composite camera, so nothing else has a
+* layout — and the device-scoped route means the widget asks THE camera, not
+* "the camera-grid addon", which is what let the old custom-action pair be
+* reached only by a caller that already knew the addon id.
+*
+* ## The tab
+*
+* `streaming`, not a top-tab of its own. A grid's geometry IS what its stream
+* is, so the Streaming tab is where it belongs; a `grid` top-tab would need an
+* entry in `WELL_KNOWN_TAB_MAP` or the device page renders the raw id as the
+* label (measured on the robot camera, 2026-09-06 — a tab called "navigation"
+* next to "PTZ").
+*/
+/** A rectangle in normalized [0,1] coordinates of whatever contains it. */
+var GridNormalizedRectSchema = object({
+	x: number().min(0).max(1),
+	y: number().min(0).max(1),
+	width: number().gt(0).max(1),
+	height: number().gt(0).max(1)
+});
+/**
+* One source camera, the part of its picture taken, and where that part lands.
+*
+* Both rectangles are NORMALIZED (D519): a source camera can change resolution
+* — a profile switch, a firmware update, a substream that comes back different
+* — and a stored PIXEL rectangle would quietly start cutting the wrong region,
+* which is the class of bug nobody files.
+*/
+var GridLayoutCellSchema = object({
+	deviceId: number().int().positive(),
+	/** The part of the SOURCE taken, normalized against the source. */
+	source: GridNormalizedRectSchema,
+	/** Where it lands, normalized against the CANVAS. */
+	cell: GridNormalizedRectSchema
+});
+/**
+* Which profiles this grid can actually compose, and why not.
+*
+* A grid's `high` composes its sources' `high` and its `low` their `low`, so a
+* profile is on offer only when EVERY source can serve it. The refusal NAMES
+* the sources, because "this grid has no low" is not a finding — "615 has no
+* low" is, and it is the one an operator can act on.
+*/
+var GridProfileOfferSchema = object({
+	profile: _enum([
+		"high",
+		"mid",
+		"low"
+	]),
+	offered: boolean(),
+	/** Sources that cannot serve it. Empty when it is offered, or when there are no cells. */
+	missingSources: array(number().int().positive()),
+	/**
+	* The canvas this profile composes onto, `WxH`, or empty when it is not
+	* offered. DERIVED from the cells and the sources' own size at this profile —
+	* it is reported because nothing else in the system would ever say what the
+	* grid came out as, and because it is the number an operator would otherwise
+	* expect to type.
+	*/
+	canvas: string(),
+	/**
+	* Whether this profile is PUBLISHED, of the ones the grid could serve.
+	*
+	* A grid's `high` is composed of its sources' `high`, so on a 4K fleet it is
+	* a 4K canvas built from 4K decodes — something to opt into, not something a
+	* viewer's adaptive should be handed by climbing to the top rung it can see.
+	* Default is `mid` + `low`.
+	*/
+	published: boolean()
+});
+var GridLayoutViewSchema = object({
+	/** The persisted grid row this camera was declared from. */
+	instanceId: string(),
+	deviceId: number().int().nonnegative(),
+	name: string(),
+	/**
+	* NO canvas size. A grid's resolution is not authored: each profile derives
+	* its own from the cells and its sources' dimensions. The two numbers that
+	* used to be here were a text field that silently decided both how much the
+	* composite cost and how sharp it was — see `profiles[].canvas` for what it
+	* came out as.
+	*/
+	fps: number().int(),
+	cells: array(GridLayoutCellSchema),
+	/** What the catalog will publish, and what it refuses to. Read-only. */
+	profiles: array(GridProfileOfferSchema)
+});
+var GridLayoutPatchSchema = object({
+	deviceId: number().int().nonnegative(),
+	name: string().min(1).max(160).optional(),
+	fps: number().int().min(1).max(60).optional(),
+	/** Which profiles to publish. See `GridProfileOffer.published`. */
+	publishedProfiles: array(_enum([
+		"high",
+		"mid",
+		"low"
+	])).max(3).optional(),
+	/**
+	* The whole cell list at once. A per-cell patch would need an ordering the
+	* editor does not have, and a half-applied layout is a picture nobody asked
+	* for.
+	*/
+	cells: array(GridLayoutCellSchema).max(16)
+});
+DeviceType.Camera, method(object({ deviceId: number().int().nonnegative() }), GridLayoutViewSchema.nullable(), { auth: "admin" }), method(GridLayoutPatchSchema, GridLayoutViewSchema, {
+	kind: "mutation",
+	auth: "admin"
+});
+/**
 * Carbon-monoxide alarm sensor. Drives Home Assistant `binary_sensor`
 * entries with `device_class: carbon_monoxide`. Push-driven.
 */
@@ -27365,346 +27796,6 @@ var dayNightCapability = {
 	volatileStateFields: ["lastFetchedAt"]
 };
 /**
-* Vendor-neutral **onboard** recording + storage cap — what the CAMERA
-* writes to the CAMERA's own card, on the camera's own schedule.
-*
-* This is NOT `recording.cap.ts`. That one is CamStack's recorder: our
-* footage ledger, our storage locations, our retention. This one has a
-* different authority — the camera's firmware — and per D62 it stores
-* nothing of its own. Every value here is read from the camera and every
-* write goes back to the camera; there is no CamStack-side mirror that
-* could disagree with the device.
-*
-* ## One shape, two firmwares
-*
-* Measured 2026-09-22 against the live fleet:
-*
-* | fact | Hikvision (ISAPI) | Reolink (Baichuan) |
-* | --- | --- | --- |
-* | storage | `ContentMgmt/Storage` `<hdd>` rows: status, capacity, freeSpace (MB) | `getHddInfoList` (cmd 102): `mount`, `format`, `capacity` GB + `capacityM` MB remainder |
-* | tracks | several (101 **and** 103 on both 1436 and 3833), each with its own schedule | one per channel |
-* | schedule | per track, 7 `ScheduleAction` blocks: DayOfWeek + TimeOfDay range + ONE `ActionRecordingMode` | per trigger type, a 168-char weekly HOUR mask |
-* | triggers | `CMR`, `MOTION` | `Normal`, `MD`, `people`, `vehicle`, `dog_cat`, `crossline`, `intrude`, `loitering` |
-* | pre-record | `PreRecordTimeSeconds` | `preRecordTime` |
-* | post-record | `PostRecordTimeSeconds` | `recordDelayTime` |
-* | overwrite | per track `LoopEnable` | `cycle`, with `cycleList` enumerating the accepted values |
-* | segment length | not exposed on V5.7.1 | `packageTime` (minutes) |
-*
-* The two schedule models look different and are the same thing in
-* different coordinates: both answer "for this trigger, during which
-* weekly windows does the camera record". {@link RecordWindow} is that
-* question in one shape — Hikvision's ranges map straight onto it,
-* Reolink's mask expands into hour-aligned windows.
-*
-* ## Union, not intersection
-*
-* **The same fields exist on every camera.** What differs per device is
-* which VALUES that device accepts, and that is what {@link
-* RecordingOnboardOptions} reports — a `{ readable, writable, reason }`
-* per field plus the schedule's own limits. A control a camera cannot
-* honour is rendered DISABLED WITH ITS REASON, never missing and never
-* dead: disabled must not look like broken.
-*
-* ## Refusal by name
-*
-* A write a camera cannot honour is refused with a sentence the operator
-* can read — never accepted and dropped. Both providers refuse through
-* {@link describeOnboardRefusal}, so the vocabulary is one function and
-* one test, not two hand-written vendor opinions.
-*
-* Follows the D14 `deviceConfig` archetype (see `stream-params.cap.ts`):
-* `getOptions` advertises per-camera availability, `getStatus` (auto-
-* injected from `status`) reports the live values, and a single
-* `setSettings` mutation applies a partial change. No hand-written
-* settings-contribution methods.
-*/
-/**
-* What makes the camera start recording during a window.
-*
-* The union of both vendors' vocabularies. `continuous` is Hikvision's
-* `CMR` and Reolink's `Normal`; `motion` is `MOTION` / `MD`. The
-* object-class triggers are Reolink-only today and the smart-event ones
-* (`lineCrossing`, `intrusion`, `loitering`) are Reolink-only on the
-* firmwares measured — a camera that cannot record on a trigger simply
-* does not list it in `options.schedule.triggers`, and a window naming
-* it is REFUSED, not dropped.
-*/
-var RecordTriggerSchema = _enum([
-	"continuous",
-	"motion",
-	"person",
-	"vehicle",
-	"animal",
-	"lineCrossing",
-	"intrusion",
-	"loitering",
-	"alarmInput"
-]);
-/**
-* One weekly recording window: "on `day`, from `startMinute` to
-* `endMinute`, record on `trigger`".
-*
-* `day` is 0 = Monday … 6 = Sunday (ISO order, which is also the order
-* both firmwares enumerate). Minutes are local camera time since
-* midnight; `endMinute` may be 1440, meaning end of day — that is
-* Hikvision's literal `24:00` and Reolink's 24th mask slot, and
-* collapsing it to 0 would turn a whole-day window into an empty one.
-*/
-var RecordWindowSchema = object({
-	trigger: RecordTriggerSchema,
-	day: number().int().min(0).max(6),
-	startMinute: number().int().min(0).max(1439),
-	endMinute: number().int().min(1).max(1440)
-});
-/** Status of one physical volume, as the camera itself describes it. */
-var OnboardStorageVolumeSchema = object({
-	/** The camera's own id for the volume (`hdd/id`, Reolink `HddInfo/number`). */
-	id: string(),
-	/** The camera's own name for it, when it gives one (`hddName`). */
-	label: string().optional(),
-	status: _enum([
-		"ok",
-		"unformatted",
-		"error",
-		"offline",
-		"unknown"
-	]),
-	/**
-	* Total size in MB, or **null when the camera did not say**.
-	*
-	* Never 0 for an unreadable value: a measurement that failed is not a
-	* measurement (D393), and a card whose size is unknown must not be
-	* rendered as a card of size zero.
-	*/
-	capacityMb: number().nullable(),
-	/**
-	* Free space in MB, or null when unknown.
-	*
-	* **Not a proxy for "has footage".** Measured 2026-09-22: 1436 and
-	* 1439 both report exactly 11776 MB free — the fixed reserve a looping
-	* card converges on once it has wrapped. At loop steady state the
-	* number is identical whether the camera recorded yesterday or stopped
-	* a month ago.
-	*/
-	freeMb: number().nullable(),
-	/** True when the camera reports the volume writable (`property` RW). */
-	writable: boolean().optional()
-});
-/**
-* What the camera is doing with its own storage, right now.
-*
-* Every scalar is nullable and **null means the camera did not answer**,
-* never a default. A form that seeds `0` from an unanswered read invites
-* the operator to save that 0 back onto the camera.
-*/
-var RecordingOnboardStatusSchema = object({
-	storage: discriminatedUnion("kind", [
-		object({
-			kind: literal("present"),
-			volumes: array(OnboardStorageVolumeSchema)
-		}),
-		object({
-			kind: literal("absent"),
-			reason: string()
-		}),
-		object({
-			kind: literal("unknown"),
-			reason: string()
-		})
-	]),
-	tracks: array(object({
-		id: string(),
-		enabled: boolean(),
-		isVideo: boolean(),
-		/** From the camera's own track description. Null when it does not say. */
-		codec: string().nullable(),
-		resolution: string().nullable(),
-		/** Per-track overwrite flag, where the firmware keeps it per track. */
-		overwriteWhenFull: boolean().nullable()
-	})),
-	/**
-	* The track the write path targets — the enabled VIDEO one. Null when
-	* no track could be identified, which is itself a refusal reason.
-	*/
-	primaryTrackId: string().nullable(),
-	/** Master "record to the card at all" switch. */
-	enabled: boolean().nullable(),
-	overwriteWhenFull: boolean().nullable(),
-	preRecordSec: number().nullable(),
-	postRecordSec: number().nullable(),
-	/** Length of one recorded file, in minutes. */
-	segmentMinutes: number().nullable(),
-	/** The primary track's weekly windows, flattened. */
-	windows: array(RecordWindowSchema),
-	/**
-	* How many windows the camera described that CamStack could NOT read —
-	* an unrecognised trigger, an unparseable clock, a weekday it does not
-	* name.
-	*
-	* A dropped window is work the reader threw away, and a schedule that
-	* silently shows fewer rows than the camera holds is how an operator
-	* saves back a schedule shorter than the one they were looking at
-	* (D391). Non-zero means the window list is INCOMPLETE and a write
-	* that replaces it would delete what was not shown — which is why a
-	* provider reporting a non-zero count also reports the schedule as not
-	* writable.
-	*/
-	unreadableWindows: number(),
-	/**
-	* The camera is scheduled to record and has NO usable storage.
-	*
-	* A first-class fact because it is the fleet's most common silent
-	* defect: measured 2026-09-22, 1441 and 3831 are both motion-recording
-	* to a card that is not there. Neither the schedule nor the storage
-	* read says anything wrong on its own; only the pair does.
-	*/
-	recordingToNowhere: boolean(),
-	lastFetchedAt: number()
-});
-/** Numeric range descriptor — `{ min, max, step }` per the getOptions convention. */
-var RangeSchema = object({
-	min: number(),
-	max: number(),
-	step: number()
-});
-/**
-* The values a camera actually takes for a numeric field, when they are a SET
-* rather than a range.
-*
-* `{min,max,step}` cannot say what these two firmwares do. Measured on 1436
-* (I91DN) on 2026-09-22 by writing each value and reading it back:
-*
-* - pre-record: `0, 5, 10, 15, 20, 25, 30` and `2147483647` (INT32_MAX, the
-*   camera's "no limit" — `-1` and `4294967295` both land on it);
-* - post-record: `5, 10, 30, 60, 120, 300, 600`.
-*
-* Neither is expressible as a step: the first has a sentinel two billion away
-* from its neighbours, the second doubles and then jumps. A range that tried
-* would forbid values the camera takes AND permit values it silently replaces
-* with 5 — wrong in both directions at once.
-*
-* `sentinel` names the member that is not a duration, so a surface can render
-* "no limit" instead of `2147483647` seconds.
-*/
-var AllowedValuesSchema = object({
-	values: array(number()).min(1),
-	sentinel: object({
-		value: number(),
-		meaning: _enum(["no-limit", "disabled"])
-	}).optional()
-});
-/**
-* Per-field availability on ONE camera.
-*
-* The field exists on every camera — this says whether this one can be
-* read and whether it can be written, and `reason` says why not when
-* either is false. The UI renders the control DISABLED with the reason
-* rather than hiding it, so a limitation is legible instead of looking
-* like a missing feature.
-*/
-var OnboardFieldSupportSchema = object({
-	readable: boolean(),
-	writable: boolean(),
-	/** Required whenever `readable` or `writable` is false. */
-	reason: string().optional()
-});
-/** What this camera's schedule model can express. */
-var OnboardScheduleSupportSchema = object({
-	support: OnboardFieldSupportSchema,
-	/**
-	* The smallest time step the camera can express, in minutes.
-	*
-	* Hikvision takes arbitrary minutes (`00:05:00`–`23:57:00` observed on
-	* 1436's track 103). Reolink's schedule is a 7×24 HOUR mask, so 60. A
-	* window whose edges are not a multiple of this is REFUSED rather than
-	* quietly rounded — rounding is how an operator's 06:30 becomes 06:00
-	* and nothing says so.
-	*/
-	granularityMinutes: number(),
-	/** Triggers this camera can record on. A window naming another is refused. */
-	triggers: array(RecordTriggerSchema),
-	/**
-	* False when the camera stores ONE trigger per time range, so two
-	* windows overlapping on the same day cannot carry different triggers.
-	* True on Reolink, whose mask is per-trigger and independent.
-	*/
-	supportsOverlappingTriggers: boolean()
-});
-var RecordingOnboardOptionsSchema = object({
-	enabled: OnboardFieldSupportSchema,
-	overwriteWhenFull: OnboardFieldSupportSchema,
-	preRecordSec: OnboardFieldSupportSchema,
-	preRecordSecRange: RangeSchema.optional(),
-	/** Preferred over the range when the camera takes a SET, not a span. */
-	preRecordSecAllowed: AllowedValuesSchema.optional(),
-	postRecordSec: OnboardFieldSupportSchema,
-	postRecordSecRange: RangeSchema.optional(),
-	/** Preferred over the range when the camera takes a SET, not a span. */
-	postRecordSecAllowed: AllowedValuesSchema.optional(),
-	segmentMinutes: OnboardFieldSupportSchema,
-	segmentMinutesRange: RangeSchema.optional(),
-	/** Preferred over the range when the camera takes a SET, not a span. */
-	segmentMinutesAllowed: AllowedValuesSchema.optional(),
-	schedule: OnboardScheduleSupportSchema
-});
-/**
-* A partial change. Every field optional.
-*
-* Unlike the other `deviceConfig` caps, a provider here does **NOT**
-* silently ignore a field it cannot support — it refuses, by name,
-* through {@link describeOnboardRefusal}. Silence on a recording setting
-* is the failure D62 exists to prevent: the operator believes the camera
-* is recording the way the form says, and it is not.
-*/
-var RecordingOnboardPatchSchema = object({
-	enabled: boolean().optional(),
-	overwriteWhenFull: boolean().optional(),
-	preRecordSec: number().optional(),
-	postRecordSec: number().optional(),
-	segmentMinutes: number().optional(),
-	/** The complete new window set for the primary track — not a delta. */
-	windows: array(RecordWindowSchema).optional()
-});
-var recordingOnboardCapability = {
-	name: "recording-onboard",
-	scope: "device",
-	deviceNative: true,
-	mode: "singleton",
-	deviceTypes: [DeviceType.Camera],
-	deviceConfig: { ui: {
-		kind: "derived-form",
-		builderId: "recording-onboard",
-		tab: "recording"
-	} },
-	methods: {
-		getOptions: method(object({ deviceId: number() }), RecordingOnboardOptionsSchema),
-		setSettings: method(object({
-			deviceId: number(),
-			settings: RecordingOnboardPatchSchema
-		}), _void(), {
-			kind: "mutation",
-			auth: "admin"
-		})
-	},
-	status: {
-		schema: RecordingOnboardStatusSchema,
-		kind: "poll"
-	},
-	runtimeState: RecordingOnboardStatusSchema,
-	/**
-	* Runtime-state durability: **restored** — operator-set camera-side
-	* recording config; mutation-driven, and the storage half is the last
-	* thing the camera said about its own card.
-	*
-	* See `RuntimeStateDurability`. Enforced by
-	* `scripts/check-runtime-state-durability.ts`.
-	*/
-	durability: "restored",
-	/** Clock fields: written, but excluded from the compare that decides
-	*  whether persisting is worth a SQLite commit. */
-	volatileStateFields: ["lastFetchedAt"]
-};
-/**
 * Generic device-level status snapshot. Auto-registered by `BaseDevice`
 * for every device, regardless of provider — the kernel needs a uniform
 * cap-keyed slice for the basic device flags every consumer expects to
@@ -27923,30 +28014,6 @@ var eventEmitterCapability = {
 	*/
 	durability: "session"
 };
-var EventItemSchema = object({
-	id: string(),
-	type: string(),
-	timestamp: number(),
-	label: string().optional(),
-	thumbnailUrl: string().optional(),
-	clipUrl: string().optional(),
-	metadata: record(string(), unknown()).optional()
-});
-DeviceType.Camera, method(object({
-	deviceId: number(),
-	from: number().optional(),
-	to: number().optional(),
-	limit: number().optional()
-}), array(EventItemSchema)), method(object({
-	deviceId: number(),
-	eventId: string()
-}), object({
-	base64: string(),
-	contentType: string()
-}).nullable()), method(object({
-	deviceId: number(),
-	eventId: string()
-}), string().nullable());
 var IdentitySchema = object({
 	id: string(),
 	name: string(),
@@ -30199,143 +30266,6 @@ var motionTriggerCapability = {
 	durability: "session"
 };
 /**
-* camera-grid-layout — the geometry of a COMPOSITE camera, on the camera's own
-* page.
-*
-* ## Why this is a capability and not an addon settings schema
-*
-* It was one, and it did not render. The addon declared the editor as a
-* `type: 'widget'` field inside its own `deviceSettingsSchema()`; the hub
-* returned that section correctly and `ConfigFormField` renders `type:'widget'`
-* perfectly well — and nothing ever asked camera-grid for it. The Cluster →
-* Pipeline → Device Overrides page interrogates a HAND-WRITTEN list of four
-* addons (`PIPELINE_CLUSTER_DEVICE_ADDONS`), whose own comment says an addon
-* not on it "falls off silently".
-*
-* Adding a fifth name to that list would have been the wrong fix twice over:
-* that page is per-camera DETECTION tuning, and a grid's geometry belongs
-* beside PTZ and motion zones on the camera itself. The device page is
-* BINDING-driven (D12), so the way in is a capability bound to the device —
-* and this cap carries its section the way `recording` does, by RETURNING it
-* from `getDeviceSettingsContribution`.
-*
-* Seven other widgets are still declared the other way, through a
-* `deviceConfig.ui` block the framework derives a section from. That route
-* gives the addon no say in where its own panel lands and no way to decline
-* for a device the panel does not suit, which is why this one does not use it.
-*
-* ## Why one addon may implement it
-*
-* It is a device-scoped NATIVE cap, registered by the grid camera device
-* itself. Nothing else declares a composite camera, so nothing else has a
-* layout — and the device-scoped route means the widget asks THE camera, not
-* "the camera-grid addon", which is what let the old custom-action pair be
-* reached only by a caller that already knew the addon id.
-*
-* ## The tab
-*
-* `streaming`, not a top-tab of its own. A grid's geometry IS what its stream
-* is, so the Streaming tab is where it belongs; a `grid` top-tab would need an
-* entry in `WELL_KNOWN_TAB_MAP` or the device page renders the raw id as the
-* label (measured on the robot camera, 2026-09-06 — a tab called "navigation"
-* next to "PTZ").
-*/
-/** A rectangle in normalized [0,1] coordinates of whatever contains it. */
-var GridNormalizedRectSchema = object({
-	x: number().min(0).max(1),
-	y: number().min(0).max(1),
-	width: number().gt(0).max(1),
-	height: number().gt(0).max(1)
-});
-/**
-* One source camera, the part of its picture taken, and where that part lands.
-*
-* Both rectangles are NORMALIZED (D519): a source camera can change resolution
-* — a profile switch, a firmware update, a substream that comes back different
-* — and a stored PIXEL rectangle would quietly start cutting the wrong region,
-* which is the class of bug nobody files.
-*/
-var GridLayoutCellSchema = object({
-	deviceId: number().int().positive(),
-	/** The part of the SOURCE taken, normalized against the source. */
-	source: GridNormalizedRectSchema,
-	/** Where it lands, normalized against the CANVAS. */
-	cell: GridNormalizedRectSchema
-});
-/**
-* Which profiles this grid can actually compose, and why not.
-*
-* A grid's `high` composes its sources' `high` and its `low` their `low`, so a
-* profile is on offer only when EVERY source can serve it. The refusal NAMES
-* the sources, because "this grid has no low" is not a finding — "615 has no
-* low" is, and it is the one an operator can act on.
-*/
-var GridProfileOfferSchema = object({
-	profile: _enum([
-		"high",
-		"mid",
-		"low"
-	]),
-	offered: boolean(),
-	/** Sources that cannot serve it. Empty when it is offered, or when there are no cells. */
-	missingSources: array(number().int().positive()),
-	/**
-	* The canvas this profile composes onto, `WxH`, or empty when it is not
-	* offered. DERIVED from the cells and the sources' own size at this profile —
-	* it is reported because nothing else in the system would ever say what the
-	* grid came out as, and because it is the number an operator would otherwise
-	* expect to type.
-	*/
-	canvas: string(),
-	/**
-	* Whether this profile is PUBLISHED, of the ones the grid could serve.
-	*
-	* A grid's `high` is composed of its sources' `high`, so on a 4K fleet it is
-	* a 4K canvas built from 4K decodes — something to opt into, not something a
-	* viewer's adaptive should be handed by climbing to the top rung it can see.
-	* Default is `mid` + `low`.
-	*/
-	published: boolean()
-});
-var GridLayoutViewSchema = object({
-	/** The persisted grid row this camera was declared from. */
-	instanceId: string(),
-	deviceId: number().int().nonnegative(),
-	name: string(),
-	/**
-	* NO canvas size. A grid's resolution is not authored: each profile derives
-	* its own from the cells and its sources' dimensions. The two numbers that
-	* used to be here were a text field that silently decided both how much the
-	* composite cost and how sharp it was — see `profiles[].canvas` for what it
-	* came out as.
-	*/
-	fps: number().int(),
-	cells: array(GridLayoutCellSchema),
-	/** What the catalog will publish, and what it refuses to. Read-only. */
-	profiles: array(GridProfileOfferSchema)
-});
-var GridLayoutPatchSchema = object({
-	deviceId: number().int().nonnegative(),
-	name: string().min(1).max(160).optional(),
-	fps: number().int().min(1).max(60).optional(),
-	/** Which profiles to publish. See `GridProfileOffer.published`. */
-	publishedProfiles: array(_enum([
-		"high",
-		"mid",
-		"low"
-	])).max(3).optional(),
-	/**
-	* The whole cell list at once. A per-cell patch would need an ordering the
-	* editor does not have, and a half-applied layout is a picture nobody asked
-	* for.
-	*/
-	cells: array(GridLayoutCellSchema).max(16)
-});
-DeviceType.Camera, method(object({ deviceId: number().int().nonnegative() }), GridLayoutViewSchema.nullable(), { auth: "admin" }), method(GridLayoutPatchSchema, GridLayoutViewSchema, {
-	kind: "mutation",
-	auth: "admin"
-});
-/**
 * Motion-zones share the same MaskShape vocabulary as privacy-mask — the
 * on-camera motion-detection mask is a single `grid` region (a row-major
 * boolean cell lattice the camera's onboard VMD evaluates). Composing it as
@@ -32698,37 +32628,37 @@ DeviceType.Camera, DeviceType.Sensor, DeviceType.Switch, method(object({ deviceI
 	kind: "mutation",
 	auth: "admin"
 });
-/**
-* `recording` cap — footage availability + HLS playback manifests + per-device
-* recording config. NOTE on events (source of truth, R5/C3): this cap carries
-* NO event surface — `getPlaybackManifest` returns playlist URLs only. Timeline
-* events (motion/object/audio) come from `pipelineAnalytics` (durable SQLite
-* rows) and are the ONLY event surface — the recorder has none. The in-RAM
-* playback markers it used to build were deleted on 2026-08-29 because nothing
-* ever read them. Event<->footage joins are by time, padded with the shared
-* `EVENT_PAD_MS` (`interfaces/recording-config.ts`).
-*/
-var RecordingStatusSchema = object({
-	deviceId: number(),
-	enabled: boolean(),
-	/** THE derived storage mode, from the one definition
-	*  (`deriveRecordingMode`) — never a second enum. A duplicated list is how
-	*  `on-device-decision` could have reached the recorder and not the status. */
-	activeMode: RecordingStorageModeSchema,
-	nodeId: string(),
-	storageBytes: number()
-});
 var RecordingRangeSchema = object({
 	profile: string(),
 	startMs: number(),
 	endMs: number()
 });
+/**
+* How a source ANSWERED, on every singular read of this cap.
+*
+* `'read'` — it looked. `ranges: []` / `days: []` is then a real claim: this
+* source has no coverage in the window. `'unreadable'` — nobody could look
+* (the camera was unreachable, the calendar rung threw, the location is
+* unmounted, the node is still on the old build), and the emptiness beside it
+* means NOTHING.
+*
+* The batch rows have carried this since the grid existed; the SINGULAR
+* answers gained it with the collection (D625 §10.4), because they are the
+* ones the single-camera picker uses and because a half-converted fleet makes
+* "nobody looked" common for the length of a deploy. Without it the timeline
+* has no vocabulary for it, and `(data ?? [])` in a viewer turns a rollout into
+* a fleet of cameras that appear to have lost their recordings (D315, D393).
+*/
+var RecordingReadSchema = _enum(["read", "unreadable"]);
 var RecordingAvailabilitySchema = object({
 	deviceId: number(),
+	/** See {@link RecordingReadSchema}. An `'unreadable'` answer carries an empty
+	*  `ranges` that means nothing — never draw it as "no footage". */
+	read: RecordingReadSchema,
 	ranges: array(RecordingRangeSchema),
 	/**
-	* Every profile this camera has footage in — not only the one `ranges`
-	* describes (D433).
+	* Every profile this camera has footage in AT THIS SOURCE — not only the one
+	* `ranges` describes (D433).
 	*
 	* `ranges` answers for ONE profile by design: the timeline is a single bar,
 	* and enumerating all of them triples the directory reads for a bar that
@@ -32745,15 +32675,285 @@ var RecordingAvailabilitySchema = object({
 });
 var RecordingDaysSchema = object({
 	deviceId: number(),
+	/** See {@link RecordingReadSchema}. `days: []` on an `'unreadable'` answer is
+	*  "nobody could look", and the date-picker must not spell it the same as
+	*  "no footage this month". */
+	read: RecordingReadSchema,
 	/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
 	days: array(number())
 });
+var RecordingManifestSchema = object({
+	deviceId: number(),
+	/** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
+	localMasterPath: string().nullable(),
+	/** HTTP(S) URL to the master playlist on the recording node's playback server
+	*  (the PRIMARY candidate); null when no recording / server. Carries the
+	*  scoped playback token in its path. */
+	playbackUrl: string().nullable(),
+	/**
+	* Candidate master-playlist URLs the client tries in order (LAN first, then
+	* remote — Tailscale/Cloudflare if the operator configured extra hosts), each
+	* carrying the same scoped token. `playbackUrl` is the first entry. Empty when
+	* there is no recording / server.
+	*/
+	playbackEndpoints: array(string())
+});
+var RecordingSourceAvailabilitySchema = object({
+	state: _enum([
+		"ok",
+		"sleeping",
+		"unreachable",
+		"no-storage",
+		"index-empty"
+	]),
+	/** Free text, shown verbatim. Names the camera's own refusal when there is one. */
+	reason: string().optional(),
+	/** When this source's coverage was last CONFIRMED. A cached answer is never
+	*  drawn as current: the surface shows the age whenever it is older than the
+	*  refresh interval. The clip catalog's `catalogAsOf`, under the name the
+	*  timeline uses for it. */
+	coverageAsOf: number().optional()
+});
+/**
+* One SOURCE of recorded coverage for a camera — a row of the picker.
+*
+* A provider lists the sources IT serves for that device, and answers for each
+* of them whether it can answer at all. A provider with nothing to offer on a
+* camera returns `[]` — it is not that camera's business. The five availability
+* states are `ClipSourceAvailability`'s verbatim: they mean exactly the same
+* things about a coverage index as about a clip catalog, and `sleeping` in
+* particular is what stops a battery camera being woken to paint a bar.
+*/
+var RecordingSourceSchema = object({
+	/** The source id. {@link RECORDING_SOURCE_CAMSTACK} for ours (RESERVED), a
+	*  vendor namespace (`native:reolink:onboard`, …) for a camera's own store. */
+	source: string(),
+	/** Operator-facing name of the source ("CamStack recordings", "SD card"). */
+	label: string(),
+	/**
+	* The addon that SERVES this row, and the value a later call passes as
+	* `provider`.
+	*
+	* Optional for version skew only. The collection dispatcher stamps it from
+	* the registry, so a row that travelled through the fan-out carries the
+	* authoritative id whatever the provider filled in (D557 §4).
+	*/
+	addonId: string().optional(),
+	availability: RecordingSourceAvailabilitySchema
+});
+/**
+* What a surface may DRAW for this (camera, source) — D612's rule applied to a
+* timeline: **the source declares what it can do, and the surface draws what
+* was declared. It never assumes, and never offers a gesture it will then
+* refuse.** D612 exists because `8` and `16` were offered as clip rates, the
+* broker clamped them to `4`, and no line anywhere said so.
+*
+* Asked once per (camera, source) before anything is drawn — never replaced by
+* a constant the surface keeps, which is the second authority D612 ends.
+*/
+var RecordingSourceOptionsSchema = object({
+	/** How this source's media reaches the player.
+	*  `archive` = our own indexed segment tree; `stream` = the provider's
+	*  forward-only fMP4 (D597); `realtime` = a replay bound to wall clock. */
+	transport: _enum([
+		"archive",
+		"stream",
+		"realtime"
+	]),
+	/** What the BAR means. `continuous` = gaps are holes in a recording;
+	*  `sparse` = gaps are the absence of one, and must be drawn as such.
+	*
+	*  Not an onboard-only concession: measured 2026-09-24, OUR bar covers 98.8 %
+	*  of 592's day and 1.2 % of 1436's. It is a fact about a (source, camera)
+	*  pair, and ours answers it per camera from `deriveRecordingMode`. */
+	coverage: _enum(["continuous", "sparse"]),
+	/** Where the playhead may be put.
+	*  `free`    — anywhere, to the frame.
+	*  `forward` — only ahead of the current position.
+	*  `segment` — a position SNAPS to the head of the covering segment; a finer
+	*              ask is accepted by the camera and SILENTLY IGNORED. Measured
+	*              on 1436 (Hikvision V5.7.1, 2026-09-23): a window-narrowed
+	*              `ContentMgmt/search` returns a row and a `playbackURI`, the
+	*              replay opens 200 and delivers media — and the burned-in OSD of
+	*              the first frame reads the SEGMENT HEAD every time. Calling
+	*              that `forward` would tell the surface it may move the playhead
+	*              ahead within a loaded segment, which it may not. */
+	seek: _enum([
+		"free",
+		"forward",
+		"segment"
+	]),
+	/** Frame-step BACKWARD is meaningful. */
+	stepBack: boolean(),
+	/** Whether the drag-scrub gesture is served, as opposed to refused by name. */
+	scrub: boolean(),
+	/** Deliverable rates, ascending, always containing `1`. The surface draws its
+	*  picker from this and from NOTHING else (D612, D620, D621). `0` is not a
+	*  member: pause is the absence of a rate. */
+	rates: array(number().positive()).min(1).readonly(),
+	/** TRUE when a read of this source HOLDS the camera's only playback session.
+	*  A surface with this set makes at most ONE read at a time and draws no
+	*  scrub-thumbnail strip, no hover preview, no prefetch and no background
+	*  refresh. The precedent is exact and expensive: filling one screen of
+	*  Hikvision thumbnails at 1.01× realtime consumed fifteen minutes of that
+	*  camera's only playback session (1.2.126, reported within minutes), and a
+	*  timeline is a screenful of reads by construction. */
+	exclusive: boolean()
+});
+/**
+* How to PLAY the instant that was asked for, from the chosen source.
+*
+* No new media transport is built for onboard sources: the `clip` arm is a
+* DELEGATION to the `videoclips` transport that vendor already has (D597 /
+* D616 / D617). The onboard half of this collection is a PROJECTION of
+* `videoclips` for coverage and a delegation to it for bytes.
+*/
+var RecordingPlaybackSchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("hls"),
+		manifest: RecordingManifestSchema
+	}),
+	object({
+		kind: literal("clip"),
+		/** The `videoclips` source namespace this clip id belongs to. */
+		source: string(),
+		clipId: string(),
+		/** Where this clip actually STARTS. On a `seek: 'segment'` source the
+		*  playhead lands here, not at the requested instant — the surface must be
+		*  TOLD, not left to discover it from a burned-in OSD. */
+		startsAtMs: number()
+	}),
+	object({
+		kind: literal("none"),
+		reason: string()
+	})
+]);
+DeviceType.Camera, method(object({ deviceId: number() }), array(RecordingSourceSchema).readonly(), {
+	kind: "query",
+	auth: "protected"
+}), method(object({
+	deviceId: number(),
+	/**
+	* WHICH provider to ask — the `addonId` a {@link RecordingSourceSchema}
+	* row carries, never a source id and never a list. **REQUIRED**, in the
+	* schema, where the generated types make it unomittable rather than
+	* merely discouraged (D554 amended).
+	*
+	* It was learned the expensive way on `videoclips.listClips`: measured
+	* on the live hub 2026-09-20, device 592 bound to `recorder` AND
+	* `provider-reolink`, a bare call with `limit: 3` answered SIX rows,
+	* three from each source, merged — `device-collection-dispatch.ts`
+	* leaves an unpinned fan-out un-narrowed, so absence buys the union the
+	* method exists not to be. An un-narrowed `getAvailability` would do
+	* that to a TIMELINE: our ranges and the card's clips unioned into one
+	* bar, which is "two sources are never drawn together" broken in the
+	* one place it matters most.
+	*
+	* A provider the device is not bound to is refused BY NAME (D552's
+	* `rejectUnresolvedAddonPin`), never answered by another one.
+	*/
+	provider: string().min(1),
+	fromMs: number(),
+	toMs: number(),
+	/**
+	* Answer for THIS profile instead of the source's preferred one (D433).
+	* Absent keeps the timeline's behaviour — one bar, one profile, one set
+	* of reads. `profilesWithFootage` on the answer says what may be asked
+	* for.
+	*/
+	profile: string().optional()
+}), RecordingAvailabilitySchema, {
+	kind: "query",
+	auth: "protected"
+}), method(object({
+	deviceId: number(),
+	provider: string().min(1),
+	fromMs: number(),
+	toMs: number(),
+	tzOffsetMinutes: number()
+}), RecordingDaysSchema, {
+	kind: "query",
+	auth: "protected"
+}), method(object({
+	deviceId: number(),
+	provider: string().min(1),
+	fromMs: number(),
+	toMs: number(),
+	profile: CamProfileSchema.optional()
+}), RecordingPlaybackSchema, {
+	kind: "query",
+	auth: "protected"
+}), method(object({
+	deviceId: number(),
+	provider: string().min(1)
+}), RecordingSourceOptionsSchema, {
+	kind: "query",
+	auth: "protected"
+});
+/**
+* `recording-archive` — OUR archive, and the intent that fills it.
+*
+* The system-singleton half of the 2026-09-24 cut (D625). `recording` used to
+* be one 33-method system singleton holding two unrelated subjects: three
+* per-camera READS about coverage and playback, and everything else — storage
+* locations, retention, relocation, rebalance, the ops log, the placement
+* table and the byte-plane primitives our scrub and export are built on.
+*
+* The reads became a device-scoped COLLECTION, so a camera's own card can be a
+* source beside ours (`recording.cap.ts`). Everything that is about OUR store,
+* or unimplementable by a camera, stayed here.
+*
+* ## On the name
+*
+* `recording-storage` was the obvious choice and is wrong: this cap also holds
+* `getDeviceConfig`/`setDeviceConfig`, which are recording INTENT — bands,
+* retention, the D62 switch authority — and a name that says "storage" invites
+* the next reader to move them out again. An archive is a thing we keep, and
+* what we keep it under is a policy; the name covers both halves honestly and
+* sits in the existing family (`recording-onboard`, `recording-export`,
+* `recording-signal`).
+*
+* ## What must NOT happen to it
+*
+* It stays a SINGLETON. It is registered by `recorder`, which is
+* `placement: 'any-node'` and runs on every recording node; the hub dispatches
+* to one of them. Putting the ledger, the placement table or the relocation
+* jobs behind a fan-out is the one genuinely dangerous move in this cut.
+*
+* `getDeviceConfig` / `setDeviceConfig` in particular are the D62 recording
+* authority (`CameraSwitch.authority`). If a write reached a different provider
+* than the read — which a collection fan-out permits — two authorities would
+* decide when one camera records, and the symptom (recording silently off, or
+* a `bands` array clobbered by a partial write) is durable and silent. Keeping
+* them here means the worst case during a rollout is a 412: the switch refuses
+* to flip and SAYS so. **Do not move them into the collection, at any point,
+* for any reason.**
+*
+* ## The two batch reads
+*
+* `getAvailabilityBatch` / `getDaysWithRecordingsBatch` take `deviceIds:
+* number[]` with no single `deviceId`, and a device-scoped mount routes
+* through `getProviderForDevice(deviceId)` — there is nothing for it to route
+* on. They stay here, and on this cap the batch is explicitly OURS: a grid has
+* no per-camera picker, and a caller that wants another source's coverage asks
+* `recording.getAvailability` per device with that source's `provider`.
+*/
+var RecordingStatusSchema = object({
+	deviceId: number(),
+	enabled: boolean(),
+	/** THE derived storage mode, from the one definition
+	*  (`deriveRecordingMode`) — never a second enum. A duplicated list is how
+	*  `on-device-decision` could have reached the recorder and not the status. */
+	activeMode: RecordingStorageModeSchema,
+	nodeId: string(),
+	storageBytes: number()
+});
 /**
 * One camera's row in a `getAvailabilityBatch` answer.
 *
-* `ranges` is EXACTLY what `getAvailability` returns for that camera — the
-* batch collapses the transport, not the work — plus the one thing the singular
-* method never had to say:
+* `ranges` is EXACTLY what `recording.getAvailability` returns for that camera
+* at OUR source — the batch collapses the transport, not the work — plus the
+* `read` mark the singular answer now carries too (D625):
 *
 *  - `read: 'read'` — answered. `ranges: []` means "read, and this camera has
 *    no footage in the window", which is a real claim.
@@ -32785,22 +32985,6 @@ var RecordingDaysForDeviceSchema = object({
 	/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
 	days: array(number()).readonly()
 });
-var RecordingManifestSchema = object({
-	deviceId: number(),
-	/** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
-	localMasterPath: string().nullable(),
-	/** HTTP(S) URL to the master playlist on the recording node's playback server
-	*  (the PRIMARY candidate); null when no recording / server. Carries the
-	*  scoped playback token in its path. */
-	playbackUrl: string().nullable(),
-	/**
-	* Candidate master-playlist URLs the client tries in order (LAN first, then
-	* remote — Tailscale/Cloudflare if the operator configured extra hosts), each
-	* carrying the same scoped token. `playbackUrl` is the first entry. Empty when
-	* there is no recording / server.
-	*/
-	playbackEndpoints: array(string())
-});
 /**
 * Recording storage usage for one camera — what the ARCHIVE holds for it,
 * across every profile and every resolvable location on this node.
@@ -33059,34 +33243,12 @@ var ReadWindowBytesResultSchema = discriminatedUnion("kind", [object({
 	segmentEndMs: number()
 })]);
 method(object({
-	deviceId: number(),
-	fromMs: number(),
-	toMs: number(),
-	/**
-	* Answer for THIS profile instead of the preferred one (D433). Absent
-	* keeps the timeline's behaviour — one bar, one profile, one set of
-	* reads. `profilesWithFootage` on the answer says what may be asked
-	* for.
-	*/
-	profile: string().optional()
-}), RecordingAvailabilitySchema, {
-	kind: "query",
-	auth: "protected"
-}), method(object({
 	deviceIds: array(number()).min(1).max(200),
 	fromMs: number(),
 	toMs: number()
 }), array(RecordingAvailabilityForDeviceSchema).readonly(), {
 	kind: "query",
 	auth: "protected"
-}), method(object({
-	deviceId: number(),
-	fromMs: number(),
-	toMs: number(),
-	tzOffsetMinutes: number()
-}), RecordingDaysSchema, {
-	kind: "query",
-	auth: "protected"
 }), method(object({
 	deviceIds: array(number()).min(1).max(200),
 	fromMs: number(),
@@ -33095,13 +33257,6 @@ method(object({
 }), array(RecordingDaysForDeviceSchema).readonly(), {
 	kind: "query",
 	auth: "protected"
-}), method(object({
-	deviceId: number(),
-	fromMs: number(),
-	toMs: number()
-}), RecordingManifestSchema, {
-	kind: "query",
-	auth: "protected"
 }), method(object({}), RecordingStorageUsageSchema, {
 	kind: "query",
 	auth: "admin"
@@ -33549,6 +33704,346 @@ method(object({
 	auth: "protected"
 });
 /**
+* Vendor-neutral **onboard** recording + storage cap — what the CAMERA
+* writes to the CAMERA's own card, on the camera's own schedule.
+*
+* This is NOT `recording.cap.ts`. That one is CamStack's recorder: our
+* footage ledger, our storage locations, our retention. This one has a
+* different authority — the camera's firmware — and per D62 it stores
+* nothing of its own. Every value here is read from the camera and every
+* write goes back to the camera; there is no CamStack-side mirror that
+* could disagree with the device.
+*
+* ## One shape, two firmwares
+*
+* Measured 2026-09-22 against the live fleet:
+*
+* | fact | Hikvision (ISAPI) | Reolink (Baichuan) |
+* | --- | --- | --- |
+* | storage | `ContentMgmt/Storage` `<hdd>` rows: status, capacity, freeSpace (MB) | `getHddInfoList` (cmd 102): `mount`, `format`, `capacity` GB + `capacityM` MB remainder |
+* | tracks | several (101 **and** 103 on both 1436 and 3833), each with its own schedule | one per channel |
+* | schedule | per track, 7 `ScheduleAction` blocks: DayOfWeek + TimeOfDay range + ONE `ActionRecordingMode` | per trigger type, a 168-char weekly HOUR mask |
+* | triggers | `CMR`, `MOTION` | `Normal`, `MD`, `people`, `vehicle`, `dog_cat`, `crossline`, `intrude`, `loitering` |
+* | pre-record | `PreRecordTimeSeconds` | `preRecordTime` |
+* | post-record | `PostRecordTimeSeconds` | `recordDelayTime` |
+* | overwrite | per track `LoopEnable` | `cycle`, with `cycleList` enumerating the accepted values |
+* | segment length | not exposed on V5.7.1 | `packageTime` (minutes) |
+*
+* The two schedule models look different and are the same thing in
+* different coordinates: both answer "for this trigger, during which
+* weekly windows does the camera record". {@link RecordWindow} is that
+* question in one shape — Hikvision's ranges map straight onto it,
+* Reolink's mask expands into hour-aligned windows.
+*
+* ## Union, not intersection
+*
+* **The same fields exist on every camera.** What differs per device is
+* which VALUES that device accepts, and that is what {@link
+* RecordingOnboardOptions} reports — a `{ readable, writable, reason }`
+* per field plus the schedule's own limits. A control a camera cannot
+* honour is rendered DISABLED WITH ITS REASON, never missing and never
+* dead: disabled must not look like broken.
+*
+* ## Refusal by name
+*
+* A write a camera cannot honour is refused with a sentence the operator
+* can read — never accepted and dropped. Both providers refuse through
+* {@link describeOnboardRefusal}, so the vocabulary is one function and
+* one test, not two hand-written vendor opinions.
+*
+* Follows the D14 `deviceConfig` archetype (see `stream-params.cap.ts`):
+* `getOptions` advertises per-camera availability, `getStatus` (auto-
+* injected from `status`) reports the live values, and a single
+* `setSettings` mutation applies a partial change. No hand-written
+* settings-contribution methods.
+*/
+/**
+* What makes the camera start recording during a window.
+*
+* The union of both vendors' vocabularies. `continuous` is Hikvision's
+* `CMR` and Reolink's `Normal`; `motion` is `MOTION` / `MD`. The
+* object-class triggers are Reolink-only today and the smart-event ones
+* (`lineCrossing`, `intrusion`, `loitering`) are Reolink-only on the
+* firmwares measured — a camera that cannot record on a trigger simply
+* does not list it in `options.schedule.triggers`, and a window naming
+* it is REFUSED, not dropped.
+*/
+var RecordTriggerSchema = _enum([
+	"continuous",
+	"motion",
+	"person",
+	"vehicle",
+	"animal",
+	"lineCrossing",
+	"intrusion",
+	"loitering",
+	"alarmInput"
+]);
+/**
+* One weekly recording window: "on `day`, from `startMinute` to
+* `endMinute`, record on `trigger`".
+*
+* `day` is 0 = Monday … 6 = Sunday (ISO order, which is also the order
+* both firmwares enumerate). Minutes are local camera time since
+* midnight; `endMinute` may be 1440, meaning end of day — that is
+* Hikvision's literal `24:00` and Reolink's 24th mask slot, and
+* collapsing it to 0 would turn a whole-day window into an empty one.
+*/
+var RecordWindowSchema = object({
+	trigger: RecordTriggerSchema,
+	day: number().int().min(0).max(6),
+	startMinute: number().int().min(0).max(1439),
+	endMinute: number().int().min(1).max(1440)
+});
+/** Status of one physical volume, as the camera itself describes it. */
+var OnboardStorageVolumeSchema = object({
+	/** The camera's own id for the volume (`hdd/id`, Reolink `HddInfo/number`). */
+	id: string(),
+	/** The camera's own name for it, when it gives one (`hddName`). */
+	label: string().optional(),
+	status: _enum([
+		"ok",
+		"unformatted",
+		"error",
+		"offline",
+		"unknown"
+	]),
+	/**
+	* Total size in MB, or **null when the camera did not say**.
+	*
+	* Never 0 for an unreadable value: a measurement that failed is not a
+	* measurement (D393), and a card whose size is unknown must not be
+	* rendered as a card of size zero.
+	*/
+	capacityMb: number().nullable(),
+	/**
+	* Free space in MB, or null when unknown.
+	*
+	* **Not a proxy for "has footage".** Measured 2026-09-22: 1436 and
+	* 1439 both report exactly 11776 MB free — the fixed reserve a looping
+	* card converges on once it has wrapped. At loop steady state the
+	* number is identical whether the camera recorded yesterday or stopped
+	* a month ago.
+	*/
+	freeMb: number().nullable(),
+	/** True when the camera reports the volume writable (`property` RW). */
+	writable: boolean().optional()
+});
+/**
+* What the camera is doing with its own storage, right now.
+*
+* Every scalar is nullable and **null means the camera did not answer**,
+* never a default. A form that seeds `0` from an unanswered read invites
+* the operator to save that 0 back onto the camera.
+*/
+var RecordingOnboardStatusSchema = object({
+	storage: discriminatedUnion("kind", [
+		object({
+			kind: literal("present"),
+			volumes: array(OnboardStorageVolumeSchema)
+		}),
+		object({
+			kind: literal("absent"),
+			reason: string()
+		}),
+		object({
+			kind: literal("unknown"),
+			reason: string()
+		})
+	]),
+	tracks: array(object({
+		id: string(),
+		enabled: boolean(),
+		isVideo: boolean(),
+		/** From the camera's own track description. Null when it does not say. */
+		codec: string().nullable(),
+		resolution: string().nullable(),
+		/** Per-track overwrite flag, where the firmware keeps it per track. */
+		overwriteWhenFull: boolean().nullable()
+	})),
+	/**
+	* The track the write path targets — the enabled VIDEO one. Null when
+	* no track could be identified, which is itself a refusal reason.
+	*/
+	primaryTrackId: string().nullable(),
+	/** Master "record to the card at all" switch. */
+	enabled: boolean().nullable(),
+	overwriteWhenFull: boolean().nullable(),
+	preRecordSec: number().nullable(),
+	postRecordSec: number().nullable(),
+	/** Length of one recorded file, in minutes. */
+	segmentMinutes: number().nullable(),
+	/** The primary track's weekly windows, flattened. */
+	windows: array(RecordWindowSchema),
+	/**
+	* How many windows the camera described that CamStack could NOT read —
+	* an unrecognised trigger, an unparseable clock, a weekday it does not
+	* name.
+	*
+	* A dropped window is work the reader threw away, and a schedule that
+	* silently shows fewer rows than the camera holds is how an operator
+	* saves back a schedule shorter than the one they were looking at
+	* (D391). Non-zero means the window list is INCOMPLETE and a write
+	* that replaces it would delete what was not shown — which is why a
+	* provider reporting a non-zero count also reports the schedule as not
+	* writable.
+	*/
+	unreadableWindows: number(),
+	/**
+	* The camera is scheduled to record and has NO usable storage.
+	*
+	* A first-class fact because it is the fleet's most common silent
+	* defect: measured 2026-09-22, 1441 and 3831 are both motion-recording
+	* to a card that is not there. Neither the schedule nor the storage
+	* read says anything wrong on its own; only the pair does.
+	*/
+	recordingToNowhere: boolean(),
+	lastFetchedAt: number()
+});
+/** Numeric range descriptor — `{ min, max, step }` per the getOptions convention. */
+var RangeSchema = object({
+	min: number(),
+	max: number(),
+	step: number()
+});
+/**
+* The values a camera actually takes for a numeric field, when they are a SET
+* rather than a range.
+*
+* `{min,max,step}` cannot say what these two firmwares do. Measured on 1436
+* (I91DN) on 2026-09-22 by writing each value and reading it back:
+*
+* - pre-record: `0, 5, 10, 15, 20, 25, 30` and `2147483647` (INT32_MAX, the
+*   camera's "no limit" — `-1` and `4294967295` both land on it);
+* - post-record: `5, 10, 30, 60, 120, 300, 600`.
+*
+* Neither is expressible as a step: the first has a sentinel two billion away
+* from its neighbours, the second doubles and then jumps. A range that tried
+* would forbid values the camera takes AND permit values it silently replaces
+* with 5 — wrong in both directions at once.
+*
+* `sentinel` names the member that is not a duration, so a surface can render
+* "no limit" instead of `2147483647` seconds.
+*/
+var AllowedValuesSchema = object({
+	values: array(number()).min(1),
+	sentinel: object({
+		value: number(),
+		meaning: _enum(["no-limit", "disabled"])
+	}).optional()
+});
+/**
+* Per-field availability on ONE camera.
+*
+* The field exists on every camera — this says whether this one can be
+* read and whether it can be written, and `reason` says why not when
+* either is false. The UI renders the control DISABLED with the reason
+* rather than hiding it, so a limitation is legible instead of looking
+* like a missing feature.
+*/
+var OnboardFieldSupportSchema = object({
+	readable: boolean(),
+	writable: boolean(),
+	/** Required whenever `readable` or `writable` is false. */
+	reason: string().optional()
+});
+/** What this camera's schedule model can express. */
+var OnboardScheduleSupportSchema = object({
+	support: OnboardFieldSupportSchema,
+	/**
+	* The smallest time step the camera can express, in minutes.
+	*
+	* Hikvision takes arbitrary minutes (`00:05:00`–`23:57:00` observed on
+	* 1436's track 103). Reolink's schedule is a 7×24 HOUR mask, so 60. A
+	* window whose edges are not a multiple of this is REFUSED rather than
+	* quietly rounded — rounding is how an operator's 06:30 becomes 06:00
+	* and nothing says so.
+	*/
+	granularityMinutes: number(),
+	/** Triggers this camera can record on. A window naming another is refused. */
+	triggers: array(RecordTriggerSchema),
+	/**
+	* False when the camera stores ONE trigger per time range, so two
+	* windows overlapping on the same day cannot carry different triggers.
+	* True on Reolink, whose mask is per-trigger and independent.
+	*/
+	supportsOverlappingTriggers: boolean()
+});
+var RecordingOnboardOptionsSchema = object({
+	enabled: OnboardFieldSupportSchema,
+	overwriteWhenFull: OnboardFieldSupportSchema,
+	preRecordSec: OnboardFieldSupportSchema,
+	preRecordSecRange: RangeSchema.optional(),
+	/** Preferred over the range when the camera takes a SET, not a span. */
+	preRecordSecAllowed: AllowedValuesSchema.optional(),
+	postRecordSec: OnboardFieldSupportSchema,
+	postRecordSecRange: RangeSchema.optional(),
+	/** Preferred over the range when the camera takes a SET, not a span. */
+	postRecordSecAllowed: AllowedValuesSchema.optional(),
+	segmentMinutes: OnboardFieldSupportSchema,
+	segmentMinutesRange: RangeSchema.optional(),
+	/** Preferred over the range when the camera takes a SET, not a span. */
+	segmentMinutesAllowed: AllowedValuesSchema.optional(),
+	schedule: OnboardScheduleSupportSchema
+});
+/**
+* A partial change. Every field optional.
+*
+* Unlike the other `deviceConfig` caps, a provider here does **NOT**
+* silently ignore a field it cannot support — it refuses, by name,
+* through {@link describeOnboardRefusal}. Silence on a recording setting
+* is the failure D62 exists to prevent: the operator believes the camera
+* is recording the way the form says, and it is not.
+*/
+var RecordingOnboardPatchSchema = object({
+	enabled: boolean().optional(),
+	overwriteWhenFull: boolean().optional(),
+	preRecordSec: number().optional(),
+	postRecordSec: number().optional(),
+	segmentMinutes: number().optional(),
+	/** The complete new window set for the primary track — not a delta. */
+	windows: array(RecordWindowSchema).optional()
+});
+var recordingOnboardCapability = {
+	name: "recording-onboard",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [DeviceType.Camera],
+	deviceConfig: { ui: {
+		kind: "derived-form",
+		builderId: "recording-onboard",
+		tab: "recording"
+	} },
+	methods: {
+		getOptions: method(object({ deviceId: number() }), RecordingOnboardOptionsSchema),
+		setSettings: method(object({
+			deviceId: number(),
+			settings: RecordingOnboardPatchSchema
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		})
+	},
+	status: {
+		schema: RecordingOnboardStatusSchema,
+		kind: "poll"
+	},
+	runtimeState: RecordingOnboardStatusSchema,
+	/**
+	* Runtime-state durability: **restored** — operator-set camera-side
+	* recording config; mutation-driven, and the storage half is the last
+	* thing the camera said about its own card.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "restored",
+	/** Clock fields: written, but excluded from the compare that decides
+	*  whether persisting is worth a SQLite commit. */
+	volatileStateFields: ["lastFetchedAt"]
+};
+/**
 * A camera's own "record me NOW" LEVEL — a signal the device raises while
 * something it knows about is happening (a robot vacuum cleaning, a machine
 * running, a gate open) and lowers when it stops.
@@ -41009,24 +41504,6 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"events.getEventClipUrl": {
-		capName: "events",
-		capScope: "device",
-		addonId: null,
-		access: "view"
-	},
-	"events.getEvents": {
-		capName: "events",
-		capScope: "device",
-		addonId: null,
-		access: "view"
-	},
-	"events.getEventThumbnail": {
-		capName: "events",
-		capScope: "device",
-		addonId: null,
-		access: "view"
-	},
 	"faceGallery.assignFace": {
 		capName: "face-gallery",
 		capScope: "system",
@@ -42347,6 +42824,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"notificationRules.getTemplateCatalog": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"notificationRules.listDeviceMutes": {
 		capName: "notification-rules",
 		capScope: "system",
@@ -42365,6 +42848,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"notificationRules.previewTemplate": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"notificationRules.resolveArtifactUrl": {
 		capName: "notification-rules",
 		capScope: "system",
@@ -43901,224 +44390,236 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"recording.applyDeviceSettingsPatch": {
+	"recording.getAvailability": {
 		capName: "recording",
-		capScope: "system",
+		capScope: "device",
 		addonId: null,
-		access: "create"
+		access: "view"
 	},
-	"recording.cancelRelocateJob": {
+	"recording.getDaysWithRecordings": {
 		capName: "recording",
-		capScope: "system",
+		capScope: "device",
 		addonId: null,
-		access: "create"
+		access: "view"
 	},
-	"recording.cancelStorageMigrationMove": {
+	"recording.getPlayback": {
 		capName: "recording",
-		capScope: "system",
+		capScope: "device",
 		addonId: null,
-		access: "create"
+		access: "view"
 	},
-	"recording.deleteFootprint": {
+	"recording.getPlaybackOptions": {
 		capName: "recording",
-		capScope: "system",
+		capScope: "device",
 		addonId: null,
-		access: "delete"
+		access: "view"
 	},
-	"recording.getAvailability": {
+	"recording.listSources": {
 		capName: "recording",
-		capScope: "system",
+		capScope: "device",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getAvailabilityBatch": {
-		capName: "recording",
+	"recordingArchive.applyDeviceSettingsPatch": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
-		access: "view"
+		access: "create"
 	},
-	"recording.getDaysWithRecordings": {
-		capName: "recording",
+	"recordingArchive.cancelRelocateJob": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
-		access: "view"
+		access: "create"
 	},
-	"recording.getDaysWithRecordingsBatch": {
-		capName: "recording",
+	"recordingArchive.cancelStorageMigrationMove": {
+		capName: "recording-archive",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"recordingArchive.deleteFootprint": {
+		capName: "recording-archive",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"recordingArchive.getAvailabilityBatch": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getDeviceConfig": {
-		capName: "recording",
+	"recordingArchive.getDaysWithRecordingsBatch": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getDeviceLiveContribution": {
-		capName: "recording",
+	"recordingArchive.getDeviceConfig": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getDeviceSettingsContribution": {
-		capName: "recording",
+	"recordingArchive.getDeviceLiveContribution": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getPlacement": {
-		capName: "recording",
+	"recordingArchive.getDeviceSettingsContribution": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getPlaybackManifest": {
-		capName: "recording",
+	"recordingArchive.getPlacement": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getRelocateResidue": {
-		capName: "recording",
+	"recordingArchive.getRelocateResidue": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getStatus": {
-		capName: "recording",
+	"recordingArchive.getStatus": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getStorageMigrationMoveStatus": {
-		capName: "recording",
+	"recordingArchive.getStorageMigrationMoveStatus": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getStorageUsage": {
-		capName: "recording",
+	"recordingArchive.getStorageUsage": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.listOpsLog": {
-		capName: "recording",
+	"recordingArchive.listOpsLog": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.listRelocateJobs": {
-		capName: "recording",
+	"recordingArchive.listRelocateJobs": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.locateSegment": {
-		capName: "recording",
+	"recordingArchive.locateSegment": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.pauseForStorageMigration": {
-		capName: "recording",
+	"recordingArchive.pauseForStorageMigration": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"recording.planStorageRebalance": {
-		capName: "recording",
+	"recordingArchive.planStorageRebalance": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.pruneFootage": {
-		capName: "recording",
+	"recordingArchive.pruneFootage": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"recording.readGopBytes": {
-		capName: "recording",
+	"recordingArchive.readGopBytes": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.readSegmentBytes": {
-		capName: "recording",
+	"recordingArchive.readSegmentBytes": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.readWindowBytes": {
-		capName: "recording",
+	"recordingArchive.readWindowBytes": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.reconcileLedgerAgainstDisk": {
-		capName: "recording",
+	"recordingArchive.reconcileLedgerAgainstDisk": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"recording.refreshStorageLocationsForMigration": {
-		capName: "recording",
+	"recordingArchive.refreshStorageLocationsForMigration": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"recording.relocateFootage": {
-		capName: "recording",
+	"recordingArchive.relocateFootage": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"recording.renderClip": {
-		capName: "recording",
+	"recordingArchive.renderClip": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"recording.renderGif": {
-		capName: "recording",
+	"recordingArchive.renderGif": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"recording.rescanStorage": {
-		capName: "recording",
+	"recordingArchive.rescanStorage": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"recording.resumeForStorageMigration": {
-		capName: "recording",
+	"recordingArchive.resumeForStorageMigration": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"recording.setDeviceConfig": {
-		capName: "recording",
+	"recordingArchive.setDeviceConfig": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"recording.setDevicePlacement": {
-		capName: "recording",
+	"recordingArchive.setDevicePlacement": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"recording.startStorageMigrationMove": {
-		capName: "recording",
+	"recordingArchive.startStorageMigrationMove": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"recording.startStorageRebalance": {
-		capName: "recording",
+	"recordingArchive.startStorageRebalance": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
@@ -45647,6 +46148,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"videoclips.getPlaybackOptions": {
+		capName: "videoclips",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"videoclips.listClips": {
 		capName: "videoclips",
 		capScope: "device",
@@ -45659,6 +46166,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"videoclips.offerClipBytes": {
+		capName: "videoclips",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"videoclips.readClipBytes": {
 		capName: "videoclips",
 		capScope: "device",
@@ -46411,21 +46924,6 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
-	"events.getEventClipUrl": [{
-		name: "deviceId",
-		form: "single",
-		optional: false
-	}],
-	"events.getEvents": [{
-		name: "deviceId",
-		form: "single",
-		optional: false
-	}],
-	"events.getEventThumbnail": [{
-		name: "deviceId",
-		form: "single",
-		optional: false
-	}],
 	"faceGallery.getFaceByTrack": [{
 		name: "deviceId",
 		form: "single",
@@ -47344,107 +47842,117 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
-	"recording.deleteFootprint": [{
+	"recording.getAvailability": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.getAvailability": [{
+	"recording.getDaysWithRecordings": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.getAvailabilityBatch": [{
-		name: "deviceIds",
-		form: "array",
+	"recording.getPlayback": [{
+		name: "deviceId",
+		form: "single",
 		optional: false
 	}],
-	"recording.getDaysWithRecordings": [{
+	"recording.getPlaybackOptions": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.getDaysWithRecordingsBatch": [{
-		name: "deviceIds",
-		form: "array",
+	"recording.listSources": [{
+		name: "deviceId",
+		form: "single",
 		optional: false
 	}],
-	"recording.getDeviceConfig": [{
+	"recordingArchive.deleteFootprint": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.getPlaybackManifest": [{
+	"recordingArchive.getAvailabilityBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
+	"recordingArchive.getDaysWithRecordingsBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
+	"recordingArchive.getDeviceConfig": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.listOpsLog": [{
+	"recordingArchive.listOpsLog": [{
 		name: "deviceId",
 		form: "single",
 		optional: true
 	}],
-	"recording.locateSegment": [{
+	"recordingArchive.locateSegment": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.pruneFootage": [{
+	"recordingArchive.pruneFootage": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.readGopBytes": [{
+	"recordingArchive.readGopBytes": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.readSegmentBytes": [{
+	"recordingArchive.readSegmentBytes": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.readWindowBytes": [{
+	"recordingArchive.readWindowBytes": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.reconcileLedgerAgainstDisk": [{
+	"recordingArchive.reconcileLedgerAgainstDisk": [{
 		name: "deviceId",
 		form: "single",
 		optional: true
 	}],
-	"recording.relocateFootage": [{
+	"recordingArchive.relocateFootage": [{
 		name: "deviceId",
 		form: "single",
 		optional: true
 	}],
-	"recording.renderClip": [{
+	"recordingArchive.renderClip": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.renderGif": [{
+	"recordingArchive.renderGif": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.rescanStorage": [{
+	"recordingArchive.rescanStorage": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.setDeviceConfig": [{
+	"recordingArchive.setDeviceConfig": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.setDevicePlacement": [{
+	"recordingArchive.setDevicePlacement": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.startStorageMigrationMove": [{
+	"recordingArchive.startStorageMigrationMove": [{
 		name: "deviceId",
 		form: "single",
 		optional: true
@@ -47705,6 +48213,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"videoclips.getPlaybackOptions": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"videoclips.listClips": [{
 		name: "deviceId",
 		form: "single",
@@ -47715,6 +48228,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"videoclips.offerClipBytes": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"videoclips.readClipBytes": [{
 		name: "deviceId",
 		form: "single",
@@ -47903,6 +48421,37 @@ var NC_AUDIO_DEFAULTS = {
 };
 new Set(["devices", "classes"]);
 NC_AUDIO_DEFAULTS.hitPercent, NC_AUDIO_DEFAULTS.samplingSeconds;
+var RULE_BODY_ONLY = ["body"];
+var RULE_TEXT = ["title", "body"];
+var BATTERY = ["device-battery-low", "device-battery-normal"];
+var CONSUMABLE = ["device-consumable-low", "device-consumable-normal"];
+var UPDATES = [
+	"addon-update-available",
+	"server-update-available",
+	"wrapper-update-available"
+];
+var PACKAGE_UPDATES = ["addon-update-available", "server-update-available"];
+var ALARM = [
+	"alarm-triggered",
+	"alarm-armed",
+	"alarm-disarmed",
+	"alarm-arming",
+	"alarm-arm-refused"
+];
+var COMBINED_ALARM = ["alarm-triggered"];
+var DEVICE_EVENTS = [
+	"device-online",
+	"device-offline",
+	"device-disabled",
+	"device-enabled",
+	...BATTERY,
+	...CONSUMABLE,
+	"stream-online",
+	"stream-offline",
+	"detection-blind",
+	...ALARM
+];
+[...DEVICE_EVENTS], [...RULE_TEXT], [...COMBINED_ALARM], [...RULE_TEXT], [...COMBINED_ALARM], [...RULE_TEXT], [...RULE_TEXT], [...COMBINED_ALARM], [...RULE_TEXT], [...PACKAGE_UPDATES], [...RULE_TEXT], [...RULE_TEXT], [...COMBINED_ALARM], [...RULE_TEXT], [...COMBINED_ALARM], [...RULE_TEXT], [...COMBINED_ALARM], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_BODY_ONLY], [...RULE_TEXT], [...RULE_TEXT], [...DEVICE_EVENTS], [...RULE_TEXT], [...DEVICE_EVENTS], [...RULE_TEXT], [...BATTERY, ...CONSUMABLE], [...RULE_TEXT], [...CONSUMABLE], [...RULE_TEXT], [...RULE_TEXT], [...UPDATES], [...RULE_TEXT], [...UPDATES], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...UPDATES], [...RULE_TEXT], [...PACKAGE_UPDATES], [...RULE_TEXT], [...PACKAGE_UPDATES], [...RULE_TEXT], [...UPDATES], [...RULE_TEXT], [...UPDATES], [...RULE_TEXT], [...PACKAGE_UPDATES], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT];
 /**
 * TimelapseRule — the STANDALONE scheduled timelapse producer's rule model.
 *
@@ -69713,7 +70262,8 @@ var PROFILE_CONFIGS = {
 			{
 				field: "LEVEL",
 				parameter: "LEVEL",
-				visible: true
+				visible: true,
+				readChannelOffset: -1
 			},
 			{
 				field: "STOP",
@@ -69722,7 +70272,8 @@ var PROFILE_CONFIGS = {
 			{
 				field: "DIRECTION",
 				parameter: "ACTIVITY_STATE",
-				visible: true
+				visible: true,
+				readChannelOffset: -1
 			}
 		]
 	},
@@ -69751,12 +70302,14 @@ var PROFILE_CONFIGS = {
 			{
 				field: "LEVEL",
 				parameter: "LEVEL",
-				visible: true
+				visible: true,
+				readChannelOffset: -1
 			},
 			{
 				field: "LEVEL_2",
 				parameter: "LEVEL_2",
-				visible: true
+				visible: true,
+				readChannelOffset: -1
 			},
 			{
 				field: "STOP",
@@ -69765,7 +70318,8 @@ var PROFILE_CONFIGS = {
 			{
 				field: "DIRECTION",
 				parameter: "ACTIVITY_STATE",
-				visible: true
+				visible: true,
+				readChannelOffset: -1
 			}
 		]
 	},
@@ -69802,29 +70356,75 @@ var CustomEntity = class {
 	primaryChannelAddress;
 	type;
 	#dataPoints;
+	#readDataPoints;
 	#writer;
 	constructor(init) {
 		this.deviceAddress = init.deviceAddress;
 		this.primaryChannelAddress = init.primaryChannelAddress;
 		this.type = init.type;
 		this.#dataPoints = new Map(init.dataPoints);
+		this.#readDataPoints = new Map(init.readDataPoints ?? []);
 		this.#writer = init.writer;
 	}
-	/** The resolved data point for a field, or `undefined` if absent. */
+	/**
+	* The data point a field is READ from — its read binding when it has one,
+	* the command binding otherwise.
+	*
+	* Every getter goes through here; {@link write} deliberately does not, so a
+	* field whose status lives on another channel is still commanded where the
+	* CCU accepts writes.
+	*/
 	dp(field) {
+		return this.#readDataPoints.get(field) ?? this.#dataPoints.get(field);
+	}
+	/** The data point a field is WRITTEN to. Never the read binding. */
+	writeDp(field) {
 		return this.#dataPoints.get(field);
 	}
 	/** The resolved data point for a field; throws if it was not resolved. */
 	requireDp(field) {
-		const dp = this.#dataPoints.get(field);
+		const dp = this.dp(field);
 		if (dp === void 0) throw new DescriptionNotFoundError(`Field ${field} is not available on ${this.kind} entity ${this.primaryChannelAddress}`);
 		return dp;
 	}
 	/** Resolve the data point for a field and route a converted write to it. */
 	async write(field, value) {
-		const dp = this.requireDp(field);
+		const dp = this.writeDp(field);
+		if (dp === void 0) throw new DescriptionNotFoundError(`Field ${field} is not writable on ${this.kind} entity ${this.primaryChannelAddress}`);
 		await this.#writer(dp.dpk.channelAddress, dp.parameter, value);
 	}
+	/**
+	* Every channel this entity touches — command bindings and read bindings —
+	* de-duplicated, in a stable order.
+	*
+	* A consumer that watches events per channel needs this: an HmIP cover reads
+	* its position on the transmitter and is commanded on the virtual receiver,
+	* so filtering events by {@link primaryChannelAddress} alone drops exactly
+	* the reports the entity exists to expose. That happened downstream and cost
+	* an evening — the library resolved the right channel and the consumer threw
+	* its events away.
+	*/
+	get channelAddresses() {
+		const seen = /* @__PURE__ */ new Set();
+		for (const dp of [...this.#dataPoints.values(), ...this.#readDataPoints.values()]) seen.add(dp.dpk.channelAddress);
+		return [...seen];
+	}
+	/**
+	* The channels this entity READS from, when those differ from where it is
+	* commanded. Empty when every field is read where it is written.
+	*
+	* Separate from {@link channelAddresses} because knowing the union is not
+	* enough for a consumer that watches raw parameter events: an HmIP cover
+	* carries `LEVEL` on BOTH the transmitter and the virtual receiver, so
+	* accepting both and taking the last arrival is a coin toss that the
+	* receiver wins — 100 % against a slat at 47.5 %. A parameter available on a
+	* status channel must be taken from THERE and nowhere else.
+	*/
+	get statusChannelAddresses() {
+		const seen = /* @__PURE__ */ new Set();
+		for (const dp of this.#readDataPoints.values()) seen.add(dp.dpk.channelAddress);
+		return [...seen];
+	}
 	/** True when at least one underlying data point was resolved. */
 	get available() {
 		return this.#dataPoints.size > 0;
@@ -69835,7 +70435,12 @@ var CustomEntity = class {
 	*/
 	subscribe(cb) {
 		const unsubscribers = [];
-		for (const dp of this.#dataPoints.values()) unsubscribers.push(dp.subscribe(() => cb()));
+		const seen = /* @__PURE__ */ new Set();
+		for (const dp of [...this.#dataPoints.values(), ...this.#readDataPoints.values()]) {
+			if (seen.has(dp)) continue;
+			seen.add(dp);
+			unsubscribers.push(dp.subscribe(() => cb()));
+		}
 		return () => {
 			for (const unsubscribe of unsubscribers) unsubscribe();
 		};
@@ -70010,8 +70615,14 @@ var DimmerEntity = class extends CustomEntity {
 		return typeof value === "number" ? value : null;
 	}
 };
-var DIRECTION_UP = "UP";
-var DIRECTION_DOWN = "DOWN";
+var TRAVEL_BY_NAME = {
+	UP: "opening",
+	DOWN: "closing",
+	STABLE: "stable",
+	NONE: "stable",
+	UNKNOWN: "unknown",
+	UNDEFINED: "unknown"
+};
 var CoverEntity = class extends CustomEntity {
 	kind = "cover";
 	/** Current position 0..100 from LEVEL, or `null` when unavailable. */
@@ -70019,17 +70630,45 @@ var CoverEntity = class extends CustomEntity {
 		const level = this.level;
 		return level === null ? null : levelToPosition(level);
 	}
-	/** True when the cover is fully closed (LEVEL 0). */
+	/**
+	* True when the cover is fully closed (LEVEL 0).
+	*
+	* `false` here covers BOTH "open" and "LEVEL has not been read yet" — check
+	* {@link currentPosition} for `null` to tell them apart. Kept as a plain
+	* boolean because narrowing it would change every caller's type.
+	*/
 	get isClosed() {
 		return this.level === 0;
 	}
-	/** True while the cover is travelling open (DIRECTION 'UP'). */
+	/**
+	* What the cover is doing, from its travel data point.
+	*
+	* The data point is `ACTIVITY_STATE` on HmIP and `DIRECTION` on RF; the
+	* profile maps whichever one the device has onto {@link Field.DIRECTION}, so
+	* this getter never needs to know which family it is looking at.
+	*
+	* The ENUM arrives already converted to its value-list member (the inbound
+	* converter resolves the CCU's index), so this reads names. A numeric value
+	* means the list could not be resolved: index 0 is the non-travelling member
+	* in both families, 1 is up and 2 is down.
+	*/
+	get travel() {
+		const value = this.dp("DIRECTION")?.value;
+		if (typeof value === "string") return TRAVEL_BY_NAME[value.toUpperCase()] ?? "unknown";
+		if (typeof value === "number") {
+			if (value === 0) return "stable";
+			if (value === 1) return "opening";
+			if (value === 2) return "closing";
+		}
+		return "unknown";
+	}
+	/** True while the cover is travelling open. */
 	get isOpening() {
-		return this.dp("DIRECTION")?.value === DIRECTION_UP;
+		return this.travel === "opening";
 	}
-	/** True while the cover is travelling closed (DIRECTION 'DOWN'). */
+	/** True while the cover is travelling closed. */
 	get isClosing() {
-		return this.dp("DIRECTION")?.value === DIRECTION_DOWN;
+		return this.travel === "closing";
 	}
 	/** Open the cover fully (LEVEL 1). */
 	async open() {
@@ -70113,19 +70752,27 @@ var RfLockEntity = class extends CustomEntity {
 function channelAddress(deviceAddress, channel) {
 	return `${deviceAddress}:${channel}`;
 }
-function resolveFields(device, baseChannel, mappings, defaultOffset, target) {
+function resolveFields(device, baseChannel, mappings, defaultOffset, target, readTarget) {
 	for (const mapping of mappings) {
 		const offset = mapping.channelOffset ?? defaultOffset;
 		const address = channelAddress(device.address, baseChannel + offset);
 		const dp = device.dataPoint(address, mapping.parameter);
 		if (dp !== void 0) target.set(mapping.field, dp);
+		if (mapping.readChannelOffset === void 0) continue;
+		const readAddress = channelAddress(device.address, baseChannel + mapping.readChannelOffset);
+		const readDp = device.dataPoint(readAddress, mapping.parameter);
+		if (readDp !== void 0) readTarget.set(mapping.field, readDp);
 	}
 }
 function buildDataPoints(device, baseChannel, profileConfig) {
 	const dataPoints = /* @__PURE__ */ new Map();
-	resolveFields(device, baseChannel, profileConfig.fields, 0, dataPoints);
-	if (profileConfig.channelFields !== void 0) for (const [offsetKey, mappings] of Object.entries(profileConfig.channelFields)) resolveFields(device, baseChannel, mappings, Number(offsetKey), dataPoints);
-	return dataPoints;
+	const readDataPoints = /* @__PURE__ */ new Map();
+	resolveFields(device, baseChannel, profileConfig.fields, 0, dataPoints, readDataPoints);
+	if (profileConfig.channelFields !== void 0) for (const [offsetKey, mappings] of Object.entries(profileConfig.channelFields)) resolveFields(device, baseChannel, mappings, Number(offsetKey), dataPoints, readDataPoints);
+	return {
+		dataPoints,
+		readDataPoints
+	};
 }
 function buildCustomEntities(device, writer) {
 	const configs = deviceProfileRegistry.getConfigs(device.type);
@@ -70134,7 +70781,7 @@ function buildCustomEntities(device, writer) {
 		const profileConfig = getProfileConfig(config.profile);
 		const primaryOffset = profileConfig.primaryChannel ?? 0;
 		for (const baseChannel of config.channels) {
-			const dataPoints = buildDataPoints(device, baseChannel, profileConfig);
+			const { dataPoints, readDataPoints } = buildDataPoints(device, baseChannel, profileConfig);
 			if (dataPoints.size === 0) continue;
 			const primaryChannelAddress = channelAddress(device.address, baseChannel + primaryOffset);
 			entities.push(new config.entityClass({
@@ -70142,6 +70789,7 @@ function buildCustomEntities(device, writer) {
 				primaryChannelAddress,
 				type: device.type,
 				dataPoints,
+				readDataPoints,
 				writer
 			}));
 		}
@@ -70923,8 +71571,11 @@ function toHmCustomEntity(entity) {
 		kind: entity.kind === "blind" ? "blind" : "cover",
 		device,
 		channel,
+		channels: entity.channelAddresses,
+		statusChannels: entity.statusChannelAddresses,
 		currentPosition: entity.currentPosition,
 		isClosed: entity.isClosed,
+		travel: entity.travel,
 		...entity instanceof BlindEntity ? { currentTiltPosition: entity.currentTiltPosition } : {}
 	};
 	if (entity instanceof IpLockEntity || entity instanceof RfLockEntity) return {
@@ -72886,11 +73537,70 @@ var HmChildDevice = class extends BaseDevice {
 	* Channel-less children (event-emitter, firmware update) span the whole
 	* device by design and accept every channel.
 	*/
+	/**
+	* Every channel this child may accept, ASKED OF THE LIBRARY.
+	*
+	* An HmIP cover reports its position on the SHUTTER_TRANSMITTER channel and
+	* is commanded on a SHUTTER_VIRTUAL_RECEIVER, so the command channel alone
+	* drops exactly the reports the entity exists to expose — measured: the
+	* receiver held 100 % while the slat sat at 47.5 %, and the library's own fix
+	* was invisible here because these events never got past the filter.
+	*
+	* `HmCustomEntity.channels` is the library's answer, so the `-1` offset lives
+	* in ONE place (the profile) rather than being re-spelled here. Falls back to
+	* the command channel alone when the entity cannot be resolved — a narrower
+	* filter is the safe direction: it costs a report, where a wider one lets a
+	* sibling relay write this child's slice.
+	*/
+	ownedChannels() {
+		const owned = this.channel;
+		if (owned === void 0) return [];
+		const declared = this.entityChannels();
+		return declared.all.length > 0 ? declared.all : [owned];
+	}
+	/**
+	* The entity's channels, split into all-of-them and the STATUS ones.
+	*
+	* Both are needed and they answer different questions. `all` is what may be
+	* accepted at all; `status` is where a parameter must be taken FROM when it
+	* exists in both places — `LEVEL` is on an HmIP cover's transmitter AND its
+	* virtual receiver, so merely accepting both and letting the last arrival
+	* win is a coin toss the receiver keeps winning: 100 % against a slat at
+	* 47.5 %. Measured, after widening the filter and before this.
+	*/
+	entityChannels() {
+		const owned = this.channel;
+		const mine = (this.facade?.customEntities() ?? []).find((e) => e.device === this.address && e.channel === owned);
+		if (mine === void 0) return {
+			all: [],
+			status: []
+		};
+		return {
+			all: "channels" in mine ? mine.channels : [],
+			status: "statusChannels" in mine ? mine.statusChannels : []
+		};
+	}
+	/**
+	* Is this (channel, parameter) the one to believe?
+	*
+	* A parameter carried by a STATUS channel is taken only from there. Anything
+	* else passes — a command-only datapoint (`STOP`) has no status twin, and a
+	* device with no split has no status channels at all.
+	*/
+	isPreferredSource(event) {
+		const { status } = this.entityChannels();
+		if (status.length === 0) return true;
+		if (status.includes(event.channel)) return true;
+		return this.resolveHmDevice()?.channels.some((c) => status.includes(c.address) && (c.dataPoints ?? []).some((d) => d.parameter === event.parameter)) !== true;
+	}
 	ownsEventChannel(event) {
 		const owned = this.channel;
 		if (owned === void 0) return true;
 		const channel = event.channel;
-		if (typeof channel === "string" && channel.length > 0) return channel === owned;
+		if (typeof channel === "string" && channel.length > 0) {
+			if (!this.ownedChannels().includes(channel)) return false;
+			return this.isPreferredSource(event);
+		}
 		this.ctx.logger.warn("Homematic value event without a channel — dropped", {
 			tags: { deviceId: this.ctx.id },
 			meta: {
@@ -72918,10 +73628,20 @@ var HmChildDevice = class extends BaseDevice {
 		const device = this.resolveHmDevice();
 		if (device === null) return;
 		const now = Date.now();
+		const accepted = this.ownedChannels();
 		for (const channel of device.channels) {
-			if (channel.address !== this.channel) continue;
+			if (!accepted.includes(channel.address)) continue;
 			for (const dp of channel.dataPoints ?? []) {
 				if (dp.value === null || dp.value === void 0) continue;
+				if (!this.isPreferredSource({
+					dpId: dp.id,
+					device: this.address,
+					channel: channel.address,
+					parameter: dp.parameter,
+					value: dp.value,
+					prevValue: null,
+					ts: now
+				})) continue;
 				handle({
 					dpId: dp.id,
 					device: this.address,
@@ -72981,25 +73701,91 @@ function levelToPercent(level) {
 * lifecycle state.
 */
 function decodeCover(previous, parameter, value, now) {
-	if ((parameter === "LEVEL" || parameter === "LEVEL_STATUS") && typeof value === "number") {
+	if (parameter === "LEVEL" && typeof value === "number") {
 		const position = levelToPercent(value);
 		return {
 			...previous,
 			position,
-			state: position <= 0 ? "closed" : "open",
+			state: isMoving(previous.state) ? previous.state : restingState(position),
 			lastChangedAt: now
 		};
 	}
-	if (parameter === "ACTIVITY_STATE" && typeof value === "number") {
-		const state = value === 1 ? "opening" : value === 2 ? "closing" : previous.state;
+	if (parameter === "ACTIVITY_STATE" || parameter === "DIRECTION") {
+		const travel = readTravel(value);
+		if (travel === "unknown") return null;
+		if (travel === "opening") return {
+			...previous,
+			state: "opening",
+			lastChangedAt: now
+		};
+		if (travel === "closing") return {
+			...previous,
+			state: "closing",
+			lastChangedAt: now
+		};
 		return {
 			...previous,
-			state,
+			state: restingState(previous.position),
 			lastChangedAt: now
 		};
 	}
 	return null;
 }
+/** The two states a cover rests in. `null` position = no intermediate surface;
+*  such a device reports its rest state through LEVEL's 0/1 ends only, so an
+*  unknown position keeps whatever was last known rather than inventing one. */
+function restingState(position) {
+	if (position === null) return "stopped";
+	return position <= 0 ? "closed" : "open";
+}
+/** Is this a MOVE in progress? The two transient states, named once. */
+function isMoving(state) {
+	return state === "opening" || state === "closing";
+}
+/**
+* Read a cover's travel datapoint, whichever of the two it is and in whichever
+* form the library hands it over.
+*
+* Two axes, and getting either wrong costs the whole transient:
+*
+*  - **The PARAMETER differs by family.** HmIP reports travel on
+*    `ACTIVITY_STATE`, classic RF on `DIRECTION` — `nodehomematic`'s profiles
+*    map both onto its own `Field.DIRECTION`. Listening only for
+*    `ACTIVITY_STATE` left every RF cover with no travel at all.
+*  - **The VALUE is a converted string, not the wire index.** The library's
+*    `ValueChangedEvent.value` is documented as "New converted value", and its
+*    inbound ENUM converter maps the CCU's index onto the value-list member.
+*    This decoder tested `typeof value === 'number'`, which a converted ENUM
+*    never is — so the branch never fired and the cover never reported a move.
+*    That is why the operator pressed "down" and saw nothing.
+*
+* Matched BY NAME on purpose. The two value lists differ in their members,
+* not merely their order: measured on this CCU, HmIP's `ACTIVITY_STATE` is
+* `UNKNOWN|UP|DOWN|STABLE` — its rest member is `STABLE` and it carries a
+* fourth meaning, "no opinion", that RF's `NONE|UP|DOWN|UNDEFINED` has no
+* equivalent for. An index mapping would be a guess about a list this code
+* never sees; a name mapping is not.
+*
+* The numeric arm survives only for a datapoint whose value list the library
+* could not resolve. Index 0 is the non-travelling member in BOTH families, so
+* it ends a move; 1 and 2 are up and down in both.
+*/
+function readTravel(value) {
+	if (typeof value === "string") {
+		const v = value.toUpperCase();
+		if (v === "UP" || v === "OPENING") return "opening";
+		if (v === "DOWN" || v === "CLOSING") return "closing";
+		if (v === "STABLE" || v === "NONE" || v === "INACTIVE" || v === "STOP" || v === "STOPPED") return "idle";
+		return "unknown";
+	}
+	if (typeof value === "number") {
+		if (value === 0) return "idle";
+		if (value === 1) return "opening";
+		if (value === 2) return "closing";
+		return "unknown";
+	}
+	return "unknown";
+}
 /**
 * Decode a lock datapoint into a LockControlStatus patch. `LOCK_STATE`
 * is an ENUM (0 unknown, 1 locked, 2 unlocked); `ACTIVITY_STATE`
@@ -73184,6 +73970,15 @@ var HmActuatorDevice = class extends HmChildDevice {
 		}
 		if (cap === "cover") {
 			const next = decodeCover(this.runtimeState.getCapState("cover") ?? COLD_COVER, parameter, value, now);
+			if (next === null && (parameter === "ACTIVITY_STATE" || parameter === "DIRECTION")) this.ctx.logger.warn("Homematic cover: travel value not understood — state unchanged", {
+				tags: { deviceId: this.id },
+				meta: {
+					deviceId: this.id,
+					parameter,
+					value,
+					valueType: typeof value
+				}
+			});
 			if (next) this.runtimeState.setCapState("cover", next);
 			return;
 		}