anchor.diff:       (b cl-rabbit:queue-bind cl-rabbit-async:async-queue-bind)
        (a add-new-channel-binding add-new-channel-binding-async))
       (user channels services)
  -  (destructuring-bind (&key content-p user-state-p user-notifications-p unread-p channel-updates-p) services
  +  (destructuring-bind (&key
  +                         content-p user-state-p user-notifications-p
  +                         unread-p channel-updates-p slashcommand-error-p)
  +      services
       (when (and (not content-p)
                  (not user-state-p)
                  (not user-notifications-p)
                  (not unread-p)
  -               (not channel-updates-p))
  +               (not channel-updates-p)
  +               (not slashcommand-error-p))
         (error "At least one service must be enabled"))
  -    (let ((uid (potato.core:ensure-user-id user))
  -          (cid-list (mapcar #'potato.core:ensure-channel-id channels)))
  +    (let* ((uid (potato.core:ensure-user-id user))
  +           (encoded-uid (encode-name-for-routing-key uid))
  +           (cid-list (mapcar #'potato.core:ensure-channel-id channels)))
         (let ((queue-name (make-queue-name uid cid-list)))
           (d queue-name nil)
           (dolist (cid cid-list)
  
positive.code:     (let ((exchange (cl-rabbit:envelope/exchange msg)))
        (log:trace "Processing message on exchange: ~s" exchange)
        (string-case:string-case (exchange :default nil)
          (#.*channel-content-exchange-name*     (process-channel-message msg msg-formatter))
          (#.*state-server-sender-exchange-name* (process-state-server-message msg))
          (#.*user-notifications-exchange-name*  (process-user-notification-message msg))
          (#.*unread-state-exchange-name*        (process-unread-message msg))
          (#.*channel-exchange-name*             (potato.rabbitmq-channels:process-channel-update msg))))))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;; Web handlers -- eventsource
  
negative.code:                  "channel" (potato.core:user-unread-state-rabbitmq-message/channel content)
                   "count" (potato.core:user-unread-state-rabbitmq-message/count content))))
  
  (defun process-unrouted-command (msg)
    (let ((headers (cdr (assoc :headers (cl-rabbit:message/properties (cl-rabbit:envelope/message msg))))))
      (st-json:jso "type" "illegal-command"
                   "cmd" (cdr (assoc "cmd" headers :test #'equal))
                   "channel" (cdr (assoc "channel" headers :test #'equal)))))
  
  (defun process-message (msg subscription-consumer-tag msg-formatter)
    (let ((consumer (cl-rabbit:envelope/consumer-tag msg)))
      (unless (equal consumer subscription-consumer-tag)
  