=>  ..ride  =>
!:
|%
+|  %global
::
++  arvo  %240
::
::  $arch: node identity
::  $axal: fundamental node, recursive (trie)
::  $axil: fundamental node
::  $beak: global context
::  $beam: global name
::  $bone: opaque duct handle
::  $case: global version
::  $cage: marked vase
::  +cask: marked data builder
::  $desk: local workspace
::  $dock: message target
::  $gang: infinite set of peers
::  $mark: symbolic content type
::  $mien: orientation
::  $page: untyped cage
::  +omen: namespace path and data
::  $ship: network identity
::  $sink: subscription
::
+$  arch  (axil @uvI)
++  axal
  |$  [item]
  [fil=(unit item) dir=(map @ta $)]
++  axil
  |$  [item]
  [fil=(unit item) dir=(map @ta ~)]
::
+$  beak  (trel ship desk case)
+$  beam  [beak s=path]
+$  bone  @ud
+$  case
  $%  ::  %da:  date
      ::  %tas: label
      ::  %ud:  sequence
      ::
      [%da p=@da]
      [%tas p=@tas]
      [%ud p=@ud]
  ==
+$  cage  (cask vase)
++  cask  |$  [a]  (pair mark a)
+$  desk  @tas
+$  dock  (pair @p term)
+$  gang  (unit (set ship))
+$  mark  @tas
+$  mien  [our=ship now=@da eny=@uvJ]
+$  page  (cask)
++  omen  |$  [a]  (pair path (cask a))
+$  ship  @p
+$  sink  (trel bone ship path)
::
+|  %meta
::
::  +hypo: type-associated builder
::  $meta: meta-vase
::  $maze: vase, or meta-vase
::
++  hypo
  |$  [a]
  (pair type a)
+$  meta  (pair)
+$  maze  (each vase meta)
::
+|  %interface
::
::  $ball: dynamic kernel action
::  $card: tagged, untyped event
::  $duct: causal history
::  +hobo: %soft task builder
::  $goof: crash label and trace XX fail/ruin/crud/flaw/lack/miss
::  $mass: memory usage
::  $move: cause and action
::  $ovum: card with cause
::  $roof: namespace
::  $rook: meta-namespace (super advanced)
::  +room: generic namespace
::  +roon: partial namespace
::  $root: raw namespace
::  $view: namespace perspective
::  +wind: kernel action builder
::  $wire: event pretext
::  +wite: kernel action/error builder
::
+$  ball  (wite [vane=term task=maze] maze)
+$  card  (cask)
+$  duct  (list wire)
++  hobo
  |$  [a]
  $?  $%  [%soft p=*]
      ==
      a
  ==
+$  goof  [mote=term =tang]
+$  mass  $~  $+|+~
          (pair cord (each * (list mass)))
+$  move  [=duct =ball]
+$  ovum  [=wire =card]
::
+$  roof  (room vase)                                   ::  namespace
+$  rook  (room meta)                                   ::  meta-namespace
++  room                                                ::  either namespace
  |$  [a]
  $~  =>(~ |~(* ~))
  $-  $:  lyc=gang                                      ::  leakset
          vis=view                                      ::  perspective
          bem=beam                                      ::  path
      ==                                                ::
  %-  unit                                              ::  ~: unknown
  %-  unit                                              ::  ~ ~: invalid
  (cask a)
+$  roon                                                ::  partial namespace
  $~  =>(~ |~(* ~))
  $-  [lyc=gang car=term bem=beam]
  (unit (unit cage))
+$  root  $-(^ (unit (unit)))
+$  view  $@(term [way=term car=term])
::
++  wind
  |$  ::  a: forward
      ::  b: reverse
      ::
      [a b]
  $%  ::  %pass: advance
      ::  %slip: lateral
      ::  %give: retreat
      ::
      [%pass p=path q=a]
      [%slip p=a]
      [%give p=b]
  ==
+$  wire  path
++  wite
  |$  ::  note: a routed $task
      ::  gift: a reverse action
      ::
      ::    NB:  task: a forward action
      ::         sign: a sourced $gift
      ::
      [note gift]
  $%  ::  %hurl: action failed
      ::  %pass: advance
      ::  %slip: lateral
      ::  %give: retreat
      ::
      [%hurl =goof wite=$;($>(?(%pass %give) $))]
      [%pass =wire =note]
      [%slip =note]
      [%give =gift]
  ==
::
+|  %implementation
::
::  $debt: ephemeral state
::  $grub: persistent state, larval stage
::  $germ: worklist source and bar stack
::  $heir: upgradeable state
::  $plan: worklist
::  $soul: persistent state
::  $vane: kernel module
::  $vere: runtime version
::  $vile: reflexive constants
::  $waif: arvo task, from anywhere
::  $wasp: arvo task, from Outside
::  $weft: kelvin version, tag and number
::  $worm: compiler cache
::  $wisp: arvo task, larval stage
::  $wynn: kelvin stack
::
+$  debt
  $:  ::  run: list of worklists
      ::  out: pending output
      ::  kel: kernel files
      ::  fil: pending files
      ::
      run=(list plan)
      out=(list ovum)
      kel=(list (pair path (cask)))
      fil=(list (pair path (cask)))
  ==
+$  germ  [vane=term bars=(list duct)]
+$  grub
  $:  ::  who: identity once we know it
      ::  eny: entropy once we learn it
      ::  lac: laconicity as we want it
      ::  ver: the Outside as we see it
      ::  fat: source when we attain it
      ::  lul: %lull when we acquire it
      ::  zus: %zuse once we receive it
      ::  van: vanes while we desire it
      ::
      who=(unit ship)
      eny=(unit @)
      lac=?
      ver=(unit vere)
      fat=(unit (axal (cask)))
      lul=(unit (trap vase))
      zus=(unit (trap vase))
      van=(map term (trap vase))
  ==
+$  heir
  $%  $:  %grub
          $%  [_arvo =grub]
      ==  ==
      [_arvo =debt =soul]
  ==
+$  plan  (pair germ (list move))
+$  soul
  $:  ::  identity, time, entropy
      ::  fad: configuration
      ::  zen: Outside knowledge
      ::  mod: internal modules
      ::
      mien
      $=  fad
      $:  ::  lac: not verbose
          ::
          lac=?
      ==
      $=  zen
      $:  ::  ver: runtime version
          ::  lag: upgrade blocked
          ::
          ver=vere
          lag=_|
      ==
      $=  mod
      $:  ::  fat: filesystem
          ::  lul: %lull
          ::  zus: %zuse
          ::  van: vanes
          ::
          fat=(axal (cask))
          lul=vase
          zus=vase
          van=(map term vane)
      ==
  ==
+$  vane  [=vase =worm]
+$  vere  [[non=@ta rev=path] kel=wynn]
+$  vile
  $:  typ=type    ::  -:!>(*type)
      duc=type    ::  -:!>(*duct)
      wir=type    ::  -:!>(*wire)
      dud=type    ::  -:!>(*(unit goof))
  ==
::
+$  waif
  ::  %trim: trim state, spam to all
  ::  %what: update from files
  ::  %whey: produce $mass                    :: XX remove, scry
  ::  %verb: toggle laconicity
  ::  %whiz: prime vane caches
  ::
  $%  [%trim p=@ud]
      [%what p=(list (pair path (cask)))]
      [%whey ~]
      [%verb p=(unit ?)]
      [%whiz ~]
  ==
+$  wasp
  ::  %crud: reroute $ovum with $goof
  ::  %wack: iterate entropy
  ::  %wyrd: check/record runtime kelvin stack
  ::
  $%  [%crud =goof =ovum]
      [%wack p=@uvJ]
      [%wyrd p=vere]
  ==
+$  weft  [lal=@tas num=@ud]
+$  worm
  $:  ::  +nest, +play, and +mint
      ::
      nes=(set ^)
      pay=(map (pair type hoon) type)
      mit=(map (pair type hoon) (pair type nock))
  ==
+$  wisp
  $%  $>(?(%verb %what) waif)
      $>(?(%wack %wyrd) wasp)
      [%whom p=ship]
  ==
+$  wynn  (list weft)
--  =>
::
~%  %hex  ..ut  ~
|%
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
::                section 3bE, Arvo core                ::
::
++  en-beam
  |=(b=beam =*(s scot `path`[(s %p p.b) q.b (s r.b) s.b]))
