anchor.diff:          (expecting-element/consuming (source "fault")
             (let ((fault (decode-value source)))
               (error 'cxml-rpc-fault
  -                   :fault-code (member-value "faultCode" fault)
  -                   :fault-phrase (member-value "faultString" fault)))))
  +                   :fault-code (assoc "faultCode" fault :test #'equal)
  +                   :fault-phrase (assoc "faultString" fault :test #'equal)))))
         (expecting-element/consuming (source "params")
  -        ;; spec states that only one value is returned, ever, but I believe in
  -        ;; being liberal in what we accept.
  -        (apply #'values  
  -               (loop while (eql :start-element (klacks:peek source))
  -                     collect (decode-parameter source)
  -                     do (skip-characters source)))))))
  +        (decode-parameter source)))))
   
   (defun decode-parameter (source)
     (expecting-element/consuming (source "param")
  
positive.code:                    string))
  
  (defun decode-time (string)
    (make-instance 'xml-rpc-date
       :iso8601 string
       :universal-time (let ((year (subseq string 0 4))
                             (month (subseq string 4 6))
                             (date (subseq string 6 8))
                             (utc-marker (subseq string 8 9))
                             (hour (subseq string 9 11))
                             (minute (subseq string 12 14))
                             (second (subseq string 15 17)))
                         (apply #'encode-universal-time
                                (mapcar #'parse-integer
                                        `(,second ,minute ,hour ,date ,month ,year
                                                  ,@(when (equal utc-marker "Z")
                                                      (list "0"))))))))
  
  (defgeneric decode-object (type source)
    (:method ((type (eql :lazy-string)) source)
      (let ((string (nth-value 1 (klacks:skip source :characters))))
        (when (eql :end-element (klacks:peek source))
          string)))
    (:method ((type (eql :string)) source)
      (expecting-element/characters (source "string" chars)
        chars))
    (:method ((type (eql :date-time)) source)
      (expecting-element/characters (source "dateTime.iso8601" chars)
        (decode-time chars)))
    (:method ((type (eql :integer)) source)
      (let ((integer-spec (nth-value 2 (klacks:peek source))))
        (expecting-element/characters (source integer-spec chars)
  
negative.code:           (when (first-invalid-integer-position chars)
              (error 'malformed-value-content
                     :type integer-spec :content chars))
            (values value :integer)))))
    (:method ((type (eql :boolean)) source)
      (expecting-element/characters (source "boolean" chars)
        (values (cond ((string= chars "1") t)
                      ((string= chars "0") nil)
                      (t (error 'malformed-value-content
                                :type "boolean" :content chars)))
                :boolean)))
    (:method ((type (eql :array)) source)
      (expecting-element/consuming (source "array")
        (expecting-element/consuming (source "data")
          (values
           (loop while (eql :start-element (klacks:peek source))
                 for (value type) =  (multiple-value-list (decode-value source))
                 collect type
                 collect value
                 do (skip-characters source))
           :array))))
    (:method ((type (eql :struct)) source)
      (expecting-element/consuming (source "struct")
        (loop while (eql :start-element (klacks:peek source))
              collect (expecting-element/consuming (source "member")
                        (let ((name (decode-name source)))
                          (multiple-value-bind (value type)  (decode-value source)
                            (list name type value))))
              do (skip-characters source))))
    (:method ((type (eql :base64)) source)
      (expecting-element/characters (source "base64" chars)
        (values (cl-base64:base64-string-to-usb8-array chars) :base64)))
    (:method ((type (eql :double)) source)
      (expecting-element/characters (source "double" chars)
        (let ((point-posn (first-invalid-integer-position chars))
  