diff --git a/lfs.c b/lfs.c
index 13ead2ec..c58cd461 100644
--- a/lfs.c
+++ b/lfs.c
@@ -2611,6 +2611,10 @@ static inline bool lfsr_bptr_isbptr(const lfsr_bptr_t *bptr) {
     return bptr->data.size & LFSR_BPTR_ISBPTR;
 }
 
+static inline lfs_size_t lfsr_bptr_size(const lfsr_bptr_t *bptr) {
+    return bptr->data.size & ~LFSR_BPTR_ONDISK & ~LFSR_BPTR_ISBPTR;
+}
+
 static inline lfs_block_t lfsr_bptr_block(const lfsr_bptr_t *bptr) {
     return bptr->data.u.disk.block;
 }
@@ -2619,10 +2623,6 @@ static inline lfs_size_t lfsr_bptr_off(const lfsr_bptr_t *bptr) {
     return bptr->data.u.disk.off;
 }
 
-static inline lfs_size_t lfsr_bptr_size(const lfsr_bptr_t *bptr) {
-    return bptr->data.size & ~LFSR_BPTR_ONDISK & ~LFSR_BPTR_ISBPTR;
-}
-
 // checked reads adds ck info to lfsr_data_t that we don't want to
 // unnecessarily duplicate, this makes accessing ck info annoyingly
 // messy...
@@ -5133,20 +5133,47 @@ static lfs_scmp_t lfsr_rbyd_namelookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
 
 // create an empty btree
 static void lfsr_btree_init(lfsr_btree_t *btree) {
-    btree->weight = 0;
-    btree->blocks[0] = -1;
-    btree->trunk = 0;
+    btree->root.weight = 0;
+    btree->root.blocks[0] = -1;
+    btree->root.trunk = 0;
+    // weight=0 indicates no leaf
+    btree->leaf.rbyd.weight = 0;
 }
 
 // convenience operations
 static inline void lfsr_btree_claim(lfsr_btree_t *btree) {
-    lfsr_rbyd_claim(btree);
+    lfsr_rbyd_claim(&btree->root);
+    lfsr_rbyd_claim(&btree->leaf.rbyd);
+}
+
+static inline void lfsr_btree_discardleaf(lfsr_btree_t *btree) {
+    btree->leaf.rbyd.weight = 0;
+}
+
+static inline lfsr_bid_t lfsr_btree_weight(const lfsr_btree_t *btree) {
+    return btree->root.weight;
+}
+
+static inline lfs_block_t lfsr_btree_block(const lfsr_btree_t *btree) {
+    return btree->root.blocks[0];
+}
+
+static inline bool lfsr_btree_isbshrub(const lfsr_btree_t *btree) {
+    return lfsr_rbyd_isshrub(&btree->root);
+}
+
+static inline lfs_size_t lfsr_btree_trunk(const lfsr_btree_t *btree) {
+    return lfsr_rbyd_trunk(&btree->root);
+}
+
+static inline uint32_t lfsr_btree_cksum(const lfsr_btree_t *btree) {
+    return btree->root.cksum;
 }
 
 static inline int lfsr_btree_cmp(
         const lfsr_btree_t *a,
         const lfsr_btree_t *b) {
-    return lfsr_rbyd_cmp(a, b);
+    return lfsr_rbyd_cmp(&a->root, &b->root);
 }
 
 
