diff --git a/ape/dojo.hoon b/ape/dojo.hoon
index feb4393c4..ce4218ee7 100644
--- a/ape/dojo.hoon
+++ b/ape/dojo.hoon
@@ -34,7 +34,7 @@
           {$file p/beam}                                ::  save to clay
           {$http p/?($post $put) q/purl}                ::  http outbound
           {$poke p/goal}                                ::  poke app
-          {$show p/?($0 $1 $2 $3)}                      ::  print val+type+twig
+          {$show p/?($0 $1 $2 $3)}                      ::  print val+span+twig
           {$verb p/term}                                ::  store variable
       ==                                                ::
     ++  dojo-source                                     ::  construction node
@@ -479,7 +479,7 @@
           $http
         ?>  ?=($mime p.cay)
         =+  mim=;;(mime q.q.cay)
-        =+  maf=(~(add ja *math) content-type+(moon p.mim))
+        =+  maf=(~(add ja *math) content-span+(moon p.mim))
         (dy-eyre /show [q.p.mad p.p.mad maf ~ q.mim])
       ::
           $show
@@ -487,7 +487,7 @@
         ?-  p.p.mad
           $0  ~
           $1  [%rose [~ "  " ~] (skol p.q.cay) ~]~ 
-          $2  [%rose [~ "  " ~] (dy-show-type-noun p.q.cay) ~]~
+          $2  [%rose [~ "  " ~] (dy-show-span-noun p.q.cay) ~]~
         ==
       ==
     ::
@@ -507,8 +507,8 @@
           (turn `wain`?~(r.hit ~ (lore q.u.r.hit)) trip)
       ==
     ::
-    ++  dy-show-type-noun
-      |=  a/type  ^-  tank
+    ++  dy-show-span-noun
+      |=  a/span  ^-  tank
       =-  >[-]<
       |-  ^-  $?  $%  {$atom @tas}
                       {$cell _$ _$}
@@ -525,7 +525,7 @@
         {$?($cell $fork) ^}  a(p $(a p.a), q $(a q.a))
         {$bull ^}  $(a q.a)
         {$core ^}  `wain`/core
-        {$hold *}  a(p (turn p.a |=({b/type c/twig} [^$(a b) c])))
+        {$hold *}  a(p (turn p.a |=({b/span c/twig} [^$(a b) c])))
       ==
     ::
     ++  dy-show-source
