anchor.diff:                       (let ((seq (word-info-seq word-info))
                              (conjs (word-info-conjugations word-info))
                              (reading-getter (lambda () (word-info-reading word-info)))
  -                           desc)
  +                           desc has-gloss)
                          (cond (root-only
                                 (return-from inner
                                   (jsown:extend-js js ("gloss" (get-senses-json seq :reading-getter reading-getter)))))
                                ((and suffix (setf desc (get-suffix-description seq)))
                                 (jsown:extend-js js ("suffix" desc)))
                                ((and seq (or (not conjs) (eql conjs :root)))
  +                              (setf has-gloss t)
                                 (jsown:extend-js js ("gloss" (get-senses-json seq :reading-getter reading-getter)))))
                          (when seq
                            (jsown:extend-js js 
                              ("conj" (conj-info-json seq :conjugations (word-info-conjugations word-info)
  -                                                   :text (word-info-true-text word-info)))))))
  +                                                   :text (word-info-true-text word-info)
  +                                                   :has-gloss has-gloss))))))
                    js)))
         (if (word-info-alternative word-info)
             (jsown:new-js ("alternative" (mapcar #'inner (word-info-components word-info))))
  
positive.code:        'sense.ord)
        1)) :single))
  
  (defun reading-str (kanji kana)
    (if kanji
        (format nil "~a 【~a】" kanji kana)
        kana))
  
negative.code: (defun reading-str-seq (seq)
    (let* ((kanji-text (car (query (:select 'text :from 'kanji-text :where (:and (:= 'seq seq) (:= 'ord 0))) :column)))
           (kana-text (car (query (:select 'text :from 'kana-text :where (:and (:= 'seq seq) (:= 'ord 0))) :column))))
      (reading-str* kanji-text kana-text)))
  
  (defgeneric reading-str (obj)
    (:method ((obj simple-text))
      (reading-str* (get-kanji obj) (get-kana obj)))
    (:method ((obj integer))
      (reading-str-seq obj)))
  
  (defun entry-info-short (seq &key with-pos)
    (let ((sense-str (short-sense-str seq :with-pos with-pos)))
  