From 2586fe68a21a3410a82be9f00350ef7aba5b6406 Mon Sep 17 00:00:00 2001
From: Christopher Haster <geky@geky.net>
Date: Fri, 18 Jul 2025 17:46:16 -0500
Subject: [PATCH] Renamed traversal -> trv

- test_traversal -> test_trvs
- lfs3_traversal_t -> lfs3_trv_t
- lfs3_btraversal_t -> lfs3_btrv_t
- t -> trv
- bt -> btrv
- lfs3_traversal_* -> lfs3_trv_*
- lfs3_btraversal_* -> lfs3_btrv_*

The traversal type is becoming one of the more fundamental types in
littlefs, and if DIR and REG both get shortened names, it makes sense
for TRV to have one as well.

This also removes the temptation to use t for traversals, which is
probably an even worse name.

---

Note that lfs3_btree_traverse, lfs3_mtree_traverse, etc, remain
unaffected. This may change in the future, but it's interesting to note
that verbs seem to need much less typing than nouns.
---
 lfs3.c                                        |  508 +++---
 lfs3.h                                        |   28 +-
 tests/test_alloc.toml                         |   18 +-
 tests/test_badblocks.toml                     |    2 +-
 tests/test_btree.toml                         |   12 +-
 tests/test_ck.toml                            |  232 +--
 tests/test_fwrite.toml                        |   60 +-
 tests/test_gc.toml                            |  198 +-
 tests/test_mount.toml                         |   22 +-
 tests/test_mtree.toml                         |   48 +-
 tests/test_powerloss.toml                     |    2 +-
 tests/{test_traversal.toml => test_trvs.toml} | 1622 ++++++++---------
 12 files changed, 1376 insertions(+), 1376 deletions(-)
 rename tests/{test_traversal.toml => test_trvs.toml} (88%)

