@camstack/addon-pipeline-orchestrator 0.1.22 → 0.1.24

package/dist/index.mjs

@@ -5067,6 +5067,7 @@ const WELL_KNOWN_TABS = [
   { id: "osd", label: "OSD", icon: "type", order: 18 },
   { 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: "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 },
@@ -5223,7 +5224,19 @@ const DecoderSessionConfigSchema = object({
    * on every line so `grep tag=broker:5/high` filters one camera
    * profile cleanly.
    */
-  tag: string().optional()
+  tag: string().optional(),
+  /**
+   * Where the session delivers decoded frames (Phase 5 / D9):
+   *
+   * - `'callback'` (default) — the legacy pixel path: decoded frames are
+   *   buffered as `DecodedFrame`s and drained via `pullFrames`.
+   * - `'shm'` — the shared-memory frame plane: decoded frames are written
+   *   into an OS shared-memory ring and drained as zero-pixel
+   *   `FrameHandle`s via `pullHandles`. A session is one mode or the
+   *   other — `pullFrames` returns nothing for an `'shm'` session and
+   *   `pullHandles` returns nothing for a `'callback'` session.
+   */
+  frameSink: _enum(["callback", "shm"]).default("callback")
 });
 function errMsg(err) {
   if (err instanceof Error) return err.message;
@@ -5981,6 +5994,53 @@ const DecodedFrameSchema = object({
   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,
@@ -6202,9 +6262,76 @@ const RtpSourceSchema = object({
       object({ released: boolean(), refcount: number().int().nonnegative() }),
       { kind: "mutation", auth: "admin" }
     ),
-    getBroker: method(
-      object({ brokerId: string() }),
-      custom()
+    /**
+     * ── Decoded audio-chunk plane (Phase 5 / D9) ──────────────────────
+     *
+     * The serialisable replacement for the live-object `IStreamBroker.
+     * onDecodedAudioChunk` callback path. Unlike the video frame plane,
+     * audio chunks are tiny (a ~500ms PCM window is a few KB) so they ship
+     * their bytes INLINE over tRPC — no shared-memory ring. A consumer:
+     *
+     *   1. `subscribeAudioChunks({ brokerId, tag })` — the broker registers
+     *      a per-subscription bounded FIFO queue and returns a
+     *      `subscriptionId`.
+     *   2. polls `pullAudioChunks({ subscriptionId, maxCount })` — drains
+     *      `DecodedAudioChunk[]` in arrival order (FIFO, no latest-wins
+     *      drop: an audio gap is audible / breaks an analysis window). The
+     *      queue is generously sized; it only drops its oldest chunk if a
+     *      truly stalled consumer lets it overflow.
+     *   3. `unsubscribeAudioChunks({ subscriptionId })` on teardown.
+     */
+    subscribeAudioChunks: method(
+      SubscribeAudioChunksInputSchema,
+      SubscribeAudioChunksResultSchema,
+      { kind: "mutation" }
+    ),
+    pullAudioChunks: method(
+      object({
+        subscriptionId: string(),
+        maxCount: number().int().positive().default(8)
+      }),
+      array(DecodedAudioChunkSchema).readonly()
+    ),
+    unsubscribeAudioChunks: method(
+      object({ subscriptionId: string() }),
+      object({ released: boolean() }),
+      { kind: "mutation" }
+    ),
+    /**
+     * ── Shared-memory frame plane (Phase 5 / D9) ──────────────────────
+     *
+     * The handle-based replacement for the live-object `IStreamBroker.
+     * onDecodedFrame` callback path. A consumer:
+     *
+     *   1. `subscribeFrames({ brokerId, format })` — the broker spins up
+     *      (or reuses) a `frameSink: 'shm'` decoder session producing that
+     *      `format` and returns a `subscriptionId`.
+     *   2. polls `pullFrameHandles({ subscriptionId, maxCount })` — drains
+     *      zero-pixel `FrameHandle[]`; each handle is fed to a
+     *      `FrameRingReader` that opens the named shm segment and reads the
+     *      pixels back zero-copy.
+     *   3. `unsubscribeFrames({ subscriptionId })` on teardown.
+     *
+     * The broker keeps one shm ring per `(brokerId, format)` actually
+     * requested — no broker-side `sharp` conversion. fps throttling is
+     * implicit (latest-wins ring reads drop frames for a slow consumer).
+     */
+    subscribeFrames: method(
+      SubscribeFramesInputSchema,
+      SubscribeFramesResultSchema,
+      { kind: "mutation" }
+    ),
+    pullFrameHandles: method(
+      object({
+        subscriptionId: string(),
+        maxCount: number().int().positive().default(4)
+      }),
+      array(FrameHandleSchema).readonly()
+    ),
+    unsubscribeFrames: method(
+      object({ subscriptionId: string() }),
+      object({ released: boolean() }),
+      { kind: "mutation" }
     ),
     setPreBufferDuration: method(
       object({ brokerId: string(), seconds: number().min(0).max(30) }),
@@ -7530,6 +7657,29 @@ const StreamProfilePatchSchema = object({
       }),
       _void(),
       { kind: "mutation", auth: "admin" }
+    ),
+    /**
+     * Build the `ConfigUISchema` (admin-ui `ConfigFormBuilder` input
+     * shape) for this camera's stream-encoder settings — one section per
+     * profile (main / sub / ext) with the resolution / codec / framerate
+     * / bitrate / bitrate-mode / encoder-profile / GOP controls the
+     * firmware actually exposes.
+     *
+     * Driven by `getOptions` (camera-probed availability) + `getStatus`
+     * (current per-profile config); each field's `default` is seeded
+     * from the live config so the form renders the camera state in one
+     * pass. Returns `null` when the camera exposes no configurable
+     * stream property — the renderer then shows the unsupported message.
+     *
+     * Output is `z.unknown().nullable()` — the same convention every
+     * other `ConfigUISchema`-returning cap method uses (`device-ops`,
+     * `device-manager`); `ConfigUISchema` is a TS-only type with no
+     * companion Zod schema, and a concrete object would collapse
+     * unrelated AppRouter branches to `unknown` during codegen.
+     */
+    getConfigSchema: method(
+      object({ deviceId: number() }),
+      unknown().nullable()
     )
   }
 });
@@ -8600,7 +8750,7 @@ const OauthIntegrationDescriptorSchema = object({
   displayName: string(),
   /** Scopes baked into every token issued for this integration. */
   requestedScopes: array(TokenScopeSchema),
-  /** Allowed redirect_uri prefixes. /oauth2/authorize rejects any
+  /** Allowed redirect_uri prefixes. /api/oauth2/authorize rejects any
    *  redirect_uri that does not start with one of these. Required —
    *  an empty list means the integration can never complete linking. */
   allowedRedirectPrefixes: array(string()).min(1)
@@ -8890,21 +9040,30 @@ const AddonPageDeclarationSchema = object({
 });
 const WidgetHostEnum = _enum(["device-tab", "dashboard", "integration-detail"]);
 const WidgetSizeEnum = _enum(["xs", "sm", "md", "lg", "xl"]);
+const WidgetRemoteSchema = object({
+  remoteName: string(),
+  exposedModule: string(),
+  componentKey: string().optional()
+});
 const WidgetMetadataSchema = object({
-  /** Stable id within the addon — kebab-case. */
-  stableId: string(),
+  // ── UiContribution core (kind:'remote') ──────────────────────────
+  /** Primary host tab — `'dashboard'`, `'device-tab'`, or a device-detail tab id. */
+  tab: string(),
+  /** Optional sub-tab within `tab`. */
+  subTab: string().optional(),
   /** Operator-facing label. */
   label: string(),
+  /** Ordering within `(tab, subTab)`, ascending. */
+  order: number().optional(),
+  /** Always `'remote'` — a widget is a Module Federation remote. */
+  kind: literal("remote"),
+  /** MF remote descriptor. */
+  remote: WidgetRemoteSchema,
+  // ── Widget-only metadata ─────────────────────────────────────────
+  /** Stable id within the addon — kebab-case. Equals `remote.componentKey`. */
+  stableId: string(),
   description: string().optional(),
   icon: string().optional(),
-  /**
-   * Module Federation remote name — must match the `name` field on the
-   * widget addon's `federation()` plugin config. Used by the host's
-   * `<WidgetRegistryProvider>` to call `loadRemote('<remoteName>/widgets')`.
-   * Conventionally `addon_<addonid>_widgets` (snake_case; MF names
-   * cannot contain hyphens).
-   */
-  remoteName: string(),
   /**
    * Bundle filename inside the addon's `dist/` dir served at
    * `/api/addon-widgets/<addonId>/<bundle>`. With Module Federation
@@ -8913,9 +9072,9 @@ const WidgetMetadataSchema = object({
    * cache-buster URL without a separate filesystem stat.
    */
   bundle: string(),
-  /** Where the widget makes sense to render. */
+  /** Every host the widget supports. The picker filters on this set. */
   hosts: array(WidgetHostEnum).readonly(),
-  /** Required props the host must supply. Validated at <WidgetSlot> mount. */
+  /** Required props the host must supply. Validated at `<WidgetSlot>` mount. */
   requires: object({
     deviceContext: boolean().default(false),
     integrationContext: boolean().default(false)
@@ -8990,6 +9149,16 @@ const InvokeReplyEnvelopeSchema = object({
     invoke: method(InvokeRequestSchema, InvokeReplyEnvelopeSchema, { kind: "mutation" })
   }
 });
+const ShmRingStatsSchema = object({
+  sessionId: string(),
+  slotCount: number().int(),
+  slotByteLength: number().int(),
+  segmentBytes: number().int(),
+  budgetMb: number().int(),
+  framesWritten: number().int(),
+  getFrameHits: number().int(),
+  getFrameMisses: number().int()
+});
 ({
   methods: {
     // ── Discovery ─────────────────────────────────────────────────
@@ -9017,10 +9186,27 @@ const InvokeReplyEnvelopeSchema = object({
       url: string()
     }), _void()),
     // ── Output — polling-based frame retrieval ────────────────────
+    // `pullFrames` drains the pixel `DecodedFrame[]` of a `frameSink:
+    // 'callback'` session. `pullHandles` (Phase 5 / D9) drains the
+    // zero-pixel `FrameHandle[]` of a `frameSink: 'shm'` session — the
+    // broker hands each handle to a `FrameRingReader` that opens the
+    // named segment and reads the pixels back zero-copy. A session is
+    // one mode or the other; the unmatched method returns an empty
+    // array.
     pullFrames: method(object({
       sessionId: string(),
       maxCount: number().default(1)
     }), array(DecodedFrameSchema)),
+    pullHandles: method(object({
+      sessionId: string(),
+      maxCount: number().default(1)
+    }), array(FrameHandleSchema)),
+    // ── Frame fetch (Phase 5 / D9 downstream access) ──────────────
+    // Read the pixels a FrameHandle refers to from this node's shm ring.
+    // Returns null when the slot was already recycled (latest-wins).
+    getFrame: method(object({ handle: FrameHandleSchema }), DecodedFrameSchema.nullable()),
+    // shm ring usage stats for a session.
+    getShmStats: method(object({ sessionId: string() }), ShmRingStatsSchema.nullable()),
     // ── Control ───────────────────────────────────────────────────
     updateConfig: method(object({
       sessionId: string(),
@@ -10192,8 +10378,8 @@ const DevicePersistConfigPayloadSchema = object({
     /**
      * Return the addon ids that declared a wrapper provider for `capName`.
      * Backs the device-bindings UI's wrapper-picker dropdown. Entries are
-     * sourced from `CapabilityRegistry.wrapperProviders`, populated at
-     * `ProviderRegistration.kind === 'wrapper'` time.
+     * sourced from `CapabilityRegistry.wrapperProviders`, populated when
+     * the cap definition declares `kind: 'wrapper'`.
      */
     listWrappersForCap: method(
       object({ capName: string() }),
@@ -11283,13 +11469,17 @@ const PtzMoveCommandSchema = object({
   zoom: number().optional(),
   speed: number().optional()
 });
+PtzPositionSchema.extend({ autofocus: boolean() });
 const PtzOptionsSchema = object({
   hasPan: boolean(),
   hasTilt: boolean(),
   hasZoom: boolean(),
   supportsPresets: boolean(),
   /** Max number of named presets the camera supports, when known. */
-  maxPresets: number().optional()
+  maxPresets: number().optional(),
+  /** Whether the camera exposes a controllable autofocus toggle
+   *  (boolean `hasX` per the getOptions availability convention). */
+  hasAutofocus: boolean()
 });
 ({
   deviceTypes: [DeviceType.Camera],
@@ -11346,6 +11536,13 @@ const PtzOptionsSchema = object({
     getPosition: method(
       object({ deviceId: number() }),
       PtzPositionSchema
+    ),
+    /** Toggle the camera's autofocus. Only meaningful when
+     *  `getOptions().hasAutofocus` is true. */
+    setAutofocus: method(
+      object({ deviceId: number(), enabled: boolean() }),
+      _void(),
+      { kind: "mutation" }
     )
   }
 });
@@ -12714,6 +12911,19 @@ const RenameNodeResultSchema = object({
       record(string(), ClusterAddonStatusEntrySchema),
       { auth: "admin" }
     ),
+    getCapUsageGraph: method(
+      object({
+        windowSeconds: number().int().positive().max(300).default(60)
+      }),
+      array(object({
+        callerAddonId: string(),
+        providerAddonId: string(),
+        capName: string(),
+        callsPerMin: number(),
+        lastCallAtMs: number()
+      })).readonly(),
+      { auth: "admin" }
+    ),
     /**
      * Direct per-node addon listing — calls `$agent.status` on the target
      * node (or returns the hub registry for `nodeId === 'hub'`) and surfaces
@@ -14519,6 +14729,60 @@ function balanceAudio(input) {
   const best = input.nodes.slice().sort((a, b) => a.deviceCount - b.deviceCount)[0];
   return { nodeId: best.nodeId, reason: "capacity" };
 }
+const POLL_INTERVAL_MS = 200;
+const PULL_MAX_COUNT = 8;
+async function startAudioChunkPoller(options) {
+  const { api, brokerId, tag, onChunk, logger } = options;
+  let subscriptionId;
+  try {
+    const result = await api.streamBroker.subscribeAudioChunks.mutate({
+      brokerId,
+      tag
+    });
+    subscriptionId = result.subscriptionId;
+  } catch (err) {
+    logger.warn("audio-chunk poller: subscribeAudioChunks failed", {
+      meta: { brokerId, tag, error: errMsg(err) }
+    });
+    return null;
+  }
+  let stopped = false;
+  let timer;
+  const tick = async () => {
+    if (stopped) return;
+    try {
+      const chunks = await api.streamBroker.pullAudioChunks.query({
+        subscriptionId,
+        maxCount: PULL_MAX_COUNT
+      });
+      for (const chunk of chunks) {
+        if (stopped) break;
+        await onChunk(chunk);
+      }
+    } catch (err) {
+      logger.warn("audio-chunk poller: pullAudioChunks failed", {
+        meta: { brokerId, subscriptionId, error: errMsg(err) }
+      });
+    }
+    if (!stopped) {
+      timer = setTimeout(() => void tick(), POLL_INTERVAL_MS);
+    }
+  };
+  void tick();
+  return () => {
+    if (stopped) return;
+    stopped = true;
+    if (timer) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+    api.streamBroker.unsubscribeAudioChunks.mutate({ subscriptionId }).catch((err) => {
+      logger.warn("audio-chunk poller: unsubscribeAudioChunks failed", {
+        meta: { brokerId, subscriptionId, error: errMsg(err) }
+      });
+    });
+  };
+}
 const PHASE_MODE_VALUES = /* @__PURE__ */ new Set([
   "disabled",
   "always-on",
@@ -14974,11 +15238,17 @@ class PipelineOrchestratorAddon extends BaseAddon {
     const widgetsProvider = {
       listWidgets: async () => [
         {
-          stableId: "pipeline-quick-stats",
+          tab: "device-tab",
           label: "Pipeline Quick Stats",
+          kind: "remote",
+          remote: {
+            remoteName: "addon_pipeline_orchestrator_widgets",
+            exposedModule: "./widgets",
+            componentKey: "pipeline-quick-stats"
+          },
+          stableId: "pipeline-quick-stats",
           description: "Phase / Detection FPS / Inference / Active Tracks tile row.",
           icon: "activity",
-          remoteName: "addon_pipeline_orchestrator_widgets",
           bundle: "remoteEntry.js",
           hosts: ["device-tab", "dashboard"],
           requires: { deviceContext: true, integrationContext: false },
@@ -14988,11 +15258,17 @@ class PipelineOrchestratorAddon extends BaseAddon {
           defaultRows: 1
         },
         {
-          stableId: "zone-editor",
+          tab: "device-tab",
           label: "Zone Editor",
+          kind: "remote",
+          remote: {
+            remoteName: "addon_pipeline_orchestrator_widgets",
+            exposedModule: "./widgets",
+            componentKey: "zone-editor"
+          },
+          stableId: "zone-editor",
           description: "Polygon / tripwire CRUD + per-stage rule editor.",
           icon: "shapes",
-          remoteName: "addon_pipeline_orchestrator_widgets",
           bundle: "remoteEntry.js",
           hosts: ["device-tab"],
           requires: { deviceContext: true, integrationContext: false },
@@ -15000,24 +15276,6 @@ class PipelineOrchestratorAddon extends BaseAddon {
           allowedSizes: ["lg", "xl"],
           defaultColumns: 12,
           defaultRows: 4
-        },
-        {
-          // On-camera motion-detection grid editor. The `motion-zones`
-          // cap is owned by the camera provider addons; the widget only
-          // talks to it over tRPC, so hosting the React surface here
-          // (one bundle) avoids duplicating it per provider.
-          stableId: "motion-zones-editor",
-          label: "Motion Zones",
-          description: "On-camera motion-detection grid editor (live-frame overlay).",
-          icon: "grid-3x3",
-          remoteName: "addon_pipeline_orchestrator_widgets",
-          bundle: "remoteEntry.js",
-          hosts: ["device-tab"],
-          requires: { deviceContext: true, integrationContext: false },
-          defaultSize: "lg",
-          allowedSizes: ["md", "lg"],
-          defaultColumns: 12,
-          defaultRows: 1
         }
       ]
     };
@@ -17166,53 +17424,27 @@ class PipelineOrchestratorAddon extends BaseAddon {
       title: "Detection Zones",
       tab: "zones",
       location: "top-tab",
-      // Single full-width column — the `zone-editor` renderer paints
-      // the polygon canvas + side panel + rules + occupancy across the
+      // Single full-width column — the zone-editor widget paints the
+      // polygon canvas + side panel + rules + occupancy across the
       // entire viewport. Default 2-column grid would clip everything to
       // 50% width.
       columns: 1,
       order: 0,
       fields: [
         {
-          type: "zone-editor",
+          type: "widget",
           key: "zones",
           label: "Detection Zones",
-          backdrop: "snapshot",
+          widgetId: "pipeline-orchestrator/zone-editor",
           // Span across the (single) column so even if a layout engine
           // were to compute multiple columns, the field still pulls full
           // width.
-          span: 1,
-          // Hydrated form requires a value field; the `zone-editor`
-          // renderer reads zones from the `dev.state.zones` slice via
-          // DeviceProxy and ignores this value entirely.
-          value: void 0
-        }
-      ]
-    };
-    const motionZonesSection = {
-      id: "motion-zones",
-      title: "Motion Zones",
-      tab: "motion",
-      location: "settings",
-      columns: 1,
-      order: 0,
-      fields: [
-        {
-          // Widget fields manage their own state via DeviceProxy —
-          // `ConfigWidgetField` carries no `value` (unlike the legacy
-          // `zone-editor` field type which still does). No `label` —
-          // the section title already reads "Motion Zones"; a field
-          // label here would duplicate it.
-          type: "widget",
-          key: "motion-zones",
-          label: "",
-          widgetId: "pipeline-orchestrator/motion-zones-editor",
           span: 1
         }
       ]
     };
     return {
-      sections: [...baseSections, zonesSection, motionZonesSection]
+      sections: [...baseSections, zonesSection]
     };
   }
   // `getCameraPipelineWithFallback` was a thin wrapper over
@@ -18065,14 +18297,16 @@ class PipelineOrchestratorAddon extends BaseAddon {
   async handleInferenceResult(payload) {
     const ctx = this.ctx;
     if (!ctx) return;
-    const { deviceId, frame } = payload;
+    const { deviceId, frame, frameHandle } = payload;
     if (frame.detections.length === 0) return;
     this.ctx.eventBus.emit({
       id: `detection-${deviceId}-${Date.now()}`,
       category: EventCategory.DetectionResult,
       source: { type: "device", id: deviceId, nodeId: "hub", addonId: "pipeline-orchestrator", deviceId },
       timestamp: /* @__PURE__ */ new Date(),
-      data: { frame, analysisResults: [] }
+      // Forward the upstream shm-ring `frameHandle` so post-analysis
+      // consumers (Task 8) can resolve the original frame zero-copy.
+      data: { frame, analysisResults: [], frameHandle }
     });
   }
   /**
@@ -18163,16 +18397,6 @@ class PipelineOrchestratorAddon extends BaseAddon {
     }
     const audioStream = config2.audioStreamId ?? config2.motionStreamId;
     const audioBrokerId = `${deviceId}/${audioStream}`;
-    const broker = await api.streamBroker.getBroker.query({
-      brokerId: audioBrokerId
-    });
-    if (!broker) {
-      this.ctx.logger.warn("No broker found for audio subscription", {
-        tags: { deviceId },
-        meta: { brokerId: audioBrokerId }
-      });
-      return null;
-    }
     const settings = await api.audioAnalysis.resolveDeviceSettings.query({
       deviceId
     });
@@ -18190,8 +18414,12 @@ class PipelineOrchestratorAddon extends BaseAddon {
       meta: { audioNodeId, isRemote: isRemoteAudio }
     });
     let loggedAnalyzerStatus = false;
-    const unsub = broker.onDecodedAudioChunk(
-      async (chunk) => {
+    const teardown = await startAudioChunkPoller({
+      api,
+      brokerId: audioBrokerId,
+      tag: "audio-analyzer",
+      logger: this.ctx.logger,
+      onChunk: async (chunk) => {
         if (!loggedAnalyzerStatus) {
           loggedAnalyzerStatus = true;
           this.ctx.logger.info("audio status", {
@@ -18280,12 +18508,18 @@ class PipelineOrchestratorAddon extends BaseAddon {
             meta: { error: msg }
           });
         }
-      },
-      { tag: "audio-analyzer" }
-    );
+      }
+    });
+    if (!teardown) {
+      this.ctx.logger.warn("audio subscription failed — no broker", {
+        tags: { deviceId },
+        meta: { brokerId: audioBrokerId }
+      });
+      return null;
+    }
     this.ctx.logger.info("Audio stream subscribed", { tags: { deviceId } });
     return () => {
-      unsub();
+      teardown();
     };
   }
 }