@@ -5257,16 +5284,16 @@ static int lfsr_data_fetchbranch(lfs_t *lfs,
 static lfsr_data_t lfsr_data_frombtree(const lfsr_btree_t *btree,
         uint8_t buffer[static LFSR_BTREE_DSIZE]) {
     // weight should not exceed 31-bits
-    LFS_ASSERT(btree->weight <= 0x7fffffff);
+    LFS_ASSERT(lfsr_btree_weight(btree) <= 0x7fffffff);
     lfs_ssize_t d = 0;
 
-    lfs_ssize_t d_ = lfs_toleb128(btree->weight, &buffer[d], 5);
+    lfs_ssize_t d_ = lfs_toleb128(lfsr_btree_weight(btree), &buffer[d], 5);
     if (d_ < 0) {
         LFS_UNREACHABLE();
     }
     d += d_;
 
-    lfsr_data_t data = lfsr_data_frombranch(btree, &buffer[d]);
+    lfsr_data_t data = lfsr_data_frombranch(&btree->root, &buffer[d]);
     d += lfsr_data_size(data);
 
     return LFSR_DATA_BUF(buffer, d);
@@ -5280,11 +5307,12 @@ static int lfsr_data_readbtree(lfs_t *lfs, lfsr_data_t *data,
         return err;
     }
 
-    err = lfsr_data_readbranch(lfs, data, weight, btree);
+    err = lfsr_data_readbranch(lfs, data, weight, &btree->root);
     if (err) {
         return err;
     }
 
+    lfsr_btree_discardleaf(btree);
     return 0;
 }
 
@@ -5295,7 +5323,7 @@ static int lfsr_btree_fetch(lfs_t *lfs, lfsr_btree_t *btree,
         lfs_block_t block, lfs_size_t trunk, lfsr_bid_t weight,
         uint32_t cksum) {
     // btree/branch fetch really are the same once we know the weight
-    int err = lfsr_branch_fetch(lfs, btree,
+    int err = lfsr_branch_fetch(lfs, &btree->root,
             block, trunk, weight,
             cksum);
     if (err) {
@@ -5305,9 +5333,9 @@ static int lfsr_btree_fetch(lfs_t *lfs, lfsr_btree_t *btree,
     #ifdef LFS_DBGBTREEFETCHES
     LFS_DEBUG("Fetched btree 0x%"PRIx32".%"PRIx32" w%"PRId32", "
                 "cksum %"PRIx32,
-            btree->blocks[0], lfsr_rbyd_trunk(btree),
-            btree->weight,
-            btree->cksum);
+            lfsr_btree_block(btree), lfsr_btree_trunk(btree),
+            lfsr_btree_weight(btree),
+            lfsr_btree_cksum(btree));
     #endif
     return 0;
 }
@@ -5322,52 +5350,62 @@ static int lfsr_data_fetchbtree(lfs_t *lfs, lfsr_data_t *data,
     }
 
     return lfsr_btree_fetch(lfs, btree,
-            btree->blocks[0], btree->trunk, btree->weight,
-            btree->cksum);
+            lfsr_btree_block(btree), lfsr_btree_trunk(btree),
+            lfsr_btree_weight(btree),
+            lfsr_btree_cksum(btree));
 }
 
 // lookup rbyd/rid containing a given bid
-static int lfsr_btree_lookupleaf(lfs_t *lfs, const lfsr_btree_t *btree,
+static int lfsr_btree_lookupnext(lfs_t *lfs, lfsr_btree_t *btree,
         lfsr_bid_t bid,
-        lfsr_bid_t *bid_, lfsr_rbyd_t *rbyd_, lfsr_srid_t *rid_,
-        lfsr_tag_t *tag_, lfsr_bid_t *weight_, lfsr_data_t *data_) {
-    // descend down the btree looking for our bid
-    *rbyd_ = *btree;
-    lfsr_srid_t rid = bid;
-    while (true) {
-        // each branch is a pair of optional name + on-disk structure
+        lfsr_bid_t *bid_, lfsr_tag_t *tag_, lfsr_bid_t *weight_,
+        lfsr_data_t *data_) {
+    // is our bid in the leaf? can we skip the btree walk?
+    //
+    // if not we need to restart from the root
+    if (!(bid >= btree->leaf.bid-(btree->leaf.rbyd.weight-1)
+            && bid < btree->leaf.bid+1)) {
+        btree->leaf.bid = lfsr_btree_weight(btree)-1;
+        btree->leaf.rbyd = btree->root;
+    }
 
+    // descend down the btree looking for our bid
+    lfsr_srid_t rid = bid - (btree->leaf.bid-(btree->leaf.rbyd.weight-1));
+    int err;
+    while (true) {
         // lookup our bid in the rbyd
         lfsr_srid_t rid__;
         lfsr_tag_t tag__;
         lfsr_rid_t weight__;
         lfsr_data_t data__;
-        int err = lfsr_rbyd_lookupnext(lfs, rbyd_, rid, 0,
+        err = lfsr_rbyd_lookupnext(lfs, &btree->leaf.rbyd, rid, 0,
                 &rid__, &tag__, &weight__, &data__);
         if (err) {
-            return err;
+            goto failed;
         }
 
         // if we found a bname, lookup the branch
         if (tag__ == LFSR_TAG_BNAME) {
-            err = lfsr_rbyd_lookup(lfs, rbyd_, rid__, LFSR_TAG_BRANCH,
+            err = lfsr_rbyd_lookup(lfs, &btree->leaf.rbyd, rid__,
+                    LFSR_TAG_BRANCH,
                     &tag__, &data__);
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_NOENT);
-                return err;
+                goto failed;
             }
         }
 
         // found another branch
         if (tag__ == LFSR_TAG_BRANCH) {
-            // adjust rid with subtree's weight
+            // adjust bid/rid with subtree's weight
+            btree->leaf.bid = bid + (rid__ - rid);
             rid -= (rid__ - (weight__-1));
 
             // fetch the next branch
             err = lfsr_data_fetchbranch(lfs, &data__, weight__,
-                    rbyd_);
+                    &btree->leaf.rbyd);
             if (err) {
-                return err;
+                goto failed;
             }
 
         // found our bid
@@ -5376,9 +5414,6 @@ static int lfsr_btree_lookupleaf(lfs_t *lfs, const lfsr_btree_t *btree,
             if (bid_) {
                 *bid_ = bid + (rid__ - rid);
             }
-            if (rid_) {
-                *rid_ = rid__;
-            }
             if (tag_) {
                 *tag_ = tag__;
             }
@@ -5391,43 +5426,42 @@ static int lfsr_btree_lookupleaf(lfs_t *lfs, const lfsr_btree_t *btree,
             return 0;
         }
     }
-}
 
-// non-leaf lookups discard the rbyd info, which can be a bit more
-// convenient, but may make commits more costly
-static int lfsr_btree_lookupnext(lfs_t *lfs, const lfsr_btree_t *btree,
-        lfsr_bid_t bid,
-        lfsr_bid_t *bid_, lfsr_tag_t *tag_, lfsr_bid_t *weight_,
-        lfsr_data_t *data_) {
-    lfsr_rbyd_t rbyd;
-    return lfsr_btree_lookupleaf(lfs, btree, bid,
-            bid_, &rbyd, NULL, tag_, weight_, data_);
+failed:;
+    // we need to discard the leaf if it's not a true leaf, otherwise
+    // this breaks lfsr_btree_lookup
+    lfsr_btree_discardleaf(btree);
+    return err;
 }
 
 // lfsr_btree_lookup assumes a known bid, matching lfsr_rbyd_lookup's
 // behavior, if you don't care about the exact bid either first call
-// lfsr_btree_lookupnext, or lfsr_btree_lookupleaf + lfsr_rbyd_lookup
-static int lfsr_btree_lookup(lfs_t *lfs, const lfsr_btree_t *btree,
+// lfsr_btree_lookupnext
+//
+// note that leaf caching makes this pretty efficient
+static int lfsr_btree_lookup(lfs_t *lfs, lfsr_btree_t *btree,
         lfsr_bid_t bid, lfsr_tag_t tag,
         lfsr_tag_t *tag_, lfsr_data_t *data_) {
-    // lookup rbyd in btree
-    lfsr_bid_t bid__;
-    lfsr_rbyd_t rbyd__;
-    lfsr_srid_t rid__;
-    int err = lfsr_btree_lookupleaf(lfs, btree, bid,
-            &bid__, &rbyd__, &rid__, NULL, NULL, NULL);
-    if (err) {
-        return err;
-    }
+    if (!(bid >= btree->leaf.bid-(btree->leaf.rbyd.weight-1)
+            && bid < btree->leaf.bid+1)) {
+        // lookup rbyd in btree
+        lfsr_bid_t bid__;
+        int err = lfsr_btree_lookupnext(lfs, btree, bid,
+                &bid__, NULL, NULL, NULL);
+        if (err) {
+            return err;
+        }
 
-    // lookup finds the next-smallest bid, all we need to do is fail if it
-    // picks up the wrong bid
-    if (bid__ != bid) {
-        return LFS_ERR_NOENT;
+        // lookup finds the next-smallest bid, all we need to do is fail
+        // if it picks up the wrong bid
+        if (bid__ != bid) {
+            return LFS_ERR_NOENT;
+        }
     }
 
     // lookup tag in rbyd
-    return lfsr_rbyd_lookup(lfs, &rbyd__, rid__, tag,
+    lfsr_srid_t rid__ = bid - (btree->leaf.bid-(btree->leaf.rbyd.weight-1));
+    return lfsr_rbyd_lookup(lfs, &btree->leaf.rbyd, rid__, tag,
             tag_, data_);
 }
 
@@ -5436,11 +5470,13 @@ static int lfsr_btree_parent(lfs_t *lfs, const lfsr_btree_t *btree,
         lfsr_bid_t bid, const lfsr_rbyd_t *child,
         lfsr_rbyd_t *rbyd_, lfsr_srid_t *rid_) {
     // we should only call this when we actually have parents
-    LFS_ASSERT(bid < (lfsr_bid_t)btree->weight);
-    LFS_ASSERT(lfsr_rbyd_cmp(btree, child) != 0);
+    LFS_ASSERT(bid < lfsr_btree_weight(btree));
+    LFS_ASSERT(lfsr_rbyd_cmp(&btree->root, child) != 0);
+
+    // note we don't bother with leaf here
 
     // descend down the btree looking for our rid
-    *rbyd_ = *btree;
+    *rbyd_ = btree->root;
     lfsr_srid_t rid = bid;
     while (true) {
         // each branch is a pair of optional name + on-disk structure
@@ -5457,7 +5493,8 @@ static int lfsr_btree_parent(lfs_t *lfs, const lfsr_btree_t *btree,
 
         // if we found a bname, lookup the branch
         if (tag__ == LFSR_TAG_BNAME) {
-            err = lfsr_rbyd_lookup(lfs, rbyd_, rid__, LFSR_TAG_BRANCH,
+            err = lfsr_rbyd_lookup(lfs, rbyd_, rid__,
+                    LFSR_TAG_BRANCH,
                     &tag__, &data__);
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_NOENT);
@@ -5550,29 +5587,28 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
         lfsr_bid_t *bid,
         const lfsr_rattr_t **rattrs, lfs_size_t *rattr_count) {
     lfsr_bid_t bid_ = *bid;
-    LFS_ASSERT(bid_ <= (lfsr_bid_t)btree->weight);
+    LFS_ASSERT(bid_ <= lfsr_btree_weight(btree));
     const lfsr_rattr_t *rattrs_ = *rattrs;
     lfs_size_t rattr_count_ = *rattr_count;
 
     // lookup which leaf our bid resides
-    //
-    // for lfsr_btree_commit_ operations to work out, we need to
-    // limit our bid to an rid in the tree, which is what this min
-    // is doing
-    lfsr_rbyd_t rbyd_ = *btree;
+    lfsr_rbyd_t child = btree->root;
     lfsr_srid_t rid_ = bid_;
-    if (btree->weight > 0) {
-        lfsr_srid_t rid__;
-        int err = lfsr_btree_lookupleaf(lfs, btree,
-                lfs_min(bid_, btree->weight-1),
-                &bid_, &rbyd_, &rid__, NULL, NULL, NULL);
+    if (lfsr_btree_weight(btree) > 0) {
+        int err = lfsr_btree_lookupnext(lfs, btree,
+                // for lfsr_btree_commit_ operations to work out, we
+                // need to limit our bid to an rid in the tree, which
+                // is what this min is doing
+                lfs_min(bid_, lfsr_btree_weight(btree)-1),
+                &bid_, NULL, NULL, NULL);
         if (err) {
             LFS_ASSERT(err != LFS_ERR_NOENT);
             return err;
         }
 
         // adjust rid
-        rid_ -= (bid_-rid__);
+        child = btree->leaf.rbyd;
+        rid_ -= (btree->leaf.bid-(btree->leaf.rbyd.weight-1));
     }
 
     // tail-recursively commit to btree
@@ -5581,16 +5617,16 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
         lfsr_rbyd_t parent = {.trunk=0, .weight=0};
         lfsr_srid_t pid = 0;
         // are we root?
-        if (!lfsr_rbyd_trunk(&rbyd_)
-                || rbyd_.blocks[0] == btree->blocks[0]) {
+        if (!lfsr_rbyd_trunk(&child)
+                || child.blocks[0] == lfsr_btree_block(btree)) {
             // new root? shrub root? yield the final root commit to
             // higher-level btree/bshrub logic
-            if (!lfsr_rbyd_trunk(&rbyd_)
-                    || lfsr_rbyd_isshrub(btree)) {
+            if (!lfsr_rbyd_trunk(&child)
+                    || lfsr_btree_isbshrub(btree)) {
                 *bid = rid_;
                 *rattrs = rattrs_;
                 *rattr_count = rattr_count_;
-                return (!lfsr_rbyd_trunk(&rbyd_)) ? LFS_ERR_RANGE : 0;
+                return (!lfsr_rbyd_trunk(&child)) ? LFS_ERR_RANGE : 0;
             }
 
             // mark btree as unerased in case of failure, our btree rbyd and
@@ -5599,7 +5635,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
             lfsr_btree_claim(btree);
 
         } else {
-            int err = lfsr_btree_parent(lfs, btree, bid_, &rbyd_,
+            int err = lfsr_btree_parent(lfs, btree, bid_, &child,
                     &parent, &pid);
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_NOENT);
@@ -5614,10 +5650,10 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
         // unfetched
         //
         // a funny benefit is we cache the root of our btree this way
-        if (!lfsr_rbyd_isfetched(&rbyd_)) {
-            int err = lfsr_rbyd_fetchck(lfs, &rbyd_,
-                    rbyd_.blocks[0], lfsr_rbyd_trunk(&rbyd_),
-                    rbyd_.cksum);
+        if (!lfsr_rbyd_isfetched(&child)) {
+            int err = lfsr_rbyd_fetchck(lfs, &child,
+                    child.blocks[0], lfsr_rbyd_trunk(&child),
+                    child.cksum);
             if (err) {
                 return err;
             }
@@ -5626,8 +5662,8 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
         // is rbyd erased? can we sneak our commit into any remaining
         // erased bytes? note that the btree trunk field prevents this from
         // interacting with other references to the rbyd
-        lfsr_rbyd_t rbyd__ = rbyd_;
-        int err = lfsr_rbyd_commit(lfs, &rbyd__, rid_,
+        lfsr_rbyd_t child_ = child;
+        int err = lfsr_rbyd_commit(lfs, &child_, rid_,
                 rattrs_, rattr_count_);
         if (err) {
             if (err == LFS_ERR_RANGE || err == LFS_ERR_CORRUPT) {
@@ -5641,7 +5677,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
     compact:;
         // estimate our compacted size
         lfsr_srid_t split_rid;
-        lfs_ssize_t estimate = lfsr_rbyd_estimate(lfs, &rbyd_, -1, -1,
+        lfs_ssize_t estimate = lfsr_rbyd_estimate(lfs, &child, -1, -1,
                 &split_rid);
         if (estimate < 0) {
             return estimate;
@@ -5707,13 +5743,13 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
             }
 
             // try the left sibling
-            if (pid-(lfsr_srid_t)rbyd_.weight >= 0) {
+            if (pid-(lfsr_srid_t)child.weight >= 0) {
                 // try looking up the sibling
                 lfsr_srid_t sibling_rid;
                 lfsr_tag_t sibling_tag;
                 lfsr_rid_t sibling_weight;
                 lfsr_data_t sibling_data;
-                err = lfsr_rbyd_lookupnext(lfs, &parent, pid-rbyd_.weight, 0,
+                err = lfsr_rbyd_lookupnext(lfs, &parent, pid-child.weight, 0,
                         &sibling_rid, &sibling_tag, &sibling_weight,
                         &sibling_data);
                 if (err) {
@@ -5754,11 +5790,11 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
                     // so our sibling is on the right
                     bid_ -= sibling.weight;
                     rid_ += sibling.weight;
-                    pid -= rbyd_.weight;
+                    pid -= child.weight;
 
-                    rbyd__ = sibling;
-                    sibling = rbyd_;
-                    rbyd_ = rbyd__;
+                    child_ = sibling;
+                    sibling = child;
+                    child = child_;
 
                     goto merge;
                 }
@@ -5767,14 +5803,14 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
 
     relocate:;
         // allocate a new rbyd
-        err = lfsr_rbyd_alloc(lfs, &rbyd__);
+        err = lfsr_rbyd_alloc(lfs, &child_);
         if (err) {
             return err;
         }
 
         #if defined(LFS_REVDBG) || defined(LFS_REVNOISE)
         // append a revision count?
-        err = lfsr_rbyd_appendrev(lfs, &rbyd__, lfsr_rev_btree(lfs));
+        err = lfsr_rbyd_appendrev(lfs, &child_, lfsr_rev_btree(lfs));
         if (err) {
             // bad prog? try another block
             if (err == LFS_ERR_CORRUPT) {
@@ -5785,7 +5821,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
         #endif
 
         // try to compact
-        err = lfsr_rbyd_compact(lfs, &rbyd__, &rbyd_, -1, -1);
+        err = lfsr_rbyd_compact(lfs, &child_, &child, -1, -1);
         if (err) {
             LFS_ASSERT(err != LFS_ERR_RANGE);
             // bad prog? try another block
@@ -5797,7 +5833,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
 
         // append any pending rattrs, it's up to upper
         // layers to make sure these always fit
-        err = lfsr_rbyd_commit(lfs, &rbyd__, rid_,
+        err = lfsr_rbyd_commit(lfs, &child_, rid_,
                 rattrs_, rattr_count_);
         if (err) {
             LFS_ASSERT(err != LFS_ERR_RANGE);
@@ -5813,18 +5849,18 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
     split:;
         // we should have something to split here
         LFS_ASSERT(split_rid > 0
-                && split_rid < (lfsr_srid_t)rbyd_.weight);
+                && split_rid < (lfsr_srid_t)child.weight);
 
     split_relocate_l:;
         // allocate a new rbyd
-        err = lfsr_rbyd_alloc(lfs, &rbyd__);
+        err = lfsr_rbyd_alloc(lfs, &child_);
         if (err) {
             return err;
         }
 
         #if defined(LFS_REVDBG) || defined(LFS_REVNOISE)
         // append a revision count?
-        err = lfsr_rbyd_appendrev(lfs, &rbyd__, lfsr_rev_btree(lfs));
+        err = lfsr_rbyd_appendrev(lfs, &child_, lfsr_rev_btree(lfs));
         if (err) {
             // bad prog? try another block
             if (err == LFS_ERR_CORRUPT) {
@@ -5835,7 +5871,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
         #endif
 
         // copy over tags < split_rid
-        err = lfsr_rbyd_compact(lfs, &rbyd__, &rbyd_, -1, split_rid);
+        err = lfsr_rbyd_compact(lfs, &child_, &child, -1, split_rid);
         if (err) {
             LFS_ASSERT(err != LFS_ERR_RANGE);
             // bad prog? try another block
@@ -5849,7 +5885,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
         //
         // upper layers should make sure this can't fail by limiting the
         // maximum commit size
-        err = lfsr_rbyd_appendrattrs(lfs, &rbyd__, rid_, -1, split_rid,
+        err = lfsr_rbyd_appendrattrs(lfs, &child_, rid_, -1, split_rid,
                 rattrs_, rattr_count_);
         if (err) {
             LFS_ASSERT(err != LFS_ERR_RANGE);
@@ -5861,7 +5897,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
         }
 
         // finalize commit
-        err = lfsr_rbyd_appendcksum(lfs, &rbyd__);
+        err = lfsr_rbyd_appendcksum(lfs, &child_);
         if (err) {
             LFS_ASSERT(err != LFS_ERR_RANGE);
             // bad prog? try another block
@@ -5891,7 +5927,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
         #endif
 
         // copy over tags >= split_rid
-        err = lfsr_rbyd_compact(lfs, &sibling, &rbyd_, split_rid, -1);
+        err = lfsr_rbyd_compact(lfs, &sibling, &child, split_rid, -1);
         if (err) {
             LFS_ASSERT(err != LFS_ERR_RANGE);
             // bad prog? try another block
@@ -5929,9 +5965,9 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
 
         // did one of our siblings drop to zero? yes this can happen! revert
         // to a normal commit in that case
-        if (rbyd__.weight == 0 || sibling.weight == 0) {
-            if (rbyd__.weight == 0) {
-                rbyd__ = sibling;
+        if (child_.weight == 0 || sibling.weight == 0) {
+            if (child_.weight == 0) {
+                child_ = sibling;
             }
             goto commit;
         }
@@ -5949,15 +5985,15 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
         }
 
         // prepare commit to parent, tail recursing upwards
-        LFS_ASSERT(rbyd__.weight > 0);
+        LFS_ASSERT(child_.weight > 0);
         LFS_ASSERT(sibling.weight > 0);
         rattr_count_ = 0;
         // new root?
         if (!lfsr_rbyd_trunk(&parent)) {
             lfsr_data_t branch_l = lfsr_data_frombranch(
-                    &rbyd__, &bctx->buf[0*LFSR_BRANCH_DSIZE]);
+                    &child_, &bctx->buf[0*LFSR_BRANCH_DSIZE]);
             bctx->rattrs[rattr_count_++] = LFSR_RATTR_BUF(
-                    LFSR_TAG_BRANCH, +rbyd__.weight,
+                    LFSR_TAG_BRANCH, +child_.weight,
                     branch_l.u.buffer, lfsr_data_size(branch_l));
             lfsr_data_t branch_r = lfsr_data_frombranch(
                     &sibling, &bctx->buf[1*LFSR_BRANCH_DSIZE]);
@@ -5971,15 +6007,15 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
             }
         // split root?
         } else {
-            bid_ -= pid - (rbyd_.weight-1);
+            bid_ -= pid - (child.weight-1);
             lfsr_data_t branch_l = lfsr_data_frombranch(
-                    &rbyd__, &bctx->buf[0*LFSR_BRANCH_DSIZE]);
+                    &child_, &bctx->buf[0*LFSR_BRANCH_DSIZE]);
             bctx->rattrs[rattr_count_++] = LFSR_RATTR_BUF(
                     LFSR_TAG_BRANCH, 0,
                     branch_l.u.buffer, lfsr_data_size(branch_l));
-            if (rbyd__.weight != rbyd_.weight) {
+            if (child_.weight != child.weight) {
                 bctx->rattrs[rattr_count_++] = LFSR_RATTR(
-                        LFSR_TAG_GROW, -rbyd_.weight + rbyd__.weight);
+                        LFSR_TAG_GROW, -child.weight + child_.weight);
             }
             lfsr_data_t branch_r = lfsr_data_frombranch(
                     &sibling, &bctx->buf[1*LFSR_BRANCH_DSIZE]);
@@ -5994,21 +6030,21 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
         }
         rattrs_ = bctx->rattrs;
 
-        rbyd_ = parent;
+        child = parent;
         rid_ = pid;
         continue;
 
     merge:;
     merge_relocate:;
         // allocate a new rbyd
-        err = lfsr_rbyd_alloc(lfs, &rbyd__);
+        err = lfsr_rbyd_alloc(lfs, &child_);
         if (err) {
             return err;
         }
 
         #if defined(LFS_REVDBG) || defined(LFS_REVNOISE)
         // append a revision count?
-        err = lfsr_rbyd_appendrev(lfs, &rbyd__, lfsr_rev_btree(lfs));
+        err = lfsr_rbyd_appendrev(lfs, &child_, lfsr_rev_btree(lfs));
         if (err) {
             // bad prog? try another block
             if (err == LFS_ERR_CORRUPT) {
@@ -6019,7 +6055,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
         #endif
 
         // merge the siblings together
-        err = lfsr_rbyd_appendcompactrbyd(lfs, &rbyd__, &rbyd_, -1, -1);
+        err = lfsr_rbyd_appendcompactrbyd(lfs, &child_, &child, -1, -1);
         if (err) {
             LFS_ASSERT(err != LFS_ERR_RANGE);
             // bad prog? try another block
@@ -6029,7 +6065,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
             return err;
         }
 
-        err = lfsr_rbyd_appendcompactrbyd(lfs, &rbyd__, &sibling, -1, -1);
+        err = lfsr_rbyd_appendcompactrbyd(lfs, &child_, &sibling, -1, -1);
         if (err) {
             LFS_ASSERT(err != LFS_ERR_RANGE);
             // bad prog? try another block
@@ -6039,7 +6075,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
             return err;
         }
 
-        err = lfsr_rbyd_appendcompaction(lfs, &rbyd__, 0);
+        err = lfsr_rbyd_appendcompaction(lfs, &child_, 0);
         if (err) {
             LFS_ASSERT(err != LFS_ERR_RANGE);
             // bad prog? try another block
@@ -6051,7 +6087,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
 
         // append any pending rattrs, it's up to upper
         // layers to make sure these always fit
-        err = lfsr_rbyd_commit(lfs, &rbyd__, rid_,
+        err = lfsr_rbyd_commit(lfs, &child_, rid_,
                 rattrs_, rattr_count_);
         if (err) {
             LFS_ASSERT(err != LFS_ERR_RANGE);
@@ -6065,47 +6101,51 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
         // we must have a parent at this point, but is our parent the root
         // and is the root degenerate?
         LFS_ASSERT(lfsr_rbyd_trunk(&parent));
-        if (rbyd_.weight+sibling.weight == btree->weight) {
+        if (child.weight+sibling.weight == lfsr_btree_weight(btree)) {
             // collapse the root, decreasing the height of the tree
-            *btree = rbyd__;
+            btree->root = child_;
+            // no new root needed
             *rattr_count = 0;
             return 0;
         }
 
         // prepare commit to parent, tail recursing upwards
-        LFS_ASSERT(rbyd__.weight > 0);
+        LFS_ASSERT(child_.weight > 0);
         rattr_count_ = 0;
         // build attr list
-        bid_ -= pid - (rbyd_.weight-1);
+        bid_ -= pid - (child.weight-1);
         bctx->rattrs[rattr_count_++] = LFSR_RATTR(
                 LFSR_TAG_RM, -sibling.weight);
         lfsr_data_t branch = lfsr_data_frombranch(
-                &rbyd__, &bctx->buf[0*LFSR_BRANCH_DSIZE]);
+                &child_, &bctx->buf[0*LFSR_BRANCH_DSIZE]);
         bctx->rattrs[rattr_count_++] = LFSR_RATTR_BUF(
                 LFSR_TAG_BRANCH, 0,
                 branch.u.buffer, lfsr_data_size(branch));
-        if (rbyd__.weight != rbyd_.weight) {
+        if (child_.weight != child.weight) {
             bctx->rattrs[rattr_count_++] = LFSR_RATTR(
-                    LFSR_TAG_GROW, -rbyd_.weight + rbyd__.weight);
+                    LFSR_TAG_GROW, -child.weight + child_.weight);
         }
         rattrs_ = bctx->rattrs;
 
-        rbyd_ = parent;
+        child = parent;
         rid_ = pid + sibling.weight;
         continue;
 
     commit:;
         // done?
         if (!lfsr_rbyd_trunk(&parent)) {
-            *btree = rbyd__;
+            // update the root
+            btree->root = child_;
+            // no new root needed
             *rattr_count = 0;
             return 0;
         }
 
         // is our parent the root and is the root degenerate?
-        if (rbyd_.weight == btree->weight) {
+        if (child.weight == lfsr_btree_weight(btree)) {
             // collapse the root, decreasing the height of the tree
-            *btree = rbyd__;
+            btree->root = child_;
+            // no new root needed
             *rattr_count = 0;
             return 0;
         }
@@ -6115,24 +6155,24 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
         // note that since we defer merges to compaction time, we can
         // end up removing an rbyd here
         rattr_count_ = 0;
-        bid_ -= pid - (rbyd_.weight-1);
-        if (rbyd__.weight == 0) {
+        bid_ -= pid - (child.weight-1);
+        if (child_.weight == 0) {
             bctx->rattrs[rattr_count_++] = LFSR_RATTR(
-                    LFSR_TAG_RM, -rbyd_.weight);
+                    LFSR_TAG_RM, -child.weight);
         } else {
             lfsr_data_t branch = lfsr_data_frombranch(
-                    &rbyd__, &bctx->buf[0*LFSR_BRANCH_DSIZE]);
+                    &child_, &bctx->buf[0*LFSR_BRANCH_DSIZE]);
             bctx->rattrs[rattr_count_++] = LFSR_RATTR_BUF(
                     LFSR_TAG_BRANCH, 0,
                     branch.u.buffer, lfsr_data_size(branch));
-            if (rbyd__.weight != rbyd_.weight) {
+            if (child_.weight != child.weight) {
                 bctx->rattrs[rattr_count_++] = LFSR_RATTR(
-                        LFSR_TAG_GROW, -rbyd_.weight + rbyd__.weight);
+                        LFSR_TAG_GROW, -child.weight + child_.weight);
             }
         }
         rattrs_ = bctx->rattrs;
 
-        rbyd_ = parent;
+        child = parent;
         rid_ = pid;
         continue;
     }
@@ -6182,81 +6222,83 @@ static int lfsr_btree_commit(lfs_t *lfs, lfsr_btree_t *btree,
             return err;
         }
 
-        *btree = rbyd_;
+        // update the root
+        btree->root = rbyd_;
     }
 
-    LFS_ASSERT(lfsr_rbyd_trunk(btree));
+    // discard the leaf
+    lfsr_btree_discardleaf(btree);
+
+    LFS_ASSERT(lfsr_btree_trunk(btree));
     #ifdef LFS_DBGBTREECOMMITS
     LFS_DEBUG("Committed btree 0x%"PRIx32".%"PRIx32" w%"PRId32", "
                 "cksum %"PRIx32,
-            btree->blocks[0], lfsr_rbyd_trunk(btree),
-            btree->weight,
-            btree->cksum);
+            lfsr_btree_block(btree), lfsr_btree_trunk(btree),
+            lfsr_btree_weight(btree),
+            lfsr_btree_cksum(btree));
     #endif
     return 0;
 }
 
 // lookup in a btree by name
-static lfs_scmp_t lfsr_btree_namelookupleaf(lfs_t *lfs,
-        const lfsr_btree_t *btree,
+static lfs_scmp_t lfsr_btree_namelookup(lfs_t *lfs,
+        lfsr_btree_t *btree,
         lfsr_did_t did, const char *name, lfs_size_t name_len,
-        lfsr_bid_t *bid_, lfsr_rbyd_t *rbyd_, lfsr_srid_t *rid_,
-        lfsr_tag_t *tag_, lfsr_bid_t *weight_, lfsr_data_t *data_) {
+        lfsr_bid_t *bid_, lfsr_tag_t *tag_, lfsr_bid_t *weight_,
+        lfsr_data_t *data_) {
     // an empty tree?
-    if (btree->weight == 0) {
+    if (lfsr_btree_weight(btree) == 0) {
         return LFS_ERR_NOENT;
     }
 
     // descend down the btree looking for our name
-    *rbyd_ = *btree;
-    lfsr_bid_t bid = 0;
+    btree->leaf.bid = lfsr_btree_weight(btree)-1;
+    btree->leaf.rbyd = btree->root;
+    int err;
     while (true) {
-        // each branch is a pair of optional name + on-disk structure
-
         // lookup our name in the rbyd via binary search
         lfsr_srid_t rid__;
         lfsr_tag_t tag__;
         lfsr_rid_t weight__;
         lfsr_data_t data__;
-        lfs_scmp_t cmp = lfsr_rbyd_namelookup(lfs, rbyd_,
+        lfs_scmp_t cmp = lfsr_rbyd_namelookup(lfs, &btree->leaf.rbyd,
                 did, name, name_len,
                 &rid__, &tag__, &weight__, &data__);
         if (cmp < 0) {
             LFS_ASSERT(cmp != LFS_ERR_NOENT);
-            return cmp;
+            err = cmp;
+            goto failed;
         }
 
         // if we found a bname, lookup the branch
         if (tag__ == LFSR_TAG_BNAME) {
-            int err = lfsr_rbyd_lookup(lfs, rbyd_, rid__,
+            err = lfsr_rbyd_lookup(lfs, &btree->leaf.rbyd, rid__,
                     LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
                     &tag__, &data__);
             if (err < 0) {
                 LFS_ASSERT(err != LFS_ERR_NOENT);
-                return err;
+                goto failed;
             }
         }
 
         // found another branch
         if (tag__ == LFSR_TAG_BRANCH) {
-            // update our bid
-            bid += rid__ - (weight__-1);
+            // adjust bid/rid with subtree's weight
+            btree->leaf.bid -= (btree->leaf.rbyd.weight-1) - rid__;
 
             // fetch the next branch
-            int err = lfsr_data_fetchbranch(lfs, &data__, weight__,
-                    rbyd_);
+            err = lfsr_data_fetchbranch(lfs, &data__, weight__,
+                    &btree->leaf.rbyd);
             if (err < 0) {
-                return err;
+                goto failed;
             }
 
         // found our rid
         } else {
             // TODO how many of these should be conditional?
             if (bid_) {
-                *bid_ = bid + rid__;
-            }
-            if (rid_) {
-                *rid_ = rid__;
+                *bid_ = btree->leaf.bid
+                        - ((btree->leaf.rbyd.weight-1) - rid__);
             }
             if (tag_) {
                 *tag_ = tag__;
@@ -6270,17 +6312,12 @@ static lfs_scmp_t lfsr_btree_namelookupleaf(lfs_t *lfs,
             return cmp;
         }
     }
-}
 
-static lfs_scmp_t lfsr_btree_namelookup(lfs_t *lfs,
-        const lfsr_btree_t *btree,
-        lfsr_did_t did, const char *name, lfs_size_t name_len,
-        lfsr_bid_t *bid_,
-        lfsr_tag_t *tag_, lfsr_bid_t *weight_, lfsr_data_t *data_) {
-    lfsr_rbyd_t rbyd;
-    return lfsr_btree_namelookupleaf(lfs, btree,
-            did, name, name_len,
-            bid_, &rbyd, NULL, tag_, weight_, data_);
+failed:;
+    // we need to discard the leaf if it's not a true leaf, otherwise
+    // this breaks lfsr_btree_lookup
+    lfsr_btree_discardleaf(btree);
+    return err;
 }
 
 // incremental btree traversal
@@ -6299,17 +6336,17 @@ static int lfsr_btree_traverse(lfs_t *lfs, const lfsr_btree_t *btree,
         lfsr_bid_t *bid_, lfsr_tag_t *tag_, lfsr_data_t *data_) {
     // explicitly traverse the root even if weight=0
     if (!bt->branch) {
-        bt->branch = btree;
+        bt->branch = &btree->root;
         bt->rid = bt->bid;
 
         // traverse the root
         if (bt->bid == 0
                 // unless we don't even have a root yet
-                && lfsr_rbyd_trunk(btree) != 0
+                && lfsr_btree_trunk(btree) != 0
                 // or are a shrub
-                && !lfsr_rbyd_isshrub(btree)) {
+                && !lfsr_btree_isbshrub(btree)) {
             if (bid_) {
-                *bid_ = btree->weight-1;
+                *bid_ = lfsr_btree_weight(btree)-1;
             }
             if (tag_) {
                 *tag_ = LFSR_TAG_BRANCH;
@@ -6323,7 +6360,7 @@ static int lfsr_btree_traverse(lfs_t *lfs, const lfsr_btree_t *btree,
 
     // need to restart from the root?
     if (bt->rid >= (lfsr_srid_t)bt->branch->weight) {
-        bt->branch = btree;
+        bt->branch = &btree->root;
         bt->rid = bt->bid;
     }
 
@@ -6486,9 +6523,9 @@ static lfs_ssize_t lfsr_shrub_estimate(lfs_t *lfs,
     for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) {
         if (lfsr_o_isbshrub(o->flags)
                 && lfsr_shrub_cmp(
-                    &((lfsr_bshrub_t*)o)->shrub,
+                    &((lfsr_bshrub_t*)o)->shrub.root,
                     shrub) == 0) {
-            last = &((lfsr_bshrub_t*)o)->shrub;
+            last = &((lfsr_bshrub_t*)o)->shrub.root;
         }
     }
     if (last && shrub != last) {
@@ -6518,7 +6555,7 @@ static int lfsr_shrub_compact(lfs_t *lfs, lfsr_rbyd_t *rbyd_,
     for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) {
         if (lfsr_o_isbshrub(o->flags)
                 && lfsr_shrub_cmp(
-                    &((lfsr_bshrub_t*)o)->shrub,
+                    &((lfsr_bshrub_t*)o)->shrub.root,
                     shrub) == 0) {
             ((lfsr_bshrub_t*)o)->shrub_.blocks[0] = rbyd_->blocks[0];
             ((lfsr_bshrub_t*)o)->shrub_.trunk = rbyd_->trunk;
@@ -6577,29 +6614,65 @@ static int lfsr_shrub_commit(lfs_t *lfs, lfsr_rbyd_t *rbyd_,
 // create a non-existant bshrub
 static void lfsr_bshrub_init(lfsr_bshrub_t *bshrub) {
     // set up a null bshrub
-    bshrub->shrub.weight = 0;
-    bshrub->shrub.blocks[0] = -1;
-    bshrub->shrub.trunk = 0;
+    bshrub->shrub.root.weight = 0;
+    bshrub->shrub.root.blocks[0] = -1;
+    bshrub->shrub.root.trunk = 0;
     // force estimate recalculation
-    bshrub->shrub.eoff = -1;
+    bshrub->shrub.root.eoff = -1;
+    // weight=0 indicates no leaf
+    bshrub->shrub.leaf.rbyd.weight = 0;
+}
+
+static inline void lfsr_bshrub_discardleaf(lfsr_bshrub_t *bshrub) {
+    lfsr_btree_discardleaf(&bshrub->shrub);
 }
 
 static inline bool lfsr_bshrub_isbnull(const lfsr_bshrub_t *bshrub) {
-    return !bshrub->shrub.trunk;
+    return !bshrub->shrub.root.trunk;
 }
 
 static inline bool lfsr_bshrub_isbshrub(const lfsr_bshrub_t *bshrub) {
-    return lfsr_shrub_isshrub(&bshrub->shrub);
+    return lfsr_btree_isbshrub(&bshrub->shrub);
 }
 
 static inline bool lfsr_bshrub_isbtree(const lfsr_bshrub_t *bshrub) {
-    return !lfsr_shrub_isshrub(&bshrub->shrub);
+    return !lfsr_btree_isbshrub(&bshrub->shrub);
+}
+
+static inline lfsr_bid_t lfsr_bshrub_weight(const lfsr_bshrub_t *bshrub) {
+    return lfsr_btree_weight(&bshrub->shrub);
+}
+
+static inline lfs_block_t lfsr_bshrub_block(const lfsr_bshrub_t *bshrub) {
+    return lfsr_btree_block(&bshrub->shrub);
+}
+
+static inline lfs_size_t lfsr_bshrub_trunk(const lfsr_bshrub_t *bshrub) {
+    return lfsr_btree_trunk(&bshrub->shrub);
+}
+
+static inline uint32_t lfsr_bshrub_cksum(const lfsr_bshrub_t *bshrub) {
+    return lfsr_btree_cksum(&bshrub->shrub);
 }
 
 static inline int lfsr_bshrub_cmp(
         const lfsr_bshrub_t *a,
         const lfsr_bshrub_t *b) {
-    return lfsr_rbyd_cmp(&a->shrub, &b->shrub);
+    return lfsr_btree_cmp(&a->shrub, &b->shrub);
+}
+
+static lfsr_data_t lfsr_data_frombshrub(const lfsr_bshrub_t *bshrub,
+        uint8_t buffer[static LFSR_SHRUB_DSIZE]) {
+    return lfsr_data_fromshrub(&bshrub->shrub.root, buffer);
+}
+
+static int lfsr_data_readbshrub(lfs_t *lfs, lfsr_data_t *data,
+        const lfsr_mdir_t *mdir,
+        lfsr_bshrub_t *bshrub) {
+    // we just need to make sure to discard the leaf here
+    lfsr_bshrub_discardleaf(bshrub);
+
+    return lfsr_data_readshrub(lfs, data, mdir, &bshrub->shrub.root);
 }
 
 // needed in lfsr_bshrub_estimate
@@ -6644,7 +6717,7 @@ static lfs_ssize_t lfsr_bshrub_estimate(lfs_t *lfs,
                 && o->mdir.mid == bshrub->o.mdir.mid
                 && lfsr_bshrub_isbshrub((lfsr_bshrub_t*)o)) {
             lfs_ssize_t dsize = lfsr_shrub_estimate(lfs,
-                    &((lfsr_bshrub_t*)o)->shrub);
+                    &((lfsr_bshrub_t*)o)->shrub.root);
             if (dsize < 0) {
                 return dsize;
             }
@@ -6656,15 +6729,7 @@ static lfs_ssize_t lfsr_bshrub_estimate(lfs_t *lfs,
 }
 
 // bshrub lookup functions
-static int lfsr_bshrub_lookupleaf(lfs_t *lfs, const lfsr_bshrub_t *bshrub,
-        lfsr_bid_t bid,
-        lfsr_bid_t *bid_, lfsr_rbyd_t *rbyd_, lfsr_srid_t *rid_,
-        lfsr_tag_t *tag_, lfsr_bid_t *weight_, lfsr_data_t *data_) {
-    return lfsr_btree_lookupleaf(lfs, &bshrub->shrub, bid,
-            bid_, rbyd_, rid_, tag_, weight_, data_);
-}
-
-static int lfsr_bshrub_lookupnext(lfs_t *lfs, const lfsr_bshrub_t *bshrub,
+static int lfsr_bshrub_lookupnext(lfs_t *lfs, lfsr_bshrub_t *bshrub,
         lfsr_bid_t bid,
         lfsr_bid_t *bid_, lfsr_tag_t *tag_, lfsr_bid_t *weight_,
         lfsr_data_t *data_) {
@@ -6672,7 +6737,7 @@ static int lfsr_bshrub_lookupnext(lfs_t *lfs, const lfsr_bshrub_t *bshrub,
             bid_, tag_, weight_, data_);
 }
 
-static int lfsr_bshrub_lookup(lfs_t *lfs, const lfsr_bshrub_t *bshrub,
+static int lfsr_bshrub_lookup(lfs_t *lfs, lfsr_bshrub_t *bshrub,
         lfsr_bid_t bid, lfsr_tag_t tag,
         lfsr_tag_t *tag_, lfsr_data_t *data_) {
     return lfsr_btree_lookup(lfs, &bshrub->shrub, bid, tag,
@@ -6699,8 +6764,8 @@ static int lfsr_bshrub_commit(lfs_t *lfs, lfsr_bshrub_t *bshrub,
         for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) {
             if (lfsr_o_isbshrub(o->flags)
                     && o != &bshrub->o
-                    && ((lfsr_bshrub_t*)o)->shrub.blocks[0]
-                        == bshrub->shrub.blocks[0]) {
+                    && lfsr_bshrub_block((lfsr_bshrub_t*)o)
+                        == lfsr_bshrub_block(bshrub)) {
                 // mark as unerased
                 lfsr_btree_claim(&((lfsr_bshrub_t*)o)->shrub);
             }
@@ -6739,7 +6804,9 @@ static int lfsr_bshrub_commit(lfs_t *lfs, lfsr_bshrub_t *bshrub,
 
         // does our estimate exceed our inline_size? need to recalculate an
         // accurate estimate
-        lfs_ssize_t estimate = (alloc) ? (lfs_size_t)-1 : bshrub->shrub.eoff;
+        lfs_ssize_t estimate = (alloc)
+                ? (lfs_size_t)-1
+                : bshrub->shrub.root.eoff;
         // this double condition avoids overflow issues
         if ((lfs_size_t)estimate > lfs->cfg->inline_size
                 || estimate + commit_estimate > lfs->cfg->inline_size) {
@@ -6766,7 +6833,7 @@ static int lfsr_bshrub_commit(lfs_t *lfs, lfsr_bshrub_t *bshrub,
         estimate += commit_estimate;
 
         // commit to shrub
-        int err = lfsr_mdir_commit(lfs, &bshrub->o.mdir, LFSR_RATTRS(
+        err = lfsr_mdir_commit(lfs, &bshrub->o.mdir, LFSR_RATTRS(
                 LFSR_RATTR_SHRUBCOMMIT(
                     (&(lfsr_shrubcommit_t){
                         .bshrub=bshrub,
@@ -6776,33 +6843,36 @@ static int lfsr_bshrub_commit(lfs_t *lfs, lfsr_bshrub_t *bshrub,
         if (err) {
             return err;
         }
-        LFS_ASSERT(bshrub->shrub.blocks[0] == bshrub->o.mdir.rbyd.blocks[0]);
+        LFS_ASSERT(lfsr_bshrub_block(bshrub) == bshrub->o.mdir.rbyd.blocks[0]);
 
         // update _all_ shrubs with the new estimate
         for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) {
             if (lfsr_o_isbshrub(o->flags)
                     && o->mdir.mid == bshrub->o.mdir.mid
                     && lfsr_bshrub_isbshrub((lfsr_bshrub_t*)o)) {
-                ((lfsr_bshrub_t*)o)->shrub.eoff = estimate;
+                ((lfsr_bshrub_t*)o)->shrub.root.eoff = estimate;
             }
         }
-        LFS_ASSERT(bshrub->shrub.eoff == (lfs_size_t)estimate);
+        LFS_ASSERT(bshrub->shrub.root.eoff == (lfs_size_t)estimate);
     }
 
-    LFS_ASSERT(lfsr_shrub_trunk(&bshrub->shrub));
+    // discard the leaf
+    lfsr_bshrub_discardleaf(bshrub);
+
+    LFS_ASSERT(lfsr_bshrub_trunk(bshrub));
     #ifdef LFS_DBGBTREECOMMITS
     if (lfsr_bshrub_isbshrub(bshrub)) {
         LFS_DEBUG("Committed bshrub "
                     "0x{%"PRIx32",%"PRIx32"}.%"PRIx32" w%"PRId32,
                 bshrub->o.mdir.rbyd.blocks[0], bshrub->o.mdir.rbyd.blocks[1],
-                lfsr_shrub_trunk(&bshrub->shrub),
-                bshrub->shrub.weight);
+                lfsr_bshrub_trunk(bshrub),
+                lfsr_bshrub_weight(bshrub));
     } else {
         LFS_DEBUG("Committed btree 0x%"PRIx32".%"PRIx32" w%"PRId32", "
                     "cksum %"PRIx32,
-                bshrub->shrub.blocks[0], lfsr_shrub_trunk(&bshrub->shrub),
-                bshrub->shrub.weight,
-                bshrub->shrub.cksum);
+                lfsr_bshrub_block(bshrub), lfsr_bshrub_trunk(bshrub),
+                lfsr_bshrub_weight(bshrub),
+                lfsr_bshrub_cksum(bshrub));
     }
     #endif
     return 0;
@@ -6828,7 +6898,8 @@ relocate:;
 
     // note this may be a new root
     if (!alloc) {
-        err = lfsr_rbyd_compact(lfs, &bshrub->shrub_, &bshrub->shrub, -1, -1);
+        err = lfsr_rbyd_compact(lfs, &bshrub->shrub_,
+                &bshrub->shrub.root, -1, -1);
         if (err) {
             LFS_ASSERT(err != LFS_ERR_RANGE);
             // bad prog? try another block
@@ -6849,15 +6920,19 @@ relocate:;
         return err;
     }
 
-    bshrub->shrub = bshrub->shrub_;
+    // update the root
+    bshrub->shrub.root = bshrub->shrub_;
 
-    LFS_ASSERT(lfsr_rbyd_trunk(&bshrub->shrub));
+    // discard the leaf
+    lfsr_bshrub_discardleaf(bshrub);
+
+    LFS_ASSERT(lfsr_bshrub_trunk(bshrub));
     #ifdef LFS_DBGBTREECOMMITS
     LFS_DEBUG("Committed btree 0x%"PRIx32".%"PRIx32" w%"PRId32", "
                 "cksum %"PRIx32,
-            bshrub->shrub.blocks[0], lfsr_shrub_trunk(&bshrub->shrub),
-            bshrub->shrub.weight,
-            bshrub->shrub.cksum);
+            lfsr_bshrub_block(bshrub), lfsr_bshrub_trunk(bshrub),
+            lfsr_bshrub_weight(bshrub),
+            lfsr_bshrub_cksum(bshrub));
     #endif
     return 0;
 }
@@ -6882,7 +6957,7 @@ static inline lfsr_srid_t lfsr_mrid(const lfs_t *lfs, lfsr_smid_t mid) {
 
 // these should only be used for logging
 static inline lfsr_sbid_t lfsr_dbgmbid(const lfs_t *lfs, lfsr_smid_t mid) {
-    if (lfs->mtree.weight == 0) {
+    if (lfsr_btree_weight(&lfs->mtree) == 0) {
         return -1;
     } else {
         return mid >> lfs->mbits;
@@ -7747,7 +7822,7 @@ static int lfsr_mdir_lookup(lfs_t *lfs, const lfsr_mdir_t *mdir,
 
 static inline lfsr_mid_t lfsr_mtree_weight(lfs_t *lfs) {
     return lfs_max(
-            lfs->mtree.weight,
+            lfsr_btree_weight(&lfs->mtree),
             1 << lfs->mbits);
 }
 
@@ -7763,7 +7838,7 @@ static int lfsr_mtree_lookup(lfs_t *lfs, lfsr_smid_t mid,
     }
 
     // looking up mroot?
-    if (lfs->mtree.weight == 0) {
+    if (lfsr_btree_weight(&lfs->mtree) == 0) {
         // treat inlined mdir as mid=0
         mdir_->mid = mid;
         lfsr_mdir_sync(mdir_, &lfs->mroot);
@@ -7772,12 +7847,11 @@ static int lfsr_mtree_lookup(lfs_t *lfs, lfsr_smid_t mid,
     // look up mdir in actual mtree
     } else {
         lfsr_bid_t bid;
-        lfsr_srid_t rid;
         lfsr_tag_t tag;
         lfsr_bid_t weight;
         lfsr_data_t data;
-        int err = lfsr_btree_lookupleaf(lfs, &lfs->mtree, mid,
-                &bid, &mdir_->rbyd, &rid, &tag, &weight, &data);
+        int err = lfsr_btree_lookupnext(lfs, &lfs->mtree, mid,
+                &bid, &tag, &weight, &data);
         if (err) {
             LFS_ASSERT(err != LFS_ERR_NOENT);
             return err;
@@ -7789,7 +7863,7 @@ static int lfsr_mtree_lookup(lfs_t *lfs, lfsr_smid_t mid,
 
         // if we found an mname, lookup the mdir
         if (tag == LFSR_TAG_MNAME) {
-            err = lfsr_rbyd_lookup(lfs, &mdir_->rbyd, rid, LFSR_TAG_MDIR,
+            err = lfsr_btree_lookup(lfs, &lfs->mtree, bid, LFSR_TAG_MDIR,
                     NULL, &data);
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_NOENT);
@@ -8062,7 +8136,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
                                 != mdir->rbyd.blocks[0]) {
                         int err = lfsr_shrub_compact(lfs, &mdir->rbyd,
                                 &((lfsr_bshrub_t*)o)->shrub_,
-                                &((lfsr_bshrub_t*)o)->shrub);
+                                &((lfsr_bshrub_t*)o)->shrub.root);
                         if (err) {
                             return err;
                         }
@@ -8279,7 +8353,7 @@ static lfs_ssize_t lfsr_mdir_estimate__(lfs_t *lfs, const lfsr_mdir_t *mdir,
                     // is a bshrub?
                     && lfsr_bshrub_isbshrub((lfsr_bshrub_t*)o)) {
                 lfs_ssize_t dsize__ = lfsr_shrub_estimate(lfs,
-                        &((lfsr_bshrub_t*)o)->shrub);
+                        &((lfsr_bshrub_t*)o)->shrub.root);
                 if (dsize__ < 0) {
                     return dsize__;
                 }
@@ -8405,7 +8479,7 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_,
                     != mdir_->rbyd.blocks[0]) {
             int err = lfsr_shrub_compact(lfs, &mdir_->rbyd,
                     &((lfsr_bshrub_t*)o)->shrub_,
-                    &((lfsr_bshrub_t*)o)->shrub);
+                    &((lfsr_bshrub_t*)o)->shrub.root);
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_RANGE);
                 return err;
@@ -8653,9 +8727,9 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
             // a bshrub outside of its mdir means something has gone
             // horribly wrong
             LFS_ASSERT(!lfsr_bshrub_isbshrub((lfsr_bshrub_t*)o)
-                    || ((lfsr_bshrub_t*)o)->shrub.blocks[0]
+                    || lfsr_bshrub_block((lfsr_bshrub_t*)o)
                         == o->mdir.rbyd.blocks[0]);
-            ((lfsr_bshrub_t*)o)->shrub_ = ((lfsr_bshrub_t*)o)->shrub;
+            ((lfsr_bshrub_t*)o)->shrub_ = ((lfsr_bshrub_t*)o)->shrub.root;
         }
     }
 
@@ -8696,7 +8770,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
     if (err == LFS_ERR_RANGE) {
         // this should not happen unless we can't fit our mroot's metadata
         LFS_ASSERT(lfsr_mdir_cmp(mdir, &lfs->mroot) != 0
-                || lfs->mtree.weight == 0);
+                || lfsr_btree_weight(&lfs->mtree) == 0);
 
         // if we're not the mroot, we need to consume the gstate so
         // we don't lose any info during the split
@@ -8813,7 +8887,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
         }
 
         // new mtree?
-        if (lfs->mtree.weight == 0) {
+        if (lfsr_btree_weight(&lfs->mtree) == 0) {
             lfsr_btree_init(&mtree_);
 
             err = lfsr_mtree_commit(lfs, &mtree_,
@@ -8870,7 +8944,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
         mdelta = -(1 << lfs->mbits);
 
         // how can we drop if we have no mtree?
-        LFS_ASSERT(lfs->mtree.weight != 0);
+        LFS_ASSERT(lfsr_btree_weight(&lfs->mtree) > 0);
 
         // mark as unerased in case of failure
         lfsr_btree_claim(&lfs->mtree);
@@ -8895,7 +8969,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
 
     relocated:;
         // new mtree?
-        if (lfs->mtree.weight == 0) {
+        if (lfsr_btree_weight(&lfs->mtree) == 0) {
             lfsr_btree_init(&mtree_);
 
             err = lfsr_mtree_commit(lfs, &mtree_,
@@ -8941,7 +9015,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
     // need to update mtree?
     if (lfsr_btree_cmp(&mtree_, &lfs->mtree) != 0) {
         // mtree should never go to zero since we always have a root bookmark
-        LFS_ASSERT(mtree_.weight > 0);
+        LFS_ASSERT(lfsr_btree_weight(&mtree_) > 0);
 
         // make sure mtree/mroot changes are on-disk before committing
         // metadata
@@ -9177,15 +9251,16 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
         // leaves that moved
         if (lfsr_o_type(o->flags) == LFS_TYPE_REG
                 && lfsr_bptr_block(&((lfsr_file_t*)o)->leaf.bptr)
-                    == ((lfsr_bshrub_t*)o)->shrub.blocks[0]
+                    == lfsr_bshrub_block((lfsr_bshrub_t*)o)
                 && ((lfsr_bshrub_t*)o)->shrub_.blocks[0]
-                    != ((lfsr_bshrub_t*)o)->shrub.blocks[0]) {
+                    != lfsr_bshrub_block((lfsr_bshrub_t*)o)) {
             lfsr_file_discardleaf((lfsr_file_t*)o);
         }
 
         // update the shrub
         if (lfsr_o_isbshrub(o->flags)) {
-            ((lfsr_bshrub_t*)o)->shrub = ((lfsr_bshrub_t*)o)->shrub_;
+            ((lfsr_bshrub_t*)o)->shrub.root = ((lfsr_bshrub_t*)o)->shrub_;
+            lfsr_bshrub_discardleaf((lfsr_bshrub_t*)o);
         }
     }
 
@@ -9281,7 +9356,7 @@ static int lfsr_mtree_namelookup(lfs_t *lfs,
         lfsr_did_t did, const char *name, lfs_size_t name_len,
         lfsr_mdir_t *mdir_, lfsr_tag_t *tag_, lfsr_data_t *data_) {
     // do we only have mroot?
-    if (lfs->mtree.weight == 0) {
+    if (lfsr_btree_weight(&lfs->mtree) == 0) {
         // treat inlined mdir as mid=0
         mdir_->mid = 0;
         lfsr_mdir_sync(mdir_, &lfs->mroot);
@@ -9289,13 +9364,12 @@ static int lfsr_mtree_namelookup(lfs_t *lfs,
     // lookup name in actual mtree
     } else {
         lfsr_bid_t bid;
-        lfsr_srid_t rid;
         lfsr_tag_t tag;
         lfsr_bid_t weight;
         lfsr_data_t data;
-        lfs_scmp_t cmp = lfsr_btree_namelookupleaf(lfs, &lfs->mtree,
+        lfs_scmp_t cmp = lfsr_btree_namelookup(lfs, &lfs->mtree,
                 did, name, name_len,
-                &bid, &mdir_->rbyd, &rid, &tag, &weight, &data);
+                &bid, &tag, &weight, &data);
         if (cmp < 0) {
             LFS_ASSERT(cmp != LFS_ERR_NOENT);
             return cmp;
@@ -9306,7 +9380,7 @@ static int lfsr_mtree_namelookup(lfs_t *lfs,
 
         // if we found an mname, lookup the mdir
         if (tag == LFSR_TAG_MNAME) {
-            int err = lfsr_rbyd_lookup(lfs, &mdir_->rbyd, rid, LFSR_TAG_MDIR,
+            int err = lfsr_btree_lookup(lfs, &lfs->mtree, bid, LFSR_TAG_MDIR,
                     NULL, &data);
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_NOENT);
@@ -9681,8 +9755,8 @@ static int lfsr_mtree_traverse_(lfs_t *lfs, lfsr_traversal_t *t,
                         || tag == LFSR_TAG_BTREE)) {
                 // found a bshrub (inlined btree)?
                 if (tag == LFSR_TAG_BSHRUB) {
-                    err = lfsr_data_readshrub(lfs, &data, &t->b.o.mdir,
-                            &t->b.shrub);
+                    err = lfsr_data_readbshrub(lfs, &data, &t->b.o.mdir,
+                            &t->b);
                     if (err) {
                         return err;
                     }
@@ -11298,7 +11372,7 @@ static inline lfs_size_t lfsr_file_cachesize(lfs_t *lfs,
 static inline lfs_off_t lfsr_file_weight(const lfsr_file_t *file) {
     return lfs_max(
             file->leaf.pos + file->leaf.weight,
-            file->b.shrub.weight);
+            lfsr_bshrub_weight(&file->b));
 }
 
 static inline lfs_off_t lfsr_file_size_(const lfsr_file_t *file) {
@@ -11331,17 +11405,16 @@ static int lfsr_file_fetch(lfs_t *lfs, lfsr_file_t *file, bool trunc) {
             return err;
         }
 
-        // note many of these functions leave bshrub undefined if
-        // there is an error, so we first read into the staging
-        // bshrub
-        file->b.shrub_ = file->b.shrub;
+        // note many of these functions leave bshrub undefined if there
+        // is an error, so we first read into a temporary bshrub/btree
+        lfsr_bshrub_t b = file->b;
 
         // found a bshrub/btree?
         if (err != LFS_ERR_NOENT) {
             // may be a bshrub (inlined btree)
             if (tag == LFSR_TAG_BSHRUB) {
-                err = lfsr_data_readshrub(lfs, &data, &file->b.o.mdir,
-                        &file->b.shrub_);
+                err = lfsr_data_readbshrub(lfs, &data, &file->b.o.mdir,
+                        &b);
                 if (err) {
                     return err;
                 }
@@ -11349,7 +11422,7 @@ static int lfsr_file_fetch(lfs_t *lfs, lfsr_file_t *file, bool trunc) {
             // or a btree
             } else if (tag == LFSR_TAG_BTREE) {
                 err = lfsr_data_fetchbtree(lfs, &data,
-                        &file->b.shrub_);
+                        &b.shrub);
                 if (err) {
                     return err;
                 }
@@ -11359,8 +11432,8 @@ static int lfsr_file_fetch(lfs_t *lfs, lfsr_file_t *file, bool trunc) {
             }
         }
 
-        // update the bshrub
-        file->b.shrub = file->b.shrub_;
+        // update the bshrub/btree
+        file->b = b;
 
         // mark as in-sync
         file->b.o.flags &= ~LFS_o_UNSYNC;
@@ -11638,7 +11711,7 @@ int lfsr_file_close(lfs_t *lfs, lfsr_file_t *file) {
 
 // low-level file reading
 
-static int lfsr_file_lookup_(lfs_t *lfs, const lfsr_file_t *file,
+static int lfsr_file_lookup_(lfs_t *lfs, lfsr_file_t *file,
         lfsr_bid_t bid,
         lfsr_bid_t *bid_, lfsr_bid_t *weight_, lfsr_bptr_t *bptr_) {
     lfsr_tag_t tag;
@@ -11672,7 +11745,7 @@ static int lfsr_file_lookup_(lfs_t *lfs, const lfsr_file_t *file,
     return 0;
 }
 
-static int lfsr_file_lookup(lfs_t *lfs, const lfsr_file_t *file,
+static int lfsr_file_lookup(lfs_t *lfs, lfsr_file_t *file,
         lfsr_bid_t bid,
         lfsr_bid_t *bid_, lfsr_bid_t *weight_, lfsr_bptr_t *bptr_) {
     // hits our leaf?
@@ -11690,12 +11763,12 @@ static int lfsr_file_lookup(lfs_t *lfs, const lfsr_file_t *file,
 
     // in between bshrub/btree and ungrafted leaf? pretend there's a
     // hole here
-    if (bid >= file->b.shrub.weight && bid < file->leaf.pos) {
+    if (bid >= lfsr_bshrub_weight(&file->b) && bid < file->leaf.pos) {
         if (bid_) {
             *bid_ = file->leaf.pos-1;
         }
         if (weight_) {
-            *weight_ = file->leaf.pos - file->b.shrub.weight;
+            *weight_ = file->leaf.pos - lfsr_bshrub_weight(&file->b);
         }
         lfsr_bptr_discard(bptr_);
         return 0;
@@ -11938,38 +12011,38 @@ static int lfsr_file_graft(lfs_t *lfs, lfsr_file_t *file,
 
     // carving the entire tree? revert to no bshrub/btree
     if (pos == 0
-            && weight >= file->b.shrub.weight
+            && weight >= lfsr_bshrub_weight(&file->b)
             && delta == -(lfs_soff_t)weight) {
         lfsr_file_discardbshrub(file);
         return 0;
     }
 
     // try to merge commits where possible
-    lfsr_bid_t bid = file->b.shrub.weight;
+    lfsr_bid_t bid = lfsr_bshrub_weight(&file->b);
     lfsr_rattr_t rattrs[3];
     lfs_size_t rattr_count = 0;
     lfsr_bptr_t l;
     lfsr_bptr_t r;
 
     // need a hole?
-    if (pos > file->b.shrub.weight) {
+    if (pos > lfsr_bshrub_weight(&file->b)) {
         // can we coalesce?
-        if (file->b.shrub.weight > 0) {
-            bid = lfs_min(bid, file->b.shrub.weight-1);
+        if (lfsr_bshrub_weight(&file->b) > 0) {
+            bid = lfs_min(bid, lfsr_bshrub_weight(&file->b)-1);
             rattrs[rattr_count++] = LFSR_RATTR(
-                    LFSR_TAG_GROW, +(pos - file->b.shrub.weight));
+                    LFSR_TAG_GROW, +(pos - lfsr_bshrub_weight(&file->b)));
 
         // new hole
         } else {
-            bid = lfs_min(bid, file->b.shrub.weight);
+            bid = lfs_min(bid, lfsr_bshrub_weight(&file->b));
             rattrs[rattr_count++] = LFSR_RATTR(
-                    LFSR_TAG_DATA, +(pos - file->b.shrub.weight));
+                    LFSR_TAG_DATA, +(pos - lfsr_bshrub_weight(&file->b)));
         }
     }
 
     // try to carve any existing data
     lfsr_rattr_t r_rattr_ = {.tag=0};
-    while (pos < file->b.shrub.weight) {
+    while (pos < lfsr_bshrub_weight(&file->b)) {
         lfsr_bid_t weight_;
         lfsr_bptr_t bptr_;
         int err = lfsr_file_lookup_(lfs, file, pos,
@@ -12148,26 +12221,26 @@ static int lfsr_file_graft(lfs_t *lfs, lfsr_file_t *file,
 
         // can we coalesce a hole?
         if (dsize == 0 && pos > 0) {
-            bid = lfs_min(bid, file->b.shrub.weight-1);
+            bid = lfs_min(bid, lfsr_bshrub_weight(&file->b)-1);
             rattrs[rattr_count++] = LFSR_RATTR(
                     LFSR_TAG_GROW, +(weight + delta));
 
         // need a new hole?
         } else if (dsize == 0) {
-            bid = lfs_min(bid, file->b.shrub.weight);
+            bid = lfs_min(bid, lfsr_bshrub_weight(&file->b));
             rattrs[rattr_count++] = LFSR_RATTR(
                     LFSR_TAG_DATA, +(weight + delta));
 
         // append a new fragment?
         } else if (data_count >= 0) {
-            bid = lfs_min(bid, file->b.shrub.weight);
+            bid = lfs_min(bid, lfsr_bshrub_weight(&file->b));
             rattrs[rattr_count++] = LFSR_RATTR_CAT_(
                     LFSR_TAG_DATA, +(weight + delta),
                     datas, data_count);
 
         // append a new bptr?
         } else {
-            bid = lfs_min(bid, file->b.shrub.weight);
+            bid = lfs_min(bid, lfsr_bshrub_weight(&file->b));
             rattrs[rattr_count++] = LFSR_RATTR_BPTR(
                     LFSR_TAG_BLOCK, +(weight + delta),
                     (const lfsr_bptr_t*)datas);
@@ -12662,7 +12735,7 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file,
         // block alignment, we use the entry immediately to the left of
         // our crystal for this
         if (crystal_start > 0
-                && file->b.shrub.weight > 0
+                && lfsr_bshrub_weight(&file->b) > 0
                 // don't bother to lookup left after the first block
                 && !aligned) {
             lfsr_bid_t bid;
@@ -12671,7 +12744,7 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file,
             int err = lfsr_file_lookup(lfs, file,
                     lfs_min(
                         crystal_start-1,
-                        file->b.shrub.weight-1),
+                        lfsr_bshrub_weight(&file->b)-1),
                     &bid, &weight, &bptr);
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_NOENT);
@@ -14519,8 +14592,8 @@ static int lfsr_mountinited(lfs_t *lfs) {
         } else if (tag == LFSR_TAG_BRANCH) {
             lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr.data.u.buffer;
             // found the root of the mtree? keep track of this
-            if (lfs->mtree.weight == 0) {
-                lfs->mtree = *rbyd;
+            if (lfsr_btree_weight(&lfs->mtree) == 0) {
+                lfs->mtree.root = *rbyd;
             }
 
         } else {
@@ -14725,7 +14798,7 @@ int lfsr_mount(lfs_t *lfs, uint32_t flags,
             lfs->mroot.rbyd.blocks[0],
             lfs->mroot.rbyd.blocks[1],
             lfsr_rbyd_trunk(&lfs->mroot.rbyd),
-            lfs->mtree.weight >> lfs->mbits,
+            lfsr_btree_weight(&lfs->mtree) >> lfs->mbits,
             1 << lfs->mbits,
             lfs->gcksum);
 
diff --git a/lfs.h b/lfs.h
index 0aa407c0..b885f36f 100644
--- a/lfs.h
+++ b/lfs.h
@@ -681,8 +681,15 @@ typedef struct lfsr_rbyd {
     uint32_t cksum;
 } lfsr_rbyd_t;
 
-// a btree is represented by the root rbyd
-typedef lfsr_rbyd_t lfsr_btree_t;
+// all we need for btrees is the root rbyd, but tracking the most recent
+// leaf helps speed up iteration/attr lookup/etc
+typedef struct lfsr_btree {
+    lfsr_rbyd_t root;
+    struct {
+        lfsr_bid_t bid;
+        lfsr_rbyd_t rbyd;
+    } leaf;
+} lfsr_btree_t;
 
 // littlefs's atomic metadata log type
 typedef struct lfsr_mdir {
@@ -709,7 +716,7 @@ typedef struct lfsr_bshrub {
     // trunk=0       => no bshrub/btree
     // sign(trunk)=1 => bshrub
     // sign(trunk)=0 => btree
-    lfsr_shrub_t shrub;
+    lfsr_btree_t shrub;
     lfsr_shrub_t shrub_;
 } lfsr_bshrub_t;
 
diff --git a/tests/test_badblocks.toml b/tests/test_badblocks.toml
index 01f23a08..17fdd384 100644
--- a/tests/test_badblocks.toml
+++ b/tests/test_badblocks.toml
@@ -98,10 +98,10 @@ code = '''
         }
         printf("]\n");
         printf("btree: w%d 0x%x.%x\n",
-                btree.weight,
-                btree.blocks[0],
-                btree.trunk);
-        assert(btree.weight == sim_size);
+                lfsr_btree_weight(&btree),
+                lfsr_btree_block(&btree),
+                lfsr_btree_trunk(&btree));
+        assert(lfsr_btree_weight(&btree) == sim_size);
 
         uint8_t buffer[4];
         lfsr_bid_t bid_;
@@ -2053,10 +2053,10 @@ code = '''
     }
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == sim_size);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == sim_size);
 
     uint8_t buffer[4];
     lfsr_bid_t bid_;
@@ -4010,10 +4010,10 @@ code = '''
     }
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == sim_size);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == sim_size);
 
     uint8_t buffer[4];
     lfsr_bid_t bid_;
diff --git a/tests/test_btree.toml b/tests/test_btree.toml
index 82826b81..49092c60 100644
--- a/tests/test_btree.toml
+++ b/tests/test_btree.toml
@@ -23,10 +23,10 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_init(&btree);
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == 0);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == 0);
 
     // try looking up tags
     lfsr_bid_t bid_;
@@ -58,10 +58,10 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
             LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "a", 1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == 1);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == 1);
 
     // try looking up tags
     uint8_t buffer[4];
@@ -104,10 +104,10 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
             LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "b", 1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == 2);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == 2);
 
     // try looking up tags
     uint8_t buffer[4];
@@ -155,10 +155,10 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
             LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "a", 1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == 2);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == 2);
 
     // try looking up tags
     uint8_t buffer[4];
@@ -209,10 +209,10 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS(
             LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "c", 1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == 3);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == 3);
 
     // try looking up tags
     uint8_t buffer[4];
@@ -269,10 +269,10 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
             LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "a", 1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == 3);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == 3);
 
     // try looking up tags
     uint8_t buffer[4];
@@ -334,10 +334,10 @@ code = '''
         n += 1;
     }
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == n);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == n);
 
     // check that the elements are in the tree
     uint8_t buffer[4];
@@ -386,10 +386,10 @@ code = '''
         n += 1;
     }
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == n);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == n);
 
     // check that the elements are in the tree
     uint8_t buffer[4];
@@ -469,10 +469,10 @@ code = '''
     }
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == sim_size);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == sim_size);
 
     uint8_t buffer[4];
     lfsr_bid_t bid_;
@@ -524,10 +524,10 @@ code = '''
         n += 1;
     }
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == n*W);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == n*W);
 
     // check that the elements are in the tree
     uint8_t buffer[4];
@@ -643,15 +643,15 @@ code = '''
     }
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
 
     lfs_size_t total_weight = 0;
     for (lfs_size_t j = 0; j < sim_size; j++) {
         total_weight += sim_weights[j];
     }
-    assert(btree.weight == total_weight);
+    assert(lfsr_btree_weight(&btree) == total_weight);
 
     uint8_t buffer[4];
     lfsr_bid_t bid_;
@@ -730,10 +730,10 @@ code = '''
                 LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0,
                 "A", 1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == 1);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == 1);
 
     // try looking up tags
     uint8_t buffer[4];
@@ -783,10 +783,10 @@ code = '''
                 LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0,
                 "B", 1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == 2);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == 2);
 
     // try looking up tags
     uint8_t buffer[4];
@@ -849,10 +849,10 @@ code = '''
                 LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0,
                 "C", 1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == 3);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == 3);
 
     // try looking up tags
     uint8_t buffer[4];
@@ -917,10 +917,10 @@ code = '''
                     &(uint8_t){'A'+(i % 26)}, 1))) => 0;
     }
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == N);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == N);
 
     // check that the elements are in the tree
     uint8_t buffer[4];
@@ -1005,10 +1005,10 @@ code = '''
     }
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == N);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == N);
 
     uint8_t buffer[4];
     lfsr_bid_t bid_;
@@ -1064,10 +1064,10 @@ code = '''
                     &(uint8_t){'A'+(i % 26)}, 1))) => 0;
     }
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == N*W);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == N*W);
 
     // check that the elements are in the tree
     uint8_t buffer[4];
@@ -1189,15 +1189,15 @@ code = '''
     }
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
 
     lfs_size_t total_weight = 0;
     for (lfs_size_t j = 0; j < N; j++) {
         total_weight += sim_weights[j];
     }
-    assert(btree.weight == total_weight);
+    assert(lfsr_btree_weight(&btree) == total_weight);
 
     uint8_t buffer[4];
     lfsr_bid_t bid_;
@@ -1275,10 +1275,10 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == 0);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == 0);
 
     // try looking up tags
     uint8_t buffer[4];
@@ -1294,10 +1294,10 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
             LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "A", 1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == 1);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == 1);
 
     // try looking up tags
     lfsr_btree_lookupnext(&lfs, &btree, 0,
@@ -1335,10 +1335,10 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == 1);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == 1);
 
     // try looking up tags
     uint8_t buffer[4];
@@ -1361,10 +1361,10 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
             LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "B", 1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == 2);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == 2);
 
     // try looking up tags
     lfsr_btree_lookupnext(&lfs, &btree, 0,
@@ -1409,10 +1409,10 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == 1);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == 1);
 
     // try looking up tags
     uint8_t buffer[4];
@@ -1435,10 +1435,10 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
             LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "A", 1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == 2);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == 2);
 
     // try looking up tags
     lfsr_btree_lookupnext(&lfs, &btree, 0,
@@ -1485,10 +1485,10 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS(
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == 2);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == 2);
 
     // try looking up tags
     uint8_t buffer[4];
@@ -1518,10 +1518,10 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS(
             LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "C", 1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == 3);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == 3);
 
     // try looking up tags
     lfsr_btree_lookupnext(&lfs, &btree, 0,
@@ -1581,10 +1581,10 @@ code = '''
     }
 
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == REMAINING);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == REMAINING);
 
     // check that the elements are in the tree
     uint8_t buffer[4];
@@ -1661,10 +1661,10 @@ code = '''
                 LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
     }
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == REMAINING);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == REMAINING);
 
     // check that the elements are in the tree
     uint8_t buffer[4];
@@ -1776,10 +1776,10 @@ code = '''
     }
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == sim_size);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == sim_size);
 
     uint8_t buffer[4];
     lfsr_bid_t bid_;
@@ -1835,10 +1835,10 @@ code = '''
                 LFSR_RATTR(LFSR_TAG_RM, -W))) => 0;
     }
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == REMAINING*W);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == REMAINING*W);
 
     // check that the elements are in the tree
     uint8_t buffer[4];
@@ -2004,15 +2004,15 @@ code = '''
     }
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
 
     lfs_size_t total_weight = 0;
     for (lfs_size_t j = 0; j < sim_size; j++) {
         total_weight += sim_weights[j];
     }
-    assert(btree.weight == total_weight);
+    assert(lfsr_btree_weight(&btree) == total_weight);
 
     uint8_t buffer[4];
     lfsr_bid_t bid_;
@@ -2098,10 +2098,10 @@ code = '''
         n += 1;
     }
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == n);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == n);
 
     // check that the elements are in the tree
     uint8_t buffer[4];
@@ -2188,10 +2188,10 @@ code = '''
     }
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == sim_size);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == sim_size);
 
     uint8_t buffer[4];
     lfsr_bid_t bid_;
@@ -2250,10 +2250,10 @@ code = '''
         n += 1;
     }
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == n*W);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == n*W);
 
     // check that the elements are in the tree
     uint8_t buffer[4];
@@ -2352,7 +2352,7 @@ code = '''
         for (lfs_size_t j = 0; j < sim_size; j++) {
             total_weight += sim_weights[j];
         }
-        assert(btree.weight == total_weight);
+        assert(lfsr_btree_weight(&btree) == total_weight);
 
         uint8_t buffer[4];
         lfsr_bid_t bid_;
@@ -2394,15 +2394,15 @@ code = '''
     }
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
 
     lfs_size_t total_weight = 0;
     for (lfs_size_t j = 0; j < sim_size; j++) {
         total_weight += sim_weights[j];
     }
-    assert(btree.weight == total_weight);
+    assert(lfsr_btree_weight(&btree) == total_weight);
 
     uint8_t buffer[4];
     lfsr_bid_t bid_;
@@ -2488,13 +2488,13 @@ code = '''
             LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, buf1, SIZE),
             LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, buf2, SIZE))) => 0;
     // force compaction
-    btree.eoff = -1;
+    lfsr_btree_claim(&btree);
     memset(buf2, 'b', SIZE);
     lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
             LFSR_RATTR_BUF(
                 LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0,
                 buf2, SIZE))) => 0;
-    assert(btree.weight == 2);
+    assert(lfsr_btree_weight(&btree) == 2);
 
     // now remove one entry, since this brings the rbyd down to zero,
     // this should force one of the blocks to drop
@@ -2502,10 +2502,10 @@ code = '''
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
 
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == 1);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == 1);
 
     // check that our other entry is fine
     lfsr_bid_t bid_;
@@ -2557,27 +2557,27 @@ code = '''
             LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, buf1, SIZE),
             LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, buf2, SIZE))) => 0;
     // force compaction
-    btree.eoff = -1;
+    lfsr_btree_claim(&btree);
     memset(buf2, 'b', SIZE);
     lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
             LFSR_RATTR_BUF(
                 LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0,
                 buf2, SIZE))) => 0;
-    assert(btree.weight == 2);
+    assert(lfsr_btree_weight(&btree) == 2);
 
     // now remove one entry, since this brings the rbyd down this zero,
     // this should force one of the blocks to drop
     //
     // do this while forcing a compaction
-    btree.eoff = -1;
+    lfsr_btree_claim(&btree);
     lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_RATTRS(
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
 
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == 1);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == 1);
 
     // check that our other entry is fine
     lfsr_bid_t bid_;
@@ -2634,15 +2634,15 @@ code = '''
     //
     // messy, isn't it? this is why we need an explicit test
     //
-    btree.eoff = -1;
+    lfsr_btree_claim(&btree);
     lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_RATTRS(
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
 
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == 1);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == 1);
 
     // check that our other entry is fine
     lfsr_bid_t bid_;
@@ -2694,13 +2694,13 @@ code = '''
             LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, buf1, SIZE),
             LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, buf2, SIZE))) => 0;
     // force compaction
-    btree.eoff = -1;
+    lfsr_btree_claim(&btree);
     memset(buf2, 'b', SIZE);
     lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
             LFSR_RATTR_BUF(
                 LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0,
                 buf2, SIZE))) => 0;
-    assert(btree.weight == 2);
+    assert(lfsr_btree_weight(&btree) == 2);
 
     // now make both entries small so they should be merged if either compacts
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
@@ -2714,15 +2714,15 @@ code = '''
 
     // force compaction, while removing one entry, this drops the rbyd
     // down to zero while also triggering a merge
-    btree.eoff = -1;
+    lfsr_btree_claim(&btree);
     lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_RATTRS(
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
 
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == 1);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == 1);
 
     // check that our other entry is fine
     lfsr_bid_t bid_;
@@ -2823,10 +2823,10 @@ code = '''
     }
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == sim_size);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == sim_size);
 
     uint8_t buffer[4];
     lfsr_bid_t bid_;
@@ -2959,15 +2959,15 @@ code = '''
     }
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
 
     lfs_size_t total_weight = 0;
     for (lfs_size_t j = 0; j < sim_size; j++) {
         total_weight += sim_weights[j];
     }
-    assert(btree.weight == total_weight);
+    assert(lfsr_btree_weight(&btree) == total_weight);
 
     uint8_t buffer[4];
     lfsr_bid_t bid_;
@@ -3037,19 +3037,17 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_init(&btree);
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == 0);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == 0);
 
     // try to find tags
     lfsr_bid_t bid_;
-    lfsr_rbyd_t rbyd_;
-    lfsr_srid_t rid_;
     lfs_size_t weight_;
 
-    lfsr_btree_namelookupleaf(&lfs, &btree, 0, "aaa", 3,
-            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_ERR_NOENT;
+    lfsr_btree_namelookup(&lfs, &btree, 0, "aaa", 3,
+            &bid_, NULL, &weight_, NULL) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_find_one]
@@ -3076,23 +3074,21 @@ code = '''
                 0, "aaa", 3),
             LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == 1);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == 1);
 
     // try to find tags
     uint8_t buffer[4];
     lfsr_bid_t bid_;
-    lfsr_rbyd_t rbyd_;
-    lfsr_srid_t rid_;
     lfsr_tag_t tag_;
     lfs_size_t weight_;
     lfsr_data_t data_;
 
-    lfsr_btree_namelookupleaf(&lfs, &btree, 0*DID, "aaa", 3,
-            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
-    lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+    lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3,
+            &bid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+    lfsr_btree_lookup(&lfs, &btree, bid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
             &tag_, &data_) => 0;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 0);
@@ -3100,9 +3096,9 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "0", 1) == 0);
 
-    lfsr_btree_namelookupleaf(&lfs, &btree, 1*DID, "aab", 3,
-            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_LT;
-    lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+    lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3,
+            &bid_, NULL, &weight_, NULL) => LFS_CMP_LT;
+    lfsr_btree_lookup(&lfs, &btree, bid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
             &tag_, &data_) => 0;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 0);
@@ -3141,23 +3137,21 @@ code = '''
                 0, "aab", 3),
             LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "1", 1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == 2);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == 2);
 
     // try to find tags
     uint8_t buffer[4];
     lfsr_bid_t bid_;
-    lfsr_rbyd_t rbyd_;
-    lfsr_srid_t rid_;
     lfsr_tag_t tag_;
     lfs_size_t weight_;
     lfsr_data_t data_;
 
-    lfsr_btree_namelookupleaf(&lfs, &btree, 0, "aaa", 3,
-            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
-    lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+    lfsr_btree_namelookup(&lfs, &btree, 0, "aaa", 3,
+            &bid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+    lfsr_btree_lookup(&lfs, &btree, bid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
             &tag_, &data_) => 0;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 0);
@@ -3165,9 +3159,9 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "0", 1) == 0);
 
-    lfsr_btree_namelookupleaf(&lfs, &btree, 0, "aab", 3,
-            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
-    lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+    lfsr_btree_namelookup(&lfs, &btree, 0, "aab", 3,
+            &bid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+    lfsr_btree_lookup(&lfs, &btree, bid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
             &tag_, &data_) => 0;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 1);
@@ -3175,9 +3169,9 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "1", 1) == 0);
 
-    lfsr_btree_namelookupleaf(&lfs, &btree, 0, "aac", 3,
-            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_LT;
-    lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+    lfsr_btree_namelookup(&lfs, &btree, 0, "aac", 3,
+            &bid_, NULL, &weight_, NULL) => LFS_CMP_LT;
+    lfsr_btree_lookup(&lfs, &btree, bid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
             &tag_, &data_) => 0;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 1);
@@ -3222,23 +3216,21 @@ code = '''
                 2*DID, "aac", 3),
             LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "2", 1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == 3);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == 3);
 
     // try to find tags
     uint8_t buffer[4];
     lfsr_bid_t bid_;
-    lfsr_rbyd_t rbyd_;
-    lfsr_srid_t rid_;
     lfsr_tag_t tag_;
     lfs_size_t weight_;
     lfsr_data_t data_;
 
-    lfsr_btree_namelookupleaf(&lfs, &btree, 0*DID, "aaa", 3,
-            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
-    lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+    lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3,
+            &bid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+    lfsr_btree_lookup(&lfs, &btree, bid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
             &tag_, &data_) => 0;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 0);
@@ -3246,9 +3238,9 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "0", 1) == 0);
 
-    lfsr_btree_namelookupleaf(&lfs, &btree, 1*DID, "aab", 3,
-            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
-    lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+    lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3,
+            &bid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+    lfsr_btree_lookup(&lfs, &btree, bid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
             &tag_, &data_) => 0;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 1);
@@ -3256,9 +3248,9 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "1", 1) == 0);
 
-    lfsr_btree_namelookupleaf(&lfs, &btree, 2*DID, "aac", 3,
-            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
-    lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+    lfsr_btree_namelookup(&lfs, &btree, 2*DID, "aac", 3,
+            &bid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+    lfsr_btree_lookup(&lfs, &btree, bid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
             &tag_, &data_) => 0;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 2);
@@ -3266,9 +3258,9 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "2", 1) == 0);
 
-    lfsr_btree_namelookupleaf(&lfs, &btree, 3*DID, "aad", 3,
-            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_LT;
-    lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+    lfsr_btree_namelookup(&lfs, &btree, 3*DID, "aad", 3,
+            &bid_, NULL, &weight_, NULL) => LFS_CMP_LT;
+    lfsr_btree_lookup(&lfs, &btree, bid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
             &tag_, &data_) => 0;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 2);
@@ -3313,23 +3305,21 @@ code = '''
                 1*DID, "aab", 3),
             LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "1", 1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == 3);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == 3);
 
     // try to find tags
     uint8_t buffer[4];
     lfsr_bid_t bid_;
-    lfsr_rbyd_t rbyd_;
-    lfsr_srid_t rid_;
     lfsr_tag_t tag_;
     lfs_size_t weight_;
     lfsr_data_t data_;
 
-    lfsr_btree_namelookupleaf(&lfs, &btree, 0*DID, "aaa", 3,
-            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
-    lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+    lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3,
+            &bid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+    lfsr_btree_lookup(&lfs, &btree, bid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
             &tag_, &data_) => 0;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 0);
@@ -3337,9 +3327,9 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "0", 1) == 0);
 
-    lfsr_btree_namelookupleaf(&lfs, &btree, 1*DID, "aab", 3,
-            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
-    lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+    lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3,
+            &bid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+    lfsr_btree_lookup(&lfs, &btree, bid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
             &tag_, &data_) => 0;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 1);
@@ -3347,9 +3337,9 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "1", 1) == 0);
 
-    lfsr_btree_namelookupleaf(&lfs, &btree, 2*DID, "aac", 3,
-            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
-    lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+    lfsr_btree_namelookup(&lfs, &btree, 2*DID, "aac", 3,
+            &bid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+    lfsr_btree_lookup(&lfs, &btree, bid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
             &tag_, &data_) => 0;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 2);
@@ -3357,9 +3347,9 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "2", 1) == 0);
 
-    lfsr_btree_namelookupleaf(&lfs, &btree, 3*DID, "aad", 3,
-            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_LT;
-    lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+    lfsr_btree_namelookup(&lfs, &btree, 3*DID, "aad", 3,
+            &bid_, NULL, &weight_, NULL) => LFS_CMP_LT;
+    lfsr_btree_lookup(&lfs, &btree, bid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
             &tag_, &data_) => 0;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 2);
@@ -3415,16 +3405,14 @@ code = '''
         n += 1;
     }
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == n);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == n);
 
     // try to find tags
     uint8_t buffer[4];
     lfsr_bid_t bid_;
-    lfsr_rbyd_t rbyd_;
-    lfsr_srid_t rid_;
     lfsr_tag_t tag_;
     lfs_size_t weight_;
     lfsr_data_t data_;
@@ -3434,9 +3422,9 @@ code = '''
             'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26)
         };
 
-        lfsr_btree_namelookupleaf(&lfs, &btree, i*DID, name, 3,
-                &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
-        lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+        lfsr_btree_namelookup(&lfs, &btree, i*DID, name, 3,
+                &bid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+        lfsr_btree_lookup(&lfs, &btree, bid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
                 &tag_, &data_) => 0;
         assert(tag_ == LFSR_TAG_DATA);
         assert(bid_ == i);
@@ -3534,22 +3522,20 @@ code = '''
     }
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == sim_size);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == sim_size);
 
     uint8_t buffer[4];
     lfsr_bid_t bid_;
-    lfsr_rbyd_t rbyd_;
-    lfsr_srid_t rid_;
     lfsr_tag_t tag_;
     lfs_size_t weight_;
     lfsr_data_t data_;
     for (lfs_size_t i = 0; i < sim_size; i++) {
-        lfsr_btree_namelookupleaf(&lfs, &btree, 0, sim_names[i], 3,
-                &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
-        lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+        lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3,
+                &bid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+        lfsr_btree_lookup(&lfs, &btree, bid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
                 &tag_, &data_) => 0;
         assert(tag_ == LFSR_TAG_DATA);
         assert(bid_ == i);
@@ -3612,16 +3598,14 @@ code = '''
         n += 1;
     }
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == n*W);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == n*W);
 
     // try to find tags
     uint8_t buffer[4];
     lfsr_bid_t bid_;
-    lfsr_rbyd_t rbyd_;
-    lfsr_srid_t rid_;
     lfsr_tag_t tag_;
     lfs_size_t weight_;
     lfsr_data_t data_;
@@ -3631,9 +3615,9 @@ code = '''
             'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26)
         };
 
-        lfsr_btree_namelookupleaf(&lfs, &btree, i*DID, name, 3,
-                &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
-        lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+        lfsr_btree_namelookup(&lfs, &btree, i*DID, name, 3,
+                &bid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+        lfsr_btree_lookup(&lfs, &btree, bid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
                 &tag_, &data_) => 0;
         assert(tag_ == LFSR_TAG_DATA);
         assert(bid_ == i*W+W-1);
@@ -3761,20 +3745,18 @@ code = '''
     }
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
 
     lfs_size_t total_weight = 0;
     for (lfs_size_t j = 0; j < sim_size; j++) {
         total_weight += sim_weights[j];
     }
-    assert(btree.weight == total_weight);
+    assert(lfsr_btree_weight(&btree) == total_weight);
 
     uint8_t buffer[4];
     lfsr_bid_t bid_;
-    lfsr_rbyd_t rbyd_;
-    lfsr_srid_t rid_;
     lfsr_tag_t tag_;
     lfs_size_t weight_;
     lfsr_data_t data_;
@@ -3785,9 +3767,9 @@ code = '''
             weighted_bid += sim_weights[j];
         }
 
-        lfsr_btree_namelookupleaf(&lfs, &btree, 0, sim_names[i], 3,
-                &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
-        lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+        lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3,
+                &bid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+        lfsr_btree_lookup(&lfs, &btree, bid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
                 &tag_, &data_) => 0;
         assert(tag_ == LFSR_TAG_DATA);
         assert(bid_ == weighted_bid+sim_weights[i]-1);
@@ -3889,10 +3871,9 @@ code = '''
             //                                       a   c d   g h i   k
             //                                                 ^
             lfsr_bid_t split_bid;
-            lfsr_rbyd_t split_rbyd;
-            lfs_scmp_t cmp = lfsr_btree_namelookupleaf(&lfs, &btree,
+            lfs_scmp_t cmp = lfsr_btree_namelookup(&lfs, &btree,
                     0, name, 3,
-                    &split_bid, &split_rbyd, NULL, NULL, NULL, NULL);
+                    &split_bid, NULL, NULL, NULL);
             assert(cmp >= 0);
             assert(cmp != LFS_CMP_EQ);
             if (cmp > LFS_CMP_EQ) {
@@ -3956,22 +3937,20 @@ code = '''
     }
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == sim_size);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == sim_size);
 
     uint8_t buffer[4];
     lfsr_bid_t bid_;
-    lfsr_rbyd_t rbyd_;
-    lfsr_srid_t rid_;
     lfsr_tag_t tag_;
     lfs_size_t weight_;
     lfsr_data_t data_;
     for (lfs_size_t i = 0; i < sim_size; i++) {
-        lfsr_btree_namelookupleaf(&lfs, &btree, 0, sim_names[i], 3,
-                &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
-        lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+        lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3,
+                &bid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+        lfsr_btree_lookup(&lfs, &btree, bid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
                 &tag_, &data_) => 0;
         assert(tag_ == LFSR_TAG_DATA);
         assert(bid_ == i);
@@ -4083,11 +4062,10 @@ code = '''
             //                                       a   c d   g h i   k
             //                                                 ^
             lfsr_bid_t split_bid;
-            lfsr_rbyd_t split_rbyd;
             lfsr_bid_t split_weight;
-            lfs_scmp_t cmp = lfsr_btree_namelookupleaf(&lfs, &btree,
+            lfs_scmp_t cmp = lfsr_btree_namelookup(&lfs, &btree,
                     0, name, 3,
-                    &split_bid, &split_rbyd, NULL, NULL, &split_weight, NULL);
+                    &split_bid, NULL, &split_weight, NULL);
             assert(cmp >= 0);
             assert(cmp != LFS_CMP_EQ);
             if (cmp > LFS_CMP_EQ) {
@@ -4173,20 +4151,18 @@ code = '''
     }
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
 
     lfs_size_t total_weight = 0;
     for (lfs_size_t j = 0; j < sim_size; j++) {
         total_weight += sim_weights[j];
     }
-    assert(btree.weight == total_weight);
+    assert(lfsr_btree_weight(&btree) == total_weight);
 
     uint8_t buffer[4];
     lfsr_bid_t bid_;
-    lfsr_rbyd_t rbyd_;
-    lfsr_srid_t rid_;
     lfsr_tag_t tag_;
     lfs_size_t weight_;
     lfsr_data_t data_;
@@ -4197,9 +4173,9 @@ code = '''
             weighted_bid += sim_weights[j];
         }
 
-        lfsr_btree_namelookupleaf(&lfs, &btree, 0, sim_names[i], 3,
-                &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
-        lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+        lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3,
+                &bid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+        lfsr_btree_lookup(&lfs, &btree, bid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
                 &tag_, &data_) => 0;
         assert(tag_ == LFSR_TAG_DATA);
         assert(bid_ == weighted_bid+sim_weights[i]-1);
@@ -4244,10 +4220,10 @@ code = '''
         n += 1;
     }
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == n);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == n);
 
     // check that the elements are in the tree
     uint8_t buffer[4];
@@ -4399,10 +4375,10 @@ code = '''
     }
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == sim_size);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == sim_size);
 
     uint8_t buffer[4];
     lfsr_bid_t bid_;
@@ -4493,10 +4469,10 @@ code = '''
     }
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
-            btree.weight,
-            btree.blocks[0],
-            btree.trunk);
-    assert(btree.weight == sim_size);
+            lfsr_btree_weight(&btree),
+            lfsr_btree_block(&btree),
+            lfsr_btree_trunk(&btree));
+    assert(lfsr_btree_weight(&btree) == sim_size);
 
     for (lfs_size_t i = 0; i < sim_size; i++) {
         lfsr_btree_lookupnext(&lfs, &btree, i,
diff --git a/tests/test_files.toml b/tests/test_files.toml
index b6a8d8b7..94f10337 100644
--- a/tests/test_files.toml
+++ b/tests/test_files.toml
@@ -1227,10 +1227,10 @@ code = '''
 
     // create an empty btree
     lfs_alloc_ckpoint(&lfs);
-    lfsr_rbyd_alloc(&lfs, &file.b.shrub) => 0;
-    lfsr_rbyd_commit(&lfs, &file.b.shrub, 0, LFSR_RATTRS(
+    lfsr_rbyd_alloc(&lfs, &file.b.shrub.root) => 0;
+    lfsr_rbyd_commit(&lfs, &file.b.shrub.root, 0, LFSR_RATTRS(
             LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "?", 1))) => 0;
-    lfsr_rbyd_commit(&lfs, &file.b.shrub, 0, LFSR_RATTRS(
+    lfsr_rbyd_commit(&lfs, &file.b.shrub.root, 0, LFSR_RATTRS(
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
     lfsr_mdir_commit(&lfs, &file.b.o.mdir, LFSR_RATTRS(
             LFSR_RATTR_BTREE(
diff --git a/tests/test_mtree.toml b/tests/test_mtree.toml
index be796f8d..9ce99887 100644
--- a/tests/test_mtree.toml
+++ b/tests/test_mtree.toml
@@ -196,7 +196,7 @@ code = '''
             LFSR_RATTR_BUF(LFSR_TAG_ATTR(3), 0, "c", 1))) => 0;
 
     // assert mdirs were unininlined
-    assert(lfs.mtree.weight == (1 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (1 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -220,7 +220,7 @@ code = '''
     lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0;
 
     // assert mdirs were unininlined
-    assert(lfs.mtree.weight == (1 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (1 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -281,7 +281,7 @@ code = '''
             LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0;
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -307,7 +307,7 @@ code = '''
     lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0;
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -370,7 +370,7 @@ code = '''
             LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0;
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -390,7 +390,7 @@ code = '''
             LFSR_RATTR_BUF(LFSR_TAG_ATTR(2), 0, "e", 1))) => 0;
 
     // assert mdir was split correctly
-    assert(lfs.mtree.weight == (3 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (3 << lfs.mbits));
     // assert mroot still has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -426,7 +426,7 @@ code = '''
     lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0;
 
     // assert mdir was split correctly
-    assert(lfs.mtree.weight == (3 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (3 << lfs.mbits));
     // assert mroot still has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -687,7 +687,7 @@ code = '''
             LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0;
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -700,7 +700,7 @@ code = '''
     assert(mdir.rbyd.weight == 0);
 
     // assert mdir was dropped
-    assert(lfs.mtree.weight == (1 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (1 << lfs.mbits));
     // assert mroot still has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -720,7 +720,7 @@ code = '''
     lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0;
 
     // assert mdir was dropped
-    assert(lfs.mtree.weight == (1 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (1 << lfs.mbits));
     // assert mroot still has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -777,7 +777,7 @@ code = '''
             LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0;
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -792,7 +792,7 @@ code = '''
     assert(mdir.rbyd.weight == 0);
 
     // assert mdir was dropped
-    assert(lfs.mtree.weight == (1 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (1 << lfs.mbits));
     // assert mroot still has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -812,7 +812,7 @@ code = '''
     lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0;
 
     // assert mdir was dropped
-    assert(lfs.mtree.weight == (1 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (1 << lfs.mbits));
     // assert mroot still has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -875,7 +875,7 @@ code = '''
     assert(mdir.rbyd.weight == 2);
 
     // assert split/drop worked out
-    assert(lfs.mtree.weight == (1 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (1 << lfs.mbits));
     // assert mroot still has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -891,7 +891,7 @@ code = '''
     lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0;
 
     // assert mdir was dropped
-    assert(lfs.mtree.weight == (1 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (1 << lfs.mbits));
     // assert mroot still has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -944,7 +944,7 @@ code = '''
             LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0;
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -969,7 +969,7 @@ code = '''
     assert(mdir.rbyd.weight == 1);
 
     // assert split/drop worked out
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot still has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -995,7 +995,7 @@ code = '''
     lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0;
 
     // assert split/drop worked out
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot still has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -1058,7 +1058,7 @@ code = '''
             LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0;
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -1083,7 +1083,7 @@ code = '''
     assert(mdir.rbyd.weight == 1);
 
     // assert split/drop worked out
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot still has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -1109,7 +1109,7 @@ code = '''
     lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0;
 
     // assert split/drop worked out
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot still has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -1296,7 +1296,7 @@ code = '''
             LFSR_RATTR_BUF(LFSR_TAG_ATTR(3), 0, "c", 1))) => 0;
 
     // assert mdirs were unininlined
-    assert(lfs.mtree.weight == (1 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (1 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -1313,7 +1313,7 @@ code = '''
     assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0);
 
     // assert mdirs were unininlined
-    assert(lfs.mtree.weight == (1 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (1 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -1347,7 +1347,7 @@ code = '''
     lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0;
 
     // assert mdirs were unininlined
-    assert(lfs.mtree.weight == (1 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (1 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -1420,7 +1420,7 @@ code = '''
             LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0;
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -1439,7 +1439,7 @@ code = '''
     assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0);
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -1475,7 +1475,7 @@ code = '''
     lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0;
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -1550,7 +1550,7 @@ code = '''
             LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0;
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -1569,7 +1569,7 @@ code = '''
     assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0);
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -1605,7 +1605,7 @@ code = '''
     lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0;
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -1982,7 +1982,7 @@ code = '''
             LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0;
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -2006,7 +2006,7 @@ code = '''
     assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0);
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -2042,7 +2042,7 @@ code = '''
     lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0;
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -2117,7 +2117,7 @@ code = '''
             LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0;
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -2148,7 +2148,7 @@ code = '''
     assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0);
 
     // assert mdir was split correctly
-    assert(lfs.mtree.weight == (3 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (3 << lfs.mbits));
     // assert mroot still has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -2188,7 +2188,7 @@ code = '''
     lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0;
 
     // assert mdir was split correctly
-    assert(lfs.mtree.weight == (3 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (3 << lfs.mbits));
     // assert mroot still has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -2267,7 +2267,7 @@ code = '''
             LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0;
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -2291,7 +2291,7 @@ code = '''
     assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0);
 
     // assert mdir was dropped
-    assert(lfs.mtree.weight == (1 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (1 << lfs.mbits));
     // assert mroot still has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -2311,7 +2311,7 @@ code = '''
     lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0;
 
     // assert mdir was dropped
-    assert(lfs.mtree.weight == (1 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (1 << lfs.mbits));
     // assert mroot still has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -2368,7 +2368,7 @@ code = '''
     assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0);
 
     // assert mdirs were unininlined
-    assert(lfs.mtree.weight == (1 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (1 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -2392,7 +2392,7 @@ code = '''
     lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0;
 
     // assert mdirs were unininlined
-    assert(lfs.mtree.weight == (1 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (1 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -2463,7 +2463,7 @@ code = '''
     assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0);
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -2489,7 +2489,7 @@ code = '''
     lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0;
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -2888,7 +2888,7 @@ code = '''
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -2979,7 +2979,7 @@ code = '''
     lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0;
 
     // assert mdir was split correctly
-    assert(lfs.mtree.weight == (3 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (3 << lfs.mbits));
     // assert mroot still has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -3114,7 +3114,7 @@ code = '''
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -3211,7 +3211,7 @@ code = '''
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -3320,7 +3320,7 @@ code = '''
     lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0;
 
     // assert mdir was split correctly
-    assert(lfs.mtree.weight == (3 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (3 << lfs.mbits));
     // assert mroot still has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -3339,7 +3339,7 @@ code = '''
     lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0;
 
     // assert mdir was split correctly
-    assert(lfs.mtree.weight == (4 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (4 << lfs.mbits));
     // assert mroot still has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -3430,7 +3430,7 @@ code = '''
     lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0;
 
     // assert mdir was split correctly
-    assert(lfs.mtree.weight == (3 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (3 << lfs.mbits));
     // assert mroot still has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -3440,7 +3440,7 @@ code = '''
     assert(mdir.rbyd.weight == 0);
 
     // assert mdir was dropped correctly
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot still has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -3597,7 +3597,7 @@ code = '''
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mdirs were unininlined
-    assert(lfs.mtree.weight == (1 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (1 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -3663,7 +3663,7 @@ code = '''
     // and the tree should still work
 
     // assert mdirs were unininlined
-    assert(lfs.mtree.weight == (1 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (1 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -3683,7 +3683,7 @@ code = '''
     lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0;
 
     // assert mdirs were unininlined
-    assert(lfs.mtree.weight == (1 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (1 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -3740,7 +3740,7 @@ code = '''
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -3806,7 +3806,7 @@ code = '''
     // and the tree should still work
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -3828,7 +3828,7 @@ code = '''
     lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0;
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -3887,7 +3887,7 @@ code = '''
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mdirs were unininlined and split
-    assert(lfs.mtree.weight == (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (2 << lfs.mbits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -3906,7 +3906,7 @@ code = '''
     lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0;
 
     // assert mdir was split correctly
-    assert(lfs.mtree.weight == (3 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (3 << lfs.mbits));
     // assert mroot still has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -3972,7 +3972,7 @@ code = '''
     // and the tree should still work
 
     // assert mdir was split correctly
-    assert(lfs.mtree.weight == (3 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (3 << lfs.mbits));
     // assert mroot still has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
@@ -4000,7 +4000,7 @@ code = '''
     lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0;
 
     // assert mdir was split correctly
-    assert(lfs.mtree.weight == (3 << lfs.mbits));
+    assert(lfs.mtree.root.weight == (3 << lfs.mbits));
     // assert mroot still has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
diff --git a/tests/test_traversal.toml b/tests/test_traversal.toml
index fe4f2f66..fce42424 100644
--- a/tests/test_traversal.toml
+++ b/tests/test_traversal.toml
@@ -3416,7 +3416,7 @@ code = '''
 
     // create enough files for mroot to split
     lfs_size_t i = 0;
-    while (lfs.mtree.weight == 0) {
+    while (lfs.mtree.root.weight == 0) {
         char name[256];
         sprintf(name, "uloborus%03x", i);
         lfsr_file_open(&lfs, &file, name,
@@ -3535,7 +3535,7 @@ code = '''
 
     // create enough files for mroot to split
     lfs_size_t i = 0;
-    while (lfs.mtree.weight == 0) {
+    while (lfs.mtree.root.weight == 0) {
         char name[256];
         sprintf(name, "uloborus%03x", i);
         lfsr_file_open(&lfs, &file, name,
@@ -3662,7 +3662,7 @@ code = '''
 
     // create enough files for mroot to split
     lfs_size_t i = 0;
-    while (lfs.mtree.weight == 0) {
+    while (lfs.mtree.root.weight == 0) {
         char name[256];
         sprintf(name, "uloborus%03x", i);
         lfsr_file_open(&lfs, &file, name,
@@ -4186,7 +4186,7 @@ code = '''
 
     // create enough files for mroot to split twice
     lfs_size_t i = 0;
-    while (lfs.mtree.weight == 0) {
+    while (lfs.mtree.root.weight == 0) {
         char name[256];
         sprintf(name, "tarantula%03x", i);
         lfsr_file_open(&lfs, &file, name,
@@ -4196,8 +4196,8 @@ code = '''
     }
 
     i = 0;
-    lfs_size_t orig = lfs.mtree.weight;
-    while (lfs.mtree.weight == orig) {
+    lfs_size_t orig = lfs.mtree.root.weight;
+    while (lfs.mtree.root.weight == orig) {
         char name[256];
         sprintf(name, "xnotata%03x", i);
         lfsr_file_open(&lfs, &file, name,
@@ -4221,8 +4221,8 @@ code = '''
 
     // create enough files for mdir to split again
     i = 0;
-    orig = lfs.mtree.weight;
-    while (lfs.mtree.weight == orig) {
+    orig = lfs.mtree.root.weight;
+    while (lfs.mtree.root.weight == orig) {
         char name[256];
         sprintf(name, "vulsor%03x", i);
         lfsr_file_open(&lfs, &file, name,
@@ -4361,7 +4361,7 @@ code = '''
 
     // create enough files for mroot to split twice
     lfs_size_t i = 0;
-    while (lfs.mtree.weight == 0) {
+    while (lfs.mtree.root.weight == 0) {
         char name[256];
         sprintf(name, "tarantula%03x", i);
         lfsr_file_open(&lfs, &file, name,
@@ -4371,8 +4371,8 @@ code = '''
     }
 
     i = 0;
-    lfs_size_t orig = lfs.mtree.weight;
-    while (lfs.mtree.weight == orig) {
+    lfs_size_t orig = lfs.mtree.root.weight;
+    while (lfs.mtree.root.weight == orig) {
         char name[256];
         sprintf(name, "xnotata%03x", i);
         lfsr_file_open(&lfs, &file, name,
@@ -4420,8 +4420,8 @@ code = '''
 
     // create enough files for mdir to split again
     i = 0;
-    orig = lfs.mtree.weight;
-    while (lfs.mtree.weight == orig) {
+    orig = lfs.mtree.root.weight;
+    while (lfs.mtree.root.weight == orig) {
         char name[256];
         sprintf(name, "vulsor%03x", i);
         lfsr_file_open(&lfs, &file, name,
@@ -4543,7 +4543,7 @@ code = '''
 
     // create enough files for mroot to split twice
     lfs_size_t i = 0;
-    while (lfs.mtree.weight == 0) {
+    while (lfs.mtree.root.weight == 0) {
         char name[256];
         sprintf(name, "tarantula%03x", i);
         lfsr_file_open(&lfs, &file, name,
@@ -4553,8 +4553,8 @@ code = '''
     }
 
     i = 0;
-    lfs_size_t orig = lfs.mtree.weight;
-    while (lfs.mtree.weight == orig) {
+    lfs_size_t orig = lfs.mtree.root.weight;
+    while (lfs.mtree.root.weight == orig) {
         char name[256];
         sprintf(name, "xnotata%03x", i);
         lfsr_file_open(&lfs, &file, name,
@@ -4607,8 +4607,8 @@ code = '''
 
     // create enough files for mdir to split again
     i = 0;
-    orig = lfs.mtree.weight;
-    while (lfs.mtree.weight == orig) {
+    orig = lfs.mtree.root.weight;
+    while (lfs.mtree.root.weight == orig) {
         char name[256];
         sprintf(name, "vulsor%03x", i);
         lfsr_file_open(&lfs, &file, name,
@@ -4719,7 +4719,7 @@ code = '''
 
     // create enough files for mroot to split twice
     lfs_size_t i = 0;
-    while (lfs.mtree.weight == 0) {
+    while (lfs.mtree.root.weight == 0) {
         char name[256];
         sprintf(name, "tarantula%03x", i);
         lfsr_file_open(&lfs, &file, name,
@@ -4729,8 +4729,8 @@ code = '''
     }
 
     i = 0;
-    lfs_size_t orig = lfs.mtree.weight;
-    while (lfs.mtree.weight == orig) {
+    lfs_size_t orig = lfs.mtree.root.weight;
+    while (lfs.mtree.root.weight == orig) {
         char name[256];
         sprintf(name, "xnotata%03x", i);
         lfsr_file_open(&lfs, &file, name,
@@ -4892,7 +4892,7 @@ code = '''
 
     // create enough files for mroot to split twice
     lfs_size_t i = 0;
-    while (lfs.mtree.weight == 0) {
+    while (lfs.mtree.root.weight == 0) {
         char name[256];
         sprintf(name, "tarantula%03x", i);
         lfsr_file_open(&lfs, &file, name,
@@ -4902,8 +4902,8 @@ code = '''
     }
 
     i = 0;
-    lfs_size_t orig = lfs.mtree.weight;
-    while (lfs.mtree.weight == orig) {
+    lfs_size_t orig = lfs.mtree.root.weight;
+    while (lfs.mtree.root.weight == orig) {
         char name[256];
         sprintf(name, "xnotata%03x", i);
         lfsr_file_open(&lfs, &file, name,
@@ -5083,7 +5083,7 @@ code = '''
 
     // create enough files for mroot to split twice
     lfs_size_t i = 0;
-    while (lfs.mtree.weight == 0) {
+    while (lfs.mtree.root.weight == 0) {
         char name[256];
         sprintf(name, "tarantula%03x", i);
         lfsr_file_open(&lfs, &file, name,
@@ -5093,8 +5093,8 @@ code = '''
     }
 
     i = 0;
-    lfs_size_t orig = lfs.mtree.weight;
-    while (lfs.mtree.weight == orig) {
+    lfs_size_t orig = lfs.mtree.root.weight;
+    while (lfs.mtree.root.weight == orig) {
         char name[256];
         sprintf(name, "xnotata%03x", i);
         lfsr_file_open(&lfs, &file, name,
@@ -5262,7 +5262,7 @@ code = '''
 
     // create enough files for mroot to split twice
     lfs_size_t i = 0;
-    while (lfs.mtree.weight == 0) {
+    while (lfs.mtree.root.weight == 0) {
         char name[256];
         sprintf(name, "tarantula%03x", i);
         lfsr_file_open(&lfs, &file, name,
@@ -5272,8 +5272,8 @@ code = '''
     }
 
     i = 0;
-    lfs_size_t orig = lfs.mtree.weight;
-    while (lfs.mtree.weight == orig) {
+    lfs_size_t orig = lfs.mtree.root.weight;
+    while (lfs.mtree.root.weight == orig) {
         char name[256];
         sprintf(name, "xnotata%03x", i);
         lfsr_file_open(&lfs, &file, name,
@@ -5795,7 +5795,7 @@ code = '''
     lfs_size_t i = 0;
     while (true) {
         // we should not have split yet
-        assert(lfs.mtree.weight == 0);
+        assert(lfs.mtree.root.weight == 0);
         // we need internals to check this
         lfs_ssize_t estimate = lfsr_mdir_estimate__(&lfs,
                 &file1.b.o.mdir, -1, -1,
@@ -5964,7 +5964,7 @@ code = '''
 
     // create enough files for mroot to split twice
     lfs_size_t i = 0;
-    while (lfs.mtree.weight == 0) {
+    while (lfs.mtree.root.weight == 0) {
         char name[256];
         sprintf(name, "hydroid%03x", i);
         lfsr_file_t file;
@@ -5975,8 +5975,8 @@ code = '''
     }
 
     i = 0;
-    lfs_size_t orig = lfs.mtree.weight;
-    while (lfs.mtree.weight == orig) {
+    lfs_size_t orig = lfs.mtree.root.weight;
+    while (lfs.mtree.root.weight == orig) {
         char name[256];
         sprintf(name, "medusa%03x", i);
         lfsr_file_t file;
@@ -6198,7 +6198,7 @@ code = '''
 
     // create enough files for mroot to split twice
     lfs_size_t i = 0;
-    while (lfs.mtree.weight == 0) {
+    while (lfs.mtree.root.weight == 0) {
         char name[256];
         sprintf(name, "hydroid%03x", i);
         lfsr_file_t file;
@@ -6209,8 +6209,8 @@ code = '''
     }
 
     i = 0;
-    lfs_size_t orig = lfs.mtree.weight;
-    while (lfs.mtree.weight == orig) {
+    lfs_size_t orig = lfs.mtree.root.weight;
+    while (lfs.mtree.root.weight == orig) {
         char name[256];
         sprintf(name, "polyp%03x", i);
         lfsr_file_t file;
@@ -6222,10 +6222,10 @@ code = '''
 
     // create enough files to both compact and split
     i = 0;
-    orig = lfs.mtree.weight;
+    orig = lfs.mtree.root.weight;
     while (true) {
         // we should not have split yet
-        assert(lfs.mtree.weight == orig);
+        assert(lfs.mtree.root.weight == orig);
         // we need internals to check this
         lfs_ssize_t estimate = lfsr_mdir_estimate__(&lfs,
                 &file2.b.o.mdir, -1, -1,
@@ -6482,7 +6482,7 @@ code = '''
     assert(!(lfs.flags & LFS_I_MKCONSISTENT));
 
     // which means there shouldn't be that many files left
-    assert(lfs.mtree.weight <= (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight <= (2 << lfs.mbits));
     assert(file1.b.o.mdir.rbyd.weight <= 3);
     assert(file2.b.o.mdir.rbyd.weight <= 3);
 
@@ -6783,7 +6783,7 @@ code = '''
     assert(!(lfs.flags & LFS_I_MKCONSISTENT));
 
     // which means there shouldn't be that many files left
-    assert(lfs.mtree.weight <= (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight <= (2 << lfs.mbits));
     assert(file1.b.o.mdir.rbyd.weight <= 3);
     assert(file2.b.o.mdir.rbyd.weight <= 3);
 
@@ -6943,7 +6943,7 @@ code = '''
     assert(!(lfs.flags & LFS_I_MKCONSISTENT));
 
     // which means there shouldn't be that many files left
-    assert(lfs.mtree.weight <= (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight <= (2 << lfs.mbits));
     assert(file1.b.o.mdir.rbyd.weight <= 3);
     assert(file2.b.o.mdir.rbyd.weight <= 3);
 
@@ -7112,7 +7112,7 @@ code = '''
     assert(!(lfs.flags & LFS_I_MKCONSISTENT));
 
     // which means there shouldn't be that many files left
-    assert(lfs.mtree.weight <= (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight <= (2 << lfs.mbits));
     assert(file1.b.o.mdir.rbyd.weight <= 3);
     assert(file2.b.o.mdir.rbyd.weight <= 3);
 
@@ -7281,7 +7281,7 @@ code = '''
     assert(!(lfs.flags & LFS_I_MKCONSISTENT));
 
     // which means there shouldn't be that many files left
-    assert(lfs.mtree.weight <= (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight <= (2 << lfs.mbits));
     assert(file1.b.o.mdir.rbyd.weight <= 3);
     assert(file2.b.o.mdir.rbyd.weight <= 3);
 
@@ -7446,7 +7446,7 @@ code = '''
     assert(!(lfs.flags & LFS_I_MKCONSISTENT));
 
     // which means there shouldn't be that many files left
-    assert(lfs.mtree.weight <= (2 << lfs.mbits));
+    assert(lfs.mtree.root.weight <= (2 << lfs.mbits));
     assert(file1.b.o.mdir.rbyd.weight <= 3);
     assert(file2.b.o.mdir.rbyd.weight <= 3);