anchor.diff:  (defun word-info-gloss-json (word-info &key root-only)
     (with-connection *connection*
       (labels ((inner (word-info &optional suffix)
  -               (let ((js (jsown:new-js ("reading" (word-info-reading-str word-info))
  +               (let ((js (jsown:new-js ("reading" (reading-str word-info))
                                          ("text" (word-info-text word-info))
                                          ("kana" (word-info-kana word-info))
                                          )))
  
positive.code:              (push via via-used)))
         (princ " ]" out)))
  
  (defun conj-info-json (seq &key conjugations text)
    (loop with via-used = nil
       for conj in (select-conjs seq conjugations)
       for via = (seq-via conj)
       unless (member via via-used)
       collect (let* ((conj-pos nil)
                      (orig-text (get-original-text-once (get-conj-data seq (list (id conj))) text))
                      (js (jsown:new-js 
                            ("prop" (loop for conj-prop in (select-dao 'conj-prop (:= 'conj-id (id conj)))
                                       do (push (pos conj-prop) conj-pos)
                                       collect (conj-prop-json conj-prop))))))
                 (if (eql via :null)
                     (jsown:extend-js js
                       ("reading" (reading-str-seq (seq-from conj)))
                       ("gloss" (get-senses-json (seq-from conj)
                                                 :pos-list conj-pos
                                                 :reading-getter (lambda ()
                                                                   (when orig-text
                                                                     ;; TODO: fix match-sense-restrictions to accept multiple readings
                                                                     (car (find-words-seqs orig-text (seq-from conj))))))))
                     (progn
                       (jsown:extend-js js
                         ("via" (conj-info-json via :text orig-text)))
                       (push via via-used)))
                 js)))
  
  (defun map-word-info-kana (fn word-info &key (separator "/")
                             &aux (wkana (word-info-kana word-info)))
  
negative.code:        'sense.ord)
        1)) :single))
  
  (defun reading-str* (kanji kana)
    (if kanji
        (format nil "~a 【~a】" kanji kana)
        kana))
  