::
++  de-beam
  ~/  %de-beam
  |=  p=path
  ^-  (unit beam)
  ?.  ?=([@ @ @ *] p)  ~
  ?~  who=(slaw %p i.p)  ~
  ?~  des=?~(i.t.p (some %$) (slaw %tas i.t.p))  ~  :: XX +sym ;~(pose low (easy %$))
  ?~  ved=(de-case i.t.t.p)  ~
  `[[`ship`u.who `desk`u.des u.ved] t.t.t.p]
::
++  de-case
  ~/  %de-case
  |=  =knot
  ^-  (unit case)
  ?^  num=(slaw %ud knot)  `[%ud u.num]
  ?^  wen=(slaw %da knot)  `[%da u.wen]
  ?~  lab=(slaw %tas knot)  ~
  `[%tas u.lab]
::
++  en-omen
  |=  [vis=view bem=beam]
  ^-  path
  :_  (en-beam bem)
  ?@  vis  vis
  ~(rent co [%many $/tas/way.vis $/tas/car.vis ~])
::
++  de-omen
  ~/  %de-omen
  |=  pax=path
  ^-  (unit [vis=view bem=beam])
  ?~  pax  ~
  ?~  bem=(de-beam t.pax)  ~
  ?:  ((sane %tas) i.pax)
    `[i.pax u.bem]
  =/  lot=(unit coin)  (rush i.pax ;~(pfix dot perd:so))
  ?.  ?&  ?=(^ lot)
          ?=([%many [%$ %tas @] [%$ %tas @] ~] u.lot)
      ==
    ~
  `[[q.p.i q.p.i.t]:p.u.lot u.bem]
::
++  look
  ~/  %look
  |=  [rof=roof lyc=gang]
  ^-  root
  ~/  %in
  |=  [ref=* raw=*]
  ?~  pax=((soft path) raw)  ~
  ?~  mon=(de-omen u.pax)  ~
  ?~  dat=(rof lyc u.mon)  ~
  ?~  u.dat  [~ ~]
  =*  vax  q.u.u.dat
  ?.  ?&  ?=(^ ref)
          =(hoon-version -.ref)
          -:(~(nets wa *worm) +.ref p.vax)
      ==
    ~>(%slog.[0 leaf+"arvo: scry-lost"] ~)
  [~ ~ q.vax]
::  |wyrd: kelvin negotiation
::
::    specified but unimplemented:
::    arvo should produce a [wend/wynn] effect
::    to signal downgrade
::
++  wyrd
  |%
  ::  +sane: kelvin stack for validity
  ::
  ++  sane
    |=  kel=wynn
    ^-  ?
    ?:  =(~ kel)  &
    =^  las=weft  kel  kel
    |-  ^-  ?
    ?~  kel  &
    ?&  (gte num.las num.i.kel)
        $(las i.kel, kel t.kel)
    ==
  ::  +need: require kelvins
  ::
  ++  need
    |=  [run=wynn hav=wynn]
    ::  wyr: ~: runtime supports all required kelvins
    ::       ^: runtime support is missing or lagging
    ::
    =;  wyr  !.
      ?~  wyr
        same
      ~&  wyrd=wyr
      ~_  :+  %rose
            [" " ~ ~]
          :~  =+  p.u.wyr
              leaf/"%{(trip lal)} %{(scow %ud num)} required;"
              ?~  q.u.wyr
                leaf/"runtime missing support"
              leaf/"runtime only supports %{(scow %ud u.q.u.wyr)}"
          ==
      ~>  %mean.'arvo: upgrade blocked'
      ~>  %mean.'wyrd'
      !!
    ::
    |-  ^-  (unit (pair weft (unit @ud)))
    ?~  hav  ~
    ::
    ::  fel: %&: runtime kelvin for [i.hav]
    ::       %|: no specified runtime support
    ::
    =/  fel
      |-  ^-  (each @ud weft)
      ?~  run  |/i.hav
      ?:(=(lal.i.hav lal.i.run) &/num.i.run $(run t.run))
    ::
    ?-  -.fel
      %|  `[p.fel ~]
      %&  ?.((lte p.fel num.i.hav) `[i.hav `p.fel] $(hav t.hav))
    ==
  --
::
::  |of: axal engine
::
++  of
  =|  fat=(axal)
  |@
  ++  del
    |=  pax=path
    ^+  fat
    ?~  pax  [~ dir.fat]
    =/  kid  (~(get by dir.fat) i.pax)
    ?~  kid  fat
    fat(dir (~(put by dir.fat) i.pax $(fat u.kid, pax t.pax)))
  ::  Descend to the axal at this path
  ::
  ++  dip
    |=  pax=path
    ^+  fat
    ?~  pax  fat
    =/  kid  (~(get by dir.fat) i.pax)
    ?~  kid  [~ ~]
    $(fat u.kid, pax t.pax)
  ::
  ++  gas
    |=  lit=(list (pair path _?>(?=(^ fil.fat) u.fil.fat)))
    ^+  fat
    ?~  lit  fat
    $(fat (put p.i.lit q.i.lit), lit t.lit)
  ::
  ++  get
    |=  pax=path
    fil:(dip pax)
  ::  Fetch file at longest existing prefix of the path
  ::
  ++  fit
    |=  pax=path
    ^+  [pax fil.fat]
    ?~  pax  [~ fil.fat]
    =/  kid  (~(get by dir.fat) i.pax)
    ?~  kid  [pax fil.fat]
    =/  low  $(fat u.kid, pax t.pax)
    ?~  +.low
      [pax fil.fat]
    low
  ::
  ++  has
    |=  pax=path
    !=(~ (get pax))
  ::  Delete subtree
  ::
  ++  lop
    |=  pax=path
    ^+  fat
    ?~  pax  fat
    |-
    ?~  t.pax  fat(dir (~(del by dir.fat) i.pax))
    =/  kid  (~(get by dir.fat) i.pax)
    ?~  kid  fat
    fat(dir (~(put by dir.fat) i.pax $(fat u.kid, pax t.pax)))
  ::
  ++  put
    |*  [pax=path dat=*]
    =>  .(dat `_?>(?=(^ fil.fat) u.fil.fat)`dat, pax `path`pax)
    |-  ^+  fat
    ?~  pax  fat(fil `dat)
    =/  kid  (~(gut by dir.fat) i.pax ^+(fat [~ ~]))
    fat(dir (~(put by dir.fat) i.pax $(fat kid, pax t.pax)))
  ::
  ++  tap
    =|  pax=path
    =|  out=(list (pair path _?>(?=(^ fil.fat) u.fil.fat)))
    |-  ^+   out
    =?  out  ?=(^ fil.fat)  :_(out [pax u.fil.fat])
    =/  dir  ~(tap by dir.fat)
    |-  ^+   out
    ?~  dir  out
    %=  $
      dir  t.dir
      out  ^$(pax (weld pax /[p.i.dir]), fat q.i.dir)
    ==
  ::  Serialize to map
  ::
  ++  tar
    (~(gas by *(map path _?>(?=(^ fil.fat) u.fil.fat))) tap)
  --