diff --git a/lfs3.c b/lfs3.c
index 019365de..bcc8b021 100644
--- a/lfs3.c
+++ b/lfs3.c
@@ -1044,7 +1044,7 @@ enum lfs3_tag {
     LFS3_TAG_BOOKMARK       = 0x0204,
     // in-device only name tags, these should never get written to disk
     LFS3_TAG_ORPHAN         = 0x0205,
-    LFS3_TAG_TRAVERSAL      = 0x0206,
+    LFS3_TAG_TRV            = 0x0206,
     LFS3_TAG_UNKNOWN        = 0x0207,
     // non-file name tags
     LFS3_TAG_MNAME          = 0x0220,
@@ -6318,25 +6318,25 @@ static lfs3_scmp_t lfs3_btree_namelookup(lfs3_t *lfs3,
 // lfs3_btree_lookupnext, traversal includes inner btree nodes
 
 #ifndef LFS3_2BONLY
-static void lfs3_btraversal_init(lfs3_btraversal_t *bt) {
-    bt->bid = 0;
-    bt->branch = NULL;
-    bt->rid = 0;
+static void lfs3_btrv_init(lfs3_btrv_t *btrv) {
+    btrv->bid = 0;
+    btrv->branch = NULL;
+    btrv->rid = 0;
 }
 #endif
 
 #ifndef LFS3_2BONLY
 static lfs3_stag_t lfs3_btree_traverse(lfs3_t *lfs3,
         const lfs3_btree_t *btree,
-        lfs3_btraversal_t *bt,
+        lfs3_btrv_t *btrv,
         lfs3_bid_t *bid_, lfs3_bid_t *weight_, lfs3_data_t *data_) {
     // explicitly traverse the root even if weight=0
-    if (!bt->branch) {
-        bt->branch = btree;
-        bt->rid = bt->bid;
+    if (!btrv->branch) {
+        btrv->branch = btree;
+        btrv->rid = btrv->bid;
 
         // traverse the root
-        if (bt->bid == 0
+        if (btrv->bid == 0
                 // unless we don't even have a root yet
                 && lfs3_rbyd_trunk(btree) != 0
                 // or are a shrub
@@ -6348,16 +6348,16 @@ static lfs3_stag_t lfs3_btree_traverse(lfs3_t *lfs3,
                 *weight_ = btree->weight;
             }
             if (data_) {
-                data_->u.buffer = (const uint8_t*)bt->branch;
+                data_->u.buffer = (const uint8_t*)btrv->branch;
             }
             return LFS3_TAG_BRANCH;
         }
     }
 
     // need to restart from the root?
-    if (bt->rid >= (lfs3_srid_t)bt->branch->weight) {
-        bt->branch = btree;
-        bt->rid = bt->bid;
+    if (btrv->rid >= (lfs3_srid_t)btrv->branch->weight) {
+        btrv->branch = btree;
+        btrv->rid = btrv->bid;
     }
 
     // descend down the tree
@@ -6365,8 +6365,8 @@ static lfs3_stag_t lfs3_btree_traverse(lfs3_t *lfs3,
         lfs3_srid_t rid__;
         lfs3_rid_t weight__;
         lfs3_data_t data__;
-        lfs3_stag_t tag__ = lfs3_rbyd_lookupnext(lfs3, bt->branch,
-                bt->rid, 0,
+        lfs3_stag_t tag__ = lfs3_rbyd_lookupnext(lfs3, btrv->branch,
+                btrv->rid, 0,
                 &rid__, &weight__, &data__);
         if (tag__ < 0) {
             return tag__;
@@ -6374,7 +6374,7 @@ static lfs3_stag_t lfs3_btree_traverse(lfs3_t *lfs3,
 
         // if we found a bname, lookup the branch
         if (tag__ == LFS3_TAG_BNAME) {
-            tag__ = lfs3_rbyd_lookup(lfs3, bt->branch, rid__, LFS3_TAG_BRANCH,
+            tag__ = lfs3_rbyd_lookup(lfs3, btrv->branch, rid__, LFS3_TAG_BRANCH,
                     &data__);
             if (tag__ < 0) {
                 LFS3_ASSERT(tag__ != LFS3_ERR_NOENT);
@@ -6385,27 +6385,27 @@ static lfs3_stag_t lfs3_btree_traverse(lfs3_t *lfs3,
         // found another branch
         if (tag__ == LFS3_TAG_BRANCH) {
             // adjust rid with subtree's weight
-            bt->rid -= (rid__ - (weight__-1));
+            btrv->rid -= (rid__ - (weight__-1));
 
             // fetch the next branch
             int err = lfs3_data_fetchbranch(lfs3, &data__, weight__,
-                    &bt->rbyd);
+                    &btrv->rbyd);
             if (err) {
                 return err;
             }
-            bt->branch = &bt->rbyd;
+            btrv->branch = &btrv->rbyd;
 
             // return inner btree nodes if this is the first time we've
             // seen them
-            if (bt->rid == 0) {
+            if (btrv->rid == 0) {
                 if (bid_) {
-                    *bid_ = bt->bid + (rid__ - bt->rid);
+                    *bid_ = btrv->bid + (rid__ - btrv->rid);
                 }
                 if (weight_) {
                     *weight_ = weight__;
                 }
                 if (data_) {
-                    data_->u.buffer = (const uint8_t*)bt->branch;
+                    data_->u.buffer = (const uint8_t*)btrv->branch;
                 }
                 return LFS3_TAG_BRANCH;
             }
@@ -6416,9 +6416,9 @@ static lfs3_stag_t lfs3_btree_traverse(lfs3_t *lfs3,
             //
             // note this effectively traverses a full leaf without redoing
             // the btree walk
-            lfs3_bid_t bid__ = bt->bid + (rid__ - bt->rid);
-            bt->bid = bid__ + 1;
-            bt->rid = rid__ + 1;
+            lfs3_bid_t bid__ = btrv->bid + (rid__ - btrv->rid);
+            btrv->bid = bid__ + 1;
+            btrv->rid = rid__ + 1;
 
             if (bid_) {
                 *bid_ = bid__;
@@ -6789,9 +6789,9 @@ static lfs3_stag_t lfs3_bshrub_lookup(lfs3_t *lfs3,
 #ifndef LFS3_2BONLY
 static lfs3_stag_t lfs3_bshrub_traverse(lfs3_t *lfs3,
         const lfs3_bshrub_t *bshrub,
-        lfs3_btraversal_t *bt,
+        lfs3_btrv_t *btrv,
         lfs3_bid_t *bid_, lfs3_bid_t *weight_, lfs3_data_t *data_) {
-    return lfs3_btree_traverse(lfs3, &bshrub->shrub, bt,
+    return lfs3_btree_traverse(lfs3, &bshrub->shrub, btrv,
             bid_, weight_, data_);
 }
 #endif
@@ -7180,7 +7180,7 @@ static inline void lfs3_o_settype(uint32_t *flags, uint8_t type) {
 
 static inline bool lfs3_o_isbshrub(uint32_t flags) {
     return lfs3_o_type(flags) == LFS3_TYPE_REG
-            || lfs3_o_type(flags) == LFS3_type_TRAVERSAL;
+            || lfs3_o_type(flags) == LFS3_type_TRV;
 }
 
 static inline bool lfs3_o_iszombie(uint32_t flags) {
@@ -7460,18 +7460,18 @@ static bool lfs3_mid_isopen(const lfs3_t *lfs3,
 // traversal invalidation things
 
 // needed in lfs3_handle_clobber
-static void lfs3_traversal_clobber(lfs3_t *lfs3, lfs3_traversal_t *t);
+static void lfs3_trv_clobber(lfs3_t *lfs3, lfs3_trv_t *trv);
 
 // clobber any traversals referencing our mdir
 #ifndef LFS3_RDONLY
 static void lfs3_handle_clobber(lfs3_t *lfs3, const lfs3_handle_t *h,
         uint32_t flags) {
     for (lfs3_handle_t *h_ = lfs3->handles; h_; h_ = h_->next) {
-        if (lfs3_o_type(h_->flags) == LFS3_type_TRAVERSAL) {
+        if (lfs3_o_type(h_->flags) == LFS3_type_TRV) {
             h_->flags |= flags;
 
-            if (h && ((lfs3_traversal_t*)h_)->ht == h) {
-                lfs3_traversal_clobber(lfs3, (lfs3_traversal_t*)h_);
+            if (h && ((lfs3_trv_t*)h_)->htrv == h) {
+                lfs3_trv_clobber(lfs3, (lfs3_trv_t*)h_);
             }
         }
     }
@@ -9370,12 +9370,12 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir,
     if (lfs3_mdir_cmp(&mroot_, &lfs3->mroot) != 0
             || lfs3_btree_cmp(&mtree_, &lfs3->mtree) != 0) {
         for (lfs3_handle_t *h = lfs3->handles; h; h = h->next) {
-            if (lfs3_o_type(h->flags) == LFS3_type_TRAVERSAL
+            if (lfs3_o_type(h->flags) == LFS3_type_TRV
                     && h->mdir.mid == -1
                     // don't clobber the current mdir, assume upper layers
                     // know what they're doing
                     && &h->mdir != mdir) {
-                lfs3_traversal_clobber(lfs3, (lfs3_traversal_t*)h);
+                lfs3_trv_clobber(lfs3, (lfs3_trv_t*)h);
             }
         }
     }
@@ -9761,46 +9761,46 @@ enum lfs3_tstate {
     LFS3_TSTATE_DONE        = 8,
 };
 
-static void lfs3_traversal_init(lfs3_traversal_t *t, uint32_t flags) {
-    t->b.h.flags = lfs3_o_typeflags(LFS3_type_TRAVERSAL)
+static void lfs3_trv_init(lfs3_trv_t *trv, uint32_t flags) {
+    trv->b.h.flags = lfs3_o_typeflags(LFS3_type_TRV)
             | lfs3_t_tstateflags(LFS3_TSTATE_MROOTANCHOR)
             | flags;
-    t->b.h.mdir.mid = -1;
-    t->b.h.mdir.r.weight = 0;
-    t->b.h.mdir.r.blocks[0] = -1;
-    t->b.h.mdir.r.blocks[1] = -1;
-    lfs3_bshrub_init(&t->b);
-    t->ht = NULL;
-    t->u.mtortoise.blocks[0] = -1;
-    t->u.mtortoise.blocks[1] = -1;
-    t->u.mtortoise.step = 0;
-    t->u.mtortoise.power = 0;
-    t->gcksum = 0;
+    trv->b.h.mdir.mid = -1;
+    trv->b.h.mdir.r.weight = 0;
+    trv->b.h.mdir.r.blocks[0] = -1;
+    trv->b.h.mdir.r.blocks[1] = -1;
+    lfs3_bshrub_init(&trv->b);
+    trv->htrv = NULL;
+    trv->u.mtortoise.blocks[0] = -1;
+    trv->u.mtortoise.blocks[1] = -1;
+    trv->u.mtortoise.step = 0;
+    trv->u.mtortoise.power = 0;
+    trv->gcksum = 0;
 }
 
 // low-level traversal _only_ finds blocks
-static lfs3_stag_t lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t,
+static lfs3_stag_t lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_trv_t *trv,
         lfs3_bptr_t *bptr_) {
     while (true) {
-        switch (lfs3_t_tstate(t->b.h.flags)) {
+        switch (lfs3_t_tstate(trv->b.h.flags)) {
         // start with the mrootanchor 0x{0,1}
         //
         // note we make sure to include all mroots in our mroot chain!
         //
         case LFS3_TSTATE_MROOTANCHOR:;
             // fetch the first mroot 0x{0,1}
-            int err = lfs3_mdir_fetch(lfs3, &t->b.h.mdir,
+            int err = lfs3_mdir_fetch(lfs3, &trv->b.h.mdir,
                     -1, LFS3_MPTR_MROOTANCHOR());
             if (err) {
                 return err;
             }
 
             // transition to traversing the mroot chain
-            lfs3_t_settstate(&t->b.h.flags, LFS3_IFDEF_2BONLY(
+            lfs3_t_settstate(&trv->b.h.flags, LFS3_IFDEF_2BONLY(
                     LFS3_TSTATE_DONE,
                     LFS3_TSTATE_MROOTCHAIN));
 
-            bptr_->d.u.buffer = (const uint8_t*)&t->b.h.mdir;
+            bptr_->d.u.buffer = (const uint8_t*)&trv->b.h.mdir;
             return LFS3_TAG_MDIR;
 
         // traverse the mroot chain, checking for mroots/mtrees
@@ -9808,15 +9808,15 @@ static lfs3_stag_t lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t,
         case LFS3_TSTATE_MROOTCHAIN:;
             // lookup mroot, if we find one this is not the active mroot
             lfs3_data_t data;
-            lfs3_stag_t tag = lfs3_mdir_lookup(lfs3, &t->b.h.mdir,
+            lfs3_stag_t tag = lfs3_mdir_lookup(lfs3, &trv->b.h.mdir,
                     LFS3_TAG_MASK8 | LFS3_TAG_STRUCT,
                     &data);
             if (tag < 0) {
                 // if we have no mtree (inlined mdir), we need to
                 // traverse any files in our mroot next
                 if (tag == LFS3_ERR_NOENT) {
-                    t->b.h.mdir.mid = 0;
-                    lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_MDIR);
+                    trv->b.h.mdir.mid = 0;
+                    lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_MDIR);
                     continue;
                 }
                 return tag;
@@ -9826,7 +9826,7 @@ static lfs3_stag_t lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t,
             if (tag == LFS3_TAG_MROOT) {
                 // fetch this mroot
                 err = lfs3_data_fetchmdir(lfs3, &data, -1,
-                        &t->b.h.mdir);
+                        &trv->b.h.mdir);
                 if (err) {
                     return err;
                 }
@@ -9838,37 +9838,37 @@ static lfs3_stag_t lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t,
                 // so creating a valid cycle is actually quite difficult
                 //
                 if (lfs3_mptr_cmp(
-                        t->b.h.mdir.r.blocks,
-                        t->u.mtortoise.blocks) == 0) {
+                        trv->b.h.mdir.r.blocks,
+                        trv->u.mtortoise.blocks) == 0) {
                     LFS3_ERROR("Cycle detected during mtree traversal "
                                 "0x{%"PRIx32",%"PRIx32"}",
-                            t->b.h.mdir.r.blocks[0],
-                            t->b.h.mdir.r.blocks[1]);
+                            trv->b.h.mdir.r.blocks[0],
+                            trv->b.h.mdir.r.blocks[1]);
                     return LFS3_ERR_CORRUPT;
                 }
-                if (t->u.mtortoise.step == (1U << t->u.mtortoise.power)) {
-                    t->u.mtortoise.blocks[0] = t->b.h.mdir.r.blocks[0];
-                    t->u.mtortoise.blocks[1] = t->b.h.mdir.r.blocks[1];
-                    t->u.mtortoise.step = 0;
-                    t->u.mtortoise.power += 1;
+                if (trv->u.mtortoise.step == (1U << trv->u.mtortoise.power)) {
+                    trv->u.mtortoise.blocks[0] = trv->b.h.mdir.r.blocks[0];
+                    trv->u.mtortoise.blocks[1] = trv->b.h.mdir.r.blocks[1];
+                    trv->u.mtortoise.step = 0;
+                    trv->u.mtortoise.power += 1;
                 }
-                t->u.mtortoise.step += 1;
+                trv->u.mtortoise.step += 1;
 
-                bptr_->d.u.buffer = (const uint8_t*)&t->b.h.mdir;
+                bptr_->d.u.buffer = (const uint8_t*)&trv->b.h.mdir;
                 return LFS3_TAG_MDIR;
 
             // found an mtree?
             } else if (tag == LFS3_TAG_MTREE) {
                 // fetch the root of the mtree
                 err = lfs3_data_fetchbtree(lfs3, &data,
-                        &t->b.shrub);
+                        &trv->b.shrub);
                 if (err) {
                     return err;
                 }
 
                 // transition to traversing the mtree
-                lfs3_btraversal_init(&t->u.bt);
-                lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_MTREE);
+                lfs3_btrv_init(&trv->u.btrv);
+                lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_MTREE);
                 continue;
 
             } else {
@@ -9882,21 +9882,21 @@ static lfs3_stag_t lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t,
         #ifndef LFS3_2BONLY
         case LFS3_TSTATE_MDIRS:;
             // find the next mdir
-            err = lfs3_mtree_lookup(lfs3, t->b.h.mdir.mid,
-                    &t->b.h.mdir);
+            err = lfs3_mtree_lookup(lfs3, trv->b.h.mdir.mid,
+                    &trv->b.h.mdir);
             if (err) {
                 // end of mtree? guess we're done
                 if (err == LFS3_ERR_NOENT) {
-                    lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_DONE);
+                    lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_DONE);
                     continue;
                 }
                 return err;
             }
 
             // transition to traversing the mdir
-            lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_MDIR);
+            lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_MDIR);
 
-            bptr_->d.u.buffer = (const uint8_t*)&t->b.h.mdir;
+            bptr_->d.u.buffer = (const uint8_t*)&trv->b.h.mdir;
             return LFS3_TAG_MDIR;
         #endif
 
@@ -9905,16 +9905,16 @@ static lfs3_stag_t lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t,
         case LFS3_TSTATE_MDIR:;
             // not traversing all blocks? have we exceeded our mdir's weight?
             // return to mtree iteration
-            if (lfs3_t_ismtreeonly(t->b.h.flags)
-                    || lfs3_mrid(lfs3, t->b.h.mdir.mid)
-                        >= (lfs3_srid_t)t->b.h.mdir.r.weight) {
-                t->b.h.mdir.mid = lfs3_mbid(lfs3, t->b.h.mdir.mid) + 1;
-                lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_MDIRS);
+            if (lfs3_t_ismtreeonly(trv->b.h.flags)
+                    || lfs3_mrid(lfs3, trv->b.h.mdir.mid)
+                        >= (lfs3_srid_t)trv->b.h.mdir.r.weight) {
+                trv->b.h.mdir.mid = lfs3_mbid(lfs3, trv->b.h.mdir.mid) + 1;
+                lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_MDIRS);
                 continue;
             }
 
             // do we have a bshrub/btree?
-            err = lfs3_bshrub_fetch(lfs3, &t->b);
+            err = lfs3_bshrub_fetch(lfs3, &trv->b);
             if (err && err != LFS3_ERR_NOENT) {
                 return err;
             }
@@ -9923,14 +9923,14 @@ static lfs3_stag_t lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t,
             // here, lfs3_bshrub_fetch ignores these for us
             if (err != LFS3_ERR_NOENT) {
                 // start traversing
-                lfs3_btraversal_init(&t->u.bt);
-                lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_BTREE);
+                lfs3_btrv_init(&trv->u.btrv);
+                lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_BTREE);
                 continue;
 
             // no? next we need to check any opened files
             } else {
-                t->ht = lfs3->handles;
-                lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_OMDIRS);
+                trv->htrv = lfs3->handles;
+                lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_OMDIRS);
                 continue;
             }
             LFS3_UNREACHABLE();
@@ -9943,10 +9943,10 @@ static lfs3_stag_t lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t,
             //
             // note we can skip checking opened files if mounted rdonly,
             // this saves a bit of code when compiled rdonly
-            if (lfs3_m_isrdonly(lfs3->flags) || !t->ht) {
-                t->ht = NULL;
-                t->b.h.mdir.mid += 1;
-                lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_MDIR);
+            if (lfs3_m_isrdonly(lfs3->flags) || !trv->htrv) {
+                trv->htrv = NULL;
+                trv->b.h.mdir.mid += 1;
+                lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_MDIR);
                 continue;
             }
 
@@ -9958,18 +9958,18 @@ static lfs3_stag_t lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t,
             // literally every file open, but other things grow O(n^2) with
             // this list anyways
             //
-            if (t->ht->mdir.mid != t->b.h.mdir.mid
-                    || lfs3_o_type(t->ht->flags) != LFS3_TYPE_REG
-                    || !lfs3_o_isunsync(t->ht->flags)) {
-                t->ht = t->ht->next;
+            if (trv->htrv->mdir.mid != trv->b.h.mdir.mid
+                    || lfs3_o_type(trv->htrv->flags) != LFS3_TYPE_REG
+                    || !lfs3_o_isunsync(trv->htrv->flags)) {
+                trv->htrv = trv->htrv->next;
                 continue;
             }
 
             // transition to traversing the file
-            const lfs3_file_t *file = (const lfs3_file_t*)t->ht;
-            t->b.shrub = file->b.shrub;
-            lfs3_btraversal_init(&t->u.bt);
-            lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_OBTREE);
+            const lfs3_file_t *file = (const lfs3_file_t*)trv->htrv;
+            trv->b.shrub = file->b.shrub;
+            lfs3_btrv_init(&trv->u.btrv);
+            lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_OBTREE);
             continue;
         #endif
 
@@ -9980,30 +9980,30 @@ static lfs3_stag_t lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t,
         case LFS3_TSTATE_BTREE:;
         case LFS3_TSTATE_OBTREE:;
             // traverse through our bshrub/btree
-            tag = lfs3_bshrub_traverse(lfs3, &t->b, &t->u.bt,
+            tag = lfs3_bshrub_traverse(lfs3, &trv->b, &trv->u.btrv,
                     NULL, NULL, &data);
             if (tag < 0) {
                 if (tag == LFS3_ERR_NOENT) {
                     // clear the bshrub state
-                    lfs3_bshrub_init(&t->b);
+                    lfs3_bshrub_init(&trv->b);
                     // end of mtree? start iterating over mdirs
-                    if (lfs3_t_tstate(t->b.h.flags)
+                    if (lfs3_t_tstate(trv->b.h.flags)
                             == LFS3_TSTATE_MTREE) {
-                        t->b.h.mdir.mid = 0;
-                        lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_MDIRS);
+                        trv->b.h.mdir.mid = 0;
+                        lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_MDIRS);
                         continue;
                     // end of mdir btree? start iterating over opened files
-                    } else if (lfs3_t_tstate(t->b.h.flags)
+                    } else if (lfs3_t_tstate(trv->b.h.flags)
                             == LFS3_TSTATE_BTREE) {
-                        t->ht = lfs3->handles;
-                        lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_OMDIRS);
+                        trv->htrv = lfs3->handles;
+                        lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_OMDIRS);
                         continue;
                     // end of opened btree? go to next opened file
                     } else if (lfs3_m_isrdonly(lfs3->flags)
-                            || lfs3_t_tstate(t->b.h.flags)
+                            || lfs3_t_tstate(trv->b.h.flags)
                                 == LFS3_TSTATE_OBTREE) {
-                        t->ht = t->ht->next;
-                        lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_OMDIRS);
+                        trv->htrv = trv->htrv->next;
+                        lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_OMDIRS);
                         continue;
                     } else {
                         LFS3_UNREACHABLE();
@@ -10049,9 +10049,9 @@ static void lfs3_alloc_markinuse(lfs3_t *lfs3,
 // high-level immutable traversal, handle extra features here,
 // but no mutation! (we're called in lfs3_alloc, so things would end up
 // recursive, which would be a bit bad!)
-static lfs3_stag_t lfs3_mtree_traverse(lfs3_t *lfs3, lfs3_traversal_t *t,
+static lfs3_stag_t lfs3_mtree_traverse(lfs3_t *lfs3, lfs3_trv_t *trv,
         lfs3_bptr_t *bptr_) {
-    lfs3_stag_t tag = lfs3_mtree_traverse_(lfs3, t,
+    lfs3_stag_t tag = lfs3_mtree_traverse_(lfs3, trv,
             bptr_);
     if (tag < 0) {
         // end of traversal?
@@ -10071,8 +10071,8 @@ static lfs3_stag_t lfs3_mtree_traverse(lfs3_t *lfs3, lfs3_traversal_t *t,
     //
     // we also compare mdir checksums with any open mdirs to try to
     // avoid traversing any outdated bshrubs/btrees
-    if ((lfs3_t_isckmeta(t->b.h.flags)
-                || lfs3_t_isckdata(t->b.h.flags))
+    if ((lfs3_t_isckmeta(trv->b.h.flags)
+                || lfs3_t_isckdata(trv->b.h.flags))
             && tag == LFS3_TAG_MDIR) {
         lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr_->d.u.buffer;
 
@@ -10106,7 +10106,7 @@ static lfs3_stag_t lfs3_mtree_traverse(lfs3_t *lfs3, lfs3_traversal_t *t,
         }
 
         // recalculate gcksum
-        t->gcksum ^= mdir->r.cksum;
+        trv->gcksum ^= mdir->r.cksum;
     }
 
     // validate btree nodes?
@@ -10114,8 +10114,8 @@ static lfs3_stag_t lfs3_mtree_traverse(lfs3_t *lfs3, lfs3_traversal_t *t,
     // this may end up revalidating some btree nodes when ckfetches
     // is enabled, but we need to revalidate cached btree nodes or
     // we risk missing errors in ckmeta scans
-    if ((lfs3_t_isckmeta(t->b.h.flags)
-                || lfs3_t_isckdata(t->b.h.flags))
+    if ((lfs3_t_isckmeta(trv->b.h.flags)
+                || lfs3_t_isckdata(trv->b.h.flags))
             && tag == LFS3_TAG_BRANCH) {
         lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr_->d.u.buffer;
         int err = lfs3_rbyd_fetchck(lfs3, rbyd,
@@ -10128,7 +10128,7 @@ static lfs3_stag_t lfs3_mtree_traverse(lfs3_t *lfs3, lfs3_traversal_t *t,
 
     // validate data blocks?
     #ifndef LFS3_2BONLY
-    if (lfs3_t_isckdata(t->b.h.flags)
+    if (lfs3_t_isckdata(trv->b.h.flags)
             && tag == LFS3_TAG_BLOCK) {
         int err = lfs3_bptr_ck(lfs3, bptr_);
         if (err) {
@@ -10141,30 +10141,30 @@ static lfs3_stag_t lfs3_mtree_traverse(lfs3_t *lfs3, lfs3_traversal_t *t,
 
 eot:;
     // compare gcksum with in-RAM gcksum
-    if ((lfs3_t_isckmeta(t->b.h.flags)
-                || lfs3_t_isckdata(t->b.h.flags))
-            && !lfs3_t_isdirty(t->b.h.flags)
-            && !lfs3_t_ismutated(t->b.h.flags)
-            && t->gcksum != lfs3->gcksum) {
+    if ((lfs3_t_isckmeta(trv->b.h.flags)
+                || lfs3_t_isckdata(trv->b.h.flags))
+            && !lfs3_t_isdirty(trv->b.h.flags)
+            && !lfs3_t_ismutated(trv->b.h.flags)
+            && trv->gcksum != lfs3->gcksum) {
         LFS3_ERROR("Found gcksum mismatch, cksum %08"PRIx32" (!= %08"PRIx32")",
-                t->gcksum,
+                trv->gcksum,
                 lfs3->gcksum);
         return LFS3_ERR_CORRUPT;
     }
 
     // was ckmeta/ckdata successful? we only consider our filesystem
     // checked if we weren't mutated
-    if ((lfs3_t_isckmeta(t->b.h.flags)
-                || lfs3_t_isckdata(t->b.h.flags))
-            && !lfs3_t_ismtreeonly(t->b.h.flags)
-            && !lfs3_t_isdirty(t->b.h.flags)
-            && !lfs3_t_ismutated(t->b.h.flags)) {
+    if ((lfs3_t_isckmeta(trv->b.h.flags)
+                || lfs3_t_isckdata(trv->b.h.flags))
+            && !lfs3_t_ismtreeonly(trv->b.h.flags)
+            && !lfs3_t_isdirty(trv->b.h.flags)
+            && !lfs3_t_ismutated(trv->b.h.flags)) {
         lfs3->flags &= ~LFS3_I_CKMETA;
     }
-    if (lfs3_t_isckdata(t->b.h.flags)
-            && !lfs3_t_ismtreeonly(t->b.h.flags)
-            && !lfs3_t_isdirty(t->b.h.flags)
-            && !lfs3_t_ismutated(t->b.h.flags)) {
+    if (lfs3_t_isckdata(trv->b.h.flags)
+            && !lfs3_t_ismtreeonly(trv->b.h.flags)
+            && !lfs3_t_isdirty(trv->b.h.flags)
+            && !lfs3_t_ismutated(trv->b.h.flags)) {
         lfs3->flags &= ~LFS3_I_CKDATA;
     }
 
@@ -10177,10 +10177,10 @@ static void lfs3_alloc_markfree(lfs3_t *lfs3);
 
 // high-level mutating traversal, handle extra features that require
 // mutation here, upper layers should call lfs3_alloc_ckpoint as needed
-static lfs3_stag_t lfs3_mtree_gc(lfs3_t *lfs3, lfs3_traversal_t *t,
+static lfs3_stag_t lfs3_mtree_gc(lfs3_t *lfs3, lfs3_trv_t *trv,
         lfs3_bptr_t *bptr_) {
 dropped:;
-    lfs3_stag_t tag = lfs3_mtree_traverse(lfs3, t,
+    lfs3_stag_t tag = lfs3_mtree_traverse(lfs3, trv,
             bptr_);
     if (tag < 0) {
         // end of traversal?
@@ -10194,18 +10194,18 @@ dropped:;
 
     #ifndef LFS3_RDONLY
     // swap dirty/mutated flags while in lfs3_mtree_gc
-    t->b.h.flags = lfs3_t_swapdirty(t->b.h.flags);
+    trv->b.h.flags = lfs3_t_swapdirty(trv->b.h.flags);
     int err;
 
     // track in-use blocks?
     #ifndef LFS3_2BONLY
-    if (lfs3_t_islookahead(t->b.h.flags)) {
+    if (lfs3_t_islookahead(trv->b.h.flags)) {
         lfs3_alloc_markinuse(lfs3, tag, bptr_);
     }
     #endif
 
     // mkconsistencing mdirs?
-    if (lfs3_t_ismkconsistent(t->b.h.flags)
+    if (lfs3_t_ismkconsistent(trv->b.h.flags)
             && lfs3_t_ismkconsistent(lfs3->flags)
             && tag == LFS3_TAG_MDIR) {
         lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr_->d.u.buffer;
@@ -10215,22 +10215,22 @@ dropped:;
         }
 
         // make sure we clear any zombie flags
-        t->b.h.flags &= ~LFS3_o_ZOMBIE;
+        trv->b.h.flags &= ~LFS3_o_ZOMBIE;
 
         // did this drop our mdir?
         #ifndef LFS3_2BONLY
         if (mdir->mid != -1 && mdir->r.weight == 0) {
             // swap back dirty/mutated flags
-            t->b.h.flags = lfs3_t_swapdirty(t->b.h.flags);
+            trv->b.h.flags = lfs3_t_swapdirty(trv->b.h.flags);
             // continue traversal
-            lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_MDIRS);
+            lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_MDIRS);
             goto dropped;
         }
         #endif
     }
 
     // compacting mdirs?
-    if (lfs3_t_iscompact(t->b.h.flags)
+    if (lfs3_t_iscompact(trv->b.h.flags)
             && tag == LFS3_TAG_MDIR
             // exceed compaction threshold?
             && lfs3_rbyd_eoff(&((lfs3_mdir_t*)bptr_->d.u.buffer)->r)
@@ -10258,14 +10258,14 @@ dropped:;
     }
 
     // swap back dirty/mutated flags
-    t->b.h.flags = lfs3_t_swapdirty(t->b.h.flags);
+    trv->b.h.flags = lfs3_t_swapdirty(trv->b.h.flags);
     #endif
     return tag;
 
     #ifndef LFS3_RDONLY
 failed:;
     // swap back dirty/mutated flags
-    t->b.h.flags = lfs3_t_swapdirty(t->b.h.flags);
+    trv->b.h.flags = lfs3_t_swapdirty(trv->b.h.flags);
     return err;
     #endif
 
@@ -10273,25 +10273,25 @@ eot:;
     #ifndef LFS3_RDONLY
     // was lookahead scan successful?
     #ifndef LFS3_2BONLY
-    if (lfs3_t_islookahead(t->b.h.flags)
-            && !lfs3_t_ismtreeonly(t->b.h.flags)
-            && !lfs3_t_isdirty(t->b.h.flags)
-            && !lfs3_t_ismutated(t->b.h.flags)) {
+    if (lfs3_t_islookahead(trv->b.h.flags)
+            && !lfs3_t_ismtreeonly(trv->b.h.flags)
+            && !lfs3_t_isdirty(trv->b.h.flags)
+            && !lfs3_t_ismutated(trv->b.h.flags)) {
         lfs3_alloc_markfree(lfs3);
     }
     #endif
 
     // was mkconsistent successful?
-    if (lfs3_t_ismkconsistent(t->b.h.flags)
-            && !lfs3_t_isdirty(t->b.h.flags)) {
+    if (lfs3_t_ismkconsistent(trv->b.h.flags)
+            && !lfs3_t_isdirty(trv->b.h.flags)) {
         lfs3->flags &= ~LFS3_I_MKCONSISTENT;
     }
 
     // was compaction successful? note we may need multiple passes if
     // we want to be sure everything is compacted
-    if (lfs3_t_iscompact(t->b.h.flags)
-            && !lfs3_t_isdirty(t->b.h.flags)
-            && !lfs3_t_ismutated(t->b.h.flags)) {
+    if (lfs3_t_iscompact(trv->b.h.flags)
+            && !lfs3_t_isdirty(trv->b.h.flags)
+            && !lfs3_t_ismutated(trv->b.h.flags)) {
         lfs3->flags &= ~LFS3_I_COMPACT;
     }
     #endif
@@ -10506,11 +10506,11 @@ static lfs3_sblock_t lfs3_alloc(lfs3_t *lfs3, uint32_t flags) {
         // traverse the filesystem, building up knowledge of what blocks are
         // in-use in the next lookahead window
         //
-        lfs3_traversal_t t;
-        lfs3_traversal_init(&t, LFS3_T_RDONLY | LFS3_T_LOOKAHEAD);
+        lfs3_trv_t trv;
+        lfs3_trv_init(&trv, LFS3_T_RDONLY | LFS3_T_LOOKAHEAD);
         while (true) {
             lfs3_bptr_t bptr;
-            lfs3_stag_t tag = lfs3_mtree_traverse(lfs3, &t,
+            lfs3_stag_t tag = lfs3_mtree_traverse(lfs3, &trv,
                     &bptr);
             if (tag < 0) {
                 if (tag == LFS3_ERR_NOENT) {
@@ -10876,11 +10876,11 @@ int lfs3_remove(lfs3_t *lfs3, const char *path) {
             }
 
         // clobber entangled traversals
-        } else if (lfs3_o_type(h->flags) == LFS3_type_TRAVERSAL) {
+        } else if (lfs3_o_type(h->flags) == LFS3_type_TRV) {
             if (lfs3_o_iszombie(h->flags)) {
                 h->flags &= ~LFS3_o_ZOMBIE;
                 h->mdir.mid -= 1;
-                lfs3_traversal_clobber(lfs3, (lfs3_traversal_t*)h);
+                lfs3_trv_clobber(lfs3, (lfs3_trv_t*)h);
             }
         }
     }
@@ -11061,10 +11061,10 @@ int lfs3_rename(lfs3_t *lfs3, const char *old_path, const char *new_path) {
             }
 
         // clobber entangled traversals
-        } else if (lfs3_o_type(h->flags) == LFS3_type_TRAVERSAL
+        } else if (lfs3_o_type(h->flags) == LFS3_type_TRV
                 && ((new_tag != LFS3_ERR_NOENT && h->mdir.mid == new_mdir.mid)
                     || h->mdir.mid == lfs3->grm.queue[0])) {
-            lfs3_traversal_clobber(lfs3, (lfs3_traversal_t*)h);
+            lfs3_trv_clobber(lfs3, (lfs3_trv_t*)h);
         }
     }
 
@@ -13706,9 +13706,9 @@ static int lfs3_file_sync_(lfs3_t *lfs3, lfs3_file_t *file,
         #endif
 
         // clobber entangled traversals
-        if (lfs3_o_type(h->flags) == LFS3_type_TRAVERSAL
+        if (lfs3_o_type(h->flags) == LFS3_type_TRV
                 && h->mdir.mid == file->b.h.mdir.mid) {
-            lfs3_traversal_clobber(lfs3, (lfs3_traversal_t*)h);
+            lfs3_trv_clobber(lfs3, (lfs3_trv_t*)h);
         }
     }
 
@@ -14084,11 +14084,11 @@ failed:;
 static int lfs3_file_ck(lfs3_t *lfs3, const lfs3_file_t *file,
         uint32_t flags) {
     // traverse the file's bshrub/btree
-    lfs3_btraversal_t bt;
-    lfs3_btraversal_init(&bt);
+    lfs3_btrv_t btrv;
+    lfs3_btrv_init(&btrv);
     while (true) {
         lfs3_data_t data;
-        lfs3_stag_t tag = lfs3_bshrub_traverse(lfs3, &file->b, &bt,
+        lfs3_stag_t tag = lfs3_bshrub_traverse(lfs3, &file->b, &btrv,
                 NULL, NULL, &data);
         if (tag < 0) {
             if (tag == LFS3_ERR_NOENT) {
@@ -14965,11 +14965,11 @@ static int lfs3_mountinited(lfs3_t *lfs3) {
     // we do validate btree inner nodes here, how can we trust our
     // mdirs are valid if we haven't checked the btree inner nodes at
     // least once?
-    lfs3_traversal_t t;
-    lfs3_traversal_init(&t, LFS3_T_RDONLY | LFS3_T_MTREEONLY | LFS3_T_CKMETA);
+    lfs3_trv_t trv;
+    lfs3_trv_init(&trv, LFS3_T_RDONLY | LFS3_T_MTREEONLY | LFS3_T_CKMETA);
     while (true) {
         lfs3_bptr_t bptr;
-        lfs3_stag_t tag = lfs3_mtree_traverse(lfs3, &t,
+        lfs3_stag_t tag = lfs3_mtree_traverse(lfs3, &trv,
                 &bptr);
         if (tag < 0) {
             if (tag == LFS3_ERR_NOENT) {
@@ -15126,7 +15126,7 @@ static int lfs3_mountinited(lfs3_t *lfs3) {
 }
 
 // needed in lfs3_mount
-static int lfs3_fs_gc_(lfs3_t *lfs3, lfs3_traversal_t *t,
+static int lfs3_fs_gc_(lfs3_t *lfs3, lfs3_trv_t *trv,
         uint32_t flags, lfs3_soff_t steps);
 
 int lfs3_mount(lfs3_t *lfs3, uint32_t flags,
@@ -15225,8 +15225,8 @@ int lfs3_mount(lfs3_t *lfs3, uint32_t flags,
                 | LFS3_IFDEF_RDONLY(0, LFS3_M_COMPACT)
                 | LFS3_M_CKMETA
                 | LFS3_M_CKDATA)) {
-        lfs3_traversal_t t;
-        err = lfs3_fs_gc_(lfs3, &t,
+        lfs3_trv_t trv;
+        err = lfs3_fs_gc_(lfs3, &trv,
                 flags & (
                     LFS3_IFDEF_RDONLY(0, LFS3_M_MKCONSISTENT)
                         | LFS3_IFDEF_RDONLY(0, LFS3_M_LOOKAHEAD)
@@ -15267,8 +15267,8 @@ int lfs3_unmount(lfs3_t *lfs3) {
     LFS3_ASSERT(lfs3->handles == NULL
             // special case for our gc traversal handle
             || LFS3_IFDEF_GC(
-                (lfs3->handles == &lfs3->gc.t.b.h
-                    && lfs3->gc.t.b.h.next == NULL),
+                (lfs3->handles == &lfs3->gc.trv.b.h
+                    && lfs3->gc.trv.b.h.next == NULL),
                 false));
 
     return lfs3_deinit(lfs3);
@@ -15439,8 +15439,8 @@ int lfs3_format(lfs3_t *lfs3, uint32_t flags,
     if (flags & (
             LFS3_F_CKMETA
                 | LFS3_F_CKDATA)) {
-        lfs3_traversal_t t;
-        err = lfs3_fs_gc_(lfs3, &t,
+        lfs3_trv_t trv;
+        err = lfs3_fs_gc_(lfs3, &trv,
                 flags & (
                     LFS3_F_CKMETA
                         | LFS3_F_CKDATA),
@@ -15496,11 +15496,11 @@ int lfs3_fs_stat(lfs3_t *lfs3, struct lfs3_fsinfo *fsinfo) {
 
 lfs3_ssize_t lfs3_fs_usage(lfs3_t *lfs3) {
     lfs3_size_t count = 0;
-    lfs3_traversal_t t;
-    lfs3_traversal_init(&t, LFS3_T_RDONLY);
+    lfs3_trv_t trv;
+    lfs3_trv_init(&trv, LFS3_T_RDONLY);
     while (true) {
         lfs3_bptr_t bptr;
-        lfs3_stag_t tag = lfs3_mtree_traverse(lfs3, &t,
+        lfs3_stag_t tag = lfs3_mtree_traverse(lfs3, &trv,
                 &bptr);
         if (tag < 0) {
             if (tag == LFS3_ERR_NOENT) {
@@ -15640,12 +15640,12 @@ failed:;
 #ifndef LFS3_RDONLY
 static int lfs3_fs_fixorphans(lfs3_t *lfs3) {
     // LFS3_T_MKCONSISTENT really just removes orphans
-    lfs3_traversal_t t;
-    lfs3_traversal_init(&t,
+    lfs3_trv_t trv;
+    lfs3_trv_init(&trv,
             LFS3_T_RDWR | LFS3_T_MTREEONLY | LFS3_T_MKCONSISTENT);
     while (true) {
         lfs3_bptr_t bptr;
-        lfs3_stag_t tag = lfs3_mtree_gc(lfs3, &t,
+        lfs3_stag_t tag = lfs3_mtree_gc(lfs3, &trv,
                 &bptr);
         if (tag < 0) {
             if (tag == LFS3_ERR_NOENT) {
@@ -15692,11 +15692,11 @@ int lfs3_fs_mkconsistent(lfs3_t *lfs3) {
 // filesystem check functions
 static int lfs3_fs_ck(lfs3_t *lfs3, uint32_t flags) {
     // we leave this up to lfs3_mtree_traverse
-    lfs3_traversal_t t;
-    lfs3_traversal_init(&t, flags);
+    lfs3_trv_t trv;
+    lfs3_trv_init(&trv, flags);
     while (true) {
         lfs3_bptr_t bptr;
-        lfs3_stag_t tag = lfs3_mtree_traverse(lfs3, &t,
+        lfs3_stag_t tag = lfs3_mtree_traverse(lfs3, &trv,
                 &bptr);
         if (tag < 0) {
             if (tag == LFS3_ERR_NOENT) {
@@ -15727,7 +15727,7 @@ int lfs3_fs_cksum(lfs3_t *lfs3, uint32_t *cksum) {
 //
 // runs the traversal until all work is completed, which may take
 // multiple passes
-static int lfs3_fs_gc_(lfs3_t *lfs3, lfs3_traversal_t *t,
+static int lfs3_fs_gc_(lfs3_t *lfs3, lfs3_trv_t *trv,
         uint32_t flags, lfs3_soff_t steps) {
     // unknown gc flags?
     //
@@ -15774,41 +15774,41 @@ static int lfs3_fs_gc_(lfs3_t *lfs3, lfs3_traversal_t *t,
         #endif
 
         // start a new traversal?
-        if (!lfs3_handle_isopen(lfs3, &t->b.h)) {
-            lfs3_traversal_init(t, pending);
-            lfs3_handle_open(lfs3, &t->b.h);
+        if (!lfs3_handle_isopen(lfs3, &trv->b.h)) {
+            lfs3_trv_init(trv, pending);
+            lfs3_handle_open(lfs3, &trv->b.h);
         }
 
         // don't bother with lookahead if we've mutated
         #ifndef LFS3_RDONLY
-        if (lfs3_t_isdirty(t->b.h.flags)
-                || lfs3_t_ismutated(t->b.h.flags)) {
-            t->b.h.flags &= ~LFS3_T_LOOKAHEAD;
+        if (lfs3_t_isdirty(trv->b.h.flags)
+                || lfs3_t_ismutated(trv->b.h.flags)) {
+            trv->b.h.flags &= ~LFS3_T_LOOKAHEAD;
         }
         #endif
 
         // will this traversal still make progress? no? start over
-        if (!(t->b.h.flags & (
+        if (!(trv->b.h.flags & (
                 LFS3_IFDEF_RDONLY(0, LFS3_T_MKCONSISTENT)
                     | LFS3_IFDEF_RDONLY(0, LFS3_T_LOOKAHEAD)
                     | LFS3_IFDEF_RDONLY(0, LFS3_T_COMPACT)
                     | LFS3_T_CKMETA
                     | LFS3_T_CKDATA))) {
-            lfs3_handle_close(lfs3, &t->b.h);
+            lfs3_handle_close(lfs3, &trv->b.h);
             continue;
         }
 
         // do we really need a full traversal?
-        if (!(t->b.h.flags & (
+        if (!(trv->b.h.flags & (
                 LFS3_IFDEF_RDONLY(0, LFS3_T_LOOKAHEAD)
                     | LFS3_T_CKMETA
                     | LFS3_T_CKDATA))) {
-            t->b.h.flags |= LFS3_T_MTREEONLY;
+            trv->b.h.flags |= LFS3_T_MTREEONLY;
         }
 
         // progress gc
         lfs3_bptr_t bptr;
-        lfs3_stag_t tag = lfs3_mtree_gc(lfs3, t,
+        lfs3_stag_t tag = lfs3_mtree_gc(lfs3, trv,
                 &bptr);
         if (tag < 0 && tag != LFS3_ERR_NOENT) {
             return tag;
@@ -15816,7 +15816,7 @@ static int lfs3_fs_gc_(lfs3_t *lfs3, lfs3_traversal_t *t,
 
         // end of traversal?
         if (tag == LFS3_ERR_NOENT) {
-            lfs3_handle_close(lfs3, &t->b.h);
+            lfs3_handle_close(lfs3, &trv->b.h);
 
             // clear any pending flags we make progress on
             pending &= lfs3->flags & (
@@ -15841,7 +15841,7 @@ static int lfs3_fs_gc_(lfs3_t *lfs3, lfs3_traversal_t *t,
 // perform any pending janitorial work
 #ifdef LFS3_GC
 int lfs3_fs_gc(lfs3_t *lfs3) {
-    return lfs3_fs_gc_(lfs3, &lfs3->gc.t,
+    return lfs3_fs_gc_(lfs3, &lfs3->gc.trv,
             lfs3->cfg->gc_flags,
             (lfs3->cfg->gc_steps)
                 ? lfs3->cfg->gc_steps
@@ -15867,7 +15867,7 @@ int lfs3_fs_unck(lfs3_t *lfs3, uint32_t flags) {
     // lfs3_fs_gc will terminate early if it discovers it can no longer
     // make progress
     #ifdef LFS3_GC
-    lfs3->gc.t.b.h.flags &= ~flags;
+    lfs3->gc.trv.b.h.flags &= ~flags;
     #endif
 
     return 0;
@@ -15937,12 +15937,12 @@ failed:;
 
 /// High-level filesystem traversal ///
 
-// needed in lfs3_traversal_open
-static int lfs3_traversal_rewind_(lfs3_t *lfs3, lfs3_traversal_t *t);
+// needed in lfs3_trv_open
+static int lfs3_trv_rewind_(lfs3_t *lfs3, lfs3_trv_t *trv);
 
-int lfs3_traversal_open(lfs3_t *lfs3, lfs3_traversal_t *t, uint32_t flags) {
+int lfs3_trv_open(lfs3_t *lfs3, lfs3_trv_t *trv, uint32_t flags) {
     // already open?
-    LFS3_ASSERT(!lfs3_handle_isopen(lfs3, &t->b.h));
+    LFS3_ASSERT(!lfs3_handle_isopen(lfs3, &trv->b.h));
     // unknown flags?
     LFS3_ASSERT((flags & ~(
             LFS3_IFDEF_RDONLY(0, LFS3_T_RDWR)
@@ -15964,46 +15964,46 @@ int lfs3_traversal_open(lfs3_t *lfs3, lfs3_traversal_t *t, uint32_t flags) {
     LFS3_ASSERT(!lfs3_t_ismtreeonly(flags) || !lfs3_t_isckdata(flags));
 
     // setup traversal state
-    t->b.h.flags = flags | lfs3_o_typeflags(LFS3_type_TRAVERSAL);
+    trv->b.h.flags = flags | lfs3_o_typeflags(LFS3_type_TRV);
 
     // let rewind initialize/reset things
-    int err = lfs3_traversal_rewind_(lfs3, t);
+    int err = lfs3_trv_rewind_(lfs3, trv);
     if (err) {
         return err;
     }
 
     // add to tracked mdirs
-    lfs3_handle_open(lfs3, &t->b.h);
+    lfs3_handle_open(lfs3, &trv->b.h);
     return 0;
 }
 
-int lfs3_traversal_close(lfs3_t *lfs3, lfs3_traversal_t *t) {
-    LFS3_ASSERT(lfs3_handle_isopen(lfs3, &t->b.h));
+int lfs3_trv_close(lfs3_t *lfs3, lfs3_trv_t *trv) {
+    LFS3_ASSERT(lfs3_handle_isopen(lfs3, &trv->b.h));
 
     // remove from tracked mdirs
-    lfs3_handle_close(lfs3, &t->b.h);
+    lfs3_handle_close(lfs3, &trv->b.h);
     return 0;
 }
 
-int lfs3_traversal_read(lfs3_t *lfs3, lfs3_traversal_t *t,
+int lfs3_trv_read(lfs3_t *lfs3, lfs3_trv_t *trv,
         struct lfs3_tinfo *tinfo) {
-    LFS3_ASSERT(lfs3_handle_isopen(lfs3, &t->b.h));
+    LFS3_ASSERT(lfs3_handle_isopen(lfs3, &trv->b.h));
 
     // check for pending grms every step, just in case some other
     // operation introduced new grms
     #ifndef LFS3_RDONLY
-    if (lfs3_t_ismkconsistent(t->b.h.flags)
+    if (lfs3_t_ismkconsistent(trv->b.h.flags)
             && lfs3_grm_count(lfs3) > 0) {
         // swap dirty/mutated flags while mutating
-        t->b.h.flags = lfs3_t_swapdirty(t->b.h.flags);
+        trv->b.h.flags = lfs3_t_swapdirty(trv->b.h.flags);
 
         int err = lfs3_fs_fixgrm(lfs3);
         if (err) {
-            t->b.h.flags = lfs3_t_swapdirty(t->b.h.flags);
+            trv->b.h.flags = lfs3_t_swapdirty(trv->b.h.flags);
             return err;
         }
 
-        t->b.h.flags = lfs3_t_swapdirty(t->b.h.flags);
+        trv->b.h.flags = lfs3_t_swapdirty(trv->b.h.flags);
     }
     #endif
 
@@ -16014,19 +16014,19 @@ int lfs3_traversal_read(lfs3_t *lfs3, lfs3_traversal_t *t,
 
     while (true) {
         // some redund blocks left over?
-        if (t->blocks[0] != -1) {
+        if (trv->blocks[0] != -1) {
             // write our traversal info
-            tinfo->btype = lfs3_t_btype(t->b.h.flags);
-            tinfo->block = t->blocks[0];
+            tinfo->btype = lfs3_t_btype(trv->b.h.flags);
+            tinfo->block = trv->blocks[0];
 
-            t->blocks[0] = t->blocks[1];
-            t->blocks[1] = -1;
+            trv->blocks[0] = trv->blocks[1];
+            trv->blocks[1] = -1;
             return 0;
         }
 
         // find next block
         lfs3_bptr_t bptr;
-        lfs3_stag_t tag = lfs3_mtree_gc(lfs3, t,
+        lfs3_stag_t tag = lfs3_mtree_gc(lfs3, trv,
                 &bptr);
         if (tag < 0) {
             return tag;
@@ -16035,20 +16035,20 @@ int lfs3_traversal_read(lfs3_t *lfs3, lfs3_traversal_t *t,
         // figure out type/blocks
         if (tag == LFS3_TAG_MDIR) {
             lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.d.u.buffer;
-            lfs3_t_setbtype(&t->b.h.flags, LFS3_BTYPE_MDIR);
-            t->blocks[0] = mdir->r.blocks[0];
-            t->blocks[1] = mdir->r.blocks[1];
+            lfs3_t_setbtype(&trv->b.h.flags, LFS3_BTYPE_MDIR);
+            trv->blocks[0] = mdir->r.blocks[0];
+            trv->blocks[1] = mdir->r.blocks[1];
 
         } else if (tag == LFS3_TAG_BRANCH) {
-            lfs3_t_setbtype(&t->b.h.flags, LFS3_BTYPE_BTREE);
+            lfs3_t_setbtype(&trv->b.h.flags, LFS3_BTYPE_BTREE);
             lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.d.u.buffer;
-            t->blocks[0] = rbyd->blocks[0];
-            t->blocks[1] = -1;
+            trv->blocks[0] = rbyd->blocks[0];
+            trv->blocks[1] = -1;
 
         } else if (tag == LFS3_TAG_BLOCK) {
-            lfs3_t_setbtype(&t->b.h.flags, LFS3_BTYPE_DATA);
-            t->blocks[0] = lfs3_bptr_block(&bptr);
-            t->blocks[1] = -1;
+            lfs3_t_setbtype(&trv->b.h.flags, LFS3_BTYPE_DATA);
+            trv->blocks[0] = lfs3_bptr_block(&bptr);
+            trv->blocks[1] = -1;
 
         } else {
             LFS3_UNREACHABLE();
@@ -16057,68 +16057,68 @@ int lfs3_traversal_read(lfs3_t *lfs3, lfs3_traversal_t *t,
 }
 
 #ifndef LFS3_RDONLY
-static void lfs3_traversal_clobber(lfs3_t *lfs3, lfs3_traversal_t *t) {
+static void lfs3_trv_clobber(lfs3_t *lfs3, lfs3_trv_t *trv) {
     (void)lfs3;
     // mroot/mtree? transition to mdir iteration
     if (LFS3_IFDEF_2BONLY(
             false,
-            lfs3_t_tstate(t->b.h.flags) < LFS3_TSTATE_MDIRS)) {
+            lfs3_t_tstate(trv->b.h.flags) < LFS3_TSTATE_MDIRS)) {
         #ifndef LFS3_2BONLY
-        lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_MDIRS);
-        t->b.h.mdir.mid = 0;
-        lfs3_bshrub_init(&t->b);
-        t->ht = NULL;
+        lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_MDIRS);
+        trv->b.h.mdir.mid = 0;
+        lfs3_bshrub_init(&trv->b);
+        trv->htrv = NULL;
         #endif
     // in-mtree mdir? increment the mid (to make progress) and reset to
     // mdir iteration
     } else if (LFS3_IFDEF_2BONLY(
             false,
-            lfs3_t_tstate(t->b.h.flags) < LFS3_TSTATE_OMDIRS)) {
+            lfs3_t_tstate(trv->b.h.flags) < LFS3_TSTATE_OMDIRS)) {
         #ifndef LFS3_2BONLY
-        lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_MDIR);
-        t->b.h.mdir.mid += 1;
-        lfs3_bshrub_init(&t->b);
-        t->ht = NULL;
+        lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_MDIR);
+        trv->b.h.mdir.mid += 1;
+        lfs3_bshrub_init(&trv->b);
+        trv->htrv = NULL;
         #endif
     // opened mdir? skip to next omdir
-    } else if (lfs3_t_tstate(t->b.h.flags) < LFS3_TSTATE_DONE) {
-        lfs3_t_settstate(&t->b.h.flags, LFS3_IFDEF_2BONLY(
+    } else if (lfs3_t_tstate(trv->b.h.flags) < LFS3_TSTATE_DONE) {
+        lfs3_t_settstate(&trv->b.h.flags, LFS3_IFDEF_2BONLY(
                 LFS3_TSTATE_DONE,
                 LFS3_TSTATE_OMDIRS));
-        lfs3_bshrub_init(&t->b);
-        t->ht = (t->ht) ? t->ht->next : NULL;
+        lfs3_bshrub_init(&trv->b);
+        trv->htrv = (trv->htrv) ? trv->htrv->next : NULL;
     // done traversals should never need clobbering
     } else {
         LFS3_UNREACHABLE();
     }
 
     // and clear any pending blocks
-    t->blocks[0] = -1;
-    t->blocks[1] = -1;
+    trv->blocks[0] = -1;
+    trv->blocks[1] = -1;
 }
 #endif
 
-static int lfs3_traversal_rewind_(lfs3_t *lfs3, lfs3_traversal_t *t) {
+static int lfs3_trv_rewind_(lfs3_t *lfs3, lfs3_trv_t *trv) {
     (void)lfs3;
 
     // reset traversal
-    lfs3_traversal_init(t,
-            t->b.h.flags
+    lfs3_trv_init(trv,
+            trv->b.h.flags
                 & ~LFS3_t_DIRTY
                 & ~LFS3_t_MUTATED
                 & ~LFS3_t_TSTATE);
 
     // and clear any pending blocks
-    t->blocks[0] = -1;
-    t->blocks[1] = -1;
+    trv->blocks[0] = -1;
+    trv->blocks[1] = -1;
 
     return 0;
 }
 
-int lfs3_traversal_rewind(lfs3_t *lfs3, lfs3_traversal_t *t) {
-    LFS3_ASSERT(lfs3_handle_isopen(lfs3, &t->b.h));
+int lfs3_trv_rewind(lfs3_t *lfs3, lfs3_trv_t *trv) {
+    LFS3_ASSERT(lfs3_handle_isopen(lfs3, &trv->b.h));
 
-    return lfs3_traversal_rewind_(lfs3, t);
+    return lfs3_trv_rewind_(lfs3, trv);
 }
 
 
diff --git a/lfs3.h b/lfs3.h
index 4bc29f17..f94b780c 100644
--- a/lfs3.h
+++ b/lfs3.h
@@ -108,7 +108,7 @@ enum lfs3_type {
     // internally used types, don't use these
     LFS3_type_BOOKMARK   = 4,  // Directory bookmark
     LFS3_type_ORPHAN     = 5,  // An orphaned stickynote
-    LFS3_type_TRAVERSAL  = 6,  // An open traversal object
+    LFS3_type_TRV        = 6,  // An open traversal object
 };
 
 // File open flags
@@ -757,20 +757,20 @@ typedef struct lfs3_dir {
     lfs3_off_t pos;
 } lfs3_dir_t;
 
-typedef struct lfs3_btraversal {
+typedef struct lfs3_btrv {
     lfs3_bid_t bid;
     const lfs3_rbyd_t *branch;
     lfs3_srid_t rid;
     lfs3_rbyd_t rbyd;
-} lfs3_btraversal_t;
+} lfs3_btrv_t;
 
 // littlefs traversal type
-typedef struct lfs3_traversal {
+typedef struct lfs3_trv {
     // mdir/bshrub/btree state, this also includes our traversal
     // state machine
     lfs3_bshrub_t b;
     // opened file state
-    lfs3_handle_t *ht;
+    lfs3_handle_t *htrv;
     union {
         // cycle detection state, only valid when traversing the mroot chain
         struct {
@@ -779,16 +779,16 @@ typedef struct lfs3_traversal {
             uint8_t power;
         } mtortoise;
         // btree traversal state
-        lfs3_btraversal_t bt;
+        lfs3_btrv_t btrv;
         // graft traversal state
-        lfs3_size_t gt;
+        lfs3_size_t gtrv;
     } u;
 
     // recalculate gcksum when traversing with ckmeta
     uint32_t gcksum;
-    // pending blocks, only used in lfs3_traversal_read
+    // pending blocks, only used in lfs3_trv_read
     lfs3_sblock_t blocks[2];
-} lfs3_traversal_t;
+} lfs3_trv_t;
 
 // grm encoding:
 // .- -+- -+- -+- -+- -.  mids:  2 leb128s  <=2x5 bytes
@@ -886,7 +886,7 @@ typedef struct lfs3 {
     // optional incremental gc state
     #ifdef LFS3_GC
     struct {
-        lfs3_traversal_t t;
+        lfs3_trv_t trv;
     } gc;
     #endif
 } lfs3_t;
@@ -1241,13 +1241,13 @@ int lfs3_dir_rewind(lfs3_t *lfs3, lfs3_dir_t *dir);
 // the filesystem.
 //
 // Returns a negative error code on failure.
-int lfs3_traversal_open(lfs3_t *lfs3, lfs3_traversal_t *t, uint32_t flags);
+int lfs3_trv_open(lfs3_t *lfs3, lfs3_trv_t *trv, uint32_t flags);
 
 // Close a traversal
 //
 // Releases any allocated resources.
 // Returns a negative error code on failure.
-int lfs3_traversal_close(lfs3_t *lfs3, lfs3_traversal_t *t);
+int lfs3_trv_close(lfs3_t *lfs3, lfs3_trv_t *trv);
 
 // Progress the traversal and read an entry
 //
@@ -1255,13 +1255,13 @@ int lfs3_traversal_close(lfs3_t *lfs3, lfs3_traversal_t *t);
 //
 // Returns 0 on success, LFS3_ERR_NOENT at the end of traversal, or a
 // negative error code on failure.
-int lfs3_traversal_read(lfs3_t *lfs3, lfs3_traversal_t *t,
+int lfs3_trv_read(lfs3_t *lfs3, lfs3_trv_t *trv,
         struct lfs3_tinfo *tinfo);
 
 // Reset the traversal
 //
 // Returns a negative error code on failure.
-int lfs3_traversal_rewind(lfs3_t *lfs3, lfs3_traversal_t *t);
+int lfs3_trv_rewind(lfs3_t *lfs3, lfs3_trv_t *trv);
 
 
 /// Filesystem-level filesystem operations
diff --git a/tests/test_alloc.toml b/tests/test_alloc.toml
index ced52afe..c88ea52a 100644
--- a/tests/test_alloc.toml
+++ b/tests/test_alloc.toml
@@ -180,8 +180,8 @@ code = '''
     uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
     memset(seen, 0, (BLOCK_COUNT+7)/8);
 
-    lfs3_traversal_t t;
-    lfs3_traversal_init(&t,
+    lfs3_trv_t trv;
+    lfs3_trv_init(&trv,
             LFS3_T_RDONLY
                 | ((CKMETA) ? LFS3_T_CKMETA : 0));
     for (lfs3_block_t i = 0;; i++) {
@@ -190,7 +190,7 @@ code = '''
 
         lfs3_stag_t tag;
         lfs3_bptr_t bptr;
-        tag = lfs3_mtree_traverse(&lfs3, &t,
+        tag = lfs3_mtree_traverse(&lfs3, &trv,
                 &bptr);
         assert(tag >= 0 || tag == LFS3_ERR_NOENT);
         if (tag == LFS3_ERR_NOENT) {
@@ -351,8 +351,8 @@ code = '''
     uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
     memset(seen, 0, (BLOCK_COUNT+7)/8);
 
-    lfs3_traversal_t t;
-    lfs3_traversal_init(&t,
+    lfs3_trv_t trv;
+    lfs3_trv_init(&trv,
             LFS3_T_RDONLY
                 | ((CKMETA) ? LFS3_T_CKMETA : 0));
     for (lfs3_block_t i = 0;; i++) {
@@ -361,7 +361,7 @@ code = '''
 
         lfs3_stag_t tag;
         lfs3_bptr_t bptr;
-        tag = lfs3_mtree_traverse(&lfs3, &t,
+        tag = lfs3_mtree_traverse(&lfs3, &trv,
                 &bptr);
         assert(tag >= 0 || tag == LFS3_ERR_NOENT);
         if (tag == LFS3_ERR_NOENT) {
@@ -508,8 +508,8 @@ code = '''
     uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
     memset(seen, 0, (BLOCK_COUNT+7)/8);
 
-    lfs3_traversal_t t;
-    lfs3_traversal_init(&t,
+    lfs3_trv_t trv;
+    lfs3_trv_init(&trv,
             LFS3_T_RDONLY
                 | ((CKMETA) ? LFS3_T_CKMETA : 0));
     for (lfs3_block_t i = 0;; i++) {
@@ -518,7 +518,7 @@ code = '''
 
         lfs3_stag_t tag;
         lfs3_bptr_t bptr;
-        tag = lfs3_mtree_traverse(&lfs3, &t,
+        tag = lfs3_mtree_traverse(&lfs3, &trv,
                 &bptr);
         assert(tag >= 0 || tag == LFS3_ERR_NOENT);
         if (tag == LFS3_ERR_NOENT) {
diff --git a/tests/test_badblocks.toml b/tests/test_badblocks.toml
index dcaf4fed..ae220b78 100644
--- a/tests/test_badblocks.toml
+++ b/tests/test_badblocks.toml
@@ -4,7 +4,7 @@ after = [
     'test_files',
     'test_fwrite',
     'test_stickynotes',
-    'test_traversal',
+    'test_trvs',
     'test_gc',
     'test_mount',
     'test_ck',
diff --git a/tests/test_btree.toml b/tests/test_btree.toml
index 9e77b7b3..92c381d1 100644
--- a/tests/test_btree.toml
+++ b/tests/test_btree.toml
@@ -4305,8 +4305,8 @@ code = '''
     uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
     memset(seen, 0, (BLOCK_COUNT+7)/8);
 
-    lfs3_btraversal_t bt;
-    lfs3_btraversal_init(&bt);
+    lfs3_btrv_t btrv;
+    lfs3_btrv_init(&btrv);
     for (lfs3_block_t i = 0;; i++) {
         // a bit hacky, but this catches infinite loops
         assert(i <= 2*N);
@@ -4315,7 +4315,7 @@ code = '''
         lfs3_stag_t tag;
         lfs3_bid_t weight;
         lfs3_data_t data;
-        tag = lfs3_btree_traverse(&lfs3, &btree, &bt,
+        tag = lfs3_btree_traverse(&lfs3, &btree, &btrv,
                 &bid, &weight, &data);
         assert(tag >= 0 || tag == LFS3_ERR_NOENT);
         if (tag == LFS3_ERR_NOENT) {
@@ -4463,8 +4463,8 @@ code = '''
     uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
     memset(seen, 0, (BLOCK_COUNT+7)/8);
 
-    lfs3_btraversal_t bt;
-    lfs3_btraversal_init(&bt);
+    lfs3_btrv_t btrv;
+    lfs3_btrv_init(&btrv);
     for (lfs3_block_t i = 0;; i++) {
         // a bit hacky, but this catches infinite loops
         assert(i <= 2*N);
@@ -4473,7 +4473,7 @@ code = '''
         lfs3_stag_t tag;
         lfs3_bid_t weight;
         lfs3_data_t data;
-        tag = lfs3_btree_traverse(&lfs3, &btree, &bt,
+        tag = lfs3_btree_traverse(&lfs3, &btree, &btrv,
                 &bid, &weight, &data);
         assert(tag >= 0 || tag == LFS3_ERR_NOENT);
         if (tag == LFS3_ERR_NOENT) {
diff --git a/tests/test_ck.toml b/tests/test_ck.toml
index 7fdc2bf5..699086a9 100644
--- a/tests/test_ck.toml
+++ b/tests/test_ck.toml
@@ -1,5 +1,5 @@
 # Test checksum validation things
-after = ['test_traversal', 'test_gc', 'test_mount']
+after = ['test_trvs', 'test_gc', 'test_mount']
 
 
 code = '''
@@ -182,7 +182,7 @@ code = '''
 [cases.test_ck_ckmeta_easy]
 # METHOD=0 => lfs3_fs_ckmeta
 # METHOD=1 => lfs3_fs_gc
-# METHOD=2 => lfs3_traversal_read
+# METHOD=2 => lfs3_trv_read
 # METHOD=3 => lfs3_mount
 defines.METHOD = [0, 1, 2, 3]
 defines.GC_FLAGS = 'LFS3_GC_CKMETA'
@@ -230,17 +230,17 @@ code = '''
         }
 
         // traverse to find blocks
-        lfs3_traversal_t t;
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+        lfs3_trv_t trv;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
         lfs3_block_t k = 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
                 lfs3_unmount(&lfs3) => 0;
                 goto done;
             }
@@ -259,7 +259,7 @@ code = '''
                             clobber_buf, BLOCK_SIZE) => 0;
                     if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) {
                         i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1;
-                        lfs3_traversal_close(&lfs3, &t) => 0;
+                        lfs3_trv_close(&lfs3, &trv) => 0;
                         goto clobbered;
                     }
                 }
@@ -280,22 +280,22 @@ code = '''
             LFS3_UNREACHABLE();
             #endif
 
-        // find clobbered blocks with lfs3_traversal_read
+        // find clobbered blocks with lfs3_trv_read
         } else if (METHOD == 2) {
-            lfs3_traversal_t t;
-            lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0;
+            lfs3_trv_t trv;
+            lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0;
             for (lfs3_block_t i = 0;; i++) {
                 // a bit hacky, but this catches infinite loops
                 LFS3_ASSERT(i < 2*BLOCK_COUNT);
 
                 struct lfs3_tinfo tinfo;
-                int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+                int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
                 assert(!err || err == LFS3_ERR_CORRUPT);
                 if (err == LFS3_ERR_CORRUPT) {
                     break;
                 }
             }
-            lfs3_traversal_close(&lfs3, &t) => 0;
+            lfs3_trv_close(&lfs3, &trv) => 0;
 
         // find clobbered blocks with lfs3_mount
         } else if (METHOD == 3) {
@@ -319,7 +319,7 @@ done:;
 [cases.test_ck_ckdata_easy]
 # METHOD=0 => lfs3_fs_ckdata
 # METHOD=1 => lfs3_fs_gc
-# METHOD=2 => lfs3_traversal_read
+# METHOD=2 => lfs3_trv_read
 # METHOD=3 => lfs3_mount
 defines.METHOD = [0, 1, 2, 3]
 defines.GC_FLAGS = 'LFS3_GC_CKDATA'
@@ -367,17 +367,17 @@ code = '''
         }
 
         // traverse to find blocks
-        lfs3_traversal_t t;
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+        lfs3_trv_t trv;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
         lfs3_block_t k = 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
                 lfs3_unmount(&lfs3) => 0;
                 goto done;
             }
@@ -397,7 +397,7 @@ code = '''
                             clobber_buf, BLOCK_SIZE) => 0;
                     if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) {
                         i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1;
-                        lfs3_traversal_close(&lfs3, &t) => 0;
+                        lfs3_trv_close(&lfs3, &trv) => 0;
                         goto clobbered;
                     }
                 }
@@ -418,22 +418,22 @@ code = '''
             LFS3_UNREACHABLE();
             #endif
 
-        // find clobbered blocks with lfs3_traversal_read
+        // find clobbered blocks with lfs3_trv_read
         } else if (METHOD == 2) {
-            lfs3_traversal_t t;
-            lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKDATA) => 0;
+            lfs3_trv_t trv;
+            lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_CKDATA) => 0;
             for (lfs3_block_t i = 0;; i++) {
                 // a bit hacky, but this catches infinite loops
                 LFS3_ASSERT(i < 2*BLOCK_COUNT);
 
                 struct lfs3_tinfo tinfo;
-                int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+                int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
                 assert(!err || err == LFS3_ERR_CORRUPT);
                 if (err == LFS3_ERR_CORRUPT) {
                     break;
                 }
             }
-            lfs3_traversal_close(&lfs3, &t) => 0;
+            lfs3_trv_close(&lfs3, &trv) => 0;
 
         // find clobbered blocks with lfs3_mount
         } else if (METHOD == 3) {
@@ -458,7 +458,7 @@ done:;
 [cases.test_ck_ckmeta_hard]
 # METHOD=0 => lfs3_fs_ckmeta
 # METHOD=1 => lfs3_fs_gc
-# METHOD=2 => lfs3_traversal_read
+# METHOD=2 => lfs3_trv_read
 # METHOD=3 => lfs3_mount
 defines.METHOD = [0, 1, 2, 3]
 defines.GC_FLAGS = 'LFS3_GC_CKMETA'
@@ -509,18 +509,18 @@ code = '''
         }
 
         // traverse to find blocks
-        lfs3_traversal_t t;
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+        lfs3_trv_t trv;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
         lfs3_block_t k = 0;
         lfs3_block_t badblock;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
                 lfs3_unmount(&lfs3) => 0;
                 goto done;
             }
@@ -530,7 +530,7 @@ code = '''
                 // found an interesting block?
                 if (k == i) {
                     badblock = tinfo.block;
-                    lfs3_traversal_close(&lfs3, &t) => 0;
+                    lfs3_trv_close(&lfs3, &trv) => 0;
                     goto clobber;
                 }
                 k += 1;
@@ -570,17 +570,17 @@ code = '''
                 LFS3_UNREACHABLE();
                 #endif
 
-            // find clobbered blocks with lfs3_traversal_read
+            // find clobbered blocks with lfs3_trv_read
             } else if (METHOD == 2) {
-                lfs3_traversal_t t;
-                lfs3_traversal_open(&lfs3, &t,
+                lfs3_trv_t trv;
+                lfs3_trv_open(&lfs3, &trv,
                         LFS3_T_RDONLY | LFS3_T_CKMETA) => 0;
                 for (lfs3_block_t i = 0;; i++) {
                     // a bit hacky, but this catches infinite loops
                     LFS3_ASSERT(i < 2*BLOCK_COUNT);
 
                     struct lfs3_tinfo tinfo;
-                    int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+                    int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
                     assert(!err
                             || err == LFS3_ERR_NOENT
                             || err == LFS3_ERR_CORRUPT);
@@ -588,11 +588,11 @@ code = '''
                         break;
                     }
                     if (err == LFS3_ERR_CORRUPT) {
-                        lfs3_traversal_close(&lfs3, &t) => 0;
+                        lfs3_trv_close(&lfs3, &trv) => 0;
                         goto detected;
                     }
                 }
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
 
             // find clobbered blocks with lfs3_mount
             } else if (METHOD == 3) {
@@ -713,7 +713,7 @@ done:;
 [cases.test_ck_ckdata_hard]
 # METHOD=0 => lfs3_fs_ckdata
 # METHOD=1 => lfs3_fs_gc
-# METHOD=2 => lfs3_traversal_read
+# METHOD=2 => lfs3_trv_read
 # METHOD=3 => lfs3_mount
 defines.METHOD = [0, 1, 2, 3]
 defines.GC_FLAGS = 'LFS3_GC_CKDATA'
@@ -764,18 +764,18 @@ code = '''
         }
 
         // traverse to find blocks
-        lfs3_traversal_t t;
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+        lfs3_trv_t trv;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
         lfs3_block_t k = 0;
         lfs3_block_t badblock;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
                 lfs3_unmount(&lfs3) => 0;
                 goto done;
             }
@@ -786,7 +786,7 @@ code = '''
                 // found an interesting block?
                 if (k == i) {
                     badblock = tinfo.block;
-                    lfs3_traversal_close(&lfs3, &t) => 0;
+                    lfs3_trv_close(&lfs3, &trv) => 0;
                     goto clobber;
                 }
                 k += 1;
@@ -826,17 +826,17 @@ code = '''
                 LFS3_UNREACHABLE();
                 #endif
 
-            // find clobbered blocks with lfs3_traversal_read
+            // find clobbered blocks with lfs3_trv_read
             } else if (METHOD == 2) {
-                lfs3_traversal_t t;
-                lfs3_traversal_open(&lfs3, &t,
+                lfs3_trv_t trv;
+                lfs3_trv_open(&lfs3, &trv,
                         LFS3_T_RDONLY | LFS3_T_CKDATA) => 0;
                 for (lfs3_block_t i = 0;; i++) {
                     // a bit hacky, but this catches infinite loops
                     LFS3_ASSERT(i < 2*BLOCK_COUNT);
 
                     struct lfs3_tinfo tinfo;
-                    int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+                    int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
                     assert(!err
                             || err == LFS3_ERR_NOENT
                             || err == LFS3_ERR_CORRUPT);
@@ -844,11 +844,11 @@ code = '''
                         break;
                     }
                     if (err == LFS3_ERR_CORRUPT) {
-                        lfs3_traversal_close(&lfs3, &t) => 0;
+                        lfs3_trv_close(&lfs3, &trv) => 0;
                         goto detected;
                     }
                 }
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
 
             // find clobbered blocks with lfs3_mount
             } else if (METHOD == 3) {
@@ -1007,17 +1007,17 @@ code = '''
         lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE;
 
         // traverse to find blocks
-        lfs3_traversal_t t;
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+        lfs3_trv_t trv;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
         lfs3_block_t k = 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
                 lfs3_file_close(&lfs3, &file) => 0;
                 lfs3_unmount(&lfs3) => 0;
                 goto done;
@@ -1032,7 +1032,7 @@ code = '''
                     CFG->erase(CFG, tinfo.block) => 0;
                     CFG->prog(CFG, tinfo.block, 0,
                             clobber_buf, BLOCK_SIZE) => 0;
-                    lfs3_traversal_close(&lfs3, &t) => 0;
+                    lfs3_trv_close(&lfs3, &trv) => 0;
                     goto clobbered;
                 }
                 k += 1;
@@ -1104,17 +1104,17 @@ code = '''
         lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE;
 
         // traverse to find blocks
-        lfs3_traversal_t t;
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+        lfs3_trv_t trv;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
         lfs3_block_t k = 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
                 lfs3_file_close(&lfs3, &file) => 0;
                 lfs3_unmount(&lfs3) => 0;
                 goto done;
@@ -1130,7 +1130,7 @@ code = '''
                     CFG->erase(CFG, tinfo.block) => 0;
                     CFG->prog(CFG, tinfo.block, 0,
                             clobber_buf, BLOCK_SIZE) => 0;
-                    lfs3_traversal_close(&lfs3, &t) => 0;
+                    lfs3_trv_close(&lfs3, &trv) => 0;
                     goto clobbered;
                 }
                 k += 1;
@@ -1208,18 +1208,18 @@ code = '''
         lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE;
 
         // traverse to find blocks
-        lfs3_traversal_t t;
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+        lfs3_trv_t trv;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
         lfs3_block_t k = 0;
         lfs3_block_t badblock;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
                 lfs3_file_close(&lfs3, &file) => 0;
                 lfs3_unmount(&lfs3) => 0;
                 goto done;
@@ -1229,7 +1229,7 @@ code = '''
                 // found an interesting block?
                 if (k == i) {
                     badblock = tinfo.block;
-                    lfs3_traversal_close(&lfs3, &t) => 0;
+                    lfs3_trv_close(&lfs3, &trv) => 0;
                     goto clobber;
                 }
                 k += 1;
@@ -1356,18 +1356,18 @@ code = '''
         lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE;
 
         // traverse to find blocks
-        lfs3_traversal_t t;
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+        lfs3_trv_t trv;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
         lfs3_block_t k = 0;
         lfs3_block_t badblock;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
                 lfs3_file_close(&lfs3, &file) => 0;
                 lfs3_unmount(&lfs3) => 0;
                 goto done;
@@ -1378,7 +1378,7 @@ code = '''
                 // found an interesting block?
                 if (k == i) {
                     badblock = tinfo.block;
-                    lfs3_traversal_close(&lfs3, &t) => 0;
+                    lfs3_trv_close(&lfs3, &trv) => 0;
                     goto clobber;
                 }
                 k += 1;
@@ -1578,18 +1578,18 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // find the data block
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
     lfs3_block_t badblock;
     while (true) {
         struct lfs3_tinfo tinfo;
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         if (tinfo.btype == LFS3_BTYPE_DATA) {
             badblock = tinfo.block;
             break;
         }
     }
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     lfs3_unmount(&lfs3) => 0;
 
@@ -1689,18 +1689,18 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // find the btree block
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
     lfs3_block_t badblock;
     while (true) {
         struct lfs3_tinfo tinfo;
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         if (tinfo.btype == LFS3_BTYPE_BTREE) {
             badblock = tinfo.block;
             break;
         }
     }
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     lfs3_unmount(&lfs3) => 0;
 
@@ -2088,18 +2088,18 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // find the data block
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
     lfs3_block_t badblock;
     while (true) {
         struct lfs3_tinfo tinfo;
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         if (tinfo.btype == LFS3_BTYPE_DATA) {
             badblock = tinfo.block;
             break;
         }
     }
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     lfs3_unmount(&lfs3) => 0;
 
@@ -2199,18 +2199,18 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // find the btree block
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
     lfs3_block_t badblock;
     while (true) {
         struct lfs3_tinfo tinfo;
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         if (tinfo.btype == LFS3_BTYPE_BTREE) {
             badblock = tinfo.block;
             break;
         }
     }
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     lfs3_unmount(&lfs3) => 0;
 
@@ -2462,18 +2462,18 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // find the btree block
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
     lfs3_block_t badblock;
     while (true) {
         struct lfs3_tinfo tinfo;
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         if (tinfo.btype == LFS3_BTYPE_BTREE) {
             badblock = tinfo.block;
             break;
         }
     }
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     lfs3_unmount(&lfs3) => 0;
 
@@ -2606,18 +2606,18 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // find the data block
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
     lfs3_block_t badblock;
     while (true) {
         struct lfs3_tinfo tinfo;
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         if (tinfo.btype == LFS3_BTYPE_DATA) {
             badblock = tinfo.block;
             break;
         }
     }
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     lfs3_unmount(&lfs3) => 0;
 
@@ -2834,15 +2834,15 @@ code = '''
             // run ckmeta mtreeonly?
             } else if (CKMETA && MTREEONLY) {
                 // need an explicit traversal for this
-                lfs3_traversal_t t;
-                lfs3_traversal_open(&lfs3, &t,
+                lfs3_trv_t trv;
+                lfs3_trv_open(&lfs3, &trv,
                         LFS3_T_RDONLY | LFS3_T_MTREEONLY | LFS3_T_CKMETA) => 0;
                 for (lfs3_block_t i = 0;; i++) {
                     // a bit hacky, but this catches infinite loops
                     LFS3_ASSERT(i < 2*BLOCK_COUNT);
 
                     struct lfs3_tinfo tinfo;
-                    int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+                    int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
                     assert(!err
                             || err == LFS3_ERR_NOENT
                             || err == LFS3_ERR_CORRUPT);
@@ -2850,11 +2850,11 @@ code = '''
                         break;
                     }
                     if (err == LFS3_ERR_CORRUPT) {
-                        lfs3_traversal_close(&lfs3, &t) => 0;
+                        lfs3_trv_close(&lfs3, &trv) => 0;
                         goto corrupt_mounted;
                     }
                 }
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
             }
         }
 
@@ -3152,15 +3152,15 @@ code = '''
             // run ckmeta mtreeonly?
             } else if (CKMETA && MTREEONLY) {
                 // need an explicit traversal for this
-                lfs3_traversal_t t;
-                lfs3_traversal_open(&lfs3, &t,
+                lfs3_trv_t trv;
+                lfs3_trv_open(&lfs3, &trv,
                         LFS3_T_RDONLY | LFS3_T_MTREEONLY | LFS3_T_CKMETA) => 0;
                 for (lfs3_block_t i = 0;; i++) {
                     // a bit hacky, but this catches infinite loops
                     LFS3_ASSERT(i < 2*BLOCK_COUNT);
 
                     struct lfs3_tinfo tinfo;
-                    int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+                    int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
                     assert(!err
                             || err == LFS3_ERR_NOENT
                             || err == LFS3_ERR_CORRUPT);
@@ -3168,11 +3168,11 @@ code = '''
                         break;
                     }
                     if (err == LFS3_ERR_CORRUPT) {
-                        lfs3_traversal_close(&lfs3, &t) => 0;
+                        lfs3_trv_close(&lfs3, &trv) => 0;
                         goto corrupt_mounted;
                     }
                 }
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
             }
         }
 
@@ -3568,15 +3568,15 @@ code = '''
             // run ckmeta mtreeonly?
             } else if (CKMETA && MTREEONLY) {
                 // need an explicit traversal for this
-                lfs3_traversal_t t;
-                lfs3_traversal_open(&lfs3, &t,
+                lfs3_trv_t trv;
+                lfs3_trv_open(&lfs3, &trv,
                         LFS3_T_RDONLY | LFS3_T_MTREEONLY | LFS3_T_CKMETA) => 0;
                 for (lfs3_block_t i = 0;; i++) {
                     // a bit hacky, but this catches infinite loops
                     LFS3_ASSERT(i < 2*BLOCK_COUNT);
 
                     struct lfs3_tinfo tinfo;
-                    int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+                    int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
                     assert(!err
                             || err == LFS3_ERR_NOENT
                             || err == LFS3_ERR_CORRUPT);
@@ -3584,11 +3584,11 @@ code = '''
                         break;
                     }
                     if (err == LFS3_ERR_CORRUPT) {
-                        lfs3_traversal_close(&lfs3, &t) => 0;
+                        lfs3_trv_close(&lfs3, &trv) => 0;
                         goto corrupt_open;
                     }
                 }
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
             }
         }
 
@@ -3851,15 +3851,15 @@ code = '''
             // run ckmeta mtreeonly?
             } else if (CKMETA && MTREEONLY) {
                 // need an explicit traversal for this
-                lfs3_traversal_t t;
-                lfs3_traversal_open(&lfs3, &t,
+                lfs3_trv_t trv;
+                lfs3_trv_open(&lfs3, &trv,
                         LFS3_T_RDONLY | LFS3_T_MTREEONLY | LFS3_T_CKMETA) => 0;
                 for (lfs3_block_t i = 0;; i++) {
                     // a bit hacky, but this catches infinite loops
                     LFS3_ASSERT(i < 2*BLOCK_COUNT);
 
                     struct lfs3_tinfo tinfo;
-                    int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+                    int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
                     assert(!err
                             || err == LFS3_ERR_NOENT
                             || err == LFS3_ERR_CORRUPT);
@@ -3867,11 +3867,11 @@ code = '''
                         break;
                     }
                     if (err == LFS3_ERR_CORRUPT) {
-                        lfs3_traversal_close(&lfs3, &t) => 0;
+                        lfs3_trv_close(&lfs3, &trv) => 0;
                         goto corrupt_mounted;
                     }
                 }
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
             }
         }
 
@@ -4451,15 +4451,15 @@ code = '''
             // run ckmeta mtreeonly?
             } else if (CKMETA && MTREEONLY) {
                 // need an explicit traversal for this
-                lfs3_traversal_t t;
-                lfs3_traversal_open(&lfs3, &t,
+                lfs3_trv_t trv;
+                lfs3_trv_open(&lfs3, &trv,
                         LFS3_T_RDONLY | LFS3_T_MTREEONLY | LFS3_T_CKMETA) => 0;
                 for (lfs3_block_t i = 0;; i++) {
                     // a bit hacky, but this catches infinite loops
                     LFS3_ASSERT(i < 2*BLOCK_COUNT);
 
                     struct lfs3_tinfo tinfo;
-                    int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+                    int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
                     assert(!err
                             || err == LFS3_ERR_NOENT
                             || err == LFS3_ERR_CORRUPT);
@@ -4467,11 +4467,11 @@ code = '''
                         break;
                     }
                     if (err == LFS3_ERR_CORRUPT) {
-                        lfs3_traversal_close(&lfs3, &t) => 0;
+                        lfs3_trv_close(&lfs3, &trv) => 0;
                         goto corrupt_mounted;
                     }
                 }
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
             }
         }
 
diff --git a/tests/test_fwrite.toml b/tests/test_fwrite.toml
index b8c39631..c437aa41 100644
--- a/tests/test_fwrite.toml
+++ b/tests/test_fwrite.toml
@@ -183,8 +183,8 @@ code = '''
         lfs3_size_t fragments = 0;
 
         lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0;
-        lfs3_btraversal_t bt;
-        lfs3_btraversal_init(&bt);
+        lfs3_btrv_t btrv;
+        lfs3_btrv_init(&btrv);
         for (lfs3_block_t i = 0;; i++) {
             // a bit hacky, but this catches infinite loops
             assert(i < 2*BLOCK_COUNT);
@@ -193,7 +193,7 @@ code = '''
             lfs3_stag_t tag;
             lfs3_bid_t weight;
             lfs3_data_t data;
-            tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt,
+            tag = lfs3_bshrub_traverse(&lfs3, &file.b, &btrv,
                     &bid, &weight, &data);
             assert(tag >= 0 || tag == LFS3_ERR_NOENT);
             if (tag == LFS3_ERR_NOENT) {
@@ -331,8 +331,8 @@ code = '''
         lfs3_block_t blocks = 0;
 
         lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0;
-        lfs3_btraversal_t bt;
-        lfs3_btraversal_init(&bt);
+        lfs3_btrv_t btrv;
+        lfs3_btrv_init(&btrv);
         for (lfs3_block_t i = 0;; i++) {
             // a bit hacky, but this catches infinite loops
             assert(i < 2*BLOCK_COUNT);
@@ -341,7 +341,7 @@ code = '''
             lfs3_stag_t tag;
             lfs3_bid_t weight;
             lfs3_data_t data;
-            tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt,
+            tag = lfs3_bshrub_traverse(&lfs3, &file.b, &btrv,
                     &bid, &weight, &data);
             assert(tag >= 0 || tag == LFS3_ERR_NOENT);
             if (tag == LFS3_ERR_NOENT) {
@@ -597,8 +597,8 @@ code = '''
         lfs3_size_t fragments = 0;
 
         lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0;
-        lfs3_btraversal_t bt;
-        lfs3_btraversal_init(&bt);
+        lfs3_btrv_t btrv;
+        lfs3_btrv_init(&btrv);
         for (lfs3_block_t i = 0;; i++) {
             // a bit hacky, but this catches infinite loops
             assert(i < 2*BLOCK_COUNT);
@@ -607,7 +607,7 @@ code = '''
             lfs3_stag_t tag;
             lfs3_bid_t weight;
             lfs3_data_t data;
-            tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt,
+            tag = lfs3_bshrub_traverse(&lfs3, &file.b, &btrv,
                     &bid, &weight, &data);
             assert(tag >= 0 || tag == LFS3_ERR_NOENT);
             if (tag == LFS3_ERR_NOENT) {
@@ -760,8 +760,8 @@ code = '''
         lfs3_block_t blocks = 0;
 
         lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0;
-        lfs3_btraversal_t bt;
-        lfs3_btraversal_init(&bt);
+        lfs3_btrv_t btrv;
+        lfs3_btrv_init(&btrv);
         for (lfs3_block_t i = 0;; i++) {
             // a bit hacky, but this catches infinite loops
             assert(i < 2*BLOCK_COUNT);
@@ -770,7 +770,7 @@ code = '''
             lfs3_stag_t tag;
             lfs3_bid_t weight;
             lfs3_data_t data;
-            tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt,
+            tag = lfs3_bshrub_traverse(&lfs3, &file.b, &btrv,
                     &bid, &weight, &data);
             assert(tag >= 0 || tag == LFS3_ERR_NOENT);
             if (tag == LFS3_ERR_NOENT) {
@@ -2088,8 +2088,8 @@ code = '''
         lfs3_size_t fragments = 0;
 
         lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0;
-        lfs3_btraversal_t bt;
-        lfs3_btraversal_init(&bt);
+        lfs3_btrv_t btrv;
+        lfs3_btrv_init(&btrv);
         for (lfs3_block_t i = 0;; i++) {
             // a bit hacky, but this catches infinite loops
             assert(i < 2*BLOCK_COUNT);
@@ -2098,7 +2098,7 @@ code = '''
             lfs3_stag_t tag;
             lfs3_bid_t weight;
             lfs3_data_t data;
-            tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt,
+            tag = lfs3_bshrub_traverse(&lfs3, &file.b, &btrv,
                     &bid, &weight, &data);
             assert(tag >= 0 || tag == LFS3_ERR_NOENT);
             if (tag == LFS3_ERR_NOENT) {
@@ -2240,8 +2240,8 @@ code = '''
         lfs3_size_t fragments = 0;
 
         lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0;
-        lfs3_btraversal_t bt;
-        lfs3_btraversal_init(&bt);
+        lfs3_btrv_t btrv;
+        lfs3_btrv_init(&btrv);
         for (lfs3_block_t i = 0;; i++) {
             // a bit hacky, but this catches infinite loops
             assert(i < 2*BLOCK_COUNT);
@@ -2250,7 +2250,7 @@ code = '''
             lfs3_stag_t tag;
             lfs3_bid_t weight;
             lfs3_data_t data;
-            tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt,
+            tag = lfs3_bshrub_traverse(&lfs3, &file.b, &btrv,
                     &bid, &weight, &data);
             assert(tag >= 0 || tag == LFS3_ERR_NOENT);
             if (tag == LFS3_ERR_NOENT) {
@@ -2539,8 +2539,8 @@ code = '''
         lfs3_size_t fragments = 0;
 
         lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0;
-        lfs3_btraversal_t bt;
-        lfs3_btraversal_init(&bt);
+        lfs3_btrv_t btrv;
+        lfs3_btrv_init(&btrv);
         for (lfs3_block_t i = 0;; i++) {
             // a bit hacky, but this catches infinite loops
             assert(i < 2*BLOCK_COUNT);
@@ -2549,7 +2549,7 @@ code = '''
             lfs3_stag_t tag;
             lfs3_bid_t weight;
             lfs3_data_t data;
-            tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt,
+            tag = lfs3_bshrub_traverse(&lfs3, &file.b, &btrv,
                     &bid, &weight, &data);
             assert(tag >= 0 || tag == LFS3_ERR_NOENT);
             if (tag == LFS3_ERR_NOENT) {
@@ -2706,8 +2706,8 @@ code = '''
         lfs3_block_t blocks = 0;
 
         lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0;
-        lfs3_btraversal_t bt;
-        lfs3_btraversal_init(&bt);
+        lfs3_btrv_t btrv;
+        lfs3_btrv_init(&btrv);
         for (lfs3_block_t i = 0;; i++) {
             // a bit hacky, but this catches infinite loops
             assert(i < 2*BLOCK_COUNT);
@@ -2716,7 +2716,7 @@ code = '''
             lfs3_stag_t tag;
             lfs3_bid_t weight;
             lfs3_data_t data;
-            tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt,
+            tag = lfs3_bshrub_traverse(&lfs3, &file.b, &btrv,
                     &bid, &weight, &data);
             assert(tag >= 0 || tag == LFS3_ERR_NOENT);
             if (tag == LFS3_ERR_NOENT) {
@@ -2999,8 +2999,8 @@ code = '''
         lfs3_size_t fragments = 0;
 
         lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0;
-        lfs3_btraversal_t bt;
-        lfs3_btraversal_init(&bt);
+        lfs3_btrv_t btrv;
+        lfs3_btrv_init(&btrv);
         for (lfs3_block_t i = 0;; i++) {
             // a bit hacky, but this catches infinite loops
             assert(i < 2*BLOCK_COUNT);
@@ -3009,7 +3009,7 @@ code = '''
             lfs3_stag_t tag;
             lfs3_bid_t weight;
             lfs3_data_t data;
-            tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt,
+            tag = lfs3_bshrub_traverse(&lfs3, &file.b, &btrv,
                     &bid, &weight, &data);
             assert(tag >= 0 || tag == LFS3_ERR_NOENT);
             if (tag == LFS3_ERR_NOENT) {
@@ -3170,8 +3170,8 @@ code = '''
         lfs3_block_t blocks = 0;
 
         lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0;
-        lfs3_btraversal_t bt;
-        lfs3_btraversal_init(&bt);
+        lfs3_btrv_t btrv;
+        lfs3_btrv_init(&btrv);
         for (lfs3_block_t i = 0;; i++) {
             // a bit hacky, but this catches infinite loops
             assert(i < 2*BLOCK_COUNT);
@@ -3180,7 +3180,7 @@ code = '''
             lfs3_stag_t tag;
             lfs3_bid_t weight;
             lfs3_data_t data;
-            tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt,
+            tag = lfs3_bshrub_traverse(&lfs3, &file.b, &btrv,
                     &bid, &weight, &data);
             assert(tag >= 0 || tag == LFS3_ERR_NOENT);
             if (tag == LFS3_ERR_NOENT) {
diff --git a/tests/test_gc.toml b/tests/test_gc.toml
index bb32e44c..d77a2526 100644
--- a/tests/test_gc.toml
+++ b/tests/test_gc.toml
@@ -1,8 +1,8 @@
 # Test GC things
 
-# most of the GC logic is tested in test_traversal, we just test
+# most of the GC logic is tested in test_trvs, we just test
 # GC-API specific things here
-after = ['test_traversal']
+after = ['test_trvs']
 
 # test that lookahead can make progress in isolation
 [cases.test_gc_lookahead_progress]
@@ -45,7 +45,7 @@ code = '''
     struct lfs3_fsinfo fsinfo;
     lfs3_fs_stat(&lfs3, &fsinfo) => 0;
     assert(fsinfo.flags & LFS3_I_LOOKAHEAD);
-    assert(lfs3.handles != &lfs3.gc.t.b.h);
+    assert(lfs3.handles != &lfs3.gc.trv.b.h);
 
     // run GC until we make progress
     for (lfs3_block_t i = 0;; i++) {
@@ -112,11 +112,11 @@ code = '''
     struct lfs3_fsinfo fsinfo;
     lfs3_fs_stat(&lfs3, &fsinfo) => 0;
     assert(fsinfo.flags & LFS3_I_LOOKAHEAD);
-    assert(lfs3.handles != &lfs3.gc.t.b.h);
+    assert(lfs3.handles != &lfs3.gc.trv.b.h);
 
     // run GC one step
     lfs3_fs_gc(&lfs3) => 0;
-    assert(lfs3.handles == &lfs3.gc.t.b.h);
+    assert(lfs3.handles == &lfs3.gc.trv.b.h);
 
     // mutate the filesystem
     lfs3_file_open(&lfs3, &file, "spider",
@@ -128,7 +128,7 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // run GC until our traversal is done
-    while (lfs3.handles == &lfs3.gc.t.b.h) {
+    while (lfs3.handles == &lfs3.gc.trv.b.h) {
         lfs3_fs_gc(&lfs3) => 0;
     }
 
@@ -197,7 +197,7 @@ code = '''
     struct lfs3_fsinfo fsinfo;
     lfs3_fs_stat(&lfs3, &fsinfo) => 0;
     assert(fsinfo.flags & LFS3_I_COMPACT);
-    assert(lfs3.handles != &lfs3.gc.t.b.h);
+    assert(lfs3.handles != &lfs3.gc.trv.b.h);
 
     // run GC until we make progress
     for (lfs3_block_t i = 0;; i++) {
@@ -286,19 +286,19 @@ code = '''
     struct lfs3_fsinfo fsinfo;
     lfs3_fs_stat(&lfs3, &fsinfo) => 0;
     assert(fsinfo.flags & LFS3_I_COMPACT);
-    assert(lfs3.handles != &lfs3.gc.t.b.h);
+    assert(lfs3.handles != &lfs3.gc.trv.b.h);
 
     // run GC one traversal + one step
     while (true) {
         lfs3_fs_gc(&lfs3) => 0;
 
         // internal traversal done?
-        if (lfs3.handles != &lfs3.gc.t.b.h) {
+        if (lfs3.handles != &lfs3.gc.trv.b.h) {
             break;
         }
     }
     lfs3_fs_gc(&lfs3) => 0;
-    assert(lfs3.handles == &lfs3.gc.t.b.h);
+    assert(lfs3.handles == &lfs3.gc.trv.b.h);
 
     // mutate the filesystem
     lfs3_file_rewind(&lfs3, &file) => 0;
@@ -309,7 +309,7 @@ code = '''
     lfs3_file_sync(&lfs3, &file) => 0;
 
     // run GC until our traversal is done (twice for compact)
-    while (lfs3.handles == &lfs3.gc.t.b.h) {
+    while (lfs3.handles == &lfs3.gc.trv.b.h) {
         lfs3_fs_gc(&lfs3) => 0;
     }
 
@@ -410,7 +410,7 @@ code = '''
     struct lfs3_fsinfo fsinfo;
     lfs3_fs_stat(&lfs3, &fsinfo) => 0;
     assert(fsinfo.flags & LFS3_I_MKCONSISTENT);
-    assert(lfs3.handles != &lfs3.gc.t.b.h);
+    assert(lfs3.handles != &lfs3.gc.trv.b.h);
 
     // run GC until we make progress
     for (lfs3_block_t i = 0;; i++) {
@@ -513,7 +513,7 @@ code = '''
     lfs3_fs_stat(&lfs3, &fsinfo) => 0;
     assert(fsinfo.flags & LFS3_I_MKCONSISTENT);
     #ifdef LFS3_GC
-    assert(lfs3.handles != &lfs3.gc.t.b.h);
+    assert(lfs3.handles != &lfs3.gc.trv.b.h);
     #endif
 
     // call lfs3_fs_mkconsistent
@@ -614,9 +614,9 @@ code = '''
     }
 
     // run GC one step
-    assert(lfs3.handles != &lfs3.gc.t.b.h);
+    assert(lfs3.handles != &lfs3.gc.trv.b.h);
     lfs3_fs_gc(&lfs3) => 0;
-    assert(lfs3.handles == &lfs3.gc.t.b.h);
+    assert(lfs3.handles == &lfs3.gc.trv.b.h);
 
     // create the rest of the orphans after GC has started
     for (lfs3_size_t i = 0; i < ORPHANS; i++) {
@@ -638,7 +638,7 @@ code = '''
     assert(fsinfo.flags & LFS3_I_MKCONSISTENT);
 
     // run GC until our traversal is done
-    while (lfs3.handles == &lfs3.gc.t.b.h) {
+    while (lfs3.handles == &lfs3.gc.trv.b.h) {
         lfs3_fs_gc(&lfs3) => 0;
     }
 
@@ -721,17 +721,17 @@ code = '''
         }
 
         // traverse to find blocks
-        lfs3_traversal_t t;
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+        lfs3_trv_t trv;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
         lfs3_block_t k = 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
                 lfs3_unmount(&lfs3) => 0;
                 goto done;
             }
@@ -750,7 +750,7 @@ code = '''
                             clobber_buf, BLOCK_SIZE) => 0;
                     if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) {
                         i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1;
-                        lfs3_traversal_close(&lfs3, &t) => 0;
+                        lfs3_trv_close(&lfs3, &trv) => 0;
                         goto clobbered;
                     }
                 }
@@ -821,17 +821,17 @@ code = '''
         }
 
         // traverse to find blocks
-        lfs3_traversal_t t;
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+        lfs3_trv_t trv;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
         lfs3_block_t k = 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
                 lfs3_unmount(&lfs3) => 0;
                 goto done;
             }
@@ -851,7 +851,7 @@ code = '''
                             clobber_buf, BLOCK_SIZE) => 0;
                     if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) {
                         i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1;
-                        lfs3_traversal_close(&lfs3, &t) => 0;
+                        lfs3_trv_close(&lfs3, &trv) => 0;
                         goto clobbered;
                     }
                 }
@@ -923,17 +923,17 @@ code = '''
         }
 
         // traverse to find blocks
-        lfs3_traversal_t t;
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+        lfs3_trv_t trv;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
         lfs3_block_t k = 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
                 lfs3_unmount(&lfs3) => 0;
                 goto done;
             }
@@ -952,7 +952,7 @@ code = '''
                             clobber_buf, BLOCK_SIZE) => 0;
                     if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) {
                         i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1;
-                        lfs3_traversal_close(&lfs3, &t) => 0;
+                        lfs3_trv_close(&lfs3, &trv) => 0;
                         goto clobbered;
                     }
                 }
@@ -1010,17 +1010,17 @@ code = '''
         }
 
         // traverse to find blocks
-        lfs3_traversal_t t;
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+        lfs3_trv_t trv;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
         lfs3_block_t k = 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
                 lfs3_unmount(&lfs3) => 0;
                 goto done;
             }
@@ -1040,7 +1040,7 @@ code = '''
                             clobber_buf, BLOCK_SIZE) => 0;
                     if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) {
                         i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1;
-                        lfs3_traversal_close(&lfs3, &t) => 0;
+                        lfs3_trv_close(&lfs3, &trv) => 0;
                         goto clobbered;
                     }
                 }
@@ -1062,7 +1062,7 @@ done:;
 [cases.test_gc_ckmeta_unck]
 # AFTER=0 => after running lfs3_fs_gc once
 # AFTER=1 => after running lfs3_fs_gc to completion
-# AFTER=2 => after running lfs3_traversal_t
+# AFTER=2 => after running lfs3_trv_t
 # AFTER=3 => after lfs3_fs_ckmeta
 # AFTER=4 => after remounting with LFS3_M_CKMETA
 defines.AFTER = [0, 1, 2, 3, 4]
@@ -1127,19 +1127,19 @@ code = '''
                 lfs3_fs_gc(&lfs3) => 0;
             }
 
-        // run lfs3_traversal_t
+        // run lfs3_trv_t
         } else if (AFTER == 2) {
-            lfs3_traversal_t t;
-            lfs3_traversal_open(&lfs3, &t, LFS3_T_RDWR | GC_FLAGS) => 0;
+            lfs3_trv_t trv;
+            lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | GC_FLAGS) => 0;
             while (true) {
                 struct lfs3_tinfo tinfo;
-                int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+                int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
                 assert(err == 0 || err == LFS3_ERR_NOENT);
                 if (err == LFS3_ERR_NOENT) {
                     break;
                 }
             }
-            lfs3_traversal_close(&lfs3, &t) => 0;
+            lfs3_trv_close(&lfs3, &trv) => 0;
 
         // run lfs3_fs_ckmeta
         } else if (AFTER == 3) {
@@ -1163,17 +1163,17 @@ code = '''
         }
 
         // traverse to find blocks
-        lfs3_traversal_t t;
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+        lfs3_trv_t trv;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
         lfs3_block_t k = 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
                 lfs3_unmount(&lfs3) => 0;
                 goto done;
             }
@@ -1192,7 +1192,7 @@ code = '''
                             clobber_buf, BLOCK_SIZE) => 0;
                     if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) {
                         i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1;
-                        lfs3_traversal_close(&lfs3, &t) => 0;
+                        lfs3_trv_close(&lfs3, &trv) => 0;
                         goto clobbered;
                     }
                 }
@@ -1225,7 +1225,7 @@ done:;
 [cases.test_gc_ckdata_unck]
 # AFTER=0 => after running lfs3_fs_gc once
 # AFTER=1 => after running lfs3_fs_gc to completion
-# AFTER=2 => after running lfs3_traversal_t
+# AFTER=2 => after running lfs3_trv_t
 # AFTER=3 => after lfs3_fs_ckdata
 # AFTER=4 => after remounting with LFS3_M_CKDATA
 defines.AFTER = [0, 1, 2, 3, 4]
@@ -1290,19 +1290,19 @@ code = '''
                 lfs3_fs_gc(&lfs3) => 0;
             }
 
-        // run lfs3_traversal_t
+        // run lfs3_trv_t
         } else if (AFTER == 2) {
-            lfs3_traversal_t t;
-            lfs3_traversal_open(&lfs3, &t, LFS3_T_RDWR | GC_FLAGS) => 0;
+            lfs3_trv_t trv;
+            lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | GC_FLAGS) => 0;
             while (true) {
                 struct lfs3_tinfo tinfo;
-                int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+                int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
                 assert(err == 0 || err == LFS3_ERR_NOENT);
                 if (err == LFS3_ERR_NOENT) {
                     break;
                 }
             }
-            lfs3_traversal_close(&lfs3, &t) => 0;
+            lfs3_trv_close(&lfs3, &trv) => 0;
 
         // run lfs3_fs_ckdata
         } else if (AFTER == 3) {
@@ -1326,17 +1326,17 @@ code = '''
         }
 
         // traverse to find blocks
-        lfs3_traversal_t t;
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+        lfs3_trv_t trv;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
         lfs3_block_t k = 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
                 lfs3_unmount(&lfs3) => 0;
                 goto done;
             }
@@ -1356,7 +1356,7 @@ code = '''
                             clobber_buf, BLOCK_SIZE) => 0;
                     if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) {
                         i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1;
-                        lfs3_traversal_close(&lfs3, &t) => 0;
+                        lfs3_trv_close(&lfs3, &trv) => 0;
                         goto clobbered;
                     }
                 }
@@ -1392,7 +1392,7 @@ done:;
 # test that gc work clears flags in lfs3_fs_stat
 [cases.test_gc_iflags]
 # AFTER=0 => after running lfs3_fs_gc
-# AFTER=1 => after running lfs3_traversal_t
+# AFTER=1 => after running lfs3_trv_t
 # AFTER=2 => after explicit operations
 # AFTER=3 => after remounting
 defines.AFTER = [0, 1, 2, 3]
@@ -1468,7 +1468,7 @@ code = '''
         assert(false);
         #endif
 
-    // run lfs3_traversal_t
+    // run lfs3_trv_t
     } else if (AFTER == 1) {
         while (true) {
             // it may take multiple traversals to do all pending work
@@ -1482,17 +1482,17 @@ code = '''
                 break;
             }
 
-            lfs3_traversal_t t;
-            lfs3_traversal_open(&lfs3, &t, LFS3_T_RDWR | GC_FLAGS) => 0;
+            lfs3_trv_t trv;
+            lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | GC_FLAGS) => 0;
             while (true) {
                 struct lfs3_tinfo tinfo;
-                int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+                int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
                 assert(err == 0 || err == LFS3_ERR_NOENT);
                 if (err == LFS3_ERR_NOENT) {
                     break;
                 }
             }
-            lfs3_traversal_close(&lfs3, &t) => 0;
+            lfs3_trv_close(&lfs3, &trv) => 0;
         }
 
     // run explicit operations
@@ -1517,34 +1517,34 @@ code = '''
 
             if (LOOKAHEAD) {
                 // we need an explicit traversal for this
-                lfs3_traversal_t t;
-                lfs3_traversal_open(&lfs3, &t,
+                lfs3_trv_t trv;
+                lfs3_trv_open(&lfs3, &trv,
                         LFS3_T_RDWR | LFS3_T_LOOKAHEAD) => 0;
                 while (true) {
                     struct lfs3_tinfo tinfo;
-                    int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+                    int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
                     assert(err == 0 || err == LFS3_ERR_NOENT);
                     if (err == LFS3_ERR_NOENT) {
                         break;
                     }
                 }
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
             }
 
             if (COMPACT) {
                 // we need an explicit traversal for this
-                lfs3_traversal_t t;
-                lfs3_traversal_open(&lfs3, &t,
+                lfs3_trv_t trv;
+                lfs3_trv_open(&lfs3, &trv,
                         LFS3_T_RDWR | LFS3_T_COMPACT) => 0;
                 while (true) {
                     struct lfs3_tinfo tinfo;
-                    int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+                    int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
                     assert(err == 0 || err == LFS3_ERR_NOENT);
                     if (err == LFS3_ERR_NOENT) {
                         break;
                     }
                 }
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
             }
 
             if (CKMETA) {
@@ -1581,7 +1581,7 @@ code = '''
 # test that gc work clears flags in lfs3_fs_stat after lfs3_fs_unck
 [cases.test_gc_iflags_unck]
 # AFTER=0 => after running lfs3_fs_gc
-# AFTER=1 => after running lfs3_traversal_t
+# AFTER=1 => after running lfs3_trv_t
 # AFTER=2 => after explicit operations
 # AFTER=3 => after remounting
 defines.AFTER = [0, 1, 2, 3]
@@ -1657,7 +1657,7 @@ code = '''
         assert(false);
         #endif
 
-    // run lfs3_traversal_t
+    // run lfs3_trv_t
     } else if (AFTER == 1) {
         while (true) {
             // it may take multiple traversals to do all pending work
@@ -1671,17 +1671,17 @@ code = '''
                 break;
             }
 
-            lfs3_traversal_t t;
-            lfs3_traversal_open(&lfs3, &t, LFS3_T_RDWR | GC_FLAGS) => 0;
+            lfs3_trv_t trv;
+            lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | GC_FLAGS) => 0;
             while (true) {
                 struct lfs3_tinfo tinfo;
-                int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+                int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
                 assert(err == 0 || err == LFS3_ERR_NOENT);
                 if (err == LFS3_ERR_NOENT) {
                     break;
                 }
             }
-            lfs3_traversal_close(&lfs3, &t) => 0;
+            lfs3_trv_close(&lfs3, &trv) => 0;
         }
 
     // run explicit operations
@@ -1706,34 +1706,34 @@ code = '''
 
             if (LOOKAHEAD) {
                 // we need an explicit traversal for this
-                lfs3_traversal_t t;
-                lfs3_traversal_open(&lfs3, &t,
+                lfs3_trv_t trv;
+                lfs3_trv_open(&lfs3, &trv,
                         LFS3_T_RDWR | LFS3_T_LOOKAHEAD) => 0;
                 while (true) {
                     struct lfs3_tinfo tinfo;
-                    int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+                    int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
                     assert(err == 0 || err == LFS3_ERR_NOENT);
                     if (err == LFS3_ERR_NOENT) {
                         break;
                     }
                 }
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
             }
 
             if (COMPACT) {
                 // we need an explicit traversal for this
-                lfs3_traversal_t t;
-                lfs3_traversal_open(&lfs3, &t,
+                lfs3_trv_t trv;
+                lfs3_trv_open(&lfs3, &trv,
                         LFS3_T_RDWR | LFS3_T_COMPACT) => 0;
                 while (true) {
                     struct lfs3_tinfo tinfo;
-                    int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+                    int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
                     assert(err == 0 || err == LFS3_ERR_NOENT);
                     if (err == LFS3_ERR_NOENT) {
                         break;
                     }
                 }
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
             }
 
             if (CKMETA) {
@@ -1786,7 +1786,7 @@ code = '''
         assert(false);
         #endif
 
-    // run lfs3_traversal_t
+    // run lfs3_trv_t
     } else if (AFTER == 1) {
         while (true) {
             // it may take multiple traversals to do all pending work
@@ -1800,17 +1800,17 @@ code = '''
                 break;
             }
 
-            lfs3_traversal_t t;
-            lfs3_traversal_open(&lfs3, &t, LFS3_T_RDWR | GC_FLAGS) => 0;
+            lfs3_trv_t trv;
+            lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | GC_FLAGS) => 0;
             while (true) {
                 struct lfs3_tinfo tinfo;
-                int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+                int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
                 assert(err == 0 || err == LFS3_ERR_NOENT);
                 if (err == LFS3_ERR_NOENT) {
                     break;
                 }
             }
-            lfs3_traversal_close(&lfs3, &t) => 0;
+            lfs3_trv_close(&lfs3, &trv) => 0;
         }
 
     // run explicit operations
@@ -1835,34 +1835,34 @@ code = '''
 
             if (LOOKAHEAD) {
                 // we need an explicit traversal for this
-                lfs3_traversal_t t;
-                lfs3_traversal_open(&lfs3, &t,
+                lfs3_trv_t trv;
+                lfs3_trv_open(&lfs3, &trv,
                         LFS3_T_RDWR | LFS3_T_LOOKAHEAD) => 0;
                 while (true) {
                     struct lfs3_tinfo tinfo;
-                    int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+                    int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
                     assert(err == 0 || err == LFS3_ERR_NOENT);
                     if (err == LFS3_ERR_NOENT) {
                         break;
                     }
                 }
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
             }
 
             if (COMPACT) {
                 // we need an explicit traversal for this
-                lfs3_traversal_t t;
-                lfs3_traversal_open(&lfs3, &t,
+                lfs3_trv_t trv;
+                lfs3_trv_open(&lfs3, &trv,
                         LFS3_T_RDWR | LFS3_T_COMPACT) => 0;
                 while (true) {
                     struct lfs3_tinfo tinfo;
-                    int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+                    int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
                     assert(err == 0 || err == LFS3_ERR_NOENT);
                     if (err == LFS3_ERR_NOENT) {
                         break;
                     }
                 }
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
             }
 
             if (CKMETA) {
diff --git a/tests/test_mount.toml b/tests/test_mount.toml
index 9e4324f2..f996a3ab 100644
--- a/tests/test_mount.toml
+++ b/tests/test_mount.toml
@@ -1,5 +1,5 @@
 # Advanced mount tests
-after = ['test_mtree', 'test_traversal']
+after = ['test_mtree', 'test_trvs']
 
 
 # test we can mount
@@ -405,17 +405,17 @@ code = '''
         }
 
         // traverse to find blocks
-        lfs3_traversal_t t;
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+        lfs3_trv_t trv;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
         lfs3_block_t k = 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
                 lfs3_unmount(&lfs3) => 0;
                 goto done;
             }
@@ -434,7 +434,7 @@ code = '''
                             clobber_buf, BLOCK_SIZE) => 0;
                     if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) {
                         i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1;
-                        lfs3_traversal_close(&lfs3, &t) => 0;
+                        lfs3_trv_close(&lfs3, &trv) => 0;
                         lfs3_unmount(&lfs3) => 0;
                         goto clobbered;
                     }
@@ -494,17 +494,17 @@ code = '''
         }
 
         // traverse to find blocks
-        lfs3_traversal_t t;
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+        lfs3_trv_t trv;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
         lfs3_block_t k = 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
                 lfs3_unmount(&lfs3) => 0;
                 goto done;
             }
@@ -524,7 +524,7 @@ code = '''
                             clobber_buf, BLOCK_SIZE) => 0;
                     if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) {
                         i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1;
-                        lfs3_traversal_close(&lfs3, &t) => 0;
+                        lfs3_trv_close(&lfs3, &trv) => 0;
                         lfs3_unmount(&lfs3) => 0;
                         goto clobbered;
                     }
diff --git a/tests/test_mtree.toml b/tests/test_mtree.toml
index 4b892869..c7a34bdf 100644
--- a/tests/test_mtree.toml
+++ b/tests/test_mtree.toml
@@ -3665,8 +3665,8 @@ code = '''
     uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
     memset(seen, 0, (BLOCK_COUNT+7)/8);
 
-    lfs3_traversal_t t;
-    lfs3_traversal_init(&t,
+    lfs3_trv_t trv;
+    lfs3_trv_init(&trv,
             LFS3_T_RDONLY
                 | LFS3_T_MTREEONLY
                 | ((CKMETA) ? LFS3_T_CKMETA : 0));
@@ -3676,7 +3676,7 @@ code = '''
 
         lfs3_stag_t tag;
         lfs3_bptr_t bptr;
-        tag = lfs3_mtree_traverse(&lfs3, &t,
+        tag = lfs3_mtree_traverse(&lfs3, &trv,
                 &bptr);
         assert(tag >= 0 || tag == LFS3_ERR_NOENT);
         if (tag == LFS3_ERR_NOENT) {
@@ -3787,8 +3787,8 @@ code = '''
     uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
     memset(seen, 0, (BLOCK_COUNT+7)/8);
 
-    lfs3_traversal_t t;
-    lfs3_traversal_init(&t,
+    lfs3_trv_t trv;
+    lfs3_trv_init(&trv,
             LFS3_T_RDONLY
                 | LFS3_T_MTREEONLY
                 | ((CKMETA) ? LFS3_T_CKMETA : 0));
@@ -3798,7 +3798,7 @@ code = '''
 
         lfs3_stag_t tag;
         lfs3_bptr_t bptr;
-        tag = lfs3_mtree_traverse(&lfs3, &t,
+        tag = lfs3_mtree_traverse(&lfs3, &trv,
                 &bptr);
         assert(tag >= 0 || tag == LFS3_ERR_NOENT);
         if (tag == LFS3_ERR_NOENT) {
@@ -3935,8 +3935,8 @@ code = '''
     uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
     memset(seen, 0, (BLOCK_COUNT+7)/8);
 
-    lfs3_traversal_t t;
-    lfs3_traversal_init(&t,
+    lfs3_trv_t trv;
+    lfs3_trv_init(&trv,
             LFS3_T_RDONLY
                 | LFS3_T_MTREEONLY
                 | ((CKMETA) ? LFS3_T_CKMETA : 0));
@@ -3946,7 +3946,7 @@ code = '''
 
         lfs3_stag_t tag;
         lfs3_bptr_t bptr;
-        tag = lfs3_mtree_traverse(&lfs3, &t,
+        tag = lfs3_mtree_traverse(&lfs3, &trv,
                 &bptr);
         assert(tag >= 0 || tag == LFS3_ERR_NOENT);
         if (tag == LFS3_ERR_NOENT) {
@@ -4106,8 +4106,8 @@ code = '''
     uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
     memset(seen, 0, (BLOCK_COUNT+7)/8);
 
-    lfs3_traversal_t t;
-    lfs3_traversal_init(&t,
+    lfs3_trv_t trv;
+    lfs3_trv_init(&trv,
             LFS3_T_RDONLY
                 | LFS3_T_MTREEONLY
                 | ((CKMETA) ? LFS3_T_CKMETA : 0));
@@ -4117,7 +4117,7 @@ code = '''
 
         lfs3_stag_t tag;
         lfs3_bptr_t bptr;
-        tag = lfs3_mtree_traverse(&lfs3, &t,
+        tag = lfs3_mtree_traverse(&lfs3, &trv,
                 &bptr);
         assert(tag >= 0 || tag == LFS3_ERR_NOENT);
         if (tag == LFS3_ERR_NOENT) {
@@ -4257,8 +4257,8 @@ code = '''
     uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
     memset(seen, 0, (BLOCK_COUNT+7)/8);
 
-    lfs3_traversal_t t;
-    lfs3_traversal_init(&t,
+    lfs3_trv_t trv;
+    lfs3_trv_init(&trv,
             LFS3_T_RDONLY
                 | LFS3_T_MTREEONLY
                 | ((CKMETA) ? LFS3_T_CKMETA : 0));
@@ -4268,7 +4268,7 @@ code = '''
 
         lfs3_stag_t tag;
         lfs3_bptr_t bptr;
-        tag = lfs3_mtree_traverse(&lfs3, &t,
+        tag = lfs3_mtree_traverse(&lfs3, &trv,
                 &bptr);
         assert(tag >= 0 || tag == LFS3_ERR_NOENT);
         if (tag == LFS3_ERR_NOENT) {
@@ -4383,8 +4383,8 @@ code = '''
     uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
     memset(seen, 0, (BLOCK_COUNT+7)/8);
 
-    lfs3_traversal_t t;
-    lfs3_traversal_init(&t,
+    lfs3_trv_t trv;
+    lfs3_trv_init(&trv,
             LFS3_T_RDONLY
                 | LFS3_T_MTREEONLY
                 | ((CKMETA) ? LFS3_T_CKMETA : 0));
@@ -4394,7 +4394,7 @@ code = '''
 
         lfs3_stag_t tag;
         lfs3_bptr_t bptr;
-        tag = lfs3_mtree_traverse(&lfs3, &t,
+        tag = lfs3_mtree_traverse(&lfs3, &trv,
                 &bptr);
         assert(tag >= 0 || tag == LFS3_ERR_NOENT);
         if (tag == LFS3_ERR_NOENT) {
@@ -4553,8 +4553,8 @@ code = '''
     uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
     memset(seen, 0, (BLOCK_COUNT+7)/8);
 
-    lfs3_traversal_t t;
-    lfs3_traversal_init(&t,
+    lfs3_trv_t trv;
+    lfs3_trv_init(&trv,
             LFS3_T_RDONLY
                 | LFS3_T_MTREEONLY
                 | ((CKMETA) ? LFS3_T_CKMETA : 0));
@@ -4564,7 +4564,7 @@ code = '''
 
         lfs3_stag_t tag;
         lfs3_bptr_t bptr;
-        tag = lfs3_mtree_traverse(&lfs3, &t,
+        tag = lfs3_mtree_traverse(&lfs3, &trv,
                 &bptr);
         assert(tag >= 0 || tag == LFS3_ERR_NOENT);
         if (tag == LFS3_ERR_NOENT) {
@@ -4686,8 +4686,8 @@ code = '''
                 LFS3_MPTR_MROOTANCHOR()))) => 0;
 
     // technically, cycle detection only needs to work when we're validating
-    lfs3_traversal_t t;
-    lfs3_traversal_init(&t,
+    lfs3_trv_t trv;
+    lfs3_trv_init(&trv,
             LFS3_T_RDONLY | LFS3_T_MTREEONLY | LFS3_T_CKMETA);
     for (lfs3_block_t i = 0;; i++) {
         // assert that we detect the cycle in a reasonable number of iterations
@@ -4695,7 +4695,7 @@ code = '''
 
         lfs3_stag_t tag;
         lfs3_bptr_t bptr;
-        tag = lfs3_mtree_traverse(&lfs3, &t,
+        tag = lfs3_mtree_traverse(&lfs3, &trv,
                 &bptr);
         assert(tag >= 0 || tag == LFS3_ERR_CORRUPT);
         if (tag == LFS3_ERR_CORRUPT) {
diff --git a/tests/test_powerloss.toml b/tests/test_powerloss.toml
index cbe89500..abf15cb0 100644
--- a/tests/test_powerloss.toml
+++ b/tests/test_powerloss.toml
@@ -8,7 +8,7 @@ after = [
     'test_dirs',
     'test_files',
     'test_stickynotes',
-    'test_traversal',
+    'test_trvs',
     'test_gc',
     'test_mount',
     'test_ck',
diff --git a/tests/test_traversal.toml b/tests/test_trvs.toml
similarity index 88%
rename from tests/test_traversal.toml
rename to tests/test_trvs.toml
index 619955c2..01d34d22 100644
--- a/tests/test_traversal.toml
+++ b/tests/test_trvs.toml
@@ -8,7 +8,7 @@ after = [
 ]
 
 # a simple traversal test
-[cases.test_traversal_simple]
+[cases.test_trvs_simple]
 defines.MKCONSISTENT = [false, true]
 defines.LOOKAHEAD = [false, true]
 defines.COMPACT = [false, true]
@@ -20,8 +20,8 @@ code = '''
     lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0)
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
@@ -29,20 +29,20 @@ code = '''
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
                 | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0;
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     lfs3_unmount(&lfs3) => 0;
 '''
 
 # can we rewind?
-[cases.test_traversal_rewind]
+[cases.test_trvs_rewind]
 defines.MKCONSISTENT = [false, true]
 defines.LOOKAHEAD = [false, true]
 defines.COMPACT = [false, true]
@@ -54,8 +54,8 @@ code = '''
     lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0)
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
@@ -63,29 +63,29 @@ code = '''
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
                 | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0;
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
 
-    lfs3_traversal_rewind(&lfs3, &t) => 0;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_rewind(&lfs3, &trv) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     lfs3_unmount(&lfs3) => 0;
 '''
 
 # test that we don't get extra anything after end of traversal
-[cases.test_traversal_idempotent]
+[cases.test_trvs_idempotent]
 defines.MKCONSISTENT = [false, true]
 defines.LOOKAHEAD = [false, true]
 defines.COMPACT = [false, true]
@@ -97,8 +97,8 @@ code = '''
     lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0)
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
@@ -106,22 +106,22 @@ code = '''
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
                 | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0;
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
 
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
 
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     lfs3_unmount(&lfs3) => 0;
 '''
@@ -129,7 +129,7 @@ code = '''
 
 
 # some simple traversal tests with clobbering
-[cases.test_traversal_clobber_dirs]
+[cases.test_trvs_clobber_dirs]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -149,8 +149,8 @@ code = '''
     uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
     memset(seen, 0, (BLOCK_COUNT+7)/8);
 
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDONLY
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
                 | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0;
@@ -159,7 +159,7 @@ code = '''
         assert(i < 2*BLOCK_COUNT);
 
         struct lfs3_tinfo tinfo;
-        int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+        int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
         assert(!err || err == LFS3_ERR_NOENT);
         if (err == LFS3_ERR_NOENT) {
             break;
@@ -173,7 +173,7 @@ code = '''
         // keep track of seen blocks
         seen[tinfo.block / 8] |= 1 << (tinfo.block % 8);
     }
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // clobber every other block
     uint8_t clobber_buf[BLOCK_SIZE];
@@ -230,7 +230,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_clobber_files]
+[cases.test_trvs_clobber_files]
 defines.N = [1, 2, 4, 8, 16, 32, 64]
 defines.SIZE = [
     '0',
@@ -271,8 +271,8 @@ code = '''
     uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
     memset(seen, 0, (BLOCK_COUNT+7)/8);
 
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDONLY
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
                 | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0;
@@ -281,7 +281,7 @@ code = '''
         assert(i < 2*BLOCK_COUNT);
 
         struct lfs3_tinfo tinfo;
-        int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+        int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
         assert(!err || err == LFS3_ERR_NOENT);
         if (err == LFS3_ERR_NOENT) {
             break;
@@ -296,7 +296,7 @@ code = '''
         // keep track of seen blocks
         seen[tinfo.block / 8] |= 1 << (tinfo.block % 8);
     }
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // clobber every other block
     uint8_t clobber_buf[BLOCK_SIZE];
@@ -346,7 +346,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_clobber_files_opened]
+[cases.test_trvs_clobber_files_opened]
 defines.N = [1, 2, 4, 8, 16, 32, 64]
 defines.SIZE = [
     '0',
@@ -386,8 +386,8 @@ code = '''
     uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
     memset(seen, 0, (BLOCK_COUNT+7)/8);
 
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDONLY
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
                 | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0;
@@ -396,7 +396,7 @@ code = '''
         assert(i < 2*BLOCK_COUNT);
 
         struct lfs3_tinfo tinfo;
-        int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+        int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
         assert(!err || err == LFS3_ERR_NOENT);
         if (err == LFS3_ERR_NOENT) {
             break;
@@ -411,7 +411,7 @@ code = '''
         // keep track of seen blocks
         seen[tinfo.block / 8] |= 1 << (tinfo.block % 8);
     }
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // clobber every other block
     uint8_t clobber_buf[BLOCK_SIZE];
@@ -483,7 +483,7 @@ code = '''
 
 
 # a bit more aggressive rewind tests
-[cases.test_traversal_rewind_clobber_dirs]
+[cases.test_trvs_rewind_clobber_dirs]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -503,8 +503,8 @@ code = '''
     uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
     memset(seen, 0, (BLOCK_COUNT+7)/8);
 
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDONLY
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
                 | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0;
@@ -514,7 +514,7 @@ code = '''
         assert(i < 2*BLOCK_COUNT);
 
         if (i == r) {
-            lfs3_traversal_rewind(&lfs3, &t) => 0;
+            lfs3_trv_rewind(&lfs3, &trv) => 0;
             memset(seen, 0, (BLOCK_COUNT+7)/8);
             r += 1;
             i = -1;
@@ -522,7 +522,7 @@ code = '''
         }
 
         struct lfs3_tinfo tinfo;
-        int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+        int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
         assert(!err || err == LFS3_ERR_NOENT);
         if (err == LFS3_ERR_NOENT) {
             break;
@@ -536,7 +536,7 @@ code = '''
         // keep track of seen blocks
         seen[tinfo.block / 8] |= 1 << (tinfo.block % 8);
     }
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // clobber every other block
     uint8_t clobber_buf[BLOCK_SIZE];
@@ -593,7 +593,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_rewind_clobber_files]
+[cases.test_trvs_rewind_clobber_files]
 defines.N = [1, 2, 4, 8, 16, 32, 64]
 defines.SIZE = [
     '0',
@@ -634,8 +634,8 @@ code = '''
     uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
     memset(seen, 0, (BLOCK_COUNT+7)/8);
 
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDONLY
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
                 | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0;
@@ -645,7 +645,7 @@ code = '''
         assert(i < 2*BLOCK_COUNT);
 
         if (i == r) {
-            lfs3_traversal_rewind(&lfs3, &t) => 0;
+            lfs3_trv_rewind(&lfs3, &trv) => 0;
             memset(seen, 0, (BLOCK_COUNT+7)/8);
             r += 1;
             i = -1;
@@ -653,7 +653,7 @@ code = '''
         }
 
         struct lfs3_tinfo tinfo;
-        int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+        int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
         assert(!err || err == LFS3_ERR_NOENT);
         if (err == LFS3_ERR_NOENT) {
             break;
@@ -668,7 +668,7 @@ code = '''
         // keep track of seen blocks
         seen[tinfo.block / 8] |= 1 << (tinfo.block % 8);
     }
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // clobber every other block
     uint8_t clobber_buf[BLOCK_SIZE];
@@ -718,7 +718,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_rewind_clobber_files_opened]
+[cases.test_trvs_rewind_clobber_files_opened]
 defines.N = [1, 2, 4, 8, 16, 32, 64]
 defines.SIZE = [
     '0',
@@ -758,8 +758,8 @@ code = '''
     uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
     memset(seen, 0, (BLOCK_COUNT+7)/8);
 
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDONLY
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
                 | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0;
@@ -769,7 +769,7 @@ code = '''
         assert(i < 2*BLOCK_COUNT);
 
         if (i == r) {
-            lfs3_traversal_rewind(&lfs3, &t) => 0;
+            lfs3_trv_rewind(&lfs3, &trv) => 0;
             memset(seen, 0, (BLOCK_COUNT+7)/8);
             r += 1;
             i = -1;
@@ -777,7 +777,7 @@ code = '''
         }
 
         struct lfs3_tinfo tinfo;
-        int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+        int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
         assert(!err || err == LFS3_ERR_NOENT);
         if (err == LFS3_ERR_NOENT) {
             break;
@@ -792,7 +792,7 @@ code = '''
         // keep track of seen blocks
         seen[tinfo.block / 8] |= 1 << (tinfo.block % 8);
     }
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // clobber every other block
     uint8_t clobber_buf[BLOCK_SIZE];
@@ -864,7 +864,7 @@ code = '''
 
 
 # check that we can detect every clobbered mdir
-[cases.test_traversal_ckmdir_dirs]
+[cases.test_trvs_ckmdir_dirs]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
 code = '''
     for (lfs3_block_t i = 0;; i += 2) {
@@ -883,17 +883,17 @@ code = '''
         }
 
         // traverse to find blocks
-        lfs3_traversal_t t;
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+        lfs3_trv_t trv;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
         lfs3_block_t k = 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
                 lfs3_unmount(&lfs3) => 0;
                 goto done;
             }
@@ -908,7 +908,7 @@ code = '''
                     CFG->prog(CFG, tinfo.block, 0,
                             clobber_buf, BLOCK_SIZE) => 0;
                     if (k == i+1) {
-                        lfs3_traversal_close(&lfs3, &t) => 0;
+                        lfs3_trv_close(&lfs3, &trv) => 0;
                         goto clobbered;
                     }
                 }
@@ -918,26 +918,26 @@ code = '''
 
     clobbered:;
         // traverse again, we should detect the clobbered metadata
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_CORRUPT);
             // found the clobbered metadata?
             if (err == LFS3_ERR_CORRUPT) {
                 break;
             }
         }
-        lfs3_traversal_close(&lfs3, &t) => 0;
+        lfs3_trv_close(&lfs3, &trv) => 0;
 
         lfs3_unmount(&lfs3) => 0;
     }
 done:;
 '''
 
-[cases.test_traversal_ckmdir_files]
+[cases.test_trvs_ckmdir_files]
 defines.N = [1, 2, 4, 8, 16, 32, 64]
 defines.SIZE = [
     '0',
@@ -979,17 +979,17 @@ code = '''
         }
 
         // traverse to find blocks
-        lfs3_traversal_t t;
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+        lfs3_trv_t trv;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
         lfs3_block_t k = 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
                 lfs3_unmount(&lfs3) => 0;
                 goto done;
             }
@@ -1004,7 +1004,7 @@ code = '''
                     CFG->prog(CFG, tinfo.block, 0,
                             clobber_buf, BLOCK_SIZE) => 0;
                     if (k == i+1) {
-                        lfs3_traversal_close(&lfs3, &t) => 0;
+                        lfs3_trv_close(&lfs3, &trv) => 0;
                         goto clobbered;
                     }
                 }
@@ -1014,26 +1014,26 @@ code = '''
 
     clobbered:;
         // traverse again, we should detect the clobbered metadata
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_CORRUPT);
             // found the clobbered metadata?
             if (err == LFS3_ERR_CORRUPT) {
                 break;
             }
         }
-        lfs3_traversal_close(&lfs3, &t) => 0;
+        lfs3_trv_close(&lfs3, &trv) => 0;
 
         lfs3_unmount(&lfs3) => 0;
     }
 done:;
 '''
 
-[cases.test_traversal_ckmdir_files_opened]
+[cases.test_trvs_ckmdir_files_opened]
 defines.N = [1, 2, 4, 8, 16, 32, 64]
 defines.SIZE = [
     '0',
@@ -1074,17 +1074,17 @@ code = '''
         }
 
         // traverse to find blocks
-        lfs3_traversal_t t;
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+        lfs3_trv_t trv;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
         lfs3_block_t k = 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
                 for (lfs3_size_t i = 0; i < N; i++) {
                     lfs3_file_close(&lfs3, &files[i]) => 0;
                 }
@@ -1102,7 +1102,7 @@ code = '''
                     CFG->prog(CFG, tinfo.block, 0,
                             clobber_buf, BLOCK_SIZE) => 0;
                     if (k == i+1) {
-                        lfs3_traversal_close(&lfs3, &t) => 0;
+                        lfs3_trv_close(&lfs3, &trv) => 0;
                         goto clobbered;
                     }
                 }
@@ -1112,19 +1112,19 @@ code = '''
 
     clobbered:;
         // traverse again, we should detect the clobbered metadata
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_CORRUPT);
             // found the clobbered metadata?
             if (err == LFS3_ERR_CORRUPT) {
                 break;
             }
         }
-        lfs3_traversal_close(&lfs3, &t) => 0;
+        lfs3_trv_close(&lfs3, &trv) => 0;
 
         for (lfs3_size_t i = 0; i < N; i++) {
             lfs3_file_desync(&lfs3, &files[i]) => 0;
@@ -1138,7 +1138,7 @@ done:;
 
 
 # check that we can detect every clobbered btree
-[cases.test_traversal_ckbtree_dirs]
+[cases.test_trvs_ckbtree_dirs]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
 code = '''
     for (lfs3_block_t i = 0;; i++) {
@@ -1157,17 +1157,17 @@ code = '''
         }
 
         // traverse to find blocks
-        lfs3_traversal_t t;
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+        lfs3_trv_t trv;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
         lfs3_block_t k = 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
                 lfs3_unmount(&lfs3) => 0;
                 goto done;
             }
@@ -1181,7 +1181,7 @@ code = '''
                     CFG->erase(CFG, tinfo.block) => 0;
                     CFG->prog(CFG, tinfo.block, 0,
                             clobber_buf, BLOCK_SIZE) => 0;
-                    lfs3_traversal_close(&lfs3, &t) => 0;
+                    lfs3_trv_close(&lfs3, &trv) => 0;
                     goto clobbered;
                 }
                 k += 1;
@@ -1190,26 +1190,26 @@ code = '''
 
     clobbered:;
         // traverse again, we should detect the clobbered metadata
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_CORRUPT);
             // found the clobbered metadata?
             if (err == LFS3_ERR_CORRUPT) {
                 break;
             }
         }
-        lfs3_traversal_close(&lfs3, &t) => 0;
+        lfs3_trv_close(&lfs3, &trv) => 0;
 
         lfs3_unmount(&lfs3) => 0;
     }
 done:;
 '''
 
-[cases.test_traversal_ckbtree_files]
+[cases.test_trvs_ckbtree_files]
 defines.N = [1, 2, 4, 8, 16, 32, 64]
 defines.SIZE = [
     '0',
@@ -1251,17 +1251,17 @@ code = '''
         }
 
         // traverse to find blocks
-        lfs3_traversal_t t;
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+        lfs3_trv_t trv;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
         lfs3_block_t k = 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
                 lfs3_unmount(&lfs3) => 0;
                 goto done;
             }
@@ -1275,7 +1275,7 @@ code = '''
                     CFG->erase(CFG, tinfo.block) => 0;
                     CFG->prog(CFG, tinfo.block, 0,
                             clobber_buf, BLOCK_SIZE) => 0;
-                    lfs3_traversal_close(&lfs3, &t) => 0;
+                    lfs3_trv_close(&lfs3, &trv) => 0;
                     goto clobbered;
                 }
                 k += 1;
@@ -1284,26 +1284,26 @@ code = '''
 
     clobbered:;
         // traverse again, we should detect the clobbered metadata
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_CORRUPT);
             // found the clobbered metadata?
             if (err == LFS3_ERR_CORRUPT) {
                 break;
             }
         }
-        lfs3_traversal_close(&lfs3, &t) => 0;
+        lfs3_trv_close(&lfs3, &trv) => 0;
 
         lfs3_unmount(&lfs3) => 0;
     }
 done:;
 '''
 
-[cases.test_traversal_ckbtree_files_opened]
+[cases.test_trvs_ckbtree_files_opened]
 defines.N = [1, 2, 4, 8, 16, 32, 64]
 defines.SIZE = [
     '0',
@@ -1344,17 +1344,17 @@ code = '''
         }
 
         // traverse to find blocks
-        lfs3_traversal_t t;
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+        lfs3_trv_t trv;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
         lfs3_block_t k = 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
                 for (lfs3_size_t i = 0; i < N; i++) {
                     lfs3_file_close(&lfs3, &files[i]) => 0;
                 }
@@ -1371,7 +1371,7 @@ code = '''
                     CFG->erase(CFG, tinfo.block) => 0;
                     CFG->prog(CFG, tinfo.block, 0,
                             clobber_buf, BLOCK_SIZE) => 0;
-                    lfs3_traversal_close(&lfs3, &t) => 0;
+                    lfs3_trv_close(&lfs3, &trv) => 0;
                     goto clobbered;
                 }
                 k += 1;
@@ -1380,19 +1380,19 @@ code = '''
 
     clobbered:;
         // traverse again, we should detect the clobbered metadata
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_CORRUPT);
             // found the clobbered metadata?
             if (err == LFS3_ERR_CORRUPT) {
                 break;
             }
         }
-        lfs3_traversal_close(&lfs3, &t) => 0;
+        lfs3_trv_close(&lfs3, &trv) => 0;
 
         for (lfs3_size_t i = 0; i < N; i++) {
             lfs3_file_desync(&lfs3, &files[i]) => 0;
@@ -1406,7 +1406,7 @@ done:;
 
 
 # check that we can detect every clobbered data block
-[cases.test_traversal_ckdata_dirs]
+[cases.test_trvs_ckdata_dirs]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
 code = '''
     for (lfs3_block_t i = 0;; i++) {
@@ -1425,17 +1425,17 @@ code = '''
         }
 
         // traverse to find blocks
-        lfs3_traversal_t t;
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+        lfs3_trv_t trv;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
         lfs3_block_t k = 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
                 lfs3_unmount(&lfs3) => 0;
                 goto done;
             }
@@ -1449,7 +1449,7 @@ code = '''
                     CFG->erase(CFG, tinfo.block) => 0;
                     CFG->prog(CFG, tinfo.block, 0,
                             clobber_buf, BLOCK_SIZE) => 0;
-                    lfs3_traversal_close(&lfs3, &t) => 0;
+                    lfs3_trv_close(&lfs3, &trv) => 0;
                     goto clobbered;
                 }
                 k += 1;
@@ -1458,26 +1458,26 @@ code = '''
 
     clobbered:;
         // traverse again, we should detect the clobbered metadata
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKDATA) => 0;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_CKDATA) => 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_CORRUPT);
             // found the clobbered metadata?
             if (err == LFS3_ERR_CORRUPT) {
                 break;
             }
         }
-        lfs3_traversal_close(&lfs3, &t) => 0;
+        lfs3_trv_close(&lfs3, &trv) => 0;
 
         lfs3_unmount(&lfs3) => 0;
     }
 done:;
 '''
 
-[cases.test_traversal_ckdata_files]
+[cases.test_trvs_ckdata_files]
 defines.N = [1, 2, 4, 8, 16, 32, 64]
 defines.SIZE = [
     '0',
@@ -1519,17 +1519,17 @@ code = '''
         }
 
         // traverse to find blocks
-        lfs3_traversal_t t;
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+        lfs3_trv_t trv;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
         lfs3_block_t k = 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
                 lfs3_unmount(&lfs3) => 0;
                 goto done;
             }
@@ -1543,7 +1543,7 @@ code = '''
                     CFG->erase(CFG, tinfo.block) => 0;
                     CFG->prog(CFG, tinfo.block, 0,
                             clobber_buf, BLOCK_SIZE) => 0;
-                    lfs3_traversal_close(&lfs3, &t) => 0;
+                    lfs3_trv_close(&lfs3, &trv) => 0;
                     goto clobbered;
                 }
                 k += 1;
@@ -1552,26 +1552,26 @@ code = '''
 
     clobbered:;
         // traverse again, we should detect the clobbered metadata
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKDATA) => 0;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_CKDATA) => 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_CORRUPT);
             // found the clobbered metadata?
             if (err == LFS3_ERR_CORRUPT) {
                 break;
             }
         }
-        lfs3_traversal_close(&lfs3, &t) => 0;
+        lfs3_trv_close(&lfs3, &trv) => 0;
 
         lfs3_unmount(&lfs3) => 0;
     }
 done:;
 '''
 
-[cases.test_traversal_ckdata_files_opened]
+[cases.test_trvs_ckdata_files_opened]
 defines.N = [1, 2, 4, 8, 16, 32, 64]
 defines.SIZE = [
     '0',
@@ -1612,17 +1612,17 @@ code = '''
         }
 
         // traverse to find blocks
-        lfs3_traversal_t t;
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0;
+        lfs3_trv_t trv;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0;
         lfs3_block_t k = 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_close(&lfs3, &t) => 0;
+                lfs3_trv_close(&lfs3, &trv) => 0;
                 for (lfs3_size_t i = 0; i < N; i++) {
                     lfs3_file_close(&lfs3, &files[i]) => 0;
                 }
@@ -1639,7 +1639,7 @@ code = '''
                     CFG->erase(CFG, tinfo.block) => 0;
                     CFG->prog(CFG, tinfo.block, 0,
                             clobber_buf, BLOCK_SIZE) => 0;
-                    lfs3_traversal_close(&lfs3, &t) => 0;
+                    lfs3_trv_close(&lfs3, &trv) => 0;
                     goto clobbered;
                 }
                 k += 1;
@@ -1648,19 +1648,19 @@ code = '''
 
     clobbered:;
         // traverse again, we should detect the clobbered metadata
-        lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKDATA) => 0;
+        lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_CKDATA) => 0;
         for (lfs3_block_t j = 0;; j++) {
             assert(j < 2*BLOCK_COUNT);
 
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_CORRUPT);
             // found the clobbered metadata?
             if (err == LFS3_ERR_CORRUPT) {
                 break;
             }
         }
-        lfs3_traversal_close(&lfs3, &t) => 0;
+        lfs3_trv_close(&lfs3, &trv) => 0;
 
         for (lfs3_size_t i = 0; i < N; i++) {
             lfs3_file_desync(&lfs3, &files[i]) => 0;
@@ -1674,7 +1674,7 @@ done:;
 
 
 # test that in general fsinfo flags work
-[cases.test_traversal_flags]
+[cases.test_trvs_flags]
 defines.MKCONSISTENT = [false, true]
 defines.LOOKAHEAD = [false, true]
 defines.COMPACT = [false, true]
@@ -1696,8 +1696,8 @@ code = '''
                 | LFS3_I_CKDATA));
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0)
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
@@ -1705,14 +1705,14 @@ code = '''
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
                 | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0;
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // check flags after
     lfs3_fs_stat(&lfs3, &fsinfo) => 0;
@@ -1728,7 +1728,7 @@ code = '''
 '''
 
 # test that we detect filesystem mutation during traversal
-[cases.test_traversal_mutation]
+[cases.test_trvs_mutation]
 defines.WHEN = [0, 1, 2]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
@@ -1739,8 +1739,8 @@ code = '''
     lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -1754,7 +1754,7 @@ code = '''
     }
 
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
 
@@ -1765,7 +1765,7 @@ code = '''
         lfs3_file_close(&lfs3, &file) => 0;
     }
 
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
 
@@ -1776,8 +1776,8 @@ code = '''
         lfs3_file_close(&lfs3, &file) => 0;
     }
 
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -1792,7 +1792,7 @@ code = '''
 '''
 
 # test that we don't get extra anything after end of traversal
-[cases.test_traversal_mutation_idempotent]
+[cases.test_trvs_mutation_idempotent]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -1802,14 +1802,14 @@ code = '''
     lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
                 | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0;
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
 
@@ -1819,17 +1819,17 @@ code = '''
             LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0;
     lfs3_file_close(&lfs3, &file) => 0;
 
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
 
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -1845,12 +1845,12 @@ code = '''
             LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0;
     lfs3_file_close(&lfs3, &file) => 0;
 
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     lfs3_fs_stat(&lfs3, &fsinfo) => 0;
@@ -1860,12 +1860,12 @@ code = '''
                 | LFS3_I_CKMETA
                 | LFS3_I_CKDATA));
 
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_mkdir]
+[cases.test_trvs_mutation_mkdir]
 defines.WHEN = [0, 1, 2]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
@@ -1876,8 +1876,8 @@ code = '''
     lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -1888,7 +1888,7 @@ code = '''
     }
 
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
 
@@ -1896,7 +1896,7 @@ code = '''
         lfs3_mkdir(&lfs3, "spider") => 0;
     }
 
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
 
@@ -1904,8 +1904,8 @@ code = '''
         lfs3_mkdir(&lfs3, "spider") => 0;
     }
 
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -1919,7 +1919,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_rm]
+[cases.test_trvs_mutation_rm]
 defines.WHEN = [0, 1, 2]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
@@ -1936,8 +1936,8 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -1948,7 +1948,7 @@ code = '''
     }
 
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
 
@@ -1956,7 +1956,7 @@ code = '''
         lfs3_remove(&lfs3, "spider") => 0;
     }
 
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
 
@@ -1964,8 +1964,8 @@ code = '''
         lfs3_remove(&lfs3, "spider") => 0;
     }
 
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -1979,7 +1979,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_mv]
+[cases.test_trvs_mutation_mv]
 defines.WHEN = [0, 1, 2]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
@@ -1996,8 +1996,8 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -2008,7 +2008,7 @@ code = '''
     }
 
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
 
@@ -2016,7 +2016,7 @@ code = '''
         lfs3_rename(&lfs3, "spider", "scorpion") => 0;
     }
 
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
 
@@ -2024,8 +2024,8 @@ code = '''
         lfs3_rename(&lfs3, "spider", "scorpion") => 0;
     }
 
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -2040,7 +2040,7 @@ code = '''
 '''
 
 # some more complex mutation tests
-[cases.test_traversal_mutation_fwrite]
+[cases.test_trvs_mutation_fwrite]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -2071,8 +2071,8 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -2090,14 +2090,14 @@ code = '''
 
         // step traversal
         struct lfs3_tinfo tinfo;
-        int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+        int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
         assert(!err || err == LFS3_ERR_NOENT);
         if (err == LFS3_ERR_NOENT) {
             break;
         }
     }
 
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -2118,7 +2118,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_fwrite_opened]
+[cases.test_trvs_mutation_fwrite_opened]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -2153,8 +2153,8 @@ code = '''
     }
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -2173,14 +2173,14 @@ code = '''
 
         // step traversal
         struct lfs3_tinfo tinfo;
-        int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+        int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
         assert(!err || err == LFS3_ERR_NOENT);
         if (err == LFS3_ERR_NOENT) {
             break;
         }
     }
 
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -2212,7 +2212,7 @@ code = '''
 #
 # these assume quite a bit more and may be a bit fragile...
 #
-[cases.test_traversal_mutation_file_bsprout]
+[cases.test_trvs_mutation_file_bsprout]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -2246,8 +2246,8 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -2255,10 +2255,10 @@ code = '''
 
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
 
@@ -2273,8 +2273,8 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // we should be at end of traversal now
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -2300,7 +2300,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_file_btree]
+[cases.test_trvs_mutation_file_btree]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -2335,8 +2335,8 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -2344,17 +2344,17 @@ code = '''
 
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
     // traverse btree
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_BTREE);
     // traverse one data block
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
 
     // rewrite the file
@@ -2368,16 +2368,16 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // traverse btree
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_BTREE);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // we should be at end of traversal now
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -2403,7 +2403,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_file_bshrub]
+[cases.test_trvs_mutation_file_bshrub]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -2437,8 +2437,8 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -2446,14 +2446,14 @@ code = '''
 
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
     // traverse one data block
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
 
     // rewrite the file
@@ -2467,13 +2467,13 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // we should be at end of traversal now
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -2499,7 +2499,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_uncreat_bsprout]
+[cases.test_trvs_mutation_uncreat_bsprout]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -2533,8 +2533,8 @@ code = '''
     lfs3_file_flush(&lfs3, &file2) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -2542,10 +2542,10 @@ code = '''
 
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
 
@@ -2558,8 +2558,8 @@ code = '''
     lfs3_file_flush(&lfs3, &file1) => 0;
 
     // we should be at end of traversal now
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -2589,7 +2589,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_uncreat_btree]
+[cases.test_trvs_mutation_uncreat_btree]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -2624,8 +2624,8 @@ code = '''
     lfs3_file_flush(&lfs3, &file2) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -2633,17 +2633,17 @@ code = '''
 
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
     // traverse btree
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_BTREE);
     // traverse one data block
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
 
     // rewrite the file
@@ -2655,16 +2655,16 @@ code = '''
     lfs3_file_flush(&lfs3, &file1) => 0;
 
     // traverse btree
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_BTREE);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // we should be at end of traversal now
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -2694,7 +2694,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_uncreat_bshrub]
+[cases.test_trvs_mutation_uncreat_bshrub]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -2728,8 +2728,8 @@ code = '''
     lfs3_file_flush(&lfs3, &file2) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -2737,14 +2737,14 @@ code = '''
 
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
     // traverse one data block
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
 
     // rewrite the file
@@ -2756,13 +2756,13 @@ code = '''
     lfs3_file_flush(&lfs3, &file1) => 0;
 
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // we should be at end of traversal now
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -2792,7 +2792,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_close_bsprout]
+[cases.test_trvs_mutation_close_bsprout]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -2827,8 +2827,8 @@ code = '''
     lfs3_file_flush(&lfs3, &file2) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -2836,10 +2836,10 @@ code = '''
 
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
 
@@ -2850,8 +2850,8 @@ code = '''
     lfs3_file_close(&lfs3, &file1) => 0;
 
     // we should be at end of traversal now
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/etc, unless we're desynced
     struct lfs3_fsinfo fsinfo;
@@ -2889,7 +2889,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_close_btree]
+[cases.test_trvs_mutation_close_btree]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -2925,8 +2925,8 @@ code = '''
     lfs3_file_flush(&lfs3, &file2) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -2934,17 +2934,17 @@ code = '''
 
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
     // traverse btree
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_BTREE);
     // traverse one data block
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
 
     // close the file
@@ -2954,16 +2954,16 @@ code = '''
     lfs3_file_close(&lfs3, &file1) => 0;
 
     // traverse btree
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_BTREE);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // we should be at end of traversal now
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/etc, unless we're desynced
     struct lfs3_fsinfo fsinfo;
@@ -3001,7 +3001,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_close_bshrub]
+[cases.test_trvs_mutation_close_bshrub]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -3036,8 +3036,8 @@ code = '''
     lfs3_file_flush(&lfs3, &file2) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -3045,14 +3045,14 @@ code = '''
 
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
     // traverse one data block
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
 
     // close the file
@@ -3062,13 +3062,13 @@ code = '''
     lfs3_file_close(&lfs3, &file1) => 0;
 
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // we should be at end of traversal now
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/etc, unless we're desynced
     struct lfs3_fsinfo fsinfo;
@@ -3106,7 +3106,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_rm_bshrub]
+[cases.test_trvs_mutation_rm_bshrub]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -3139,8 +3139,8 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -3148,27 +3148,27 @@ code = '''
 
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
     // traverse one data block
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
 
     // remove the file
     lfs3_remove(&lfs3, "spider") => 0;
 
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // we should be at end of traversal now
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/etc, unless we're desynced
     struct lfs3_fsinfo fsinfo;
@@ -3195,7 +3195,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_mv_src_bshrub]
+[cases.test_trvs_mutation_mv_src_bshrub]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -3237,8 +3237,8 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -3246,32 +3246,32 @@ code = '''
 
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
     // traverse one data block
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
 
     // rename one file over another
     lfs3_rename(&lfs3, "spider", "tarantula") => 0;
 
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // we should be at end of traversal now
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -3299,7 +3299,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_mv_dst_bshrub]
+[cases.test_trvs_mutation_mv_dst_bshrub]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -3341,8 +3341,8 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -3350,27 +3350,27 @@ code = '''
 
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
     // traverse one data block
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
 
     // rename one file over another
     lfs3_rename(&lfs3, "tarantula", "spider") => 0;
 
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // we should be at end of traversal now
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -3398,7 +3398,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_mroot_split]
+[cases.test_trvs_mutation_mroot_split]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -3431,8 +3431,8 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -3440,7 +3440,7 @@ code = '''
 
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
 
@@ -3456,28 +3456,28 @@ code = '''
     }
 
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // we should be at end of traversal now
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -3503,7 +3503,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_mroot_split_bshrub_l]
+[cases.test_trvs_mutation_mroot_split_bshrub_l]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -3545,8 +3545,8 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -3554,14 +3554,14 @@ code = '''
 
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
     // traverse a data block
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
 
     // create enough files for mroot to split
@@ -3576,26 +3576,26 @@ code = '''
     }
 
     // traverse another data block
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // we should be at end of traversal now
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -3626,7 +3626,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_mroot_split_bshrub_r]
+[cases.test_trvs_mutation_mroot_split_bshrub_r]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -3668,8 +3668,8 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -3677,19 +3677,19 @@ code = '''
 
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // and another data block
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
 
     // create enough files for mroot to split
@@ -3704,16 +3704,16 @@ code = '''
     }
 
     // traverse another data block
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // we should be at end of traversal now
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -3744,7 +3744,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_mroot_extend]
+[cases.test_trvs_mutation_mroot_extend]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -3779,8 +3779,8 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -3788,7 +3788,7 @@ code = '''
 
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
 
@@ -3802,23 +3802,23 @@ code = '''
     }
 
     // traverse mroot
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // we should be at end of traversal now
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -3844,7 +3844,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_mroot_extend_bshrub]
+[cases.test_trvs_mutation_mroot_extend_bshrub]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -3879,8 +3879,8 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -3888,14 +3888,14 @@ code = '''
 
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
     // traverse a data block
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
 
     // rewrite enough files for mroot to extend
@@ -3908,16 +3908,16 @@ code = '''
     }
 
     // traverse another data block
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // we should be at end of traversal now
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -3943,7 +3943,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_mroot_relocate]
+[cases.test_trvs_mutation_mroot_relocate]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -3987,8 +3987,8 @@ code = '''
     }
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -3996,7 +3996,7 @@ code = '''
 
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
 
@@ -4015,23 +4015,23 @@ code = '''
     // I wouldn't worry too much about it
     //
     // traverse mroot
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // we should be at end of traversal now
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -4057,7 +4057,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_mroot_relocate_bshrub]
+[cases.test_trvs_mutation_mroot_relocate_bshrub]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -4101,8 +4101,8 @@ code = '''
     }
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -4110,18 +4110,18 @@ code = '''
 
     // traverse mroots
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse a data block
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
 
     // rewrite enough files for mroot to relocate
@@ -4135,16 +4135,16 @@ code = '''
     }
 
     // traverse another data block
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // we should be at end of traversal now
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -4170,7 +4170,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_mtree_split]
+[cases.test_trvs_mutation_mtree_split]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -4243,8 +4243,8 @@ code = '''
     }
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -4252,7 +4252,7 @@ code = '''
 
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
 
@@ -4269,48 +4269,48 @@ code = '''
     }
 
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // we should be at end of traversal now
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -4346,7 +4346,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_mtree_split_bshrub_l]
+[cases.test_trvs_mutation_mtree_split_bshrub_l]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -4419,8 +4419,8 @@ code = '''
     }
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -4428,32 +4428,32 @@ code = '''
 
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
     // traverse mtree
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_BTREE);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse one data block
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
 
     // create enough files for mdir to split again
@@ -4469,31 +4469,31 @@ code = '''
     }
 
     // traverse another data block
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // we should be at end of traversal now
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -4529,7 +4529,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_mtree_split_bshrub_r]
+[cases.test_trvs_mutation_mtree_split_bshrub_r]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -4602,8 +4602,8 @@ code = '''
     }
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -4611,37 +4611,37 @@ code = '''
 
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
     // traverse mtree
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_BTREE);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse one data block
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
 
     // create enough files for mdir to split again
@@ -4656,21 +4656,21 @@ code = '''
         i += 1;
     }
     // traverse another data block
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // we should be at end of traversal now
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -4706,7 +4706,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_mtree_extend]
+[cases.test_trvs_mutation_mtree_extend]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -4785,8 +4785,8 @@ code = '''
     lfs3_mount(&lfs3, LFS3_M_RDWR, &cfg) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -4794,7 +4794,7 @@ code = '''
 
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
 
@@ -4808,43 +4808,43 @@ code = '''
     }
 
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // we should be at end of traversal now
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -4880,7 +4880,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_mtree_extend_bshrub]
+[cases.test_trvs_mutation_mtree_extend_bshrub]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -4959,8 +4959,8 @@ code = '''
     lfs3_mount(&lfs3, LFS3_M_RDWR, &cfg) => 0;
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -4968,32 +4968,32 @@ code = '''
 
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
     // traverse mtree
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_BTREE);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse one data block
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
 
     // rewrite enough files for mroot to extend
@@ -5006,26 +5006,26 @@ code = '''
     }
 
     // traverse another data block
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // we should be at end of traversal now
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -5061,7 +5061,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_mtree_relocate]
+[cases.test_trvs_mutation_mtree_relocate]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -5145,8 +5145,8 @@ code = '''
     }
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -5154,7 +5154,7 @@ code = '''
 
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
 
@@ -5169,43 +5169,43 @@ code = '''
     }
 
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // we should be at end of traversal now
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -5241,7 +5241,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mutation_mtree_relocate_bshrub]
+[cases.test_trvs_mutation_mtree_relocate_bshrub]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -5325,8 +5325,8 @@ code = '''
     }
 
     // try traversing
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
                 | ((CKMETA) ? LFS3_T_CKMETA : 0)
@@ -5334,36 +5334,36 @@ code = '''
 
     // traverse mroots
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse mtree
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_BTREE);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse one data block
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
 
     // rewrite enough files for mroot to relocate
@@ -5377,26 +5377,26 @@ code = '''
     }
 
     // traverse another data block
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse two data blocks
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_DATA);
     // we should be at end of traversal now
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should _not_ update lookahead/compact/ckmeta/ckdata
     struct lfs3_fsinfo fsinfo;
@@ -5435,7 +5435,7 @@ code = '''
 
 # test traversals with mdir compaction
 
-[cases.test_traversal_compact]
+[cases.test_trvs_compact]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -5475,8 +5475,8 @@ code = '''
                 | LFS3_I_CKDATA));
 
     // try traversing and compacting
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | LFS3_T_COMPACT
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
@@ -5484,13 +5484,13 @@ code = '''
                 | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0;
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
 
     // mdir should have been compacted
     assert((file.b.h.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
@@ -5504,15 +5504,15 @@ code = '''
                 | LFS3_I_CKDATA));
 
     // running another traversal should clear the uncompacted flag
-    lfs3_traversal_rewind(&lfs3, &t) => 0;
+    lfs3_trv_rewind(&lfs3, &trv) => 0;
     while (true) {
-        int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+        int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
         assert(!err || err == LFS3_ERR_NOENT);
         if (err == LFS3_ERR_NOENT) {
             break;
         }
     }
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // mdir should have been compacted
     assert((file.b.h.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
@@ -5545,7 +5545,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_compact_mrootchain]
+[cases.test_trvs_compact_mrootchain]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -5606,8 +5606,8 @@ code = '''
                 | LFS3_I_CKDATA));
 
     // try traversing and compacting
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | LFS3_T_COMPACT
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
@@ -5615,18 +5615,18 @@ code = '''
                 | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0;
     // traverse mrootanchor
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
     // traverse mroot
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
 
     // mrootanchor should have been compacted
     lfs3_mdir_t mrootanchor;
@@ -5643,15 +5643,15 @@ code = '''
                 | LFS3_I_CKDATA));
 
     // running another traversal should clear the uncompacted flag
-    lfs3_traversal_rewind(&lfs3, &t) => 0;
+    lfs3_trv_rewind(&lfs3, &trv) => 0;
     while (true) {
-        int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+        int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
         assert(!err || err == LFS3_ERR_NOENT);
         if (err == LFS3_ERR_NOENT) {
             break;
         }
     }
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // mrootanchor should have been compacted
     lfs3_mdir_fetch(&lfs3, &mrootanchor,
@@ -5686,7 +5686,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_compact_mroot_extend]
+[cases.test_trvs_compact_mroot_extend]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -5729,8 +5729,8 @@ code = '''
                 | LFS3_I_CKDATA));
 
     // try traversing and compacting
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | LFS3_T_COMPACT
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
@@ -5742,11 +5742,11 @@ code = '''
     //
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
 
     // mdir should have been compacted
     assert((file.b.h.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
@@ -5760,15 +5760,15 @@ code = '''
                 | LFS3_I_CKDATA));
 
     // running another traversal should clear the uncompacted flag
-    lfs3_traversal_rewind(&lfs3, &t) => 0;
+    lfs3_trv_rewind(&lfs3, &trv) => 0;
     while (true) {
-        int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+        int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
         assert(!err || err == LFS3_ERR_NOENT);
         if (err == LFS3_ERR_NOENT) {
             break;
         }
     }
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // mdir should have been compacted
     assert((file.b.h.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
@@ -5801,7 +5801,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_compact_mroot_split]
+[cases.test_trvs_compact_mroot_split]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -5871,8 +5871,8 @@ code = '''
                 | LFS3_I_CKDATA));
 
     // try traversing and compacting
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | LFS3_T_COMPACT
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
@@ -5880,26 +5880,26 @@ code = '''
                 | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0;
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
     // should have split, traverse mtree
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_BTREE);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
 
     // mdirs should have been compacted
     assert((file1.b.h.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
@@ -5914,15 +5914,15 @@ code = '''
                 | LFS3_I_CKDATA));
 
     // running another traversal should clear the uncompacted flag
-    lfs3_traversal_rewind(&lfs3, &t) => 0;
+    lfs3_trv_rewind(&lfs3, &trv) => 0;
     while (true) {
-        int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+        int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
         assert(!err || err == LFS3_ERR_NOENT);
         if (err == LFS3_ERR_NOENT) {
             break;
         }
     }
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // mdirs should have been compacted
     assert((file1.b.h.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
@@ -5963,7 +5963,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_compact_mtree]
+[cases.test_trvs_compact_mtree]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -6080,8 +6080,8 @@ code = '''
                 | LFS3_I_CKDATA));
 
     // try traversing and compacting
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | LFS3_T_COMPACT
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
@@ -6089,31 +6089,31 @@ code = '''
                 | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0;
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
     // traverse mtree
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_BTREE);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
 
     if (COMPACTSET) {
         // mdirs should have been compacted
@@ -6130,16 +6130,16 @@ code = '''
                     | LFS3_I_CKDATA));
 
         // running another traversal should clear the uncompacted flag
-        lfs3_traversal_rewind(&lfs3, &t) => 0;
+        lfs3_trv_rewind(&lfs3, &trv) => 0;
         while (true) {
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             if (err == LFS3_ERR_NOENT) {
                 break;
             }
         }
     }
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // mdirs should have been compacted
     assert((file1.b.h.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
@@ -6188,7 +6188,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_compact_mtree_split]
+[cases.test_trvs_compact_mtree_split]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -6303,8 +6303,8 @@ code = '''
                 | LFS3_I_CKDATA));
 
     // try traversing and compacting
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | LFS3_T_COMPACT
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
@@ -6312,36 +6312,36 @@ code = '''
                 | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0;
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
     // traverse mtree
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_BTREE);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // should have split, traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     // traverse mdir
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
 
     // mdirs should have been compacted
     assert((file1.b.h.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
@@ -6358,15 +6358,15 @@ code = '''
                 | LFS3_I_CKDATA));
 
     // running another traversal should clear the uncompacted flag
-    lfs3_traversal_rewind(&lfs3, &t) => 0;
+    lfs3_trv_rewind(&lfs3, &trv) => 0;
     while (true) {
-        int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+        int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
         assert(!err || err == LFS3_ERR_NOENT);
         if (err == LFS3_ERR_NOENT) {
             break;
         }
     }
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // mdirs should have been compacted
     assert((file1.b.h.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
@@ -6429,7 +6429,7 @@ code = '''
 
 # test traversals with mkconsistent
 
-[cases.test_traversal_mkconsistent]
+[cases.test_trvs_mkconsistent]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -6497,8 +6497,8 @@ code = '''
                 | LFS3_I_CKDATA));
 
     // try traversing with mkconsistent
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | LFS3_T_MKCONSISTENT
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
@@ -6506,28 +6506,28 @@ code = '''
                 | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0;
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
     if (ORPHANS > 3) {
         // traverse mtree
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
         // traverse mdirs
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
     }
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should have cleaned up all grms/orphans
     assert(lfs3.grm.queue[0] == 0);
@@ -6575,7 +6575,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mkconsistent_conflict]
+[cases.test_trvs_mkconsistent_conflict]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -6621,8 +6621,8 @@ code = '''
                 | LFS3_I_CKDATA));
 
     // try traversing with mkconsistent
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | LFS3_T_MKCONSISTENT
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
@@ -6630,7 +6630,7 @@ code = '''
                 | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0;
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
 
@@ -6658,22 +6658,22 @@ code = '''
     // keep traversing
     if (ORPHANS <= 3) {
         // traverse mroot
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
         assert(tinfo.block == 0 || tinfo.block == 1);
     } else {
         // traverse mdirs
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
     }
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should be able to clean up grms
     assert(lfs3.grm.queue[0] == 0);
@@ -6720,7 +6720,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mkconsistent_btree]
+[cases.test_trvs_mkconsistent_btree]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -6792,8 +6792,8 @@ code = '''
                 | LFS3_I_CKDATA));
 
     // try traversing with mkconsistent
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | LFS3_T_MKCONSISTENT
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
@@ -6801,42 +6801,42 @@ code = '''
                 | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0;
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
     if (ORPHANS <= 3) {
         // traverse btree
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
         // traverse btree
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
     } else {
         // traverse mtree
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
         // traverse mdirs
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
         // traverse btree
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
         // traverse mdirs
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
         // traverse btree
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
     }
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should have cleaned up all grms/orphans
     assert(lfs3.grm.queue[0] == 0);
@@ -6884,7 +6884,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mkconsistent_btree_uncreat]
+[cases.test_trvs_mkconsistent_btree_uncreat]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -6956,8 +6956,8 @@ code = '''
                 | LFS3_I_CKDATA));
 
     // try traversing with mkconsistent
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | LFS3_T_MKCONSISTENT
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
@@ -6965,42 +6965,42 @@ code = '''
                 | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0;
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
     if (ORPHANS <= 3) {
         // traverse btree
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
         // traverse btree
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
     } else {
         // traverse mtree
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
         // traverse mdirs
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
         // traverse btree
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
         // traverse mdirs
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
         // traverse btree
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
     }
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should have cleaned up all grms/orphans
     assert(lfs3.grm.queue[0] == 0);
@@ -7048,7 +7048,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mkconsistent_bshrub]
+[cases.test_trvs_mkconsistent_bshrub]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -7121,8 +7121,8 @@ code = '''
                 | LFS3_I_CKDATA));
 
     // try traversing with mkconsistent
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | LFS3_T_MKCONSISTENT
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
@@ -7130,50 +7130,50 @@ code = '''
                 | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0;
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
     if (ORPHANS <= 3) {
         // traverse bshrub
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
         // traverse bshrub
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
     } else {
         // traverse mtree
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
         // traverse mdirs
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
         // traverse bshrub
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
         // traverse mdirs
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
         // traverse bshrub
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
     }
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should have cleaned up all grms/orphans
     assert(lfs3.grm.queue[0] == 0);
@@ -7221,7 +7221,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mkconsistent_bshrub_uncreat]
+[cases.test_trvs_mkconsistent_bshrub_uncreat]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -7294,8 +7294,8 @@ code = '''
                 | LFS3_I_CKDATA));
 
     // try traversing with mkconsistent
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | LFS3_T_MKCONSISTENT
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
@@ -7303,50 +7303,50 @@ code = '''
                 | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0;
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
     if (ORPHANS <= 3) {
         // traverse bshrub
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
         // traverse bshrub
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
     } else {
         // traverse mtree
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
         // traverse mdirs
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
         // traverse bshrub
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
         // traverse mdirs
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
         // traverse bshrub
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
     }
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should have cleaned up all grms/orphans
     assert(lfs3.grm.queue[0] == 0);
@@ -7394,7 +7394,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mkconsistent_compact]
+[cases.test_trvs_mkconsistent_compact]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -7485,8 +7485,8 @@ code = '''
                 | LFS3_I_CKDATA));
 
     // try traversing with mkconsistent
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | LFS3_T_MKCONSISTENT
                 | LFS3_T_COMPACT
@@ -7495,27 +7495,27 @@ code = '''
                 | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0;
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
     if (ORPHANS > 3) {
         // traverse mtree
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_BTREE);
         // traverse mdirs
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
     }
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
 
     // we should have cleaned up all grms/orphans
     assert(lfs3.grm.queue[0] == 0);
@@ -7541,15 +7541,15 @@ code = '''
                 | LFS3_I_CKDATA));
 
     // running another traversal should clear the uncompacted flag
-    lfs3_traversal_rewind(&lfs3, &t) => 0;
+    lfs3_trv_rewind(&lfs3, &trv) => 0;
     while (true) {
-        int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+        int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
         assert(!err || err == LFS3_ERR_NOENT);
         if (err == LFS3_ERR_NOENT) {
             break;
         }
     }
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // mdirs should have been compacted
     assert((file1.b.h.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
@@ -7590,7 +7590,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_mkconsistent_compact_conflict]
+[cases.test_trvs_mkconsistent_compact_conflict]
 defines.LOOKAHEAD = [false, true]
 defines.CKMETA = [false, true]
 defines.CKDATA = [false, true]
@@ -7659,8 +7659,8 @@ code = '''
                 | LFS3_I_CKDATA));
 
     // try traversing with mkconsistent
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | LFS3_T_MKCONSISTENT
                 | LFS3_T_COMPACT
@@ -7669,7 +7669,7 @@ code = '''
                 | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0;
     // traverse mroot
     struct lfs3_tinfo tinfo;
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
     assert(tinfo.btype == LFS3_BTYPE_MDIR);
     assert(tinfo.block == 0 || tinfo.block == 1);
 
@@ -7697,22 +7697,22 @@ code = '''
     // keep traversing
     if (ORPHANS <= 3) {
         // traverse mroot
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
         assert(tinfo.block == 0 || tinfo.block == 1);
     } else {
         // traverse mdirs
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
-        lfs3_traversal_read(&lfs3, &t, &tinfo) => 0;
+        lfs3_trv_read(&lfs3, &trv, &tinfo) => 0;
         assert(tinfo.btype == LFS3_BTYPE_MDIR);
     }
-    lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // we should be able to clean up grms
     assert(lfs3.grm.queue[0] == 0);
@@ -7772,7 +7772,7 @@ code = '''
 # these should hopefully test a bunch of messy traversal state
 #
 
-[cases.test_traversal_spam_dir_many]
+[cases.test_trvs_spam_dir_many]
 # traverse steps between each op
 defines.STEPS = [1, 2, 4, 8, 16, 32, 64, 128]
 defines.MKCONSISTENT = [false, true]
@@ -7790,8 +7790,8 @@ code = '''
     lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0;
 
     // open a traversal
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0)
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
@@ -7809,16 +7809,16 @@ code = '''
         // step the traversal
         for (lfs3_size_t s = 0; s < STEPS; s++) {
             struct lfs3_tinfo tinfo;
-            err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             // restart traversal
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_rewind(&lfs3, &t) => 0;
+                lfs3_trv_rewind(&lfs3, &trv) => 0;
             }
         }
     }
 
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     for (int remount = 0; remount < 2; remount++) {
         // remount?
@@ -7883,7 +7883,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_spam_dir_fuzz]
+[cases.test_trvs_spam_dir_fuzz]
 # traverse steps between each op
 defines.STEPS = [1, 2, 4, 8, 16, 32, 64, 128]
 defines.MKCONSISTENT = [false, true]
@@ -7908,8 +7908,8 @@ code = '''
     lfs3_size_t sim_size = 0;
 
     // open a traversal
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0)
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
@@ -8003,16 +8003,16 @@ code = '''
         // step the traversal
         for (lfs3_size_t s = 0; s < STEPS; s++) {
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             // restart traversal
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_rewind(&lfs3, &t) => 0;
+                lfs3_trv_rewind(&lfs3, &trv) => 0;
             }
         }
     }
 
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     for (int remount = 0; remount < 2; remount++) {
         // remount?
@@ -8065,7 +8065,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_spam_file_many]
+[cases.test_trvs_spam_file_many]
 # traverse steps between each op
 defines.STEPS = [1, 2, 4, 8, 16, 32, 64, 128]
 defines.MKCONSISTENT = [false, true]
@@ -8093,8 +8093,8 @@ code = '''
     lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0;
 
     // open a traversal
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0)
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
@@ -8122,16 +8122,16 @@ code = '''
         // step the traversal
         for (lfs3_size_t s = 0; s < STEPS; s++) {
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             // restart traversal
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_rewind(&lfs3, &t) => 0;
+                lfs3_trv_rewind(&lfs3, &trv) => 0;
             }
         }
     }
 
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     for (int remount = 0; remount < 2; remount++) {
         // remount?
@@ -8170,7 +8170,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_spam_file_fuzz]
+[cases.test_trvs_spam_file_fuzz]
 # traverse steps between each op
 defines.STEPS = [1, 2, 4, 8, 16, 32, 64, 128]
 defines.MKCONSISTENT = [false, true]
@@ -8206,8 +8206,8 @@ code = '''
     lfs3_size_t sim_size = 0;
 
     // open a traversal
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0)
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
@@ -8337,16 +8337,16 @@ code = '''
         // step the traversal
         for (lfs3_size_t s = 0; s < STEPS; s++) {
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             // restart traversal
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_rewind(&lfs3, &t) => 0;
+                lfs3_trv_rewind(&lfs3, &trv) => 0;
             }
         }
     }
 
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     for (int remount = 0; remount < 2; remount++) {
         // remount?
@@ -8414,7 +8414,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_spam_fwrite_fuzz]
+[cases.test_trvs_spam_fwrite_fuzz]
 # traverse steps between each op
 defines.STEPS = [1, 2, 4, 8, 16, 32, 64, 128]
 defines.MKCONSISTENT = [false, true]
@@ -8482,8 +8482,8 @@ code = '''
     }
 
     // open a traversal
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0)
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
@@ -8517,16 +8517,16 @@ code = '''
         // step the traversal
         for (lfs3_size_t s = 0; s < STEPS; s++) {
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             // restart traversal
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_rewind(&lfs3, &t) => 0;
+                lfs3_trv_rewind(&lfs3, &trv) => 0;
             }
         }
     }
 
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     lfs3_file_close(&lfs3, &file) => 0;
 
@@ -8578,7 +8578,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_spam_uz_fuzz]
+[cases.test_trvs_spam_uz_fuzz]
 # traverse steps between each op
 defines.STEPS = [1, 2, 4, 8, 16, 32, 64, 128]
 defines.MKCONSISTENT = [false, true]
@@ -8625,8 +8625,8 @@ code = '''
     lfs3_size_t sim_file_count = 0;
 
     // open a traversal
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0)
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
@@ -8927,16 +8927,16 @@ code = '''
         // step the traversal
         for (lfs3_size_t s = 0; s < STEPS; s++) {
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             // restart traversal
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_rewind(&lfs3, &t) => 0;
+                lfs3_trv_rewind(&lfs3, &trv) => 0;
             }
         }
     }
 
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // check that disk matches our simulation
     for (lfs3_size_t j = 0; j < sim_size; j++) {
@@ -9029,7 +9029,7 @@ code = '''
     lfs3_unmount(&lfs3) => 0;
 '''
 
-[cases.test_traversal_spam_uzd_fuzz]
+[cases.test_trvs_spam_uzd_fuzz]
 # traverse steps between each op
 defines.STEPS = [1, 2, 4, 8, 16, 32, 64, 128]
 defines.MKCONSISTENT = [false, true]
@@ -9077,8 +9077,8 @@ code = '''
     lfs3_size_t sim_file_count = 0;
 
     // open a traversal
-    lfs3_traversal_t t;
-    lfs3_traversal_open(&lfs3, &t,
+    lfs3_trv_t trv;
+    lfs3_trv_open(&lfs3, &trv,
             LFS3_T_RDWR
                 | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0)
                 | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0)
@@ -9458,16 +9458,16 @@ code = '''
         // step the traversal
         for (lfs3_size_t s = 0; s < STEPS; s++) {
             struct lfs3_tinfo tinfo;
-            int err = lfs3_traversal_read(&lfs3, &t, &tinfo);
+            int err = lfs3_trv_read(&lfs3, &trv, &tinfo);
             assert(!err || err == LFS3_ERR_NOENT);
             // restart traversal
             if (err == LFS3_ERR_NOENT) {
-                lfs3_traversal_rewind(&lfs3, &t) => 0;
+                lfs3_trv_rewind(&lfs3, &trv) => 0;
             }
         }
     }
 
-    lfs3_traversal_close(&lfs3, &t) => 0;
+    lfs3_trv_close(&lfs3, &trv) => 0;
 
     // check that disk matches our simulation
     for (lfs3_size_t j = 0; j < sim_size; j++) {