anchor.diff:  		  (require-rb-transaction)
   		  (let ((id (call-next-method)))
   		    (or (object-for-id *rb-transaction* id)
  -			(let ((node (prb-load (storage (tree *rb-transaction*)) id)))
  -			  (add-opened-node *rb-transaction* node id)
  +			(let ((node (prb-load (storage (tree *rb-transaction*)) *rb-transaction* id)))
  +			  (add-opened-object *rb-transaction* node id)
   			  node))))
   
   		(defmethod (setf ,slot) :around (value (node persistent-red-black-node))
   		  (require-rb-transaction)
  -		  (add-changed-node *rb-transaction* node)
  +		  (add-changed-object *rb-transaction* node)
   		  (call-next-method (id-for-object *rb-transaction* value) node)))))
     (declare-slot-translation parent)
     (declare-slot-translation left)
  -  (declare-slot-translation right))
  +  (declare-slot-translation right)
  +  (declare-slot-translation data))
   
   (defmethod (setf color) (color (node persistent-red-black-node))
     (require-rb-transaction)
  -  (add-changed-node *rb-transaction* node)
  +  (add-changed-object *rb-transaction* node)
     (call-next-method))
   
   (defmethod root :around ((tree persistent-red-black-tree))
     (require-rb-transaction)
     (let ((id (or (and *rb-transaction* (new-root *rb-transaction*)) (call-next-method))))
       (or (object-for-id *rb-transaction* id)
  -	(let ((root (prb-load (storage tree) id)))
  -	  (add-opened-node *rb-transaction* root id)
  +	(let ((root (prb-load (storage tree) *rb-transaction* id)))
  +	  (add-opened-object *rb-transaction* root id)
   	  root))))
   
   (defmethod (setf root) (node (tree persistent-red-black-tree))
     (require-rb-transaction)
  -  (add-changed-node *rb-transaction* node)
  +  (add-changed-object *rb-transaction* node)
     (setf (new-root *rb-transaction*) (id-for-object *rb-transaction* node)))
   
   (defmethod allocate-id ((*rb-transaction* red-black-tree-transaction) obj)
  
positive.code: (defgeneric prb-close-storage (storage)
    (:documentation "Release storage from use; further load & save operations cannot succeed without a subsequent open call"))
  
  (defgeneric prb-load (storage id)
    (:documentation "Load the indicated object from storage (usually a node or tree)"))
  
  (defgeneric prb-save (storage id object)
    (:documentation "Save the indicated object in storage (usually a node or tree); 
      return a reference to its id within the storage"))
  
  (defgeneric prb-commit (transaction-or-tree)
    (:documentation "Orchestrate the persisting of all changes to a tree, including all changed nodes"))
  
negative.code: (defun make-persistent-red-black-tree (&key ((:storage storage) (make-instance 'red-black-tree-memory-storage)))
    (with-rb-transaction ((make-instance 'persistent-red-black-tree :storage storage))))
  
  ;; (defun open-persistent-red-black-tree (storage-info)
  ;;   "Return a persisted red-black tree connected to its backing storage"
  ;;   (declare (ignorable storage-info))
  ;;   ;; TODO for now, we are using memory-based storage; we'll shift to file-based storage later
  ;;   (let* ((storage (make-instance 'red-black-tree-memory-storage))
  ;; 	 (tree (make-instance 'persistent-red-black-tree :storage storage)))
  ;;     (prb-open-storage storage)
  ;;     (prb-load storage *rb-transaction* tree)
  ;;     tree))
  
  (defmethod rb-node-class ((tree persistent-red-black-tree))
    'persistent-red-black-node)
  