::
++  wa                                                  ::  cached compile
  |_  worm
  ++  nell  |=(ref=type (nest [%cell %noun %noun] ref)) ::  nest in cell
  ++  nest                                              ::  nest:ut, cached
    |=  [sut=type ref=type]
    ^-  [? worm]
    ?:  (~(has in nes) [sut ref])  [& +>+<]
    ?.  (~(nest ut sut) | ref)
      ~&  %nest-failed
      =+  foo=(skol ref)
      =+  bar=(skol sut)
      ~&  %nest-need
      ~>  %slog.[0 bar]
      ~&  %nest-have
      ~>  %slog.[0 foo]
      [| +>+<.$]
    [& +>+<(nes (~(put in nes) [sut ref]))]
  ::
  ++  call                                              ::  call gate
    |=  [vax=vase nam=term som=(each vase ^)]
    ^-  [vase worm]
    =^  duf  +>+<.$  (open vax nam som)
    (slap duf [%limb %$])
  ::
  ++  open                                              ::  assemble door
    |=  [vax=vase nam=term som=(each vase ^)]
    ^-  [vase worm]
    =*  key  [%cncb [[%& 2] ~] [[[%& 6] ~] [%$ 3]] ~]
    =^  dor  +>+<.$  (slap vax [%limb nam])
    =^  mes  +>+<.$  (slot 6 dor)
    =^  hip  +>+<.$
      ?-  -.som
         %&  (nest p.mes p.p.som)
         %|  (nets p.mes -.p.som)
      ==
    ?>  hip
    [[p.dor q.dor(+6 +7.som)] +>+<.$]
  ::
  ++  neat                                              ::  type compliance
    |=  [typ=type som=(each vase ^)]
    ^-  worm
    =^  hip  +>+<.$
      ?-  -.som
        %&  (nest typ p.p.som)
        %|  (nets typ -.p.som)
      ==
    ?>  hip
    +>+<.$
  ::
  ++  nets                                              ::  typeless nest
    |=  [sut=* ref=*]
    ^-  [? worm]
    ?:  (~(has in nes) [sut ref])  [& +>+<]
    =+  gat=|=([a=type b=type] (~(nest ut a) | b))
    ?.  (? (slum gat [sut ref]))
      ~&  %nets-failed
      =+  tag=`*`skol
      =+  foo=(tank (slum tag ref))
      =+  bar=(tank (slum tag sut))
      ~&  %nets-need
      ~>  %slog.[0 bar]
      ~&  %nets-have
      ~>  %slog.[0 foo]
      [| +>+<.$]
    [& +>+<.$(nes (~(put in nes) [sut ref]))]
  ::  +play: +play:ut, cached
  ::
  ++  play
    |=  [sut=type gen=hoon]
    ^-  [type 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, cached
  ::
  ++  mint
    |=  [sut=type gen=hoon]
    ^-  [(pair type nock) worm]
    =+  old=(~(get by mit) [sut gen])
    ?^  old  [u.old +>+<.$]
    =+  new=(~(mint ut sut) %noun gen)
    [new +>+<.$(mit (~(put by mit) [sut gen] new))]
  ::  +slam: +slam:ut, cached
  ::
  ++  slam
    |=  [gat=vase sam=vase]
    =/  sut=type  [%cell p.gat p.sam]
    =/  gen=hoon  [%cnsg [%$ ~] [%$ 2] [%$ 3] ~]
    =^  new=type  +>+<.$  (play sut gen)
    [[new (slum q.gat q.sam)] +>+<.$]
  ::  +slap: +slap:ut, cached
  ::
  ++  slap
    |=  [vax=vase gen=hoon]
    ^-  [vase worm]
    =^  gun  +>+<  (mint p.vax gen)
    [[p.gun .*(q.vax q.gun)] +>+<.$]
  ::  +slot: +slot:ut, cached
  ::
  ++  slot
    |=  [axe=@ vax=vase]
    ^-  [vase worm]
    =^  gun  +>+<  (mint p.vax [%$ axe])
    [[p.gun .*(q.vax [0 axe])] +>+<.$]
  ::
  ::  +slur: slam a vase with a maze
  ::
  ++  slur
    |=  [gat=vase sam=maze]
    ^-  [vase worm]
    =^  cur  +>+<.$  (slot 6 gat)
    =.  +>+<.$  (neat p.cur sam)
    (slym gat q.p.sam)
  ::  +slym: +slym:ut, cached
  ::
  ++  slym
    |=  [gat=vase sam=*]
    ^-  [vase worm]
    (slap gat(+<.q sam) [%limb %$])
  ::
  ++  sped                                              ::  specialize vase
    |=  vax=vase
    ^-  [vase worm]
    =+  ^=  gen  ^-  hoon
      ?@  q.vax    [%wtts [%base [%atom %$]] [%& 1]~]
      ?@  -.q.vax  [%wtts [%leaf %tas -.q.vax] [%& 2]~]
      [%wtts [%base %cell] [%& 1]~]
    =^  typ  +>+<.$  (play p.vax [%wtgr gen [%$ 1]])
    [[typ q.vax] +>+<.$]
  ::
  ++  spot                                              ::  slot then sped
    |=  [axe=@ vax=vase]
    ^-  [vase worm]
    =^  xav  +>+<  (slot axe vax)
    (sped xav)
  ::
  ++  stop                                              ::  sped then slot
    |=  [axe=@ vax=vase]
    ^-  [vase worm]
    =^  xav  +>+<  (sped vax)
    (slot axe xav)
  --
::
::  |part: arvo structures and engines
::
++  part
  =>  |%
      ::  $card: tagged, untyped event
      ::  $ovum: card with cause
      ::  $news: collated updates
      ::  $oped: module updates
      ::  $seed: next kernel source
      ::
      +$  news
          $:  ::  sys: installs + replacements
              ::  use: non-system files
              ::
              sys=(map path (cask))
              use=(map path (cask))
          ==
      +$  oped
        $:  lul=(unit cord)
            zus=(unit cord)
            van=(list (cask cord))
        ==
      +$  seed  [hun=(unit cord) arv=cord]
      --
  ::
  ~%  %part  ..part  ~
  |%
  ::
  +|  %engines
  ::
  ::  |eden: lifecycle and bootstrap formula generators
  ::
  ::    while unused by arvo itself, these nock formulas
  ::    bootstrap arvo and define its lifecycle.
  ::
  ::    we're creating an event series E whose lifecycle can be computed
  ::    with the urbit lifecycle formula L, `[2 [0 3] [0 2]]`.  that is:
  ::    if E is the list of events processed by a computer in its life,
  ::    its final state is S, where S is nock(E L).
  ::
  ::    in practice, the first five nouns in E are: two boot formulas,
  ::    a hoon compiler as a nock formula, the same compiler as source,
  ::    and the arvo kernel as source.
  ::
  ::    after the first five special events, we enter an iterative
  ::    sequence of regular events which continues for the rest of the
  ::    computer's life.  during this sequence, each state is a function
  ::    that, passed the next event, produces the next state.
  ::
  ::    a regular event is an $ovum, or `[date wire type data]` tuple, where
  ::    `date` is a 128-bit Urbit date; `wire` is an opaque path which
  ::    output can match to track causality; `type` is a symbol describing
  ::    the type of input; and `data` is input data specific to `type`.
  ::
  ::    in real life we don't actually run the lifecycle loop,
  ::    since real life is updated incrementally and also cares
  ::    about things like output.  we couple to the internal
  ::    structure of the state machine and work directly with
  ::    the underlying arvo engine.
  ::
  ::    this arvo core, which is at `+7` (Lisp `cddr`) of the state
  ::    function (see its public interface in `sys/arvo`), gives us
  ::    extra features, like output, which are relevant to running
  ::    a real-life urbit vm, but don't affect the formal definition.
  ::
  ::    so a real-life urbit interpreter is coupled to the shape of
  ::    the arvo core.  it becomes very hard to change this shape.
  ::    fortunately, it is not a very complex interface.
  ::
  ++  eden
    |%
    ::  +aeon: arvo lifecycle loop
    ::
    ::    the first event in a ship's log,
    ::    computing the final state from the rest of log
    ::    when invoked via the lifecycle formula: [%2 [%0 3] %0 2]
    ::
    ::    the formal urbit state is always just a gate (function)
    ::    which, passed the next event, produces the next state.
    ::
    ++  aeon
      ^-  *
      =>  ::  boot: kernel bootstrap, event 2
          ::  tale: events 3-n
          ::
          *log=[boot=* tale=*]
      !=  ::  arvo: bootstrapped kernel
          ::  epic: remainder of the log
          ::
      =+  [arvo epic]=.*(tale.log boot.log)
      |-  ^-  *
      ?@  epic  arvo
      %=  $
        epic  +.epic
        arvo  .*([arvo -.epic] [%9 2 %10 [6 %0 3] %0 2])
      ==
    ::
    ::  +boot: event 2: bootstrap a kernel from source
    ::
    ++  boot
      ^-  *
      ::
      ::  event 2 is the startup formula, which verifies the compiler
      ::  and starts the main lifecycle.
      ::
      =>  ::  fate: event 3: a nock formula producing the hoon bootstrap compiler
          ::  hoon: event 4: compiler source
          ::  arvo: event 5: kernel source
          ::  epic: event 6-n
          ::
          *log=[fate=* hoon=@ arvo=@ epic=*]
      !=
      ::
      ::  activate the compiler gate.  the product of this formula
      ::  is smaller than the formula.  so you might think we should
      ::  save the gate itself rather than the formula producing it.
      ::  but we have to run the formula at runtime, to register jets.
      ::
      ::  as always, we have to use raw nock as we have no type.
      ::  the gate is in fact ++ride.
      ::
      ~>  %slog.[0 leaf+"1-b"]
      =/  compiler-gate  .*(0 fate.log)
      ::
      ::  compile the compiler source, producing (pair span nock).
      ::  the compiler ignores its input so we use a trivial span.
      ::
      ~>  %slog.[0 leaf+"1-c (compiling compiler, wait a few minutes)"]
      =/  compiler-tool
        .*([compiler-gate noun/hoon.log] [%9 2 %10 [6 %0 3] %0 2])
      ::
      ::  switch to the second-generation compiler.  we want to be
      ::  able to generate matching reflection nouns even if the
      ::  language changes -- the first-generation formula will
      ::  generate last-generation spans for `!>`, etc.
      ::
      ~>  %slog.[0 leaf+"1-d"]
      =.  compiler-gate  .*(0 +.compiler-tool)
      ::
      ::  get the span (type) of the kernel core, which is the context
      ::  of the compiler gate.  we just compiled the compiler,
      ::  so we know the span (type) of the compiler gate.  its
      ::  context is at tree address `+>` (ie, `+7` or Lisp `cddr`).
      ::  we use the compiler again to infer this trivial program.
      ::
      ~>  %slog.[0 leaf+"1-e"]
      =/  kernel-span
        -:.*([compiler-gate -.compiler-tool '+>'] [%9 2 %10 [6 %0 3] %0 2])
      ::
      ::  compile the arvo source against the kernel core.
      ::
      ~>  %slog.[0 leaf+"1-f"]
      =/  kernel-tool
        .*([compiler-gate kernel-span arvo.log] [%9 2 %10 [6 %0 3] %0 2])
      ::
      ::  create the arvo kernel, whose subject is the kernel core.
      ::
      ~>  %slog.[0 leaf+"1-g"]
      [.*(+>.compiler-gate +.kernel-tool) epic.log]
    --
  ::
  ::  |adapt
  ::
  ++  adapt
    =>  |%
        ::  deep file as source
        ::
        ++  sole  |=(a=(cask) `cord`?>(?=([%hoon @t] a) q.a))
        --
    |_  fat=(axal (cask))
    ::
    ::  +group: collate changes
    ::
    ++  group
      |=  fal=(list (pair path (cask)))
      =|  del=news
      |-  ^+   del
      ?~  fal  del
      ::  classify files, ignoring unchanged
      ::
      =*  pax  p.i.fal
      =*  dat  q.i.fal
      =/  hav  (~(get of fat) pax)
      =?  del  |(?=(~ hav) !=(u.hav dat))
         ?:  ?=([%sys *] pax)
           del(sys (~(put by sys.del) pax dat))
         del(use (~(put by use.del) pax dat))
      $(fal t.fal)
    ::  +usurp: consider self-replacement
    ::
    ++  usurp
      |=  del=news
      ^-  (unit (pair seed (list (pair path (cask)))))
      =/  hun  (~(get by sys.del) /sys/hoon)
      =/  arv  (~(get by sys.del) /sys/arvo)
      ?~  hun
        ?~  arv  ~
        `[`(sole u.arv) [/sys/arvo u.arv] ~]
      =/  rav
        ~|  %usurp-hoon-no-arvo
        ((bond |.((need (~(get of fat) /sys/arvo)))) arv)
      ~!  rav
      :+  ~
        [`(sole u.hun) (sole rav)]
      [[/sys/arvo rav] [/sys/hoon u.hun] ~]
    ::  +adorn: augment capabilities
    ::
    ++  adorn
      |=  [del=news all=?]
      ^-  (pair oped _fat)
      ::  lull: shared structures
      ::
      =^  lul  fat
        ?^  hav=(~(get by sys.del) /sys/lull)
          :-  `(sole u.hav)
          (~(put of fat) /sys/lull u.hav)
        :_  fat
        ~|  %adorn-no-lull
        ?.(all ~ `(sole (need (~(get of fat) /sys/lull))))
      ::  zuse: shared library
      ::
      ::    %lull is the subject of %zuse; force all if we have a new %lull
      ::
      =.  all  |(all ?=(^ lul))
      =^  zus  fat
        ?^  hav=(~(get by sys.del) /sys/zuse)
          :-  `(sole u.hav)
          (~(put of fat) /sys/zuse u.hav)
        :_  fat
        ~|  %adorn-no-zuse
        ?.(all ~ `(sole (need (~(get of fat) /sys/zuse))))
      ::  kernel modules
      ::
      ::    %zuse is the subject of the vanes; force all if we have a new %zuse
      ::
      =.  all  |(all ?=(^ zus))
      =|  nav=(map term cord)
      =?  nav  all
        %-  ~(gas by nav)
        %+  turn
          ~(tap by dir:(~(dip of fat) /sys/vane))
        |=([name=@ta _fat] [`@tas`name (sole (need fil))])
      ::
      =^  new  fat
        %^    spin
            %+  skim  ~(tap by sys.del)
            |=([p=path *] ?=([%sys %vane @tas ~] p))
          fat
        |=  [[p=path q=(cask)] taf=_fat]
        ^-  (pair (cask cord) _fat)
        ?>  ?=([%sys %vane @tas ~] p)
        =*  nam  i.t.t.p
        ?>  ((sane %tas) nam)
        [[`@tas`nam (sole q)] (~(put of taf) p q)]
      ::
      =;  van
        [[lul zus van] fat]
      %+  sort  ~(tap by (~(gas by nav) new))
      |=([[a=@tas *] [b=@tas *]] (aor a b))
    -- :: adapt
  ::
  ::  |me: dynamic analysis
  ::
  ++  me
    ~/  %me
    |_  ::  sac: compiler cache
        ::  pyt: cached types
        ::
        [sac=worm vil=vile]
    ::  +refine-moves: move list from vase
    ::
    ++  refine-moves
      |=  vax=vase
      ^-  (pair (list move) worm)
      ?:  =(~ q.vax)  [~ sac]
      =^  hed  sac  (~(slot wa sac) 2 vax)
      =^  tal  sac  (~(slot wa sac) 3 vax)
      =^  mov  sac  (refine-move hed)
      =^  moz  sac  $(vax tal)
      [[mov moz] sac]
    ::  +refine-move: move from vase
    ::
    ++  refine-move
      |=  vax=vase
      ^-  (pair move worm)
      ~>  %mean.'bad-move'
      =^  hip  sac  (~(nell wa sac) p.vax)
      ?.  hip
        ~>(%mean.'not-cell' !!)
      =/  duc
        ~>  %mean.'bad-duct'
        ;;(duct -.q.vax)
      ::
      ::  yat: specialized ball vase
      ::
      =^  yat  sac  (~(spot wa sac) 3 vax)
      =^  del  sac  (refine-ball yat)
      [[duc del] sac]
    ::  +refine-ball: ball from vase
    ::
    ++  refine-ball
      |=  vax=vase
      ^-  (pair ball worm)
      ?+    q.vax
          ~>  %mean.'bad-ball'
          ~_  (sell vax)
          !!
      ::
          [%give card]
        ::  yed: vase containing card
        ::  hil: card as maze
        ::
        =^  yed  sac  (~(spot wa sac) 3 vax)
        =^  hil  sac  (refine-card yed)
        [[%give hil] sac]
      ::
          [%pass wire=* vane=term card]
        =/  =wire
          ~>  %mean.'bad-wire'
          ;;(wire wire.q.vax)
        =/  vane
          ~>  %mean.'bad-vane-label'
          ?>  ((sane %tas) vane.q.vax)
          vane.q.vax
        ::
        ::  yed: vase containing card
        ::  hil: card as maze
        ::
        =^  xav  sac  (~(spot wa sac) 7 vax)
        =^  yed  sac  (~(spot wa sac) 3 xav)
        =^  hil  sac  (refine-card yed)
        [[%pass wire vane hil] sac]
      ::
          [%slip vane=term card]
        =/  vane
          ~>  %mean.'bad-vane-label'
          ?>  ((sane %tas) vane.q.vax)
          vane.q.vax
        ::
        ::  yed: vase containing card
        ::  hil: card as maze
        ::
        =^  xav  sac  (~(spot wa sac) 3 vax)
        =^  yed  sac  (~(spot wa sac) 3 xav)
        =^  hil  sac  (refine-card yed)
        [[%slip vane hil] sac]
      ::
          [%hurl goof=^ ball=*]
        =/  =goof
          =/  mote  -.goof.q.vax
          ?>  ?&  ?=(@ mote)
                  ((sane %tas) mote)
              ==
          [mote ;;(tang +.goof.q.vax)]
        ::
        =^  bal  sac
          =^  lab  sac  (~(spot wa sac) 7 vax)
          $(vax lab)
        ::
        ?>  ?=(?(%pass %give) -.p.bal)
        [[%hurl goof p.bal] sac]
      ==
    ::  +refine-card: card from vase
    ::
    ++  refine-card
      |=  vax=vase
      ^-  (pair maze worm)
      ~>  %mean.'bad-card'
      =^  hip  sac  (~(nell wa sac) p.vax)
      ?>  hip
      ?.  ?=(%meta -.q.vax)
        ::
        ::  for a non-meta card, the maze is the vase
        ::
        [[%& vax] sac]
      ~>  %mean.'bad-meta'
      ::
      ::  tiv: vase of vase of card
      ::  typ: vase of span
      ::
      =^  tiv  sac  (~(slot wa sac) 3 vax)
      =^  hip  sac  (~(nell wa sac) p.tiv)
      ?>  hip
      =^  typ  sac  (~(slot wa sac) 2 tiv)
      =.  sac  (~(neat wa sac) typ.vil [%& typ])
      ::
      ::  support for meta-meta-cards has been removed
      ::
      ?>  ?=(meta q.tiv)
      [[%| q.tiv] sac]
    --
  ::
  ::  |va: vane engine
  ::
  ++  va
    =>  |%
        +$  vane-sample  [now=@da eny=@uvJ rof=rook]
        ::
        ++  smit
          |=  [cap=tape sub=vase pax=path txt=@t]
          ^-  vase
          ~>  %slog.[0 leaf/"{cap}: {(scow p+(mug txt))}"]
          %-  road  |.
          ~_  leaf/"{cap}: build failed"
          (slap sub (rain pax txt))
        ::
        ++  create
          |=  [our=ship zus=vase lal=term pax=path txt=@t]
          ^-  vase
          =/  cap  "vane: %{(trip lal)}"
          (slym (smit cap zus pax txt) our)
        ::
        ++  settle
          |=  van=vase
          ^-  (pair vase worm)
          =|  sac=worm
          =^  rig=vase  sac  (~(slym wa sac) van *vane-sample)
          =^  gat=vase  sac  (~(slap wa sac) rig [%limb %scry])
          =^  pro=vase  sac  (~(slap wa sac) gat [%limb %$])
          [van +:(~(mint wa sac) p.pro [%$ 7])]
        ::
        ::  XX pass identity to preserve behavior?
        ::
        ++  update
          |=  [las=vase nex=vase]
          ^-  vase
          =/  sam=vase  (slap (slym las *vane-sample) [%limb %stay])
          =/  gat=vase  (slap (slym nex *vane-sample) [%limb %load])
          (slam gat sam)
        --
    ::
    ~%  %va  ..va  ~
    |_  [vil=vile vax=vase sac=worm]
    ::
    ::  |plow:va: operate in time and space
    ::
    ++  plow
      |=  [now=@da rok=rook]
      |%
      ::  +peek:plow:va: read from a local namespace
      ::
      ++  peek
        ^-  rook
        |=  [lyc=gang vis=view bem=beam]
        ^-  (unit (unit (cask meta)))
        ::  namespace reads receive no entropy
        ::
        =/  sam=vane-sample  [now *@uvJ rok]
        =^  rig  sac
          ~>  %mean.'peek: activation failed'
          (~(slym wa sac) vax sam)
        =^  gat  sac
          ~>  %mean.'peek: pull failed'
          (~(slap wa sac) rig [%limb %scry])
        ::
        =/  mas=[gang view beam]  [lyc vis bem]
        ::
        =^  pro  sac
          ~>  %mean.'peek: call failed'
          (~(slym wa sac) gat mas)
        ?~  q.pro  ~
        ?~  +.q.pro  [~ ~]
        =^  dat  sac  (~(slot wa sac) 7 pro)
        ``[(,mark -.q.dat) (,^ +.q.dat)]
      ::
      ::  |spin:plow:va: move statefully
      ::
      ++  spin
        |=  [hen=duct eny=@uvJ dud=(unit goof)]
        =*  duc  [duc.vil hen]
        =*  err  [dud.vil dud]
        =/  sam=vane-sample  [now eny rok]
        =^  rig  sac
          ~>  %mean.'spin: activation failed'
          (~(slym wa sac) vax sam)
        ::
        =>  |%
            ::  +slid: cons a vase onto a maze
            ::
            ++  slid
              |=  [hed=vase tal=maze]
              ^-  maze
              ?-  -.tal
                %&  [%& (slop hed p.tal)]
                %|  [%| [%cell p.hed p.p.tal] [q.hed q.p.tal]]
              ==
            --
        |%
        ::  +peel:spin:plow:va: extract products, finalize vane
        ::
        ++  peel
          |=  pro=vase
          ^-  (pair [vase vase] worm)
          =^  moz  sac  (~(slot wa sac) 2 pro)
          =^  vem  sac  (~(slot wa sac) 3 pro)
          ::  replace vane sample with default to plug leak
          ::
          =.  +<.q.vem  *vane-sample
          [[moz vem] sac]
        ::  +call:spin:plow:va: advance statefully
        ::
        ++  call
          |=  task=maze
          ^-  (pair [vase vase] worm)
          ~>  %mean.'call: failed'
          =^  gat  sac
            (~(slap wa sac) rig [%limb %call])
          ::
          ::  sample is [duct (unit goof) (hobo task)]
          ::
          =/  sam=maze
            (slid duc (slid err task))
          =^  pro  sac  (~(slur wa sac) gat sam)
          (peel pro)
        ::  +take:spin:plow:va: retreat statefully
        ::
        ++  take
          |=  [=wire from=term gift=maze]
          ^-  (pair [vase vase] worm)
          ~>  %mean.'take: failed'
          =^  gat  sac
            (~(slap wa sac) rig [%limb %take])
          =/  src=vase
            [[%atom %tas `from] from]
          ::
          ::  sample is [wire duct (unit goof) sign=[term gift]]
          ::
          =/  sam=maze
            =*  tea  [wir.vil wire]
            (slid tea (slid duc (slid err (slid src gift))))
          =^  pro  sac  (~(slur wa sac) gat sam)
          (peel pro)
        --
      --
    --
  ::
  ::  |le: arvo event-loop engine
  ::
  ++  le
    ~%  %le  ..le  ~
    =|  $:  ::  run: list of worklists
            ::  out: pending output
            ::  gem: worklist metadata
            ::  dud: propagate error
            ::  but: reboot signal
            ::
            ::
            run=(list plan)
            out=(list ovum)
            gem=germ
            dud=(unit goof)
            $=  but  %-  unit
                     $:  gat=$-(heir (trap ^))
                         kel=(list (pair path (cask)))
                         fil=(list (pair path (cask)))
                     ==
        ==
    ::
    |_  [[pit=vase vil=vile] soul]
    +*  this  .
        sol   +<+
    ::
    ::  +abet: finalize loop
    ::
    ++  abet
      ^-  (each (pair (list ovum) soul) (trap ^))
      ?~  but
        ^-   [%& (pair (list ovum) soul)]
        &/[(flop out) sol]
      |/(gat.u.but [arvo [run out [kel fil]:u.but] sol])
    ::  +poke: prepare a worklist-of-one from outside
    ::
    ++  poke
      |=  =ovum
      ^+  this
      ~>  %mean.'arvo: poke crashed'
      ~?  !lac.fad  ["" %unix p.card.ovum wire.ovum now]
      (poke:pith ovum)
    ::
    ++  jump
      |=  =debt
      ^+  this
      =:  run  run.debt
          out  out.debt
        ==
      ::  apply remaining update
      ::
      =.  ..this  (~(lod what:pith fil.debt) kel.debt)
      ::  send upgrade notifications
      ::
      =+  [wir car]=[/arvo vega/~]
      =.  ..this  (xeno:pith $/wir car)
      (emit $/~ (spam:pith wir !>(car)))
    ::  +emit: enqueue a worklist with source
    ::
    ++  emit
      |=  pan=plan
      this(run [pan run])
    ::  +loop: until done
    ::
    ++  loop
      ^+  abet
      ?:  ?|  ?=(~ run)
              ?=(^ but)
          ==
        abet
      ?:  =(~ q.i.run)    :: XX TMI
        loop(run t.run)
      =.  dud  ~
      =.  gem  p.i.run
      =^  mov=move  q.i.run  q.i.run
      loop:(step mov)
    ::  +step: advance the loop one step by routing a move
    ::
    ++  step
      |=  =move
      ^+  this
      ::
      ~?  &(!lac.fad ?=(^ dud))  %goof
      ::
      ?-  -.ball.move
      ::
      ::  %pass: forward move
      ::
          %pass
        =*  wire  wire.ball.move
        =*  duct  duct.move
        =*  vane  vane.note.ball.move
        =*  task  task.note.ball.move
        ::
        ~?  &(!lac.fad !=(%$ vane.gem))
          :-  (runt [(lent bars.gem) '|'] "")
          :^  %pass  [vane.gem vane]
            ?:  ?=(?(%deal %deal-gall) +>-.task)
              :-  :-  +>-.task
                  ;;([[ship ship] term term] [+>+< +>+>- +>+>+<]:task)
              wire
            [(symp +>-.task) wire]
          duct
        ::
        ::  cons source onto wire, and wire onto duct
        ::
        (call [[vane.gem wire] duct] vane task)
      ::
      ::  %slip: lateral move
      ::
          %slip
        =*  duct  duct.move
        =*  vane  vane.note.ball.move
        =*  task  task.note.ball.move
        ::
        ~?  !lac.fad
          :-  (runt [(lent bars.gem) '|'] "")
          [%slip [vane.gem vane] (symp +>-.task) duct]
        ::
        (call duct vane task)
      ::
      ::  %give: return move
      ::
          %give
        ?.  ?=(^ duct.move)
          ~>(%mean.'give-no-duct' !!)
        ::
        =/  wire  i.duct.move
        =/  duct  t.duct.move
        =*  gift  gift.ball.move
        ::
        =^  way=term  wire
          ~|  [%give duct.move (symp -.q.p.gift)]
          ?>(?=(^ wire) wire)
        ::
        ~?  &(!lac.fad !=(%$ way) |(!=(%blit +>-.gift) !=(%d vane.gem)))
          :-  (runt [(lent bars.gem) '|'] "")
          :^  %give  vane.gem
            ?:  ?=(%unto +>-.gift)
              [+>-.gift (symp +>+<.gift)]
            (symp +>-.gift)
          duct.move
        ::
        (take duct wire way gift)
      ::
      ::  %hurl: action with error
      ::
          %hurl
        %=  $
          dud       `goof.ball.move
          ball.move  wite.ball.move
        ==
      ==
    ::  +whey: measure memory usage
    ::
    ++  whey
      ^-  mass
      =;  sam=(list mass)
        :+  %arvo  %|
        :~  :+  %hoon  %|
            :~  one+&+..bloq
                two+&+..turn
                tri+&+..year
                qua+&+..sane
                pen+&+..ride
            ==
            hex+&+..part
            pit+&+pit
            lull+|+[dot+&+q typ+&+p ~]:lul.mod
            zuse+|+[dot+&+q typ+&+p ~]:zus.mod
            vane+|+sam
        ==
      ::
      %+  turn
        (sort ~(tap by van.mod) |=([[a=@tas *] [b=@tas *]] (aor a b)))
      =/  bem=beam  [[our %base da+now] /whey]  ::TODO  %base?
      |=  [nam=term =vane]
      =;  mas=(list mass)
        nam^|+(welp mas [dot+&+q.vase typ+&+p.vase sac+&+worm ~]:vane)
      ?~  met=(peek [~ ~] nam bem)  ~
      ?~  u.met  ~
      ~|  mass+nam
      ;;((list mass) q.q.u.u.met)
    ::  +peek: read from the entire namespace
    ::
    ++  peek
      ^-  rook
      |=  [lyc=gang vis=view bem=beam]
      ^-  (unit (unit (cask meta)))
      ::  vane and care may be concatenated
      ::
      =/  [way=term car=term]
        ?^  vis  vis
        ?.  =(2 (met 3 vis))
          [vis %$]
        [(end 3 vis) (rsh 3 vis)]
      ::
      ?:  ?=(%$ way)
        (peek:pith lyc car bem)
      ::
      =.  way  (grow way)
      ?~  van=(~(get by van.mod) way)
        ~
      %.  [lyc car bem]
      peek:spin:(~(plow va [vil u.van]) now peek)
    ::  +call: advance to target
    ::
    ++  call
      |=  [=duct way=term task=maze]
      ^+  this
      ?:  ?=(%$ way)
        ~>  %mean.'arvo: call:pith failed'
        %-  call:pith
        ~>  %mean.'call: bad waif'
        ;;(waif q.p.task)
      ::
      =.  way  (grow way)
      %+  push  [way duct bars.gem]
      ~|  bar-stack=`(list ^duct)`[duct bars.gem]
      %.  task
      call:(spin:(plow way) duct eny dud)
    ::  +take: retreat along call-stack
    ::
    ++  take
      |=  [=duct =wire way=term gift=maze]
      ^+  this
      ?:  ?=(%$ way)
        ::
        ::  the caller was Outside
        ::
        ?>  ?=(~ duct)
        (xeno:pith wire ;;(card q.p.gift))
      ::  the caller was a vane
      ::
      =.  way  (grow way)
      %+  push  [way duct bars.gem]
      ::
      ::  cons source onto .gift to make a $sign
      ::
      ~|  wire=wire
      ~|  bar-stack=`(list ^duct)`[duct bars.gem]
      %.  [wire [vane.gem gift]]
      take:(spin:(plow way) duct eny dud)
    ::  +push: finalize an individual step
    ::
    ++  push
      |=  [gum=germ [zom=vase vax=vase] sac=worm]
      ^+  this
      =^  moz  sac
        (~(refine-moves me sac vil) zom)
      =.  van.mod  (~(put by van.mod) vane.gum [vax sac])
      (emit `plan`[`germ`gum `(list move)`moz])
    ::  +plow: operate on a vane, in time and space
    ::
    ++  plow
      |=  way=term
      ~|  [%plow-failed way]
      =/  =vane
        ~|  [%missing-vane way]
        (~(got by van.mod) way)
      (~(plow va [vil vane]) now peek)
    ::
    ::  |pith: operate on arvo internals
    ::
    ++  pith
      |%
      ++  gest
        |=  =ovum
        ^-  $>(%pass ball)
        =^  way=term  wire.ovum  wire.ovum
        ::
        ::  %$: default, routed to arvo-proper as trivial vase
        ::  @:  route to vane as $hobo
        ::
        =/  =vase
          ?-  way
            %$  noun/card.ovum
            @   [cell/[atom/tas/`%soft %noun] soft/card.ovum]
          ==
        [%pass wire.ovum way &/vase]
      ::
      ::  |what: update engine
      ::
      ::    +kel: (maybe) initiate a kernel update
      ::    +lod: continue with update after kernel +load
      ::    +mod: update the modules of the kernel
      ::
      ++  what
        |_  fil=(list (pair path (cask)))
        ::
        ++  kel
          ^+  ..pith
          =/  del  (~(group adapt fat.mod.sol) fil)
          =/  tub  (~(usurp adapt fat.mod.sol) del)
          ?~  tub
            (mod del |)
          =/  gat  (boot kel.ver.zen [hun arv]:p.u.tub)
          ..pith(but `[gat q.u.tub fil])
        ::
        ++  lod
          |=  kel=(list (pair path (cask)))
          ^+  ..pith
          =.  fat.mod.sol  (~(gas of fat.mod.sol) kel)
          %+  mod
            (~(group adapt fat.mod.sol) fil)
          %+  lien  kel
          |=  [p=path *]
          ?=([%sys ?(%arvo %hoon) *] p)
        ::
        ++  mod
          |=  [del=news all=?]
          ^+  ..pith
          =^  job=oped  fat.mod.sol  (~(adorn adapt fat.mod.sol) del all)
          =?  lul.mod.sol  ?=(^ lul.job)
            (smit:va "lull" pit /sys/lull/hoon u.lul.job)
          =?  zus.mod.sol  ?=(^ zus.job)
            (smit:va "zuse" lul.mod.sol /sys/zuse/hoon u.zus.job)
          %-  %+  need:wyrd   kel.ver.zen
              :~  lull/;;(@ud q:(slap lul.mod.sol limb/%lull))
                  zuse/;;(@ud q:(slap zus.mod.sol limb/%zuse))
              ==
          %=    ..pith
              van.mod
            %+  roll  van.job
            |=  [[nam=term txt=cord] van=_van.mod.sol]
            ^+  van
            =/  nex  (create:va our zus.mod.sol nam /sys/vane/[nam]/hoon txt)
            =/  nav  (~(get by van) nam)
            =?  nex  ?=(^ nav)  (update:va vase.u.nav nex)
            (~(put by van) nam (settle:va nex))
          ==
        --
      ::
      ++  call
        |=  =waif
        ^+  ..pith
        ?^  dud  ~>(%mean.'pith: goof' !!)
        ?-  -.waif
        ::
        ::  %trim: clear state
        ::
        ::    clears compiler caches if high-priority
        ::    XX add separate $wasp if this should happen last
        ::
          %trim  =?  van.mod  =(0 p.waif)
                   (~(run by van.mod) |=(=vane vane(worm *worm)))
                 (emit $/~ (spam /arvo !>(waif)))
        ::
          %verb  ..pith(lac.fad ?~(p.waif !lac.fad u.p.waif))
          %what  ~(kel what p.waif)
          %whey  ..pith(out [[//arvo mass/whey] out])
        ::
            %whiz
          ..pith(van.mod (~(run by van.mod) |=(vane (settle:va:part vase))))
        ==
      ::
      ++  peek
        ^-  roon
        |=  [lyc=gang car=term bem=beam]
        ^-  (unit (unit cage))
        ?.  ?|  =(our p.bem)
                ?=(%$ q.bem)
                =([%da now] p.r.bem)
            ==
          ~
        ?+  s.bem  ~
          [%whey ~]      ``mass/!>(whey)
          [%fad %lac ~]  ``noun/!>(lac.fad)
          [%zen %lag ~]  ``noun/!>(lag.zen)
          [%zen %ver ~]  ``noun/!>(ver.zen)
          [%mod %fat *]  ``noun/!>((~(dip of fat.mod) t.t.s.bem))
        ==
      ::
      ++  poke
        |=  =ovum
        ^+  ..pith
        ?~  wire.ovum
          ~>(%mean.'pith: bad wire' !!)
        ::
        ?.  ?=(?(%crud %wack %wyrd) p.card.ovum)
          (emit $/~ [*duct (gest ovum)] ~)
        ::
        =/  buz  ~>  %mean.'pith: bad wasp'
                 ;;(wasp card.ovum)
        ?-  -.buz
        ::
        ::  %crud: forward error notification
        ::
          %crud  =?  lag.zen  ?&  ?=(%exit mote.goof.buz)
                                  ?=(^ tang.goof.buz)
                                  ?=([%leaf *] i.tang.goof.buz)
                                  ?=(%wyrd (crip p.i.tang.goof.buz))
                              ==
                   ~&(%lagging &)
                 (emit $/~ [*duct hurl/[goof.buz (gest ovum.buz)]] ~)
        ::
        ::  XX review
        ::
          %wack  ..pith(eny (shaz (cat 3 eny p.buz)))
        ::
        ::  %wyrd: check for runtime kelvin compatibility
        ::
          %wyrd  ?.  (sane:wyrd kel.p.buz)
                   ~>(%mean.'wyrd: insane' !!)
                 %-  %+  need:wyrd  kel.p.buz
                     ^-  wynn
                     :~  hoon/hoon-version
                         arvo/arvo
                         lull/;;(@ud q:(slap lul.mod limb/%lull))
                         zuse/;;(@ud q:(slap zus.mod limb/%zuse))
                     ==
                 =?  lag.zen  !=(rev.ver.zen rev.p.buz)  ~&(%unlagging |)
                 ..pith(ver.zen p.buz)
        ==
      ::
      ++  spam
        |=  [=wire =vase]
        ^-  (list move)
        %+  turn
          %+  sort  ~(tap by van.mod)
          |=([[a=@tas *] [b=@tas *]] (aor a b))
        |=([way=term *] `move`[*duct %pass wire way `maze`&/vase])
      ::
      ++  xeno
        |=  =ovum
        ^+  ..pith
        ..pith(out [ovum out])
      --
    --
  --
::
++  symp                                                ::  symbol or empty
  |=  a=*  ^-  @tas
  ?.(&(?=(@ a) ((sane %tas) a)) %$ a)
::
++  boot
  |=  [kel=wynn hun=(unit @t) van=@t]
  ^-  $-(heir (trap ^))
  ~>  %mean.'arvo: upgrade failed'
  ~>  %slog.[0 'arvo: beginning upgrade']
  ?~  hun
    =/  gat
      ~>  %slog.[0 'arvo: compiling next arvo']
      %-  road  |.
      (slap !>(..ride) (rain /sys/arvo/hoon van))
    =/  lod
      (slap (slot 7 gat) [%limb %load])
    |=  =heir
    |.  ~>  %slog.[0 'arvo: +load next']
    ;;(^ q:(slam lod !>(heir)))
  ::
  ::  hyp: hoon core type
  ::  hoc: hoon core
  ::  cop: compiler gate
  ::
  =/  [hyp=* hoc=* cop=*]
    ::  compile new hoon.hoon source with the current compiler
    ::
    =/  raw
      ~>  %slog.[0 'arvo: compiling hoon']
      (road |.((ride %noun u.hun)))
    ::  activate the new compiler gate, producing +ride
    ::
    =/  cop  .*(0 +.raw)
    ::  find the kelvin version number of the new compiler
    ::
    =/  nex
      ;;(@ .*(cop q:(~(mint ut p.raw) %noun [%limb %hoon-version])))
    ::  require single-step upgrade
    ::
    ?.  |(=(nex hoon-version) =(+(nex) hoon-version))
      =*  ud  |=(a=@ (scow %ud a))
      ~_  leaf/"cannot upgrade to hoon %{(ud nex)} from %{(ud hoon-version)}"
      !!
    ::  require runtime compatibility
    ::
    %-  (need:wyrd kel [hoon/nex ~])
    ::
    ::  if we're upgrading language versions, recompile the compiler
    ::
    =^  hot=*  cop
      ?:  =(nex hoon-version)
        [raw cop]
      =/  hot
        ~>  %slog.[0 leaf/"arvo: recompiling hoon %{(scow %ud nex)}"]
        (road |.((slum cop [%noun u.hun])))
      [hot .*(0 +.hot)]
    ::  extract the hoon core from the outer gate (+ride)
    ::
    =/  hoc  .*(cop [%0 7])
    ::  compute the type of the hoon.hoon core
    ::
    =/  hyp  -:(slum cop [-.hot '+>'])
    ::
    [hyp hoc cop]
  ::
  ::  compile arvo
  ::
  =/  rav
    ~>  %slog.[0 'arvo: compiling next arvo']
    (road |.((slum cop [hyp van])))
  ::  activate arvo and extract the arvo core from the outer gate
  ::
  =/  voc  .*(hoc [%7 +.rav %0 7])
  ::
  ::  extract the upgrade gate +load
  ::
  =/  lod
    ::  vip: type of the arvo.hoon core
    ::  fol: formula for the +load gate
    ::
    =/  vip  -:(slum cop [-.rav '+>'])
    =/  fol  +:(slum cop [vip 'load'])
    ::  produce the upgrade gate
    ::
    .*(voc fol)
  ::
  |=  =heir
  |.  ~>  %slog.[1 'arvo: +load next']
  ;;(^ (slum lod heir))
::
++  viol                                                ::  vane tools
  |=  but=type
  ^-  vile
  =+  pal=|=(a=@t ^-(type (~(play ut but) (vice a))))
  :*  typ=(pal '$:type')
      duc=(pal '$:duct')
      wir=(pal '$:wire')
      dud=(pal '=<($ (unit goof))')  ::  XX misparse
  ==
::
++  grow
  |=  way=term
  ?+  way  way
    %a  %ames
    %b  %behn
    %c  %clay
    %d  %dill
    %e  %eyre
    %f  %ford
    %g  %gall
    %i  %iris
    %j  %jael
    %k  %khan
  ==
--  =>
::
::  cached reflexives
::
=/  pit=vase  !>(..part)
=/  vil=vile  (viol p.pit)
::
::  arvo state, as a discriminable sample
::
=|  [_arvo soul]
=*  sol  ->
|%
::  +load: upgrade from previous state
::
++  load                                                ::   +4
  |=  hir=$<(%grub heir)
  ^-  ^
  ~|  %load
  ::  store persistent state
  ::
  =.  sol
    ?-  -.hir
      _arvo  soul.hir
    ==
  ::  clear compiler caches
  ::
  =.  van.mod  (~(run by van.mod) |=(=vane vane(worm *worm)))
  ::
  %-  %+  need:wyrd  kel.ver.zen
      ^-  wynn
      :~  hoon/hoon-version
          arvo/arvo
          lull/;;(@ud q:(slap lul.mod limb/%lull))
          zuse/;;(@ud q:(slap zus.mod limb/%zuse))
      ==
  ::  restore working state and resume
  ::
  =/  zef=(each (pair (list ovum) soul) (trap ^))
    loop:(~(jump le:part [pit vil] sol) debt.hir)
  ?-  -.zef
    %&  [p.p.zef ..load(sol q.p.zef)]
    %|  $:p.zef
  ==
::
::  +peek: external inspect
::
++  peek                                                ::  +22
  |=  $:  lyc=gang
          $=  nom
          %+  each  path
          $%  [%once vis=view syd=desk tyl=spur]
              [%beam vis=view bem=beam]
          ==
      ==
  ^-  (unit (cask))
  =/  hap=(unit [pat=? vis=view bem=beam])
    ?-  nom
      [%& *]        ?~(mon=(de-omen p.nom) ~ `[| u.mon])
      [%| %beam *]  `[| vis bem]:p.nom
      [%| %once *]  `[& vis.p.nom [our syd.p.nom da/now] tyl.p.nom]
    ==
  ::
  ?~  hap  ~
  =/  pro  (~(peek le:part [pit vil] sol) lyc [vis bem]:u.hap)
  ?:  |(?=(~ pro) ?=(~ u.pro))  ~
  =/  dat=(cask)  [p q.q]:u.u.pro
  ?.  pat.u.hap  `dat
  `[%omen (en-omen [vis bem]:u.hap) dat]
