anchor.diff:  (defmethod stop-backend ((backend (eql :supercollider)))
     (cl-collider:server-quit cl-collider:*s*))
   
  -(defmethod backend-play-event (item task (backend (eql :supercollider)))
  -  "Play ITEM on the SuperCollider sound server. TASK is an internal parameter used when this function is called from the clock."
  -  (let ((type (event-value item :type))
  -        (inst (instrument item)))
  -    (when (and (not (position type (list :rest :tempo-change))) ;; FIX: make sure other backends ignore tempo-change too.
  -               (or (cl-collider:synthdef-metadata inst)
  -                   (typep inst 'cl-collider::node)))
  -      (let* ((quant (quant item))
  -             (offset (if (> (length quant) 2)
  -                         (nth 2 quant)
  -                         0))
  -             (time (+ (or (raw-event-value item :latency) *latency*)
  -                      (or (timestamp-to-cl-collider (raw-event-value item :timestamp-at-start)) (cl-collider:now))
  -                      (time-dur (or (raw-event-value item :timing-offset) 0) (tempo *clock*))
  -                      offset))
  -             (params (supercollider-make-synth-args-list inst item)))
  -        (if (or (eql type :mono)
  -                (typep inst 'cl-collider::node))
  -            (let ((node (cl-collider:at time
  -                          (let ((nodes (task-nodes task *supercollider-node-map*)))
  -                            (cond ((not (null nodes))
  -                                   (apply #'cl-collider:ctrl (car nodes) params))
  -                                  ((typep inst 'cl-collider::node)
  -                                   ;; redefining a proxy changes its Node's ID.
  -                                   ;; thus if the user redefines a proxy, the Node object previously provided to the pbind will become inaccurate.
  -                                   ;; thus we look up the proxy in the node-proxy-table to ensure we always have the correct ID.
  -                                   (let ((node (or (get-proxys-node-id inst)
  -                                                   inst)))
  -                                     (apply #'cl-collider:ctrl node params)))
  -                                  (t
  -                                   (apply #'cl-collider:synth inst params)))))))
  -              (unless (or (typep inst 'cl-collider::node)
  -                          (not (has-gate-p inst :supercollider)))
  -                (if (< (legato item) 1)
  -                    (cl-collider:at (+ time (dur-time (sustain item)))
  -                      (setf (task-nodes task *supercollider-node-map*) nil)
  -                      (cl-collider:release node))
  -                    (setf (task-nodes task *supercollider-node-map*) (list node)))))
  -            (let ((node (cl-collider:at time
  -                          (apply #'cl-collider:synth inst params))))
  -              (when (has-gate-p node :supercollider)
  -                (cl-collider:at (+ time (dur-time (sustain item)))
  -                  (cl-collider:release node)))))))))
  +(defmethod backend-instrument-controls (instrument (backend (eql :supercollider)))
  +  (mapcar #'car (cl-collider:synthdef-metadata instrument :controls)))
   
  -(defmethod backend-task-removed (task (backend (eql :supercollider)))
  -  (let ((item (slot-value task 'item)))
  -    (if (typep item 'event)
  -        (map nil 'stop (task-nodes task *supercollider-node-map*)) ;; FIX: this doesn't work because the preview synth doesn't have a gate argument, and non-gated synths aren't kept in the *supercollider-node-map*.
  -        (let ((last-output (last-output item)))
  -          (dolist (node (task-nodes task *supercollider-node-map*))
  -            (cl-collider:at (timestamp-to-cl-collider
  -                             (absolute-beats-to-timestamp (+ (slot-value task 'start-beat) (beat last-output) (sustain last-output))
  -                                                          (slot-value task 'clock)))
  -              (cl-collider:release node))))))
  -  (setf (task-nodes task *supercollider-node-map*) nil))
  +(defmethod backend-node-p (object (backend (eql :supercollider)))
  +  (typep object 'cl-collider::node))
  +
  +(defmethod backend-timestamps-for-event (event task (backend (eql :supercollider)))
  +  (let ((time (if-let ((timestamp (raw-event-value event :timestamp-at-start)))
  +                (+ (local-time:timestamp-to-unix timestamp) (* (local-time:nsec-of timestamp) 1.0d-9))
  +                (cl-collider:now))))
  +    (list time (+ time (dur-time (sustain event))))))
  +
  +(defmethod backend-proxys-node (id (backend (eql :supercollider)))
  +  (if (typep id 'cl-collider::node)
  +      id
  +      (gethash id (cl-collider::node-proxy-table cl-collider::*s*))))
  +
  +(defmethod backend-control-node-at (time (node symbol) params (backend (eql :supercollider)))
  +  (cl-collider:at time
  +    (apply #'cl-collider:synth node params)))
  +
  +(defmethod backend-control-node-at (time (node cl-collider::node) params (backend (eql :supercollider)))
  +  (cl-collider:at time
  +    (apply #'cl-collider:ctrl node params)))
  +
  +(defmethod backend-convert-object ((object cl-collider::buffer) key (backend (eql :supercollider)))
  +  (declare (ignore key))
  +  (cl-collider:bufnum object))
  +
  +(defmethod backend-convert-object ((object cl-collider::bus) key (backend (eql :supercollider)))
  +  (declare (ignore key))
  +  (cl-collider:busnum object))
  +
  +(defmethod backend-convert-object ((object cl-collider::node) key (backend (eql :supercollider)))
  +  (let ((bus (if (eql key :out)
  +                 (cl-collider:synthdef-metadata object :input-bus)
  +                 (or (cl-collider:synthdef-metadata object :output-bus)
  +                     (cl-collider:synthdef-metadata object :input-bus)))))
  +    (if bus
  +        (cl-collider:busnum bus)
  +        object)))
  +
  +(defmethod backend-convert-object ((object cl-collider::group) key (backend (eql :supercollider)))
  +  (declare (ignore key))
  +  (cl-collider::id object))
   
   ;;; convenience methods
  +
  +(defun cl-collider-proxy (id) ;; FIX: remove this and just make `lookup-object-for-symbol' call `backend-proxys-node' for each enabled/registered backend?
  +  "Get the object representing the `cl-collider:proxy' with the given name."
  +  (backend-proxys-node id :supercollider))
   
   (endpushnew *dictionary-lookup-functions* 'cl-collider-proxy)
   
  
positive.code:   (let* ((synth *cl-collider-buffer-preview-synth*)
           (synthdef-controls (mapcar #'car (cl-collider:synthdef-metadata synth :controls))))
      (play (event :backend :supercollider
                   :instrument synth
                   (find-if (lambda (x)
                              (position-if (lambda (y)
                                             (string-equal y x))
                                           (list 'buffer 'bufnum)))
                            synthdef-controls)
                   (cl-collider:bufnum buffer)
                   :dur (time-dur (cl-collider:buffer-dur buffer)) ;; FIX: this doesn't calculate the correct time for this.
                   :quant 0
                   :latency 0))))
  
  
negative.code: (defvar *cl-collider-buffer-preview-synth* :spt
    "The name of the synth to use to `play' a buffer.")
  
  ;;; backend functions
  
  (defmethod start-backend ((backend (eql :supercollider)))
  