Looking a little smoother.

arvo/hoon.hoon

@@ -2218,6 +2218,8 @@
 ++  same  |*(* +<)                                      ::  identity
 ++  head  |*(^ +<-)                                     ::  get head
 ++  tail  |*(^ +<+)                                     ::  get head
+++  fore  |*(a/$+(* *) |*(b/$+(* *) (pair a b)))        ::  pair before
+++  aftr  |*(a/$+(* *) |*(b/$+(* *) (pair b a)))        ::  pair after
 ++  test  |=(^ =(+<- +<+))                              ::  equality
 ++  cork  |*({a/_|=(* **) b/gate} (corl b a))           ::  compose forward
 ++  corl                                                ::  compose backwards
@@ -8008,66 +8010,78 @@
       hag  [q.p.dix q.q.dix]
     ==
   ::
-  ++  oc
+  ++  inca
-    |*  $_  ^|                                          ::  structures
-        |%  
-        ++  borm  span                                  ::  typestate
-        ++  burk  (pair axis borm)                      ::  leg change
-        ++  clow  onyx                                  ::  type manifest
-        ++  glub  palo                                  ::  general response
-        ++  dink  nock                                  ::  mint product
-        ++  ract  (list (pair axis nock))               ::  mint manifest
-        ++  resh  |*($+(* *) (pair +< ract))            ::  wrap mint manifest
-        ++  prod  |*($+(* *) (pair +< dink))            ::  wrap mint product
-        ++  stup  head                                  ::  unwrap
-        --
-    =>  |%
-        ++  rath  |~(clow `(resh clow)`[+< ~])          ::  working clow
-        ++  renk  (prod borm)                           ::  general result
-        ++  rowt  |~(borm `(resh borm)`[+< ~])          ::  working borm
-        --
-    |*  $_  ^|
-        |%                                              ::  functions
-        ++  halp  |~(twig `renk`(mint %noun +<))        ::  compile
-        ++  terp  |~  {a/span b/wing c/span}
-                  ^-  burk
-                  (tack(sut a) b c)
-        --
     |%  
-    ++  echo
+    ++  borm  span                                      ::  typestate
-      |=  {rum/borm rig/(list (pair wing twig))}
+    ++  clow  onyx                                      ::  type manifest
-      |-  ^-  (resh span)
+    ++  rosh  |*(* [p=+< q=*(list (pair axis nock))])   ::  wrap mint changes
-      ?~  rig
+    ++  pord  |*(* [p=+< q=*nock])                      ::  wrap mint formula
-        [rum ~]
+    ++  stup  head                                      ::  mint filling
-      =+  mor=$(rig t.rig)
+    ++  pust  tail                                      ::  mint wrap
-      =+  zil=(mint %noun q.i.rig)
+    ++  fleg  _(pord *borm)                             ::  leg with formula
-      =+  dar=(tack(sut p.mor) p.i.rig p.zil)
+    ++  fram  _(pord *clow)                             ::  arm with formula
-      [q.dar [[p.dar q.zil] q.mor]]
+    ++  foat  _(rosh *borm)                             ::  leg with changes
-    ::
+    ++  fult  _(rosh *clow)                             ::  arm with changes
-    ++  ecmo
+    ++  halp  |~  a/twig 
-      |=  {hag/onyx rig/(list (pair wing twig))}
+              ^-  fleg
-      ^-  (resh span)
+              (mint %noun a)
-      =-  [(fire p.-) q.-]
+    ++  terp  |~  {a/borm b/wing c/borm}
-      |-  ^-  (resh onyx)
+              ^-  (pair axis borm)
-      ?~  rig
+              (tack(sut a) b c)
-        [hag ~]
+    ++  toda  |~  {a/(pair axis clow) b/fleg c/fult}
-      =+  mor=$(rig t.rig)
+              ^+  (rosh *clow)
-      =+  zil=(mint %noun q.i.rig)
+              [q.a [[p.a (pust b)] (pust c)]]
-      =+  dix=(toss p.i.rig p.zil p.mor)
+    ++  todt  |~  {a/(pair axis borm) b/fleg c/foat}
-      [q.dix [[p.dix q.zil] q.mor]]
+              ^+  (rosh *borm)
-    ::
+              [q.a [[p.a (pust b)] (pust c)]]
-    ++  ecto
+    ++  tusp  |~  {a/clow b/wing c/borm}
-      |=  {lop/glub rig/(list (pair wing twig))}
+              ^-  (pair axis clow)
-      ^-  (pair span nock)
+              (toss b c a)
-      =.  rig  (flop rig)         ::  XX this unbreaks, void order in devulc
+    ++  tyte  |~  fult
-      =+  axe=(tend p.lop)
+              ^-  foat
-      ?:  ?=($& -.q.lop)
+              [(fire +<-) +<+]
-        =-  [p.- (hike axe q.-)]
-        (echo p.q.lop rig)
-      =-  [p.- [%9 p.q.lop (hike axe q.-)]]
-      (ecmo (~(tap in q.q.lop)) rig)
     --
   ::
+  ++  oc
+    =+  inc=inca
+    |%
+    +-  $
+      =>  inc
+      |%
+      ++  echo
+        |=  {rum/borm rig/(list (pair wing twig))}
+        |-  ^-  foat
+        ?~  rig  (rosh rum)
+        =+  mor=$(rig t.rig)
+        =+  zil=(halp q.i.rig)
+        =+  dar=(terp (stup mor) p.i.rig (stup zil))
+        (todt dar zil mor)
+      ::
+      ++  ecmo
+        |=  {hag/clow rig/(list (pair wing twig))}
+        ^-  foat
+        %-  tyte
+        |-  ^-  fult
+        ?~  rig  (rosh hag)
+        =+  mor=$(rig t.rig)
+        =+  zil=(halp q.i.rig)
+        =+  dar=(tusp (stup mor) p.i.rig (stup zil))
+        (toda dar zil mor)
+      --
+    --
+  ::
+  ++  etco
+    |=  {lop/palo rig/(list (pair wing twig))}
+    ^-  (pair span nock)
+    =+  cin=(oc inca)
+    =.  rig  (flop rig)         ::  XX this unbreaks, void order in devulc
+    =+  axe=(tend p.lop)
+    ?:  ?=($& -.q.lop)
+      =-  [p.- (hike axe q.-)]
+      (echo:cin p.q.lop rig)
+    =-  [p.- [%9 p.q.lop (hike axe q.-)]]
+    (ecmo:cin (~(tap in q.q.lop)) rig)
+  ::
   ++  et
     |_  {hyp/wing rig/(list (pair wing twig))}
     ++  play
@@ -8082,7 +8096,7 @@
       =+  lug=(seed hyp)
       ?:  ?=($| -.lug)  ~|(%twig ?>(?=($~ rig) p.lug))
       =-  ?>(?|(!vet (nest(sut gol) & p.-)) -)
-      (ecto:**oc p.lug rig)
+      (etco p.lug rig)
     ::
     ++  mull  
       |=  {gol/span dox/span}
@@ -8398,6 +8412,7 @@
     ~/  %mint
     |=  {gol/span gen/twig}
     ^-  {p/span q/nock}
+    ~&  %pure-mint
     |^  ^-  {p/span q/nock}
     ?:  ?&(=(%void sut) !?=({$dbug *} gen))
       ?.  |(!vet ?=({$lost *} gen) ?=({$zpzp *} gen))