::
::  +poke: external apply
::
++  poke                                                ::  +23
  |=  [now=@da ovo=ovum]
  ^-  ^
  ::  this assertion is not yet viable, as vere's timestamps
  ::  are too unreliable. sad!
  ::
  :: ?.  (gth now now.sol)
  ::   ~|  poke/[now=now last=now.sol wire.ovo p.card.ovo]
  ::   ~>(%mean.'time-marches-on' !!)
  ::
  =:  eny.sol  (shaz (cat 3 eny now))  ::  XX review
      now.sol  now
    ==
  ::
  ~|  poke/p.card.ovo
  =/  zef=(each (pair (list ovum) soul) (trap ^))
    loop:(~(poke le:part [pit vil] sol) ovo)
  ?-  -.zef
    %&  [p.p.zef ..poke(sol q.p.zef)]
    %|  $:p.zef
  ==
::
::  +wish: external compute
::
++  wish                                                ::  +10
  |=  txt=@
  q:(slap zus.mod (ream txt))
--  =>
::
::  larval stage
::
::    The true Arvo kernel knows who it is. It should not *maybe*
::    have an identity, nor should it contain multitudes. This outer
::    kernel exists to accumulate identity, entropy, and the
::    standard library. Upon having done so, it upgrades itself into
::    the true Arvo kernel. Subsequent upgrades will fall through
::    the larval stage directly into the actual kernel.
::
::    For convenience, this larval stage also supports hoon compilation
::    with +wish and vane installation with the %veer event.
::
=>  |%
    ++  molt
      |=  [now=@da grub]
      ^-  (unit $>(_arvo heir))
      ?.  &(?=(^ who) ?=(^ eny) ?=(^ ver) ?=(^ fat) ?=(^ lul) ?=(^ zus))
        ~
      =/  lul  $:u.lul
      =/  zus  $:u.zus
      %-  %+  need:wyrd  kel.u.ver
          ^-  wynn
          :~  hoon/hoon-version
              arvo/arvo
              lull/;;(@ud q:(slap lul limb/%lull))
              zuse/;;(@ud q:(slap zus limb/%zuse))
          ==
      =/  nav  %-  ~(run by van)
               |=(a=(trap vase) (settle:va:part (slym $:a u.who)))
      :^  ~  arvo  *debt
      [[u.who now u.eny] [lac] [u.ver |] u.fat lul zus nav]
    ::
    ++  what
      =>  |%
          ++  smit
            |=  [cap=tape sub=(trap vase) pax=path txt=@t]
            ^-  (trap vase)
            ~>  %slog.[0 leaf/"{cap}: {(scow p+(mug txt))}"]
            %-  road  |.
            ~_  leaf/"{cap}: build failed"
            (swat sub (rain pax txt))
          --
      ::
      |=  [grub fil=(list (pair path (cask)))]
      ^-  grub
      =*  gub  +<-
      =/  taf  (fall fat *(axal (cask)))
      =/  del  (~(group adapt:part taf) fil)
      =/  tub  (~(usurp adapt:part taf) del)
      ?:  &(?=(^ dir.taf) ?=(^ tub))
        ~>(%mean.'arvo: larval reboot' !!)    :: XX support
      ::
      ::  require, and unconditionally adopt, initial kernel source
      ::
      =?  taf  =(~ dir.taf)     ::  XX TMI
        ~|  %larval-need-kernel
        ?>  &(?=(^ tub) ?=(^ hun.p.u.tub))
        (~(gas of taf) q.u.tub)
      ::
      =^  job=oped:part  taf  (~(adorn adapt:part taf) del |)
      =?  lul  ?=(^ lul.job)
       `(smit "lull" |.(pit) /sys/lull/hoon u.lul.job)
      =?  zus  ?=(^ zus.job)
        ?.  ?=(^ lul)
         ~|(%larval-need-lull !!)
        `(smit "zuse" u.lul /sys/zuse/hoon u.zus.job)
      =?  van  !=(~ van.job)    ::  XX TMI
        ?.  ?=(^ zus)
         ~|(%larval-need-zuse !!)
        %+  roll  van.job
        |=  [[nam=term txt=cord] =_van]
        ^+  van
        %+  ~(put by van)  nam
        (smit "vane: %{(trip nam)}" u.zus /sys/vane/[nam]/hoon txt)
      gub(fat `taf)
    --
::
::  larval state, as a discriminable sample
::
=|  [%grub _arvo grub]
=*  gub  ->+
::
|%
++  load                                                ::   +4
  |=  hir=heir
  ?:  ?=(%grub -.hir)
    ~>(%mean.'arvo: larval reboot' !!)    :: XX support
  (^load hir)
::
++  peek  _~                                            ::  +22
++  poke                                                ::  +23
  |=  [now=@da ovo=ovum]
  ^-  ^
  ~|  poke/p.card.ovo
  =/  wip
    ~>  %mean.'arvo: bad wisp'
    ;;(wisp card.ovo)
  ::
  =.  ..poke
    ?-    -.wip
      %verb  ..poke(lac ?~(p.wip !lac u.p.wip))
      %wack  ..poke(eny `p.wip)
      %what  ..poke(gub (what gub p.wip))
      %whom  ..poke(who ~|(%whom-once ?>(?=(~ who) `p.wip)))
    ::
      %wyrd  ?.  (sane:wyrd kel.p.wip)
                   ~>(%mean.'wyrd: insane' !!)
             %-  %+  need:wyrd  kel.p.wip
                 ^-  wynn
                 :*  hoon/hoon-version
                     arvo/arvo
                     ?~  lul  ~
                     :-  lull/;;(@ud q:(slap $:u.lul limb/%lull))
                     ?~  zus  ~
                     [zuse/;;(@ud q:(slap $:u.zus limb/%zuse)) ~]
                 ==
             ..poke(ver `p.wip)
    ==
  ::
  ::  upgrade once we've accumulated necessary state
  ::
  ?~  hir=(molt now gub)
    [~ ..poke]
  ~>  %slog.[0 leaf+"arvo: metamorphosis"]
  (load u.hir)
::
++  wish                                                ::  +10
  |=  txt=*
  q:(slap ?~(zus pit $:u.zus) (ream ;;(@t txt)))
--
::
::  Arvo formal interface
::
::    this lifecycle wrapper makes the arvo door (multi-armed core)
::    look like a gate (function or single-armed core), to fit
::    urbit's formal lifecycle function (see aeon:eden:part).
::    a practical interpreter can and will ignore it.
::
|=  [now=@da ovo=ovum]
^-  *
.(+> +:(poke now ovo))