anchor.diff:  			      (layout-edges graph node stream arc-drawer arc-drawing-options))
                               (map nil continuation children))))))
   
  -(defmethod layout-graph-edges :around ((graph-output-record tree-graph-output-record)
  -                                       stream arc-drawer arc-drawing-options)
  -  (setf arc-drawer (or arc-drawer #'standard-arc-drawer))
  -  (call-next-method graph-output-record stream arc-drawer arc-drawing-options))
  -
   (defmethod layout-graph-edges :around ((graph-output-record digraph-graph-output-record)
                                          stream arc-drawer arc-drawing-options)
  +  ;; The default behaviour of a mere line is not appropriate for digraphs, so default to a
  +  ;; more helpful alternative
     (setf arc-drawer (or arc-drawer #'arrow-arc-drawer))
  -  (call-next-method graph-output-record stream arc-drawer arc-drawing-options))
  -
  -(defmethod layout-graph-edges :around ((graph-output-record dag-graph-output-record)
  -                                       stream arc-drawer arc-drawing-options)
  -  (setf arc-drawer (or arc-drawer #'standard-arc-drawer))
     (call-next-method graph-output-record stream arc-drawer arc-drawing-options))
   
   (defun standard-arc-drawer (stream from-node to-node x1 y1 x2 y2
  
positive.code:      :stream *query-io*
       :orientation :vertical)))
  
  (define-graph-test-command baz ()
    (with-text-style (*query-io* (make-text-style :sans-serif nil 10))
      (let ((*print-case* :downcase))
        (format-graph-from-roots
         (list (c2mop:find-class 'standard-graph-output-record)
               ;;(c2mop:find-class 'climi::basic-output-record)
               ;;(c2mop:find-class 'climi::graph-output-record)
               
               )
         #'(lambda (x s)
             (with-text-style (s (make-text-style nil
                                                  (if (external-symbol-p (class-name x))
                                                      :bold
                                                      nil)
                                                  nil))
               (prin1 (class-name x) s)))
         #'(lambda (x)
             (reverse(c2mop:class-direct-superclasses x)))
         ;; :duplicate-key #'(lambda (x) 't)
         :merge-duplicates t
         :graph-type :tree
         :arc-drawer #'arrow-arc-drawer
         :stream *query-io*
         :orientation :vertical))))
  
  (define-graph-test-command test ()
    (let ((stream *query-io*)
          (orientation :vertical))
      (fresh-line stream)
  
negative.code:       ;; generation sizes is an adjustable array that tracks the major
        ;; dimension of each of the generations [2005/07/18:rpg]
        (let ((generation-sizes (make-array 10 :adjustable t :initial-element 0))
  	    (depth-hash (make-hash-table :test #'eq))
  	    (parent-hash (make-hash-table :test #'eq)))
          (flet ((node-major-dimension (node)
                   (if (eq orientation :vertical)
                       (bounding-rectangle-height node)
                       (bounding-rectangle-width node)))
                 (node-minor-dimension (node)
                   (if (eq orientation :vertical)
                       (bounding-rectangle-width node)
                       (bounding-rectangle-height node))))
            ;;
            (labels ((assign-depth (node depth trail)
                       ;; In a DAG or digraph, there may be multiple paths to a node ending up at
                       ;; different depths, so in the major dimension - depending on
                       ;; maximize-generations - put the node one generation beyond all of its parents
                       ;; or one generation beyond the parent nearest the roots. Use a trail to
                       ;; escape from circularity, while still processing reentrancies --JAC 2017/09/04
  		     (unless (member node trail :test #'eq)
  		       (let ((node-depth (gethash node depth-hash)))
  		         (when (or (null node-depth)
                                     (if maximize-generations (> depth node-depth) (< depth node-depth)))
  		           (setf (gethash node depth-hash) depth)
  		           (map nil #'(lambda (child)
  		                        (assign-depth child (1+ depth) (cons node trail)))
  		                (graph-node-children node)))))))
              (map nil #'(lambda (x) (assign-depth x 0 nil))
                   root-nodes))
            ;;
            (labels ((compute-dimensions (node depth &optional parent)
  		     ;; compute the major dimension of all the nodes at this generation depth,
  		     ;; and the minor dimension of this individual node - which takes into account
  		     ;; the space for the node's children
  		     (when (eql (gethash node depth-hash) depth)
  		       (setf (gethash node depth-hash) nil) ; mark as done
                         (when parent
  		         (setf (gethash node parent-hash) parent))
  		       (when (>= depth (length generation-sizes))
  			 (setf generation-sizes (adjust-array generation-sizes (ceiling (* depth 1.2))
  			  				      :initial-element 0)))
  		       (setf (aref generation-sizes depth)
  			     (max (aref generation-sizes depth) (node-major-dimension node)))
  		       (setf (graph-node-minor-size node) 0)
  		       (max (node-minor-dimension node)
  			    (setf (graph-node-minor-size node)
  				  (let ((sum 0) (n 0))
  				    (map nil #'(lambda (child)
  					         (let ((x (compute-dimensions child (+ depth 1) node)))
  						   (when x
  						     (incf sum x)
  						     (incf n))))
  					 (graph-node-children node))
  				    (+ sum
  				       (* (max 0 (- n 1)) within-generation-separation))))))))
              (map nil #'(lambda (x) (compute-dimensions x 0))
                   root-nodes))
            ;;
            (let ((visited (make-hash-table :test #'eq)))
              (labels ((compute-position (node majors u0 v0)
                         (cond ((gethash node visited)
                                v0)
                               (t
                                (setf (gethash node visited) t)
                                (let ((d (- (node-minor-dimension node)
                                            (graph-node-minor-size node))))
                                  ;; center-nodes is meant to be "with respect to the widest node
                                  ;; in the same generation". Interpret "wide" as being the size in
                                  ;; the major dimension --JAC 2017/09/04
                                  (let ((u (if center-nodes
                                               (+ u0 (/ (- (car majors) (node-major-dimension node)
                                                           generation-separation)
                                                        2))
                                               u0))
                                        (v (+ v0 (/ (min 0 d) -2))))
                                    (setf (output-record-position node)
                                          (if (eq orientation :vertical)
                                              (transform-position (medium-transformation stream) v u)
                                              (transform-position (medium-transformation stream) u v)))
                                    (add-output-record node graph-output-record))
                                  ;;
                                  (let ((u (+ u0 (car majors)))
                                        (v (+ v0 (max 0 (/ d 2))))
                                        (firstp t))
                                    (map nil #'(lambda (q)
                                                 (unless (gethash q visited)
                                                   (if firstp
                                                       (setf firstp nil)
                                                       (incf v within-generation-separation))
                                                   (setf v (compute-position q (cdr majors) u v))))
                                         ;; to make the tree style layout work for DAGs and digraphs,
                                         ;; we must only recurse to those children whose dimensions
                                         ;; were computed previously with this node as their
                                         ;; principal parent --JAC 2017/09/04
                                         (remove-if-not
                                           #'(lambda (x) (eq (gethash x parent-hash) node))
                                           (graph-node-children node))))
                                  ;;
                                  (+ v0 (max (node-minor-dimension node)
                                             (graph-node-minor-size node))))))))
                ;;
                (let ((majors (mapcar (lambda (x) (+ x generation-separation))
                                      (coerce generation-sizes 'list))))
                  (let ((u (/ generation-separation 2))
                        (v 0))
                    (maplist (lambda (rest)
                               (setf v (compute-position (car rest) majors u v))
                               (unless (null rest)
                                 (incf v within-generation-separation)))
                             (graph-root-nodes graph-output-record)))))))))))
  
  ;;;; Edges
  
  (defclass standard-edge-output-record (standard-sequence-output-record)
    ((stream)
     (arc-drawer)
     (arc-drawing-options)
     (from-node :initarg :from-node)
     (to-node :initarg :to-node)))
  
  (defun layout-edges (graph node stream arc-drawer arc-drawing-options)
    (dolist (k (graph-node-children node))
  