@camstack/addon-post-analysis 0.1.19 → 0.1.20

package/dist/{index-BFbwYH1P.js → index-B0RhVv1c.js}

@@ -1273,10 +1273,10 @@ const $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
           return;
         }
       }
-      const url = new URL(trimmed);
+      const url2 = new URL(trimmed);
       if (def.hostname) {
         def.hostname.lastIndex = 0;
-        if (!def.hostname.test(url.hostname)) {
+        if (!def.hostname.test(url2.hostname)) {
           payload.issues.push({
             code: "invalid_format",
             format: "url",
@@ -1290,7 +1290,7 @@ const $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
       }
       if (def.protocol) {
         def.protocol.lastIndex = 0;
-        if (!def.protocol.test(url.protocol.endsWith(":") ? url.protocol.slice(0, -1) : url.protocol)) {
+        if (!def.protocol.test(url2.protocol.endsWith(":") ? url2.protocol.slice(0, -1) : url2.protocol)) {
           payload.issues.push({
             code: "invalid_format",
             format: "url",
@@ -1303,7 +1303,7 @@ const $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
         }
       }
       if (def.normalize) {
-        payload.value = url.href;
+        payload.value = url2.href;
       } else {
         payload.value = trimmed;
       }
@@ -4427,6 +4427,9 @@ const ZodURL = /* @__PURE__ */ $constructor("ZodURL", (inst, def) => {
   $ZodURL.init(inst, def);
   ZodStringFormat.init(inst, def);
 });
+function url(params) {
+  return /* @__PURE__ */ _url(ZodURL, params);
+}
 const ZodEmoji = /* @__PURE__ */ $constructor("ZodEmoji", (inst, def) => {
   $ZodEmoji.init(inst, def);
   ZodStringFormat.init(inst, def);
@@ -5110,6 +5113,7 @@ const WELL_KNOWN_TABS = [
   { id: "stream-broker", label: "Stream Broker", icon: "radio", order: 20 },
   { id: "streaming", label: "Streaming", icon: "video", order: 35 },
   { id: "ptz", label: "PTZ", icon: "move", order: 40 },
+  { id: "consumables", label: "Consumables", icon: "recycle", order: 44 },
   { id: "pipeline", label: "Detection Pipeline", icon: "cpu", order: 39 },
   { id: "zones", label: "Detection", icon: "shapes", order: 38 },
   { id: "live-stats", label: "Live Stats", icon: "activity", order: 39 },
@@ -5129,7 +5133,7 @@ const WELL_KNOWN_TABS = [
 ];
 Object.fromEntries(WELL_KNOWN_TABS.map((t) => [t.id, t]));
 function isValuelessField(field) {
-  return field.type === "separator" || field.type === "info" || field.type === "button" || field.type === "object-array" || field.type === "widget" || field.type === "addon-action-button";
+  return field.type === "separator" || field.type === "info" || field.type === "qr-code" || field.type === "button" || field.type === "object-array" || field.type === "widget" || field.type === "addon-action-button" || field.type === "device-action-button";
 }
 function hydrateSchema(schema, values) {
   return {
@@ -5191,6 +5195,8 @@ function typeOf(field) {
     case "password":
     case "color":
     case "probe":
+    case "timezone":
+    case "datetime":
       return "string";
     case "number":
     case "slider":
@@ -5201,32 +5207,262 @@ function typeOf(field) {
       return "other";
   }
 }
-const StorageLocationTypeSchema = _enum([
-  "data",
-  "media",
-  "recordings",
-  // Recording-stream slots — addons pick high/low/clips per use case.
-  // The legacy `IStorageProvider` interface enumerated these; keeping
-  // them in the Zod enum means the `storage` cap can route per-slot
-  // location refs (e.g. `'recordings-high:nas-01'`) without losing
-  // type safety.
-  "recordings-high",
-  "recordings-low",
-  "recordings-clips",
-  // Detection snapshots / thumbnails / crops.
-  "event-images",
-  "models",
-  "cache",
-  "logs",
-  "addons-data",
-  // `backups` — owned by the backup-orchestrator builtin. Default
-  // root: `<dataDir>/backups`. Operators can repoint via the same
-  // override mechanism every other location uses (storage settings).
-  "backups"
+const CamProfileSchema = _enum(["high", "mid", "low"]);
+const CamStreamKindSchema = _enum([
+  "pull-rtsp",
+  "pull-rtmp",
+  "pull-http",
+  "pull-rfc4571",
+  "push-annexb",
+  /** Broker-spawned ffmpeg transcode plane — reads from a source cam-stream
+   *  and writes a re-encoded RTP plane. The broker routes demand signals to
+   *  the source broker; the transcode process is single-flighted per
+   *  identical EncodeProfile so multiple derived subscribers share one ffmpeg
+   *  process. */
+  "derived"
+]);
+const CamStreamResolutionSchema = object({
+  width: number().int().positive(),
+  height: number().int().positive()
+});
+const CameraStreamSchema = object({
+  /** Stable, provider-assigned id unique within the (deviceId) scope. */
+  camStreamId: string().min(1),
+  deviceId: number().int().nonnegative(),
+  kind: CamStreamKindSchema,
+  /** Required for pull-* kinds. Ignored for push-annexb. */
+  url: string().optional(),
+  codec: string().optional(),
+  resolution: CamStreamResolutionSchema.optional(),
+  fps: number().positive().optional(),
+  /** Human label surfaced in the Admin UI "Camera Stream" dropdown. */
+  label: string().optional(),
+  /**
+   * Device-level features the publisher advertised (e.g. `battery-operated`).
+   * The broker, snapshot orchestrator, and prebuffer manager all consult
+   * this list to derive policy — relaxed stall watchdog for battery
+   * cams, prebuffer off by default, longer snapshot rate-limit, etc.
+   *
+   * Single source of truth replacing per-stream flags like the
+   * historical `allowStall`: if the publisher knows the camera is
+   * battery-powered, every downstream service derives the right policy
+   * from this list.
+   */
+  deviceFeatures: array(string()).optional(),
+  /**
+   * Whether this stream participates in the broker's automatic profile
+   * assignment (`computeInitialAssignment`). Defaults to `true`. Publishers
+   * use `false` when they want a stream to be SELECTABLE in the UI but not
+   * picked by default — e.g. Reolink publishes its native Baichuan streams
+   * as `autoEligible: true` (the recommended path) and its RTSP / RTMP
+   * mirrors as `autoEligible: false` (still pickable per slot, just not
+   * the auto choice). Manual `assignProfile` calls remain valid for
+   * non-eligible streams.
+   */
+  autoEligible: boolean().optional(),
+  /**
+   * Transport-specific opaque metadata. The broker passes it through to
+   * the source reader without inspecting it. Currently used by
+   * `pull-rfc4571` streams to carry the upstream SDP (so the reader can
+   * route RTP packets to the right depacketizer without an in-band
+   * DESCRIBE phase). Other kinds typically leave it undefined.
+   */
+  metadata: record(string(), unknown()).optional()
+});
+const ProfileSlotStatusSchema = _enum([
+  "unassigned",
+  "idle",
+  "connecting",
+  "streaming",
+  "error"
+]);
+const ProfileSlotSchema = object({
+  deviceId: number().int().nonnegative(),
+  profile: CamProfileSchema,
+  /** Broker id the rest of the system addresses: `${deviceId}/${profile}`. */
+  brokerId: string(),
+  /** `null` when the profile is unassigned. */
+  sourceCamStreamId: string().nullable(),
+  status: ProfileSlotStatusSchema,
+  resolution: CamStreamResolutionSchema.optional(),
+  codec: string().optional(),
+  preBufferSec: number().nonnegative().optional(),
+  errorMessage: string().optional()
+});
+const StreamSourceEntrySchema$1 = object({
+  id: string(),
+  label: string(),
+  protocol: _enum(["rtsp", "rtmp", "annexb", "http-mjpeg", "webrtc", "custom"]),
+  url: string().optional(),
+  resolution: object({ width: number(), height: number() }).readonly().optional(),
+  fps: number().optional(),
+  bitrate: number().optional(),
+  codec: string().optional(),
+  profileHint: CamProfileSchema.optional()
+});
+object({
+  type: string(),
+  url: string(),
+  videoCodec: string().optional(),
+  audioCodec: string().optional(),
+  metadata: record(string(), unknown()).readonly().optional()
+});
+const EncodedPacketSchema = object({
+  type: _enum(["video", "audio"]),
+  data: _instanceof(Uint8Array),
+  pts: number(),
+  dts: number(),
+  keyframe: boolean(),
+  codec: string()
+});
+const DecodedFrameSchema = object({
+  data: _instanceof(Uint8Array),
+  width: number(),
+  height: number(),
+  format: _enum(["jpeg", "rgb", "bgr", "yuv420", "gray"]),
+  timestamp: number()
+});
+const FrameHandleSchema = object({
+  shmId: string(),
+  slot: number().int().nonnegative(),
+  seq: number().int().nonnegative(),
+  width: number().int().positive(),
+  height: number().int().positive(),
+  format: _enum(["jpeg", "rgb", "bgr", "yuv420", "gray"]),
+  pts: number(),
+  byteLength: number().int().nonnegative(),
+  nodeId: string(),
+  slotCount: number().int().positive()
+});
+const FrameHandleFormatSchema = _enum(["rgb", "bgr", "yuv420", "gray"]);
+const SubscribeFramesInputSchema = object({
+  brokerId: string(),
+  format: FrameHandleFormatSchema,
+  /**
+   * Optional reader-side cadence hint in frames per second. The broker does
+   * NOT throttle — latest-wins ring reads drop frames implicitly for a slow
+   * consumer. The value is echoed back in `SubscribeFramesResult.maxFps` so
+   * the consumer can pace its own `pullFrameHandles` polling.
+   */
+  maxFps: number().positive().optional(),
+  /** Short caller-identity tag (`motion`, `detection`, …) for diagnostics. */
+  tag: string().optional()
+});
+const SubscribeFramesResultSchema = object({
+  /** Opaque id the consumer passes to `pullFrameHandles` / `unsubscribeFrames`. */
+  subscriptionId: string(),
+  /** Reader-side cadence hint (frames/s) — echoes `SubscribeFramesInput.maxFps`. */
+  maxFps: number().nonnegative()
+});
+const DecodedAudioChunkSchema = object({
+  data: _instanceof(Uint8Array),
+  sampleRate: number().int().positive(),
+  channels: number().int().positive(),
+  timestamp: number()
+});
+const SubscribeAudioChunksInputSchema = object({
+  brokerId: string(),
+  /** Short caller-identity tag (`audio-analyzer`, …) for `listClients`. */
+  tag: string().optional()
+});
+const SubscribeAudioChunksResultSchema = object({
+  /** Opaque id passed to `pullAudioChunks` / `unsubscribeAudioChunks`. */
+  subscriptionId: string()
+});
+const BrokerStatusSchema$1 = _enum(["idle", "connecting", "streaming", "error", "stopped"]);
+const BrokerStatsSchema = object({
+  status: BrokerStatusSchema$1,
+  inputFps: number(),
+  decodeFps: number(),
+  encodedSubscribers: number(),
+  decodedSubscribers: number(),
+  uptimeMs: number(),
+  bitrateKbps: number(),
+  idrIntervalMs: number(),
+  codec: string().optional(),
+  totalBytes: number(),
+  packetCount: number(),
+  rtspClients: number(),
+  pipeClients: number(),
+  preBufferSec: number(),
+  preBufferMs: number(),
+  preBufferPackets: number(),
+  /**
+   * Moleculer node id of the decoder provider currently servicing this
+   * stream's decoded subscribers. `null` until the deferred decoder is
+   * created (no decoded clients yet, or codec not detected). Surfaces the
+   * runtime decoder placement so the UI can show "Decoder: <agent>" without
+   * a separate cap call per broker.
+   */
+  decoderNodeId: string().nullable(),
+  /**
+   * Detected audio track parameters from the RTSP DESCRIBE / SDP. `null`
+   * when the stream has no audio track or the broker is in cold start.
+   * `supported = false` means the codec was detected but the local
+   * decoder pipeline cannot produce PCM chunks (e.g. AAC without the
+   * AAC pipeline wired). Surfaced in the UI device-overview so operators
+   * can pre-pick the audio-analysis model that matches the codec.
+   */
+  audio: object({
+    codec: string(),
+    sampleRate: number(),
+    channels: number(),
+    supported: boolean()
+  }).nullable().optional()
+});
+const ProfileRtspEntrySchema = object({
+  profile: CamProfileSchema,
+  /** Profile-keyed broker id, format `${deviceId}/${profile}` (e.g. `"15/high"`). */
+  brokerId: string(),
+  url: string(),
+  mutedUrl: string(),
+  enabled: boolean(),
+  codec: string().optional(),
+  resolution: CamStreamResolutionSchema.optional()
+});
+const RecordingWeekdaySchema = number().int().min(0).max(6);
+const HHMM = /^([01]\d|2[0-3]):[0-5]\d$/;
+const RecordingScheduleSchema = discriminatedUnion("kind", [
+  object({ kind: literal("always") }),
+  object({
+    kind: literal("timeOfDay"),
+    start: string().regex(HHMM),
+    end: string().regex(HHMM),
+    /** Restrict to these weekdays; omit = every day. */
+    days: array(RecordingWeekdaySchema).optional()
+  })
 ]);
+const RecordingModeSchema = _enum(["continuous", "onMotion", "onAudioThreshold"]);
+const RecordingRuleSchema = object({
+  schedule: RecordingScheduleSchema,
+  mode: RecordingModeSchema,
+  /** Seconds of footage to retain BEFORE a trigger (applied at keep/discard). */
+  preBufferSec: number().min(0).default(0),
+  /** Keep recording until this many seconds after the last trigger. */
+  postBufferSec: number().min(0).default(0),
+  /** Each new trigger restarts the post-buffer window. */
+  resetTimeoutOnNewEvent: boolean().default(true),
+  /** onAudioThreshold only — dBFS level that counts as a trigger. */
+  thresholdDbfs: number().optional()
+});
+const RecordingRetentionSchema = object({
+  maxAgeDays: number().min(0).optional(),
+  maxSizeGb: number().min(0).optional()
+});
+const RecordingConfigSchema = object({
+  enabled: boolean(),
+  profiles: array(CamProfileSchema).optional(),
+  segmentSeconds: number().int().positive().optional(),
+  rules: array(RecordingRuleSchema).optional(),
+  retention: RecordingRetentionSchema.optional()
+});
+const StorageLocationTypeSchema = string().regex(/^[a-z][a-zA-Z0-9-]*$/);
 const StorageLocationSchema = object({
-  id: string().regex(/^[a-z][a-z0-9-]*:[a-z0-9-]+$/),
-  type: StorageLocationTypeSchema,
+  id: string().regex(/^[a-z][a-zA-Z0-9-]*:[a-zA-Z0-9-]+$/),
+  // Open string — the location's *kind* is an addon-declared id matching
+  // `StorageLocationDeclaration.id`. All built-in ids are valid plain
+  // strings, and addon-declared ids are admitted without schema changes.
+  type: string(),
   displayName: string().min(1),
   providerId: string().min(1),
   config: record(string(), unknown()),
@@ -5237,8 +5473,36 @@ const StorageLocationSchema = object({
 });
 const StorageLocationRefSchema = union([
   StorageLocationTypeSchema,
-  string().regex(/^[a-z][a-z0-9-]*:[a-z0-9-]+$/)
+  string().regex(/^[a-z][a-zA-Z0-9-]*:[a-zA-Z0-9-]+$/)
 ]);
+const StorageLocationDeclarationSchema = object({
+  /**
+   * Global location identifier, e.g. `recordings` or `recordingsLow`.
+   * Must start with a lowercase letter and may contain letters, digits, and
+   * hyphens.
+   */
+  id: string().regex(/^[a-z][a-zA-Z0-9-]*$/, {
+    message: "id must start with a lowercase letter and contain only letters, digits, or hyphens"
+  }),
+  /** Human-readable name shown in the admin UI. */
+  displayName: string().min(1, { message: "displayName must not be empty" }),
+  /** Optional longer explanation of what data this location stores. */
+  description: string().optional(),
+  /**
+   * `single` — exactly one instance of this location is allowed system-wide
+   * (e.g. `logs`, `models`). The operator can edit it but not add more.
+   * `multi`  — the operator may register several instances (e.g. a second
+   * `recordings` on a NAS for disk tiering); one is the default at any time.
+   */
+  cardinality: _enum(["single", "multi"]),
+  /**
+   * When set, the default instance for this location inherits its resolved
+   * root from the named location's default instance. Useful for derivative
+   * slots (e.g. `recordingsLow` → `recordings`) so operators only need to
+   * configure the primary location.
+   */
+  defaultsTo: string().optional()
+});
 const DecoderStatsSchema = object({
   inputFps: number(),
   outputFps: number(),
@@ -5280,6 +5544,51 @@ const DecoderSessionConfigSchema = object({
    */
   frameSink: _enum(["callback", "shm"]).default("callback")
 });
+const VideoEncodeSchema = object({
+  codec: _enum(["h264", "h265", "copy"]),
+  profile: _enum(["baseline", "main", "high"]).optional(),
+  width: number().int().positive().optional(),
+  height: number().int().positive().optional(),
+  fps: number().positive().optional(),
+  bitrateKbps: number().int().positive().optional(),
+  gopFrames: number().int().positive().optional(),
+  bf: number().int().min(0).optional(),
+  preset: _enum([
+    "ultrafast",
+    "superfast",
+    "veryfast",
+    "faster",
+    "fast",
+    "medium"
+  ]).optional(),
+  tune: _enum(["zerolatency", "film", "animation"]).optional()
+});
+const AudioEncodeSchema = union([
+  literal("passthrough"),
+  object({
+    codec: _enum(["opus", "aac", "pcmu", "pcma", "copy"]),
+    bitrateKbps: number().int().positive().optional(),
+    sampleRateHz: number().int().positive().optional(),
+    channels: union([literal(1), literal(2)]).optional()
+  })
+]);
+const EncodeProfileSchema = object({
+  video: VideoEncodeSchema,
+  audio: AudioEncodeSchema,
+  /**
+   * ffmpeg input-side args, inserted between the fixed global flags
+   * (`-hide_banner -loglevel error`) and `-i pipe:0`. Free-text array
+   * — the widget surfaces a textarea + suggestion chips for the most-
+   * used demuxer/format options.
+   */
+  inputArgs: array(string()).optional(),
+  /**
+   * ffmpeg output-side args, inserted between the encode block and
+   * the final `-f <muxer> pipe:1`. Use for muxer options, bitstream
+   * filters, codec-specific overrides. Free-text array.
+   */
+  outputArgs: array(string()).optional()
+});
 function errMsg(err) {
   if (err instanceof Error) return err.message;
   if (typeof err === "string") return err;
@@ -5586,18 +5895,74 @@ var DeviceType = /* @__PURE__ */ ((DeviceType2) => {
   DeviceType2["Sensor"] = "sensor";
   DeviceType2["Thermostat"] = "thermostat";
   DeviceType2["Button"] = "button";
+  DeviceType2["EventEmitter"] = "event-emitter";
+  DeviceType2["Update"] = "update";
   DeviceType2["Generic"] = "generic";
+  DeviceType2["Notifier"] = "notifier";
+  DeviceType2["Script"] = "script";
+  DeviceType2["Automation"] = "automation";
+  DeviceType2["Lock"] = "lock";
+  DeviceType2["Cover"] = "cover";
+  DeviceType2["Valve"] = "valve";
+  DeviceType2["Humidifier"] = "humidifier";
+  DeviceType2["WaterHeater"] = "water-heater";
+  DeviceType2["Fan"] = "fan";
+  DeviceType2["MediaPlayer"] = "media-player";
+  DeviceType2["AlarmPanel"] = "alarm-panel";
+  DeviceType2["Control"] = "control";
+  DeviceType2["Presence"] = "presence";
+  DeviceType2["Weather"] = "weather";
+  DeviceType2["Vacuum"] = "vacuum";
+  DeviceType2["LawnMower"] = "lawn-mower";
+  DeviceType2["Container"] = "container";
+  DeviceType2["Image"] = "image";
   return DeviceType2;
 })(DeviceType || {});
 var DeviceFeature = /* @__PURE__ */ ((DeviceFeature2) => {
   DeviceFeature2["BatteryOperated"] = "battery-operated";
   DeviceFeature2["Rebootable"] = "rebootable";
+  DeviceFeature2["Resyncable"] = "resyncable";
   DeviceFeature2["NativeSnapshot"] = "native-snapshot";
   DeviceFeature2["DoorbellButton"] = "doorbell-button";
   DeviceFeature2["TwoWayAudio"] = "two-way-audio";
   DeviceFeature2["PanTiltZoom"] = "pan-tilt-zoom";
   DeviceFeature2["PtzAutotrack"] = "ptz-autotrack";
   DeviceFeature2["MotionTrigger"] = "motion-trigger";
+  DeviceFeature2["LightColorRgb"] = "light-color-rgb";
+  DeviceFeature2["LightColorHsv"] = "light-color-hsv";
+  DeviceFeature2["LightColorMired"] = "light-color-mired";
+  DeviceFeature2["ClimateDualSetpoint"] = "climate-dual-setpoint";
+  DeviceFeature2["ClimateHumidity"] = "climate-humidity";
+  DeviceFeature2["ClimateFanMode"] = "climate-fan-mode";
+  DeviceFeature2["ClimatePreset"] = "climate-preset";
+  DeviceFeature2["CoverPositionable"] = "cover-positionable";
+  DeviceFeature2["CoverTilt"] = "cover-tilt";
+  DeviceFeature2["ValvePositionable"] = "valve-positionable";
+  DeviceFeature2["FanSpeed"] = "fan-speed";
+  DeviceFeature2["FanPreset"] = "fan-preset";
+  DeviceFeature2["FanDirection"] = "fan-direction";
+  DeviceFeature2["FanOscillating"] = "fan-oscillating";
+  DeviceFeature2["LockPinRequired"] = "lock-pin-required";
+  DeviceFeature2["LockOpen"] = "lock-open";
+  DeviceFeature2["MediaPlayerSeek"] = "media-player-seek";
+  DeviceFeature2["MediaPlayerVolume"] = "media-player-volume";
+  DeviceFeature2["MediaPlayerMute"] = "media-player-mute";
+  DeviceFeature2["MediaPlayerShuffle"] = "media-player-shuffle";
+  DeviceFeature2["MediaPlayerRepeat"] = "media-player-repeat";
+  DeviceFeature2["MediaPlayerSelectSource"] = "media-player-select-source";
+  DeviceFeature2["MediaPlayerPlayMedia"] = "media-player-play-media";
+  DeviceFeature2["MediaPlayerNext"] = "media-player-next";
+  DeviceFeature2["MediaPlayerPrevious"] = "media-player-previous";
+  DeviceFeature2["MediaPlayerStop"] = "media-player-stop";
+  DeviceFeature2["AlarmPinRequired"] = "alarm-pin-required";
+  DeviceFeature2["PresenceGps"] = "presence-gps";
+  DeviceFeature2["NotifierImage"] = "notifier-image";
+  DeviceFeature2["NotifierPriority"] = "notifier-priority";
+  DeviceFeature2["NotifierData"] = "notifier-data";
+  DeviceFeature2["NotifierActions"] = "notifier-actions";
+  DeviceFeature2["NotifierRecipients"] = "notifier-recipients";
+  DeviceFeature2["ScriptVariables"] = "script-variables";
+  DeviceFeature2["AutomationSkipCondition"] = "automation-skip-condition";
   return DeviceFeature2;
 })(DeviceFeature || {});
 var DeviceRole = /* @__PURE__ */ ((DeviceRole2) => {
@@ -5610,6 +5975,40 @@ var DeviceRole = /* @__PURE__ */ ((DeviceRole2) => {
   DeviceRole2["Nightvision"] = "nightvision";
   DeviceRole2["PrivacyMask"] = "privacy-mask";
   DeviceRole2["Doorbell"] = "doorbell";
+  DeviceRole2["BinaryHelper"] = "binary-helper";
+  DeviceRole2["MotionSensor"] = "motion-sensor";
+  DeviceRole2["ContactSensor"] = "contact-sensor";
+  DeviceRole2["LeakSensor"] = "leak-sensor";
+  DeviceRole2["SmokeSensor"] = "smoke-sensor";
+  DeviceRole2["COSensor"] = "co-sensor";
+  DeviceRole2["GasSensor"] = "gas-sensor";
+  DeviceRole2["TamperSensor"] = "tamper-sensor";
+  DeviceRole2["VibrationSensor"] = "vibration-sensor";
+  DeviceRole2["ConnectivitySensor"] = "connectivity-sensor";
+  DeviceRole2["SoundSensor"] = "sound-sensor";
+  DeviceRole2["BinarySensor"] = "binary-sensor";
+  DeviceRole2["TemperatureSensor"] = "temperature-sensor";
+  DeviceRole2["HumiditySensor"] = "humidity-sensor";
+  DeviceRole2["AmbientLightSensor"] = "ambient-light-sensor";
+  DeviceRole2["PressureSensor"] = "pressure-sensor";
+  DeviceRole2["PowerSensor"] = "power-sensor";
+  DeviceRole2["EnergySensor"] = "energy-sensor";
+  DeviceRole2["VoltageSensor"] = "voltage-sensor";
+  DeviceRole2["CurrentSensor"] = "current-sensor";
+  DeviceRole2["AirQualitySensor"] = "air-quality-sensor";
+  DeviceRole2["BatterySensor"] = "battery-sensor";
+  DeviceRole2["NumericSensor"] = "numeric-sensor";
+  DeviceRole2["EnumSensor"] = "enum-sensor";
+  DeviceRole2["DateTimeSensor"] = "datetime-sensor";
+  DeviceRole2["GenericSensor"] = "generic-sensor";
+  DeviceRole2["NumericControl"] = "numeric-control";
+  DeviceRole2["SelectControl"] = "select-control";
+  DeviceRole2["TextControl"] = "text-control";
+  DeviceRole2["DateTimeControl"] = "datetime-control";
+  DeviceRole2["MobilePushNotifier"] = "mobile-push-notifier";
+  DeviceRole2["MessagingNotifier"] = "messaging-notifier";
+  DeviceRole2["EmailNotifier"] = "email-notifier";
+  DeviceRole2["GenericNotifier"] = "generic-notifier";
   return DeviceRole2;
 })(DeviceRole || {});
 ({
@@ -5691,6 +6090,33 @@ const FeatureProbeStatusSchema = object({
     }) }
   }
 });
+object({
+  /** Carbon dioxide concentration in ppm. */
+  co2Ppm: number().min(0).optional(),
+  /** Total volatile organic compounds in ppb. */
+  vocPpb: number().min(0).optional(),
+  /** Particulate matter ≤ 2.5 μm in µg/m³. */
+  pm25: number().min(0).optional(),
+  /** Particulate matter ≤ 10 μm in µg/m³. */
+  pm10: number().min(0).optional(),
+  /** Composite AQI value (typically 0..500). */
+  aqi: number().optional(),
+  /** Ms epoch when the slice was last updated. */
+  lastFetchedAt: number(),
+  /** Live display unit of the single metric this slice carries (e.g. HA
+   *  `attributes.unit_of_measurement` → 'ppm' / 'ppb' / 'µg/m³'). Each
+   *  upstream `sensor.*` entity surfaces ONE device_class, so one unit
+   *  per slice is unambiguous. */
+  unit: string().optional(),
+  /** Suggested decimal places for numeric display.
+   *  Populated live from the upstream source when provided (e.g. HA
+   *  `attributes.suggested_display_precision`). Falls back to
+   *  auto-formatting when absent. */
+  precision: number().int().min(0).max(10).optional()
+});
+({
+  deviceTypes: [DeviceType.Sensor]
+});
 const ContributionSectionSchema = object({
   id: string(),
   title: string(),
@@ -5748,27 +6174,112 @@ function method(input, output, options) {
 function event(data) {
   return { data };
 }
-const AudioClassSummarySchema = object({
-  className: string(),
-  /** Number of windows (chunks) where this class was the top hit. */
-  hits: number().int().nonnegative(),
-  /** Mean score across those hits, clamped to [0,1]. */
-  avgScore: number().min(0).max(1),
-  /** Peak score in the window. */
-  peakScore: number().min(0).max(1)
+const AlarmStateSchema = _enum([
+  "disarmed",
+  "armed_home",
+  "armed_away",
+  "armed_night",
+  "armed_vacation",
+  "armed_custom_bypass",
+  "arming",
+  "disarming",
+  "pending",
+  "triggered"
+]);
+const AlarmArmModeSchema = _enum([
+  "home",
+  "away",
+  "night",
+  "vacation",
+  "custom_bypass"
+]);
+object({
+  /** Current lifecycle state. */
+  state: AlarmStateSchema,
+  /** Subset of arm modes the panel accepts. UI renders one button per
+   *  mode in this list. */
+  availableModes: array(AlarmArmModeSchema),
+  /** Whether the panel requires a PIN on arm / disarm. Mirrors
+   *  `DeviceFeature.AlarmPinRequired` for slice consumers. */
+  requiresCode: boolean(),
+  /** Ms epoch when the slice was last updated. */
+  lastChangedAt: number()
 });
-const AudioMetricsSnapshotSchema = object({
-  /** Wall-clock timestamp (ms) of the most recent audio window. */
-  ts: number().int(),
-  /** Sliding-window length (seconds) used for aggregation. */
-  windowSec: number().int().positive(),
-  /** Latest level reading from the most recent window. */
-  level: object({
-    rms: number(),
-    dbfs: number()
-  }),
-  /** Peak dBFS observed across the rolling window. */
-  peakDbfs: number(),
+({
+  deviceTypes: [DeviceType.AlarmPanel],
+  methods: {
+    arm: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        mode: AlarmArmModeSchema,
+        /** Optional PIN code. Required when `requiresCode === true`.
+         *  Passed through to the upstream service; never persisted. */
+        code: string().min(1).optional()
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    disarm: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        code: string().min(1).optional()
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    /**
+     * Force the panel into the `triggered` state — used by HA
+     * automations to surface external sensor events through the panel
+     * (e.g. a Reolink camera intrusion event firing the security
+     * system). Provider rejects when the panel hardware doesn't
+     * support a software-initiated trigger.
+     */
+    trigger: method(
+      object({ deviceId: number().int().nonnegative() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    )
+  }
+});
+object({
+  /** Current illuminance in lux (lx). */
+  lux: number().min(0),
+  /** Ms epoch when the slice was last updated. */
+  lastFetchedAt: number(),
+  /** Live display unit from the upstream source (e.g. HA
+   *  `attributes.unit_of_measurement`). The UI prefers this over the
+   *  role's canonical unit. Absent → fall back to the canonical unit. */
+  unit: string().optional(),
+  /** Suggested decimal places for numeric display.
+   *  Populated live from the upstream source when provided (e.g. HA
+   *  `attributes.suggested_display_precision`). Falls back to
+   *  auto-formatting when absent. */
+  precision: number().int().min(0).max(10).optional()
+});
+({
+  deviceTypes: [DeviceType.Sensor]
+});
+const AudioClassSummarySchema = object({
+  className: string(),
+  /** Number of windows (chunks) where this class was the top hit. */
+  hits: number().int().nonnegative(),
+  /** Mean score across those hits, clamped to [0,1]. */
+  avgScore: number().min(0).max(1),
+  /** Peak score in the window. */
+  peakScore: number().min(0).max(1)
+});
+const AudioMetricsSnapshotSchema = object({
+  /** Wall-clock timestamp (ms) of the most recent audio window. */
+  ts: number().int(),
+  /** Sliding-window length (seconds) used for aggregation. */
+  windowSec: number().int().positive(),
+  /** Latest level reading from the most recent window. */
+  level: object({
+    rms: number(),
+    dbfs: number()
+  }),
+  /** Peak dBFS observed across the rolling window. */
+  peakDbfs: number(),
   /** Mean dBFS across the rolling window. */
   avgDbfs: number(),
   /** Most recent above-threshold classification, or null on silence. */
@@ -5844,6 +6355,46 @@ const audioMetricsCapability = {
   /** Reactive runtime-state mirror — live `device.state.audioMetrics.value`. */
   runtimeState: AudioMetricsSnapshotSchema
 };
+object({
+  /** Whether the automation is currently enabled. Disabled automations
+   *  ignore their trigger block — manual `trigger` still works. */
+  enabled: boolean(),
+  /** Whether the automation is currently executing its action block. */
+  isRunning: boolean(),
+  /** Ms epoch of the last successful run. 0 when never run. */
+  lastTriggeredAt: number(),
+  /** Failure description from the last completed run. Null on success
+   *  or when never run. */
+  lastError: string().nullable(),
+  /** Ms epoch when the slice was last updated. */
+  lastChangedAt: number()
+});
+({
+  deviceTypes: [DeviceType.Automation],
+  methods: {
+    enable: method(
+      object({ deviceId: number().int().nonnegative() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    disable: method(
+      object({ deviceId: number().int().nonnegative() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    trigger: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        /** When true, fires the action block while bypassing the
+         *  automation's condition evaluation. Gated by
+         *  `DeviceFeature.AutomationSkipCondition`. */
+        skipCondition: boolean().optional()
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    )
+  }
+});
 const BatteryStatusSchema = object({
   /** 0..100 inclusive. Firmware-reported. */
   percentage: number().min(0).max(100),
@@ -5861,10 +6412,48 @@ const BatteryStatusSchema = object({
    */
   sleeping: boolean(),
   /** Ms epoch of the last observation. Lets consumers reason about freshness. */
-  lastUpdated: number()
+  lastUpdated: number(),
+  /**
+   * True when the source is a BINARY low-battery indicator (HA
+   * `binary_sensor` device_class=battery / `LOW_BAT`) that has no real
+   * charge level — `percentage` is then a coarse stand-in (100 = normal,
+   * sub-threshold = low). UI MUST render "Normal"/"Low" instead of a
+   * misleading exact percentage. Absent/false → genuine 0–100 % reading.
+   */
+  binary: boolean().optional()
 });
 ({
   deviceTypes: [DeviceType.Camera, DeviceType.Sensor, DeviceType.Button, DeviceType.Switch],
+  methods: {
+    /**
+     * Explicitly wake the camera from low-power sleep ahead of a
+     * streaming session start. Consumers that initiate a stream
+     * against a sleeping battery cam (HomeKit Secure Video, Alexa
+     * RTCSession, snapshot wrappers) call this with a short timeout
+     * before establishing the media pipeline — the broker's own
+     * passive wake-on-dial works but adds 5–7 seconds to first-frame,
+     * during which the consumer renders a black screen. Pre-waking
+     * compresses that gap.
+     *
+     * Returns `awoke: true` when the firmware acknowledged the wake
+     * before `timeoutMs`. Returns `awoke: false` when it timed out OR
+     * the cap surface is unavailable (no Baichuan / firmware
+     * channel); the caller should still attempt the stream — the
+     * passive broker wake remains as fallback.
+     */
+    wakeForStream: method(
+      object({
+        deviceId: number(),
+        /** Bound on the wait. Sensible range 3000–10000ms. */
+        timeoutMs: number().int().min(500).max(3e4).default(8e3)
+      }),
+      object({
+        awoke: boolean(),
+        durationMs: number()
+      }),
+      { kind: "mutation" }
+    )
+  },
   events: {
     /**
      * Emitted whenever the cached status changes (firmware push OR
@@ -5878,6 +6467,14 @@ const BatteryStatusSchema = object({
     }) }
   }
 });
+object({
+  on: boolean(),
+  /** Ms epoch of the last transition. 0 if never observed. */
+  lastChangedAt: number()
+});
+({
+  deviceTypes: [DeviceType.Sensor]
+});
 object({
   /** Current level as 0..100 inclusive. Firmware-reported. */
   percentage: number().min(0).max(100),
@@ -5909,287 +6506,199 @@ object({
     }) }
   }
 });
-const CamProfileSchema = _enum(["high", "mid", "low"]);
-const CamStreamKindSchema = _enum([
-  "pull-rtsp",
-  "pull-rtmp",
-  "pull-http",
-  "pull-rfc4571",
-  "push-annexb"
-]);
-const CamStreamResolutionSchema = object({
-  width: number().int().positive(),
-  height: number().int().positive()
+const StreamFormatSchema = _enum(["webrtc", "hls", "mjpeg", "rtsp"]);
+const StreamInfoSchema = object({
+  streamId: string(),
+  format: StreamFormatSchema,
+  url: string().nullable(),
+  active: boolean()
 });
-const CameraStreamSchema = object({
-  /** Stable, provider-assigned id unique within the (deviceId) scope. */
-  camStreamId: string().min(1),
-  deviceId: number().int().nonnegative(),
-  kind: CamStreamKindSchema,
-  /** Required for pull-* kinds. Ignored for push-annexb. */
-  url: string().optional(),
+({
+  methods: {
+    registerStream: method(
+      object({ streamId: string(), sourceUrl: string(), codec: string().optional() }),
+      _void(),
+      { kind: "mutation" }
+    ),
+    unregisterStream: method(object({ streamId: string() }), _void(), { kind: "mutation" }),
+    getStreamUrl: method(
+      object({ streamId: string(), format: StreamFormatSchema }),
+      string().nullable()
+    ),
+    listStreams: method(_void(), array(StreamInfoSchema))
+  }
+});
+const RtspRestreamEntrySchema = object({
+  brokerId: string(),
+  url: string(),
+  mutedUrl: string(),
+  enabled: boolean(),
+  /**
+   * Source-stream codec / resolution for the camStream this entry serves
+   * (the broker's "high"/"mid"/"low" profile slot for this device).
+   * Used by exporter pickers (`pickPreferredRtspEntry`) to resolve
+   * `streamPreference: 'auto'` to the slot whose source is closest to
+   * the consumer's target — Alexa wants ~720p, HomeKit wants ~1080p,
+   * and there's no point dialling the 4K slot for an Echo Show. Absent
+   * when the source publisher never advertised the field; pickers fall
+   * back to first-enabled in that case.
+   */
   codec: string().optional(),
-  resolution: CamStreamResolutionSchema.optional(),
-  fps: number().positive().optional(),
-  /** Human label surfaced in the Admin UI "Camera Stream" dropdown. */
+  resolution: object({
+    width: number().int().positive(),
+    height: number().int().positive()
+  }).optional()
+});
+const BrokerRtspClientSchema = object({
+  sessionId: string(),
+  remoteAddr: string(),
+  playing: boolean(),
+  muted: boolean(),
+  connectedAt: number(),
+  lastRtpAt: number(),
+  bytesSent: number()
+});
+const BrokerDecodedClientSchema = object({
+  tag: string(),
+  subscribedAt: number(),
+  maxFps: number(),
+  framesDelivered: number(),
+  framesDropped: number()
+});
+const BrokerAudioClientSchema = object({
+  tag: string(),
+  subscribedAt: number(),
+  chunksDelivered: number()
+});
+const BrokerConsumerKindSchema = _enum([
+  "alexa",
+  "homekit",
+  "webrtc-browser",
+  "webrtc-mobile",
+  "webrtc-whep",
+  "rtsp-listen",
+  "derived-broker",
+  "recording",
+  "pipeline",
+  "snapshot",
+  "warmup",
+  "unknown"
+]);
+const BrokerConsumerAttributionSchema = object({
+  kind: BrokerConsumerKindSchema,
+  /**
+   * Free-form label intended to disambiguate consumers OF THE SAME kind
+   * on the same broker — e.g. user name, device alias. Should NOT repeat
+   * the kind / cam / cam-stream / sessionId (those are surfaced by
+   * dedicated fields). When empty the widget falls back to `${kind} ·
+   * <sessionId tail>`.
+   */
   label: string().optional(),
   /**
-   * Device-level features the publisher advertised (e.g. `battery-operated`).
-   * The broker, snapshot orchestrator, and prebuffer manager all consult
-   * this list to derive policy — relaxed stall watchdog for battery
-   * cams, prebuffer off by default, longer snapshot rate-limit, etc.
+   * Which part of the encoded plane this subscription consumes:
+   *   - `'audio'` — audio packets only
+   *   - `'video'` — video packets only
+   *   - `'both'`  — both video + audio (typical for AnnexB push paths
+   *                 that don't split the source RTP)
    *
-   * Single source of truth replacing per-stream flags like the
-   * historical `allowStall`: if the publisher knows the camera is
-   * battery-powered, every downstream service derives the right policy
-   * from this list.
+   * Missing field means "unknown" — older callers and the legacy
+   * paths that haven't been migrated yet.
    */
-  deviceFeatures: array(string()).optional(),
+  media: _enum(["audio", "video", "both"]).optional(),
   /**
-   * Whether this stream participates in the broker's automatic profile
-   * assignment (`computeInitialAssignment`). Defaults to `true`. Publishers
-   * use `false` when they want a stream to be SELECTABLE in the UI but not
-   * picked by default — e.g. Reolink publishes its native Baichuan streams
-   * as `autoEligible: true` (the recommended path) and its RTSP / RTMP
-   * mirrors as `autoEligible: false` (still pickable per slot, just not
-   * the auto choice). Manual `assignProfile` calls remain valid for
-   * non-eligible streams.
+   * Codec the consumer receives AFTER any per-session re-encoding. For
+   * a WebRTC session this is the negotiated egress codec (e.g. `H264`,
+   * `H265`, `Opus`, `Pcmu`); for an RTSP restreamer it mirrors the
+   * source codec. Surfaced in the widget chip so operators see at a
+   * glance whether a viewer is on H.264 (Echo) or H.265 (Safari).
    */
-  autoEligible: boolean().optional(),
+  targetCodec: string().optional(),
   /**
-   * Transport-specific opaque metadata. The broker passes it through to
-   * the source reader without inspecting it. Currently used by
-   * `pull-rfc4571` streams to carry the upstream SDP (so the reader can
-   * route RTP packets to the right depacketizer without an in-band
-   * DESCRIBE phase). Other kinds typically leave it undefined.
+   * Whether the broker is re-encoding for this consumer:
+   *   - `'passthrough'` — bytes flow source→consumer without ffmpeg
+   *   - `'repacketize'` — RTP payload is re-packetized but NOT re-encoded
+   *                       (preserves frames, just rebuilds headers; e.g.
+   *                       the H.265 repacketizer path)
+   *   - `'transcode'`   — a full encode/decode round (ffmpeg, libx264,
+   *                       libav…); the most expensive path
    */
-  metadata: record(string(), unknown()).optional()
+  transport: _enum(["passthrough", "repacketize", "transcode"]).optional(),
+  /** Remote peer IP if the consumer terminates a network socket. */
+  remoteAddr: string().optional(),
+  /**
+   * Server-read User-Agent of the originating client; enriched by the hub
+   * from the tRPC request context (browser sessions).
+   */
+  userAgent: string().optional(),
+  /** Authenticated user id (CamStack OAuth subject) when known. */
+  userId: string().optional(),
+  /** Higher-level session identifier (Alexa Echo sessionId, HAP session, …). */
+  sessionId: string().optional(),
+  /** Free-form key/value extras (e.g. clientHints from a WebRTC offer). */
+  extra: record(string(), string()).optional()
+}).readonly();
+const BrokerEncodedClientSchema = object({
+  /** Stable id assigned on attach; used by `killClient`. */
+  id: string(),
+  /** Which broker fanout the subscriber rides — annexB encoded packets vs raw RTP. */
+  channel: _enum(["annexb", "rtp"]),
+  attribution: BrokerConsumerAttributionSchema,
+  subscribedAt: number(),
+  /** Total packets delivered (annex-B EncodedPackets or RTP byte-buffers). */
+  packetsDelivered: number()
 });
-const ProfileSlotStatusSchema = _enum([
-  "unassigned",
-  "idle",
-  "connecting",
-  "streaming",
-  "error"
+const BrokerClientsSchema = object({
+  rtsp: array(BrokerRtspClientSchema).readonly(),
+  decoded: array(BrokerDecodedClientSchema).readonly(),
+  audio: array(BrokerAudioClientSchema).readonly(),
+  encoded: array(BrokerEncodedClientSchema).readonly(),
+  pipeClients: number(),
+  /** Total encoded + raw-RTP callback subscriber count (sum of `encoded[].length`). */
+  encodedSubscribers: number()
+});
+_enum([
+  "reconnecting",
+  "sleeping",
+  "offline",
+  "disabled",
+  "waking"
 ]);
-const ProfileSlotSchema = object({
+const VideoCodecTargetSchema = _enum(["h264", "h265", "copy"]);
+const AudioCodecTargetSchema = _enum(["aac", "opus", "pcmu", "copy", "none"]);
+const GetStreamWithCodecInputSchema = object({
   deviceId: number().int().nonnegative(),
-  profile: CamProfileSchema,
-  /** Broker id the rest of the system addresses: `${deviceId}/${profile}`. */
-  brokerId: string(),
-  /** `null` when the profile is unassigned. */
-  sourceCamStreamId: string().nullable(),
-  status: ProfileSlotStatusSchema,
-  resolution: CamStreamResolutionSchema.optional(),
-  codec: string().optional(),
-  preBufferSec: number().nonnegative().optional(),
-  errorMessage: string().optional()
-});
-const StreamSourceEntrySchema$1 = object({
-  id: string(),
-  label: string(),
-  protocol: _enum(["rtsp", "rtmp", "annexb", "http-mjpeg", "webrtc", "custom"]),
-  url: string().optional(),
-  resolution: object({ width: number(), height: number() }).readonly().optional(),
-  fps: number().optional(),
-  bitrate: number().optional(),
-  codec: string().optional(),
-  profileHint: _enum(["high", "mid", "low"]).optional()
+  /** Target codec. `'copy'` = passthrough (no re-encode). */
+  video: VideoCodecTargetSchema,
+  /** Target audio codec. `'copy'` = passthrough. Defaults to `'aac'`. */
+  audio: AudioCodecTargetSchema.optional(),
+  /** Target a profile's assigned source camStream. Required to resolve a source. */
+  profile: CamProfileSchema.optional(),
+  /** Optional output resolution target. When set: drives the transcode
+   *  output scale (downscale toward WxH), and — when `profile` is absent —
+   *  selects the published source closest to this resolution. Ignored for
+   *  `video:'copy'` scaling (a copy can't be rescaled), but still used for
+   *  source selection. */
+  targetResolution: object({ width: number().int().positive(), height: number().int().positive() }).optional(),
+  /** Extra ffmpeg output flags appended verbatim by the consumer (in code).
+   *  Folded into the pipeline key so different args never share a child. */
+  outputArgs: array(string()).optional(),
+  /** Opt-in: carry transcoded audio over an RTP sidecar grafted into the
+   *  restreamer SDP (only for re-encoded audio targets — aac/opus/pcmu).
+   *  Default/absent = the live-verified video-only egress. */
+  audioEgress: boolean().optional(),
+  tag: string().optional()
 });
-object({
-  type: string(),
+const RtpSourceSchema = object({
   url: string(),
-  videoCodec: string().optional(),
-  audioCodec: string().optional(),
-  metadata: record(string(), unknown()).readonly().optional()
-});
-const EncodedPacketSchema = object({
-  type: _enum(["video", "audio"]),
-  data: _instanceof(Uint8Array),
-  pts: number(),
-  dts: number(),
-  keyframe: boolean(),
-  codec: string()
-});
-const DecodedFrameSchema = object({
-  data: _instanceof(Uint8Array),
-  width: number(),
-  height: number(),
-  format: _enum(["jpeg", "rgb", "bgr", "yuv420", "gray"]),
-  timestamp: number()
-});
-const FrameHandleSchema = object({
-  shmId: string(),
-  slot: number().int().nonnegative(),
-  seq: number().int().nonnegative(),
-  width: number().int().positive(),
-  height: number().int().positive(),
-  format: _enum(["jpeg", "rgb", "bgr", "yuv420", "gray"]),
-  pts: number(),
-  byteLength: number().int().nonnegative(),
-  nodeId: string(),
-  slotCount: number().int().positive()
-});
-const FrameHandleFormatSchema = _enum(["rgb", "bgr", "yuv420", "gray"]);
-const SubscribeFramesInputSchema = object({
-  brokerId: string(),
-  format: FrameHandleFormatSchema,
-  /**
-   * Optional reader-side cadence hint in frames per second. The broker does
-   * NOT throttle — latest-wins ring reads drop frames implicitly for a slow
-   * consumer. The value is echoed back in `SubscribeFramesResult.maxFps` so
-   * the consumer can pace its own `pullFrameHandles` polling.
-   */
-  maxFps: number().positive().optional(),
-  /** Short caller-identity tag (`motion`, `detection`, …) for diagnostics. */
-  tag: string().optional()
-});
-const SubscribeFramesResultSchema = object({
-  /** Opaque id the consumer passes to `pullFrameHandles` / `unsubscribeFrames`. */
-  subscriptionId: string(),
-  /** Reader-side cadence hint (frames/s) — echoes `SubscribeFramesInput.maxFps`. */
-  maxFps: number().nonnegative()
-});
-const DecodedAudioChunkSchema = object({
-  data: _instanceof(Uint8Array),
-  sampleRate: number().int().positive(),
-  channels: number().int().positive(),
-  timestamp: number()
-});
-const SubscribeAudioChunksInputSchema = object({
-  brokerId: string(),
-  /** Short caller-identity tag (`audio-analyzer`, …) for `listClients`. */
-  tag: string().optional()
-});
-const SubscribeAudioChunksResultSchema = object({
-  /** Opaque id passed to `pullAudioChunks` / `unsubscribeAudioChunks`. */
-  subscriptionId: string()
-});
-const BrokerStatusSchema$1 = _enum(["idle", "connecting", "streaming", "error", "stopped"]);
-const BrokerStatsSchema = object({
-  status: BrokerStatusSchema$1,
-  inputFps: number(),
-  decodeFps: number(),
-  encodedSubscribers: number(),
-  decodedSubscribers: number(),
-  uptimeMs: number(),
-  bitrateKbps: number(),
-  idrIntervalMs: number(),
-  codec: string().optional(),
-  totalBytes: number(),
-  packetCount: number(),
-  rtspClients: number(),
-  pipeClients: number(),
-  preBufferSec: number(),
-  preBufferMs: number(),
-  preBufferPackets: number(),
-  /**
-   * Moleculer node id of the decoder provider currently servicing this
-   * stream's decoded subscribers. `null` until the deferred decoder is
-   * created (no decoded clients yet, or codec not detected). Surfaces the
-   * runtime decoder placement so the UI can show "Decoder: <agent>" without
-   * a separate cap call per broker.
-   */
-  decoderNodeId: string().nullable(),
-  /**
-   * Detected audio track parameters from the RTSP DESCRIBE / SDP. `null`
-   * when the stream has no audio track or the broker is in cold start.
-   * `supported = false` means the codec was detected but the local
-   * decoder pipeline cannot produce PCM chunks (e.g. AAC without the
-   * AAC pipeline wired). Surfaced in the UI device-overview so operators
-   * can pre-pick the audio-analysis model that matches the codec.
-   */
-  audio: object({
-    codec: string(),
-    sampleRate: number(),
-    channels: number(),
-    supported: boolean()
-  }).nullable().optional()
-});
-const StreamFormatSchema = _enum(["webrtc", "hls", "mjpeg", "rtsp"]);
-const StreamInfoSchema = object({
-  streamId: string(),
-  format: StreamFormatSchema,
-  url: string().nullable(),
-  active: boolean()
-});
-({
-  methods: {
-    registerStream: method(
-      object({ streamId: string(), sourceUrl: string(), codec: string().optional() }),
-      _void(),
-      { kind: "mutation" }
-    ),
-    unregisterStream: method(object({ streamId: string() }), _void(), { kind: "mutation" }),
-    getStreamUrl: method(
-      object({ streamId: string(), format: StreamFormatSchema }),
-      string().nullable()
-    ),
-    listStreams: method(_void(), array(StreamInfoSchema))
-  }
-});
-const RtspRestreamEntrySchema = object({
-  brokerId: string(),
-  url: string(),
-  mutedUrl: string(),
-  enabled: boolean()
-});
-const BrokerRtspClientSchema = object({
-  sessionId: string(),
-  remoteAddr: string(),
-  playing: boolean(),
-  muted: boolean(),
-  connectedAt: number(),
-  lastRtpAt: number(),
-  bytesSent: number()
-});
-const BrokerDecodedClientSchema = object({
-  tag: string(),
-  subscribedAt: number(),
-  maxFps: number(),
-  framesDelivered: number(),
-  framesDropped: number()
-});
-const BrokerAudioClientSchema = object({
-  tag: string(),
-  subscribedAt: number(),
-  chunksDelivered: number()
-});
-const BrokerClientsSchema = object({
-  rtsp: array(BrokerRtspClientSchema).readonly(),
-  decoded: array(BrokerDecodedClientSchema).readonly(),
-  audio: array(BrokerAudioClientSchema).readonly(),
-  pipeClients: number(),
-  encodedSubscribers: number()
-});
-_enum([
-  "reconnecting",
-  "sleeping",
-  "offline",
-  "disabled",
-  "waking"
-]);
-const VideoCodecTargetSchema = _enum(["H264", "H265", "auto"]);
-const AudioCodecTargetSchema = _enum(["AAC", "Opus", "PCMU", "none"]);
-const MaxResolutionSchema = object({
-  width: number().int().positive(),
-  height: number().int().positive()
-});
-const GetStreamWithCodecInputSchema = object({
-  deviceId: number().int().nonnegative(),
-  videoCodec: VideoCodecTargetSchema,
-  audioCodec: AudioCodecTargetSchema.optional(),
-  maxResolution: MaxResolutionSchema.optional(),
-  tag: string().optional()
-});
-const RtpSourceSchema = object({
-  url: string(),
-  videoCodec: _enum(["H264", "H265"]),
-  audioCodec: string(),
-  resolution: MaxResolutionSchema,
-  transcoded: boolean(),
-  encoder: string(),
-  pipelineKey: string()
+  videoCodec: _enum(["H264", "H265"]),
+  audioCodec: string(),
+  resolution: object({
+    width: number().int().positive(),
+    height: number().int().positive()
+  }),
+  transcoded: boolean(),
+  encoder: string(),
+  pipelineKey: string()
 });
 ({
   methods: {
@@ -6205,7 +6714,17 @@ const RtpSourceSchema = object({
         label: string().optional(),
         deviceFeatures: array(string()).optional(),
         autoEligible: boolean().optional(),
-        metadata: record(string(), unknown()).optional()
+        metadata: record(string(), unknown()).optional(),
+        /** Required when kind === 'derived' — the source camStreamId the
+         *  derived broker reads its encoded plane from.
+         *  The runtime guard (broker manager, Task 10) enforces presence for
+         *  kind === 'derived'; the schema stays permissive so ts-morph emits
+         *  full field types instead of collapsing to ZodEffects. */
+        sourceCamStreamId: string().min(1).optional(),
+        /** Required when kind === 'derived' — the ffmpeg params for the
+         *  spawn. Reuses the same brokerId for identical params (single-flight).
+         *  Runtime guard in broker manager; schema is permissive (see above). */
+        encodeProfile: EncodeProfileSchema.optional()
       }),
       object({ success: literal(true) }),
       { kind: "mutation", auth: "admin" }
@@ -6268,12 +6787,21 @@ const RtpSourceSchema = object({
       object({ success: boolean() }),
       { kind: "mutation", auth: "admin" }
     ),
+    /**
+     * LEGACY / observability. Returns a raw per-broker restream URL for a
+     * single stream. Prefer {@link getStreamWithCodec} for programmatic
+     * CONSUMPTION — it is the single demand-counted entry that rides the
+     * broker's one source dial and returns a codec-correct passthrough.
+     */
     getStreamUrl: method(
       object({ streamId: string(), format: StreamFormatSchema }),
       object({ url: string() })
     ),
     /**
-     * Shared codec-targeted stream API — see Task #184.
+     * Shared codec-targeted stream API — see Task #184. THE single public
+     * stream-acquisition surface for programmatic consumers: single-dial
+     * (rides the broker's one source pull) and passthrough-correct
+     * (`videoCodec:'auto'` → `-c copy`, never a needless re-encode).
      * Resolution order: source-select → HW transcode → libx264/libx265.
      */
     getStreamWithCodec: method(
@@ -6367,10 +6895,20 @@ const RtpSourceSchema = object({
       object({ configuredSec: number(), bufferedMs: number(), packetCount: number() })
     ),
     getRtspPort: method(_void(), number()),
+    /**
+     * Enumeration surface — backs the admin RTSP-export picker and
+     * `pickPreferredRtspEntry`. Lists every per-broker restream entry. NOT a
+     * consumption API: programmatic readers use {@link getStreamWithCodec}.
+     */
     getAllRtspEntries: method(
       object({ hostname: string().optional() }),
       array(RtspRestreamEntrySchema).readonly()
     ),
+    /**
+     * LEGACY / observability. Resolves one broker's restream entry. Prefer
+     * {@link getStreamWithCodec} for programmatic CONSUMPTION so the read is
+     * demand-counted and rides the single source dial.
+     */
     getRtspEntry: method(
       object({ brokerId: string(), hostname: string().optional() }),
       RtspRestreamEntrySchema.nullable()
@@ -6407,203 +6945,1099 @@ const RtpSourceSchema = object({
     }))
   }
 });
+const STREAM_CODEC_VALUES = ["h264", "h265", "hevc", "av1", "mjpeg", "vp8", "vp9"];
+const StreamCodecSchema = _enum(STREAM_CODEC_VALUES);
+const PickStreamRequirementsSchema = object({
+  /**
+   * Codecs the consumer can decode without an intermediate transcode.
+   * Match is case-insensitive against the camera stream's `codec`.
+   * Default (omitted / empty array): no codec filter — useful when the
+   * consumer just wants "the highest-quality stream of any codec".
+   */
+  acceptCodecs: array(StreamCodecSchema).readonly().optional(),
+  /** Minimum vertical resolution. Streams shorter than this are dropped. */
+  minHeight: number().int().positive().optional(),
+  /** Minimum horizontal resolution. */
+  minWidth: number().int().positive().optional(),
+  /**
+   * When true (default), `derived:*` streams (transcoded broker pipes)
+   * are excluded — the caller wants a SOURCE stream the broker can
+   * forward without a re-encode. Set false to allow derived in the
+   * picker (useful for a "best playable" fallback).
+   */
+  excludeDerived: boolean().optional(),
+  /**
+   * Bypass gate. When set, the picker returns a hit ONLY IF the device
+   * also exposes a non-derived stream in one of these (rejected) codecs.
+   * Mirrors the Alexa "bypass only when the natural path WOULD have
+   * transcoded" guard: if the device is already serving the consumer's
+   * codec end-to-end, there's nothing to optimise.
+   */
+  requireSiblingCodec: array(StreamCodecSchema).readonly().optional()
+}).readonly();
+const PickStreamPreferencesSchema = object({
+  /**
+   * Ordered list of provider prefixes (e.g. `['native:', 'rtsp:']`) the
+   * picker prefers — earlier entries win ties. Defaults to
+   * `['native:']`, mirroring Alexa's "prefer the native dial path".
+   */
+  preferredProviders: array(string()).readonly().optional(),
+  /**
+   * Resolution preference within the surviving candidates. `'highest'`
+   * picks the tallest stream; `'lowest'` picks the shortest (used by
+   * memory-constrained consumers / Apple Home guest sessions).
+   */
+  resolutionPreference: _enum(["highest", "lowest"]).optional()
+}).readonly();
+const PickedCamStreamSchema = object({
+  camStreamId: string(),
+  codec: string().optional(),
+  resolution: CamStreamResolutionSchema.optional(),
+  /** One-line explanation of why this stream won — for logs / debug UI. */
+  reason: string()
+});
+({
+  deviceTypes: [DeviceType.Camera],
+  methods: {
+    getCameraStreams: method(
+      object({ deviceId: number().int().nonnegative() }),
+      array(CameraStreamSchema).readonly()
+    ),
+    getBrokerStreams: method(
+      object({ deviceId: number().int().nonnegative() }),
+      array(ProfileSlotSchema).readonly()
+    ),
+    /**
+     * Per-device RAW RTSP restream entries — one per published camStream
+     * that has RTSP restream enabled (`native:main`, `rtsp:sub`, …).
+     *
+     * LIVE-VIEW ONLY. This is the surface the device-details stream
+     * picker uses so an operator can hit each physical stream directly.
+     * Programmatic / external consumers (HAP, Alexa, ha-mqtt, recording)
+     * MUST use `getProfileRtspEntries` instead — picking from raw
+     * variants makes two consumers of the same camera land on two
+     * different physical pulls (e.g. Reolink `native:main` vs
+     * `rtsp:main`) and trips the camera's concurrent-session limit.
+     */
+    getRtspEntries: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        /** Override hostname embedded in returned URLs. Defaults to the broker's bound address. */
+        hostname: string().optional()
+      }),
+      array(RtspRestreamEntrySchema).readonly()
+    ),
+    /**
+     * Per-device PROFILE RTSP restream entries — one per ASSIGNED
+     * profile slot (high/mid/low). Each entry's `url` is a profile-keyed
+     * broker restream that aliases the profile's assigned source broker,
+     * so HAP / Alexa / recording / WebRTC all converge on the broker's
+     * single on-demand pull for that profile. This is the supported
+     * exporter-facing surface; the raw `getRtspEntries` is live-view
+     * only. Returns `[]` for a device with no assigned profiles
+     * (cold-start before first publish).
+     */
+    getProfileRtspEntries: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        /** Override hostname embedded in returned URLs. Defaults to the broker's bound address. */
+        hostname: string().optional()
+      }),
+      array(ProfileRtspEntrySchema).readonly()
+    ),
+    /**
+     * "Best source stream for these decode constraints". Returns the
+     * camStreamId the caller should dial (or null when no stream
+     * matches). See `PickStreamRequirementsSchema` for the filter shape
+     * and `PickStreamPreferencesSchema` for the ranking inputs.
+     *
+     * Returning null instructs the caller to fall back to its existing
+     * path (derived-broker transcode, profile-slot pick, etc.) — the
+     * picker NEVER ranks `derived:*` candidates as a "match" because
+     * its whole job is to avoid the transcode.
+     */
+    pickStream: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        requirements: PickStreamRequirementsSchema,
+        preferences: PickStreamPreferencesSchema.optional()
+      }),
+      PickedCamStreamSchema.nullable()
+    )
+  },
+  events: {
+    /** Fires on publishCameraStream / retractCameraStream. */
+    onCamStreamsChanged: event(object({
+      deviceId: number().int().nonnegative(),
+      camStreams: array(CameraStreamSchema).readonly()
+    })),
+    /** Fires on assignProfile / unassignProfile / runtime status change. */
+    onProfileSlotsChanged: event(object({
+      deviceId: number().int().nonnegative(),
+      profileSlots: array(ProfileSlotSchema).readonly()
+    }))
+  },
+  /**
+   * Per-device live stream-broker state. Persistent settings (RTSP
+   * tokens, profile assignments, pre-buffer config, RTSP-enabled toggles,
+   * streamingDebug) stay in the broker's addon store — they survive
+   * restarts. The slice below carries ONLY what's truly runtime:
+   *
+   *   - `online` — at least one profile slot is currently `'streaming'`.
+   *     Drivers without a firmware liveness signal (RTSP, ONVIF…) can
+   *     subscribe and mirror this into `state.deviceStatus.online`.
+   *   - `slotStatuses` — current `ProfileSlotStatus` per profile,
+   *     mirroring the runtime-mutable subset of `ProfileSlot`.
+   *   - `slotErrors` — last error message per profile (only set when the
+   *     corresponding slot is in `'error'`).
+   *   - `lastChangedAt` — freshness signal for consumers that want to
+   *     reason about how stale the slice is.
+   *
+   * Written by the stream-broker manager on every transition that
+   * affects these aggregates. Read via `device.state.cameraStreams.<field>`
+   * (BaseDevice proxy) or, cross-process, via
+   * `device-state.getCapSlice({deviceId, capName: 'camera-streams'})`.
+   * The cap's `onChanged` event fires automatically on each write so
+   * subscribers get push semantics for free.
+   */
+  runtimeState: object({
+    online: boolean(),
+    slotStatuses: object({
+      high: ProfileSlotStatusSchema.optional(),
+      mid: ProfileSlotStatusSchema.optional(),
+      low: ProfileSlotStatusSchema.optional()
+    }),
+    slotErrors: object({
+      high: string().optional(),
+      mid: string().optional(),
+      low: string().optional()
+    }),
+    lastChangedAt: number()
+  })
+});
+object({
+  detected: boolean(),
+  /** Ms epoch of the last transition. 0 if never observed. */
+  lastChangedAt: number()
+});
+({
+  deviceTypes: [DeviceType.Sensor]
+});
+const HvacModeSchema = _enum([
+  "off",
+  "heat",
+  "cool",
+  "auto",
+  "heat_cool",
+  "fan_only",
+  "dry"
+]);
+object({
+  /** Active HVAC mode. */
+  mode: HvacModeSchema,
+  /** Available HVAC modes the device accepts. Subset of HvacMode. */
+  availableModes: array(HvacModeSchema),
+  /** Active fan mode (`auto` / `low` / `medium` / `high` / `on` / `off`
+   *  / vendor-specific) — empty string when the device has no fan
+   *  surface. */
+  fanMode: string(),
+  /** Available fan modes the device accepts. */
+  availableFanModes: array(string()),
+  /** Active preset (`eco` / `away` / `sleep` / vendor-specific) —
+   *  empty string when no preset is active or the device has no
+   *  preset surface. */
+  preset: string(),
+  /** Available presets the device accepts. */
+  availablePresets: array(string()),
+  /** Single setpoint in Celsius. Used by single-target modes
+   *  (heat / cool / dry). Null when the device is in a range mode
+   *  (`heat_cool`) or has no setpoint at all (`fan_only`/`off`). */
+  target: number().nullable(),
+  /** Upper bound of the dual setpoint in Celsius. Populated only
+   *  in `heat_cool` mode. */
+  targetHigh: number().nullable(),
+  /** Lower bound of the dual setpoint in Celsius. Populated only
+   *  in `heat_cool` mode. */
+  targetLow: number().nullable(),
+  /** Target relative humidity (0..100). Null when the device has no
+   *  humidity control. */
+  targetHumidity: number().min(0).max(100).nullable(),
+  /** Current measured temperature in Celsius. Read-only — pushed by
+   *  the device's internal sensor. */
+  currentTemp: number().nullable(),
+  /** Current measured relative humidity (0..100). Read-only. */
+  currentHumidity: number().min(0).max(100).nullable(),
+  /** Ms epoch when the slice was last updated (push or command). */
+  lastFetchedAt: number()
+});
+({
+  deviceTypes: [DeviceType.Thermostat],
+  methods: {
+    setMode: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        mode: HvacModeSchema
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    setFanMode: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        fanMode: string().min(1)
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    setPreset: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        preset: string().min(1)
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    setTarget: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        target: number()
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    setTargetRange: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        targetLow: number(),
+        targetHigh: number()
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    setTargetHumidity: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        targetHumidity: number().min(0).max(100)
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    )
+  }
+});
+const RgbTripletSchema = object({
+  r: number().int().min(0).max(255),
+  g: number().int().min(0).max(255),
+  b: number().int().min(0).max(255)
+});
+const HsvTripletSchema = object({
+  /** Hue in degrees, 0..360. */
+  h: number().min(0).max(360),
+  /** Saturation as 0..100 inclusive. */
+  s: number().min(0).max(100),
+  /** Value/brightness as 0..100 inclusive. */
+  v: number().min(0).max(100)
+});
+const ColorInputSchema = discriminatedUnion("mode", [
+  object({ mode: literal("rgb"), rgb: RgbTripletSchema }),
+  object({ mode: literal("hsv"), hsv: HsvTripletSchema }),
+  object({ mode: literal("mired"), mireds: number().int().min(50).max(1e3) })
+]);
+object({
+  /** Active color mode — which of `rgb` / `hsv` / `mireds` reflects
+   *  the bulb's current state. */
+  mode: _enum(["rgb", "hsv", "mired"]),
+  /** Populated when `mode === 'rgb'`. */
+  rgb: RgbTripletSchema.optional(),
+  /** Populated when `mode === 'hsv'`. */
+  hsv: HsvTripletSchema.optional(),
+  /** Populated when `mode === 'mired'`. */
+  mireds: number().int().optional(),
+  /** Ms epoch of the last operator-driven change. */
+  lastChangedAt: number()
+});
+({
+  deviceTypes: [DeviceType.Light],
+  methods: {
+    setColor: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        color: ColorInputSchema
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    )
+  },
+  events: {
+    /**
+     * Emitted whenever the color changes — operator action OR firmware
+     * push. Subscribers (UI color pickers, automation engines) react
+     * without polling.
+     */
+    onColorChanged: { data: object({
+      deviceId: number(),
+      mode: _enum(["rgb", "hsv", "mired"]),
+      rgb: RgbTripletSchema.optional(),
+      hsv: HsvTripletSchema.optional(),
+      mireds: number().int().optional(),
+      lastChangedAt: number()
+    }) }
+  }
+});
+object({
+  /** True when the upstream system considers the entity connected. */
+  connected: boolean(),
+  /** Ms epoch of the last transition. 0 if never observed. */
+  lastChangedAt: number()
+});
+({
+  deviceTypes: [DeviceType.Sensor]
+});
+const ConsumableItemSchema = object({
+  /** Stable id, e.g. 'main-brush'. */
+  key: string().min(1),
+  /** Display name. */
+  label: string().min(1),
+  /** Remaining life % when known (0..100). */
+  level: number().min(0).max(100).nullable(),
+  /** Discrete state when known (binary mode). */
+  status: _enum(["ok", "replace"]).nullable(),
+  /** Ms epoch of the last replace, when known. */
+  lastResetAt: number().nullable(),
+  /** Whether `reset()` is meaningful for this item. */
+  resettable: boolean()
+});
+const ConsumablesStatusSchema = object({
+  items: array(ConsumableItemSchema),
+  lastChangedAt: number()
+});
+({
+  // Device-agnostic — any device may expose consumables, so the cap
+  // binds on EVERY DeviceType. The list enumerates every enum member
+  // (kept in sync with `device-type.ts`) rather than a subset, so a
+  // provider on any device type — vacuums/mowers included — can register
+  // it and no future device type silently fails to bind.
+  deviceTypes: [
+    DeviceType.Camera,
+    DeviceType.Hub,
+    DeviceType.Light,
+    DeviceType.Siren,
+    DeviceType.Switch,
+    DeviceType.Sensor,
+    DeviceType.Thermostat,
+    DeviceType.Button,
+    DeviceType.EventEmitter,
+    DeviceType.Update,
+    DeviceType.Generic,
+    DeviceType.Notifier,
+    DeviceType.Script,
+    DeviceType.Automation,
+    DeviceType.Lock,
+    DeviceType.Cover,
+    DeviceType.Valve,
+    DeviceType.Humidifier,
+    DeviceType.WaterHeater,
+    DeviceType.Fan,
+    DeviceType.MediaPlayer,
+    DeviceType.AlarmPanel,
+    DeviceType.Control,
+    DeviceType.Presence,
+    DeviceType.Weather,
+    DeviceType.Vacuum,
+    DeviceType.LawnMower,
+    DeviceType.Container,
+    DeviceType.Image
+  ],
+  methods: {
+    /** Mark a consumable as replaced — resets its remaining life. Only
+     *  meaningful when the item's `resettable` is true. */
+    reset: method(
+      object({ deviceId: number().int().nonnegative(), key: string().min(1) }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    )
+  },
+  // Per the cap checklist, runtimeState carries the bridge helper's
+  // freshness field. The status surface stays the plain schema; only the
+  // persistent slice gains `lastFetchedAt` so future poll-backed
+  // providers can use the runtime-state bridge unchanged.
+  runtimeState: ConsumablesStatusSchema.extend({ lastFetchedAt: number() })
+});
+object({
+  /** True when the entry is open; false when closed. */
+  entryOpen: boolean(),
+  /** Ms epoch of the last open↔closed transition. 0 if never observed. */
+  lastChangedAt: number()
+});
+({
+  deviceTypes: [DeviceType.Sensor]
+});
+const ControlKindSchema = _enum(["numeric", "select", "text", "datetime"]);
+object({
+  kind: ControlKindSchema,
+  /** Current value. Numeric kind → number; select/text/datetime → string.
+   *  Datetime values are ISO 8601 strings (full timestamp, date-only,
+   *  or time-only — HA accepts all three forms). */
+  value: union([number(), string()]),
+  /** Acceptable values when `kind === 'select'`. Empty for other kinds. */
+  options: array(string()),
+  /** Ms epoch when the slice was last updated. */
+  lastChangedAt: number(),
+  /** Display unit-of-measurement (e.g. '°C', '%', 'lx').
+   *  Populated live from HA `attributes.unit_of_measurement` on each push.
+   *  Meaningful for `kind === 'numeric'`; absent for other kinds. */
+  unit: string().optional(),
+  /** Minimum allowed value. Populated live from HA `attributes.min`.
+   *  Meaningful for `kind === 'numeric'`; absent for other kinds. */
+  min: number().optional(),
+  /** Maximum allowed value. Populated live from HA `attributes.max`.
+   *  Meaningful for `kind === 'numeric'`; absent for other kinds. */
+  max: number().optional(),
+  /** Step increment. Populated live from HA `attributes.step`.
+   *  Meaningful for `kind === 'numeric'`; absent for other kinds. */
+  step: number().optional(),
+  /** Suggested decimal places for numeric display. Populated live from HA
+   *  `attributes.suggested_display_precision`, or derived from `step` when the
+   *  HA attribute is absent. Meaningful for `kind === 'numeric'`; absent for
+   *  other kinds. Falls back to auto-formatting when absent. */
+  precision: number().int().min(0).max(10).optional(),
+  /** Date-picker granularity for `kind === 'datetime'`. 'date' → date-only,
+   *  'time' → time-only, 'datetime' → full timestamp. Absent for other kinds
+   *  (UI defaults to 'datetime'). Derived live from the device's HA domain
+   *  (date.* / time.* / datetime.*) or, for input_datetime, from the entity's
+   *  `has_date`/`has_time` attributes on each push. */
+  format: _enum(["date", "time", "datetime"]).optional()
+});
+const ControlSetValueInputSchema = discriminatedUnion("kind", [
+  object({ kind: literal("numeric"), value: number() }),
+  object({ kind: literal("select"), value: string().min(1) }),
+  object({ kind: literal("text"), value: string() }),
+  object({ kind: literal("datetime"), value: string().min(1) })
+]);
+({
+  deviceTypes: [DeviceType.Control],
+  methods: {
+    setValue: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        control: ControlSetValueInputSchema
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    )
+  }
+});
+const CoverStateSchema = _enum([
+  "open",
+  "opening",
+  "closing",
+  "closed",
+  "stopped"
+]);
+object({
+  /** Lifecycle state of the cover. */
+  state: CoverStateSchema,
+  /** 0 = fully closed, 100 = fully open. Null when the device has
+   *  no intermediate position surface. */
+  position: number().min(0).max(100).nullable(),
+  /** 0 = closed slats, 100 = open slats. Null when no tilt support. */
+  tiltPosition: number().min(0).max(100).nullable(),
+  /** Ms epoch when the slice was last updated. */
+  lastChangedAt: number()
+});
+({
+  deviceTypes: [DeviceType.Cover],
+  methods: {
+    open: method(
+      object({ deviceId: number().int().nonnegative() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    close: method(
+      object({ deviceId: number().int().nonnegative() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    stop: method(
+      object({ deviceId: number().int().nonnegative() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    setPosition: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        position: number().min(0).max(100)
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    setTiltPosition: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        tiltPosition: number().min(0).max(100)
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    )
+  }
+});
+const SourceInfoSchema = object({
+  // ── Identity (required) ─────────────────────────────────────────
+  /** Live dispatch key — mutable when the source system allows rename. */
+  id: string(),
+  /** Source system tag — e.g. 'homeassistant' | 'reolink' | 'frigate'. */
+  system: string(),
+  // ── Stability (optional) ────────────────────────────────────────
+  /** Immutable upstream identifier when available (HA `unique_id`, … ).
+   *  Used to detect rename when `id` changes. */
+  uniqueId: string().optional(),
+  // ── Free-form passthrough ───────────────────────────────────────
+  /** Provider-specific extras that don't fit the structured slots.
+   *  Whitelist what goes here per provider — do NOT dump entire HA
+   *  attribute blobs (would explode the meta JSON column). */
+  raw: record(string(), unknown()).optional()
+});
+const DiscoveredChildStatusSchema = _enum(["online", "sleeping", "offline", "unknown"]);
+const DiscoveredChildDeviceSchema = lazy(
+  () => object({
+    /** Stable, integration-defined identifier. Must be unique per parent and persistent across reboots. */
+    childNativeId: string(),
+    /** Friendly name as reported by the source (Reolink camera name, ONVIF profile, ...). */
+    name: string(),
+    /** DeviceType the child should be created with on adopt. */
+    type: _enum(DeviceType),
+    status: DiscoveredChildStatusSchema,
+    /** Free-form integration-specific metadata surfaced in the panel. */
+    metadata: object({
+      model: string().optional(),
+      serialNumber: string().optional(),
+      uid: string().optional(),
+      /** Reolink: 0-based channel index inside the parent NVR/Hub. */
+      rtspChannel: number().int().nonnegative().optional(),
+      isBattery: boolean().optional(),
+      isDoorbell: boolean().optional(),
+      isMultifocal: boolean().optional(),
+      externalLocation: string().optional(),
+      /** Vendor / manufacturer name as reported by the source (HA device
+       *  `manufacturer`, …). Surfaced in the adoption modal's fuzzy search. */
+      manufacturer: string().optional(),
+      /** Integration / platform domain the candidate belongs to (HA
+       *  `entity_registry.platform`, e.g. `dreame_vacuum`). Surfaced in the
+       *  adoption modal's fuzzy search. */
+      integration: string().optional()
+    }).default({}),
+    /**
+     * `true` when the framework already created a child device for this
+     * `childNativeId` under the current parent. The panel uses it to
+     * gate the Add/Remove button and surface the existing `deviceId`.
+     */
+    alreadyAdopted: boolean(),
+    /** When `alreadyAdopted=true`, the framework-assigned child device id. */
+    adoptedDeviceId: number().int().nonnegative().nullable(),
+    /** Capability names the candidate advertises — integrations populate, Hubs omit. */
+    capabilities: array(string()).readonly().optional(),
+    /** Feature flags the candidate advertises — integrations populate, Hubs omit. */
+    features: array(string()).readonly().optional(),
+    /** Upstream-system identity + rendering hints for the candidate. */
+    sourceInfo: SourceInfoSchema.optional(),
+    /** Nested entity-children for accordion preview — integrations populate, Hubs omit. */
+    children: array(DiscoveredChildDeviceSchema).readonly().optional()
+  })
+);
+const DeviceDiscoveryStatusSchema = object({
+  discovered: array(DiscoveredChildDeviceSchema),
+  /** Wall-clock ms of the last successful enumeration. */
+  lastDiscoveryAt: number().int().nonnegative().nullable(),
+  /** Last error surfaced from the source (rendered as a banner). */
+  lastError: string().nullable()
+});
+({
+  // Hub is the canonical parent. Other integrations (gateway-style)
+  // can register against the cap by also targeting their root type.
+  deviceTypes: [DeviceType.Hub],
+  // Mirror status into the per-device runtime-state slice so the panel
+  // hydrates from the kernel cache without a round-trip on every open.
+  runtimeState: DeviceDiscoveryStatusSchema.extend({
+    lastFetchedAt: number().int().nonnegative()
+  }),
+  methods: {
+    /**
+     * Snapshot of the current `discovered` list. Returns the
+     * runtime-state cache — call `refreshDiscovery` first if a
+     * fresh round-trip to the source is required.
+     */
+    listDiscovered: method(
+      object({ deviceId: number().int().nonnegative() }),
+      array(DiscoveredChildDeviceSchema).readonly()
+    ),
+    /**
+     * Force the integration to re-enumerate and update the
+     * runtime-state slice. Returns the freshly-enumerated list (also
+     * available via `listDiscovered` post-call).
+     */
+    refreshDiscovery: method(
+      object({ deviceId: number().int().nonnegative() }),
+      array(DiscoveredChildDeviceSchema).readonly(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    /**
+     * Promote a discovered entry to a real child device. The framework
+     * creates the child via `kernel.devices.create()` with
+     * `parentDeviceId = parent.id` and seeds the child's config from
+     * `childInitialConfig` (driver-defined; usually carries channel +
+     * uid + parent reference). Returns the kernel-assigned numeric id.
+     */
+    adoptDevice: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        childNativeId: string(),
+        /** Optional override for the child's display name. */
+        name: string().optional()
+      }),
+      object({
+        deviceId: number().int().nonnegative(),
+        stableId: string()
+      }),
+      { kind: "mutation", auth: "admin" }
+    ),
+    /**
+     * Inverse of `adoptDevice`: removes the child device from the
+     * kernel registry. The discovered entry remains in the
+     * enumeration (status updates resume) so the operator can re-adopt
+     * it later without a fresh refresh.
+     */
+    releaseDevice: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        childDeviceId: number().int().nonnegative()
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    )
+  }
+});
+object({
+  /** Ms epoch of the last press. null = never observed since this provider started. */
+  lastPressedAt: number().nullable(),
+  /** Counter since provider start. Resets on reboot. Useful for metrics/debug. */
+  pressCountSinceStart: number()
+});
+object({
+  deviceId: number(),
+  timestamp: number()
+});
+({
+  deviceTypes: [DeviceType.Button]
+});
+const EnumSensorDateTimeFormatSchema = _enum(["date", "time", "datetime"]);
+object({
+  value: string(),
+  /**
+   * Set for `DateTimeSensor`-role sensors so the UI renders the ISO `value`
+   * as a locale date/time/datetime; absent for plain enum sensors. HA
+   * `device_class=timestamp` → `'datetime'`, `device_class=date` → `'date'`,
+   * a time-only sensor → `'time'`.
+   */
+  format: EnumSensorDateTimeFormatSchema.optional(),
+  /** Ms epoch when the slice was last updated. */
+  lastFetchedAt: number()
+});
+({
+  deviceTypes: [DeviceType.Sensor]
+});
+const EventFireSchema = object({
+  deviceId: number(),
+  eventType: string(),
+  data: record(string(), unknown()).nullable(),
+  timestamp: number(),
+  seq: number()
+});
+object({
+  eventTypes: array(string()),
+  lastEvent: EventFireSchema.nullable(),
+  eventCountSinceStart: number()
+});
+({
+  deviceTypes: [DeviceType.EventEmitter]
+});
+const FanDirectionSchema = _enum(["forward", "reverse"]);
+object({
+  /** Active speed as 0..100 inclusive. Null when the device has no
+   *  speed surface (single-speed fan). */
+  percentage: number().min(0).max(100).nullable(),
+  /** Speed granularity the device accepts (HA `percentage_step`, e.g. 25 for
+   *  a 4-speed fan). Absent when unknown — the UI then falls back to step 1. */
+  percentageStep: number().positive().optional(),
+  /** Active preset mode (`auto` / `quiet` / `turbo` / vendor-specific)
+   *  — empty string when no preset is active or supported. */
+  preset: string(),
+  /** Available preset modes the device accepts. */
+  availablePresets: array(string()),
+  /** Ceiling-fan blade direction. Null when the device has no
+   *  direction surface. */
+  direction: FanDirectionSchema.nullable(),
+  /** Oscillation toggle. Null when the device has no oscillation
+   *  surface. */
+  oscillating: boolean().nullable(),
+  /** Ms epoch when the slice was last updated. */
+  lastChangedAt: number()
+});
+({
+  deviceTypes: [DeviceType.Fan],
+  methods: {
+    setPercentage: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        percentage: number().min(0).max(100)
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    setPreset: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        preset: string().min(1)
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    setDirection: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        direction: FanDirectionSchema
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    setOscillating: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        oscillating: boolean()
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    )
+  }
+});
+object({
+  /** True when leak is currently detected. */
+  flooded: boolean(),
+  /** Ms epoch of the last flooded↔dry transition. 0 if never observed. */
+  lastChangedAt: number()
+});
+({
+  deviceTypes: [DeviceType.Sensor]
+});
+object({
+  detected: boolean(),
+  /** Ms epoch of the last transition. 0 if never observed. */
+  lastChangedAt: number()
+});
+({
+  deviceTypes: [DeviceType.Sensor]
+});
+object({
+  /** Whether the humidifier is currently on. */
+  on: boolean(),
+  /** Current measured relative humidity (0..100). Null when not reported. */
+  currentHumidity: number().min(0).max(100).nullable(),
+  /** Target relative humidity (0..100). Null when no setpoint surface. */
+  targetHumidity: number().min(0).max(100).nullable(),
+  /** Active mode (`auto` / `normal` / `baby` / vendor). Null when the
+   *  device has no mode surface. */
+  mode: string().nullable(),
+  /** Available modes the device accepts. */
+  availableModes: array(string()),
+  /** HA `action` attribute, verbatim (`humidifying` / `drying` /
+   *  `idle` / `off`). Null when the device doesn't report it. */
+  action: string().nullable(),
+  /** HA `min_humidity` attribute. Null → UI uses 0. */
+  minHumidity: number().nullable(),
+  /** HA `max_humidity` attribute. Null → UI uses 100. */
+  maxHumidity: number().nullable(),
+  /** Ms epoch when the slice was last updated. */
+  lastChangedAt: number()
+});
+({
+  deviceTypes: [DeviceType.Humidifier],
+  methods: {
+    setOn: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        on: boolean()
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    setTargetHumidity: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        humidity: number().min(0).max(100)
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    setMode: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        mode: string().min(1)
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    )
+  }
+});
+object({
+  /** Current relative humidity, 0..100. */
+  percent: number().min(0).max(100),
+  /** Ms epoch when the slice was last updated. */
+  lastFetchedAt: number(),
+  /** Live display unit from the upstream source (e.g. HA
+   *  `attributes.unit_of_measurement`). The UI prefers this over the
+   *  role's canonical unit. Absent → fall back to the canonical unit. */
+  unit: string().optional(),
+  /** Suggested decimal places for numeric display.
+   *  Populated live from the upstream source when provided (e.g. HA
+   *  `attributes.suggested_display_precision`). Falls back to
+   *  auto-formatting when absent. */
+  precision: number().int().min(0).max(10).optional()
+});
+({
+  deviceTypes: [DeviceType.Sensor, DeviceType.Thermostat]
+});
+object({
+  /** Absolute signed URL the browser loads directly. Null when the
+   *  entity exposes no `entity_picture` (yet). */
+  url: string().nullable(),
+  /** Ms epoch of the upstream last-updated timestamp. Null at cold-start. */
+  lastUpdated: number().nullable()
+});
+({
+  deviceTypes: [DeviceType.Image]
+});
+const LawnMowerActivitySchema = _enum([
+  "idle",
+  "mowing",
+  "paused",
+  "docked",
+  "error"
+]);
+object({
+  /** Lifecycle activity of the mower. */
+  activity: LawnMowerActivitySchema,
+  /** 0..100 battery percentage. Null when the device has no battery
+   *  reading. */
+  batteryLevel: number().min(0).max(100).nullable(),
+  /** Ms epoch when the slice was last updated. */
+  lastChangedAt: number()
+});
 ({
-  deviceTypes: [DeviceType.Camera],
+  deviceTypes: [DeviceType.LawnMower],
   methods: {
-    getCameraStreams: method(
+    startMowing: method(
       object({ deviceId: number().int().nonnegative() }),
-      array(CameraStreamSchema).readonly()
+      _void(),
+      { kind: "mutation", auth: "admin" }
     ),
-    getBrokerStreams: method(
+    pause: method(
       object({ deviceId: number().int().nonnegative() }),
-      array(ProfileSlotSchema).readonly()
+      _void(),
+      { kind: "mutation", auth: "admin" }
     ),
-    /**
-     * Per-device RTSP restream entries. Returns the broker's published
-     * RTSP URLs (one per `${deviceId}/${profile}`) for THIS device only,
-     * including the rendered `url` field with the RTSP token applied.
-     * Consumers (snapshot wrapper, recording, external probes) use this
-     * to pick a stream URL without scanning the whole cluster.
-     *
-     * The system `stream-broker.getAllRtspEntries({hostname?})` still
-     * exists for whole-cluster use cases (admin dashboard, settings
-     * exports). This device-scoped accessor is the supported handle for
-     * code that already has a `deviceId` in hand — keeps device-keyed
-     * filtering server-side and rides the DeviceProxy auto-injection.
-     */
-    getRtspEntries: method(
+    dock: method(
+      object({ deviceId: number().int().nonnegative() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    )
+  }
+});
+const LockStateSchema = _enum([
+  "locked",
+  "unlocked",
+  "locking",
+  "unlocking",
+  "jammed"
+]);
+object({
+  /** Lifecycle state of the lock. `jammed` means the motor reported
+   *  failure to reach the target — operator intervention required. */
+  state: LockStateSchema,
+  /** Ms epoch when the slice was last updated. */
+  lastChangedAt: number()
+});
+({
+  deviceTypes: [DeviceType.Lock],
+  methods: {
+    lock: method(
       object({
         deviceId: number().int().nonnegative(),
-        /** Override hostname embedded in returned URLs. Defaults to the broker's bound address. */
-        hostname: string().optional()
+        /** Optional PIN code required by some keypad locks. NOT
+         *  persisted — passed directly to the upstream service. */
+        code: string().min(1).optional()
       }),
-      array(RtspRestreamEntrySchema).readonly()
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    unlock: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        code: string().min(1).optional()
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    open: method(
+      object({
+        deviceId: number().int().nonnegative()
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
     )
-  },
-  events: {
-    /** Fires on publishCameraStream / retractCameraStream. */
-    onCamStreamsChanged: event(object({
-      deviceId: number().int().nonnegative(),
-      camStreams: array(CameraStreamSchema).readonly()
-    })),
-    /** Fires on assignProfile / unassignProfile / runtime status change. */
-    onProfileSlotsChanged: event(object({
-      deviceId: number().int().nonnegative(),
-      profileSlots: array(ProfileSlotSchema).readonly()
-    }))
-  },
-  /**
-   * Per-device live stream-broker state. Persistent settings (RTSP
-   * tokens, profile assignments, pre-buffer config, RTSP-enabled toggles,
-   * streamingDebug) stay in the broker's addon store — they survive
-   * restarts. The slice below carries ONLY what's truly runtime:
-   *
-   *   - `online` — at least one profile slot is currently `'streaming'`.
-   *     Drivers without a firmware liveness signal (RTSP, ONVIF…) can
-   *     subscribe and mirror this into `state.deviceStatus.online`.
-   *   - `slotStatuses` — current `ProfileSlotStatus` per profile,
-   *     mirroring the runtime-mutable subset of `ProfileSlot`.
-   *   - `slotErrors` — last error message per profile (only set when the
-   *     corresponding slot is in `'error'`).
-   *   - `lastChangedAt` — freshness signal for consumers that want to
-   *     reason about how stale the slice is.
-   *
-   * Written by the stream-broker manager on every transition that
-   * affects these aggregates. Read via `device.state.cameraStreams.<field>`
-   * (BaseDevice proxy) or, cross-process, via
-   * `device-state.getCapSlice({deviceId, capName: 'camera-streams'})`.
-   * The cap's `onChanged` event fires automatically on each write so
-   * subscribers get push semantics for free.
-   */
-  runtimeState: object({
-    online: boolean(),
-    slotStatuses: object({
-      high: ProfileSlotStatusSchema.optional(),
-      mid: ProfileSlotStatusSchema.optional(),
-      low: ProfileSlotStatusSchema.optional()
-    }),
-    slotErrors: object({
-      high: string().optional(),
-      mid: string().optional(),
-      low: string().optional()
-    }),
-    lastChangedAt: number()
-  })
+  }
 });
-const DiscoveredChildStatusSchema = _enum(["online", "sleeping", "offline", "unknown"]);
-const DiscoveredChildDeviceSchema = object({
-  /** Stable, integration-defined identifier. Mirrors Scrypted's `nativeId`. */
-  childNativeId: string(),
-  /** Friendly name as reported by the source (Reolink camera name, ONVIF profile, ...). */
-  name: string(),
-  /** DeviceType the child should be created with on adopt. */
-  type: _enum(DeviceType),
-  status: DiscoveredChildStatusSchema,
-  /** Free-form integration-specific metadata surfaced in the panel. */
-  metadata: object({
-    model: string().optional(),
-    serialNumber: string().optional(),
-    uid: string().optional(),
-    /** Reolink: 0-based channel index inside the parent NVR/Hub. */
-    rtspChannel: number().int().nonnegative().optional(),
-    isBattery: boolean().optional(),
-    isDoorbell: boolean().optional(),
-    isMultifocal: boolean().optional()
-  }).default({}),
-  /**
-   * `true` when the framework already created a child device for this
-   * `childNativeId` under the current parent. The panel uses it to
-   * gate the Add/Remove button and surface the existing `deviceId`.
-   */
-  alreadyAdopted: boolean(),
-  /** When `alreadyAdopted=true`, the framework-assigned child device id. */
-  adoptedDeviceId: number().int().nonnegative().nullable()
+const MediaPlayerStateSchema = _enum([
+  "off",
+  "on",
+  "idle",
+  "playing",
+  "paused",
+  "buffering",
+  "standby"
+]);
+const MediaPlayerRepeatSchema = _enum(["off", "all", "one"]);
+const MediaInfoSchema = object({
+  /** Free-form media kind (`music`, `tvshow`, `movie`, `app`, `channel`,
+   *  `podcast`, …). */
+  type: string(),
+  /** Human-readable title. */
+  title: string(),
+  /** Optional artist / channel / station label. */
+  artist: string().optional(),
+  /** Optional album / season / show name. */
+  album: string().optional(),
+  /** Optional cover-art / thumbnail URL. */
+  imageUrl: string().optional()
 });
-const DeviceDiscoveryStatusSchema = object({
-  discovered: array(DiscoveredChildDeviceSchema),
-  /** Wall-clock ms of the last successful enumeration. */
-  lastDiscoveryAt: number().int().nonnegative().nullable(),
-  /** Last error surfaced from the source (rendered as a banner). */
-  lastError: string().nullable()
+object({
+  /** Playback lifecycle state. */
+  state: MediaPlayerStateSchema,
+  /** Volume as 0..100 inclusive. Null when the device has no volume
+   *  surface. Pair with `DeviceFeature.MediaPlayerVolume`. */
+  volumeLevel: number().min(0).max(100).nullable(),
+  /** Mute toggle distinct from volume=0. Null when no mute surface.
+   *  Pair with `DeviceFeature.MediaPlayerMute`. */
+  isMuted: boolean().nullable(),
+  /** Active source / input. Empty when no source surface. */
+  source: string(),
+  /** Selectable sources. Empty when no source surface.
+   *  Pair with `DeviceFeature.MediaPlayerSelectSource`. */
+  availableSources: array(string()),
+  /** Currently-playing media info. Null when nothing is playing. */
+  currentMedia: MediaInfoSchema.nullable(),
+  /** Current playback position in ms. Null when not seekable or
+   *  nothing is playing. Pair with `DeviceFeature.MediaPlayerSeek`. */
+  positionMs: number().int().nonnegative().nullable(),
+  /** Total duration of the current media in ms. Null when unknown
+   *  (live stream) or nothing is playing. */
+  durationMs: number().int().nonnegative().nullable(),
+  /** Shuffle toggle. Null when no shuffle surface.
+   *  Pair with `DeviceFeature.MediaPlayerShuffle`. */
+  shuffle: boolean().nullable(),
+  /** Repeat mode. Null when no repeat surface.
+   *  Pair with `DeviceFeature.MediaPlayerRepeat`. */
+  repeat: MediaPlayerRepeatSchema.nullable(),
+  /** Ms epoch when the slice was last updated. */
+  lastChangedAt: number()
 });
 ({
-  // Hub is the canonical parent. Other integrations (gateway-style)
-  // can register against the cap by also targeting their root type.
-  deviceTypes: [DeviceType.Hub],
-  // Mirror status into the per-device runtime-state slice so the panel
-  // hydrates from the kernel cache without a round-trip on every open.
-  runtimeState: DeviceDiscoveryStatusSchema.extend({
-    lastFetchedAt: number().int().nonnegative()
-  }),
+  deviceTypes: [DeviceType.MediaPlayer],
   methods: {
-    /**
-     * Snapshot of the current `discovered` list. Returns the
-     * runtime-state cache — call `refreshDiscovery` first if a
-     * fresh round-trip to the source is required.
-     */
-    listDiscovered: method(
+    play: method(
       object({ deviceId: number().int().nonnegative() }),
-      array(DiscoveredChildDeviceSchema).readonly()
+      _void(),
+      { kind: "mutation", auth: "admin" }
     ),
-    /**
-     * Force the integration to re-enumerate and update the
-     * runtime-state slice. Returns the freshly-enumerated list (also
-     * available via `listDiscovered` post-call).
-     */
-    refreshDiscovery: method(
+    pause: method(
       object({ deviceId: number().int().nonnegative() }),
-      array(DiscoveredChildDeviceSchema).readonly(),
+      _void(),
       { kind: "mutation", auth: "admin" }
     ),
-    /**
-     * Promote a discovered entry to a real child device. The framework
-     * creates the child via `kernel.devices.create()` with
-     * `parentDeviceId = parent.id` and seeds the child's config from
-     * `childInitialConfig` (driver-defined; usually carries channel +
-     * uid + parent reference). Returns the kernel-assigned numeric id.
-     */
-    adoptDevice: method(
+    stop: method(
+      object({ deviceId: number().int().nonnegative() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    next: method(
+      object({ deviceId: number().int().nonnegative() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    previous: method(
+      object({ deviceId: number().int().nonnegative() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    seek: method(
       object({
         deviceId: number().int().nonnegative(),
-        childNativeId: string(),
-        /** Optional override for the child's display name. */
-        name: string().optional()
+        positionMs: number().int().nonnegative()
       }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    setVolume: method(
       object({
         deviceId: number().int().nonnegative(),
-        stableId: string()
+        volumeLevel: number().min(0).max(100)
       }),
+      _void(),
       { kind: "mutation", auth: "admin" }
     ),
-    /**
-     * Inverse of `adoptDevice`: removes the child device from the
-     * kernel registry. The discovered entry remains in the
-     * enumeration (status updates resume) so the operator can re-adopt
-     * it later without a fresh refresh.
-     */
-    releaseDevice: method(
+    setMute: method(
       object({
         deviceId: number().int().nonnegative(),
-        childDeviceId: number().int().nonnegative()
+        muted: boolean()
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    setShuffle: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        shuffle: boolean()
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    setRepeat: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        repeat: MediaPlayerRepeatSchema
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    selectSource: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        source: string().min(1)
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    playMedia: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        /** Media identifier / URL. */
+        mediaId: string().min(1),
+        /** Media kind (`music`, `tvshow`, `movie`, `app`, …) — provider
+         *  passes it through to the upstream service. */
+        mediaType: string().min(1)
       }),
       _void(),
       { kind: "mutation", auth: "admin" }
     )
   }
 });
-object({
-  /** Ms epoch of the last press. null = never observed since this provider started. */
-  lastPressedAt: number().nullable(),
-  /** Counter since provider start. Resets on reboot. Useful for metrics/debug. */
-  pressCountSinceStart: number()
-});
-object({
-  deviceId: number(),
-  timestamp: number()
-});
-({
-  deviceTypes: [DeviceType.Button]
-});
 const FrameFormatSchema = _enum(["jpeg", "rgb", "bgr", "yuv420", "gray"]);
 const FrameInputSchema = object({
   data: custom(),
@@ -7010,8 +8444,8 @@ const PipelineRunResultBridge = custom();
      * calls. Single root step + uniform model assumed; trees with crop
      * children fall back to sequential execution.
      *
-     * Used by `scripts/bench-scrypted-style.mts` to mirror Scrypted's
-     * `detectObjects(media, {batch})` semantics for fair comparison.
+     * Used by `scripts/bench-batch-style.mts` for batch benchmarking —
+     * N frames in one call to amortise per-call IPC overhead.
      */
     runPipelineBatch: method(
       object({
@@ -7392,8 +8826,8 @@ object({
   lastDetectedAt: number().nullable(),
   /**
    * Ms after which `detected` auto-reverts to false if no fresh push
-   * arrives. Mirrors the scrypted-reolink-native default. Null means
-   * the provider leaves detected state until a native "clear" event.
+   * arrives. Null means the provider leaves detected state until a
+   * native "clear" event.
    */
   autoClearAfterMs: number().nullable()
 });
@@ -7579,6 +9013,194 @@ NativeObjectDetectionStatusSchema.extend({
     }) }
   }
 });
+const NotifierPrioritySchema = _enum(["min", "low", "normal", "high"]);
+const NotifierActionSchema = object({
+  /** Stable id used in the callback when the user taps the button. */
+  id: string().min(1),
+  /** User-visible button label. */
+  title: string().min(1),
+  /** Optional deep-link URI invoked on tap (rich notifiers only). */
+  uri: url().optional(),
+  /** Optional flag — when true, the action is destructive and the
+   *  client should render the button in a warning style. */
+  destructive: boolean().optional()
+});
+const NotifierSupportsSchema = object({
+  /** Inline / URL image attachment. Pair with `DeviceFeature.NotifierImage`. */
+  image: boolean(),
+  /** Priority hint. Pair with `DeviceFeature.NotifierPriority`. */
+  priority: boolean(),
+  /** Free-form platform-specific data block.
+   *  Pair with `DeviceFeature.NotifierData`. */
+  data: boolean(),
+  /** Interactive action buttons. Pair with `DeviceFeature.NotifierActions`. */
+  actions: boolean(),
+  /** Per-call recipient targeting (multi-user notifiers).
+   *  Pair with `DeviceFeature.NotifierRecipients`. */
+  recipients: boolean()
+});
+object({
+  /** Ms epoch of the most recent successful send. 0 if none yet. */
+  lastSentAt: number(),
+  /** Failure description from the most recent send attempt. Null on
+   *  success or when nothing has been sent yet. */
+  lastError: string().nullable(),
+  /** Number of deliveries currently buffered server-side (rate-limited
+   *  notifiers may queue). 0 when the provider sends synchronously. */
+  queueDepth: number().int().nonnegative(),
+  /** Per-feature capability matrix — authoritative source for the
+   *  compose-form field gating. */
+  supports: NotifierSupportsSchema
+});
+const NotifierSendInputSchema = object({
+  deviceId: number().int().nonnegative(),
+  /** Optional title — many platforms render it bolder than the body. */
+  title: string().optional(),
+  /** Required message body. */
+  body: string().min(1),
+  /** Optional image URL or inline data URI (`data:image/...;base64,...`). */
+  image: string().optional(),
+  /** Priority hint — providers without priority support ignore the field. */
+  priority: NotifierPrioritySchema.optional(),
+  /** Channel / topic / tag the notifier should route through (Android
+   *  notification channel, Telegram chat id, ntfy topic, …). */
+  channel: string().optional(),
+  /** Optional list of recipient ids (multi-user notifiers). Empty /
+   *  omitted = the device's default recipient. */
+  recipients: array(string()).optional(),
+  /** Optional interactive action buttons. */
+  actions: array(NotifierActionSchema).optional(),
+  /** Free-form platform-specific payload — passed through to the
+   *  upstream service untouched. */
+  data: record(string(), unknown()).optional()
+});
+const NotifierSendResultSchema = object({
+  /** Provider-assigned id for the delivery. Used for `cancel`. */
+  notificationId: string(),
+  /** Ms epoch when the notifier accepted the send (not when delivered). */
+  acceptedAt: number()
+});
+({
+  deviceTypes: [DeviceType.Notifier],
+  methods: {
+    send: method(
+      NotifierSendInputSchema,
+      NotifierSendResultSchema,
+      { kind: "mutation", auth: "admin" }
+    ),
+    cancel: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        notificationId: string().min(1)
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    )
+  },
+  events: {
+    /**
+     * Emitted after every send attempt — success or failure. Subscribers
+     * (admin UI history pane, automation engines, retry workers) react
+     * without polling the provider's `lastSentAt`.
+     */
+    onSent: { data: object({
+      deviceId: number(),
+      notificationId: string(),
+      success: boolean(),
+      error: string().nullable(),
+      acceptedAt: number()
+    }) }
+  }
+});
+object({
+  value: number(),
+  /** Display unit-of-measurement (e.g. 'dBm', 's', 'rpm', 'steps').
+   *  Populated live from the upstream source on each state push.
+   *  Absent for unitless sensors. */
+  unit: string().optional(),
+  /** Suggested decimal places for numeric display.
+   *  Populated live from the upstream source when provided.
+   *  Falls back to auto-formatting when absent. */
+  precision: number().int().min(0).max(10).optional(),
+  /** Ms epoch when the slice was last updated. */
+  lastFetchedAt: number()
+});
+({
+  deviceTypes: [DeviceType.Sensor]
+});
+object({
+  /** Instantaneous power draw in watts. */
+  watts: number().optional(),
+  /** Cumulative energy in kilowatt-hours since the meter was reset. */
+  kwhTotal: number().optional(),
+  /** Voltage in volts. */
+  volts: number().optional(),
+  /** Current in amperes. */
+  amps: number().optional(),
+  /** Apparent power in volt-amperes (W × power-factor reciprocal). */
+  va: number().optional(),
+  /** Power factor (0..1) if reported. */
+  powerFactor: number().min(0).max(1).optional(),
+  /** Ms epoch when the slice was last updated. */
+  lastFetchedAt: number(),
+  /** Live display unit of the single metric this slice carries (e.g. HA
+   *  `attributes.unit_of_measurement` → 'V' / 'A' / 'W' / 'kW' / 'kWh').
+   *  Each upstream `sensor.*` entity surfaces ONE device_class, so one
+   *  unit per slice is unambiguous. The UI prefers this over the role's
+   *  canonical unit so a 'kW' / 'Wh' feed renders verbatim. */
+  unit: string().optional(),
+  /** Suggested decimal places for numeric display.
+   *  Populated live from the upstream source when provided (e.g. HA
+   *  `attributes.suggested_display_precision`). Falls back to
+   *  auto-formatting when absent. */
+  precision: number().int().min(0).max(10).optional()
+});
+({
+  deviceTypes: [DeviceType.Sensor]
+});
+const GpsLocationSchema = object({
+  /** Latitude in decimal degrees, -90..90. */
+  latitude: number().min(-90).max(90),
+  /** Longitude in decimal degrees, -180..180. */
+  longitude: number().min(-180).max(180),
+  /** Reported accuracy in meters (lower = better). */
+  accuracyMeters: number().nonnegative()
+});
+object({
+  /** `home` / `not_home` / any user-defined zone name. */
+  state: string(),
+  /** Optional textual location label (zone name, city, address). Null
+   *  when only the binary state is known. */
+  location: string().nullable(),
+  /** GPS coordinates when available. Null otherwise. */
+  gps: GpsLocationSchema.nullable(),
+  /** Optional battery level of the tracking device (0..100). Null
+   *  when not reported. */
+  batteryPercent: number().min(0).max(100).nullable(),
+  /** Ms epoch when the slice was last updated. */
+  lastChangedAt: number()
+});
+({
+  deviceTypes: [DeviceType.Presence]
+});
+object({
+  /** Current pressure in hPa. */
+  hpa: number(),
+  /** Ms epoch when the slice was last updated. */
+  lastFetchedAt: number(),
+  /** Live display unit from the upstream source (e.g. HA
+   *  `attributes.unit_of_measurement`). The UI prefers this over the
+   *  role's canonical unit. Absent → fall back to the canonical unit. */
+  unit: string().optional(),
+  /** Suggested decimal places for numeric display.
+   *  Populated live from the upstream source when provided (e.g. HA
+   *  `attributes.suggested_display_precision`). Falls back to
+   *  auto-formatting when absent. */
+  precision: number().int().min(0).max(10).optional()
+});
+({
+  deviceTypes: [DeviceType.Sensor]
+});
 const PrivacyMaskShapeSchema = discriminatedUnion("kind", [
   MaskRectShapeSchema,
   MaskPolygonShapeSchema
@@ -7707,6 +9329,51 @@ PtzAutotrackStatusSchema.extend({
     }) }
   }
 });
+object({
+  /** Whether the script is currently executing. */
+  isRunning: boolean(),
+  /** Ms epoch of the last invocation start. 0 when never run. */
+  lastRunAt: number(),
+  /** Outcome of the last completed run. Null when never run or still
+   *  running. */
+  lastRunSuccess: boolean().nullable(),
+  /** Failure description from the last completed run. Null on success
+   *  or when never run. */
+  lastError: string().nullable(),
+  /** Ms epoch when the slice was last updated. */
+  lastChangedAt: number()
+});
+({
+  deviceTypes: [DeviceType.Script],
+  methods: {
+    run: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        /** Optional variables map — passed through to the upstream
+         *  script. Provider rejects when the script doesn't declare
+         *  input fields (gated by `DeviceFeature.ScriptVariables`). */
+        variables: record(string(), unknown()).optional()
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    /** Cancel a running script. Provider rejects when the script
+     *  isn't currently running. */
+    stop: method(
+      object({ deviceId: number().int().nonnegative() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    )
+  }
+});
+object({
+  detected: boolean(),
+  /** Ms epoch of the last transition. 0 if never observed. */
+  lastChangedAt: number()
+});
+({
+  deviceTypes: [DeviceType.Sensor]
+});
 const StreamProfileSchema = _enum(["main", "sub", "ext"]);
 const StreamProfileConfigSchema = object({
   width: number(),
@@ -7823,6 +9490,257 @@ object({
     }) }
   }
 });
+object({
+  /** True when the device's tamper switch / case-open contact is
+   *  currently triggered. */
+  tampered: boolean(),
+  /** Ms epoch of the last transition. 0 if never observed. */
+  lastChangedAt: number()
+});
+({
+  deviceTypes: [DeviceType.Sensor]
+});
+object({
+  /** Current temperature in Celsius. */
+  celsius: number(),
+  /** Ms epoch when the slice was last updated (push or poll). */
+  lastFetchedAt: number(),
+  /** Live display unit from the upstream source (e.g. HA
+   *  `attributes.unit_of_measurement`). The UI prefers this over the
+   *  role's canonical unit, so a Fahrenheit feed renders '°F' not '°C'.
+   *  Absent → the UI falls back to the role's canonical unit. */
+  unit: string().optional(),
+  /** Suggested decimal places for numeric display.
+   *  Populated live from the upstream source when provided (e.g. HA
+   *  `attributes.suggested_display_precision`). Falls back to
+   *  auto-formatting when absent. */
+  precision: number().int().min(0).max(10).optional()
+});
+({
+  deviceTypes: [DeviceType.Sensor, DeviceType.Thermostat]
+});
+object({
+  currentVersion: string().nullable(),
+  availableVersion: string().nullable(),
+  /**
+   * DEVICE-CAPABILITY flag: the entity supports firmware updates at all — NOT
+   * a per-state "an update is available right now" flag. The canonical
+   * "update available" signal is `availableVersion !== currentVersion` (which
+   * is what the UI uses); HA's `state === 'on'` mirrors that same condition.
+   */
+  updatable: boolean(),
+  state: string().nullable(),
+  // e.g. 'UP_TO_DATE' / 'DELIVER_FIRMWARE_IMAGE' (provider-verbatim)
+  inProgress: boolean()
+});
+({
+  deviceTypes: [DeviceType.Update],
+  methods: {
+    installUpdate: method(_void(), _void(), { kind: "mutation", auth: "admin" })
+  }
+});
+const VacuumStateSchema = _enum([
+  "idle",
+  "cleaning",
+  "paused",
+  "returning",
+  "docked",
+  "error"
+]);
+const TankStatusSchema = object({
+  /** Numeric fill 0..100 when the hardware reports a percentage; null otherwise. */
+  level: number().min(0).max(100).nullable(),
+  /** Discrete state when the hardware is binary-mode; null otherwise. */
+  status: _enum(["ok", "low", "full"]).nullable()
+});
+object({
+  /** Lifecycle state of the vacuum. */
+  state: VacuumStateSchema,
+  /** 0..100 battery percentage. Null when the device has no battery
+   *  reading. */
+  batteryLevel: number().min(0).max(100).nullable(),
+  /** Current fan-speed token (provider-verbatim). Null when unknown or
+   *  the vacuum has no speed control. */
+  fanSpeed: string().nullable(),
+  /** Speed tokens the hardware accepts — drives the UI selector. */
+  availableFanSpeeds: array(string()),
+  /** Clean-water (mop) tank. Null when the hardware has no clean-water tank. */
+  cleanWater: TankStatusSchema.nullable(),
+  /** Dirty-water (recovery) tank. Null when the hardware has no dirty-water tank. */
+  dirtyWater: TankStatusSchema.nullable(),
+  /** Detergent tank. Null when the hardware has no detergent tank. */
+  detergent: TankStatusSchema.nullable(),
+  /** Dust bin. Null when the hardware has no dust bin. */
+  dustBin: TankStatusSchema.nullable(),
+  /** Ms epoch when the slice was last updated. */
+  lastChangedAt: number()
+});
+({
+  deviceTypes: [DeviceType.Vacuum],
+  methods: {
+    start: method(
+      object({ deviceId: number().int().nonnegative() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    pause: method(
+      object({ deviceId: number().int().nonnegative() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    stop: method(
+      object({ deviceId: number().int().nonnegative() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    returnToBase: method(
+      object({ deviceId: number().int().nonnegative() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    locate: method(
+      object({ deviceId: number().int().nonnegative() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    setFanSpeed: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        speed: string().min(1)
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    )
+  }
+});
+const ValveStateSchema = _enum([
+  "open",
+  "opening",
+  "closing",
+  "closed",
+  "stopped"
+]);
+object({
+  /** Lifecycle state of the valve. */
+  state: ValveStateSchema,
+  /** 0 = fully closed, 100 = fully open. Null when the device has no
+   *  intermediate position surface. */
+  position: number().min(0).max(100).nullable(),
+  /** Ms epoch when the slice was last updated. */
+  lastChangedAt: number()
+});
+({
+  deviceTypes: [DeviceType.Valve],
+  methods: {
+    open: method(
+      object({ deviceId: number().int().nonnegative() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    close: method(
+      object({ deviceId: number().int().nonnegative() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    stop: method(
+      object({ deviceId: number().int().nonnegative() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    setPosition: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        position: number().min(0).max(100)
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    )
+  }
+});
+object({
+  detected: boolean(),
+  /** Ms epoch of the last transition. 0 if never observed. */
+  lastChangedAt: number()
+});
+({
+  deviceTypes: [DeviceType.Sensor]
+});
+object({
+  /** Current measured temperature. Null when not reported. */
+  currentTemp: number().nullable(),
+  /** Target temperature setpoint. Null when no setpoint surface. */
+  targetTemp: number().nullable(),
+  /** Active operation mode = HA `state` (`eco` / `electric` / `gas` /
+   *  `heat_pump` / `high_demand` / `performance` / `off`). Null when the
+   *  device reports an unknown state. */
+  operationMode: string().nullable(),
+  /** Available operation modes = HA `operation_list`. */
+  availableModes: array(string()),
+  /** Away mode (HA `away_mode` 'on'/'off' → bool). Null when the device
+   *  has no away surface. */
+  away: boolean().nullable(),
+  /** HA `min_temp` attribute. Null when not reported. */
+  minTemp: number().nullable(),
+  /** HA `max_temp` attribute. Null when not reported. */
+  maxTemp: number().nullable(),
+  /** Ms epoch when the slice was last updated. */
+  lastChangedAt: number()
+});
+({
+  deviceTypes: [DeviceType.WaterHeater],
+  methods: {
+    setTargetTemp: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        temp: number().finite()
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    setOperationMode: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        mode: string().min(1)
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    setAway: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        on: boolean()
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    )
+  }
+});
+object({
+  /** Verbatim HA condition state (`sunny`, `cloudy`, `rainy`, …). Null
+   *  when no condition has been reported yet. */
+  condition: string().nullable(),
+  /** Current temperature in the reported unit. Null when not provided. */
+  temperature: number().nullable(),
+  /** Temperature unit string (e.g. `°C` / `°F`). Null when not provided. */
+  temperatureUnit: string().nullable(),
+  /** Relative humidity (0..100). Null when not provided. */
+  humidity: number().min(0).max(100).nullable(),
+  /** Barometric pressure in the reported unit. Null when not provided. */
+  pressure: number().nullable(),
+  /** Pressure unit string (e.g. `hPa` / `inHg`). Null when not provided. */
+  pressureUnit: string().nullable(),
+  /** Wind speed in the reported unit. Null when not provided. */
+  windSpeed: number().nullable(),
+  /** Wind-speed unit string (e.g. `km/h` / `mph`). Null when not provided. */
+  windSpeedUnit: string().nullable(),
+  /** Wind bearing in degrees (0..360, meteorological). Null when not provided. */
+  windBearing: number().nullable(),
+  /** Ms epoch when the slice was last updated. */
+  lastFetchedAt: number()
+});
+({
+  deviceTypes: [DeviceType.Weather]
+});
 const PerScopeBreakdownSchema = object({
   /** Total tracked objects in this scope (frame / zone / unzoned). */
   totalObjects: number().int().nonnegative(),
@@ -8018,7 +9936,14 @@ const DiscoveryCandidateSchema = object({
   stableId: string(),
   type: _enum(DeviceType),
   suggestedName: string(),
-  prefilledConfig: record(string(), unknown())
+  prefilledConfig: record(string(), unknown()),
+  /**
+   * Optional upstream-system identity (HA entity_id, vendor MAC, …).
+   * Discovery pre-populates this for systems that know the upstream
+   * identity ahead of adoption. Rendering metadata (unit, precision)
+   * flows live through the cap STATUS SLICE after adoption.
+   */
+  sourceInfo: SourceInfoSchema.optional()
 });
 const DeviceSummarySchema = object({
   id: number(),
@@ -8029,7 +9954,12 @@ const DeviceSummarySchema = object({
   parentDeviceId: number().nullable(),
   online: boolean(),
   features: array(string()),
-  config: record(string(), unknown())
+  config: record(string(), unknown()),
+  /** Optional upstream-system identity (dispatch key + system tag).
+   *  See `SourceInfo`. Present when the device has a non-synthetic
+   *  source identifier (HA entities, vendor MAC, …); omitted when the
+   *  synthetic backfill is in effect. */
+  sourceInfo: SourceInfoSchema.optional()
 });
 const FieldProbeResultSchema = object({
   status: _enum(["ok", "error"]),
@@ -8208,6 +10138,22 @@ const AlertSchema = object({
     dismiss: method(object({ alertId: string() }), _void(), { kind: "mutation" })
   }
 });
+const ProviderListEntrySchema = discriminatedUnion("shouldSaveDiskSpace", [
+  object({
+    providerId: string().min(1),
+    displayName: string().min(1),
+    configSchema: unknown(),
+    shouldSaveDiskSpace: literal(true),
+    minFreePercent: number().min(0).max(100)
+  }),
+  object({
+    providerId: string().min(1),
+    displayName: string().min(1),
+    configSchema: unknown(),
+    shouldSaveDiskSpace: literal(false),
+    minFreePercent: literal(null)
+  })
+]);
 ({
   methods: {
     // ── Small-file primitives ────────────────────────────────────────
@@ -8282,6 +10228,16 @@ const AlertSchema = object({
       object({ type: StorageLocationTypeSchema }),
       StorageLocationSchema.nullable()
     ),
+    // The admin-UI Data screen renders one group per declared location
+    // (header = `displayName`, "+ Add" shown only for `cardinality:
+    // 'multi'`). Source: the kernel-aggregated `storageLocations`
+    // declarations injected into the orchestrator via `setRegistry`.
+    // No closed type enum in the UI — the screen is fully declaration-
+    // driven.
+    listLocationDeclarations: method(
+      _void(),
+      array(StorageLocationDeclarationSchema).readonly()
+    ),
     upsertLocation: method(
       StorageLocationSchema.omit({ createdAt: true, updatedAt: true }),
       StorageLocationSchema,
@@ -8306,12 +10262,7 @@ const AlertSchema = object({
     // never changes after boot).
     listProviders: method(
       _void(),
-      array(object({
-        providerId: string(),
-        displayName: string(),
-        supportedLocationTypes: array(StorageLocationTypeSchema).readonly(),
-        configSchema: unknown()
-      })).readonly()
+      array(ProviderListEntrySchema).readonly()
     ),
     // Validate a candidate config against a provider BEFORE persisting.
     // Used by the wizard so operators can preflight a connection
@@ -8327,12 +10278,24 @@ const AlertSchema = object({
     )
   }
 });
-const ProviderInfoSchema = object({
-  providerId: string().min(1),
-  displayName: string().min(1),
-  supportedLocationTypes: array(StorageLocationTypeSchema).readonly(),
-  configSchema: unknown()
-});
+const ProviderInfoSchema = discriminatedUnion("shouldSaveDiskSpace", [
+  object({
+    providerId: string().min(1),
+    displayName: string().min(1),
+    configSchema: unknown(),
+    // Provider manages a finite volume → declares a default free-space threshold.
+    shouldSaveDiskSpace: literal(true),
+    minFreePercent: number().min(0).max(100)
+  }),
+  object({
+    providerId: string().min(1),
+    displayName: string().min(1),
+    configSchema: unknown(),
+    // No local free-space concept (remote/object store) → no threshold.
+    shouldSaveDiskSpace: literal(false),
+    minFreePercent: literal(null)
+  })
+]);
 const TestLocationResultSchema = object({
   ok: boolean(),
   error: string().optional()
@@ -8418,6 +10381,35 @@ const EndDownloadInputSchema = object({ downloadId: string() });
     endDownload: method(EndDownloadInputSchema, _void(), { kind: "mutation" })
   }
 });
+const EvictableUsageSchema = object({
+  /** Bytes this provider currently holds on the location (0 if none). */
+  bytes: number().int().nonnegative()
+});
+const EvictResultSchema = object({
+  /** Bytes actually reclaimed (only successfully-deleted data counts). */
+  reclaimedBytes: number().int().nonnegative(),
+  /** True when the provider has nothing left it is willing to drop on this location. */
+  exhausted: boolean()
+});
+({
+  methods: {
+    /** Bytes this provider holds on the given location — drives proportional fan-out. */
+    getEvictableUsage: method(
+      object({ locationId: string() }),
+      EvictableUsageSchema
+    ),
+    /**
+     * Free approximately `targetBytes` of this provider's OWN least-valuable
+     * data on the location (oldest footage, expired clips, …). Returns what it
+     * actually reclaimed + whether it is now exhausted.
+     */
+    evict: method(
+      object({ locationId: string(), targetBytes: number().int().positive() }),
+      EvictResultSchema,
+      { kind: "mutation" }
+    )
+  }
+});
 const BackupSubDestinationInfoSchema = object({
   /**
    * Sub-id within this addon. Convention `default` for single-
@@ -8628,7 +10620,7 @@ const QueryFilterSchema = object({
   limit: number().optional(),
   offset: number().optional()
 });
-const SettingsRecordSchema = object({
+const SettingsRecordSchema$1 = object({
   id: string(),
   data: record(string(), unknown())
 });
@@ -8660,11 +10652,11 @@ const CollectionIndexSchema = object({
     /** Get all entries matching an optional filter. */
     query: method(
       object({ namespace: string().optional(), collection: string(), filter: QueryFilterSchema.optional() }),
-      array(SettingsRecordSchema).readonly()
+      array(SettingsRecordSchema$1).readonly()
     ),
     /** Insert a new record. */
     insert: method(
-      object({ namespace: string().optional(), collection: string(), record: SettingsRecordSchema }),
+      object({ namespace: string().optional(), collection: string(), record: SettingsRecordSchema$1 }),
       _void(),
       { kind: "mutation" }
     ),
@@ -8685,6 +10677,18 @@ const CollectionIndexSchema = object({
       object({ namespace: string().optional(), collection: string(), filter: QueryFilterSchema.optional() }),
       number()
     ),
+    /** Grouped counts per ((field-origin)/bucketSize) bucket, filtered. */
+    histogram: method(
+      object({
+        namespace: string().optional(),
+        collection: string(),
+        field: string(),
+        bucketSize: number().int().positive(),
+        origin: number().int(),
+        filter: QueryFilterSchema.optional()
+      }),
+      array(object({ bucket: number().int(), count: number().int() })).readonly()
+    ),
     /** Check if a collection is empty. */
     isEmpty: method(
       object({ namespace: string().optional(), collection: string() }),
@@ -9005,6 +11009,297 @@ const SmtpStatusSchema = object({
     )
   }
 });
+const AdoptionFilterSchema = object({
+  id: string(),
+  label: string(),
+  isDefault: boolean().optional()
+});
+const CandidateQueryFilterSchema = object({
+  /** Substring filter on name + manufacturer + model. */
+  search: string().optional(),
+  /** Area-name exact match. */
+  area: string().optional(),
+  /** Manufacturer exact match. */
+  manufacturer: string().optional(),
+  /** When true, only return candidates the operator already adopted. */
+  adoptedOnly: boolean().optional(),
+  /** When true, only return candidates the operator hasn't adopted yet. */
+  unadoptedOnly: boolean().optional()
+});
+const ListCandidatesInputSchema = object({
+  integrationId: string(),
+  page: number().int().positive().default(1),
+  // Pagination is client-side in the adoption UI: the modal fetches the whole
+  // candidate set in one page and the shared list paginates locally. The cap
+  // stays high enough to return every candidate at once. The large case is the
+  // HA `entities` granularity — one HA device maps to many entities, so an
+  // install can expose several thousand candidates; the ceiling is sized for it.
+  pageSize: number().int().positive().max(2e4).default(50),
+  /**
+   * Optional provider-declared discovery GRANULARITY id (opaque; see
+   * `AdoptionFilterSchema`). Omitted = the reserved `'devices'` granularity =
+   * exactly the pre-existing behavior (fully back-compatible).
+   */
+  filter: string().optional(),
+  /** Optional candidate-list text/query narrowing within the granularity. */
+  filterText: CandidateQueryFilterSchema.optional()
+});
+const ListCandidatesOutputSchema = object({
+  candidates: array(DiscoveredChildDeviceSchema).readonly(),
+  totalCount: number().int().nonnegative(),
+  page: number().int().positive(),
+  pageSize: number().int().positive()
+});
+const GetCandidateInputSchema = object({
+  integrationId: string(),
+  childNativeId: string()
+});
+const AdoptionStatusSchema = object({
+  /** Last refresh timestamp (ms epoch) — null when never refreshed. */
+  lastDiscoveryAt: number().int().nonnegative().nullable(),
+  /** Count of candidates in the discovery cache. */
+  candidateCount: number().int().nonnegative(),
+  /** Count of candidates the operator has already adopted. */
+  adoptedCount: number().int().nonnegative(),
+  /** Last error message from a refresh attempt. */
+  lastError: string().nullable()
+});
+const PerCandidateSchema = object({
+  /** Override the default display name for this candidate's parent. */
+  name: string().min(1).optional(),
+  /** Pre-hide a subset of entity-children — created (state still flows)
+   *  but listed in the parent's `accessories.hiddenChildIds`. */
+  hiddenChildIds: array(string()).optional()
+});
+const AdoptInputSchema = object({
+  integrationId: string(),
+  /**
+   * Candidate native ids to adopt. Their MEANING is filter-relative: under the
+   * default `'devices'` granularity these are device-native ids; under a
+   * provider-declared granularity (e.g. HA `'entities'`) they are that
+   * granularity's native ids (e.g. entity ids). The field name is kept stable
+   * to avoid a breaking rename.
+   */
+  childNativeIds: array(string()).min(1),
+  /**
+   * Optional provider-declared discovery GRANULARITY id (opaque; see
+   * `AdoptionFilterSchema`). Omitted = the reserved `'devices'` granularity =
+   * exactly the pre-existing behavior (fully back-compatible).
+   */
+  filter: string().optional(),
+  /** When true, import each adopted device's source-system location (e.g. HA
+   *  area) into CamStack — fuzzy-match an existing location or create it, then
+   *  assign. Omitted/false = no location work (back-compat). */
+  importLocations: boolean().optional(),
+  perCandidate: record(string(), PerCandidateSchema).optional()
+});
+const AdoptResultSchema = object({
+  adopted: array(
+    object({
+      childNativeId: string(),
+      parentDeviceId: number().int().nonnegative(),
+      accessoryDeviceIds: array(number().int().nonnegative()).readonly()
+    })
+  ).readonly()
+});
+const ReleaseInputSchema = object({
+  integrationId: string(),
+  /** Parent CamStack device id (NOT an accessory child id). Removing
+   *  the parent cascades into every accessory. */
+  camDeviceId: number().int().nonnegative()
+});
+const ResyncInputSchema = object({
+  /** Parent CamStack device id of an adopted device. The provider resolves its
+   *  source (integration/broker + native id) and re-aligns the device's
+   *  structural spec (type/role/capabilities/units) with the live mapping,
+   *  rebuilding any child whose class changed while preserving operator edits. */
+  camDeviceId: number().int().nonnegative()
+});
+const ResyncResultSchema = object({
+  /** True when the persisted spec actually changed (children may have been rebuilt). */
+  changed: boolean(),
+  /** Number of child devices rebuilt into a new class by this re-sync. */
+  rebuiltChildren: number().int().nonnegative()
+});
+({
+  methods: {
+    listCandidateFilters: method(
+      object({ integrationId: string() }),
+      object({ filters: array(AdoptionFilterSchema) }),
+      { auth: "admin" }
+    ),
+    listCandidates: method(ListCandidatesInputSchema, ListCandidatesOutputSchema, { auth: "admin" }),
+    getCandidate: method(GetCandidateInputSchema, DiscoveredChildDeviceSchema.nullable(), { auth: "admin" }),
+    refresh: method(object({ integrationId: string() }), AdoptionStatusSchema, { kind: "mutation", auth: "admin" }),
+    adopt: method(AdoptInputSchema, AdoptResultSchema, { kind: "mutation", auth: "admin" }),
+    release: method(ReleaseInputSchema, _void(), { kind: "mutation", auth: "admin" }),
+    resync: method(ResyncInputSchema, ResyncResultSchema, { kind: "mutation", auth: "admin" })
+  }
+});
+const BrokerStatusEnum = _enum([
+  "connected",
+  "disconnected",
+  "connecting",
+  "auth-failed",
+  "unreachable",
+  "error"
+]);
+const BrokerInfoSchema$1 = object({
+  /** Stable broker id. Persisted; survives addon restarts. */
+  id: string(),
+  /** Addon id of the provider that OWNS this broker.
+   *
+   *  The `broker` cap is a system-scoped collection: several addons
+   *  register a `broker` provider, each owning a DISJOINT set of
+   *  brokers (mqtt-broker owns `mqtt_*`, provider-homeassistant owns
+   *  `ha_*`). A broker therefore belongs to exactly one addon — like a
+   *  device belongs to one integration. The admin UI threads this id
+   *  back as the `{ addonId }` system-collection selector on every
+   *  id-keyed call (`get` / `getSettings` / `setSettings` / `remove` /
+   *  `testConnection`), so the call routes to the OWNING provider
+   *  instead of defaulting to the first-registered one. */
+  addonId: string(),
+  /** Human-readable name (operator-chosen at add-time). */
+  name: string(),
+  /** Provider-defined kind tag — `mqtt` / `home-assistant` / future. */
+  kind: string(),
+  status: BrokerStatusEnum,
+  /** Free-form provider-specific info (HA version, MQTT broker
+   *  flavour, latency, mTLS active, …). */
+  info: record(string(), unknown()),
+  /** Ms epoch of the last connection probe / status update. */
+  lastCheckedAt: number().nullable(),
+  /** Last error message, when `status` indicates failure. */
+  error: string().nullable()
+});
+const RegistryStatusSchema = object({
+  brokerCount: number().int().nonnegative(),
+  connectedCount: number().int().nonnegative()
+});
+const BrokerProviderInfoSchema = object({
+  /** Addon id of the `broker` provider this entry describes. */
+  addonId: string(),
+  /** Broker kinds this provider can create, with a display label. */
+  kinds: array(object({ kind: string(), label: string() }))
+});
+const ListInputSchema = object({
+  /** Optional kind filter — `list({kind:'home-assistant'})` returns
+   *  only HA brokers. Omit to list every broker. */
+  kind: string().optional()
+});
+const GetInputSchema = object({ id: string() });
+const AddInputSchema = object({
+  kind: string().min(1),
+  name: string().min(1),
+  /** Kind-specific settings (e.g. MQTT `{url,username,password}` or HA
+   *  `{baseUrl,accessToken}`). Validated by the kind-specific provider
+   *  branch on receipt — invalid shape rejects the add. */
+  settings: record(string(), unknown())
+});
+const AddResultSchema = object({ id: string() });
+const RemoveInputSchema = object({ id: string() });
+const TestConnectionResultSchema$1 = discriminatedUnion("ok", [
+  object({ ok: literal(true), latencyMs: number().nonnegative() }),
+  object({ ok: literal(false), error: string() })
+]);
+const SettingsRecordSchema = record(string(), unknown());
+const SettingsSchemaInputSchema = object({ kind: string() });
+const TestSettingsInputSchema = object({
+  kind: string(),
+  settings: SettingsRecordSchema
+});
+const TestSettingsResultSchema = discriminatedUnion("ok", [
+  // `.strict()` on the success branch so a stray `error` field is rejected,
+  // not silently stripped — a success result must never carry an error.
+  object({ ok: literal(true), latencyMs: number().nonnegative().optional() }).strict(),
+  object({ ok: literal(false), error: string() })
+]);
+const SettingsSchemaResultSchema = unknown().nullable();
+const PublishInputSchema = object({
+  brokerId: string(),
+  /** Kind-specific routing target.
+   *  MQTT: `{ topic: string, qos?: 0|1|2, retain?: boolean }`.
+   *  HA:   `{ domain: string, service: string, entityId?: string, area?: string }`. */
+  target: record(string(), unknown()),
+  /** Kind-specific payload.
+   *  MQTT: raw string / number / object (provider serialises).
+   *  HA:   service-call `data` object (transition, brightness, …). */
+  payload: unknown().optional()
+});
+const SubscribeInputSchema = object({
+  brokerId: string(),
+  /** Kind-specific filter.
+   *  MQTT: `{ topic: string, qos?: 0|1|2 }` — topic can include wildcards.
+   *  HA:   `{ entityIds: string[] }` or `{ domain: string }`. */
+  filter: record(string(), unknown())
+});
+const SubscribeResultSchema = object({
+  /** Stable subscription id. Used to unsubscribe and to filter the
+   *  matching `broker.message` events on the bus. */
+  subscriptionId: string()
+});
+const UnsubscribeInputSchema = object({
+  brokerId: string(),
+  subscriptionId: string()
+});
+const GetStateInputSchema = object({
+  brokerId: string(),
+  /** Kind-specific lookup key.
+   *  MQTT: topic string (returns the last retained message).
+   *  HA:   entity_id (returns the cached entity state). */
+  key: string()
+});
+({
+  methods: {
+    // ── Registry CRUD ────────────────────────────────────────────────
+    list: method(ListInputSchema, array(BrokerInfoSchema$1)),
+    get: method(GetInputSchema, BrokerInfoSchema$1.nullable()),
+    /** Enumerate which addon provides which broker kind(s) for the
+     *  unified create picker. The auto-mount fans this array across
+     *  every registered `broker` provider (array-output method), so the
+     *  picker sees every kind from every provider in one call. */
+    listProviders: method(_void(), array(BrokerProviderInfoSchema), { auth: "admin" }),
+    add: method(AddInputSchema, AddResultSchema, { kind: "mutation", auth: "admin" }),
+    remove: method(RemoveInputSchema, _void(), { kind: "mutation", auth: "admin" }),
+    testConnection: method(GetInputSchema, TestConnectionResultSchema$1, { kind: "mutation", auth: "admin" }),
+    // ── Settings ─────────────────────────────────────────────────────
+    /** Read the persisted settings record for a broker (kind-specific
+     *  shape). Admin-only — settings may contain secrets. Returns `null`
+     *  when the broker id is unknown to the provider (the collection
+     *  fallback may route a foreign id to the first provider). */
+    getSettings: method(GetInputSchema, SettingsRecordSchema.nullable(), { auth: "admin" }),
+    /** Overwrite the persisted settings record. The kind-specific
+     *  provider validates the shape and applies the change (reconnects
+     *  if credentials changed). */
+    setSettings: method(
+      object({ id: string(), settings: SettingsRecordSchema }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    // ── Connection-config (for consumers that open their own client) ─
+    /** Returns the kind-specific connection config the consumer needs
+     *  to open its own client (MQTT pattern: `{url, username, password,
+     *  clientIdPrefix}`). HA providers MAY return the auth envelope
+     *  but typical HA consumers use `publish` / `subscribe` instead.
+     *  Returns `null` when the broker id is unknown to the provider. */
+    getBrokerConfig: method(GetInputSchema, SettingsRecordSchema.nullable(), { auth: "admin" }),
+    // ── Per-kind creation schema + pre-creation test ─────────────────
+    getSettingsSchema: method(SettingsSchemaInputSchema, SettingsSchemaResultSchema, { auth: "admin" }),
+    testSettings: method(TestSettingsInputSchema, TestSettingsResultSchema, { kind: "mutation", auth: "admin" }),
+    // ── Pub/sub primitives ───────────────────────────────────────────
+    publish: method(PublishInputSchema, unknown(), { kind: "mutation", auth: "admin" }),
+    subscribe: method(SubscribeInputSchema, SubscribeResultSchema, { kind: "mutation", auth: "admin" }),
+    unsubscribe: method(UnsubscribeInputSchema, _void(), { kind: "mutation", auth: "admin" }),
+    /** Read the broker's cached state for a key. Returns `null` when
+     *  unknown to the broker (never published / unknown entity). */
+    getState: method(GetStateInputSchema, unknown().nullable()),
+    /** Status method — explicit registration with a `z.void()` input so
+     *  the codegen-generated tRPC router types its input as
+     *  `{addonId?: string, nodeId?: string}` (system-scoped collection
+     *  shape) instead of the device-scoped `{deviceId}` fallback. */
+    getStatus: method(_void(), RegistryStatusSchema)
+  }
+});
 const BrokerKindSchema = _enum(["external", "embedded"]);
 const BrokerStatusSchema = _enum([
   "connected",
@@ -9518,7 +11813,15 @@ const WebrtcStreamChoiceSchema = object({
          * direct (host/srflx) path. Clients MUST NOT send this — the
          * server overwrites it from the request context.
          */
-        relayOnly: boolean().optional()
+        relayOnly: boolean().optional(),
+        /**
+         * Subscriber attribution surfaced in the stream-broker widget's
+         * client list. Callers (Alexa addon, browser hooks, WHEP server)
+         * populate `kind` and any of `label`/`userId`/`sessionId`/
+         * `remoteAddr` they know. The hub layer enriches `remoteAddr`
+         * from the tRPC request context.
+         */
+        consumerAttribution: BrokerConsumerAttributionSchema.optional()
       }),
       object({ sessionId: string(), sdpOffer: string() }),
       { kind: "mutation" }
@@ -9556,7 +11859,62 @@ const WebrtcStreamChoiceSchema = object({
          * Untrusted browser clients MUST NOT send it — the hub overwrites
          * it from the request context.
          */
-        relayOnly: boolean().optional()
+        relayOnly: boolean().optional(),
+        /**
+         * Force a NON-TRICKLE answer: the server awaits ICE gathering to
+         * COMPLETE and returns a full-candidate answer SDP (with `a=candidate`
+         * lines) instead of the default bare/trickle answer.
+         *
+         * Set `true` by callers that DON'T support trickle ICE — notably
+         * Alexa's RTCSessionController, which never polls `getIceCandidates`
+         * nor trickles back via `addIceCandidate`, so without server
+         * candidates in the answer SDP its ICE agent stalls (no nominated
+         * pair → DTLS never connects → Echo shows black → SessionDisconnected).
+         *
+         * Browser viewers leave it absent/false: they poll `getIceCandidates`
+         * and trickle, so the bare answer lets media start in ~0s instead of
+         * blocking on full gathering.
+         */
+        nonTrickle: boolean().optional(),
+        /**
+         * Suppress TURN servers from the per-session iceConfig: the answer
+         * will carry ONLY host + srflx candidates, never a relay one.
+         *
+         * Set `true` by peers that are themselves directly reachable on the
+         * public internet (Alexa's RTCSessionController media gateway is
+         * AWS-hosted with public host candidates). Including a TURN relay
+         * for such a peer is counterproductive: (a) gathering blocks on the
+         * TURN allocation round-trip and slows the answer; (b) werift
+         * spends ICE-checking budget on a relay-pair that the peer cannot
+         * use, sometimes stalling the host/srflx pair validation enough
+         * that Echo's agent times out before nominating one — visible as
+         * 'ICE checking → DTLS never connected'. Browser viewers leave it
+         * absent/false so the relay candidate remains as a fallback for
+         * symmetric-NAT clients.
+         *
+         * Independent from `relayOnly`. `relayOnly: true` forces ICE to a
+         * relay-only pair set; `disableTurn: true` strips the relay
+         * candidate entirely. They are mutually exclusive in practice but
+         * not policed at the schema level — callers MUST NOT set both.
+         */
+        disableTurn: boolean().optional(),
+        /**
+         * Suppress IPv6 host candidates from gathering and from
+         * `additionalHostAddresses`. The answer SDP will contain only IPv4
+         * host/srflx (and TURN, unless `disableTurn` is also set).
+         *
+         * Set `true` by peers that document IPv4-only ICE — Amazon's
+         * `Alexa.RTCSessionController` spec states: "For ICE candidates,
+         * you can use either UDP or TCP but you must use IPv4." Echo's
+         * media gateway ignores IPv6 candidates and they consume budget
+         * against the gateway's documented 6-second SDP processing limit.
+         *
+         * Browser viewers leave it absent/false so IPv6-only paths
+         * (Tailscale, native dual-stack) remain available.
+         */
+        disableIpv6: boolean().optional(),
+        /** Subscriber attribution. See `createSession` for the contract. */
+        consumerAttribution: BrokerConsumerAttributionSchema.optional()
       }),
       object({ sessionId: string(), sdpAnswer: string() }),
       { kind: "mutation" }
@@ -9575,7 +11933,7 @@ const WebrtcStreamChoiceSchema = object({
      * Lets the client send its SDP offer/answer IMMEDIATELY (before ICE
      * gathering finishes) and deliver candidates as they arrive, so the
      * connection establishes in ~0s instead of waiting for full gathering.
-     * The dual of `getIceCandidates`. Mirrors Scrypted's signaling.
+     * The dual of `getIceCandidates` in the trickle-ICE signaling exchange.
      */
     addIceCandidate: method(
       object({
@@ -9625,6 +11983,18 @@ const WebrtcStreamChoiceSchema = object({
         profile: CamProfileSchema
       }),
       boolean()
+    ),
+    /** Poll the live signaling state of a session. `pendingRenegotiation` is
+     *  non-null after an adaptive tier switch — the client re-offers on the
+     *  same sessionId; `epoch` guards against acting on a stale poll twice. */
+    getSessionState: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        sessionId: string()
+      }),
+      object({
+        pendingRenegotiation: object({ target: WebrtcStreamTargetSchema, epoch: number() }).nullable()
+      })
     )
   }
 });
@@ -10237,6 +12607,26 @@ const embeddingEncoderCapability = {
     getInfo: method(_void(), EmbeddingInfoSchema)
   }
 };
+const ChildLayoutEntrySchema = object({
+  childKey: string(),
+  section: string(),
+  order: number().optional(),
+  // Section-level default-collapsed hint: when true the accordion section this
+  // entry belongs to renders closed by default. The section is treated as
+  // collapsed if ANY of its entries sets collapsed:true; consistent values
+  // across a section's entries are recommended but not enforced. Absent ⇒ open.
+  collapsed: boolean().optional()
+});
+const DeviceLinkSchema = object({
+  id: string(),
+  source: object({ sourceKey: string(), cap: string(), fieldPath: string() }),
+  target: object({ cap: string(), fieldPath: string(), itemKey: string().optional() }),
+  transform: discriminatedUnion("kind", [
+    object({ kind: literal("identity") }),
+    object({ kind: literal("enum-map"), mapping: record(string(), union([string(), number(), boolean()])), fallback: union([string(), number(), boolean()]).optional() }),
+    object({ kind: literal("linear"), scale: number(), offset: number(), clamp: tuple([number(), number()]).readonly().optional() })
+  ]).optional()
+});
 const DeviceInfoSchema = object({
   /** Progressive, system-wide unique number. Allocated synchronously by
    *  `device-manager.allocateDeviceId` BEFORE the owning `IDevice` is
@@ -10256,6 +12646,12 @@ const DeviceInfoSchema = object({
   /** Optional semantic role — `DeviceRole` string. null for top-level devices. */
   role: string().nullable().optional(),
   online: boolean(),
+  /** True when the device's initial feature-probe has completed (or it has
+   *  no probe) — exported shape is stable; exporters gate advertise on this.
+   *  Optional for deploy-order resilience: a record produced by an older
+   *  device-manager build omits it, and consumers treat absent as "not ready"
+   *  (export gate carries forward, never advertises a partial shape). */
+  probed: boolean().optional(),
   features: array(string()),
   /** true when the device has a getStreamSources() method (ICameraDevice) */
   isCamera: boolean(),
@@ -10263,7 +12659,25 @@ const DeviceInfoSchema = object({
   config: record(string(), unknown()),
   /** Hardware + identity blob (manufacturer / model / firmware / sn /
    *  uid / mac / …). Populated by drivers; editable via setMetadata. */
-  metadata: record(string(), unknown()).nullable().optional()
+  metadata: record(string(), unknown()).nullable().optional(),
+  /** Optional upstream-system identity + rendering envelope. See
+   *  `SourceInfo` in `packages/types/src/device/source-info.ts`. */
+  sourceInfo: SourceInfoSchema.optional(),
+  /** Owning integration id, stamped at create — used by the core to
+   *  cascade-delete an integration's devices. Optional: only present
+   *  when the device was created through an integration (e.g. HA). */
+  integrationId: string().optional(),
+  linkDeviceId: number().nullable().optional(),
+  /** Durable primary-child override for a CONTAINER device, keyed on the
+   *  chosen child's re-sync/rename-stable `entityId`. Survives a re-sync
+   *  that reallocates the child's numeric id. `null` clears the override. */
+  primaryChildEntityId: string().nullable().optional(),
+  /** Container-level layout hint: assigns specific child/accessory devices to
+   *  named accordion sections (with optional intra-section order). See
+   *  `DeviceMeta.childLayout`. Absent ⇒ no layout declared. */
+  childLayout: array(ChildLayoutEntrySchema).readonly().optional(),
+  /** Operator-authored cross-device field wirings. See `DeviceMeta.deviceLinks`. */
+  deviceLinks: array(DeviceLinkSchema).readonly().optional()
 });
 const ConfigEntrySchema$1 = object({
   key: string(),
@@ -10294,7 +12708,32 @@ const DeviceMetaSchema = object({
   location: string().nullable(),
   disabled: boolean(),
   parentDeviceId: number().nullable(),
-  metadata: record(string(), unknown()).nullable().optional()
+  metadata: record(string(), unknown()).nullable().optional(),
+  /** Optional upstream-system identity + rendering envelope. See
+   *  `SourceInfo`. Present when the device has been persisted with a
+   *  non-synthetic source identifier (HA entities, vendor MAC, …);
+   *  omitted when the synthetic `{ id: stableId, system: addonId }`
+   *  fallback is in effect. Persisted under
+   *  `DeviceMeta.metadata.sourceInfo` — the field on this schema is
+   *  the typed projection callers consume directly. */
+  sourceInfo: SourceInfoSchema.optional(),
+  /** Owning integration id, stamped at create — used by the core to
+   *  cascade-delete an integration's devices. Optional: only present
+   *  when the device was created through an integration (e.g. HA). */
+  integrationId: string().optional(),
+  linkDeviceId: number().nullable().optional(),
+  /** Durable primary-child override for a CONTAINER device, keyed on the
+   *  chosen child's re-sync/rename-stable `entityId`. See `DeviceMeta`. */
+  primaryChildEntityId: string().nullable().optional(),
+  /** Container-level layout hint: assigns child/accessory devices to named
+   *  accordion sections (with optional intra-section order). See
+   *  `DeviceMeta.childLayout`. Absent ⇒ no layout declared. */
+  childLayout: array(ChildLayoutEntrySchema).readonly().optional(),
+  /** Operator-authored cross-device field wirings. See `DeviceMeta.deviceLinks`. */
+  deviceLinks: array(DeviceLinkSchema).readonly().optional(),
+  /** Semantic role string (`DeviceRole`) — propagated from the spawn pre-seed.
+   *  Optional: only present for accessory children that carry a known role. */
+  role: string().nullable().optional()
 });
 const ConfigUISchemaOutput = unknown().nullable();
 const StreamProbeResultSchema = object({
@@ -10388,6 +12827,109 @@ const DevicePersistConfigPayloadSchema = object({
       _void(),
       { kind: "mutation", auth: "admin" }
     ),
+    /** Update the device type. Writes the meta row, emits a
+     *  `DeviceMetaChanged` event. Used by the kernel to apply
+     *  `initialMeta.type` before device construction so the device
+     *  constructs with its real type instead of the allocateDeviceId
+     *  placeholder `'generic'`. */
+    setType: method(
+      object({ deviceId: number(), type: _enum(DeviceType) }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    /** Stamp (or update) the owning integration id on the device's meta
+     *  row. Called by the kernel's `create()` pre-seed path when
+     *  `initialMeta.integrationId` is set (analogous to `setName` /
+     *  `setType`). Idempotent. */
+    setIntegrationId: method(
+      object({ deviceId: number(), integrationId: string() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    /** Stamp (or update) the soft-link device id on the device's meta
+     *  row. Called by the kernel `create()` pre-seed when
+     *  `initialMeta.linkDeviceId !== undefined`. Idempotent. */
+    setLinkDeviceId: method(
+      object({ deviceId: number(), linkDeviceId: number().nullable() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    /** Set (or clear) the durable primary-child override on a CONTAINER
+     *  device's meta row, keyed on the chosen child's re-sync/rename-stable
+     *  `entityId`. Unlike `setLinkDeviceId` (numeric child id, goes stale on
+     *  re-sync), this survives a re-sync that reallocates the child's numeric
+     *  id. `null` clears the override → priority default. Idempotent. */
+    setPrimaryChildEntityId: method(
+      object({ deviceId: number(), primaryChildEntityId: string().nullable() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    /** Set (or replace) the container-level `childLayout` on a device's meta
+     *  row — assigns specific child/accessory devices to named accordion
+     *  sections (with optional intra-section order). Mirrors
+     *  `setPrimaryChildEntityId`; the layout is parent-only. Persisted,
+     *  projected, and preserved across re-register/restore. Idempotent. */
+    setChildLayout: method(
+      object({ deviceId: number(), childLayout: array(ChildLayoutEntrySchema).readonly() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    /** Set (or replace) the cross-device field wirings on a device's meta row.
+     *  Mirrors `setChildLayout`; persisted, projected, preserved across
+     *  re-register/restore. Idempotent. */
+    setDeviceLinks: method(
+      object({ deviceId: number(), deviceLinks: array(DeviceLinkSchema).readonly() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    /** List the wireable status-schema fields per cap bound to a device.
+     *  Powers the Wiring tab's field pickers. Caps without a status schema are omitted. */
+    getWireableFields: method(
+      object({ deviceId: number() }),
+      object({
+        caps: array(object({
+          cap: string(),
+          fields: array(object({
+            path: string(),
+            kind: _enum(["string", "number", "boolean", "enum"]),
+            enumValues: array(string()).optional()
+          })).readonly()
+        })).readonly()
+      }),
+      { kind: "query" }
+    ),
+    /** Stamp (or update) the semantic role on the device's meta row.
+     *  Called by the kernel's `create()` / `spawnAccessoryChild` pre-seed
+     *  path when `initialMeta.role` is set (analogous to `setIntegrationId`).
+     *  Idempotent. `null` explicitly clears a previous role. */
+    setRole: method(
+      object({ deviceId: number(), role: string().nullable() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
+    /** Batched meta pre-seed — applies every provided field to the device's
+     *  meta row in ONE settings round-trip (one lock acquisition, one
+     *  `deviceMeta` write) and emits one `DeviceMetaChanged` event per field
+     *  that was supplied. Each field carries the SAME semantics as its
+     *  individual setter (`setName` / `setLocation` / `setType` /
+     *  `setIntegrationId` / `setLinkDeviceId` / `setRole`) — omitted fields are
+     *  left untouched; `null` clears `location` / `linkDeviceId` / `role`.
+     *  Idempotent. Used by the kernel's `spawnAccessoryChild` flow to collapse
+     *  the per-child meta pre-seed (4-6 individual setter calls) into one,
+     *  which is the dominant cost when reconciling a many-entity container. */
+    applyInitialMeta: method(
+      object({
+        deviceId: number(),
+        name: string().optional(),
+        location: string().nullable().optional(),
+        type: _enum(DeviceType).optional(),
+        integrationId: string().optional(),
+        linkDeviceId: number().nullable().optional(),
+        role: string().nullable().optional()
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
     /** Patch the device's hardware-identity metadata blob. Merges
      *  `patch` over the current blob (shallow). Value `null` for a
      *  given key removes that key. Drivers populate factual fields
@@ -10501,6 +13043,15 @@ const DevicePersistConfigPayloadSchema = object({
       object({ success: literal(true) }),
       { kind: "mutation", auth: "admin" }
     ),
+    /** Cascade-delete every top-level device whose `integrationId` matches.
+     *  Children cascade automatically via the per-parent remove path.
+     *  Idempotent: a device whose `integrationId` was never set never matches.
+     *  Returns the count of top-level parents actually removed. */
+    removeByIntegration: method(
+      object({ integrationId: string() }),
+      object({ removed: number() }),
+      { kind: "mutation", auth: "admin" }
+    ),
     // ── Stream profile map ────────────────────────────────────────────────────
     /** Get quality→streamId mapping for a camera. Derived from profileHint if not explicitly set. */
     getStreamProfileMap: method(
@@ -10644,6 +13195,15 @@ const DevicePersistConfigPayloadSchema = object({
         live: SettingsSchemaWithValuesSchema.nullable()
       })
     ),
+    runDeviceAction: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        action: string().min(1),
+        input: unknown()
+      }),
+      unknown(),
+      { kind: "mutation" }
+    ),
     updateDeviceField: method(
       object({
         deviceId: number(),
@@ -10698,7 +13258,11 @@ const DevicePersistConfigPayloadSchema = object({
     adoptDevice: method(
       object({
         addonId: string(),
-        candidate: DiscoveryCandidateSchema
+        candidate: DiscoveryCandidateSchema,
+        /** Owning integration id, stamped onto the new device's meta by the
+         *  device-manager forwarder so `removeByIntegration` can cascade it.
+         *  Optional for back-compat (omitted = no stamp = pre-existing behavior). */
+        integrationId: string().optional()
       }),
       DeviceSummarySchema,
       { kind: "mutation", auth: "admin" }
@@ -10719,7 +13283,11 @@ const DevicePersistConfigPayloadSchema = object({
       object({
         addonId: string(),
         type: _enum(DeviceType),
-        config: record(string(), unknown())
+        config: record(string(), unknown()),
+        /** Owning integration id, stamped onto the new device's meta by the
+         *  device-manager forwarder so `removeByIntegration` can cascade it.
+         *  Optional for back-compat (omitted = no stamp = pre-existing behavior). */
+        integrationId: string().optional()
       }),
       DeviceSummarySchema,
       { kind: "mutation", auth: "admin" }
@@ -10743,6 +13311,41 @@ const DevicePersistConfigPayloadSchema = object({
       FieldProbeResultSchema,
       { kind: "mutation", auth: "admin" }
     ),
+    // ── Device-adoption operations (routed via CapabilityRegistry) ────────────
+    //
+    // These methods proxy to the `device-adoption` capability for an
+    // integration-style addon (Home Assistant, …), routing by addonId —
+    // the same hub-side proxy pattern as `discoverDevices`/`adoptDevice`
+    // above. The admin UI's generic adopt modal calls them through this
+    // singleton so it never needs a direct handle on the addon's
+    // `device-adoption` provider.
+    // getCandidate is not proxied — the adopt modal expands rows from
+    // listCandidates' nested `children`, so a single-candidate fetch is
+    // never needed at this layer.
+    /** List adoption candidates for an integration via its device-adoption provider. */
+    adoptionListCandidates: method(
+      ListCandidatesInputSchema.extend({ addonId: string() }),
+      ListCandidatesOutputSchema,
+      { auth: "admin" }
+    ),
+    /** Trigger a discovery refresh on the integration's device-adoption provider. */
+    adoptionRefresh: method(
+      object({ addonId: string(), integrationId: string() }),
+      AdoptionStatusSchema,
+      { kind: "mutation", auth: "admin" }
+    ),
+    /** Adopt one or more discovered candidates via the device-adoption provider. */
+    adoptionAdopt: method(
+      AdoptInputSchema.extend({ addonId: string() }),
+      AdoptResultSchema,
+      { kind: "mutation", auth: "admin" }
+    ),
+    /** Release an adopted parent device via the device-adoption provider. */
+    adoptionRelease: method(
+      ReleaseInputSchema.extend({ addonId: string() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    ),
     /**
      * Test a field value on an existing device (e.g. probe an RTSP URL).
      * Routes through the device-provider for the owning addon.
@@ -11030,7 +13633,11 @@ const NotificationRuleConditionsSchema = object({
     endHour: number()
   }).optional(),
   cooldownSeconds: number().optional(),
-  minDwellSeconds: number().optional()
+  minDwellSeconds: number().optional(),
+  /** Match against `event.data.eventType` token (e.g. `'press_long'`). When non-empty, only events
+   *  carrying a matching `data.eventType` string pass this condition. Rules without this field are
+   *  unaffected (back-compat). Distinct from `rule.eventTypes` which holds EventCategory strings. */
+  eventTypeTokens: array(string()).readonly().optional()
 });
 const NotificationRuleTemplateSchema = object({
   title: string(),
@@ -11099,192 +13706,6 @@ const NotificationHistoryFilterSchema = object({
     )
   }
 });
-const RecordingModeSchema = _enum(["continuous", "motion", "scheduled", "composite"]);
-const StreamPolicySchema = object({
-  streamId: string(),
-  mode: _enum(["always", "inherit"])
-});
-const ScheduleRuleSchema = object({
-  days: array(number()).readonly(),
-  startTime: string(),
-  endTime: string(),
-  mode: _enum(["continuous", "motion"])
-});
-const RecordingPolicySchema = object({
-  deviceId: number(),
-  mode: RecordingModeSchema,
-  streams: array(StreamPolicySchema).readonly(),
-  enabled: boolean(),
-  preBufferSec: number(),
-  postBufferSec: number(),
-  scheduleRules: array(ScheduleRuleSchema).readonly().optional()
-});
-const DataCategorySchema = _enum([
-  "recording:main",
-  "recording:mid",
-  "recording:sub",
-  "thumbnail:scrub",
-  "thumbnail:event"
-]);
-const RecordingStorageConfigSchema = object({
-  deviceId: number(),
-  dataCategory: DataCategorySchema,
-  storageName: string(),
-  subDirectory: string(),
-  retentionDays: number().nullable(),
-  retentionGb: number().nullable()
-});
-const RecordingSegmentSchema = object({
-  id: string(),
-  deviceId: number(),
-  streamId: string(),
-  startTime: number(),
-  endTime: number(),
-  duration: number(),
-  path: string(),
-  storageName: string(),
-  subDirectory: string(),
-  sizeBytes: number(),
-  codec: _enum(["h264", "h265"]),
-  hasAudio: boolean()
-});
-const RecordingThumbnailSchema = object({
-  deviceId: number(),
-  timestamp: number(),
-  path: string(),
-  storageName: string(),
-  subDirectory: string(),
-  sizeBytes: number(),
-  category: _enum(["scrub", "event"])
-});
-const AvailabilityRangeSchema = object({
-  startTime: number(),
-  endTime: number(),
-  streams: array(string()).readonly()
-});
-const StorageUsageSchema = object({
-  totalBytes: number(),
-  segmentCount: number()
-});
-const StreamEstimateSchema = object({
-  bitrateKbps: number(),
-  retentionDays: number().nullable(),
-  retentionGb: number().nullable(),
-  estimatedGb: number(),
-  estimatedDaysAtCapacity: number().nullable()
-});
-const StorageEstimateSchema = object({
-  perStream: record(string(), StreamEstimateSchema),
-  thumbnails: object({ estimatedGb: number() }),
-  totalEstimatedGb: number(),
-  motionEstimate: object({
-    avgEventsPerDay: number(),
-    avgDurationSec: number(),
-    dutyCyclePercent: number()
-  }).optional()
-});
-const MotionStatsSchema = object({
-  totalEvents: number(),
-  avgDurationSec: number(),
-  avgEventsPerDay: number(),
-  dutyCyclePercent: number()
-});
-const DeviceIdInput = object({ deviceId: number() });
-const EnableInput = object({
-  deviceId: number(),
-  policy: RecordingPolicySchema.omit({ deviceId: true }),
-  storageOverrides: array(RecordingStorageConfigSchema.omit({ deviceId: true })).readonly().optional(),
-  ffmpegOverrides: record(string(), unknown()).optional()
-});
-const TimeRangeInput = object({
-  deviceId: number(),
-  startTime: number(),
-  endTime: number()
-});
-const StreamTimeRangeInput = object({
-  deviceId: number(),
-  streamId: string(),
-  startTime: number(),
-  endTime: number()
-});
-const PlaylistInput = object({
-  deviceId: number(),
-  streamId: string(),
-  startTime: number(),
-  endTime: number(),
-  live: boolean().optional()
-});
-const ThumbnailInput = object({
-  deviceId: number(),
-  timestamp: number(),
-  category: string().optional()
-});
-const DeviceStreamInput = object({
-  deviceId: number(),
-  streamId: string()
-});
-const StorageEstimateInput = object({
-  deviceId: number(),
-  motionInput: object({
-    avgEventsPerDay: number(),
-    avgDurationSec: number()
-  }).optional()
-});
-const RetentionConfigInput = object({
-  deviceId: number(),
-  dataCategory: DataCategorySchema
-});
-const SetPolicyInput = object({
-  deviceId: number(),
-  policy: RecordingPolicySchema.omit({ deviceId: true })
-});
-const UpdateConfigInput = object({
-  deviceId: number(),
-  policy: RecordingPolicySchema.omit({ deviceId: true }),
-  ffmpegOverrides: record(string(), unknown()).optional()
-});
-const recordingEngineCapability = {
-  name: "recording-engine",
-  scope: "system",
-  mode: "singleton",
-  methods: {
-    // ── Status ────────────────────────────────────────────────────────
-    getStatus: method(_void(), object({
-      activeRecordings: number(),
-      totalSegments: number(),
-      totalSizeMB: number()
-    })),
-    // ── Lifecycle ─────────────────────────────────────────────────────
-    enable: method(EnableInput, _void(), { kind: "mutation", auth: "admin" }),
-    disable: method(DeviceIdInput, _void(), { kind: "mutation", auth: "admin" }),
-    // ── Config ────────────────────────────────────────────────────────
-    getConfig: method(DeviceIdInput, RecordingPolicySchema.nullable()),
-    updateConfig: method(UpdateConfigInput, _void(), { kind: "mutation", auth: "admin" }),
-    // ── Playback ──────────────────────────────────────────────────────
-    getPlaylist: method(PlaylistInput, string()),
-    getThumbnail: method(ThumbnailInput, RecordingThumbnailSchema.nullable()),
-    getSegments: method(StreamTimeRangeInput, array(RecordingSegmentSchema).readonly()),
-    getAvailability: method(TimeRangeInput, array(AvailabilityRangeSchema).readonly()),
-    // ── Storage ───────────────────────────────────────────────────────
-    estimateStorage: method(StorageEstimateInput, StorageEstimateSchema),
-    estimateGlobalStorage: method(_void(), StorageEstimateSchema),
-    getStorageUsage: method(DeviceStreamInput, StorageUsageSchema),
-    // ── Policy ────────────────────────────────────────────────────────
-    setPolicy: method(SetPolicyInput, _void(), { kind: "mutation", auth: "admin" }),
-    getPolicy: method(DeviceIdInput, RecordingPolicySchema.nullable()),
-    getPolicyStatus: method(DeviceIdInput, object({
-      deviceId: number(),
-      enabled: boolean(),
-      mode: RecordingModeSchema,
-      activeStreams: number()
-    }).nullable()),
-    // ── Retention ─────────────────────────────────────────────────────
-    getRetentionConfig: method(RetentionConfigInput, RecordingStorageConfigSchema.nullable()),
-    updateRetentionConfig: method(RecordingStorageConfigSchema, _void(), { kind: "mutation", auth: "admin" }),
-    // ── Motion ────────────────────────────────────────────────────────
-    getMotionStats: method(TimeRangeInput, MotionStatsSchema)
-  }
-};
 ({
   deviceTypes: [DeviceType.Camera]
 });
@@ -11333,26 +13754,38 @@ const MotionEventSchema = object({
   ...BaseEventFields,
   kind: literal("motion"),
   regionCount: number(),
+  /** Heavy JSON array — omitted in slim projection. */
   regions: array(object({
     bbox: BoundingBoxSchema,
     pixelCount: number(),
     intensity: number()
-  })).readonly(),
-  frameWidth: number(),
-  frameHeight: number()
+  })).readonly().optional(),
+  /** Omitted in slim projection. */
+  frameWidth: number().optional(),
+  /** Omitted in slim projection. */
+  frameHeight: number().optional(),
+  /** Populated by B5 (recording playback URL for this event). */
+  mediaUrl: string().optional()
 });
 const ObjectEventSchema = object({
   ...BaseEventFields,
   kind: literal("object"),
-  trackId: string(),
+  /** Omitted in slim projection. */
+  trackId: string().optional(),
   className: string(),
   label: string().optional(),
-  confidence: number(),
-  bbox: BoundingBoxSchema,
-  zones: array(string()).readonly(),
-  state: TrackStateSchema,
+  /** Omitted in slim projection. */
+  confidence: number().optional(),
+  /** Heavy JSON — omitted in slim projection. */
+  bbox: BoundingBoxSchema.optional(),
+  /** Heavy JSON — omitted in slim projection. */
+  zones: array(string()).readonly().optional(),
+  /** Omitted in slim projection. */
+  state: TrackStateSchema.optional(),
   /** MediaStore key for the crop attached to this event (if any). */
-  mediaKey: string().optional()
+  mediaKey: string().optional(),
+  /** Populated by B5 (recording playback URL for this event). */
+  mediaUrl: string().optional()
 });
 const AudioEventSchema = object({
   ...BaseEventFields,
@@ -11363,7 +13796,9 @@ const AudioEventSchema = object({
     className: string(),
     originalClass: string().optional(),
     score: number()
-  }).optional()
+  }).optional(),
+  /** Populated by B5 (recording playback URL for this event). */
+  mediaUrl: string().optional()
 });
 const MediaFileSchema = object({
   key: string(),
@@ -11378,7 +13813,12 @@ const DeviceEventQueryInput = object({
   deviceId: number(),
   since: number().optional(),
   until: number().optional(),
-  limit: number().int().min(1).max(MAX_EVENT_QUERY_LIMIT).default(DEFAULT_EVENT_QUERY_LIMIT)
+  limit: number().int().min(1).max(MAX_EVENT_QUERY_LIMIT).default(DEFAULT_EVENT_QUERY_LIMIT),
+  /** `slim` drops heavy JSON fields (regions/bbox/zones) and carries an
+   *  optional `mediaUrl` (populated by B5). `full` (default) keeps today's
+   *  exact behaviour. Callers may omit this field — the store defaults to
+   *  `full` when not provided. */
+  projection: _enum(["full", "slim"]).optional()
 });
 const ObjectEventQueryInput = DeviceEventQueryInput.extend({
   classFilter: string().optional()
@@ -11439,6 +13879,37 @@ const pipelineAnalyticsCapability = {
       DeviceEventQueryInput,
       array(AudioEventSchema).readonly()
     ),
+    // ── Density (timeline histogram) ──────────────────────────
+    /** Server-side bucketed event counts for the 24-hour timeline.
+     *  Returns one entry per non-empty bucket; empty buckets are omitted. */
+    getEventDensity: method(
+      object({
+        deviceId: number(),
+        since: number(),
+        until: number(),
+        bucketMs: number().int().positive()
+      }),
+      array(object({
+        bucketStart: number(),
+        motion: number().int(),
+        object: number().int(),
+        audio: number().int()
+      })).readonly()
+    ),
+    // ── Maintenance ───────────────────────────────────────────
+    /**
+     * Delete all events (motion + object + audio) for the given device
+     * that are older than `cutoffMs` (exclusive), and delete their
+     * thumbnails in lockstep. Returns per-kind deleted counts.
+     *
+     * Called by Phase B3 recorder orchestration to keep event history
+     * aligned with available footage.
+     */
+    pruneEventsBefore: method(
+      object({ deviceId: number(), cutoffMs: number() }),
+      object({ motion: number().int(), object: number().int(), audio: number().int() }),
+      { kind: "mutation", auth: "admin" }
+    ),
     // ── Media ─────────────────────────────────────────────────
     getEventMedia: method(
       object({ eventId: string() }),
@@ -11792,32 +14263,102 @@ const EventItemSchema = object({
     )
   }
 });
-const SegmentSchema = object({
-  id: string(),
-  startTs: number(),
-  // unix ms
-  endTs: number(),
-  durationSec: number(),
-  sizeBytes: number().optional()
+const RecordingStatusSchema = object({
+  deviceId: number(),
+  enabled: boolean(),
+  activeMode: _enum(["off", "continuous"]),
+  nodeId: string(),
+  storageBytes: number()
+});
+const RecordingRangeSchema = object({
+  profile: string(),
+  startMs: number(),
+  endMs: number()
+});
+const RecordingAvailabilitySchema = object({
+  deviceId: number(),
+  ranges: array(RecordingRangeSchema)
+});
+const 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())
+});
+const RecordingDeviceUsageSchema = object({
+  deviceId: number(),
+  usedBytes: number()
+});
+const RecordingLocationUsageSchema = object({
+  /** StorageLocation id; null for the legacy/degraded single-root fallback. */
+  locationId: string().nullable(),
+  /** Bytes of recordings stored on this location. */
+  usedBytes: number(),
+  /** Free bytes on the location's volume; null when capacity is unknown (remote). */
+  availableBytes: number().nullable(),
+  /** Total bytes of the location's volume; null when unknown. */
+  totalBytes: number().nullable()
+});
+const RecordingStorageUsageSchema = object({
+  nodeId: string(),
+  totalUsedBytes: number(),
+  devices: array(RecordingDeviceUsageSchema),
+  locations: array(RecordingLocationUsageSchema)
 });
 ({
-  deviceTypes: [DeviceType.Camera],
   methods: {
-    getSegments: method(
-      object({
-        deviceId: number(),
-        from: number().optional(),
-        to: number().optional()
-      }),
-      array(SegmentSchema)
+    getAvailability: method(
+      object({ deviceId: number(), fromMs: number(), toMs: number() }),
+      RecordingAvailabilitySchema,
+      { kind: "query", auth: "admin" }
     ),
-    getPlaybackUrl: method(
-      object({ deviceId: number(), segmentId: string() }),
-      string().nullable()
+    getPlaybackManifest: method(
+      object({ deviceId: number(), fromMs: number(), toMs: number() }),
+      RecordingManifestSchema,
+      { kind: "query", auth: "admin" }
     ),
-    getThumbnailAt: method(
-      object({ deviceId: number(), timestamp: number() }),
-      object({ base64: string(), contentType: string() }).nullable()
+    getStorageUsage: method(
+      object({}),
+      RecordingStorageUsageSchema,
+      { kind: "query", auth: "admin" }
+    ),
+    getDeviceConfig: method(
+      object({ deviceId: number() }),
+      RecordingConfigSchema,
+      { kind: "query", auth: "admin" }
+    ),
+    setDeviceConfig: method(
+      object({ deviceId: number(), config: RecordingConfigSchema }),
+      RecordingConfigSchema,
+      { kind: "mutation", auth: "admin" }
+    ),
+    /** Re-scan this device's footage from disk (stat sizes) and reseed the
+     *  index, then return the fresh status. */
+    rescanStorage: method(
+      object({ deviceId: number() }),
+      RecordingStatusSchema,
+      { kind: "mutation", auth: "admin" }
+    ),
+    /** Apply this device's retention policy to footage now; returns the oldest
+     *  surviving footage start (the retention floor) or null if no footage. */
+    pruneFootage: method(
+      object({ deviceId: number() }),
+      object({
+        floorMs: number().nullable(),
+        deletedBuckets: number().int(),
+        reclaimedBytes: number().int()
+      }),
+      { kind: "mutation", auth: "admin" }
     )
   }
 });
@@ -11830,13 +14371,19 @@ const StreamSourceEntrySchema = object({
   fps: number().optional(),
   bitrate: number().optional(),
   codec: string().optional(),
-  profileHint: _enum(["high", "mid", "low"]).optional(),
+  profileHint: CamProfileSchema.optional(),
   sdp: string().optional()
 });
 const ConfigEntrySchema = object({
   key: string(),
   value: unknown()
 });
+const RawStateResultSchema = object({
+  /** Originating provider id, e.g. 'homeassistant' | 'reolink' | 'hikvision'. */
+  source: string(),
+  /** Opaque, DISPLAY-SAFE upstream blob (no secrets/PII). */
+  data: record(string(), unknown())
+});
 ({
   methods: {
     /**
@@ -11868,6 +14415,21 @@ const ConfigEntrySchema = object({
       _void(),
       { kind: "mutation" }
     ),
+    /**
+     * Invoke a device custom action on a forked/remote device (the
+     * cross-process transport for `IDevice.runDeviceAction`). Mirrors
+     * `setConfig` — the device-manager calls this when the device is not
+     * hub-local.
+     */
+    runAction: method(
+      object({
+        deviceId: number(),
+        action: string().min(1),
+        input: unknown()
+      }),
+      unknown(),
+      { kind: "mutation" }
+    ),
     /**
      * Invoke `IDevice.removeDevice()` so the driver can release resources
      * (close sockets, stop background tasks, …). The device-manager still
@@ -11895,6 +14457,18 @@ const ConfigEntrySchema = object({
     getSettingsSchema: method(
       object({ deviceId: number() }),
       unknown().nullable()
+    ),
+    /**
+     * Opt-in: return the device's RAW upstream state (the provider's
+     * cached values) as a display-safe `{ source, data }` blob. Returns
+     * `null` when the device exposes no raw state — the State panel hides
+     * its Raw toggle in that case. One-shot (read the provider's existing
+     * cache; no upstream round-trip).
+     */
+    getRawState: method(
+      object({ deviceId: number() }),
+      RawStateResultSchema.nullable(),
+      { auth: "protected" }
     )
   }
 });
@@ -11952,6 +14526,16 @@ object({
     )
   }
 });
+({
+  deviceTypes: [DeviceType.Button],
+  methods: {
+    press: method(
+      object({ deviceId: number().int().nonnegative() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    )
+  }
+});
 const OsdOverlayKindEnum = _enum(["text", "timestamp", "watermark"]);
 const OsdPositionEnum = _enum([
   "top-left",
@@ -12014,18 +14598,72 @@ const OsdOverlayPatchSchema = object({
   }
 });
 object({
-  childDeviceIds: array(number()).readonly()
+  /** All accessory children of the parent. */
+  childDeviceIds: array(number()).readonly(),
+  /** Subset of `childDeviceIds` the operator hid from the UI. The order
+   *  is irrelevant; the array is treated as a set by consumers. */
+  hiddenChildIds: array(number()).readonly()
 });
 ({
-  deviceTypes: [DeviceType.Camera, DeviceType.Hub],
+  // Cameras + Hubs are the historical consumers; the HA integration
+  // landed in Phase E adds Switch / Light / Sensor / Thermostat / Cover
+  // / Lock / Fan / MediaPlayer / AlarmPanel / Generic as parent types
+  // for adopted HA devices whose entity-children sit under accessories.
+  deviceTypes: [
+    DeviceType.Camera,
+    DeviceType.Hub,
+    DeviceType.Switch,
+    DeviceType.Light,
+    DeviceType.Sensor,
+    DeviceType.Thermostat,
+    DeviceType.Cover,
+    DeviceType.Lock,
+    DeviceType.Fan,
+    DeviceType.MediaPlayer,
+    DeviceType.AlarmPanel,
+    DeviceType.Generic
+  ],
+  methods: {
+    /**
+     * Toggle the UI-visibility of a single accessory child. Hidden
+     * children stay registered and continue to receive state updates;
+     * they're omitted only from the parent's UI accessories panel.
+     *
+     * Idempotent — hiding an already-hidden child or unhiding a
+     * non-hidden child is a no-op. Providers that don't support
+     * per-child visibility may implement this as a no-op (the UI hide
+     * toggle gracefully degrades).
+     */
+    setChildHidden: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        childDeviceId: number().int().nonnegative(),
+        hidden: boolean()
+      }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    )
+  },
   events: {
     /**
      * Emitted when a child device is created, removed, or its parent
-     * assignment changes. Payload carries the fresh list.
+     * assignment changes. Payload carries the fresh list and the
+     * hidden subset.
      */
     onAccessoriesChanged: { data: object({
       deviceId: number(),
-      childDeviceIds: array(number()).readonly()
+      childDeviceIds: array(number()).readonly(),
+      hiddenChildIds: array(number()).readonly()
+    }) },
+    /**
+     * Emitted when the operator toggles a child's UI-visibility.
+     * Subscribers (admin UI accessories panel) re-render off this
+     * signal without re-fetching the full status block.
+     */
+    onChildVisibilityChanged: { data: object({
+      deviceId: number(),
+      childDeviceId: number(),
+      hidden: boolean()
     }) }
   }
 });
@@ -12046,6 +14684,12 @@ const IntercomStatusSchema = object({
   /** Firmware ability cached at first session creation. Null until probed. */
   ability: IntercomAbilitySchema.nullable()
 });
+const TalkAudioCodecSchema = _enum([
+  "opus",
+  "s16le",
+  "g711ulaw",
+  "g711alaw"
+]);
 ({
   deviceTypes: [DeviceType.Camera],
   methods: {
@@ -12090,20 +14734,35 @@ const IntercomStatusSchema = object({
       { kind: "mutation", auth: "admin" }
     ),
     /**
-     * Push a chunk of PCM s16le mono onto the active raw-PCM talk
-     * session. Frames are encoded to the firmware's expected codec
-     * (Reolink: IMA ADPCM @ camera sample rate; Hikvision: G.711 @
-     * 8 kHz) inside the provider — callers must resample upstream to
-     * the rate the camera negotiated (typical: 16 kHz Reolink,
-     * 8 kHz Hikvision). PCM is shipped base64-encoded so the payload
-     * survives JSON serialization across tRPC.
+     * Push one chunk of talk-back audio onto the active talk session.
+     * The cap is codec-agnostic: the caller declares (or omits) the
+     * wire format via `codec`; the provider decides between passthrough
+     * (when the wire codec matches the camera's native talk channel),
+     * transcoding via the `audio-codec` cap, or rejecting the call.
+     *
+     * Callers do NOT need to know the camera's wire format or sample
+     * rate — that information lives entirely inside the provider.
+     *
+     * Sequence numbers MUST be monotonic per talk session; older frames
+     * arriving after newer ones are dropped to avoid smearing the
+     * downstream encoder state (G.711 is stateless but IMA ADPCM's
+     * predictor would corrupt with re-ordering).
      */
-    pushTalkPcm: method(
+    pushTalkAudio: method(
       object({
         deviceId: number(),
-        /** PCM frames as little-endian s16, mono. Base64-encoded so
-         *  the payload survives tRPC JSON serialization. */
-        pcmBase64: string(),
+        /** Audio bytes for ONE frame, base64-encoded so the payload
+         *  survives tRPC JSON serialization. */
+        audioBase64: string(),
+        /** Wire codec of the payload. Omit to let the provider default
+         *  to its native expected format (s16le @ provider-native rate,
+         *  mono). See {@link TalkAudioCodecSchema} for the supported set. */
+        codec: TalkAudioCodecSchema.optional(),
+        /** Sample rate (Hz). REQUIRED for `s16le`; advisory for
+         *  `opus` (encoder clock); ignored for `g711*` (implied 8000). */
+        sampleRate: number().int().positive().optional(),
+        /** Channel count. Default 1. */
+        channels: number().int().positive().optional(),
         /** Sequence number for ordering / dropping out-of-order frames. */
         sequenceNumber: number().int()
       }),
@@ -12197,6 +14856,10 @@ const HardwareEncodersSchema = object({
   defaultH265: HardwareEncoderIdSchema,
   probedAt: number()
 });
+const HardwareDecodeAccelsSchema = object({
+  methods: array(string()).readonly(),
+  probedAt: number()
+});
 const HardwarePlatformSchema = _enum(["darwin", "linux", "win32"]);
 const HardwareArchSchema = _enum(["arm64", "x64"]);
 const GpuInfoSchema = object({
@@ -12265,6 +14928,16 @@ const ResolvedInferenceConfigSchema = object({
       _void(),
       HardwareEncodersSchema,
       { kind: "mutation", auth: "admin" }
+    ),
+    /**
+     * Decode-side hw-accel probe — the `-hwaccel` methods the configured ffmpeg
+     * binary supports (via `ffmpeg -hwaccels`). Cached after first call.
+     */
+    getHardwareDecodeAccels: method(_void(), HardwareDecodeAccelsSchema),
+    refreshHardwareDecodeAccels: method(
+      _void(),
+      HardwareDecodeAccelsSchema,
+      { kind: "mutation", auth: "admin" }
     )
   }
 });
@@ -12954,6 +15627,7 @@ const ClientNetworkStatsSchema = object({
   rttMs: number(),
   jitterMs: number(),
   estimatedBandwidthKbps: number(),
+  packetLossPercent: number().min(0).max(100),
   lastUpdated: number()
 });
 const DeviceNetworkStatsSchema = object({
@@ -12976,7 +15650,8 @@ const DeviceNetworkStatsSchema = object({
         deviceId: number(),
         rttMs: number().min(0).max(6e4),
         jitterMs: number().min(0).max(1e4),
-        estimatedBandwidthKbps: number().min(0).max(1e6)
+        estimatedBandwidthKbps: number().min(0).max(1e6),
+        packetLossPercent: number().min(0).max(100)
       }),
       _void(),
       { kind: "mutation" }
@@ -13201,6 +15876,24 @@ const AvailableIntegrationTypeSchema = object({
   color: string(),
   instanceMode: string(),
   discoveryMode: string(),
+  /**
+   * Which integration-marker cap the addon declared, so the wizard can
+   * branch on CAP — never on addon name. `device-adoption` integrations
+   * (Home Assistant, …) route through the broker step (Approach A);
+   * `device-provider` integrations (Reolink/Frigate/ONVIF) keep the
+   * legacy config → discovery flow.
+   */
+  kind: _enum(["device-adoption", "device-provider"]),
+  /**
+   * For `device-adoption` addons: the broker kind to create/link
+   * (e.g. `home-assistant`), declared in the addon manifest. `null` for
+   * `device-provider` addons, which carry no broker.
+   */
+  brokerKind: string().nullable(),
+  /** True when the integration's source system exposes locations the adoption
+   *  flow can import (e.g. HA areas). Drives the adopt modal's "import
+   *  locations" checkbox. Provider-declared in the addon manifest. */
+  supportsLocationImport: boolean(),
   existingInstances: array(object({ id: string(), name: string() })),
   canAdd: boolean()
 });
@@ -13807,10 +16500,15 @@ var EventCategory = /* @__PURE__ */ ((EventCategory2) => {
   EventCategory2["DeviceSettingsUpdated"] = "device.settings-updated";
   EventCategory2["DeviceBindingsChanged"] = "device.bindings-changed";
   EventCategory2["DeviceMetaChanged"] = "device.meta-changed";
+  EventCategory2["DeviceSourceInfoChanged"] = "device.source-info-changed";
   EventCategory2["DeviceStreamsRegistered"] = "device.streams-registered";
+  EventCategory2["DeviceProvisioned"] = "device.provisioned";
+  EventCategory2["DeviceReady"] = "device.ready";
   EventCategory2["IntegrationEnabled"] = "integration.enabled";
   EventCategory2["IntegrationDisabled"] = "integration.disabled";
   EventCategory2["IntegrationDeleted"] = "integration.deleted";
+  EventCategory2["BrokerStatusChanged"] = "broker.status-changed";
+  EventCategory2["BrokerMessage"] = "broker.message";
   EventCategory2["ProviderStarted"] = "provider.started";
   EventCategory2["ProviderStopped"] = "provider.stopped";
   EventCategory2["ProcessCrashed"] = "process.crashed";
@@ -13844,7 +16542,9 @@ var EventCategory = /* @__PURE__ */ ((EventCategory2) => {
   EventCategory2["StreamParamsChanged"] = "stream-params.changed";
   EventCategory2["DeviceStateChanged"] = "device.state-changed";
   EventCategory2["BatteryOnStatusChanged"] = "battery.onStatusChanged";
+  EventCategory2["BatteryOnWakeStarted"] = "battery.onWakeStarted";
   EventCategory2["DoorbellOnPressed"] = "doorbell.onPressed";
+  EventCategory2["EventEmitted"] = "event-emitter.event";
   EventCategory2["PipelineEngineMetricsSnapshot"] = "pipeline.engine-metrics-snapshot";
   EventCategory2["ClusterTopologySnapshot"] = "cluster.topology-snapshot";
   EventCategory2["MetricsNodeResourcesSnapshot"] = "metrics.node-resources-snapshot";
@@ -13927,6 +16627,27 @@ function emitReadiness(bus, params) {
     }
   ));
 }
+function createDurableState(deps) {
+  const get = async () => {
+    const store = await deps.read();
+    const raw = store[deps.key];
+    if (raw === void 0) return deps.fallback;
+    const parsed = deps.schema.safeParse(raw);
+    if (!parsed.success) {
+      deps.onParseError?.(deps.key, parsed.error);
+      return deps.fallback;
+    }
+    return parsed.data;
+  };
+  const set = async (next) => {
+    const validated = deps.schema.parse(next);
+    await deps.write({ [deps.key]: validated });
+  };
+  const update = async (fn2) => {
+    await set(fn2(await get()));
+  };
+  return { get, set, update };
+}
 class BaseAddon {
   _ctx = null;
   _config;
@@ -14170,12 +16891,18 @@ class BaseAddon {
   // ── Lifecycle event emission ────────────────────────────────────────────
   emitLifecycle(category, data) {
     try {
-      this._ctx?.eventBus.emit({
-        id: `${this._ctx.id}-${Date.now()}`,
+      const ctx = this._ctx;
+      if (!ctx) return;
+      ctx.eventBus.emit({
+        id: `${ctx.id}-${Date.now()}`,
         timestamp: /* @__PURE__ */ new Date(),
-        source: { type: "addon", id: this._ctx.id, nodeId: this._ctx.kernel.localNodeId ?? "hub" },
+        source: { type: "addon", id: ctx.id, nodeId: ctx.kernel.localNodeId ?? "hub" },
         category,
-        data: data ?? {}
+        // Always carry `addonId` in the payload (the lifecycle event
+        // contract declares it) so consumers — e.g. the alerts builder —
+        // can name the addon without reaching into `source`. An explicit
+        // `data.addonId` still wins if a caller provides one.
+        data: { addonId: ctx.id, ...data ?? {} }
       });
     } catch {
     }
@@ -14248,6 +16975,44 @@ class BaseAddon {
     }
     this._config = resolved;
   }
+  /**
+   * Typed durable handle over ONE key of this addon's store. The whole
+   * Zod-validated value round-trips on every read/write — no hand-listed
+   * fields, so a field can never be silently dropped on persist. Reads use
+   * the same retry budget as config resolution; a corrupt/legacy blob logs
+   * a warning and falls back rather than crashing boot.
+   */
+  state(key, schema, fallback) {
+    return createDurableState({
+      key,
+      schema,
+      fallback,
+      read: () => this.readAddonStoreWithRetry(),
+      write: async (patch) => {
+        await this._ctx?.settings?.writeAddonStore(patch);
+      },
+      onParseError: (k, e) => this._ctx?.logger?.warn?.(
+        `durable-state: stored "${k}" failed validation — using fallback`,
+        { meta: { addonId: this._ctx?.id, key: k, error: String(e) } }
+      )
+    });
+  }
+  /** Per-device variant of {@link state}, backed by the per-device store. */
+  deviceState(deviceId, key, schema, fallback) {
+    return createDurableState({
+      key,
+      schema,
+      fallback,
+      read: async () => await this._ctx?.settings?.readDeviceStore(deviceId) ?? {},
+      write: async (patch) => {
+        await this._ctx?.settings?.writeDeviceStore(deviceId, patch);
+      },
+      onParseError: (k, e) => this._ctx?.logger?.warn?.(
+        `durable-state: stored device ${deviceId} "${k}" failed validation — using fallback`,
+        { meta: { addonId: this._ctx?.id, deviceId, key: k, error: String(e) } }
+      )
+    });
+  }
   /**
    * Wrap `ctx.settings.readAddonStore()` with a short retry budget so a
    * transient settings-store outage (mid-restart of sqlite-settings, tsx-watch
@@ -14336,8 +17101,7 @@ exports.hydrateSchema = hydrateSchema;
 exports.number = number;
 exports.object = object;
 exports.pipelineAnalyticsCapability = pipelineAnalyticsCapability;
-exports.recordingEngineCapability = recordingEngineCapability;
 exports.string = string;
 exports.tuple = tuple;
 exports.zoneAnalyticsCapability = zoneAnalyticsCapability;
-//# sourceMappingURL=index-BFbwYH1P.js.map
+//# sourceMappingURL=index-B0RhVv1c.js.map