@@ -568,7 +568,7 @@
         (dy-diff %mor [%det lic] [%bel ~] ~)
       (dy-slam(per `dat) /edit u.pro !>((tufa buf.say)))
     ::
-    ++  dy-type                                         ::  sole action
+    ++  dy-span                                         ::  sole action
       |=  act/sole-action
       ?-  -.act
         $det  (dy-edit +.act)
@@ -930,11 +930,11 @@
       ==
     ==
   ::
-  ++  he-type                                           ::  apply input
+  ++  he-span                                           ::  apply input
     |=  act/sole-action
     ^+  +>
     ?^  poy
-      he-pine:(~(dy-type dy u.poy) act)
+      he-pine:(~(dy-span dy u.poy) act)
     ?-  -.act
       $det  (he-stir +.act)
       $ret  (he-done (tufa buf.say))
@@ -972,7 +972,7 @@
   |=  {moz/(list move) ses/session}
   =>  ~(. he moz ses)
   =-  [wrap=- +]
-  |*  he-arm/_he-type
+  |*  he-arm/_he-span
   |=  _+<.he-arm  
   ^-  (quip move ..he)
   he-abet:(he-arm +<)
@@ -989,7 +989,7 @@
 ::
 ++  poke-sole-action
   |=  act/sole-action  ~|  poke+act  %.  act
-  (wrap he-type):arm
+  (wrap he-span):arm
 ++  made       (wrap he-made):arm
 ++  sigh-httr  (wrap he-sigh):arm
 ++  sigh-tang  |=({a/wire b/tang} ~|(`term`(cat 3 'sigh-' -.a) (mean b)))
diff --git a/arvo/clay.hoon b/arvo/clay.hoon
index e4118dfb8..2c8c44295 100644
--- a/arvo/clay.hoon
+++ b/arvo/clay.hoon
@@ -1340,7 +1340,7 @@
       [p q has t]
     ::
     ++  apply-changes                                   ::   apply-changes:ze
-      |=  lar/(list {p/path q/misu})                   ::  store changes
+      |=  lar/(list {p/path q/misu})                    ::  store changes
       ^-  (map path blob)
       =+  ^=  hat                                       ::  current state
           ?:  =(let.dom 0)                              ::  initial commit
diff --git a/arvo/eyre.hoon b/arvo/eyre.hoon
index 28f1ff132..8c0c7e75f 100644
--- a/arvo/eyre.hoon
+++ b/arvo/eyre.hoon
@@ -692,7 +692,7 @@
   ::    [%of @ ^]  (get-ack:(ire-ix p.tee) q.tee hon)
   ::  ==
   ++  axon                                              ::  accept response
-    |=  {tee/whir typ/type sih/sign}
+    |=  {tee/whir typ/span sih/sign}
     ^+  +>
     =.  our  ?~(hov our u.hov)  ::  XX
     ?:  &(?=({?($of $ow) ^} tee) !(~(has by wix) p.tee))
diff --git a/arvo/ford.hoon b/arvo/ford.hoon
index 79f7b329b..96953b3c7 100644
--- a/arvo/ford.hoon
+++ b/arvo/ford.hoon
@@ -57,8 +57,8 @@
   $%  {$hood p/calm q/(pair beam cage) r/hood}          ::  compile
       {$bake p/calm q/(trel mark beam heel) r/(unit vase)}::  load
       {$lilt p/calm q/beak r/(jug mark mark)}           ::  translation graph
-      {$slit p/calm q/{p/type q/type} r/type}           ::  slam type
-      {$slim p/calm q/{p/type q/twig} r/(pair type nock)}::  mint
+      {$slit p/calm q/{p/span q/span} r/span}           ::  slam span
+      {$slim p/calm q/{p/span q/twig} r/(pair span nock)}::  mint
       {$slap p/calm q/{p/vase q/twig} r/vase}           ::  compute
       {$slam p/calm q/{p/vase q/vase} r/vase}           ::  compute
   ==                                                    ::
@@ -77,7 +77,7 @@
 --                                                      ::
 |%                                                      ::
 ++  calf                                                ::  reduce calx
-  |*  sem/*                                             ::  a typesystem hack
+  |*  sem/*                                             ::  a spansystem hack
   |=  cax/calx
   ?+  sem  !!
     $hood  ?>(?=($hood -.cax) r.cax)
@@ -895,7 +895,7 @@
       |=  {cof/cafe suh/vase yom/(list (pair wing vase))}
       ^-  (bolt vase)
       %+  cool  =<  |.(leaf+"ford: keel {<(murn yom +)>}")
-                |=  {a/wing b/type *}
+                |=  {a/wing b/span *}
                 =+  c=p:(slap suh wing+a)
                 ?:  (~(nest ut c) | b)  ~
                 (some [a c b])
@@ -1047,10 +1047,10 @@
       ^-  (bolt vase)
       ((lake for) cof [%noun som])
     ::
-    ++  lane                                            ::  type infer
-      |=  {cof/cafe typ/type gen/twig}
+    ++  lane                                            ::  span infer
+      |=  {cof/cafe typ/span gen/twig}
       %+  (cowl cof)  (mule |.((~(play ut typ) gen)))
-      |=(ref/type ref)
+      |=(ref/span ref)
     ::
     ++  lash                                            ::  filter at beam
       |*  {cof/cafe bem/beam fun/(burg knot (unit))}
@@ -1243,10 +1243,10 @@
       ^$(cof cof, for i.yaw, yaw t.yaw, vax yed)
     ::
     ++  mail                                            ::  cached mint
-      |=  {cof/cafe sut/type gen/twig}
-      ^-  (bolt (pair type nock))
+      |=  {cof/cafe sut/span gen/twig}
+      ^-  (bolt (pair span nock))
       %+  (clef %slim)  (fine cof sut gen)
-      |=  {cof/cafe sut/type gen/twig}
+      |=  {cof/cafe sut/span gen/twig}
       =+  puz=(mule |.((~(mint ut sut) [%noun gen])))
       ?-  -.puz
         $|  (flaw cof p.puz)
@@ -1257,7 +1257,7 @@
       |=  {cof/cafe vax/vase gen/twig}
       ^-  (bolt vase)
       %+  cope  (mail cof p.vax gen)
-      |=  {cof/cafe typ/type fol/nock}
+      |=  {cof/cafe typ/span fol/nock}
       %+  (coup cof)  (mock [q.vax fol] (mole (slod save)))
       |=(val/* `vase`[typ val])
     ::
@@ -1434,10 +1434,10 @@
       ==
     ::
     ++  malt                                            ::  cached slit
-      |=  {cof/cafe gat/type sam/type}
-      ^-  (bolt type)
+      |=  {cof/cafe gat/span sam/span}
+      ^-  (bolt span)
       %+  (clef %slit)  (fine cof gat sam)
-      |=  {cof/cafe gat/type sam/type}
+      |=  {cof/cafe gat/span sam/span}
       %+  cool  |.(%.(%have ~(dunk ut sam)))
       %+  cool  |.(%.(%want ~(dunk ut (~(peek ut gat) %free 6))))
       =+  top=(mule |.((slit gat sam)))
@@ -1450,7 +1450,7 @@
       |=  {cof/cafe gat/vase sam/vase}
       ^-  (bolt vase)
       %+  cope  (malt cof p.gat p.sam)
-      |=  {cof/cafe typ/type}
+      |=  {cof/cafe typ/span}
       %+  (coup cof)  (mong [q.gat q.sam] (mole (slod save)))
       |=(val/* `vase`[typ val])
     ::
@@ -1626,7 +1626,7 @@
           %+  cope  (maim cof bax [%cnbc p.hon])
           |=  {cof/cafe tug/vase}
           ?.  (~(nest ut p.tug) | p.vax)
-            (flaw cof [%leaf "type error: {<p.hon>} {<q.hon>}"]~)
+            (flaw cof [%leaf "span error: {<p.hon>} {<q.hon>}"]~)
           (fine cof [p.tug q.vax])
         ::
             $toy  (cope (cope (make cof %boil p.hon how ~) furl) feel)
@@ -1768,14 +1768,14 @@
         |=  {cof/cafe cay/cage coy/cage}  ^-  (bolt gage)
         ?:  ?=(?($hoon $hook) p.cay)
           ?.  ?=($txt-diff p.coy)
-            (flaw cof leaf+"{<p.cay>} mark with bad diff type: {<p.coy>}" ~)
+            (flaw cof leaf+"{<p.cay>} mark with bad diff span: {<p.coy>}" ~)
           =+  txt=((soft @t) q.q.cay)
           ?~  txt
             (flaw cof leaf+"{<p.cay>} mark on bad data" ~)
           =+  dif=((soft (urge cord)) q.q.coy)
           ?~  dif
             =-  (flaw cof leaf+"{<p.cay>} data with bad diff" -)
-            [>type=p.q.coy< >want=p:!>(*(urge cord))< ~]
+            [>span=p.q.coy< >want=p:!>(*(urge cord))< ~]
           =+  pac=(role (lurk (lore (cat 3 u.txt '\0a')) u.dif))
           (fine cof %& p.cay [%atom %t] (end 3 (dec (met 3 pac)) pac))
         ::
diff --git a/arvo/gall.hoon b/arvo/gall.hoon
index a794a5236..b2cbdff22 100644
--- a/arvo/gall.hoon
+++ b/arvo/gall.hoon
@@ -25,7 +25,7 @@
       {$hiss p/mark q/cage}
   ==                                                    ::
 ++  cove  (pair bone (mold cote cuft))                  ::  internal move
-++  move  {p/duct q/(mold note-arvo gift-arvo)}        ::  typed move
+++  move  {p/duct q/(mold note-arvo gift-arvo)}         ::  typed move
 --                                                      ::
 |%  ::::::::::::::::::::::::::::::::::::::::::::::::::::::    %gall state
     ::::::::::::::::::::::::::::::::::::::::::::::::::::::
diff --git a/arvo/hoon.hoon b/arvo/hoon.hoon
index fb5e353bd..98c769e72 100644
--- a/arvo/hoon.hoon
+++ b/arvo/hoon.hoon
@@ -24,7 +24,7 @@
     +
   ~
 |%                                                      ::
-++  abel  typo                                          ::  original sin: type
+++  abel  typo                                          ::  original sin: span
 ++  ache  |*  {a/$+(* *) b/$+(* *)}                     ::  either a or b
           $%({$| p/b} {$& p/a})                         ::    b default
 ++  axis  @                                             ::  tree address
@@ -60,8 +60,8 @@
               {ven/term pro/term ver/@ kel/@}           ::  all of the above
           ==                                            ::
 ++  clue  {p/chum q/nock r/(list (pair term nock))}     ::  battery definition
-++  coil  $:  p/?($gold $iron $lead $zinc)              ::  core type
-              q/type                                    ::
+++  coil  $:  p/?($gold $iron $lead $zinc)              ::  core span
+              q/span                                    ::
               r/{p/?($~ ^) q/(map term foot)}           ::
           ==                                            ::
 ++  coin  $%  {$$ p/dime}                               ::
@@ -130,28 +130,28 @@
 ++  pont  %+  each                                      ::  new pull result
             %+  pair                                    ::  normal
               vein                                      ::  wing trace
-            $%  {$& p/type}                             ::  leg
-                {$| p/axis q/(set {p/type q/foot})}     ::  arm
+            $%  {$& p/span}                             ::  leg
+                {$| p/axis q/(set {p/span q/foot})}     ::  arm
             ==                                          ::
           %+  each                                      ::  abnormal
             @ud                                         ::  unmatched, skips
-          (pair type nock)                              ::  functional
+          (pair span nock)                              ::  functional
 ++  port  $:  p/axis                                    ::
               $=  q                                     ::
-              $%  {$& p/type}                           ::
-                  {$| p/axis q/(list {p/type q/foot})}  ::
+              $%  {$& p/span}                           ::
+                  {$| p/axis q/(list {p/span q/foot})}  ::
               ==                                        ::
           ==                                            ::
 ++  post  $:  p/axis                                    ::
               $=  q                                     ::
-              $%  {$0 p/type}                           ::
-                  {$1 p/axis q/(list {p/type q/foot})}  ::
-                  {$2 p/twin q/type}                    ::
+              $%  {$0 p/span}                           ::
+                  {$1 p/axis q/(list {p/span q/foot})}  ::
+                  {$2 p/twin q/span}                    ::
               ==                                        ::
           ==                                            ::
 ++  prop  $:  p/axis                                    ::
               $=  q                                     ::
-              {p/?($~ axis) q/(list {p/type q/foot})}   ::
+              {p/?($~ axis) q/(list {p/span q/foot})}   ::
           ==                                            ::
 ++  qual  |*  {a/$+(* *) b/$+(* *) c/$+(* *) d/$+(* *)} ::  just a quadruple
           {p/a q/b r/c s/d}                             ::
@@ -181,7 +181,7 @@
               {$| p/(unit term) q/twig}                 ::  named wing
           ==                                            ::
 ++  tile  $^  {p/tile q/tile}                           ::  ordered pair
-          $%  {$axil p/base}                            ::  base type
+          $%  {$axil p/base}                            ::  base span
               {$bark p/term q/tile}                     ::  name
               {$bush p/tile q/tile}                     ::  pair+tag
               {$deet p/spot q/tile}                     ::  set debug
@@ -275,9 +275,9 @@
     {$dttr p/twig q/twig}                               ::  nock p w+ formula q
     {$dtts p/twig q/twig}                               ::  nock 5 equality test
     {$dtwt p/twig}                                      ::  nock 3 cell test
-  ::                                            ::::::  type conversion
+  ::                                            ::::::  span conversion
     {$ktbr p/twig}                                      ::  %gold core to %iron
-    {$ktdt p/twig q/twig}                               ::  cast q to type (p q)
+    {$ktdt p/twig q/twig}                               ::  cast q to span (p q)
     {$ktls p/twig q/twig}                               ::  cast q to p, verify
     {$kthp p/twig q/twig}                               ::  cast q to icon of p
     {$ktpm p/twig}                                      ::  %gold core to %zinc
@@ -296,7 +296,7 @@
     {$sgpm p/@ud q/twig r/twig}                         ::  print q w+priority
     {$sgts p/twig q/twig}                               ::  avoid duplication
     {$sgwt p/@ud q/twig r/twig s/twig}                  ::  hint iff q is yes
-    {$sgzp p/twig q/twig}                               ::  type in stacktrace
+    {$sgzp p/twig q/twig}                               ::  span in stacktrace
   ::                                            ::::::  miscellaneous
     {$smcl p/twig q/(list twig)}                        ::  binary to n-ary
     {$smsg p/twig q/(list twig)}                        ::  gonads
@@ -304,7 +304,7 @@
   ::                                            ::::::  compositions
     {$tsbr p/twig q/twig}                               ::  push bunt: ++(*p q)
     {$tscl p/(list (pair wing twig)) q/twig}            ::  p changes then q
-    {$tscn p/twig q/twig r/twig}                        ::  typed variable
+    {$tscn p/twig q/twig r/twig}                        ::  spand variable
     {$tsdt p/wing q/twig r/twig}                        ::  r with p set to q
     {$tsgl p/twig q/twig}                               ::  +>(q p)
     {$tshp p/twig q/twig}                               ::  flip push: ++(q p)
@@ -328,9 +328,9 @@
     {$wtts p/twig q/wing}                               ::  if q is in p
     {$wtzp p/twig}                                      ::  logical NOT
   ::                                            ::::::  special
-    {$zpcm p/twig q/twig}                               ::  q twig with p type
+    {$zpcm p/twig q/twig}                               ::  q twig with p span
     {$zpgr p/twig}                                      ::  vase w+ value p
-    {$zpsm p/twig q/twig}                               ::  [type noun] pair
+    {$zpsm p/twig q/twig}                               ::  [span noun] pair
     {$zpts p/twig}                                      ::  Nock formula of p
     {$zpwt p/$@(p/@ {p/@ q/@}) q/twig}                  ::  restrict hoon vers.
     {$zpzp $~}                                          ::  always crash
@@ -356,13 +356,13 @@
                   $void                                 ::  no noun
               ==                                        ::
           $%  {$atom p/term}                            ::  number and format
-              {$bull p/twin q/type}                     ::  alias
-              {$cell p/type q/type}                     ::  ordered pair
-              {$core p/type q/coil}                     ::  object
-              {$cube p/* q/type}                        ::  constant
-              {$face p/term q/type}                     ::  name
-              {$fork p/type q/type}                     ::  union
-              {$hold p/(list {p/type q/twig})}          ::  lazy evaluation
+              {$bull p/twin q/span}                     ::  alias
+              {$cell p/span q/span}                     ::  ordered pair
+              {$core p/span q/coil}                     ::  object
+              {$cube p/* q/span}                        ::  constant
+              {$face p/term q/span}                     ::  name
+              {$fork p/span q/span}                     ::  union
+              {$hold p/(list {p/span q/twig})}          ::  lazy evaluation
           ==                                            ::
 ++  tone  $%  {$0 p/*}                                  ::  success
               {$1 p/(list)}                             ::  blocks
@@ -376,20 +376,8 @@
               {$1 p/(list)}                             ::
               {$2 p/(list {@ta *})}                     ::
           ==                                            ::
-++  twin  {p/term q/wing r/axis s/type}                 ::  alias info
-++  type  $@  $?  $noun                                 ::  any nouns
-                  $void                                 ::  no noun
-              ==                                        ::
-          $%  {$atom p/term}                            ::  number and format
-              {$bull p/twin q/type}                     ::  alias
-              {$cell p/type q/type}                     ::  ordered pair
-              {$core p/type q/coil}                     ::  object
-              {$cube p/* q/type}                        ::  constant
-              {$face p/term q/type}                     ::  name
-              {$fork p/type q/type}                     ::  union
-              {$hold p/(list {p/type q/twig})}          ::  lazy evaluation
-          ==                                            ::
-++  typo  type                                          ::  old type
+++  twin  {p/term q/wing r/axis s/span}                 ::  alias info
+++  typo  span                                          ::  old span
 ++  udal                                                ::  atomic change (%b)
           $:  p/@ud                                     ::  blockwidth
               q/(list {p/@ud q/(unit {p/@ q/@})})       ::  indels
@@ -423,16 +411,16 @@
               {$2 p/axis q/udon}                        ::  mutate!
           ==                                            ::
 ++  urge  |*(a/$+(* *) (list (unce a)))                 ::  list change
-++  vase  {p/type q/*}                                  ::  type-value pair
+++  vase  {p/span q/*}                                  ::  span-value pair
 ++  vise  {p/typo q/*}                                  ::  old vase
 ++  wall  (list tape)                                   ::  text lines (no \n)
 ++  wain  (list cord)                                   ::  text lines (no \n)
 ++  vein  (list (unit axis))                            ::  search trace
 ++  wing  (list limb)                                   ::  search path
-++  wine                                                ::  printable type
+++  wine                                                ::  printable span
           $@  $?  $noun                                 ::
                   $path                                 ::
-                  $type                                 ::
+                  $span                                 ::
                   $void                                 ::
                   $wall                                 ::
                   $wool                                 ::
@@ -452,8 +440,8 @@
 ++  wonk  |*(veq/edge ?~(q.veq !! p.u.q.veq))           ::
 ++  worm                                                ::  compiler cache
   $:  nes/(set ^)                                       ::  ++nest
-      pay/(map (pair type twig) type)                   ::  ++play
-      mit/(map (pair type twig) (pair type nock))       ::  ++mint
+      pay/(map (pair span twig) span)                   ::  ++play
+      mit/(map (pair span twig) (pair span nock))       ::  ++mint
   ==                                                    ::
 ::                                                      ::
 ++  map  |*  {a/$+(* *) b/$+(* *)}                      ::  associative tree
@@ -2266,7 +2254,7 @@
 ++  cork  |*({a/_|=(* **) b/gate} (corl b a))           ::  compose forward
 ++  corl                                                ::  compose backwards
   |*  {a/gate b/_|=(* **)}
-  =<  +:|.((a (b)))      ::  type check
+  =<  +:|.((a (b)))      ::  span check
   |*  c/_+<.b
   (a (b c))
 ::
@@ -2283,14 +2271,14 @@
 ++  gulf                                                ::  range list
   |=({a/@ b/@} `(list @)`?:(=(a +(b)) ~ [a $(a +(a))]))
 ::
-++  hard                                                ::  force coerce to type
+++  hard                                                ::  force coerce to span
   |*  han/$+(* *)
   |=  fud/*  ^-  han
   ~|  %hard
   =+  gol=(han fud)
   ?>(=(gol fud) gol)
 ::
-++  soft                                                ::  maybe coerce to type
+++  soft                                                ::  maybe coerce to span
   |*  han/$+(* *)
   |=  fud/*  ^-  (unit han)
   =+  gol=(han fud)
@@ -4721,7 +4709,7 @@
     [%2 ~]
   (mink [[-.gat [sam +>.gat]] -.gat] sky)
 ::
-++  mule                                                ::  typed virtual
+++  mule                                                ::  spand virtual
   ~/  %mule
   |*  taq/_|.(**)
   =+  mud=(mute taq)
@@ -4730,7 +4718,7 @@
     $|  [%| p=p.mud]
   ==
 ::
-++  mute                                                ::  untyped virtual
+++  mute                                                ::  unspand virtual
   |=  taq/_^?(|.(**))
   ^-  (each * (list tank))
   =+  ton=(mock [taq 9 2 0 1] |=(* ~))
@@ -6119,7 +6107,7 @@
 ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
 ::                section 2eZ, OLD rendering (kill me)  ::
 ::
-++  show                            ::  XX deprecated, use type
+++  show                            ::  XX deprecated, use span
   |=  vem/*
   |^  ^-  tank
       ?:  ?=(@ vem)
@@ -6289,49 +6277,49 @@
 ::  ::::::::::::::::::::::::::::::::::::::::::::::::::::::
 ::                section 2fA, miscellaneous funs       ::
 ::                                                      ::
-++  bull                                                ::  make %bull type
-  |=  {bid/twin der/type}
-  ^-  type
+++  bull                                                ::  make %bull span
+  |=  {bid/twin der/span}
+  ^-  span
   ?:(|(=(%void der) =(%void s.bid)) %void [%bull bid der])
 ::
 ++  cain  |=(vax/vase (sell vax))                       ::  $+(vase tank) for />
-++  cell                                                ::  make %cell type
+++  cell                                                ::  make %cell span
   ~/  %cell
-  |=  {hed/type tal/type}
-  ^-  type
+  |=  {hed/span tal/span}
+  ^-  span
   ?:(=(%void hed) %void ?:(=(%void tal) %void [%cell hed tal]))
 ::
-++  core                                                ::  make %core type
+++  core                                                ::  make %core span
   ~/  %core
-  |=  {pac/type con/coil}
-  ^-  type
+  |=  {pac/span con/coil}
+  ^-  span
   ?:(=(%void pac) %void [%core pac con])
 ::
-++  cube                                                ::  make %cube type
+++  cube                                                ::  make %cube span
   ~/  %cube
-  |=  {dil/* goq/type}
-  ^-  type
+  |=  {dil/* goq/span}
+  ^-  span
   ?:  =(%void goq)
     %void
   [%cube dil goq]
 ::
-++  face                                                ::  make %face type
+++  face                                                ::  make %face span
   ~/  %face
-  |=  {cog/term der/type}
-  ^-  type
+  |=  {cog/term der/span}
+  ^-  span
   ?:  =(%void der)
     %void
   [%face cog der]
 ::
-++  bool  ^-(type [%fork [%cube 0 %atom %f] [%cube 1 %atom %f]])  :: -:!>(*?)
+++  bool  ^-(span [%fork [%cube 0 %atom %f] [%cube 1 %atom %f]])  :: -:!>(*?)
 ++  flay
   ~/  %flay
   |=  pok/port
-  ^-  {p/axis q/type}
+  ^-  {p/axis q/span}
   :-  p.pok
   ?-  -.q.pok
     $&  p.q.pok
-    $|  (roll q.q.pok =+([p=[p=*type q=*foot] q=`type`%void] |.((fork p.p q))))
+    $|  (roll q.q.pok =+([p=[p=*span q=*foot] q=`span`%void] |.((fork p.p q))))
   ==
 ::
 ++  flee
@@ -6352,10 +6340,10 @@
     $|  [p.pok [p.q.pok q.q.pok]]
   ==
 ::
-++  fork                                                ::  make %fork type
+++  fork                                                ::  make %fork span
   ~/  %fork
-  |=  {hoz/type bur/type}
-  ^-  type
+  |=  {hoz/span bur/span}
+  ^-  span
   ?:  =(hoz bur)
     hoz
   ?:  =(%void hoz)
@@ -6561,7 +6549,7 @@
   |=  bon/path
   (rain bon ((hard @t) .^(%cx (weld bon `path`[%hoon ~]))))
 ::
-++  seem  |=(toy/typo `type`toy)                        ::  promote typo
+++  seem  |=(toy/typo `span`toy)                        ::  promote typo
 ++  seer  |=(vix/vise `vase`vix)                        ::  promote vise
 ++  sell                                                ::  tank pretty-print
   |=  vax/vase  ^-  tank
@@ -6574,7 +6562,7 @@
 ::
 ++  slam                                                ::  slam a gate
   |=  {gat/vase sam/vase}  ^-  vase
-  =+  :-  ^=  typ  ^-  type
+  =+  :-  ^=  typ  ^-  span
           [%cell p.gat p.sam]
       ^=  gen  ^-  twig
       [%cncl [~ 2] [~ 3]]
@@ -6585,17 +6573,17 @@
   |=  old/vise  ^-  vase
   old
 ::
-++  slit                                                ::  type of slam
-  |=  {gat/type sam/type}
+++  slit                                                ::  span of slam
+  |=  {gat/span sam/span}
   ?>  (~(nest ut (~(peek ut gat) %free 6)) & sam)
   (~(play ut [%cell gat sam]) [%cncl [~ 2] [~ 3]])
 ::
-++  slym                                                ::  slam w+o sample-type
+++  slym                                                ::  slam w+o sample-span
   |=  {gat/vase sam/*}  ^-  vase
   (slap gat(+<.q sam) [%limb %$])
 ::
 ++  slap
-  |=  {vax/vase gen/twig}  ^-  vase                     ::  untyped vase .*
+  |=  {vax/vase gen/twig}  ^-  vase                     ::  unspand vase .*
   =+  gun=(~(mint ut p.vax) %noun gen)
   [p.gun .*(q.vax q.gun)]
 ::
@@ -6604,11 +6592,11 @@
   ^-  vase
   [[%cell p.hed p.tal] [q.hed q.tal]]
 ::
-++  skol                                                ::  $+(type tank) for ~!
-  |=  typ/type  ^-  tank
+++  skol                                                ::  $+(span tank) for ~!
+  |=  typ/span  ^-  tank
   ~(duck ut typ)
 ::
-++  spec                                                ::  reconstruct type
+++  spec                                                ::  reconstruct span
   |=  vax/vase
   ^-  vase
   :_  q.vax
@@ -6629,11 +6617,11 @@
   `[(~(peek ut p.vax) %free axe) .*(q.vax [0 axe])]
 ::
 ++  slab                                                ::  test if contains
-  |=  {cog/@tas typ/type}
+  |=  {cog/@tas typ/span}
   =(& -:(~(feel ut typ) %free [cog ~]))
 ::
 ++  slob                                                ::  superficial arm
-  |=  {cog/@tas typ/type}
+  |=  {cog/@tas typ/span}
   ^-  ?
   ?+  typ  |
     {$hold *}  $(typ ~(repo ut typ))
@@ -6641,7 +6629,7 @@
   ==
 ::
 ++  sloe                                                ::  get arms in core
-  |=  typ/type
+  |=  typ/span
   ^-  (list term)
   ?+    typ  ~
       {$hold *}  $(typ ~(repo ut typ))
@@ -6659,9 +6647,9 @@
 ::
 ++  wa  !:                                              ::  cached compile
   |_  worm
-  ++  nell  |=(ref/type (nest [%cell %noun %noun] ref)) ::  nest in cell
+  ++  nell  |=(ref/span (nest [%cell %noun %noun] ref)) ::  nest in cell
   ++  nest                                              ::  nest:ut
-    |=  {sut/type ref/type}
+    |=  {sut/span ref/span}
     ^-  {? worm}
     ?:  (~(has in nes) [sut ref])  [& +>+<]
     ?.  (~(nest ut sut) | ref)
@@ -6669,11 +6657,11 @@
       [| +>+<]
     [& +>+<(nes (~(put in nes) [sut ref]))]
   ::
-  ++  nets                                              ::  typeless nest
-    |=  {sut/type ref/*}
+  ++  nets                                              ::  spanless nest
+    |=  {sut/span ref/*}
     ^-  {? worm}
     ?:  (~(has in nes) [sut ref])  [& +>+<]
-    =+  gat=|=({a/type b/type} (~(nest ut a) | b))
+    =+  gat=|=({a/span b/span} (~(nest ut a) | b))
     ?.  (? .*(gat(+< [sut ref]) -.gat))
       ::  ~&  %nets-failed
       ::  =+  tag=`*`skol
@@ -6687,16 +6675,16 @@
     [& +>+<.$(nes (~(put in nes) [sut ref]))]
   ::
   ++  play                                              ::  play:ut
-    |=  {sut/type gen/twig}
-    ^-  {type worm}
+    |=  {sut/span gen/twig}
+    ^-  {span worm}
     =+  old=(~(get by pay) [sut gen])
     ?^  old  [u.old +>+<.$]
     =+  new=(~(play ut sut) gen)
     [new +>+<.$(pay (~(put by pay) [sut gen] new))]
   ::
   ++  mint                                              ::  mint:ut to noun
-    |=  {sut/type gen/twig}
-    ^-  {(pair type nock) worm}
+    |=  {sut/span gen/twig}
+    ^-  {(pair span nock) worm}
     =+  old=(~(get by mit) [sut gen])
     ?^  old  [u.old +>+<.$]
     =+  new=(~(mint ut sut) %noun gen)
@@ -7386,15 +7374,15 @@
       %tock   tock
       %wrap   wrap
     ==
-  =+  :*  fan=*(set {type twig})
-          rib=*(set {type type twig})
+  =+  :*  fan=*(set {span twig})
+          rib=*(set {span span twig})
           vet=`?`&
           fab=`?`&
       ==
-  =+  sut=`type`%noun
+  =+  sut=`span`%noun
   |%
   ++  burn
-    =+  gil=*(set type)
+    =+  gil=*(set span)
     |-  ^-  *
     ?-    sut
         {$atom *}   0
@@ -7405,7 +7393,7 @@
         {$face *}   $(sut repo)
         {$fork *}   $(sut p.sut)
         {$hold *}   ?:  (~(has in gil) sut)
-                      ~_  (dunk %type)
+                      ~_  (dunk %span)
                       ~|(%burn-loop !!)
                     $(sut repo, gil (~(put in gil) sut))
         $noun       0
@@ -7415,12 +7403,12 @@
   ++  busk
     ~/  %busk
     |=  {cog/term hyp/wing}
-    ^-  type
+    ^-  span
     (bull [cog hyp (seep %both hyp)] sut)
   ::
   ++  conk
     |=  got/toga
-    ^-  type
+    ^-  span
     ?@  got  [%face got sut]
     ?-  -.got
       $0  sut
@@ -7433,12 +7421,12 @@
   ::
   ++  crop
     ~/  %crop
-    |=  ref/type
-    =+  bix=*(set {type type})
+    |=  ref/span
+    =+  bix=*(set {span span})
     =<  dext
     |%
     ++  dext
-      ^-  type
+      ^-  span
       ~|  %crop-dext
       ::  ~_  (dunk 'dext: sut')
       ::  ~_  (dunk(sut ref) 'dext: ref')
@@ -7491,7 +7479,7 @@
       ==
     ::
     ++  sint
-      ^-  type
+      ^-  span
       ?-    ref
         {$core *}  sut
         {$cube *}  sut
@@ -7503,9 +7491,9 @@
     --
   ::
   ++  cool
-    |=  {pol/? hyp/wing ref/type}
-    ^-  type
-    q:(tuck %both hyp |=(a/type ?:(pol (fuse(sut a) ref) (crop(sut a) ref))))
+    |=  {pol/? hyp/wing ref/span}
+    ^-  span
+    q:(tuck %both hyp |=(a/span ?:(pol (fuse(sut a) ref) (crop(sut a) ref))))
   ::
   ++  dash
       |=  {mil/tape lim/char}  ^-  tape
@@ -7536,7 +7524,7 @@
       ?-    q.ham
           $noun      :_(gid [%leaf '*' ~])
           $path      :_(gid [%leaf '/' ~])
-          $type      :_(gid [%leaf '#' 't' ~]) 
+          $span      :_(gid [%leaf '#' 't' ~]) 
           $void      :_(gid [%leaf '#' ~])
           $wool      :_(gid [%leaf '*' '"' '"' ~])
           $wall      :_(gid [%leaf '*' '\'' '\'' ~])
@@ -7620,8 +7608,8 @@
       ?>  ?=(@ -.lum)
       [[%leaf (rip 3 -.lum)] $(lum +.lum)]
     ::
-        $type
-      =+  cis=((hard tank) .*(.(sut lum) !=(duck)))     ::  type bypass
+        $span
+      =+  cis=((hard tank) .*(.(sut lum) !=(duck)))     ::  span bypass
       :^  ~   %palm
         [~ ~ ~ ~]
       [[%leaf '#' 't' '/' ~] cis ~]
@@ -7832,13 +7820,13 @@
   ::
   ++  dole
     ^-  calf
-    =+  gil=*(set type)
-    =+  dex=[p=*(map type @) q=*(map @ wine)]
+    =+  gil=*(set span)
+    =+  dex=[p=*(map span @) q=*(map @ wine)]
     =<  [q.p q]
-    |-  ^-  {p/{p/(map type @) q/(map @ wine)} q/wine}
+    |-  ^-  {p/{p/(map span @) q/(map @ wine)} q/wine}
     =-  [p.tez (doge q.p.tez q.tez)]
     ^=  tez
-    ^-  {p/{p/(map type @) q/(map @ wine)} q/wine}
+    ^-  {p/{p/(map span @) q/(map @ wine)} q/wine}
     ?-    sut
         $noun      [dex sut]
         $void      [dex sut]
@@ -7896,7 +7884,7 @@
     ::
         {$fork *}
       ?:  =(p.sut fork+[cube+[%noun atom+%tas]]^[cube+[%void atom+%tas]])
-        [dex %type]                    ::  XX  proper print
+        [dex %span]                    ::  XX  proper print
       =+  hin=$(sut p.sut)
       =+  yon=$(dex p.hin, sut q.sut)
       :-  p.yon
@@ -7953,22 +7941,22 @@
           :*  axe=`axis`1
               lon=p.p.mor
               heg=?^(i.hyp i.hyp [%| p=0 q=(some i.hyp)])
-              ^-  ref/type
+              ^-  ref/span
               ?-  -.q.p.mor
                 $&  p.q.p.mor
-              ::%|  hold+(turn (~(tap by q.q.mor) |=({a/type b/foot} [a ~ 1])))
+              ::%|  hold+(turn (~(tap by q.q.mor) |=({a/span b/foot} [a ~ 1])))
                 $|  ::  
                     ::  XX  don't know why we're "firing" here; test code above
                     ::
                     %-  fire
                     %+  turn  (~(tap in q.q.p.mor))
-                    |=  {a/type b/foot}
+                    |=  {a/span b/foot}
                     [a [%ash ~ 1]]
               ==
           ==
       ?:  ?=($& -.heg)
         [%& [`p.heg lon] %& (peek(sut ref) way p.heg)]
-      =|  gil/(set type)
+      =|  gil/(set span)
       =<  $
       |%  ++  $
             ^-  pont
@@ -8057,14 +8045,14 @@
   ::
   ++  fire
     ~/  %fire
-    |=  hag/(list {p/type q/foot})
-    ^-  type
+    |=  hag/(list {p/span q/foot})
+    ^-  span
     ?:  ?=({{* {$elm $~ $1}} $~} hag)
       p.i.hag
     :-  %hold
     %+  turn
       hag.$
-    |=  {p/type q/foot}
+    |=  {p/span q/foot}
     ?.  ?=({$core *} p)
       ~|(%fire-core !!)
     =+  dox=[%core q.q.p q.p]
@@ -8086,7 +8074,7 @@
   ++  firm
     ~/  %firm
     |=  dib/*
-    =+  bix=*(set {type *})
+    =+  bix=*(set {span *})
     |-  ^-  ?
     ?-    sut
         {$atom *}  !.?(dib)
@@ -8113,7 +8101,7 @@
   ++  fish
     ~/  %fish
     |=  axe/axis
-    =+  vot=*(set type)
+    =+  vot=*(set span)
     |-  ^-  nock
     ?-  sut
         $void       [%1 1]
@@ -8138,9 +8126,9 @@
   ::
   ++  fuse
     ~/  %fuse
-    |=  ref/type
-    =+  bix=*(set {type type})
-    |-  ^-  type
+    |=  ref/span
+    =+  bix=*(set {span span})
+    |-  ^-  span
     ?:  ?|(=(sut ref) =(%noun ref))
       sut
     ?-    sut
@@ -8177,7 +8165,7 @@
   ::
   ++  gain
     ~/  %gain
-    |=  gen/twig  ^-  type
+    |=  gen/twig  ^-  span
     (chip & gen)
   ::
   ++  harp
@@ -8199,12 +8187,12 @@
   ::
   ++  lose
     ~/  %lose
-    |=  gen/twig  ^-  type
+    |=  gen/twig  ^-  span
     (chip | gen)
   ::
   ++  chip
     ~/  %chip
-    |=  {how/? gen/twig}  ^-  type
+    |=  {how/? gen/twig}  ^-  span
     ?:  ?=({$wtts *} gen)  
       (cool how q.gen (play ~(bunt al [%herb p.gen])))  
     ?:  ?&(how ?=({$wtpm *} gen))
@@ -8216,9 +8204,9 @@
   ::
   ++  mint
     ~/  %mint
-    |=  {gol/type gen/twig}
-    ^-  {p/type q/nock}
-    |^  ^-  {p/type q/nock}
+    |=  {gol/span gen/twig}
+    ^-  {p/span q/nock}
+    |^  ^-  {p/span q/nock}
     ?:  ?&(=(%void sut) !?=({$dbug *} gen))
       ?.  |(!vet ?=({$lost *} gen) ?=({$zpzp *} gen))
         ~|(%mint-vain !!)
@@ -8238,7 +8226,7 @@
       =-  [(nice p.yom) ?:(=(0 p.q.lar) q.yom [%9 p.q.lar q.yom])]
       ^=  yom
       =+  hej=*(list {p/axis q/nock})
-      |-  ^-  {p/type q/nock}
+      |-  ^-  {p/span q/nock}
       ?~  mew
         [(fire q.q.lar) (hike p.lar hej)]
       =+  zil=^$(gen q.i.mew, gol %noun)
@@ -8335,14 +8323,14 @@
     ==
     ::
     ++  nice
-      |=  typ/type
+      |=  typ/span
       ~|  %mint-nice
       ?>  ?|(!vet (nest(sut gol) & typ))
       typ
     ::
     ++  grow
       |=  {mel/?($gold $iron $lead $zinc) ruf/twig dab/(map term foot)}
-      ^-  {p/type q/nock}
+      ^-  {p/span q/nock}
       =+  dan=^$(gen ruf, gol %noun)
       =+  toc=(core p.dan [%gold p.dan [~ dab]])
       =+  dez=(harp(sut toc) dab)
@@ -8351,7 +8339,7 @@
     --
   ::
   ++  moot
-    =+  gil=*(set type)
+    =+  gil=*(set span)
     |-  ^-  ?
     ?-  sut
       {$atom *}  |
@@ -8368,12 +8356,12 @@
   ::
   ++  mull
     ~/  %mull
-    |=  {gol/type dox/type gen/twig}
+    |=  {gol/span dox/span gen/twig}
     ^-  ?
     ?.  vet
       &
     =<  &
-    |^  ^-  {p/type q/type}
+    |^  ^-  {p/span q/span}
     ?:  =(%void sut)
       ~|(%mull-none !!)
     ?-    gen
@@ -8392,7 +8380,7 @@
       =+  mew=(snub q.gen)
       =-  [(nice (fire p.yom)) (fire(vet |) q.yom)]
       ^=  yom
-      |-  ^-  {p/(list {p/type q/foot}) q/(list {p/type q/foot})}
+      |-  ^-  {p/(list {p/span q/foot}) q/(list {p/span q/foot})}
       ?~  mew
         [q.q.lar q.q.vug]
       =+  zil=^$(gen q.i.mew, gol %noun)
@@ -8445,14 +8433,14 @@
     ::
         {$wtcl *}
       =+  nor=$(gen p.gen, gol bool)
-      =+  ^=  hiq  ^-  {p/type q/type}
+      =+  ^=  hiq  ^-  {p/span q/span}
           =+  fex=[p=(gain p.gen) q=(gain(sut dox) p.gen)]
           ?:  =(%void p.fex)
             [%void ?:(=(%void q.fex) %void ~|(%wtcl-z (play(sut q.fex) q.gen)))]
           ?:  =(%void q.fex)
             ~|(%mull-bonk-b !!)
           $(sut p.fex, dox q.fex, gen q.gen)
-      =+  ^=  ran  ^-  {p/type q/type}
+      =+  ^=  ran  ^-  {p/span q/span}
           =+  wux=[p=(lose p.gen) q=(lose(sut dox) p.gen)]
           ?:  =(%void p.wux)
             [%void ?:(=(%void q.wux) %void ~|(%wtcl-a (play(sut q.wux) r.gen)))]
@@ -8494,11 +8482,11 @@
     ==
     ::
     ++  beth
-      |=  typ/type
+      |=  typ/span
       [(nice typ) typ]
     ::
     ++  nice
-      |=  typ/type
+      |=  typ/span
       ::  ~_  (dunk(sut gol) 'need')
       ::  ~_  (dunk(sut typ) 'have')
       ~|  %mull-nice
@@ -8508,7 +8496,7 @@
     ++  grow
       |=  {mel/?($gold $iron $lead $zinc) ruf/twig dab/(map term foot)}
       ~|  %mull-grow
-      ^-  {p/type q/type}
+      ^-  {p/span q/span}
       =+  dan=^$(gen ruf, gol %noun)
       =+  ^=  toc  :-  p=(core p.dan [%gold p.dan [~ dab]])
                    q=(core q.dan [%gold q.dan [~ dab]])
@@ -8534,14 +8522,14 @@
       ==
     --
   ::
-  ++  meet  |=(ref/type &((nest | ref) (nest(sut ref) | sut)))
+  ++  meet  |=(ref/span &((nest | ref) (nest(sut ref) | sut)))
   ++  nest
     ~/  %nest
-    |=  {tel/? ref/type}
+    |=  {tel/? ref/span}
     ^-  ?
-    =|  $:  gem/(set {p/type q/type})                ::  prune ref
-            gul/(set {p/type q/type})                ::  assume match
-            meg/(set {p/type q/type})                ::  prune sut
+    =|  $:  gem/(set {p/span q/span})                ::  prune ref
+            gul/(set {p/span q/span})                ::  assume match
+            meg/(set {p/span q/span})                ::  prune sut
         ==
     =<  dext
     |%
@@ -8665,7 +8653,7 @@
           ?:  tel
             ::  ~_  (dunk %need)
             ::  ~_  (dunk(sut ref) %have)
-            ~|(%type-fail !!)
+            ~|(%span-fail !!)
           |
       ^=  tyn
       ?:  =(sut ref)  &
@@ -8720,12 +8708,12 @@
   ++  peek
     ~/  %peek
     |=  {way/?($read $rite $both $free) axe/axis}
-    ^-  type
+    ^-  span
     ?:  =(1 axe)
       sut
     =+  [now=(cap axe) lat=(mas axe)]
-    =+  gil=*(set type)
-    |-  ^-  type
+    =+  gil=*(set span)
+    |-  ^-  span
     ?-    sut
         {$atom *}   %void
         {$cell *}   ?:(=(2 now) ^$(sut p.sut, axe lat) ^$(sut q.sut, axe lat))
@@ -8751,7 +8739,7 @@
     ~/  %play
     =>  .(vet |)
     |=  gen/twig
-    ^-  type
+    ^-  span
     ?-  gen
       {^ *}      (cell $(gen p.gen) $(gen q.gen))
       {$brcn *}  (core sut %gold sut [[%0 0] p.gen])
@@ -8759,7 +8747,7 @@
                  =+  mew=(snub q.gen)
                  =+  rag=q.q.lar
                  %-  fire
-                 |-  ^-  (list {p/type q/foot})
+                 |-  ^-  (list {p/span q/foot})
                  ?~  mew
                    rag
                  $(mew t.mew, rag q:(tock p.i.mew ^$(gen q.i.mew) rag))
@@ -8799,7 +8787,7 @@
     ==
   ::
   ++  repo
-    ^-  type
+    ^-  span
     ?-  sut
       {$bull *}   q.sut
       {$core *}   [%cell %noun p.sut]
@@ -8812,18 +8800,18 @@
   ::
   ++  rest
     ~/  %rest
-    |=  leg/(list {p/type q/twig})
-    ^-  type
-    ?:  (lien leg |=({p/type q/twig} (~(has in fan) [p q])))
+    |=  leg/(list {p/span q/twig})
+    ^-  span
+    ?:  (lien leg |=({p/span q/twig} (~(has in fan) [p q])))
       ~|(%rest-loop !!)
     =>  .(fan (~(gas in fan) leg))
     %+  roll
       %-  %~  tap
             in
-          %-  ~(gas in *(set type))
-          (turn leg |=({p/type q/twig} (play(sut p) q)))
+          %-  ~(gas in *(set span))
+          (turn leg |=({p/span q/twig} (play(sut p) q)))
       ~
-    =+([p=*type q=`type`%void] |.((fork p q)))
+    =+([p=*span q=`span`%void] |.((fork p q)))
   ::
   ++  seek
     |=  {way/?($read $rite $both $free) hyp/wing}
@@ -8834,7 +8822,7 @@
     ::        $&  old
     ::        $|  
     ::      :^  p.old  %|  p.q.old
-    ::    (~(tap in (~(gas in *(set (pair type foot))) q.q.old)) ~)
+    ::    (~(tap in (~(gas in *(set (pair span foot))) q.q.old)) ~)
     ~|  [%seek-miss [way hyp] ~]
     =+  fid=(feel way hyp)
     ?.  ?=($& -.fid)
@@ -8850,7 +8838,7 @@
   ::
   ++  seep
     |=  {way/?($read $rite $both $free) hyp/wing}
-    ^-  {p/axis q/type}
+    ^-  {p/axis q/span}
     =+  zar=(seek way hyp)
     ?>(?=($& -.q.zar) [p.zar p.q.zar])
   ::
@@ -8873,16 +8861,16 @@
     ?~(vit 1 (peg $(vit t.vit) ?~(i.vit 1 u.i.vit)))
   ::
   ++  tuck
-    |=  {way/?($read $rite $both $free) hyp/wing duz/$+(type type)}
+    |=  {way/?($read $rite $both $free) hyp/wing duz/$+(span span)}
     ~|  [%tuck hyp]
-    ^-  (pair axis type)
+    ^-  (pair axis span)
     =+  ^-  vit/vein  (tech %rite hyp)
     :-  (tonk vit)
     =.  vit  (flop vit)
-    |-  ^-  type
+    |-  ^-  span
     ?~  vit  (duz sut)
     ?~  i.vit
-      |-  ^-  type
+      |-  ^-  span
       ?+  sut  !!
         {$bull *}  (bull p.sut ^$(vit t.vit, sut q.sut))
         {$cube *}  [%cube p.sut ^$(vit t.vit, sut q.sut)]
@@ -8890,8 +8878,8 @@
         {$fork *}  (fork $(sut p.sut) $(sut q.sut))
         {$hold *}  $(sut repo) 
       ==
-    =+  vil=*(set type)
-    |-  ^-  type
+    =+  vil=*(set span)
+    |-  ^-  span
     ?:  =(1 u.i.vit)
       ^$(vit t.vit)
     =+  [now lat]=(cap u.i.vit)^(mas u.i.vit)
@@ -8914,15 +8902,15 @@
     ==
   ::
   ++  tack
-    |=  {peh/wing mur/type}
-    (tuck %rite (flop peh) |=(type mur))
+    |=  {peh/wing mur/span}
+    (tuck %rite (flop peh) |=(span mur))
   ::
   ++  tock
-    |=  {peh/wing mur/type men/(list {p/type q/foot})}
-    ^-  {p/axis q/(list {p/type q/foot})}
+    |=  {peh/wing mur/span men/(list {p/span q/foot})}
+    ^-  {p/axis q/(list {p/span q/foot})}
     =-  [(need p.wib) q.wib]
     ^=  wib
-    |-  ^-  {p/(unit axis) q/(list {p/type q/foot})}
+    |-  ^-  {p/(unit axis) q/(list {p/span q/foot})}
     ?~  men
       [*(unit axis) ~]
     =+  geq=(tack(sut p.i.men) peh mur)
@@ -8932,12 +8920,12 @@
   ++  wrap
     ~/  %wrap
     |=  yoz/?($lead $iron $zinc)
-    ^-  type
+    ^-  span
     ?-  sut
       {$core *}  ?.(=(%gold p.q.sut) ~|(%wrap-metl !!) sut(p.q yoz))
       {$fork *}  (fork $(sut p.sut) $(sut q.sut))
       {$hold *}  $(sut repo)
-      *          ~|(%wrap-type !!)
+      *          ~|(%wrap-span !!)
     ==
   --
 ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
@@ -10135,9 +10123,9 @@
           $:  p/(unit (set monk))                       ::  can be read by
               q/(set monk)                              ::  caused or created by
           ==                                            ::
-++  curd  {p/@tas q/*}                                  ::  typeless card
+++  curd  {p/@tas q/*}                                  ::  spanless card
 ++  duct  (list wire)                                   ::  causal history
-++  hypo  |*(a/$+(* *) (pair type a))                   ::  type associated
+++  hypo  |*(a/$+(* *) (pair span a))                   ::  span associated
 ++  hobo  |*  a/$+(* *)                                 ::  kiss wrapper
           $?  $%  {$soft p/*}                           ::
               ==                                        ::
@@ -10157,7 +10145,7 @@
   $@  mark                                              ::  plain mark
   $%  {$tabl p/(list (pair marc marc))}                 ::  map
   ==                                                    ::
-++  mark  @tas                                          ::  content type
+++  mark  @tas                                          ::  content span
 ++  mash  |=(* (mass +<))                               ::  producing mass
 ++  mass  (pair cord (each noun (list mash)))           ::  memory usage
 ++  mill  (each vase milt)                              ::  vase+metavase
@@ -10172,21 +10160,21 @@
           ==                                            ::
 ++  muse  {p/@tas q/duct r/arvo}                        ::  sourced move
 ++  move  {p/duct q/arvo}                               ::  arvo move
-++  ovum  {p/wire q/curd}                               ::  typeless ovum
+++  ovum  {p/wire q/curd}                               ::  spanless ovum
 ++  pane  (list {p/@tas q/vase})                        ::  kernel modules
 ++  pone  (list {p/@tas q/vise})                        ::  kernel modules old
 ++  ship  @p                                            ::  network identity
 ++  sink  (trel bone ship path)                         ::  subscription
 ++  sled  $+  {(unit (set monk)) term beam}             ::  namespace function
           (unit (unit cage))                            ::
-++  slad  $+  {(unit (set monk)) term beam}             ::  undertyped
+++  slad  $+  {(unit (set monk)) term beam}             ::  underspand
           (unit (unit (cask)))                          ::
 ++  slut  $+(* (unit (unit)))                           ::  old namespace
 ++  vile                                                ::  reflexive constants
-          $:  typ/type                                  ::  -:!>(*type)
-              duc/type                                  ::  -:!>(*duct)
-              pah/type                                  ::  -:!>(*path)
-              mev/type                                  ::  -:!>([%meta *vase])
+          $:  typ/span                                  ::  -:!>(*span)
+              duc/span                                  ::  -:!>(*duct)
+              pah/span                                  ::  -:!>(*path)
+              mev/span                                  ::  -:!>([%meta *vase])
           ==                                            ::
 ++  wire  path                                          ::  event pretext
 ::::: hacks and tools
@@ -10300,10 +10288,10 @@
       ?.  hip  ~                                        ::  a vase is a cell
       =^  vax  p.sew  (~(slot wa p.sew) 2 tiv)          ::
       =^  hip  p.sew  (~(nest wa p.sew) typ.vil p.vax)  ::
-      ?.  hip  ~                                        ::  vase head is type
+      ?.  hip  ~                                        ::  vase head is span
       %-  biff                                          ::
       :_  |=(a/(pair milt worm) `[[%| p.a] q.a])        ::  milt to mill
-      =+  mut=(milt q.tiv)                              ::  card type, value
+      =+  mut=(milt q.tiv)                              ::  card span, value
       |-  ^-  (unit (pair milt worm))                   ::
       ?.  ?=({$meta p/* q/milt} q.mut)  `[mut p.sew]    ::  ordinary metacard
       =^  hip  p.sew  (~(nets wa p.sew) mev.vil p.mut)  ::
@@ -10440,10 +10428,10 @@
   (vent lal vil bud *worm (slym (slap bud (rain pax txt)) bud))
 ::
 ++  viol                                                ::  vane tools
-  |=  but/type
+  |=  but/span
   ^-  vile
-  =+  pal=|=(a/@t ^-(type (~(play ut but) (vice a))))
-  :*  typ=(pal '*type')
+  =+  pal=|=(a/@t ^-(span (~(play ut but) (vice a))))
+  :*  typ=(pal '*span')
       duc=(pal '*duct')
       pah=(pal '*path')
       mev=(pal '*{$meta $vase}')