@camstack/types 0.1.31 → 0.1.33

package/dist/{index-BKifir_y.js → index-DRWlYskM.js}

@@ -1070,9 +1070,9 @@ const DecodedFrameSchema = zod.z.object({
   format: zod.z.enum(["jpeg", "rgb", "bgr", "yuv420", "gray"]),
   timestamp: zod.z.number()
 });
-const BrokerStatusSchema = zod.z.enum(["idle", "connecting", "streaming", "error", "stopped"]);
+const BrokerStatusSchema$1 = zod.z.enum(["idle", "connecting", "streaming", "error", "stopped"]);
 const BrokerStatsSchema = zod.z.object({
-  status: BrokerStatusSchema,
+  status: BrokerStatusSchema$1,
   inputFps: zod.z.number(),
   decodeFps: zod.z.number(),
   encodedSubscribers: zod.z.number(),
@@ -1178,22 +1178,34 @@ const PlaceholderReasonSchema = zod.z.enum([
   "disabled",
   "waking"
 ]);
+const VideoCodecTargetSchema = zod.z.enum(["H264", "H265", "auto"]);
+const AudioCodecTargetSchema = zod.z.enum(["AAC", "Opus", "PCMU", "none"]);
+const MaxResolutionSchema = zod.z.object({
+  width: zod.z.number().int().positive(),
+  height: zod.z.number().int().positive()
+});
+const GetStreamWithCodecInputSchema = zod.z.object({
+  deviceId: zod.z.number().int().nonnegative(),
+  videoCodec: VideoCodecTargetSchema,
+  audioCodec: AudioCodecTargetSchema.optional(),
+  maxResolution: MaxResolutionSchema.optional(),
+  tag: zod.z.string().optional()
+});
+const RtpSourceSchema = zod.z.object({
+  url: zod.z.string(),
+  videoCodec: zod.z.enum(["H264", "H265"]),
+  audioCodec: zod.z.string(),
+  resolution: MaxResolutionSchema,
+  transcoded: zod.z.boolean(),
+  encoder: zod.z.string(),
+  pipelineKey: zod.z.string()
+});
 const streamBrokerCapability = {
   name: "stream-broker",
   scope: "system",
   mode: "singleton",
   exposesDeviceSettings: true,
   methods: {
-    // ── Cam stream lifecycle (publish / retract) ─────────────────────
-    /**
-     * Register a physical camera stream as an input option. Idempotent
-     * for (deviceId, camStreamId) — re-publishing updates metadata
-     * without disturbing profile assignments. The provider calls this
-     * in `onInitialize` for each stream it offers. Third-party addons
-     * may also publish (e.g. an RTMP discovery layer) — camstack has
-     * no notion of "owner" beyond the (deviceId, camStreamId) key.
-     */
-    /* — see STREAM_BROKER_CAP_EVENTS below for cap-event category strings — */
     publishCameraStream: method(
       zod.z.object({
         deviceId: zod.z.number().int().nonnegative(),
@@ -1204,28 +1216,8 @@ const streamBrokerCapability = {
         resolution: CamStreamResolutionSchema.optional(),
         fps: zod.z.number().positive().optional(),
         label: zod.z.string().optional(),
-        /**
-         * Device-level features that the broker / manager / snapshot
-         * orchestrator consult to derive per-stream policy (e.g.
-         * `BatteryOperated` → relax stall watchdog, default pre-buffer
-         * to off, raise snapshot rate-limit). Single source of truth —
-         * publishers no longer set per-stream flags like `allowStall`.
-         */
         deviceFeatures: zod.z.array(zod.z.string()).optional(),
-        /**
-         * Whether this stream participates in the broker's automatic
-         * profile assignment. Defaults `true`. Publishers set `false` for
-         * streams that should be SELECTABLE but not auto-picked — e.g.
-         * Reolink publishes native Baichuan as eligible and RTSP/RTMP
-         * mirrors as ineligible (still assignable manually via
-         * `assignProfile`).
-         */
         autoEligible: zod.z.boolean().optional(),
-        /**
-         * Transport-specific opaque metadata stashed alongside the stream
-         * record. `pull-rfc4571` publishers put the SDP here so the broker
-         * reader can route packets without an in-band DESCRIBE phase.
-         */
         metadata: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
       }),
       zod.z.object({ success: zod.z.literal(true) }),
@@ -1239,12 +1231,6 @@ const streamBrokerCapability = {
       zod.z.object({ success: zod.z.literal(true) }),
       { kind: "mutation", auth: "admin" }
     ),
-    // ── Profile assignment ───────────────────────────────────────────
-    /**
-     * Assign a cam stream to a profile slot. Tears down any existing
-     * broker for that slot and rebuilds against the new source. Persists
-     * the choice — survives reboots.
-     */
     assignProfile: method(
       zod.z.object({
         deviceId: zod.z.number().int().nonnegative(),
@@ -1262,12 +1248,6 @@ const streamBrokerCapability = {
       zod.z.object({ success: zod.z.literal(true) }),
       { kind: "mutation", auth: "admin" }
     ),
-    // ── System-wide views ────────────────────────────────────────────
-    /**
-     * Full dump of every published cam stream across every device.
-     * For dashboards and cross-device tooling; per-device reads go
-     * through the `camera-streams` cap on the device proxy.
-     */
     listAllCameraStreams: method(
       zod.z.void(),
       zod.z.array(CameraStreamSchema).readonly()
@@ -1276,7 +1256,6 @@ const streamBrokerCapability = {
       zod.z.void(),
       zod.z.array(ProfileSlotSchema).readonly()
     ),
-    // ── Broker runtime (stats + client inventory) ────────────────────
     getBrokerStats: method(
       zod.z.object({ brokerId: zod.z.string() }),
       BrokerStatsSchema
@@ -1294,7 +1273,6 @@ const streamBrokerCapability = {
       zod.z.object({ killed: zod.z.boolean() }),
       { kind: "mutation", auth: "admin" }
     ),
-    /** Rebuild the broker for a profile slot in place (re-dial source). */
     restartProfile: method(
       zod.z.object({
         deviceId: zod.z.number().int().nonnegative(),
@@ -1303,24 +1281,28 @@ const streamBrokerCapability = {
       zod.z.object({ success: zod.z.boolean() }),
       { kind: "mutation", auth: "admin" }
     ),
-    // ── Stream URLs ──────────────────────────────────────────────────
     getStreamUrl: method(
       zod.z.object({ streamId: zod.z.string(), format: StreamFormatSchema }),
       zod.z.object({ url: zod.z.string() })
     ),
-    // ── In-process broker access ─────────────────────────────────────
     /**
-     * Return the live IStreamBroker instance for a given brokerId. Same
-     * LOCAL-ONLY contract as before: callers (pipeline-runner) must be
-     * co-located. BrokerId is `${deviceId}/${camStreamId}` — profile
-     * lookup goes through `assignments` if a caller starts from a
-     * profile.
+     * Shared codec-targeted stream API — see Task #184.
+     * Resolution order: source-select → HW transcode → libx264/libx265.
      */
+    getStreamWithCodec: method(
+      GetStreamWithCodecInputSchema,
+      RtpSourceSchema,
+      { kind: "mutation", auth: "admin" }
+    ),
+    releaseStreamWithCodec: method(
+      zod.z.object({ pipelineKey: zod.z.string() }),
+      zod.z.object({ released: zod.z.boolean(), refcount: zod.z.number().int().nonnegative() }),
+      { kind: "mutation", auth: "admin" }
+    ),
     getBroker: method(
       zod.z.object({ brokerId: zod.z.string() }),
       zod.z.custom()
     ),
-    // ── Pre-buffer ───────────────────────────────────────────────────
     setPreBufferDuration: method(
       zod.z.object({ brokerId: zod.z.string(), seconds: zod.z.number().min(0).max(30) }),
       zod.z.void(),
@@ -1330,7 +1312,6 @@ const streamBrokerCapability = {
       zod.z.object({ brokerId: zod.z.string() }),
       zod.z.object({ configuredSec: zod.z.number(), bufferedMs: zod.z.number(), packetCount: zod.z.number() })
     ),
-    // ── RTSP restream ────────────────────────────────────────────────
     getRtspPort: method(zod.z.void(), zod.z.number()),
     getAllRtspEntries: method(
       zod.z.object({ hostname: zod.z.string().optional() }),
@@ -1356,37 +1337,15 @@ const streamBrokerCapability = {
     )
   },
   events: {
-    /**
-     * Emitted when a profile starts consuming a push-kind cam stream.
-     * Push-kind providers (e.g. Reolink Baichuan native streams)
-     * subscribe and begin emitting packets only on demand — battery
-     * cams stay asleep until someone actually watches.
-     */
     onCamStreamDemand: event(zod.z.object({
       deviceId: zod.z.number().int().nonnegative(),
       camStreamId: zod.z.string(),
       profile: CamProfileSchema
     })),
-    /**
-     * Emitted when the last profile consuming a push-kind cam stream
-     * releases it. Providers tear down upstream connections on this
-     * signal.
-     */
     onCamStreamIdle: event(zod.z.object({
       deviceId: zod.z.number().int().nonnegative(),
       camStreamId: zod.z.string()
     })),
-    /**
-     * Emitted by a broker that failed to dial a managed-loopback
-     * source (today: `pull-rfc4571`). The publisher's transport (e.g.
-     * the Reolink lib's RFC 4571 TCP server) idle-tears-down after
-     * ~15s with no clients and may rebind to a different port on
-     * recreate, leaving the URL the broker has cached stale. The owning
-     * camera provider re-runs its publish pipeline on receipt — that
-     * call self-heals the loopback server (`ensureRfc4571Server`) and
-     * `publishCameraStream` propagates the fresh URL back into the
-     * broker's source resolver.
-     */
     onRequestStreamSourceRefresh: event(zod.z.object({
       deviceId: zod.z.number().int().nonnegative(),
       camStreamId: zod.z.string(),
@@ -3660,14 +3619,16 @@ const logDestinationCapability = {
     )
   }
 };
+const StaticDirOutputSchema = zod.z.object({ staticDir: zod.z.string() });
+const VersionOutputSchema = zod.z.object({ version: zod.z.string() });
 const adminUiCapability = {
   name: "admin-ui",
   scope: "system",
   mode: "singleton",
   internal: true,
   methods: {
-    getStaticDir: method(zod.z.void(), zod.z.string()),
-    getVersion: method(zod.z.void(), zod.z.string())
+    getStaticDir: method(zod.z.void(), StaticDirOutputSchema),
+    getVersion: method(zod.z.void(), VersionOutputSchema)
   }
 };
 const SsoBridgeClaimsSchema = zod.z.object({
@@ -3676,7 +3637,16 @@ const SsoBridgeClaimsSchema = zod.z.object({
   isAdmin: zod.z.boolean(),
   provider: zod.z.string(),
   email: zod.z.string().optional(),
-  displayName: zod.z.string().optional()
+  displayName: zod.z.string().optional(),
+  /**
+   * Public HTTPS URL of the hub that issued this token. Used by
+   * cloud-mode OAuth proxies (Alexa Smart Home Lambda, future Google
+   * Home Lambda) to route a request back to the originating hub
+   * without holding routing state of their own. The Lambda decodes the
+   * JWT WITHOUT verifying the signature — the hub re-verifies on every
+   * inbound call so trust still rests with the signing hub.
+   */
+  hubUrl: zod.z.string().optional()
 });
 const ssoBridgeCapability = {
   name: "sso-bridge",
@@ -3758,7 +3728,7 @@ const userPasskeysCapability = {
     )
   }
 };
-const EmailAddressSchema = zod.z.string().email();
+const EmailAddressSchema = zod.z.email();
 const SendEmailInputSchema = zod.z.object({
   to: zod.z.union([EmailAddressSchema, zod.z.array(EmailAddressSchema).min(1)]),
   cc: zod.z.array(EmailAddressSchema).optional(),
@@ -3796,6 +3766,7 @@ const smtpProviderCapability = {
   scope: "system",
   mode: "collection",
   internal: true,
+  providerKind: "email",
   methods: {
     sendEmail: method(
       SendEmailInputSchema,
@@ -3816,204 +3787,125 @@ const smtpProviderCapability = {
     )
   }
 };
-const QosSchema = zod.z.union([zod.z.literal(0), zod.z.literal(1), zod.z.literal(2)]);
-const PublishInputSchema = zod.z.object({
-  topic: zod.z.string(),
-  /** UTF-8 payload. Binary payloads must be base64-encoded by the caller. */
-  payload: zod.z.string(),
-  qos: QosSchema.default(0),
-  retain: zod.z.boolean().default(false)
-});
-const SubscribeInputSchema = zod.z.object({
-  /** MQTT topic filter (supports `+` single-level and `#` multi-level wildcards). */
-  topic: zod.z.string(),
-  qos: QosSchema.default(0),
+const BrokerKindSchema = zod.z.enum(["external", "embedded"]);
+const BrokerStatusSchema = zod.z.enum([
+  "connected",
+  "disconnected",
+  "auth-failed",
+  "unreachable",
+  "tls-error"
+]);
+const BrokerInfoSchema = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string(),
+  url: zod.z.string(),
+  kind: BrokerKindSchema,
+  status: BrokerStatusSchema,
+  latencyMs: zod.z.number().nullable(),
+  error: zod.z.string().optional(),
+  /** Embedded brokers only: number of MQTT clients currently connected. */
+  connectedClients: zod.z.number().int().nonnegative().optional(),
+  /** Epoch ms of the last live probe (external) or aedes snapshot (embedded). */
+  lastCheckedAt: zod.z.number().optional()
+});
+const BrokerConnectionDetailsSchema = zod.z.object({
+  url: zod.z.string(),
+  username: zod.z.string().optional(),
+  password: zod.z.string().optional(),
   /**
-   * Caller-supplied owner tag. Useful for debugging + the
-   * `listSubscriptions` admin view ("which consumer owns this?").
-   * When omitted, the addon synthesizes one from the caller's addon id.
+   * Suggested prefix for `clientId`. Each consumer should suffix this
+   * with its own discriminator (addon id, instance id) so reconnects
+   * don't kick each other off (MQTT spec: clientId must be unique per
+   * broker).
    */
-  owner: zod.z.string().optional()
+  clientIdPrefix: zod.z.string().optional()
 });
-const SubscribeResultSchema = zod.z.object({
-  success: zod.z.literal(true),
-  /** Server-generated subscription id. Pass to `unsubscribe` to release. */
-  subscriptionId: zod.z.string()
+const AddBrokerInputSchema = zod.z.object({
+  name: zod.z.string().min(1),
+  url: zod.z.string().regex(/^(mqtt|mqtts|ws|wss):\/\//, "URL must start with mqtt(s):// or ws(s)://"),
+  username: zod.z.string().optional(),
+  password: zod.z.string().optional(),
+  clientIdPrefix: zod.z.string().optional()
 });
-const UnsubscribeInputSchema = zod.z.object({
-  /** Subscription id from `subscribe`. */
-  subscriptionId: zod.z.string()
+const AddBrokerResultSchema = zod.z.object({
+  id: zod.z.string()
 });
-const MqttStatusSchema = zod.z.object({
-  /** True iff the addon has an active connection to the broker. */
-  connected: zod.z.boolean(),
-  /** Operator-visible host string (e.g. `mqtt://broker.example:1883`). */
-  brokerUrl: zod.z.string(),
-  /** Active subscription count (per-owner, NOT broker-side topic count). */
-  subscriptionCount: zod.z.number().int(),
-  /** Last error reported by the broker. */
-  error: zod.z.string().optional(),
-  /** Last successful connection timestamp (unix ms). */
-  connectedAt: zod.z.number().optional()
-});
-const SubscriptionInfoSchema = zod.z.object({
-  subscriptionId: zod.z.string(),
-  topic: zod.z.string(),
-  qos: QosSchema,
-  owner: zod.z.string(),
-  /** When this individual subscription was created. */
-  createdAt: zod.z.number()
+const IdInputSchema = zod.z.object({ id: zod.z.string() });
+const TestResultSchema = zod.z.discriminatedUnion("ok", [
+  zod.z.object({ ok: zod.z.literal(true), latencyMs: zod.z.number() }),
+  zod.z.object({ ok: zod.z.literal(false), error: zod.z.string() })
+]);
+const StartEmbeddedInputSchema = zod.z.object({
+  port: zod.z.number().int().min(1).max(65535).default(1883),
+  /** Allow anonymous connect (no username/password). Default: false. */
+  allowAnonymous: zod.z.boolean().default(false),
+  /** Optional shared username/password for clients. */
+  username: zod.z.string().optional(),
+  password: zod.z.string().optional()
+});
+const StartEmbeddedResultSchema = zod.z.object({
+  id: zod.z.string(),
+  url: zod.z.string()
 });
-const mqttProviderCapability = {
-  name: "mqtt-provider",
+const StatusSchema = zod.z.object({
+  brokerCount: zod.z.number(),
+  embeddedRunning: zod.z.boolean()
+});
+const mqttBrokerCapability = {
+  name: "mqtt-broker",
   scope: "system",
   mode: "collection",
-  internal: true,
+  providerKind: "broker",
+  status: { schema: StatusSchema, kind: "poll" },
   methods: {
-    /** Publish a message. Lazy-opens the connection if not yet active. */
-    publish: method(
-      PublishInputSchema,
-      zod.z.object({ success: zod.z.literal(true) }),
-      { kind: "mutation", auth: "admin", access: "create" }
-    ),
-    /**
-     * Subscribe to a topic. Returns a `subscriptionId` to pass to
-     * `unsubscribe`. The addon refcounts broker subscriptions —
-     * multiple consumers on the same topic share one upstream sub.
-     * Messages arrive on `mqtt.message` events with `subscriptionIds[]`
-     * listing which subscriptions matched.
-     */
-    subscribe: method(
-      SubscribeInputSchema,
-      SubscribeResultSchema,
-      { kind: "mutation", auth: "admin", access: "create" }
-    ),
-    /** Release a specific subscription. Tears down the broker sub
-     *  only when the last owner releases. Idempotent. */
-    unsubscribe: method(
-      UnsubscribeInputSchema,
-      zod.z.object({ success: zod.z.literal(true) }),
-      { kind: "mutation", auth: "admin", access: "delete" }
-    ),
-    /** List active per-owner subscriptions on this provider. */
-    listSubscriptions: method(
-      zod.z.void(),
-      zod.z.array(SubscriptionInfoSchema),
-      { auth: "admin" }
-    ),
-    getStatus: method(
-      zod.z.void(),
-      MqttStatusSchema,
-      { auth: "admin" }
-    )
+    listBrokers: method(zod.z.void(), zod.z.array(BrokerInfoSchema)),
+    getBrokerConfig: method(IdInputSchema, BrokerConnectionDetailsSchema),
+    addBroker: method(AddBrokerInputSchema, AddBrokerResultSchema, { kind: "mutation" }),
+    removeBroker: method(IdInputSchema, zod.z.void(), { kind: "mutation" }),
+    testConnection: method(IdInputSchema, TestResultSchema, { kind: "mutation" }),
+    startEmbeddedBroker: method(StartEmbeddedInputSchema, StartEmbeddedResultSchema, { kind: "mutation" }),
+    stopEmbeddedBroker: method(IdInputSchema, zod.z.void(), { kind: "mutation" }),
+    getStatus: method(zod.z.void(), StatusSchema)
   }
 };
-const HaServiceCallSchema = zod.z.object({
-  /** HA domain (e.g. `light`, `switch`, `notify`). */
-  domain: zod.z.string(),
-  /** HA service (e.g. `turn_on`, `toggle`). */
-  service: zod.z.string(),
-  /** Service-specific data payload (e.g. `{entity_id: 'light.kitchen', brightness: 200}`). */
-  serviceData: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
-  /** Optional target spec (entity_id / device_id / area_id). */
-  target: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
-});
-const HaStateSchema = zod.z.object({
-  entity_id: zod.z.string(),
-  state: zod.z.string(),
-  attributes: zod.z.record(zod.z.string(), zod.z.unknown()).default({}),
-  last_changed: zod.z.string().optional(),
-  last_updated: zod.z.string().optional()
+const LinkStateSchema = zod.z.enum(["unlinked", "linked", "error"]);
+const DeviceExportStatusSchema = zod.z.object({
+  linkState: LinkStateSchema,
+  exposedDeviceCount: zod.z.number(),
+  error: zod.z.string().optional()
 });
-const HaStatusSchema = zod.z.object({
-  connected: zod.z.boolean(),
-  host: zod.z.string(),
-  /** Active per-owner subscription count. */
-  subscriptionCount: zod.z.number().int(),
-  /** Last error reported by the WebSocket. */
-  error: zod.z.string().optional(),
-  /** HA version reported during the auth handshake, when reachable. */
-  haVersion: zod.z.string().optional(),
-  connectedAt: zod.z.number().optional()
+const DeviceKindSchema = zod.z.string();
+const ExposedDeviceSchema = zod.z.object({
+  deviceId: zod.z.string(),
+  exposedAs: zod.z.string().optional(),
+  capabilities: zod.z.array(zod.z.string()).optional()
 });
-const HaSubscribeInputSchema = zod.z.object({
-  /**
-   * Specific HA event type to subscribe to (`state_changed`,
-   * `service_called`, etc.). Empty string = all events (firehose —
-   * only for debugging).
-   */
-  eventType: zod.z.string().optional(),
-  /** Caller-supplied tag for listSubscriptions debugging. */
-  owner: zod.z.string().optional()
-});
-const HaSubscribeResultSchema = zod.z.object({
-  success: zod.z.literal(true),
-  subscriptionId: zod.z.string()
-});
-const HaUnsubscribeInputSchema = zod.z.object({
-  subscriptionId: zod.z.string()
-});
-const HaSubscriptionInfoSchema = zod.z.object({
-  subscriptionId: zod.z.string(),
-  /** Empty string when subscribed to ALL events. */
-  eventType: zod.z.string(),
-  owner: zod.z.string(),
-  createdAt: zod.z.number()
+const ExposeInputSchema = zod.z.object({
+  deviceId: zod.z.string(),
+  capabilities: zod.z.array(zod.z.string()).optional()
 });
-const homeAssistantCapability = {
-  name: "home-assistant",
+const UnexposeInputSchema = zod.z.object({ deviceId: zod.z.string() });
+const deviceExportCapability = {
+  name: "device-export",
   scope: "system",
   mode: "collection",
-  internal: true,
+  providerKind: "device-export",
+  status: { schema: DeviceExportStatusSchema, kind: "poll" },
+  /**
+   * Each export provider contributes its own per-device "Export" panel
+   * (enabled toggle, preferred stream, addon-specific knobs like the
+   * HA-MQTT discovery prefix). The three framework methods
+   * `getDeviceSettingsContribution` / `getDeviceLiveContribution` /
+   * `applyDeviceSettingsPatch` are auto-injected on the provider
+   * interface and routed to the device-details aggregator.
+   */
+  exposesDeviceSettings: true,
   methods: {
-    /**
-     * Subscribe to HA events. Returns a `subscriptionId` to pass to
-     * `unsubscribeEvents`. The addon refcounts upstream subscriptions
-     * so multiple consumers share one HA-side event stream.
-     * Events arrive on the kernel bus under `home-assistant.event`
-     * with `subscriptionIds[]` listing which subs matched.
-     */
-    subscribeEvents: method(
-      HaSubscribeInputSchema,
-      HaSubscribeResultSchema,
-      { kind: "mutation", auth: "admin", access: "create" }
-    ),
-    /** Release a specific subscription. Tears down the upstream sub
-     *  only when the last owner releases. Idempotent. */
-    unsubscribeEvents: method(
-      HaUnsubscribeInputSchema,
-      zod.z.object({ success: zod.z.literal(true) }),
-      { kind: "mutation", auth: "admin", access: "delete" }
-    ),
-    /**
-     * Call an HA service (turn light on, run a script, etc.). Returns
-     * the HA response object — usually `{context, response: ...}`.
-     */
-    callService: method(
-      HaServiceCallSchema,
-      zod.z.object({ result: zod.z.unknown() }),
-      { kind: "mutation", auth: "admin", access: "create" }
-    ),
-    /** Fetch all entity states. Cheap snapshot — HA returns the full
-     *  state registry on every call. */
-    getStates: method(
-      zod.z.void(),
-      zod.z.array(HaStateSchema).readonly(),
-      { auth: "admin" }
-    ),
-    /** Fetch a single entity's current state. `null` when not found. */
-    getState: method(
-      zod.z.object({ entityId: zod.z.string() }),
-      HaStateSchema.nullable(),
-      { auth: "admin" }
-    ),
-    /** List active per-owner subscriptions. */
-    listSubscriptions: method(
-      zod.z.void(),
-      zod.z.array(HaSubscriptionInfoSchema).readonly(),
-      { auth: "admin" }
-    ),
-    getStatus: method(zod.z.void(), HaStatusSchema, { auth: "admin" })
+    getStatus: method(zod.z.void(), DeviceExportStatusSchema),
+    listSupportedDeviceKinds: method(zod.z.void(), zod.z.array(DeviceKindSchema)),
+    listExposedDevices: method(zod.z.void(), zod.z.array(ExposedDeviceSchema)),
+    exposeDevice: method(ExposeInputSchema, zod.z.void(), { kind: "mutation" }),
+    unexposeDevice: method(UnexposeInputSchema, zod.z.void(), { kind: "mutation" })
   }
 };
 const AddonPageDeclarationSchema$1 = zod.z.object({
@@ -4415,6 +4307,29 @@ const webrtcSessionCapability = {
       zod.z.object({ sessionId: zod.z.string(), sdpOffer: zod.z.string() }),
       { kind: "mutation" }
     ),
+    /**
+     * Accept a CLIENT-generated SDP offer and return the server's
+     * SDP answer. Mirrors the WHEP / Alexa
+     * `Alexa.RTCSessionController.InitiateSessionWithOffer` direction
+     * (client offers, server answers) — the dual of `createSession`,
+     * which has the server offer first.
+     *
+     * `target` defaults to the device's adaptive selection when
+     * omitted; an optional `sessionId` lets the client provide its
+     * own correlation id (Alexa supplies one in the directive
+     * payload). The returned `sessionId` is whatever the server uses
+     * to track the session and accepts via `closeSession`.
+     */
+    handleOffer: method(
+      zod.z.object({
+        deviceId: zod.z.number().int().nonnegative(),
+        target: WebrtcStreamTargetSchema.optional(),
+        sdpOffer: zod.z.string(),
+        sessionId: zod.z.string().optional()
+      }),
+      zod.z.object({ sessionId: zod.z.string(), sdpAnswer: zod.z.string() }),
+      { kind: "mutation" }
+    ),
     handleAnswer: method(
       zod.z.object({
         deviceId: zod.z.number().int().nonnegative(),
@@ -5054,12 +4969,12 @@ const audioCodecCapability = {
 };
 const EmbeddingResultSchema = zod.z.object({
   embedding: zod.z.array(zod.z.number()),
-  dimensions: zod.z.number()
+  inferenceMs: zod.z.number()
 });
 const EmbeddingInfoSchema = zod.z.object({
   modelId: zod.z.string(),
-  dimensions: zod.z.number(),
-  inputSize: zod.z.number()
+  embeddingDim: zod.z.number(),
+  ready: zod.z.boolean()
 });
 const embeddingEncoderCapability = {
   name: "embedding-encoder",
@@ -5794,16 +5709,36 @@ const NetworkAccessStatusSchema = zod.z.object({
   endpoint: NetworkEndpointSchema.nullable(),
   error: zod.z.string().optional()
 });
+const NetworkEndpointEntrySchema = NetworkEndpointSchema.extend({
+  /**
+   * Stable id within the provider — typically `<mode>-<sourcePort>` so
+   * the orchestrator can dedupe across `listEndpoints` polls.
+   */
+  id: zod.z.string(),
+  /** Operator-facing label (mirrors `MeshEndpoint.label`). */
+  label: zod.z.string(),
+  /** Optional provider-specific mode tag, used for icon/colour in admin UI. */
+  mode: zod.z.string().optional(),
+  /** Originating local port the ingress fronts (informational). */
+  sourcePort: zod.z.number().optional()
+});
 const networkAccessCapability = {
   name: "network-access",
   scope: "system",
   mode: "collection",
   internal: true,
+  providerKind: "ingress",
   methods: {
     start: method(zod.z.void(), NetworkEndpointSchema, { kind: "mutation" }),
     stop: method(zod.z.void(), zod.z.void(), { kind: "mutation" }),
     getEndpoint: method(zod.z.void(), NetworkEndpointSchema.nullable()),
-    getStatus: method(zod.z.void(), NetworkAccessStatusSchema)
+    getStatus: method(zod.z.void(), NetworkAccessStatusSchema),
+    /**
+     * Enumerate every active ingress entry. Default implementation (when
+     * the provider omits this method) is derived from `getEndpoint()` —
+     * see the remote-access orchestrator for the fallback path.
+     */
+    listEndpoints: method(zod.z.void(), zod.z.array(NetworkEndpointEntrySchema).readonly())
   }
 };
 const RemoteAccessEndpointSchema = zod.z.object({
@@ -6007,20 +5942,59 @@ const notificationOutputCapability = {
     )
   }
 };
+const NotificationRuleConditionsSchema = zod.z.object({
+  deviceIds: zod.z.array(zod.z.number()).readonly().optional(),
+  classNames: zod.z.array(zod.z.string()).readonly().optional(),
+  zoneIds: zod.z.array(zod.z.string()).readonly().optional(),
+  minConfidence: zod.z.number().optional(),
+  source: zod.z.enum(["pipeline", "onboard", "any"]).optional(),
+  schedule: zod.z.object({
+    days: zod.z.array(zod.z.number()).readonly(),
+    startHour: zod.z.number(),
+    endHour: zod.z.number()
+  }).optional(),
+  cooldownSeconds: zod.z.number().optional(),
+  minDwellSeconds: zod.z.number().optional()
+});
+const NotificationRuleTemplateSchema = zod.z.object({
+  title: zod.z.string(),
+  body: zod.z.string(),
+  imageMode: zod.z.enum(["crop", "annotated", "full", "none"])
+});
 const NotificationRuleSchema = zod.z.object({
   id: zod.z.string(),
   name: zod.z.string(),
   enabled: zod.z.boolean(),
-  conditions: zod.z.record(zod.z.string(), zod.z.unknown()),
-  actions: zod.z.array(zod.z.record(zod.z.string(), zod.z.unknown()))
+  eventTypes: zod.z.array(zod.z.string()).readonly(),
+  conditions: NotificationRuleConditionsSchema,
+  outputs: zod.z.array(zod.z.string()).readonly(),
+  template: NotificationRuleTemplateSchema.optional(),
+  priority: zod.z.enum(["low", "normal", "high", "critical"])
+});
+const NotificationTestResultSchema = zod.z.object({
+  ruleId: zod.z.string(),
+  eventId: zod.z.string(),
+  timestamp: zod.z.number(),
+  wouldFire: zod.z.boolean(),
+  reason: zod.z.string().optional()
 });
 const NotificationHistoryEntrySchema = zod.z.object({
   id: zod.z.string(),
   ruleId: zod.z.string(),
+  ruleName: zod.z.string(),
+  eventId: zod.z.string(),
   timestamp: zod.z.number(),
-  deviceId: zod.z.number().optional(),
+  outputs: zod.z.array(zod.z.string()).readonly(),
   success: zod.z.boolean(),
-  error: zod.z.string().optional()
+  error: zod.z.string().optional(),
+  deviceId: zod.z.number().optional()
+});
+const NotificationHistoryFilterSchema = zod.z.object({
+  ruleId: zod.z.string().optional(),
+  deviceId: zod.z.number().optional(),
+  from: zod.z.number().optional(),
+  to: zod.z.number().optional(),
+  limit: zod.z.number().optional()
 });
 const advancedNotifierCapability = {
   name: "advanced-notifier",
@@ -6028,17 +6002,28 @@ const advancedNotifierCapability = {
   mode: "singleton",
   internal: true,
   methods: {
-    getRules: method(zod.z.void(), zod.z.array(NotificationRuleSchema).readonly()),
-    upsertRule: method(NotificationRuleSchema, zod.z.void(), { kind: "mutation" }),
-    deleteRule: method(zod.z.object({ ruleId: zod.z.string() }), zod.z.void(), { kind: "mutation" }),
+    getRules: method(
+      zod.z.void(),
+      zod.z.object({ rules: zod.z.array(NotificationRuleSchema).readonly() })
+    ),
+    upsertRule: method(
+      zod.z.object({ rule: NotificationRuleSchema }),
+      zod.z.object({ success: zod.z.literal(true) }),
+      { kind: "mutation" }
+    ),
+    deleteRule: method(
+      zod.z.object({ ruleId: zod.z.string() }),
+      zod.z.object({ success: zod.z.literal(true) }),
+      { kind: "mutation" }
+    ),
     testRule: method(
       zod.z.object({ ruleId: zod.z.string(), lookbackMinutes: zod.z.number() }),
-      zod.z.array(zod.z.record(zod.z.string(), zod.z.unknown())),
+      zod.z.object({ results: zod.z.array(NotificationTestResultSchema).readonly() }),
       { kind: "mutation" }
     ),
     getHistory: method(
-      zod.z.object({ ruleId: zod.z.string().optional(), limit: zod.z.number().optional() }),
-      zod.z.array(NotificationHistoryEntrySchema)
+      zod.z.object({ filter: NotificationHistoryFilterSchema.optional() }),
+      zod.z.object({ entries: zod.z.array(NotificationHistoryEntrySchema).readonly() })
     )
   }
 };
@@ -7060,6 +7045,47 @@ const intercomCapability = {
       zod.z.object({ deviceId: zod.z.number(), sessionId: zod.z.string() }),
       zod.z.void(),
       { kind: "mutation", auth: "admin" }
+    ),
+    /**
+     * Open a raw-PCM talk session (no WebRTC SDP plumbing). Used by
+     * non-WebRTC consumers (HomeKit export, Alexa raw audio, test
+     * harnesses) that already have decoded PCM frames and just need a
+     * direct path onto the camera's talk channel. Mutually exclusive
+     * with `startSession` (an active WebRTC session must be stopped
+     * before a raw-PCM session can be opened on the same device, and
+     * vice versa).
+     */
+    startTalkSession: method(
+      zod.z.object({ deviceId: zod.z.number() }),
+      zod.z.object({ sessionId: zod.z.string() }),
+      { 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.
+     */
+    pushTalkPcm: method(
+      zod.z.object({
+        deviceId: zod.z.number(),
+        /** PCM frames as little-endian s16, mono. Base64-encoded so
+         *  the payload survives tRPC JSON serialization. */
+        pcmBase64: zod.z.string(),
+        /** Sequence number for ordering / dropping out-of-order frames. */
+        sequenceNumber: zod.z.number().int()
+      }),
+      zod.z.object({ accepted: zod.z.boolean() }),
+      { kind: "mutation", auth: "admin" }
+    ),
+    /** Close the raw-PCM talk session. Idempotent. */
+    endTalkSession: method(
+      zod.z.object({ deviceId: zod.z.number() }),
+      zod.z.void(),
+      { kind: "mutation", auth: "admin" }
     )
   },
   events: {
@@ -7135,6 +7161,33 @@ const HwAccelBackendInputSchema = zod.z.enum([
 const HwAccelResolutionSchema = zod.z.object({
   preferred: zod.z.array(zod.z.string()).readonly()
 });
+const HardwareEncoderIdSchema = zod.z.enum([
+  "h264_videotoolbox",
+  "hevc_videotoolbox",
+  "h264_vaapi",
+  "hevc_vaapi",
+  "h264_nvenc",
+  "hevc_nvenc",
+  "h264_qsv",
+  "hevc_qsv",
+  "h264_amf",
+  "hevc_amf",
+  "libx264",
+  "libx265"
+]);
+const HardwareEncoderProbeSchema = zod.z.object({
+  encoder: HardwareEncoderIdSchema,
+  codec: zod.z.enum(["H264", "H265"]),
+  family: zod.z.enum(["videotoolbox", "vaapi", "nvenc", "qsv", "amf", "software"]),
+  available: zod.z.boolean(),
+  reason: zod.z.string().optional()
+});
+const HardwareEncodersSchema = zod.z.object({
+  encoders: zod.z.array(HardwareEncoderProbeSchema).readonly(),
+  defaultH264: HardwareEncoderIdSchema,
+  defaultH265: HardwareEncoderIdSchema,
+  probedAt: zod.z.number()
+});
 const HardwarePlatformSchema = zod.z.enum(["darwin", "linux", "win32"]);
 const HardwareArchSchema = zod.z.enum(["arm64", "x64"]);
 const GpuInfoSchema = zod.z.object({
@@ -7188,41 +7241,24 @@ const platformProbeCapability = {
   scope: "system",
   mode: "singleton",
   methods: {
-    /** Return cached hardware + scored backends for this node. */
-    getCapabilities: method(
-      zod.z.void(),
-      PlatformCapabilitiesSchema
-    ),
-    /** Convenience getter — hardware only. */
-    getHardware: method(
-      zod.z.void(),
-      HardwareInfoSchema
-    ),
-    /**
-     * Resolve the best (model, runtime, backend, format) for a given list
-     * of requirements, using this node's scored backends as the candidate
-     * pool. Always returns a config — falls back to CPU when no preferred
-     * backend matches.
-     */
+    getCapabilities: method(zod.z.void(), PlatformCapabilitiesSchema),
+    getHardware: method(zod.z.void(), HardwareInfoSchema),
     resolveInferenceConfig: method(
-      zod.z.object({
-        requirements: zod.z.array(ModelRequirementSchema).readonly()
-      }),
+      zod.z.object({ requirements: zod.z.array(ModelRequirementSchema).readonly() }),
       ResolvedInferenceConfigSchema
     ),
-    /**
-     * Resolve the ordered HW acceleration backend list for this node.
-     * Pass `prefer` to hint a specific backend; pass `null` or omit
-     * for auto-detection. Replaces the legacy `$hwaccel.resolve`
-     * Moleculer action — cap routing handles per-node dispatch via
-     * `nodeId`.
-     */
     resolveHwAccel: method(
-      zod.z.object({
-        prefer: HwAccelBackendInputSchema,
-        nodeId: zod.z.string().optional()
-      }),
+      zod.z.object({ prefer: HwAccelBackendInputSchema, nodeId: zod.z.string().optional() }),
       HwAccelResolutionSchema
+    ),
+    /**
+     * Hardware-encoder probe — see Task #185. Cached after first call.
+     */
+    getHardwareEncoders: method(zod.z.void(), HardwareEncodersSchema),
+    refreshHardwareEncoders: method(
+      zod.z.void(),
+      HardwareEncodersSchema,
+      { kind: "mutation", auth: "admin" }
     )
   }
 };
@@ -7434,7 +7470,9 @@ const MeshPeerSchema = zod.z.object({
   id: zod.z.string(),
   /** Hostname / device name as shown in the mesh dashboard. */
   hostname: zod.z.string(),
-  /** Mesh IP(s). Multiple when the peer is dual-stacked. */
+  /** MagicDNS / mesh DNS name (e.g. `peer-foo.tail-abc.ts.net`). Empty when the provider doesn't support DNS or peer-side resolution is disabled. */
+  magicDns: zod.z.string(),
+  /** Mesh IPv4 / IPv6 addresses combined. Multiple when dual-stacked. */
   addresses: zod.z.array(zod.z.string()).readonly(),
   /** Operating system reported by the peer (informational). */
   os: zod.z.string().optional(),
@@ -7443,7 +7481,32 @@ const MeshPeerSchema = zod.z.object({
   /** Last-seen timestamp (epoch ms). 0 when never seen. */
   lastSeenMs: zod.z.number(),
   /** True for the row representing the current host. */
-  isSelf: zod.z.boolean()
+  isSelf: zod.z.boolean(),
+  /**
+   * Connection mode to this peer:
+   *   - `direct`: NAT-traversed P2P (UDP punched)
+   *   - `relay`: traffic relayed through provider edge (Tailscale DERP)
+   *   - `idle`: peer reachable but no recent traffic / handshake
+   */
+  connection: zod.z.enum(["direct", "relay", "idle"]),
+  /** DERP region / relay node identifier when `connection: relay`. Null otherwise. */
+  relay: zod.z.string().nullable(),
+  /** Last successful handshake timestamp (epoch ms). 0 when never. */
+  lastHandshakeMs: zod.z.number(),
+  /** Bytes received from this peer since the daemon started. */
+  rxBytes: zod.z.number(),
+  /** Bytes transmitted to this peer since the daemon started. */
+  txBytes: zod.z.number(),
+  /** ACL tags this peer carries (e.g. `["tag:server"]`). Empty when human-owned. */
+  tags: zod.z.array(zod.z.string()).readonly(),
+  /** True when the peer advertises itself as an exit-node candidate. */
+  exitNodeOption: zod.z.boolean(),
+  /** Subnet routes the peer advertises (e.g. `["192.168.1.0/24"]`). */
+  advertisedRoutes: zod.z.array(zod.z.string()).readonly(),
+  /** Owner account login (e.g. `foo@example.com`). Null for tagged peers. */
+  userLogin: zod.z.string().nullable(),
+  /** Pre-auth key / machine-key expiry (epoch ms). Null when keys don't expire. */
+  keyExpiry: zod.z.number().nullable()
 });
 const MeshStatusSchema = zod.z.object({
   /** True when the host is joined and the daemon reports healthy. */
@@ -7457,27 +7520,44 @@ const MeshStatusSchema = zod.z.object({
   /** Every endpoint this provider exposes for the current host. */
   endpoints: zod.z.array(MeshEndpointSchema$1).readonly(),
   /** Last error from the daemon, when not joined. */
-  error: zod.z.string().optional()
-});
-const PublicIngressConfigSchema = zod.z.object({
-  /** Whether the provider should expose CamStack via its public
-   *  ingress (Tailscale Funnel, etc.). */
-  enabled: zod.z.boolean(),
-  /** Local port to forward. Auto-detected from the hub HTTP port
-   *  when omitted. */
-  port: zod.z.number().int().min(1).max(65535).optional()
-});
-const MeshIngressConfigSchema = zod.z.object({
-  /** Whether the provider should expose CamStack inside the mesh
-   *  via HTTPS (Tailscale Serve, etc.) instead of just raw IP. */
-  enabled: zod.z.boolean(),
-  /** Local port to forward. Auto-detected when omitted. */
-  port: zod.z.number().int().min(1).max(65535).optional()
+  error: zod.z.string().optional(),
+  // ── Account / tenant identity (generic across providers) ────────
+  /**
+   * Tenant / tailnet / network display name (Tailscale = tailnet
+   * domain, Headscale = namespace, ZeroTier = network name). Empty
+   * pre-join. Per-provider semantics, common slot.
+   */
+  tenantName: zod.z.string(),
+  /**
+   * Mesh DNS suffix when the provider exposes peer-resolvable DNS
+   * (Tailscale MagicDNS, Headscale MagicDNS, …). Empty when the
+   * provider doesn't ship DNS (e.g. ZeroTier).
+   */
+  magicDnsSuffix: zod.z.string(),
+  /**
+   * Authenticated user / account login bound to this host. Null when
+   * the provider authenticates with a long-lived network token rather
+   * than a user account (e.g. ZeroTier API token).
+   */
+  userLogin: zod.z.string().nullable(),
+  /**
+   * Provider control-plane URL (Tailscale SaaS `https://login.tailscale.com`,
+   * self-hosted Headscale, ZeroTier Central, …). Empty when not
+   * applicable (rare).
+   */
+  controlPlaneUrl: zod.z.string(),
+  /**
+   * Machine-key / node-key expiry (epoch ms). Null when the provider
+   * doesn't rotate keys for the bound host. Operator-facing surface
+   * for "your access expires on …" banners.
+   */
+  keyExpiry: zod.z.number().nullable()
 });
 const meshNetworkCapability = {
   name: "mesh-network",
   scope: "system",
   mode: "collection",
+  providerKind: "mesh",
   methods: {
     /** Return the current join state + endpoints + peer count. Cheap
      *  poll-target — admin UI hits this every few seconds. */
@@ -7499,35 +7579,54 @@ const meshNetworkCapability = {
       zod.z.object({ joined: zod.z.literal(true) }),
       { kind: "mutation" }
     ),
+    /**
+     * Start an interactive browser-redirect login flow.
+     *
+     * The provider spawns its daemon's join command without a pre-auth
+     * key, captures the verification URL the daemon prints, and returns
+     * it. The admin UI opens the URL in a new tab; the user completes
+     * authentication in the provider's web console and the background
+     * process self-terminates. The caller then polls `getStatus()` until
+     * `joined: true`.
+     *
+     * Mirrors the `tailscale up` (no `--auth-key`) flow.
+     */
+    startLogin: method(
+      zod.z.object({
+        /** Optional hostname override the host should advertise once joined. */
+        hostname: zod.z.string().optional()
+      }),
+      zod.z.object({
+        /** Authentication URL the operator should open in a browser. */
+        loginUrl: zod.z.string()
+      }),
+      { kind: "mutation" }
+    ),
     /** Leave the mesh. After this the meshIp/magicDnsHostname/etc.
-     *  vanish until the next `join`. */
+     *  vanish until the next `join`. The bound account stays — a
+     *  subsequent `join` reuses it without prompting for a new login. */
     leave: method(
       zod.z.void(),
       zod.z.object({ left: zod.z.literal(true) }),
       { kind: "mutation" }
     ),
-    /** Enumerate every peer the daemon currently knows about. */
-    listPeers: method(zod.z.void(), zod.z.object({
-      peers: zod.z.array(MeshPeerSchema).readonly()
-    })),
-    /**
-     * Toggle the public ingress (e.g. Tailscale Funnel) that maps a
-     * local port to the open internet via the provider's edge. Idempotent.
-     */
-    setPublicIngress: method(
-      PublicIngressConfigSchema,
-      zod.z.object({ success: zod.z.literal(true) }),
-      { kind: "mutation" }
-    ),
     /**
-     * Toggle the in-mesh HTTPS ingress (e.g. Tailscale Serve) so peers
-     * inside the mesh hit a valid TLS endpoint instead of the raw IP.
+     * Sign out of the mesh account entirely. Distinct from `leave`:
+     * `leave` only takes the host off-mesh (`tailscale down`) while the
+     * account binding survives, so the next `join` reconnects silently.
+     * `logout` (`tailscale logout`) wipes the daemon's stored
+     * credentials — the next `startLogin` MUST go through a fresh
+     * browser-redirect flow to bind a new account.
      */
-    setMeshIngress: method(
-      MeshIngressConfigSchema,
-      zod.z.object({ success: zod.z.literal(true) }),
+    logout: method(
+      zod.z.void(),
+      zod.z.object({ loggedOut: zod.z.literal(true) }),
       { kind: "mutation" }
     ),
+    /** Enumerate every peer the daemon currently knows about. */
+    listPeers: method(zod.z.void(), zod.z.object({
+      peers: zod.z.array(MeshPeerSchema).readonly()
+    })),
     /**
      * Probe the mesh daemon / API for a sanity check WITHOUT joining.
      * Operator-facing "test connection" button: validates the auth key
@@ -7557,6 +7656,15 @@ const meshNetworkCapability = {
       }),
       { kind: "mutation" }
     )
+    // Provider-specific runtime knobs (accept-routes / advertise-routes /
+    // shields-up / ssh / exit-node, …) live on the addon's own
+    // `getSettingsUISchema` (form-builder), NOT here. Different mesh
+    // providers (Tailscale, Headscale, ZeroTier, Nebula) have very
+    // different config surfaces — picking one shape and forcing all
+    // implementations to honour it would either lose options or
+    // misrepresent them. The Mesh page renders the addon's settings
+    // schema as a "Settings" tab next to the generic Status / Peers
+    // tabs driven by this cap.
   }
 };
 const MeshEndpointSchema = zod.z.object({
@@ -7584,7 +7692,18 @@ const MeshProviderInfoSchema = zod.z.object({
   /** Active endpoints (mesh IP + MagicDNS + optional public Funnel). */
   endpoints: zod.z.array(MeshEndpointSchema).readonly(),
   /** Last error reported by the provider. */
-  error: zod.z.string().optional()
+  error: zod.z.string().optional(),
+  // ── Generic identity fields mirrored from MeshStatus ─────────────
+  /** Tenant / tailnet / network display name. Empty pre-join. */
+  tenantName: zod.z.string(),
+  /** Mesh DNS suffix (e.g. tailXXXX.ts.net). Empty when not configured. */
+  magicDnsSuffix: zod.z.string(),
+  /** Authenticated user / account login. Null for token-only providers. */
+  userLogin: zod.z.string().nullable(),
+  /** Provider control-plane URL. */
+  controlPlaneUrl: zod.z.string(),
+  /** Machine-key expiry (epoch ms). Null when keys don't rotate. */
+  keyExpiry: zod.z.number().nullable()
 });
 const meshOrchestratorCapability = {
   name: "mesh-orchestrator",
@@ -7610,6 +7729,43 @@ const meshOrchestratorCapability = {
       zod.z.object({ addonId: zod.z.string() }),
       zod.z.object({ success: zod.z.literal(true) }),
       { kind: "mutation" }
+    ),
+    /**
+     * Browser-redirect login flow. Forwards to the named provider's
+     * `mesh-network.startLogin` and returns the URL the daemon
+     * prints. UI opens it in a new tab, then polls `listProviders`
+     * for `joined: true`.
+     */
+    startLoginProvider: method(
+      zod.z.object({
+        addonId: zod.z.string(),
+        hostname: zod.z.string().optional()
+      }),
+      zod.z.object({ loginUrl: zod.z.string() }),
+      { kind: "mutation" }
+    ),
+    /**
+     * Sign out of the provider's account entirely (`mesh-network.logout`).
+     * Distinct from `leaveProvider` which only takes the host off-mesh;
+     * `logoutProvider` wipes credentials so the next start requires a
+     * fresh login.
+     */
+    logoutProvider: method(
+      zod.z.object({ addonId: zod.z.string() }),
+      zod.z.object({ loggedOut: zod.z.literal(true) }),
+      { kind: "mutation" }
+    ),
+    /**
+     * Per-provider peer list. Forwards to `mesh-network.listPeers` on
+     * the addressed provider. Separate from `listProviders` because
+     * peer payloads can be large on a heavily-populated tailnet —
+     * fetch only when the operator opens the Peers tab.
+     */
+    listProviderPeers: method(
+      zod.z.object({ addonId: zod.z.string() }),
+      zod.z.object({
+        peers: zod.z.array(MeshPeerSchema).readonly()
+      })
     )
   }
 };
@@ -7697,6 +7853,13 @@ const UserSummarySchema = zod.z.object({
   allowedProviders: zod.z.union([zod.z.array(zod.z.string()), zod.z.literal("*")]),
   allowedDevices: zod.z.record(zod.z.string(), zod.z.union([zod.z.array(zod.z.string()), zod.z.literal("*")])),
   scopes: zod.z.array(TokenScopeSchema).default([]),
+  /**
+   * True iff this user has a CONFIRMED TOTP enrollment. Surfaced on
+   * `listUsers` so the admin Users page can render the "Remove 2FA"
+   * action conditionally without firing one `getTotpStatus` query per
+   * row. Self-service enrollment lives on the user's profile page.
+   */
+  totpEnabled: zod.z.boolean().default(false),
   createdAt: zod.z.number(),
   updatedAt: zod.z.number()
 });
@@ -7995,6 +8158,12 @@ const NodeAddonInputSchema = zod.z.object({
   nodeId: zod.z.string(),
   addonId: zod.z.string()
 });
+const NodeAddonEntrySchema = zod.z.object({
+  id: zod.z.string(),
+  status: zod.z.string(),
+  version: zod.z.string().optional(),
+  packageName: zod.z.string().optional()
+});
 const SuccessSchema = zod.z.object({ success: zod.z.boolean() });
 const RestartProcessResultSchema = zod.z.object({
   success: zod.z.boolean(),
@@ -8055,6 +8224,19 @@ const nodesCapability = {
       zod.z.record(zod.z.string(), ClusterAddonStatusEntrySchema),
       { auth: "admin" }
     ),
+    /**
+     * Direct per-node addon listing — calls `$agent.status` on the target
+     * node (or returns the hub registry for `nodeId === 'hub'`) and surfaces
+     * the full addon roster including `version` + `packageName`. The
+     * `topology` cap also includes addons but strips them down to
+     * `{id, capabilities, status}` for the cluster diagram; this method
+     * is the one the per-node "Addons" tab should call.
+     */
+    getNodeAddons: method(
+      zod.z.object({ nodeId: zod.z.string() }),
+      zod.z.array(NodeAddonEntrySchema).readonly(),
+      { auth: "admin" }
+    ),
     setProcessLogLevel: method(
       zod.z.object({ nodeId: zod.z.string(), level: zod.z.string() }),
       SuccessSchema,
@@ -8461,6 +8643,7 @@ exports.AUDIO_MACRO_LABELS = AUDIO_MACRO_LABELS;
 exports.AbortUploadInputSchema = AbortUploadInputSchema;
 exports.AccessoriesStatusSchema = AccessoriesStatusSchema;
 exports.AccessoryKind = AccessoryKind;
+exports.AddBrokerInputSchema = AddBrokerInputSchema;
 exports.AddonAutoUpdateSchema = AddonAutoUpdateSchema;
 exports.AddonListItemSchema = AddonListItemSchema;
 exports.AddonPageDeclarationSchema = AddonPageDeclarationSchema;
@@ -8506,10 +8689,12 @@ exports.BoundingBoxSchema = BoundingBoxSchema;
 exports.BrightnessStatusSchema = BrightnessStatusSchema;
 exports.BrokerAudioClientSchema = BrokerAudioClientSchema;
 exports.BrokerClientsSchema = BrokerClientsSchema;
+exports.BrokerConnectionDetailsSchema = BrokerConnectionDetailsSchema;
 exports.BrokerDecodedClientSchema = BrokerDecodedClientSchema;
+exports.BrokerInfoSchema = BrokerInfoSchema;
 exports.BrokerRtspClientSchema = BrokerRtspClientSchema;
 exports.BrokerStatsSchema = BrokerStatsSchema;
-exports.BrokerStatusSchema = BrokerStatusSchema;
+exports.BrokerStatusSchema = BrokerStatusSchema$1;
 exports.CAM_PROFILE_ORDER = CAM_PROFILE_ORDER;
 exports.CamProfileSchema = CamProfileSchema;
 exports.CamStreamKindSchema = CamStreamKindSchema;
@@ -8549,6 +8734,7 @@ exports.DecoderStatsSchema = DecoderStatsSchema;
 exports.DeleteIntegrationResultSchema = DeleteIntegrationResultSchema;
 exports.DetectorOutputSchema = DetectorOutputSchema;
 exports.DeviceDiscoveryStatusSchema = DeviceDiscoveryStatusSchema;
+exports.DeviceExportStatusSchema = DeviceExportStatusSchema;
 exports.DeviceFeature = DeviceFeature;
 exports.DeviceInfoSchema = DeviceInfoSchema;
 exports.DeviceNetworkStatsSchema = DeviceNetworkStatsSchema;
@@ -8567,16 +8753,16 @@ exports.EndDownloadInputSchema = EndDownloadInputSchema;
 exports.EnrichedWidgetMetadataSchema = EnrichedWidgetMetadataSchema;
 exports.EventItemSchema = EventItemSchema;
 exports.EventKindSchema = EventKindSchema;
+exports.ExposeInputSchema = ExposeInputSchema;
+exports.ExposedDeviceSchema = ExposedDeviceSchema;
 exports.ExposedResourceSchema = ExposedResourceSchema;
 exports.FeatureManifestSchema = FeatureManifestSchema;
 exports.FeatureProbeStatusSchema = FeatureProbeStatusSchema;
 exports.FinalizeUploadInputSchema = FinalizeUploadInputSchema;
 exports.FrameInputSchema = FrameInputSchema;
+exports.GetStreamWithCodecInputSchema = GetStreamWithCodecInputSchema;
 exports.GlobalMetricsSchema = GlobalMetricsSchema;
 exports.HWACCEL_OPTIONS = HWACCEL_OPTIONS;
-exports.HaServiceCallSchema = HaServiceCallSchema;
-exports.HaStateSchema = HaStateSchema;
-exports.HaStatusSchema = HaStatusSchema;
 exports.HealthStatusSchema = HealthStatusSchema;
 exports.HistoryPointSchema = HistoryPointSchema;
 exports.HistoryResolutionEnum = HistoryResolutionEnum;
@@ -8601,7 +8787,6 @@ exports.MotionSourcesSchema = MotionSourcesSchema;
 exports.MotionStatusSchema = MotionStatusSchema;
 exports.MotionTriggerRuntimeStateSchema = MotionTriggerRuntimeStateSchema;
 exports.MotionTriggerStatusSchema = MotionTriggerStatusSchema;
-exports.MqttStatusSchema = MqttStatusSchema;
 exports.NativeDetectionSchema = NativeDetectionSchema;
 exports.NativeObjectClassEnum = NativeObjectClassEnum;
 exports.NativeObjectDetectionStatusSchema = NativeObjectDetectionStatusSchema;
@@ -8643,13 +8828,13 @@ exports.PtzAutotrackTargetOptionSchema = PtzAutotrackTargetOptionSchema;
 exports.PtzMoveCommandSchema = PtzMoveCommandSchema;
 exports.PtzPositionSchema = PtzPositionSchema;
 exports.PtzPresetSchema = PtzPresetSchema;
-exports.PublishInputSchema = PublishInputSchema;
 exports.QueryFilterSchema = QueryFilterSchema;
 exports.ReadChunkInputSchema = ReadChunkInputSchema;
 exports.RegisteredStreamSchema = RegisteredStreamSchema;
 exports.RemoteAccessEndpointSchema = RemoteAccessEndpointSchema;
 exports.RemoteAccessProviderInfoSchema = RemoteAccessProviderInfoSchema;
 exports.ReportMotionInputSchema = ReportMotionInputSchema;
+exports.RtpSourceSchema = RtpSourceSchema;
 exports.RtspRestreamEntrySchema = RtspRestreamEntrySchema;
 exports.RunnerCameraConfigSchema = RunnerCameraConfigSchema;
 exports.RunnerCameraDeviceUIFields = RunnerCameraDeviceUIFields;
@@ -8670,6 +8855,8 @@ exports.SmtpStatusSchema = SmtpStatusSchema;
 exports.SnapshotImageSchema = SnapshotImageSchema;
 exports.SpatialDetectionSchema = SpatialDetectionSchema;
 exports.SsoBridgeClaimsSchema = SsoBridgeClaimsSchema;
+exports.StartEmbeddedInputSchema = StartEmbeddedInputSchema;
+exports.StatusSchema = StatusSchema;
 exports.StorageLocationRefSchema = StorageLocationRefSchema;
 exports.StorageLocationSchema = StorageLocationSchema;
 exports.StorageLocationTypeSchema = StorageLocationTypeSchema;
@@ -8678,8 +8865,6 @@ exports.StreamInfoSchema = StreamInfoSchema;
 exports.StreamNetworkStatsSchema = StreamNetworkStatsSchema;
 exports.StreamSourceEntrySchema = StreamSourceEntrySchema$1;
 exports.StreamSourceSchema = StreamSourceSchema;
-exports.SubscribeInputSchema = SubscribeInputSchema;
-exports.SubscriptionInfoSchema = SubscriptionInfoSchema;
 exports.SwitchStatusSchema = SwitchStatusSchema;
 exports.SystemMetricsSchema = SystemMetricsSchema;
 exports.TestConnectionResultSchema = TestConnectionResultSchema;
@@ -8694,6 +8879,7 @@ exports.TrackStateSchema = TrackStateSchema;
 exports.TrackedDetectionSchema = TrackedDetectionSchema;
 exports.TurnProviderInfoSchema = TurnProviderInfoSchema;
 exports.TurnServerSchema = TurnServerSchema;
+exports.UnexposeInputSchema = UnexposeInputSchema;
 exports.UpdateIntegrationInputSchema = UpdateIntegrationInputSchema;
 exports.UpdateUserInputSchema = UpdateUserInputSchema;
 exports.UserRecordSchema = UserRecordSchema;
@@ -8740,6 +8926,7 @@ exports.cameraStreamsCapability = cameraStreamsCapability;
 exports.decoderCapability = decoderCapability;
 exports.detectionPipelineCapability = detectionPipelineCapability;
 exports.deviceDiscoveryCapability = deviceDiscoveryCapability;
+exports.deviceExportCapability = deviceExportCapability;
 exports.deviceManagerCapability = deviceManagerCapability;
 exports.deviceMatchesProfile = deviceMatchesProfile;
 exports.deviceOpsCapability = deviceOpsCapability;
@@ -8754,7 +8941,6 @@ exports.eventsCapability = eventsCapability;
 exports.expandCapMethods = expandCapMethods;
 exports.featureProbeCapability = featureProbeCapability;
 exports.getAudioMacroClassIds = getAudioMacroClassIds;
-exports.homeAssistantCapability = homeAssistantCapability;
 exports.hydrateSchema = hydrateSchema;
 exports.integrationsCapability = integrationsCapability;
 exports.intercomCapability = intercomCapability;
@@ -8768,7 +8954,7 @@ exports.metricsProviderCapability = metricsProviderCapability;
 exports.motionCapability = motionCapability;
 exports.motionDetectionCapability = motionDetectionCapability;
 exports.motionTriggerCapability = motionTriggerCapability;
-exports.mqttProviderCapability = mqttProviderCapability;
+exports.mqttBrokerCapability = mqttBrokerCapability;
 exports.nativeObjectDetectionCapability = nativeObjectDetectionCapability;
 exports.networkAccessCapability = networkAccessCapability;
 exports.networkQualityCapability = networkQualityCapability;
@@ -8810,4 +8996,4 @@ exports.webrtcSessionCapability = webrtcSessionCapability;
 exports.zoneAnalyticsCapability = zoneAnalyticsCapability;
 exports.zoneRulesCapability = zoneRulesCapability;
 exports.zonesCapability = zonesCapability;
-//# sourceMappingURL=index-BKifir_y.js.map
+//# sourceMappingURL=index-DRWlYskM.js.map