@camstack/addon-pipeline-orchestrator 0.1.25 → 0.1.27

package/dist/index.mjs

@@ -4778,6 +4778,16 @@ function record(keyType, valueType, params) {
     ...normalizeParams(params)
   });
 }
+function partialRecord(keyType, valueType, params) {
+  const k = clone(keyType);
+  k._zod.values = void 0;
+  return new ZodRecord({
+    type: "record",
+    keyType: k,
+    valueType,
+    ...normalizeParams(params)
+  });
+}
 const ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
   $ZodEnum.init(inst, def);
   ZodType.init(inst, def);
@@ -5054,6 +5064,37 @@ function _instanceof(cls, params = {}) {
   };
   return inst;
 }
+const wiringProbeKindSchema = _enum(["singleton", "device", "widget"]);
+const wiringProbeResultSchema = object({
+  capName: string(),
+  kind: wiringProbeKindSchema,
+  deviceId: number().optional(),
+  reachable: boolean(),
+  latencyMs: number(),
+  error: string().optional()
+});
+const wiringAddonHealthSchema = object({
+  addonId: string(),
+  caps: array(wiringProbeResultSchema).readonly(),
+  widgets: array(wiringProbeResultSchema).readonly()
+});
+const wiringNodeHealthSchema = object({
+  nodeId: string(),
+  addons: array(wiringAddonHealthSchema).readonly()
+});
+object({
+  /** True only when every probed target is reachable. */
+  ok: boolean(),
+  /** True when at least one target is unreachable. */
+  degraded: boolean(),
+  checkedAt: string(),
+  nodes: array(wiringNodeHealthSchema).readonly(),
+  summary: object({
+    total: number(),
+    reachable: number(),
+    unreachable: number()
+  })
+});
 const MODEL_FORMATS = ["onnx", "coreml", "openvino", "tflite", "pt"];
 const WELL_KNOWN_TABS = [
   { id: "overview", label: "Overview", icon: "layout-dashboard", order: -10 },
@@ -6601,7 +6642,7 @@ const SpatialDetectionSchema = object({
   bbox: BoundingBoxSchema
 });
 const AudioChunkInputSchema = object({
-  data: _instanceof(Float32Array),
+  data: _instanceof(Uint8Array),
   sampleRate: number(),
   channels: number(),
   timestamp: number(),
@@ -7276,7 +7317,23 @@ const RunnerCameraConfigSchema = object({
    * whenever its `zones` device-state slice changes, so the runner's
    * copy stays in sync. Empty array → no zone filtering.
    */
-  zones: array(ZoneSchema).readonly().default([])
+  zones: array(ZoneSchema).readonly().default([]),
+  /**
+   * When true (default) and the camera's `motionSources` contains only
+   * `'onboard'`, the runner dynamically opens the same WASM frame-diff
+   * motion-frames subscription on each `MotionOnMotionChanged
+   * source:'onboard'` event and tears it down after `motionCooldownMs`.
+   * This causes `runMotionAnalysis` to emit `MotionZonesRaw` /
+   * `MotionAnalysis` during active-motion windows without the
+   * substream being held open continuously.
+   *
+   * Set to `false` to disable the dynamic analyzer for this camera
+   * (e.g. very low-bandwidth links where the extra substream is
+   * undesirable). Has no effect when `motionSources` already includes
+   * `'analyzer'` — the analyzer runs continuously in that case and
+   * this gate is bypassed.
+   */
+  onboardMotionDrivesAnalyzer: boolean().default(true)
 });
 const RunnerCameraDeviceUIFields = [
   {
@@ -7336,6 +7393,16 @@ const RunnerCameraDeviceUIFields = [
     showValue: true,
     unit: "s",
     displayScale: 1e3
+  },
+  // Only meaningful for onboard-only cameras — when `motionSources`
+  // contains `'analyzer'` the analyzer runs continuously already.
+  {
+    key: "onboardMotionDrivesAnalyzer",
+    type: "boolean",
+    label: "Run motion analyzer on onboard motion",
+    description: "When onboard motion is detected, temporarily start the frame-diff analyzer to emit zone results. Stops after the motion cooldown window.",
+    default: true,
+    showWhen: { field: "motionSources", includes: "onboard" }
   }
 ];
 const RunnerLocalLoadSchema = object({
@@ -7473,22 +7540,68 @@ MotionTriggerStatusSchema.extend({
     }) }
   }
 });
+const MaskPointSchema = object({
+  x: number(),
+  y: number()
+});
+const MaskRectShapeSchema = object({
+  kind: literal("rect"),
+  x: number(),
+  y: number(),
+  width: number(),
+  height: number()
+});
+const MaskPolygonShapeSchema = object({
+  kind: literal("polygon"),
+  points: array(MaskPointSchema)
+});
+const MaskGridShapeSchema = object({
+  kind: literal("grid"),
+  gridWidth: number(),
+  gridHeight: number(),
+  cells: array(boolean())
+});
+const MaskLineShapeSchema = object({
+  kind: literal("line"),
+  points: array(MaskPointSchema)
+});
+discriminatedUnion("kind", [
+  MaskRectShapeSchema,
+  MaskPolygonShapeSchema,
+  MaskGridShapeSchema,
+  MaskLineShapeSchema
+]);
+const MaskShapeKindSchema = _enum(["rect", "polygon", "grid", "line"]);
+const MaskPolygonVerticesSchema = object({
+  min: number(),
+  max: number()
+});
+const MaskGridDimsSchema = object({
+  width: number(),
+  height: number()
+});
+const MotionZoneRegionSchema = object({
+  id: number(),
+  enabled: boolean(),
+  shape: MaskGridShapeSchema
+});
 object({
   enabled: boolean(),
   sensitivity: number(),
-  /** Row-major active-cell grid. Length = gridWidth*gridHeight (see getOptions). */
-  cells: array(boolean()),
+  /** Grid region(s). Today exactly one `grid` shape. */
+  regions: array(MotionZoneRegionSchema),
   lastFetchedAt: number()
 });
 const MotionZoneOptionsSchema = object({
-  gridWidth: number(),
-  gridHeight: number(),
+  maxRegions: number(),
+  supportedShapes: array(MaskShapeKindSchema),
+  grid: MaskGridDimsSchema,
   sensitivity: object({ min: number(), max: number(), step: number() })
 });
 const MotionZonePatchSchema = object({
   enabled: boolean().optional(),
   sensitivity: number().optional(),
-  cells: array(boolean()).optional()
+  regions: array(MotionZoneRegionSchema).optional()
 });
 ({
   deviceTypes: [DeviceType.Camera],
@@ -7501,6 +7614,102 @@ const MotionZonePatchSchema = object({
     )
   }
 });
+const NativeObjectClassEnum = _enum([
+  "person",
+  "vehicle",
+  "animal",
+  "face",
+  "package",
+  "other"
+]);
+const NativeDetectionSchema = object({
+  class: NativeObjectClassEnum,
+  timestamp: number(),
+  /** Firmware-provided confidence [0..1]. Reolink pushes don't carry it → undefined. */
+  confidence: number().min(0).max(1).optional()
+});
+const NativeObjectDetectionStatusSchema = object({
+  /**
+   * Last observed instance per class. Missing entries mean the class
+   * is supported but nothing has been seen since the provider started.
+   *
+   * MUST be a partial record: providers seed an empty `{}` on cold-start
+   * and write one class at a time as detections arrive. In Zod 4
+   * `z.record(enum, …)` is EXHAUSTIVE (requires every enum key), so a
+   * partial write throws "expected object, received undefined" for every
+   * unseen class. `z.partialRecord` keeps the enum-key narrowing while
+   * allowing the sparse shape the providers actually write.
+   */
+  lastByClass: partialRecord(NativeObjectClassEnum, NativeDetectionSchema.nullable()),
+  /** Classes the firmware is capable of detecting — enumerated at device register. */
+  supportedClasses: array(NativeObjectClassEnum).readonly(),
+  /**
+   * Whether forwarding of onboard AI detections is enabled for this device.
+   * Default true (on cold-start) — detections flow unconditionally before
+   * the toggle is saved, so defaulting true preserves existing behaviour.
+   */
+  enabled: boolean()
+});
+NativeObjectDetectionStatusSchema.extend({
+  /** Required by createRuntimeStateBridge — epoch ms of last refresh. */
+  lastFetchedAt: number()
+});
+({
+  deviceTypes: [DeviceType.Camera],
+  methods: {
+    setEnabled: method(
+      object({ deviceId: number(), enabled: boolean() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    )
+  },
+  events: {
+    onDetected: { data: object({
+      deviceId: number(),
+      detection: NativeDetectionSchema
+    }) }
+  }
+});
+const PrivacyMaskShapeSchema = discriminatedUnion("kind", [
+  MaskRectShapeSchema,
+  MaskPolygonShapeSchema
+]);
+const PrivacyMaskRegionSchema = object({
+  /** Slot id, 0-based. Stable across read/write. */
+  id: number(),
+  /** Whether this zone is active (blanked out by the camera). */
+  enabled: boolean(),
+  shape: PrivacyMaskShapeSchema
+});
+object({
+  enabled: boolean(),
+  /** Active zones (normalized 0..1). Length ≤ maxRegions. */
+  regions: array(PrivacyMaskRegionSchema),
+  lastFetchedAt: number()
+});
+const PrivacyMaskOptionsSchema = object({
+  /** Maximum number of supported zones. */
+  maxRegions: number(),
+  /** Shape kinds this camera accepts — Reolink: ['rect']; Hikvision: ['rect','polygon']. */
+  supportedShapes: array(MaskShapeKindSchema),
+  /** Polygon vertex bounds when 'polygon' is supported (Hikvision: {min:4,max:4}). */
+  polygonVertices: MaskPolygonVerticesSchema.optional()
+});
+const PrivacyMaskPatchSchema = object({
+  enabled: boolean().optional(),
+  regions: array(PrivacyMaskRegionSchema).optional()
+});
+({
+  deviceTypes: [DeviceType.Camera],
+  methods: {
+    getOptions: method(object({ deviceId: number() }), PrivacyMaskOptionsSchema),
+    setMask: method(
+      object({ deviceId: number(), patch: PrivacyMaskPatchSchema }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    )
+  }
+});
 const AutotrackTargetTypeSchema = string().describe("Vendor target string (people/vehicle/pet); empty = camera default");
 const PtzAutotrackSettingsSchema = object({
   targetType: AutotrackTargetTypeSchema,
@@ -8022,7 +8231,8 @@ const SettingsUpdateResultSchema = object({
       object({
         addonId: string(),
         nodeId: string().optional(),
-        overlay: record(string(), unknown()).optional()
+        overlay: record(string(), unknown()).optional(),
+        cap: string().optional()
       }),
       SettingsSchemaWithValuesSchema.nullable()
     ),
@@ -8753,7 +8963,14 @@ const OauthIntegrationDescriptorSchema = object({
   /** 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)
+  allowedRedirectPrefixes: array(string()).min(1),
+  /** Optional public origin (no trailing slash) that this integration's
+   *  issued codes/tokens should carry as the `hubUrl` claim — typically the
+   *  operator-selected external-access endpoint resolved by the addon. When
+   *  present, /api/oauth2/authorize bakes THIS into the code instead of the
+   *  hub-global `publicHubUrl()`, so a forked exporter addon (which can't set
+   *  the hub's env) drives the claim that its cloud Lambda routes back on. */
+  hubUrl: string().optional()
 });
 ({
   methods: {
@@ -9371,7 +9588,20 @@ const WebrtcStreamChoiceSchema = object({
       object({
         deviceId: number().int().nonnegative(),
         target: WebrtcStreamTargetSchema,
-        hints: webrtcClientHintsSchema.optional()
+        hints: webrtcClientHintsSchema.optional(),
+        /**
+         * SERVER-INJECTED — NOT a client hint. The hub layer that holds
+         * the tRPC request context (and therefore the client IP) sets
+         * this to `true` when the viewer's source IP is non-LAN
+         * (4G/CGNAT/internet). The broker then forces TURN-relay-only
+         * ICE for the session so a CGNAT client (which can only offer a
+         * relay candidate) gets a clean relay↔relay media path instead
+         * of werift nominating a dead host/hairpin-srflx pair. LAN
+         * clients leave this absent/false and keep the low-latency
+         * direct (host/srflx) path. Clients MUST NOT send this — the
+         * server overwrites it from the request context.
+         */
+        relayOnly: boolean().optional()
       }),
       object({ sessionId: string(), sdpOffer: string() }),
       { kind: "mutation" }
@@ -9394,7 +9624,22 @@ const WebrtcStreamChoiceSchema = object({
         deviceId: number().int().nonnegative(),
         target: WebrtcStreamTargetSchema.optional(),
         sdpOffer: string(),
-        sessionId: string().optional()
+        sessionId: string().optional(),
+        /**
+         * Force TURN-relay-only ICE for this session. Two kinds of caller
+         * set it:
+         *  - A cloud peer like Alexa's RTCSessionController (reachable
+         *    only via TURN, never our host/srflx behind NAT) passes
+         *    `true` from its own trusted addon context.
+         *  - The hub injects it for browser client-offer viewers from the
+         *    request's source IP (non-LAN ⇒ true), exactly as it does for
+         *    `createSession`.
+         * A LAN/Tailscale browser doing client-offer passthrough leaves it
+         * absent/false so a direct host pair carries full native quality.
+         * Untrusted browser clients MUST NOT send it — the hub overwrites
+         * it from the request context.
+         */
+        relayOnly: boolean().optional()
       }),
       object({ sessionId: string(), sdpAnswer: string() }),
       { kind: "mutation" }
@@ -9408,6 +9653,46 @@ const WebrtcStreamChoiceSchema = object({
       _void(),
       { kind: "mutation" }
     ),
+    /**
+     * Trickle ICE — add a remote (client) ICE candidate to a live session.
+     * 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.
+     */
+    addIceCandidate: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        sessionId: string(),
+        candidate: string(),
+        sdpMid: string().nullable().optional(),
+        sdpMLineIndex: number().int().nullable().optional()
+      }),
+      _void(),
+      { kind: "mutation" }
+    ),
+    /**
+     * Trickle ICE — poll the server's gathered ICE candidates for a session.
+     * The server answers immediately (no gathering wait) and the client polls
+     * this to receive host/srflx/relay candidates as werift gathers them,
+     * adding each to its PeerConnection. Returns all candidates gathered so
+     * far; the client dedupes. `done` flips true once gathering completes.
+     */
+    getIceCandidates: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        sessionId: string()
+      }),
+      object({
+        candidates: array(object({
+          candidate: string(),
+          sdpMid: string().nullable(),
+          sdpMLineIndex: number().int().nullable()
+        })),
+        done: boolean()
+      }),
+      { kind: "query" }
+    ),
     closeSession: method(
       object({
         deviceId: number().int().nonnegative(),
@@ -11083,6 +11368,16 @@ const UpdateConfigInput = object({
 ({
   deviceTypes: [DeviceType.Camera]
 });
+const cameraPipelineConfigCapability = {
+  name: "camera-pipeline-config",
+  scope: "device",
+  mode: "singleton",
+  kind: "wrapper",
+  defaultActive: true,
+  deviceTypes: [DeviceType.Camera],
+  exposesDeviceSettings: true,
+  methods: {}
+};
 const TrackStateSchema = _enum(["new", "entered", "left", "moving", "idle"]);
 const EventKindSchema = _enum(["motion", "object", "audio"]);
 const TrackPositionSchema = object({
@@ -11910,36 +12205,28 @@ const IntercomStatusSchema = object({
     }) }
   }
 });
-const NativeObjectClassEnum = _enum([
-  "person",
-  "vehicle",
-  "animal",
-  "face",
-  "package",
-  "other"
-]);
-const NativeDetectionSchema = object({
-  class: NativeObjectClassEnum,
-  timestamp: number(),
-  /** Firmware-provided confidence [0..1]. Reolink pushes don't carry it → undefined. */
-  confidence: number().min(0).max(1).optional()
-});
-object({
-  /**
-   * Last observed instance per class. Undefined entries mean the class
-   * is supported but nothing has been seen since the provider started.
-   */
-  lastByClass: record(NativeObjectClassEnum, NativeDetectionSchema.nullable()),
-  /** Classes the firmware is capable of detecting — enumerated at device register. */
-  supportedClasses: array(NativeObjectClassEnum).readonly()
+const CamStreamDescriptorSchema = object({
+  camStreamId: string().min(1),
+  kind: CamStreamKindSchema,
+  url: string().optional(),
+  codec: string().optional(),
+  resolution: CamStreamResolutionSchema.optional(),
+  fps: number().positive().optional(),
+  label: string().optional(),
+  /** Device-level features (e.g. `battery-operated`) — drives broker policy. */
+  deviceFeatures: array(string()).optional(),
+  /** Eligible for automatic profile assignment. Absent = `true`. */
+  autoEligible: boolean().optional(),
+  /** Transport-specific opaque metadata (e.g. rfc4571 SDP). */
+  metadata: record(string(), unknown()).optional()
 });
 ({
   deviceTypes: [DeviceType.Camera],
-  events: {
-    onDetected: { data: object({
-      deviceId: number(),
-      detection: NativeDetectionSchema
-    }) }
+  methods: {
+    getCatalog: method(
+      object({ deviceId: number().int().nonnegative() }),
+      array(CamStreamDescriptorSchema).readonly()
+    )
   }
 });
 const ModelFormatSchema = _enum(MODEL_FORMATS);
@@ -12807,6 +13094,18 @@ const TopologyProcessSchema = object({
   services: array(TopologyServiceSchema).readonly(),
   groupId: string().optional()
 });
+const TopologyCategoryAddonSchema = object({
+  id: string(),
+  status: string(),
+  cpuPercent: number(),
+  memoryRss: number()
+});
+const TopologyCategorySchema = object({
+  category: string(),
+  total: number(),
+  healthy: number(),
+  addons: array(TopologyCategoryAddonSchema).readonly()
+});
 const TopologyNodeSchema = object({
   id: string(),
   name: string(),
@@ -12831,7 +13130,15 @@ const TopologyNodeSchema = object({
       status: string()
     })
   ).readonly(),
-  processes: array(TopologyProcessSchema).readonly()
+  processes: array(TopologyProcessSchema).readonly(),
+  categories: array(TopologyCategorySchema).readonly()
+});
+const CapUsageEdgeSchema = object({
+  callerAddonId: string(),
+  providerAddonId: string(),
+  capName: string(),
+  callsPerMin: number(),
+  lastCallAtMs: number()
 });
 const ClusterAddonNodeDeploymentSchema = object({
   nodeId: string(),
@@ -12915,13 +13222,7 @@ const RenameNodeResultSchema = object({
       object({
         windowSeconds: number().int().positive().max(300).default(60)
       }),
-      array(object({
-        callerAddonId: string(),
-        providerAddonId: string(),
-        capName: string(),
-        callsPerMin: number(),
-        lastCallAtMs: number()
-      })).readonly(),
+      array(CapUsageEdgeSchema).readonly(),
       { auth: "admin" }
     ),
     /**
@@ -13133,7 +13434,8 @@ const PackageUpdateSchema = object({
   currentVersion: string(),
   latestVersion: string(),
   category: _enum(["addon", "core"]),
-  requiresRestart: boolean()
+  requiresRestart: boolean(),
+  isSystem: boolean()
 });
 const PackageVersionInfoSchema = object({
   version: string(),
@@ -13166,6 +13468,42 @@ const UpdateFrameworkPackageResultSchema = object({
   /** Ms-epoch the server scheduled its self-restart. */
   restartingAt: number()
 });
+const BulkUpdateItemStatusSchema = _enum([
+  "queued",
+  "updating",
+  "done",
+  "done-pending-restart",
+  "failed"
+]);
+const BulkUpdateItemSchema = object({
+  name: string(),
+  isSystem: boolean(),
+  fromVersion: string(),
+  toVersion: string(),
+  status: BulkUpdateItemStatusSchema,
+  error: string().optional(),
+  startedAtMs: number().optional(),
+  completedAtMs: number().optional()
+});
+const BulkUpdatePhaseSchema = _enum([
+  "regular",
+  "system",
+  "restarting",
+  "finalizing"
+]);
+const BulkUpdateStateSchema = object({
+  id: string(),
+  nodeId: string(),
+  startedAtMs: number(),
+  completedAtMs: number().optional(),
+  total: number(),
+  completed: number(),
+  failed: number(),
+  current: string().nullable(),
+  phase: BulkUpdatePhaseSchema,
+  cancelled: boolean(),
+  items: array(BulkUpdateItemSchema).readonly()
+});
 const FrameworkPackageStatusSchema = object({
   packageName: string(),
   currentVersion: string(),
@@ -13303,7 +13641,7 @@ const CustomActionInputSchema = object({
     getLastRestart: method(
       _void(),
       object({
-        kind: _enum(["framework-update", "manual", "system"]),
+        kind: _enum(["framework-update", "manual", "system", "framework-bulk-update"]),
         packageName: string().optional(),
         fromVersion: string().optional(),
         toVersion: string().optional(),
@@ -13393,11 +13731,70 @@ const CustomActionInputSchema = object({
     updateFrameworkPackage: method(
       object({
         packageName: string().min(1),
-        version: string().optional()
+        version: string().optional(),
+        deferRestart: boolean().optional()
       }),
       UpdateFrameworkPackageResultSchema,
       { kind: "mutation", auth: "admin" }
     ),
+    /**
+     * Kicks off a server-side bulk update operation and returns the bulk
+     * id immediately. The operation runs asynchronously; observe progress
+     * via the `AddonsBulkUpdateProgress` event or `getBulkUpdateState`.
+     * Items with `isSystem: true` use `deferRestart` — the hub restarts
+     * ONCE at the end of the system phase, after all system packages are
+     * installed.
+     *
+     * `items[].version` is REQUIRED — callers must pass the resolved
+     * version from `listUpdates`. There is no `'latest'` default here
+     * (unlike `updatePackage`) to guarantee deterministic bulk rolls.
+     */
+    startBulkUpdate: method(
+      object({
+        nodeId: string(),
+        items: array(object({
+          name: string(),
+          version: string(),
+          isSystem: boolean()
+        })).readonly()
+      }),
+      object({ id: string() }),
+      { kind: "mutation", auth: "admin" }
+    ),
+    /**
+     * Returns the current state of a bulk update by id.
+     * Returns `null` if the id is unknown or has been auto-cleaned
+     * (5 minutes after `completedAt` the record is evicted from memory).
+     */
+    getBulkUpdateState: method(
+      object({ id: string() }),
+      BulkUpdateStateSchema.nullable(),
+      { auth: "admin" }
+    ),
+    /**
+     * Cancels an in-flight bulk update. The update loop exits after the
+     * currently-processing item completes — cancellation is not
+     * instantaneous. Has no effect once the `restarting` phase has been
+     * entered (the hub is already shutting down at that point).
+     * Returns `{ cancelled: false }` if the id is unknown, the operation
+     * has already completed, or the `restarting` phase is active.
+     */
+    cancelBulkUpdate: method(
+      object({ id: string() }),
+      object({ cancelled: boolean() }),
+      { kind: "mutation", auth: "admin" }
+    ),
+    /**
+     * Lists all currently active (non-completed) bulk updates.
+     * If `nodeId` is provided, filters to only bulk updates targeting
+     * that node. Useful for restoring an in-progress banner on a fresh
+     * page load when the UI reconnects mid-operation.
+     */
+    listActiveBulkUpdates: method(
+      object({ nodeId: string().optional() }),
+      array(BulkUpdateStateSchema).readonly(),
+      { auth: "admin" }
+    ),
     getVersions: method(
       object({ name: string() }),
       array(PackageVersionInfoSchema).readonly()
@@ -13525,6 +13922,7 @@ var EventCategory = /* @__PURE__ */ ((EventCategory2) => {
   EventCategory2["StreamBrokerOnCamStreamDemand"] = "stream-broker.onCamStreamDemand";
   EventCategory2["StreamBrokerOnCamStreamIdle"] = "stream-broker.onCamStreamIdle";
   EventCategory2["StreamBrokerOnRequestStreamSourceRefresh"] = "stream-broker.onRequestStreamSourceRefresh";
+  EventCategory2["StreamParamsChanged"] = "stream-params.changed";
   EventCategory2["DeviceStateChanged"] = "device.state-changed";
   EventCategory2["BatteryOnStatusChanged"] = "battery.onStatusChanged";
   EventCategory2["DoorbellOnPressed"] = "doorbell.onPressed";
@@ -13572,6 +13970,7 @@ var EventCategory = /* @__PURE__ */ ((EventCategory2) => {
   EventCategory2["NetworkTunnelStarted"] = "network.tunnel.started";
   EventCategory2["NetworkTunnelStopped"] = "network.tunnel.stopped";
   EventCategory2["LocalNetworkChanged"] = "network.local.changed";
+  EventCategory2["MeshNetworkChanged"] = "network.mesh.changed";
   EventCategory2["BackupCompleted"] = "backup.completed";
   EventCategory2["BackupRestored"] = "backup.restored";
   EventCategory2["NotificationDispatched"] = "notification.dispatched";
@@ -13582,6 +13981,7 @@ var EventCategory = /* @__PURE__ */ ((EventCategory2) => {
   EventCategory2["DeviceAwake"] = "device.awake";
   EventCategory2["DeviceSleeping"] = "device.sleeping";
   EventCategory2["RetentionCleanup"] = "retention.cleanup";
+  EventCategory2["AddonsBulkUpdateProgress"] = "addons.bulk-update-progress";
   return EventCategory2;
 })(EventCategory || {});
 function isEvent(event2, category) {
@@ -13734,7 +14134,7 @@ class BaseAddon {
   }
   // ── Settings schemas (override to provide UI) ─────────────────────────
   /** Override to provide global-level settings UI schema. */
-  globalSettingsSchema() {
+  globalSettingsSchema(_cap) {
     return null;
   }
   /** Override to provide device-level settings UI schema. */
@@ -13748,8 +14148,8 @@ class BaseAddon {
   // blob and every addon used exactly one of them; the distinction was
   // never semantically load-bearing. `global` won because it was the
   // widely-used one and the name reads naturally (per-node addon config).
-  async getGlobalSettings(overlay) {
-    const schema = this.globalSettingsSchema();
+  async getGlobalSettings(overlay, cap) {
+    const schema = this.globalSettingsSchema(cap);
     if (!schema) return { sections: [] };
     const raw = await this._ctx?.settings?.readAddonStore() ?? {};
     return hydrateSchema(schema, overlay ? { ...raw, ...overlay } : raw);
@@ -14168,6 +14568,14 @@ class ReadinessRegistry {
         cleanup();
         reject(new ReadinessTimeoutError(capName, scope, this.now() - start));
       }, timeoutMs);
+      const PENDING_LOG_INTERVAL_MS = 3e4;
+      const pendingLogTimer = setInterval(() => {
+        if (settled) return;
+        this.logger?.warn(
+          `readiness: still awaiting ${capName} (${scopeKey(scope)}) after ${this.now() - start}ms`
+        );
+      }, PENDING_LOG_INTERVAL_MS);
+      if (typeof pendingLogTimer.unref === "function") pendingLogTimer.unref();
       const onAbort = () => {
         if (settled) return;
         settled = true;
@@ -14178,6 +14586,7 @@ class ReadinessRegistry {
       function cleanup() {
         unsubscribe();
         if (timer !== null) clearTimeout(timer);
+        clearInterval(pendingLogTimer);
         opts.signal?.removeEventListener("abort", onAbort);
       }
     });
@@ -14731,6 +15140,8 @@ function balanceAudio(input) {
 }
 const POLL_INTERVAL_MS = 200;
 const PULL_MAX_COUNT = 8;
+const RESUBSCRIBE_AFTER_FAILURES = 2;
+const RESUBSCRIBE_THROTTLE_TICKS = 5;
 async function startAudioChunkPoller(options) {
   const { api, brokerId, tag, onChunk, logger } = options;
   let subscriptionId;
@@ -14748,6 +15159,19 @@ async function startAudioChunkPoller(options) {
   }
   let stopped = false;
   let timer;
+  let consecutiveFailures = 0;
+  const resubscribe = async () => {
+    try {
+      const result = await api.streamBroker.subscribeAudioChunks.mutate({ brokerId, tag });
+      subscriptionId = result.subscriptionId;
+      logger.info("audio-chunk poller: re-subscribed after broker outage", {
+        meta: { brokerId, tag, subscriptionId, afterFailures: consecutiveFailures }
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  };
   const tick = async () => {
     if (stopped) return;
     try {
@@ -14755,14 +15179,24 @@ async function startAudioChunkPoller(options) {
         subscriptionId,
         maxCount: PULL_MAX_COUNT
       });
+      if (consecutiveFailures > 0) {
+        logger.info("audio-chunk poller: stream recovered", { meta: { brokerId, subscriptionId } });
+      }
+      consecutiveFailures = 0;
       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) }
-      });
+      consecutiveFailures += 1;
+      if (consecutiveFailures === 1) {
+        logger.warn("audio-chunk poller: pullAudioChunks failed — attempting recovery", {
+          meta: { brokerId, subscriptionId, error: errMsg(err) }
+        });
+      }
+      if (!stopped && consecutiveFailures >= RESUBSCRIBE_AFTER_FAILURES && (consecutiveFailures - RESUBSCRIBE_AFTER_FAILURES) % RESUBSCRIBE_THROTTLE_TICKS === 0) {
+        await resubscribe();
+      }
     }
     if (!stopped) {
       timer = setTimeout(() => void tick(), POLL_INTERVAL_MS);
@@ -14783,6 +15217,18 @@ async function startAudioChunkPoller(options) {
     });
   };
 }
+function desiredDeviceIdsFromSlots(slots) {
+  const result = /* @__PURE__ */ new Set();
+  for (const slot of slots) {
+    if (slot.status !== "unassigned" && slot.sourceCamStreamId !== null) {
+      result.add(slot.deviceId);
+    }
+  }
+  return result;
+}
+function computeDispatchGap(desired, known) {
+  return [...desired].filter((id) => !known.has(id));
+}
 const PHASE_MODE_VALUES = /* @__PURE__ */ new Set([
   "disabled",
   "always-on",
@@ -14794,6 +15240,7 @@ function isPipelinePhaseMode(v) {
 const PREFERRED_AGENT_SETTING = "preferredAgent";
 const AUDIO_NODE_SETTING = "audioNodeId";
 const DEFAULT_BROKER_CALL_TIMEOUT_MS = 5e3;
+const RECONCILE_DEBOUNCE_MS = 200;
 const AGENT_SETTINGS_KEY = "agentSettings";
 const CAMERA_SETTINGS_KEY = "cameraSettings";
 const TEMPLATES_KEY = "templates";
@@ -14945,6 +15392,12 @@ class PipelineOrchestratorAddon extends BaseAddon {
   loadShedState = /* @__PURE__ */ new Map();
   /** Timer for the auto-resume sweep. */
   loadShedResumeTimer = null;
+  /** Pending `scheduleReconcile` debounce timer. */
+  reconcileTimer = null;
+  /** True while `reconcileDispatch` is awaiting the RPC round-trip. */
+  reconcileInFlight = false;
+  /** Set to true when a reconcile is requested while one is already in-flight; triggers a follow-up pass. */
+  reconcileRerunRequested = false;
   initTimestamp = 0;
   constructor() {
     super({});
@@ -15003,6 +15456,7 @@ class PipelineOrchestratorAddon extends BaseAddon {
             meta: { error: msg }
           });
         });
+        this.scheduleReconcile();
       }
     );
     this.watchCapability(["pipeline-executor", "analysis-pipeline"], {
@@ -15100,6 +15554,7 @@ class PipelineOrchestratorAddon extends BaseAddon {
             });
           }, PROFILE_SLOTS_DEBOUNCE_MS)
         );
+        this.scheduleReconcile();
       }
     );
     this.unsubDeviceUnregistered = this.ctx.eventBus.subscribe(
@@ -15279,9 +15734,15 @@ class PipelineOrchestratorAddon extends BaseAddon {
         }
       ]
     };
+    this.scheduleReconcile();
     return {
       providers: [
         { capability: pipelineOrchestratorCapability, provider: this },
+        // D12 re-home: the per-device settings contribution (motion/pipeline
+        // tabs + zones top-tab) rides this device-scoped defaultActive wrapper
+        // so it auto-binds to every camera and the binding-driven aggregate
+        // invokes it. `this` already implements the three contribution methods.
+        { capability: cameraPipelineConfigCapability, provider: this },
         { capability: zonesCapability, provider: this.zonesProvider },
         { capability: zoneRulesCapability, provider: this.zoneRulesProvider },
         { capability: addonWidgetsSourceCapability, provider: widgetsProvider }
@@ -15406,6 +15867,10 @@ class PipelineOrchestratorAddon extends BaseAddon {
       this.profileSlotTimers.clear();
       this.profileSlotTimers = null;
     }
+    if (this.reconcileTimer !== null) {
+      clearTimeout(this.reconcileTimer);
+      this.reconcileTimer = null;
+    }
     this.unsubDeviceRegistered?.();
     this.unsubDeviceRegistered = null;
     this.unsubDeviceUnregistered?.();
@@ -15481,7 +15946,7 @@ class PipelineOrchestratorAddon extends BaseAddon {
       );
     this.cameraConfigs.set(runnerConfig.deviceId, runnerConfig);
     const cfg = this.globalSettings ?? {};
-    const minThreshold = typeof cfg.fpsMinThreshold === "number" ? cfg.fpsMinThreshold : 3;
+    const minThreshold = typeof cfg.fpsMinThreshold === "number" ? cfg.fpsMinThreshold : PipelineOrchestratorAddon.DEFAULT_FPS_MIN_THRESHOLD;
     const windowMs = typeof cfg.fpsLowWindowMs === "number" && cfg.fpsLowWindowMs > 0 ? cfg.fpsLowWindowMs : PipelineOrchestratorAddon.DEFAULT_FPS_LOW_WINDOW_MS;
     if (minThreshold > 0 && this.initTimestamp && Date.now() - this.initTimestamp > 3e4) {
       const now = Date.now();
@@ -15924,7 +16389,7 @@ class PipelineOrchestratorAddon extends BaseAddon {
       const api = ctx?.api;
       if (!api) continue;
       try {
-        const load = await api.pipelineRunner.getLocalLoad.query({ nodeId });
+        const load = await this.queryLocalLoadBounded(nodeId);
         loads.push(load);
       } catch (err) {
         const msg = errMsg(err);
@@ -15949,6 +16414,53 @@ class PipelineOrchestratorAddon extends BaseAddon {
     }
     this.cachedAgentLoad = next;
   }
+  /**
+   * Per-node `getLocalLoad` budget (ms). A WEDGED runner — transport up
+   * enough to stay in the service registry, but whose `broker.call` neither
+   * resolves nor rejects (observed live as
+   * "[brokerTransportLink] still awaiting … after 18min") — would otherwise
+   * stall `collectAgentLoad`, and through it `dispatchCamera` →
+   * `startDetection` for EVERY camera, indefinitely: the transport link does
+   * not abort an in-flight `broker.call` (see trpc-links.ts), so neither the
+   * try/catch nor an AbortSignal can unstick it. Tunable via the
+   * `agentLoadTimeoutMs` global setting; the default is generous enough that
+   * a healthy-but-slow node is never falsely skipped (the pinned-discovery
+   * window alone is 2s).
+   */
+  static DEFAULT_AGENT_LOAD_TIMEOUT_MS = 4e3;
+  agentLoadBudgetMs() {
+    const cfg = this.globalSettings ?? {};
+    const value = cfg.agentLoadTimeoutMs;
+    return typeof value === "number" && value > 0 ? value : PipelineOrchestratorAddon.DEFAULT_AGENT_LOAD_TIMEOUT_MS;
+  }
+  /**
+   * `getLocalLoad` for one runner node, bounded by `agentLoadBudgetMs`. On
+   * timeout it rejects so `collectAgentLoad`'s catch treats the node exactly
+   * like an offline one (logged at debug, skipped). The underlying query is
+   * left to settle on its own — Moleculer rejects it when the node
+   * disconnects — rather than leaking an unbounded await into the dispatch
+   * path.
+   */
+  async queryLocalLoadBounded(nodeId) {
+    const api = this.ctx?.api;
+    if (!api) throw new Error("queryLocalLoadBounded: addon not initialized");
+    const budgetMs = this.agentLoadBudgetMs();
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+      timer = setTimeout(
+        () => reject(new Error(`getLocalLoad exceeded ${budgetMs}ms budget for ${nodeId}`)),
+        budgetMs
+      );
+    });
+    try {
+      return await Promise.race([
+        api.pipelineRunner.getLocalLoad.query({ nodeId }),
+        timeout
+      ]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
   async readPreferredAgent(deviceId) {
     const ctx = this.ctx;
     if (!ctx?.settings) return null;
@@ -16246,6 +16758,44 @@ class PipelineOrchestratorAddon extends BaseAddon {
       "audio-analyzer ready — node now available for audio dispatch",
       { tags: { nodeId }, meta: { epoch: t.epoch } }
     );
+    await this.reattachAudioForNode(nodeId);
+    this.scheduleReconcile();
+  }
+  /**
+   * Re-establish audio subscriptions for every camera whose audio is routed
+   * to `nodeId`, after that node's audio-analyzer (re)started. Mirrors the
+   * audio block in `startDetection` (drop prior sub, re-subscribe, keep only
+   * if detection is active). Idempotent.
+   */
+  async reattachAudioForNode(nodeId) {
+    for (const [deviceId, audioNode] of this.audioNodeByDevice) {
+      if (audioNode !== nodeId) continue;
+      const config2 = this.cameraConfigs.get(deviceId);
+      if (!config2) continue;
+      const prior = this.audioSubscriptions.get(deviceId);
+      if (prior) {
+        try {
+          prior();
+        } catch {
+        }
+        this.audioSubscriptions.delete(deviceId);
+      }
+      try {
+        const unsub = await this.subscribeAudioStream(deviceId, config2);
+        if (unsub) {
+          if (this.activeDetections.has(deviceId)) {
+            this.audioSubscriptions.set(deviceId, unsub);
+          } else {
+            unsub();
+          }
+        }
+      } catch (err) {
+        this.ctx.logger.error("audio re-attach on analyzer readiness failed", {
+          tags: { deviceId, nodeId },
+          meta: { error: errMsg(err) }
+        });
+      }
+    }
   }
   /**
    * Act on a `detection-pipeline` transition: on `ready` with a new
@@ -16317,6 +16867,7 @@ class PipelineOrchestratorAddon extends BaseAddon {
           });
         });
       }, 3e3);
+      this.scheduleReconcile();
     } catch (err) {
       this.ctx.logger.debug("readiness seed+redispatch failed", {
         tags: { nodeId },
@@ -16361,6 +16912,75 @@ class PipelineOrchestratorAddon extends BaseAddon {
       }
     }
   }
+  // ── Dispatch reconcile ───────────────────────────────────────────────
+  /**
+   * Coalesce bursts of topology/slot-change signals into a single
+   * `reconcileDispatch` pass. Mirrors `scheduleRehydrate` in
+   * `packages/kernel/src/moleculer/readiness-context.ts`.
+   */
+  scheduleReconcile() {
+    if (this.reconcileTimer !== null) clearTimeout(this.reconcileTimer);
+    this.reconcileTimer = setTimeout(() => {
+      this.reconcileTimer = null;
+      void this.reconcileDispatch();
+    }, RECONCILE_DEBOUNCE_MS);
+  }
+  /**
+   * RPC snapshot-reconcile: pull the current broker fleet over
+   * `listAllProfileSlots`, diff against `cameraConfigs`, and dispatch
+   * the gap via `handleDeviceRegistered`.
+   *
+   * Additive only — never retracts or re-dispatches a known device.
+   * Guards against re-entrant calls: a trailing request schedules one
+   * extra pass after the in-flight one completes.
+   */
+  async reconcileDispatch() {
+    if (this.reconcileInFlight) {
+      this.reconcileRerunRequested = true;
+      return;
+    }
+    this.reconcileInFlight = true;
+    try {
+      const api = this.api;
+      if (!api) {
+        this.ctx.logger.debug(
+          "dispatch reconcile skipped — ctx.api not yet available"
+        );
+        return;
+      }
+      let slots;
+      try {
+        slots = await api.streamBroker.listAllProfileSlots.query();
+      } catch (err) {
+        this.ctx.logger.debug("dispatch reconcile skipped — stream-broker not ready", {
+          meta: { error: errMsg(err) }
+        });
+        return;
+      }
+      const desired = desiredDeviceIdsFromSlots(slots);
+      const known = new Set(this.cameraConfigs.keys());
+      const gap = computeDispatchGap(desired, known);
+      this.ctx.logger.info("dispatch reconcile", {
+        meta: { desired: desired.size, known: known.size, gap }
+      });
+      for (const deviceId of gap) {
+        try {
+          await this.handleDeviceRegistered(deviceId);
+        } catch (err) {
+          this.ctx.logger.warn("dispatch reconcile: handleDeviceRegistered failed", {
+            tags: { deviceId },
+            meta: { error: errMsg(err) }
+          });
+        }
+      }
+    } finally {
+      this.reconcileInFlight = false;
+      if (this.reconcileRerunRequested) {
+        this.reconcileRerunRequested = false;
+        this.scheduleReconcile();
+      }
+    }
+  }
   // ── Capability bindings (cap methods) ────────────────────────────────
   async getCapabilityBindings(input) {
     const ctx = this.ctx;
@@ -17142,11 +17762,11 @@ class PipelineOrchestratorAddon extends BaseAddon {
               key: "fpsMinThreshold",
               type: "slider",
               label: "Min FPS Threshold",
-              description: "If a camera sustains FPS below this value for the duration set by 'Low FPS Window' below, it is paused (load-shed) and new dispatches are blocked. Auto-resumes with exponential backoff. 0 = disabled.",
+              description: "Per-camera low-FPS load shedding. If a camera sustains FPS below this value for the duration set by 'Low FPS Window' below, it is paused (load-shed) and new dispatches are blocked. Auto-resumes with exponential backoff. 0 = disabled (default) — a single slow camera is never detached; only capacity-based placement applies.",
               min: 0,
               max: 10,
               step: 1,
-              default: 3,
+              default: PipelineOrchestratorAddon.DEFAULT_FPS_MIN_THRESHOLD,
               showValue: true,
               unit: "fps"
             },
@@ -17443,8 +18063,41 @@ class PipelineOrchestratorAddon extends BaseAddon {
         }
       ]
     };
+    const hasNativeObjectDetection = await this.deviceHasNativeObjectDetectionCap(input.deviceId);
+    const nativeObjectDetectionSections = [];
+    if (hasNativeObjectDetection) {
+      let nativeObjectDetectionEnabled = true;
+      try {
+        const status = await this.ctx.api?.nativeObjectDetection.getStatus.query({
+          deviceId: input.deviceId
+        });
+        if (status !== void 0 && status !== null && "enabled" in status) {
+          nativeObjectDetectionEnabled = Boolean(
+            status.enabled
+          );
+        }
+      } catch {
+      }
+      nativeObjectDetectionSections.push({
+        id: "onboard-object-detection",
+        title: "Onboard Object Detection",
+        tab: "motion",
+        order: 10,
+        fields: [
+          {
+            type: "boolean",
+            key: "nativeObjectDetectionEnabled",
+            label: "Use onboard object detection",
+            description: "When enabled, AI detections from the camera firmware are forwarded to the system notification and recording pipeline. Onboard motion events are never suppressed.",
+            default: true,
+            immediate: true,
+            value: nativeObjectDetectionEnabled
+          }
+        ]
+      });
+    }
     return {
-      sections: [...baseSections, zonesSection]
+      sections: [...baseSections, zonesSection, ...nativeObjectDetectionSections]
     };
   }
   // `getCameraPipelineWithFallback` was a thin wrapper over
@@ -17505,11 +18158,25 @@ class PipelineOrchestratorAddon extends BaseAddon {
   }
   async applyDeviceSettingsPatch(input) {
     const { pipelinePatch, rest } = this.splitPipelinePatch(input.patch);
+    const { nativeObjectDetectionEnabled, ...orchestratorRest } = rest;
+    if (nativeObjectDetectionEnabled !== void 0) {
+      try {
+        await this.ctx.api?.nativeObjectDetection.setEnabled.mutate({
+          deviceId: input.deviceId,
+          enabled: Boolean(nativeObjectDetectionEnabled)
+        });
+      } catch (err) {
+        this.ctx.logger.warn("Failed to route nativeObjectDetectionEnabled to cap", {
+          tags: { deviceId: input.deviceId },
+          meta: { error: err instanceof Error ? err.message : String(err) }
+        });
+      }
+    }
     if (Object.keys(pipelinePatch).length > 0) {
       await this.applyPipelinePatch(input.deviceId, pipelinePatch);
     }
-    if (Object.keys(rest).length > 0) {
-      await this.writeDeviceOrchestratorSettings(input.deviceId, rest);
+    if (Object.keys(orchestratorRest).length > 0) {
+      await this.writeDeviceOrchestratorSettings(input.deviceId, orchestratorRest);
     }
     return { success: true };
   }
@@ -17684,6 +18351,23 @@ class PipelineOrchestratorAddon extends BaseAddon {
       return false;
     }
   }
+  /**
+   * Returns true when the camera has a native `native-object-detection`
+   * binding (i.e. the driver registered the cap). Used to gate the
+   * "Use onboard object detection" toggle in `getDeviceSettingsContribution`.
+   */
+  async deviceHasNativeObjectDetectionCap(deviceId) {
+    const api = this.api;
+    if (!api) return false;
+    try {
+      const bindings = await api.deviceManager.getBindings.query({ deviceId });
+      return bindings.entries.some(
+        (e) => e.kind === "native" && e.capName === "native-object-detection"
+      );
+    } catch {
+      return false;
+    }
+  }
   async resolveDeviceDetectionSettings(deviceId) {
     const ctx = this.ctx;
     if (!ctx?.settings) {
@@ -17748,6 +18432,8 @@ class PipelineOrchestratorAddon extends BaseAddon {
       const detectionMode = typeof userDetectionMode === "string" && isPipelinePhaseMode(userDetectionMode) ? userDetectionMode : profile?.defaults.detectionMode ?? "on-motion";
       const userAudioMode = raw["audioMode"];
       const audioMode = typeof userAudioMode === "string" && isPipelinePhaseMode(userAudioMode) ? userAudioMode : profile?.defaults.audioMode ?? "always-on";
+      const userOnboardMotionDrivesAnalyzer = raw["onboardMotionDrivesAnalyzer"];
+      const onboardMotionDrivesAnalyzer = typeof userOnboardMotionDrivesAnalyzer === "boolean" ? userOnboardMotionDrivesAnalyzer : true;
       return {
         motionDetectionEnabled,
         pipelineEnabled,
@@ -17758,7 +18444,8 @@ class PipelineOrchestratorAddon extends BaseAddon {
         detectionFps: mustNumber("detectionFps"),
         motionCooldownMs: mustNumber("motionCooldownMs"),
         detectionMode,
-        audioMode
+        audioMode,
+        onboardMotionDrivesAnalyzer
       };
     } catch (err) {
       const msg = errMsg(err);
@@ -17866,7 +18553,8 @@ class PipelineOrchestratorAddon extends BaseAddon {
       motionCooldownMs: resolved.motionCooldownMs,
       audioStreamId: void 0,
       detectionMode: resolved.detectionMode,
-      audioMode: resolved.audioMode
+      audioMode: resolved.audioMode,
+      onboardMotionDrivesAnalyzer: resolved.onboardMotionDrivesAnalyzer
     };
   }
   /**
@@ -17901,7 +18589,8 @@ class PipelineOrchestratorAddon extends BaseAddon {
       audio: pipelineConfig.audio ?? null,
       zones,
       detectionMode: config2.detectionMode,
-      audioMode: config2.audioMode
+      audioMode: config2.audioMode,
+      onboardMotionDrivesAnalyzer: config2.onboardMotionDrivesAnalyzer
     };
     let dispatchedNodeId = null;
     try {
@@ -18086,6 +18775,7 @@ class PipelineOrchestratorAddon extends BaseAddon {
     if (a.detectionFps !== b.detectionFps) return false;
     if (a.motionCooldownMs !== b.motionCooldownMs) return false;
     if (a.audioStreamId !== b.audioStreamId) return false;
+    if (a.onboardMotionDrivesAnalyzer !== b.onboardMotionDrivesAnalyzer) return false;
     if (a.motionSources.length !== b.motionSources.length) return false;
     for (const s of a.motionSources) if (!b.motionSources.includes(s)) return false;
     return true;
@@ -18175,9 +18865,20 @@ class PipelineOrchestratorAddon extends BaseAddon {
    * across recoveries.
    */
   static DEFAULT_FPS_LOW_WINDOW_MS = 6e4;
+  /**
+   * Default min-FPS threshold for the per-camera low-fps load shedder.
+   *
+   * `0` = DISABLED by default: a single slow camera (e.g. an on-motion
+   * camera idling at <1 fps between motion events) must NOT be detached or
+   * block new dispatches. Capacity-based assignment (`collectAgentLoad` +
+   * `balance()`, the "high-water" placement logic) is independent of this
+   * and stays active. Operators can re-enable per-camera shedding by setting
+   * a positive `fpsMinThreshold` in global settings.
+   */
+  static DEFAULT_FPS_MIN_THRESHOLD = 0;
   enforceLoadManagement(deviceId, metrics) {
     const cfg = this.globalSettings ?? {};
-    const threshold = typeof cfg.fpsMinThreshold === "number" ? cfg.fpsMinThreshold : 3;
+    const threshold = typeof cfg.fpsMinThreshold === "number" ? cfg.fpsMinThreshold : PipelineOrchestratorAddon.DEFAULT_FPS_MIN_THRESHOLD;
     const windowMs = typeof cfg.fpsLowWindowMs === "number" && cfg.fpsLowWindowMs > 0 ? cfg.fpsLowWindowMs : PipelineOrchestratorAddon.DEFAULT_FPS_LOW_WINDOW_MS;
     if (threshold <= 0) return;
     if (metrics.phase !== "active") return;
@@ -18297,7 +18998,7 @@ class PipelineOrchestratorAddon extends BaseAddon {
   async handleInferenceResult(payload) {
     const ctx = this.ctx;
     if (!ctx) return;
-    const { deviceId, frame, frameHandle } = payload;
+    const { deviceId, frame, frameHandle, capturedAt } = payload;
     if (frame.detections.length === 0) return;
     this.ctx.eventBus.emit({
       id: `detection-${deviceId}-${Date.now()}`,
@@ -18305,8 +19006,10 @@ class PipelineOrchestratorAddon extends BaseAddon {
       source: { type: "device", id: deviceId, nodeId: "hub", addonId: "pipeline-orchestrator", deviceId },
       timestamp: /* @__PURE__ */ new Date(),
       // Forward the upstream shm-ring `frameHandle` so post-analysis
-      // consumers (Task 8) can resolve the original frame zero-copy.
-      data: { frame, analysisResults: [], frameHandle }
+      // consumers (Task 8) can resolve the original frame zero-copy, and
+      // `capturedAt` (shm-commit wall-clock) so a UI/probe consumer can
+      // measure true frame-capture → delivery latency.
+      data: { frame, analysisResults: [], frameHandle, ...typeof capturedAt === "number" ? { capturedAt } : {} }
     });
   }
   /**
@@ -18432,8 +19135,8 @@ class PipelineOrchestratorAddon extends BaseAddon {
         }
         try {
           const byteLength = chunk.data.byteLength;
-          const ab = new ArrayBuffer(byteLength);
-          new Uint8Array(ab).set(
+          const data = new Uint8Array(byteLength);
+          data.set(
             new Uint8Array(
               chunk.data.buffer,
               chunk.data.byteOffset,
@@ -18441,7 +19144,7 @@ class PipelineOrchestratorAddon extends BaseAddon {
             )
           );
           const audioChunkInput = {
-            data: new Float32Array(ab, 0, byteLength / 4),
+            data,
             sampleRate: chunk.sampleRate,
             channels: chunk.channels,
             timestamp: chunk.timestamp,