@camstack/addon-post-analysis 1.2.273 → 1.2.274

package/dist/{dist-m5QdWXqR.js → dist-B9V4PRZO.js}

@@ -5390,7 +5390,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-CaB_hL5g.mjs
+//#region ../types/dist/sleep-PEo0-Fz9.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -6526,6 +6526,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",
@@ -7020,6 +7038,18 @@ function systemMethod(input, output, options) {
 		systemOnly: true
 	};
 }
+/**
+* A method a SOURCE of a collection cap may legitimately not serve — OPTIONAL
+* on `InferProvider`. The `providerOptional: true` literal is what
+* `InferProvider` keys on; see {@link CapabilityMethodSchema.providerOptional}
+* for when this is the honest answer and when it is a soft stub.
+*/
+function optionalMethod(input, output, options) {
+	return {
+		...method(input, output, options),
+		providerOptional: true
+	};
+}
 /** Shorthand to define an event schema */
 function event(data) {
 	return { data };
@@ -7434,7 +7464,7 @@ method(object({ deviceId: number() }), array(StreamSourceEntrySchema)), method(o
 * can answer "may a rule actuate this?" without importing the schema barrel
 * (~144MB RSS per runner, D28).
 *
-* Coverage: 85 device-scoped capabilities.
+* Coverage: 87 device-scoped capabilities.
 */
 var DEVICE_SCOPED_CAPS = new Set([
 	"accessories",
@@ -7462,13 +7492,13 @@ var DEVICE_SCOPED_CAPS = new Set([
 	"cover",
 	"day-night",
 	"detection-pipeline",
+	"device-admin-link",
 	"device-discovery",
 	"device-ops",
 	"device-status",
 	"doorbell",
 	"enum-sensor",
 	"event-emitter",
-	"events",
 	"fan-control",
 	"feature-probe",
 	"flood",
@@ -7500,6 +7530,8 @@ var DEVICE_SCOPED_CAPS = new Set([
 	"ptz",
 	"ptz-autotrack",
 	"reboot",
+	"recording",
+	"recording-onboard",
 	"recording-signal",
 	"scene-monitor",
 	"script-runner",
@@ -7888,7 +7920,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
@@ -7914,7 +7946,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 |
@@ -8030,10 +8062,20 @@ var CameraSwitchAuthoritySchema = discriminatedUnion("kind", [
 var CameraSwitchUnavailableReasonSchema = _enum([
 	"no-provider",
 	"source-unreachable",
-	"not-configured",
 	"device-disabled"
 ]);
 /**
+* Something true about a switch that is nonetheless OFFERED.
+*
+* The distinction from {@link CameraSwitchUnavailableReasonSchema} is the
+* whole point: a reason replaces the control, a warning travels WITH it. The
+* privacy mask taught us the difference — greying the one button that starts
+* the feature teaches the operator the feature is broken, while a live toggle
+* that flips nothing teaches them the switch is broken. Neither is true; the
+* honest surface is a working toggle that says what is missing.
+*/
+var CameraSwitchWarningSchema = _enum(["no-privacy-zones"]);
+/**
 * One switch, resolved for one camera.
 *
 * `label` and `costWhenOff` travel ON THE WIRE rather than being looked up
@@ -8052,6 +8094,11 @@ var CameraSwitchSchema = object({
 	/** False = do not render a control. `unavailableReason` says why. */
 	available: boolean(),
 	unavailableReason: CameraSwitchUnavailableReasonSchema.optional(),
+	/**
+	* Present on an AVAILABLE switch only. Rendered beside the live control;
+	* never a substitute for one.
+	*/
+	warning: CameraSwitchWarningSchema.optional(),
 	/** Current state. Meaningless when `available` is false — read it as `true`. */
 	enabled: boolean(),
 	authority: CameraSwitchAuthoritySchema
@@ -12145,87 +12192,6 @@ method(ListInputSchema, array(BrokerInfoSchema$1)), method(GetInputSchema, Broke
 	auth: "admin"
 }), method(GetStateInputSchema, unknown().nullable()), method(_void(), RegistryStatusSchema);
 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",
@@ -13695,6 +13661,97 @@ 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()
+});
+method(object({ deviceId: number().int().nonnegative() }), DeviceAdminLinkSchema.nullable(), { auth: "admin" });
+/**
 * Identity envelope for a device's upstream-system metadata.
 *
 * Two jobs:
@@ -25748,6 +25805,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());
@@ -26320,6 +26458,7 @@ _enum([
 	"sleeping",
 	"camera-refused",
 	"no-keyframe",
+	"decode-failed",
 	"no-catalog-row",
 	"unsupported",
 	"unknown-device",
@@ -26540,6 +26679,199 @@ var ClipPlaybackSchema = object({
 * which days it asked for and got nothing — "no clips" would be a lie about a
 * card that is full of them.
 */
+/**
+* The operator's authorisation to WAKE a sleeping camera for one clip read.
+*
+* ONE value, absent by default, and it is a `force`-shaped operator signal in
+* exactly the sense `snapshot-wake-gate.ts` uses the word: *"`snapshot.getSnapshot`'s
+* `force` flag, and nothing else… a background caller must never set it…
+* Stale but honest beats woken"*. A scheduler, a retry, a reconcile and a
+* prefetch never set it; a surface sets it only behind the same confirm the
+* "Wake and refresh" gesture uses, and it is refused below 15 % battery
+* exactly as that gesture is.
+*
+* The gate is decided BEFORE `getApi()`, because on UDP the login IS the wake
+* (D549) — a read that opened a session and then checked would have woken the
+* camera to find out it was not allowed to.
+*
+* **One authorised yes is one wake.** `next-natural` — take the clip the next
+* time the camera is awake for its own reasons — is deliberately not a member:
+* it was proposed, it is free on the battery, and the operator declined it on
+* 2026-09-20 (*"Quando un export viene richiesto si sveglia la camera."*,
+* D558 "Considered and not taken").
+*/
+var ClipWakeSchema = _enum(["authorised"]);
+/**
+* A clip's finished bytes, inline — the twin of `recordingExport.readExportBytes`.
+*
+* `bytes` is the DECODED length, so nobody infers it from the base64 length,
+* and `served` says which twin the caller actually got.
+*/
+var ClipBytesSchema = object({
+	base64: string(),
+	contentType: string(),
+	/** Suggested filename, extension included. */
+	name: string(),
+	bytes: number().int().nonnegative(),
+	/**
+	* Which twin was actually served — the same contract
+	* {@link ClipPlaybackSchema.served} carries, and REQUIRED here because the
+	* export record persists it: a row read a week later must say the same thing
+	* the panel said at the moment of the tap. A missing main twin is never
+	* served silently as if it were the asked-for quality (D549 15).
+	*/
+	served: CamProfileSchema,
+	/**
+	* The DECODED duration of the delivered file, when the fetch measured one.
+	*
+	* A clip fetch verifies its own completion against the catalog row and
+	* retries a materially short pass (D568); this is that measurement, carried
+	* so a consumer can say the same thing rather than re-deriving it. Absent
+	* when the producer did not measure — never zero, which would say the file
+	* is empty.
+	*/
+	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}.
+*
+* `url` is plain `http://` on the provider's own token-gated listener, one
+* shot, short-lived. It is NOT the hub-proxied `/addon/<id>/clip-stream/…`
+* path: that plane takes only a user credential, which an addon does not
+* hold, and the framework offers no addon→addon byte transport — the one
+* precedent is the broker's own restream URLs (`getStreamWithCodec`), which
+* a consumer dials directly, and this is that precedent one addon over.
+*/
+/**
+* The audio a clip stream can be asked for, and the audio it carries.
+*
+* The camera stores AAC and no WebRTC session speaks it, so a stream that
+* carries sound carries it TRANSCODED, muxed as a second track beside the
+* video by the one ffmpeg the provider already runs (D600). `opus` is
+* 48 kHz mono, `pcmu` is 8 kHz µ-law — the two codecs a broker session
+* negotiates — and `none` is a stream asked for, or served, without sound.
+*/
+var ClipStreamAudioSchema = _enum([
+	"opus",
+	"pcmu",
+	"none"
+]);
+/**
+* Why a stream that was ASKED for sound is not carrying it (D600).
+*
+* Only ever set beside `servedAudio: 'none'` after a non-`none` ask. Absent
+* means the ask was honoured, or there was no ask.
+*
+* - `not-requested` — the caller asked for `none`.
+* - `unsupported-ask` — the provider cannot produce that codec.
+*
+* Whether the RECORDING has sound at all is not knowable here: the camera
+* declares no audio track before its first frame arrives. That answer is in
+* the stream itself — an fMP4 with no audio track — and the broker reads it
+* there. A dial that says `opus` promises the codec, never the content.
+*/
+var ClipStreamAudioReasonSchema = _enum(["not-requested", "unsupported-ask"]);
+var ClipStreamDialSchema = object({
+	url: string().min(1),
+	/** After this the token is gone and the URL answers 404 `dial-expired`. */
+	expiresAtMs: number(),
+	/** What the stream IS — a consumer that cannot honour it must not dial. */
+	transport: literal("forward-only"),
+	/**
+	* Which twin the stream ACTUALLY carries — not what was asked for.
+	*
+	* The stream serves every profile (D599), and a recording whose main twin
+	* does not exist is streamed as its sub copy, which this field reports as
+	* `low`. That is the whole reason the dial no longer refuses `high`:
+	* stating what was served is what makes accepting honest, where a silent
+	* substitution would be the 33x lie D576 forbids. Stated rather than
+	* assumed, the way {@link ClipPlaybackSchema.served} is (D549 15).
+	*/
+	served: CamProfileSchema,
+	/**
+	* Which audio the stream will ACTUALLY carry — `served`'s companion for
+	* sound, and the same reasoning (D599, D600).
+	*
+	* The broker asks for the codec its WebRTC session negotiated, and the
+	* provider either muxes that codec or carries none. Stating it is what
+	* lets the broker wire the matching sink before the first byte, and what
+	* keeps a session from being handed a codec it cannot send — the audio
+	* shape of the substitution `served` exists to prevent.
+	*
+	* It is a promise about the CODEC, not about the content: a recording with
+	* no microphone track answers `opus` here and then arrives with no audio
+	* track at all. That second answer is in the stream, and the broker reads
+	* it from the `moov`.
+	*/
+	servedAudio: ClipStreamAudioSchema,
+	/** 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",
@@ -26596,22 +26928,40 @@ DeviceType.Camera, method(object({
 	limit: number().int().positive().optional(),
 	/**
 	* WHICH provider to ask — the `addonId` a {@link ClipSourceSchema} row
-	* carries, never a source id and never a list.
-	*
-	* Absent means the device's BOUND provider, which is CamStack on every
-	* camera today because that is what `deviceManager.getBindings`
-	* answers with. A provider the device is not bound to is refused by
-	* name rather than answered by another one (D552's
-	* `rejectUnresolvedAddonPin` rule).
+	* carries, never a source id and never a list. **Required** (D554 amended).
+	*
+	* A provider the device is not bound to is refused by name rather than
+	* answered by another one (D552's `rejectUnresolvedAddonPin` rule).
+	*
+	* It was optional, documented as "absent means the device's BOUND
+	* provider, which is CamStack on every camera". No code implemented
+	* that. 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 newest-first:
+	* `device-collection-dispatch.ts` simply left the fan-out un-narrowed,
+	* so absence bought the union this method exists not to be, and
+	* `limit` meant `limit × sources`.
+	*
+	* There is nothing to restore the default to. `getBindings` answers a
+	* collection cap with a DERIVED, PLURAL set (D554 amended, step 0);
+	* `setWrapperActive` — the singleton authority that could name one —
+	* throws for a collection cap by design. Naming CamStack here instead
+	* would privilege one addon by id inside a surface whose premise is
+	* that sources are peers, and would be wrong on the first camera with
+	* no recorder binding. So absence is REFUSED, in the schema, where the
+	* generated types make it unomittable rather than merely discouraged.
+	*
+	* The default belongs to the SURFACE, which has the `listSources` rows
+	* and can say which one it picked (D569 § 1–3; the viewer already
+	* always sends this).
 	*
 	* It replaced `sources?: string[]`, a VIEW filter over source ids that
 	* assumed the answer was a fan-out over everything a camera has. The
-	* operator settled otherwise on 2026-09-20 — *"il get videoclips
-	* prendere un provider opzionale, di default va su camstack"*,
-	* *"l'utilizzatore è uno solo"* — so the list is asked of one provider
-	* at a time and there is nothing to filter out of it.
+	* operator settled otherwise on 2026-09-20 — *"l'utilizzatore è uno
+	* solo"* — so the list is asked of one provider at a time and there is
+	* nothing to filter out of it.
 	*/
-	provider: string().optional()
+	provider: string().min(1)
 }), array(ClipSchema).readonly(), {
 	kind: "query",
 	auth: "protected"
@@ -26637,6 +26987,103 @@ DeviceType.Camera, method(object({
 }), ClipPlaybackSchema, {
 	kind: "query",
 	auth: "protected"
+}), optionalMethod(object({
+	deviceId: number(),
+	clipId: string().min(1),
+	/**
+	* WHICH provider holds the bytes — the `addonId` a
+	* {@link ClipSourceSchema} row carries. **Required**, for the reason
+	* `listClips` states one method above and for a second one this method
+	* learned the hard way.
+	*
+	* The caller is the stream broker, and the broker lives in
+	* `addon-pipeline` — the same addon that registers the RECORDER's
+	* videoclips provider. With no provider named, the in-process
+	* resolution handed it its own sibling, which implements this method
+	* solely to explain that an analytics visit has no file behind it. So
+	* every onboard clip answered with that sentence, a flash of video and
+	* nothing more, while the SAME call from outside the addon reached the
+	* right provider and returned the bytes (measured on 3628,
+	* 2026-09-21).
+	*/
+	provider: string().min(1),
+	/**
+	* Which twin to fetch, on the mapping D549 15 already fixed:
+	* `low | mid` → the sub file, `high` → the main twin. `auto` is not
+	* accepted here for the same reason it is not accepted by
+	* `getClipPlayback` — a stored file has no broker session, so the
+	* adaptive tier cannot be resolved for it.
+	*/
+	profile: CamProfileSchema.optional(),
+	/**
+	* The CALLER's byte bound, so an over-size clip is refused before it is
+	* read and encoded rather than after. Capped by
+	* {@link VIDEOCLIPS_MAX_READ_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()
+}), 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),
+	/** WHICH provider holds the camera — see `readClipBytes.provider`. */
+	provider: string().min(1),
+	/** Which twin — `high` → the main file, everything else the sub (D599). */
+	profile: CamProfileSchema.optional(),
+	/**
+	* Which audio codec the caller's session negotiated, so the provider
+	* can mux it (D600). The ask travels on the DIAL because the mux is
+	* spawned once, before the first byte, and cannot gain a track later.
+	*
+	* ABSENT IS `none`, never a guess: a caller that does not state an
+	* ask is served the video-only stream that shipped first, so a broker
+	* older than this field keeps working unchanged (D382 — an unstated
+	* ask is zero).
+	*/
+	audio: ClipStreamAudioSchema.optional()
+}), 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
@@ -27997,6 +28444,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.
 */
@@ -29017,30 +29601,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(),
@@ -31357,143 +31917,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
@@ -33890,37 +34313,40 @@ 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()
-});
+/** The one addon allowed to serve {@link RECORDING_SOURCE_CAMSTACK}: the
+*  recorder, which is the addon that writes the footage (D560). */
+var RECORDING_SOURCE_CAMSTACK_ADDON = "recorder";
 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
@@ -33937,15 +34363,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.
@@ -33977,22 +34673,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.
@@ -34251,34 +34931,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(),
@@ -34287,19 +34945,12 @@ 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"
 }), method(object({ deviceId: number() }), RecordingConfigSchema, {
 	kind: "query",
-	auth: "admin"
+	auth: "protected"
 }), method(object({
 	deviceId: number(),
 	profile: string(),
@@ -34529,13 +35180,101 @@ var ExportStateSchema = _enum([
 	"expired",
 	"deleted"
 ]);
-/** One export job / history row. */
+/**
+* WHAT an export is — the authority, as opposed to the four top-level fields
+* the Library sorts and labels on (D558 § 2.2).
+*
+* Read it through {@link exportSubjectOf}, never off the record directly: the
+* field is optional for the history rows written before it existed, and that
+* absence has exactly one interpreter.
+*/
+var ExportSubjectSchema = discriminatedUnion("kind", [object({
+	kind: literal("footage"),
+	deviceId: number(),
+	profiles: array(string()).min(1),
+	fromMs: number(),
+	toMs: number()
+}), object({
+	kind: literal("clip"),
+	deviceId: number(),
+	provider: string().min(1),
+	source: string().min(1),
+	sourceLabel: string().min(1),
+	clipId: string().min(1),
+	/**
+	* WHERE IN THE CATALOG to confirm this clip — the day window the surface was
+	* already listing when the operator picked the segment.
+	*
+	* It is **not** a time range control and it never becomes one: the record's
+	* `fromMs`/`toMs` come from the catalog ROW and from nothing a caller
+	* supplied (D558 § 5.4.3), and a window that does not contain the clip is a
+	* `catalog-miss`, not a silently wider search. It exists because
+	* `videoclips.listClips` takes `since`/`until` and has no by-handle twin:
+	* the catalog check D558 asks for is literally that call, and a call needs a
+	* window. The surface has one — `ClipsBrowser`'s `dayWindow`, one local
+	* wall-clock day, which is also the only width measured to be cheap (one
+	* day on 592 lists 171 clips in 712 ms, a busy day 546 in 2.0 s; twenty days
+	* of one child's events took 3.6–5.4 s).
+	*/
+	catalogWindow: object({
+		sinceMs: number(),
+		untilMs: number()
+	}),
+	profile: _enum([
+		"high",
+		"mid",
+		"low"
+	]),
+	/**
+	* The operator's authorisation to wake a sleeping camera for this export.
+	* ONE definition, in the cap that owns the clip read ({@link ClipWakeSchema}),
+	* because the gate that honours it is the clip provider's sleep gate — a
+	* second enum here would be a second contract. Absent by default; never
+	* settable by a scheduler or a retry.
+	*
+	* **One authorised yes is ONE wake.** A failed clip export is retried only by
+	* an operator act that asks again; a queued job that outlived its wake fails
+	* with a reason rather than waking on its turn; and this subject carries
+	* exactly one profile precisely so one tap is never two fetches (D558 § 5.2).
+	*/
+	wake: ClipWakeSchema.optional()
+})]);
+/**
+* One export job / history row.
+*
+* **`subject` is the AUTHORITY on what was exported. `deviceId`, `profile`,
+* `fromMs` and `toMs` are its PROJECTION** — kept top-level because the whole
+* Library sorts and labels on them (`library-items.ts` orders an export by
+* `fromMs`; `export-format.ts` draws `rangeLabel` from the pair), and a row
+* that did not fill them would sort under the epoch and render a blank range.
+* Write to the subject and read from the projection and the two will disagree;
+* the projection is derived at creation and never edited afterwards.
+*
+* And they mean DIFFERENT FACTS for the two kinds, which is the part a reader
+* who knows only the recording export will get wrong:
+*
+* | field | `kind:'footage'` | `kind:'clip'` |
+* | --- | --- | --- |
+* | `fromMs`/`toMs` | the stretch the operator ASKED for | the camera's own boundaries, always `clip.timeRange`, never anything a caller supplied |
+* | `profile` | the stream rendered | the twin actually SERVED (`subject.profile` is the one asked for) |
+*
+* Same type, different fact — the shape this repo keeps getting wrong (D385's
+* two authorities, D224's second copy).
+*/
 var ExportRecordSchema = object({
 	id: string(),
 	deviceId: number(),
 	profile: string(),
 	fromMs: number(),
 	toMs: number(),
+	/**
+	* What this export IS. Optional ONLY for the rows written before D558: the
+	* store parses every row through this schema on every read, so a required
+	* field would make the export AUDIT — which is the whole reason rows survive
+	* file deletion — unreadable in one release. Absence means `footage`, and
+	* {@link exportSubjectOf} is the one place that says so.
+	*/
+	subject: ExportSubjectSchema.optional(),
 	options: ExportOptionsSchema,
 	state: ExportStateSchema,
 	/** 0–100 while rendering; null otherwise. */
@@ -34552,6 +35291,18 @@ var ExportRecordSchema = object({
 	/** Failure reason when state is 'failed'; null otherwise. */
 	error: string().nullable()
 });
+_enum([
+	"catalog-miss",
+	"catalog-unreachable",
+	"no-file-for-window",
+	"clip-in-progress",
+	"unsupported-option",
+	"sleeping",
+	"camera-refused",
+	"fetch-failed",
+	"too-large-to-transfer",
+	"wake-expired"
+]);
 /** Candidate download URLs (LAN first, then operator extra hosts). */
 var ExportDownloadSchema = object({
 	url: string(),
@@ -34589,16 +35340,50 @@ var ExportBytesSchema = object({
 	name: string(),
 	bytes: number().int().nonnegative()
 });
+/** Canonical `profiles[]`, falling back to the legacy singular `profile`. */
+function resolveExportProfiles(input) {
+	if (input.profiles !== void 0 && input.profiles.length > 0) return [...input.profiles];
+	if (typeof input.profile === "string" && input.profile.length > 0) return [input.profile];
+	return [];
+}
 method(object({
 	deviceId: number(),
 	/** @deprecated Prefer `profiles`. Kept so timelapse/notifiers keep working. */
 	profile: string().optional(),
 	profiles: array(string()).min(1).optional(),
-	fromMs: number(),
-	toMs: number(),
+	/** Footage only — a clip's boundaries are the camera's. */
+	fromMs: number().optional(),
+	toMs: number().optional(),
+	/** What to export. Absent means the legacy flat footage request. */
+	subject: ExportSubjectSchema.optional(),
 	options: ExportOptionsSchema
 }).superRefine((v, ctx) => {
-	if ((v.profiles !== void 0 && v.profiles.length > 0 ? v.profiles : v.profile !== void 0 ? [v.profile] : []).length < 1) ctx.addIssue({
+	if (v.subject?.kind === "clip") {
+		if (v.subject.deviceId !== v.deviceId) ctx.addIssue({
+			code: ZodIssueCode.custom,
+			message: `subject.deviceId (${v.subject.deviceId}) must equal deviceId (${v.deviceId}) — the top-level field is what per-device scope enforcement reads`,
+			path: ["subject", "deviceId"]
+		});
+		if (v.fromMs !== void 0 || v.toMs !== void 0) ctx.addIssue({
+			code: ZodIssueCode.custom,
+			message: "a clip export asks for no time range: the camera chose the boundaries and they are read from the catalog row",
+			path: ["fromMs"]
+		});
+		return;
+	}
+	if (v.subject?.kind === "footage" && v.subject.deviceId !== v.deviceId) ctx.addIssue({
+		code: ZodIssueCode.custom,
+		message: `subject.deviceId (${v.subject.deviceId}) must equal deviceId (${v.deviceId})`,
+		path: ["subject", "deviceId"]
+	});
+	const fromMs = v.subject?.kind === "footage" ? v.subject.fromMs : v.fromMs;
+	const toMs = v.subject?.kind === "footage" ? v.subject.toMs : v.toMs;
+	if (typeof fromMs !== "number" || typeof toMs !== "number") ctx.addIssue({
+		code: ZodIssueCode.custom,
+		message: "a footage export needs fromMs and toMs",
+		path: ["fromMs"]
+	});
+	if ((v.subject?.kind === "footage" ? [...v.subject.profiles] : resolveExportProfiles(v)).length < 1) ctx.addIssue({
 		code: ZodIssueCode.custom,
 		message: "pass profiles[] (min 1) or legacy profile",
 		path: ["profiles"]
@@ -34626,6 +35411,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.
@@ -37610,6 +38735,7 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	pressureSensor: pressureSensorCapability,
 	privacyMask: privacyMaskCapability,
 	ptzAutotrack: ptzAutotrackCapability,
+	recordingOnboard: recordingOnboardCapability,
 	recordingSignal: recordingSignalCapability,
 	sceneMonitor: sceneMonitorCapability,
 	scriptRunner: scriptRunnerCapability,
@@ -38353,7 +39479,1336 @@ var DeclaredDevices = class {
 DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Camera, DeviceType.Hub, DeviceType.Switch, DeviceType.Siren, DeviceType.Light, DeviceType.Fan, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder;
 new Set(Object.values(DeviceType));
 DeviceFeature.BatteryOperated;
+/**
+* The vocabulary, in the order a picker offers it.
+*
+* Adding a key here is not enough to make it pickable: both glyph tables must
+* gain it too, and their tests fail until they do. That is the intended
+* friction — it is the only thing that keeps the two surfaces honest.
+*/
+var DISPLAY_ICON_VOCABULARY = [
+	{
+		key: "camera",
+		group: "device",
+		synonyms: [
+			"telecamera",
+			"videocamera",
+			"camera",
+			"cam"
+		]
+	},
+	{
+		key: "network",
+		group: "device",
+		synonyms: [
+			"rete",
+			"network",
+			"lan"
+		]
+	},
+	{
+		key: "toggle-left",
+		group: "device",
+		synonyms: [
+			"interruttore",
+			"switch",
+			"toggle"
+		]
+	},
+	{
+		key: "toggle-right",
+		group: "device",
+		synonyms: [
+			"interruttore",
+			"switch",
+			"toggle",
+			"acceso"
+		]
+	},
+	{
+		key: "circle-dot",
+		group: "device",
+		synonyms: [
+			"pulsante",
+			"bottone",
+			"button",
+			"dot"
+		]
+	},
+	{
+		key: "refresh-cw",
+		group: "device",
+		synonyms: [
+			"aggiorna",
+			"ricarica",
+			"refresh",
+			"reload",
+			"ciclo"
+		]
+	},
+	{
+		key: "box",
+		group: "device",
+		synonyms: [
+			"scatola",
+			"box",
+			"contenitore"
+		]
+	},
+	{
+		key: "scroll-text",
+		group: "device",
+		synonyms: [
+			"registro",
+			"log",
+			"testo"
+		]
+	},
+	{
+		key: "workflow",
+		group: "device",
+		synonyms: [
+			"automazione",
+			"flusso",
+			"workflow",
+			"scenario"
+		]
+	},
+	{
+		key: "lock",
+		group: "device",
+		synonyms: [
+			"serratura",
+			"chiave",
+			"lucchetto",
+			"chiuso",
+			"locked"
+		]
+	},
+	{
+		key: "lock-open",
+		group: "device",
+		synonyms: [
+			"serratura",
+			"aperta",
+			"sbloccato",
+			"unlocked"
+		]
+	},
+	{
+		key: "blinds",
+		group: "device",
+		synonyms: [
+			"tapparella",
+			"persiana",
+			"serranda",
+			"avvolgibile",
+			"shutter",
+			"blind",
+			"veneziana"
+		]
+	},
+	{
+		key: "air-vent",
+		group: "device",
+		synonyms: [
+			"bocchetta",
+			"aria",
+			"ventilazione",
+			"condizionatore",
+			"vent"
+		]
+	},
+	{
+		key: "monitor-play",
+		group: "device",
+		synonyms: [
+			"schermo",
+			"riproduzione",
+			"player",
+			"display"
+		]
+	},
+	{
+		key: "sliders-horizontal",
+		group: "device",
+		synonyms: [
+			"regolazione",
+			"cursori",
+			"impostazioni",
+			"slider"
+		]
+	},
+	{
+		key: "map-pin",
+		group: "device",
+		synonyms: [
+			"posizione",
+			"luogo",
+			"mappa",
+			"pin"
+		]
+	},
+	{
+		key: "bot",
+		group: "device",
+		synonyms: [
+			"robot",
+			"aspirapolvere",
+			"bot"
+		]
+	},
+	{
+		key: "tractor",
+		group: "device",
+		synonyms: [
+			"trattore",
+			"tosaerba",
+			"giardino"
+		]
+	},
+	{
+		key: "image",
+		group: "device",
+		synonyms: [
+			"immagine",
+			"foto",
+			"snapshot"
+		]
+	},
+	{
+		key: "bone",
+		group: "device",
+		synonyms: ["osso", "cane"]
+	},
+	{
+		key: "door-closed",
+		group: "device",
+		synonyms: [
+			"porta",
+			"chiusa",
+			"contatto"
+		]
+	},
+	{
+		key: "door-open",
+		group: "device",
+		synonyms: [
+			"porta",
+			"aperta",
+			"contatto",
+			"ingresso",
+			"uscita"
+		]
+	},
+	{
+		key: "crosshair",
+		group: "device",
+		synonyms: [
+			"mirino",
+			"puntamento",
+			"centro"
+		]
+	},
+	{
+		key: "eye",
+		group: "device",
+		synonyms: [
+			"occhio",
+			"visibile",
+			"visto"
+		]
+	},
+	{
+		key: "eye-off",
+		group: "device",
+		synonyms: [
+			"privacy",
+			"nascosto",
+			"oscurato",
+			"mascherato",
+			"invisibile"
+		]
+	},
+	{
+		key: "smartphone",
+		group: "device",
+		synonyms: [
+			"telefono",
+			"cellulare",
+			"smartphone"
+		]
+	},
+	{
+		key: "phone",
+		group: "device",
+		synonyms: ["telefono", "chiamata"]
+	},
+	{
+		key: "tablet",
+		group: "device",
+		synonyms: ["tablet", "ipad"]
+	},
+	{
+		key: "laptop",
+		group: "device",
+		synonyms: [
+			"portatile",
+			"laptop",
+			"notebook"
+		]
+	},
+	{
+		key: "monitor",
+		group: "device",
+		synonyms: ["monitor", "schermo"]
+	},
+	{
+		key: "tv",
+		group: "device",
+		synonyms: ["televisore", "tv"]
+	},
+	{
+		key: "speaker",
+		group: "device",
+		synonyms: [
+			"altoparlante",
+			"cassa",
+			"speaker"
+		]
+	},
+	{
+		key: "printer",
+		group: "device",
+		synonyms: ["stampante"]
+	},
+	{
+		key: "projector",
+		group: "device",
+		synonyms: ["proiettore"]
+	},
+	{
+		key: "gamepad-2",
+		group: "device",
+		synonyms: [
+			"console",
+			"gioco",
+			"joystick"
+		]
+	},
+	{
+		key: "radio",
+		group: "device",
+		synonyms: ["radio"]
+	},
+	{
+		key: "router",
+		group: "device",
+		synonyms: ["router", "modem"]
+	},
+	{
+		key: "bluetooth",
+		group: "device",
+		synonyms: ["bluetooth"]
+	},
+	{
+		key: "cpu",
+		group: "device",
+		synonyms: [
+			"processore",
+			"cpu",
+			"chip",
+			"dispositivo"
+		]
+	},
+	{
+		key: "hard-drive",
+		group: "device",
+		synonyms: [
+			"disco",
+			"hdd",
+			"archiviazione",
+			"storage"
+		]
+	},
+	{
+		key: "server",
+		group: "device",
+		synonyms: ["server", "nas"]
+	},
+	{
+		key: "mic",
+		group: "device",
+		synonyms: ["microfono", "audio"]
+	},
+	{
+		key: "mic-off",
+		group: "device",
+		synonyms: [
+			"microfono",
+			"spento",
+			"muto"
+		]
+	},
+	{
+		key: "video",
+		group: "device",
+		synonyms: ["video"]
+	},
+	{
+		key: "video-off",
+		group: "device",
+		synonyms: ["video", "spento"]
+	},
+	{
+		key: "music",
+		group: "device",
+		synonyms: ["musica"]
+	},
+	{
+		key: "plug",
+		group: "device",
+		synonyms: [
+			"presa",
+			"spina",
+			"plug"
+		]
+	},
+	{
+		key: "plug-zap",
+		group: "device",
+		synonyms: ["presa", "alimentata"]
+	},
+	{
+		key: "power",
+		group: "device",
+		synonyms: [
+			"accensione",
+			"alimentazione",
+			"power"
+		]
+	},
+	{
+		key: "power-off",
+		group: "device",
+		synonyms: ["spegnimento", "spento"]
+	},
+	{
+		key: "cable",
+		group: "device",
+		synonyms: ["cavo"]
+	},
+	{
+		key: "battery",
+		group: "device",
+		synonyms: ["batteria"]
+	},
+	{
+		key: "battery-charging",
+		group: "device",
+		synonyms: [
+			"batteria",
+			"carica",
+			"ricarica"
+		]
+	},
+	{
+		key: "battery-full",
+		group: "device",
+		synonyms: [
+			"batteria",
+			"carica",
+			"piena"
+		]
+	},
+	{
+		key: "battery-low",
+		group: "device",
+		synonyms: ["batteria", "scarica"]
+	},
+	{
+		key: "key",
+		group: "device",
+		synonyms: ["chiave"]
+	},
+	{
+		key: "key-round",
+		group: "device",
+		synonyms: ["chiave", "tonda"]
+	},
+	{
+		key: "mailbox",
+		group: "device",
+		synonyms: [
+			"cassetta",
+			"postale",
+			"posta"
+		]
+	},
+	{
+		key: "package",
+		group: "device",
+		synonyms: ["pacco", "consegna"]
+	},
+	{
+		key: "shield",
+		group: "device",
+		synonyms: [
+			"scudo",
+			"protezione",
+			"sicurezza",
+			"allarme"
+		]
+	},
+	{
+		key: "shield-check",
+		group: "device",
+		synonyms: [
+			"protetto",
+			"sicuro",
+			"armato"
+		]
+	},
+	{
+		key: "shield-off",
+		group: "device",
+		synonyms: [
+			"protezione",
+			"disattivata",
+			"disarmato"
+		]
+	},
+	{
+		key: "briefcase",
+		group: "device",
+		synonyms: [
+			"ufficio",
+			"lavoro",
+			"valigetta",
+			"studio"
+		]
+	},
+	{
+		key: "lightbulb",
+		group: "lighting",
+		synonyms: [
+			"luce",
+			"lampadina",
+			"lampada",
+			"light"
+		]
+	},
+	{
+		key: "lamp",
+		group: "lighting",
+		synonyms: ["lampada", "abatjour"]
+	},
+	{
+		key: "lamp-ceiling",
+		group: "lighting",
+		synonyms: [
+			"plafoniera",
+			"lampadario",
+			"luce",
+			"soffitto"
+		]
+	},
+	{
+		key: "lamp-desk",
+		group: "lighting",
+		synonyms: [
+			"lampada",
+			"scrivania",
+			"abatjour"
+		]
+	},
+	{
+		key: "lamp-floor",
+		group: "lighting",
+		synonyms: [
+			"piantana",
+			"lampada",
+			"terra"
+		]
+	},
+	{
+		key: "flashlight",
+		group: "lighting",
+		synonyms: [
+			"faretto",
+			"torcia",
+			"spot",
+			"faro"
+		]
+	},
+	{
+		key: "heater",
+		group: "lighting",
+		synonyms: [
+			"riscaldamento",
+			"termosifone",
+			"stufa",
+			"calore"
+		]
+	},
+	{
+		key: "snowflake",
+		group: "lighting",
+		synonyms: [
+			"freddo",
+			"raffrescamento",
+			"aria",
+			"condizionata",
+			"neve"
+		]
+	},
+	{
+		key: "thermometer-sun",
+		group: "lighting",
+		synonyms: [
+			"caldo",
+			"temperatura",
+			"alta"
+		]
+	},
+	{
+		key: "thermometer-snowflake",
+		group: "lighting",
+		synonyms: [
+			"freddo",
+			"temperatura",
+			"bassa"
+		]
+	},
+	{
+		key: "refrigerator",
+		group: "lighting",
+		synonyms: ["frigorifero", "frigo"]
+	},
+	{
+		key: "microwave",
+		group: "lighting",
+		synonyms: ["microonde", "forno"]
+	},
+	{
+		key: "washing-machine",
+		group: "lighting",
+		synonyms: [
+			"lavatrice",
+			"lavastoviglie",
+			"asciugatrice"
+		]
+	},
+	{
+		key: "cooking-pot",
+		group: "lighting",
+		synonyms: [
+			"pentola",
+			"cucina",
+			"fornello"
+		]
+	},
+	{
+		key: "utensils",
+		group: "lighting",
+		synonyms: [
+			"cucina",
+			"posate",
+			"sala",
+			"pranzo"
+		]
+	},
+	{
+		key: "thermometer",
+		group: "sensing",
+		synonyms: [
+			"temperatura",
+			"termometro",
+			"termostato"
+		]
+	},
+	{
+		key: "droplets",
+		group: "sensing",
+		synonyms: [
+			"umidita",
+			"acqua",
+			"allagamento",
+			"perdita"
+		]
+	},
+	{
+		key: "droplet",
+		group: "sensing",
+		synonyms: [
+			"goccia",
+			"acqua",
+			"perdita",
+			"allagamento"
+		]
+	},
+	{
+		key: "gauge",
+		group: "sensing",
+		synonyms: [
+			"misura",
+			"livello",
+			"pressione",
+			"indicatore"
+		]
+	},
+	{
+		key: "gauge2",
+		group: "sensing",
+		synonyms: [
+			"misura",
+			"livello",
+			"pressione",
+			"indicatore"
+		],
+		aliasOf: "gauge"
+	},
+	{
+		key: "sun",
+		group: "sensing",
+		synonyms: [
+			"sole",
+			"luminosita",
+			"giorno",
+			"esterno"
+		]
+	},
+	{
+		key: "sun-medium",
+		group: "sensing",
+		synonyms: ["sole", "luminosita"]
+	},
+	{
+		key: "sunrise",
+		group: "sensing",
+		synonyms: ["alba"]
+	},
+	{
+		key: "moon",
+		group: "sensing",
+		synonyms: [
+			"notte",
+			"luna",
+			"notturna",
+			"nightvision"
+		]
+	},
+	{
+		key: "wind",
+		group: "sensing",
+		synonyms: [
+			"vento",
+			"aria",
+			"gas",
+			"monossido",
+			"co"
+		]
+	},
+	{
+		key: "cloud",
+		group: "sensing",
+		synonyms: ["nuvola", "nuvoloso"]
+	},
+	{
+		key: "cloud-rain",
+		group: "sensing",
+		synonyms: ["pioggia"]
+	},
+	{
+		key: "cloud-sun",
+		group: "sensing",
+		synonyms: [
+			"variabile",
+			"sole",
+			"nuvole"
+		]
+	},
+	{
+		key: "waves",
+		group: "sensing",
+		synonyms: [
+			"onde",
+			"acqua",
+			"vibrazione"
+		]
+	},
+	{
+		key: "sprout",
+		group: "sensing",
+		synonyms: [
+			"irrigazione",
+			"pianta",
+			"germoglio",
+			"orto"
+		]
+	},
+	{
+		key: "leaf",
+		group: "sensing",
+		synonyms: [
+			"foglia",
+			"pianta",
+			"verde"
+		]
+	},
+	{
+		key: "flower",
+		group: "sensing",
+		synonyms: ["fiore", "pianta"]
+	},
+	{
+		key: "zap",
+		group: "sensing",
+		synonyms: [
+			"energia",
+			"corrente",
+			"consumo",
+			"watt",
+			"elettricita"
+		]
+	},
+	{
+		key: "flame",
+		group: "sensing",
+		synonyms: [
+			"fiamma",
+			"gas",
+			"fuoco",
+			"incendio"
+		]
+	},
+	{
+		key: "bell",
+		group: "sensing",
+		synonyms: [
+			"campanello",
+			"suoneria",
+			"notifica",
+			"bell",
+			"chime"
+		]
+	},
+	{
+		key: "bell-ring",
+		group: "sensing",
+		synonyms: [
+			"campanello",
+			"suona",
+			"doorbell",
+			"notifica"
+		]
+	},
+	{
+		key: "bell-off",
+		group: "sensing",
+		synonyms: [
+			"silenzioso",
+			"notifiche",
+			"disattivate",
+			"muto"
+		]
+	},
+	{
+		key: "siren",
+		group: "sensing",
+		synonyms: ["sirena", "allarme"]
+	},
+	{
+		key: "radar",
+		group: "sensing",
+		synonyms: [
+			"movimento",
+			"presenza",
+			"pir",
+			"rilevamento",
+			"radar"
+		]
+	},
+	{
+		key: "activity",
+		group: "sensing",
+		synonyms: [
+			"attivita",
+			"sensore",
+			"generico"
+		]
+	},
+	{
+		key: "hash",
+		group: "sensing",
+		synonyms: [
+			"numero",
+			"contatore",
+			"valore"
+		]
+	},
+	{
+		key: "clock",
+		group: "sensing",
+		synonyms: [
+			"orologio",
+			"ora",
+			"tempo"
+		]
+	},
+	{
+		key: "timer",
+		group: "sensing",
+		synonyms: [
+			"timer",
+			"conto",
+			"rovescia"
+		]
+	},
+	{
+		key: "calendar",
+		group: "sensing",
+		synonyms: [
+			"calendario",
+			"data",
+			"pianificazione"
+		]
+	},
+	{
+		key: "pipette",
+		group: "sensing",
+		synonyms: [
+			"qualita",
+			"aria",
+			"misura",
+			"campione"
+		]
+	},
+	{
+		key: "fan",
+		group: "sensing",
+		synonyms: [
+			"ventilatore",
+			"ventola",
+			"aria"
+		]
+	},
+	{
+		key: "bath",
+		group: "sensing",
+		synonyms: [
+			"bagno",
+			"vasca",
+			"doccia"
+		]
+	},
+	{
+		key: "footprints",
+		group: "sensing",
+		synonyms: [
+			"movimento",
+			"passi",
+			"presenza",
+			"motion"
+		]
+	},
+	{
+		key: "alarm-smoke",
+		group: "sensing",
+		synonyms: [
+			"fumo",
+			"antincendio",
+			"rilevatore"
+		]
+	},
+	{
+		key: "shield-alert",
+		group: "sensing",
+		synonyms: [
+			"manomissione",
+			"allarme",
+			"tamper",
+			"avviso"
+		]
+	},
+	{
+		key: "vibrate",
+		group: "sensing",
+		synonyms: [
+			"vibrazione",
+			"urto",
+			"tamper"
+		]
+	},
+	{
+		key: "wifi",
+		group: "sensing",
+		synonyms: [
+			"wifi",
+			"rete",
+			"segnale"
+		]
+	},
+	{
+		key: "wifi-off",
+		group: "sensing",
+		synonyms: [
+			"wifi",
+			"assente",
+			"offline",
+			"disconnesso"
+		]
+	},
+	{
+		key: "volume-2",
+		group: "sensing",
+		synonyms: [
+			"volume",
+			"audio",
+			"altoparlante",
+			"suono"
+		]
+	},
+	{
+		key: "volume-x",
+		group: "sensing",
+		synonyms: [
+			"muto",
+			"silenziato",
+			"volume",
+			"spento"
+		]
+	},
+	{
+		key: "heart",
+		group: "sensing",
+		synonyms: [
+			"cuore",
+			"preferito",
+			"salute"
+		]
+	},
+	{
+		key: "heart-pulse",
+		group: "sensing",
+		synonyms: [
+			"battito",
+			"salute",
+			"monitoraggio"
+		]
+	},
+	{
+		key: "star",
+		group: "sensing",
+		synonyms: [
+			"preferito",
+			"stella",
+			"importante"
+		]
+	},
+	{
+		key: "sparkles",
+		group: "sensing",
+		synonyms: [
+			"automatico",
+			"intelligente",
+			"ai",
+			"scena"
+		]
+	},
+	{
+		key: "house",
+		group: "place",
+		synonyms: [
+			"casa",
+			"abitazione",
+			"home"
+		]
+	},
+	{
+		key: "sofa",
+		group: "place",
+		synonyms: [
+			"salone",
+			"soggiorno",
+			"divano",
+			"living"
+		]
+	},
+	{
+		key: "bed-double",
+		group: "place",
+		synonyms: [
+			"camera",
+			"letto",
+			"matrimoniale"
+		]
+	},
+	{
+		key: "bed",
+		group: "place",
+		synonyms: [
+			"cameretta",
+			"letto",
+			"singolo"
+		]
+	},
+	{
+		key: "warehouse",
+		group: "place",
+		synonyms: [
+			"magazzino",
+			"capanno",
+			"deposito",
+			"cantina"
+		]
+	},
+	{
+		key: "trees",
+		group: "place",
+		synonyms: [
+			"giardino",
+			"alberi",
+			"esterno",
+			"parco"
+		]
+	},
+	{
+		key: "tree-pine",
+		group: "place",
+		synonyms: [
+			"albero",
+			"pino",
+			"giardino"
+		]
+	},
+	{
+		key: "fence",
+		group: "place",
+		synonyms: [
+			"recinto",
+			"cancello",
+			"staccionata",
+			"perimetro"
+		]
+	},
+	{
+		key: "store",
+		group: "place",
+		synonyms: [
+			"negozio",
+			"ingresso",
+			"vetrina"
+		]
+	},
+	{
+		key: "building",
+		group: "place",
+		synonyms: ["edificio", "palazzo"]
+	},
+	{
+		key: "building-2",
+		group: "place",
+		synonyms: [
+			"edificio",
+			"uffici",
+			"condominio"
+		]
+	},
+	{
+		key: "mountain",
+		group: "place",
+		synonyms: [
+			"montagna",
+			"esterno",
+			"panorama"
+		]
+	},
+	{
+		key: "umbrella",
+		group: "place",
+		synonyms: [
+			"tenda",
+			"markise",
+			"ombrellone",
+			"pergola",
+			"veranda"
+		]
+	},
+	{
+		key: "dumbbell",
+		group: "place",
+		synonyms: ["palestra", "attrezzi"]
+	},
+	{
+		key: "wrench",
+		group: "place",
+		synonyms: [
+			"officina",
+			"manutenzione",
+			"attrezzi",
+			"utenze"
+		]
+	},
+	{
+		key: "hammer",
+		group: "place",
+		synonyms: [
+			"officina",
+			"martello",
+			"lavori"
+		]
+	},
+	{
+		key: "drill",
+		group: "place",
+		synonyms: [
+			"officina",
+			"trapano",
+			"lavori"
+		]
+	},
+	{
+		key: "waves-ladder",
+		group: "place",
+		synonyms: ["piscina", "vasca"]
+	},
+	{
+		key: "circle-parking",
+		group: "place",
+		synonyms: [
+			"parcheggio",
+			"posto",
+			"auto",
+			"garage"
+		]
+	},
+	{
+		key: "route",
+		group: "place",
+		synonyms: [
+			"percorso",
+			"strada",
+			"vialetto",
+			"tragitto"
+		]
+	},
+	{
+		key: "car",
+		group: "life",
+		synonyms: [
+			"auto",
+			"macchina",
+			"veicolo",
+			"parcheggio"
+		]
+	},
+	{
+		key: "bike",
+		group: "life",
+		synonyms: [
+			"bicicletta",
+			"bici",
+			"moto"
+		]
+	},
+	{
+		key: "bus",
+		group: "life",
+		synonyms: ["autobus", "pullman"]
+	},
+	{
+		key: "truck",
+		group: "life",
+		synonyms: [
+			"camion",
+			"furgone",
+			"consegna"
+		]
+	},
+	{
+		key: "plane",
+		group: "life",
+		synonyms: ["aereo"]
+	},
+	{
+		key: "train-front",
+		group: "life",
+		synonyms: ["treno"]
+	},
+	{
+		key: "sailboat",
+		group: "life",
+		synonyms: ["barca", "imbarcazione"]
+	},
+	{
+		key: "dog",
+		group: "life",
+		synonyms: ["cane", "animale"]
+	},
+	{
+		key: "cat",
+		group: "life",
+		synonyms: ["gatto", "animale"]
+	},
+	{
+		key: "bird",
+		group: "life",
+		synonyms: ["uccello", "animale"]
+	},
+	{
+		key: "paw-print",
+		group: "life",
+		synonyms: [
+			"animale",
+			"zampa",
+			"pet"
+		]
+	},
+	{
+		key: "baby",
+		group: "life",
+		synonyms: [
+			"neonato",
+			"bimbo",
+			"cameretta",
+			"babymonitor"
+		]
+	},
+	{
+		key: "user",
+		group: "life",
+		synonyms: ["persona", "utente"]
+	},
+	{
+		key: "users",
+		group: "life",
+		synonyms: [
+			"persone",
+			"gruppo",
+			"famiglia"
+		]
+	},
+	{
+		key: "person-standing",
+		group: "life",
+		synonyms: [
+			"persona",
+			"piedi",
+			"presenza"
+		]
+	}
+];
+DISPLAY_ICON_VOCABULARY.map((e) => e.key);
+DISPLAY_ICON_VOCABULARY.filter((e) => e.aliasOf === void 0).map((e) => e.key);
+new Map(DISPLAY_ICON_VOCABULARY.map((e) => [e.key, e]));
 Object.freeze({
+	"accessories.getStatus": {
+		capName: "accessories",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"accessories.setChildHidden": {
 		capName: "accessories",
 		capScope: "device",
@@ -38636,6 +41091,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"airQualitySensor.getStatus": {
+		capName: "air-quality-sensor",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"alarmPanel.arm": {
 		capName: "alarm-panel",
 		capScope: "device",
@@ -38648,6 +41109,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"alarmPanel.getStatus": {
+		capName: "alarm-panel",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"alarmPanel.trigger": {
 		capName: "alarm-panel",
 		capScope: "device",
@@ -38696,6 +41163,30 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"ambientLightSensor.getStatus": {
+		capName: "ambient-light-sensor",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"audioAnalysis.applyDeviceSettingsPatch": {
+		capName: "audio-analysis",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"audioAnalysis.getDeviceLiveContribution": {
+		capName: "audio-analysis",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"audioAnalysis.getDeviceSettingsContribution": {
+		capName: "audio-analysis",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"audioAnalysis.resolveDeviceSettings": {
 		capName: "audio-analysis",
 		capScope: "device",
@@ -38858,6 +41349,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"automationControl.getStatus": {
+		capName: "automation-control",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"automationControl.trigger": {
 		capName: "automation-control",
 		capScope: "device",
@@ -38954,12 +41451,30 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"battery.getStatus": {
+		capName: "battery",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"battery.wakeForStream": {
 		capName: "battery",
 		capScope: "device",
 		addonId: null,
 		access: "create"
 	},
+	"binary.getStatus": {
+		capName: "binary",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"brightness.getStatus": {
+		capName: "brightness",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"brightness.setBrightness": {
 		capName: "brightness",
 		capScope: "device",
@@ -39074,6 +41589,30 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"cameraCredentials.getStatus": {
+		capName: "camera-credentials",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"cameraGridLayout.applyDeviceSettingsPatch": {
+		capName: "camera-grid-layout",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"cameraGridLayout.getDeviceLiveContribution": {
+		capName: "camera-grid-layout",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"cameraGridLayout.getDeviceSettingsContribution": {
+		capName: "camera-grid-layout",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"cameraGridLayout.getLayout": {
 		capName: "camera-grid-layout",
 		capScope: "device",
@@ -39086,6 +41625,24 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"cameraPipelineConfig.applyDeviceSettingsPatch": {
+		capName: "camera-pipeline-config",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"cameraPipelineConfig.getDeviceLiveContribution": {
+		capName: "camera-pipeline-config",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"cameraPipelineConfig.getDeviceSettingsContribution": {
+		capName: "camera-pipeline-config",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"cameraStreams.getBrokerStreams": {
 		capName: "camera-streams",
 		capScope: "device",
@@ -39116,6 +41673,18 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"carbonMonoxide.getStatus": {
+		capName: "carbon-monoxide",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"climateControl.getStatus": {
+		capName: "climate-control",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"climateControl.setFanMode": {
 		capName: "climate-control",
 		capScope: "device",
@@ -39164,6 +41733,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"color.getStatus": {
+		capName: "color",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"color.setColor": {
 		capName: "color",
 		capScope: "device",
@@ -39182,12 +41757,36 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"connectivity.getStatus": {
+		capName: "connectivity",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"consumables.getStatus": {
+		capName: "consumables",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"consumables.reset": {
 		capName: "consumables",
 		capScope: "device",
 		addonId: null,
 		access: "delete"
 	},
+	"contact.getStatus": {
+		capName: "contact",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"control.getStatus": {
+		capName: "control",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"control.setValue": {
 		capName: "control",
 		capScope: "device",
@@ -39254,6 +41853,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"cover.getStatus": {
+		capName: "cover",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"cover.open": {
 		capName: "cover",
 		capScope: "device",
@@ -39386,6 +41991,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"dayNight.getStatus": {
+		capName: "day-night",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"dayNight.setSettings": {
 		capName: "day-night",
 		capScope: "device",
@@ -39476,6 +42087,30 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"detectionPipeline.applyDeviceSettingsPatch": {
+		capName: "detection-pipeline",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"detectionPipeline.getDeviceLiveContribution": {
+		capName: "detection-pipeline",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"detectionPipeline.getDeviceSettingsContribution": {
+		capName: "detection-pipeline",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"deviceAdminLink.getAdminLink": {
+		capName: "device-admin-link",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"deviceAdoption.adopt": {
 		capName: "device-adoption",
 		capScope: "system",
@@ -39488,6 +42123,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"deviceAdoption.getStatus": {
+		capName: "device-adoption",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"deviceAdoption.listCandidateFilters": {
 		capName: "device-adoption",
 		capScope: "system",
@@ -39524,6 +42165,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"deviceDiscovery.getStatus": {
+		capName: "device-discovery",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"deviceDiscovery.listDiscovered": {
 		capName: "device-discovery",
 		capScope: "device",
@@ -39542,12 +42189,30 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"deviceExport.applyDeviceSettingsPatch": {
+		capName: "device-export",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"deviceExport.exposeDevice": {
 		capName: "device-export",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
+	"deviceExport.getDeviceLiveContribution": {
+		capName: "device-export",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceExport.getDeviceSettingsContribution": {
+		capName: "device-export",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"deviceExport.getStatus": {
 		capName: "device-export",
 		capScope: "system",
@@ -39644,6 +42309,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"deviceManager.applyDeviceSettingsPatch": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"deviceManager.applyInitialMeta": {
 		capName: "device-manager",
 		capScope: "system",
@@ -39746,6 +42417,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"deviceManager.getDeviceLiveContribution": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"deviceManager.getDeviceLiveInfoAggregate": {
 		capName: "device-manager",
 		capScope: "system",
@@ -39758,6 +42435,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"deviceManager.getDeviceSettingsContribution": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"deviceManager.getDeviceStatusAggregate": {
 		capName: "device-manager",
 		capScope: "system",
@@ -40250,6 +42933,36 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"deviceStatus.getStatus": {
+		capName: "device-status",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"doorbell.applyDeviceSettingsPatch": {
+		capName: "doorbell",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"doorbell.getDeviceLiveContribution": {
+		capName: "doorbell",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"doorbell.getDeviceSettingsContribution": {
+		capName: "doorbell",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"doorbell.getStatus": {
+		capName: "doorbell",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"embeddingEncoder.encode": {
 		capName: "embedding-encoder",
 		capScope: "system",
@@ -40268,20 +42981,14 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"events.getEventClipUrl": {
-		capName: "events",
+	"enumSensor.getStatus": {
+		capName: "enum-sensor",
 		capScope: "device",
 		addonId: null,
 		access: "view"
 	},
-	"events.getEvents": {
-		capName: "events",
-		capScope: "device",
-		addonId: null,
-		access: "view"
-	},
-	"events.getEventThumbnail": {
-		capName: "events",
+	"eventEmitter.getStatus": {
+		capName: "event-emitter",
 		capScope: "device",
 		addonId: null,
 		access: "view"
@@ -40388,6 +43095,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"fanControl.getStatus": {
+		capName: "fan-control",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"fanControl.setDirection": {
 		capName: "fan-control",
 		capScope: "device",
@@ -40412,6 +43125,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"featureProbe.getStatus": {
+		capName: "feature-probe",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"filesystemBrowse.browse": {
 		capName: "filesystem-browse",
 		capScope: "system",
@@ -40430,6 +43149,24 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"flood.getStatus": {
+		capName: "flood",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"gas.getStatus": {
+		capName: "gas",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"humidifier.getStatus": {
+		capName: "humidifier",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"humidifier.setMode": {
 		capName: "humidifier",
 		capScope: "device",
@@ -40448,12 +43185,30 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"humiditySensor.getStatus": {
+		capName: "humidity-sensor",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"image.getStatus": {
+		capName: "image",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"imageSettings.getOptions": {
 		capName: "image-settings",
 		capScope: "device",
 		addonId: null,
 		access: "view"
 	},
+	"imageSettings.getStatus": {
+		capName: "image-settings",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"imageSettings.setSettings": {
 		capName: "image-settings",
 		capScope: "device",
@@ -40526,6 +43281,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"intercom.getStatus": {
+		capName: "intercom",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"intercom.handleAnswer": {
 		capName: "intercom",
 		capScope: "device",
@@ -40562,6 +43323,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"lawnMowerControl.getStatus": {
+		capName: "lawn-mower-control",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"lawnMowerControl.pause": {
 		capName: "lawn-mower-control",
 		capScope: "device",
@@ -40844,6 +43611,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"lockControl.getStatus": {
+		capName: "lock-control",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"lockControl.lock": {
 		capName: "lock-control",
 		capScope: "device",
@@ -40892,6 +43665,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"mediaPlayer.getStatus": {
+		capName: "media-player",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"mediaPlayer.next": {
 		capName: "media-player",
 		capScope: "device",
@@ -41084,6 +43863,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"motion.getStatus": {
+		capName: "motion",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"motion.isDetected": {
 		capName: "motion",
 		capScope: "device",
@@ -41096,6 +43881,24 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"motionDetection.applyDeviceSettingsPatch": {
+		capName: "motion-detection",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"motionDetection.getDeviceLiveContribution": {
+		capName: "motion-detection",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"motionDetection.getDeviceSettingsContribution": {
+		capName: "motion-detection",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"motionDetection.removeCamera": {
 		capName: "motion-detection",
 		capScope: "device",
@@ -41108,6 +43911,12 @@ Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
+	"motionTrigger.getStatus": {
+		capName: "motion-trigger",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"motionTrigger.setMotionTrigger": {
 		capName: "motion-trigger",
 		capScope: "device",
@@ -41120,6 +43929,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"motionZones.getStatus": {
+		capName: "motion-zones",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"motionZones.setZone": {
 		capName: "motion-zones",
 		capScope: "device",
@@ -41180,6 +43995,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"nativeObjectDetection.getStatus": {
+		capName: "native-object-detection",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"nativeObjectDetection.setEnabled": {
 		capName: "native-object-detection",
 		capScope: "device",
@@ -41198,6 +44019,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"navigation.getStatus": {
+		capName: "navigation",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"navigation.goToPoint": {
 		capName: "navigation",
 		capScope: "device",
@@ -41282,6 +44109,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"networkLink.getStatus": {
+		capName: "network-link",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"networkQuality.getAllStats": {
 		capName: "network-quality",
 		capScope: "system",
@@ -41540,18 +44373,36 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"notifier.getStatus": {
+		capName: "notifier",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"notifier.send": {
 		capName: "notifier",
 		capScope: "device",
 		addonId: null,
 		access: "create"
 	},
+	"numericSensor.getStatus": {
+		capName: "numeric-sensor",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"oauthIntegration.getDescriptor": {
 		capName: "oauth-integration",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
+	"osd.getStatus": {
+		capName: "osd",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"osd.setOverlay": {
 		capName: "osd",
 		capScope: "device",
@@ -41624,6 +44475,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"petFeeder.getStatus": {
+		capName: "pet-feeder",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"petFeeder.markFoodReplenished": {
 		capName: "pet-feeder",
 		capScope: "device",
@@ -41666,6 +44523,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.applyDeviceSettingsPatch": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.cancelRelocateMedia": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -41732,6 +44595,18 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.getDeviceLiveContribution": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"pipelineAnalytics.getDeviceSettingsContribution": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.getEventDensity": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -42302,6 +45177,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.applyDeviceSettingsPatch": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.assignAudio": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -42392,6 +45273,18 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.getDeviceLiveContribution": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"pipelineOrchestrator.getDeviceSettingsContribution": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.getGlobalMetrics": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -42800,12 +45693,36 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"powerMeter.getStatus": {
+		capName: "power-meter",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"presence.getStatus": {
+		capName: "presence",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"pressureSensor.getStatus": {
+		capName: "pressure-sensor",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"privacyMask.getOptions": {
 		capName: "privacy-mask",
 		capScope: "device",
 		addonId: null,
 		access: "view"
 	},
+	"privacyMask.getStatus": {
+		capName: "privacy-mask",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"privacyMask.setAudioEnabled": {
 		capName: "privacy-mask",
 		capScope: "device",
@@ -42866,6 +45783,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"ptz.getStatus": {
+		capName: "ptz",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"ptz.goHome": {
 		capName: "ptz",
 		capScope: "device",
@@ -42944,200 +45867,236 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"recording.cancelRelocateJob": {
+	"recording.getAvailability": {
+		capName: "recording",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"recording.getDaysWithRecordings": {
+		capName: "recording",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"recording.getPlayback": {
 		capName: "recording",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"recording.getPlaybackOptions": {
+		capName: "recording",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"recording.listSources": {
+		capName: "recording",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"recordingArchive.applyDeviceSettingsPatch": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"recording.cancelStorageMigrationMove": {
-		capName: "recording",
+	"recordingArchive.cancelRelocateJob": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"recording.deleteFootprint": {
-		capName: "recording",
+	"recordingArchive.cancelStorageMigrationMove": {
+		capName: "recording-archive",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"recordingArchive.deleteFootprint": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "delete"
 	},
-	"recording.getAvailability": {
-		capName: "recording",
+	"recordingArchive.getAvailabilityBatch": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getAvailabilityBatch": {
-		capName: "recording",
+	"recordingArchive.getDaysWithRecordingsBatch": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getDaysWithRecordings": {
-		capName: "recording",
+	"recordingArchive.getDeviceConfig": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getDaysWithRecordingsBatch": {
-		capName: "recording",
+	"recordingArchive.getDeviceLiveContribution": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getDeviceConfig": {
-		capName: "recording",
+	"recordingArchive.getDeviceSettingsContribution": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getPlacement": {
-		capName: "recording",
+	"recordingArchive.getPlacement": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getPlaybackManifest": {
-		capName: "recording",
+	"recordingArchive.getRelocateResidue": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getRelocateResidue": {
-		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"
@@ -43184,6 +46143,24 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"recordingOnboard.getOptions": {
+		capName: "recording-onboard",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"recordingOnboard.getStatus": {
+		capName: "recording-onboard",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"recordingOnboard.setSettings": {
+		capName: "recording-onboard",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"recordingSignal.getStatus": {
 		capName: "recording-signal",
 		capScope: "device",
@@ -43214,6 +46191,12 @@ Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
+	"sceneMonitor.getStatus": {
+		capName: "scene-monitor",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"sceneMonitor.listScenes": {
 		capName: "scene-monitor",
 		capScope: "device",
@@ -43244,6 +46227,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"scriptRunner.getStatus": {
+		capName: "script-runner",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"scriptRunner.run": {
 		capName: "script-runner",
 		capScope: "device",
@@ -43376,6 +46365,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"smoke.getStatus": {
+		capName: "smoke",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"smtpProvider.getStatus": {
 		capName: "smtp-provider",
 		capScope: "system",
@@ -43394,12 +46389,30 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"snapshot.applyDeviceSettingsPatch": {
+		capName: "snapshot",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"snapshot.getDebugState": {
 		capName: "snapshot",
 		capScope: "device",
 		addonId: null,
 		access: "view"
 	},
+	"snapshot.getDeviceLiveContribution": {
+		capName: "snapshot",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"snapshot.getDeviceSettingsContribution": {
+		capName: "snapshot",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"snapshot.getSnapshot": {
 		capName: "snapshot",
 		capScope: "device",
@@ -43418,6 +46431,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"snapshot.getStatus": {
+		capName: "snapshot",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"snapshot.invalidateCache": {
 		capName: "snapshot",
 		capScope: "device",
@@ -43754,6 +46773,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"streamBroker.applyDeviceSettingsPatch": {
+		capName: "stream-broker",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"streamBroker.assignProfile": {
 		capName: "stream-broker",
 		capScope: "system",
@@ -43790,6 +46815,18 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"streamBroker.getDeviceLiveContribution": {
+		capName: "stream-broker",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"streamBroker.getDeviceSettingsContribution": {
+		capName: "stream-broker",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"streamBroker.getPreBufferInfo": {
 		capName: "stream-broker",
 		capScope: "system",
@@ -43988,6 +47025,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"streamParams.getStatus": {
+		capName: "stream-params",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"streamParams.setProfile": {
 		capName: "stream-params",
 		capScope: "device",
@@ -44000,6 +47043,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"switch.getStatus": {
+		capName: "switch",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"switch.setState": {
 		capName: "switch",
 		capScope: "device",
@@ -44096,6 +47145,18 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"tamper.getStatus": {
+		capName: "tamper",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"temperatureSensor.getStatus": {
+		capName: "temperature-sensor",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"terminalSession.adoptLegacyMonitor": {
 		capName: "terminal-session",
 		capScope: "system",
@@ -44192,6 +47253,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"update.getStatus": {
+		capName: "update",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"update.installUpdate": {
 		capName: "update",
 		capScope: "device",
@@ -44414,6 +47481,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"vacuumControl.getStatus": {
+		capName: "vacuum-control",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"vacuumControl.locate": {
 		capName: "vacuum-control",
 		capScope: "device",
@@ -44456,6 +47529,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"valve.getStatus": {
+		capName: "valve",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"valve.open": {
 		capName: "valve",
 		capScope: "device",
@@ -44528,12 +47607,30 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"vibration.getStatus": {
+		capName: "vibration",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"videoclips.dialClipStream": {
+		capName: "videoclips",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"videoclips.getClipPlayback": {
 		capName: "videoclips",
 		capScope: "device",
 		addonId: null,
 		access: "view"
 	},
+	"videoclips.getPlaybackOptions": {
+		capName: "videoclips",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"videoclips.listClips": {
 		capName: "videoclips",
 		capScope: "device",
@@ -44546,6 +47643,18 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"videoclips.offerClipBytes": {
+		capName: "videoclips",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"videoclips.readClipBytes": {
+		capName: "videoclips",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"viewerUi.getStaticDir": {
 		capName: "viewer-ui",
 		capScope: "system",
@@ -44558,6 +47667,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"waterHeater.getStatus": {
+		capName: "water-heater",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"waterHeater.setAway": {
 		capName: "water-heater",
 		capScope: "device",
@@ -44576,6 +47691,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"weather.getStatus": {
+		capName: "weather",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"webrtcSession.addIceCandidate": {
 		capName: "webrtc-session",
 		capScope: "device",
@@ -44938,6 +48059,11 @@ Object.freeze({
 		form: "single",
 		optional: true
 	}],
+	"deviceAdminLink.getAdminLink": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"deviceAdoption.release": [{
 		name: "camDeviceId",
 		form: "single",
@@ -45275,21 +48401,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",
@@ -46208,107 +49319,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
@@ -46323,6 +49444,16 @@ Object.freeze({
 		form: "single",
 		optional: true
 	}],
+	"recordingOnboard.getOptions": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recordingOnboard.setSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"recordingSignal.getStatus": [{
 		name: "deviceId",
 		form: "single",
@@ -46549,11 +49680,21 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"videoclips.dialClipStream": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"videoclips.getClipPlayback": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
+	"videoclips.getPlaybackOptions": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"videoclips.listClips": [{
 		name: "deviceId",
 		form: "single",
@@ -46564,6 +49705,16 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"videoclips.offerClipBytes": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"videoclips.readClipBytes": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"waterHeater.setAway": [{
 		name: "deviceId",
 		form: "single",
@@ -48121,6 +51272,12 @@ Object.defineProperty(exports, "RECORDING_EXPORT_MAX_READ_BYTES", {
 		return RECORDING_EXPORT_MAX_READ_BYTES;
 	}
 });
+Object.defineProperty(exports, "RECORDING_SOURCE_CAMSTACK_ADDON", {
+	enumerable: true,
+	get: function() {
+		return RECORDING_SOURCE_CAMSTACK_ADDON;
+	}
+});
 Object.defineProperty(exports, "RetrainStatusSchema", {
 	enumerable: true,
 	get: function() {