!: 
::  clay (4c), revision control
::
|=  pit=vase
=>  |%
++  bead  ,[p=(set beam) q=gage]                        ::  ford result
++  cult  (map duct rove)                               ::  subscriptions
++  dojo                                                ::  domestic desk state
          $:  qyx=cult                                  ::  subscribers
              dom=dome                                  ::  desk data
              dok=(unit dork)                           ::  outstanding diffs
              mer=(map (pair ship desk) mery)           ::  outstanding merges
          ==                                            ::
++  gift                                                ::  out result <-$
          $%  [%ergo p=@p q=@tas r=@ud s=(list ,[path (unit mime)])]
                                                        ::  version update
              [%note p=@tD q=tank]                      ::  debug message
              [%writ p=riot]                            ::  response
          ==                                            ::
++  khan                                                ::
          $:  fil=(unit (unit cage))                    ::
              dir=(map ,@ta khan)                       ::
          ==                                            ::
++  kiss                                                ::  in request ->$
          $%  [%font p=@p q=@tas r=@p s=@tas]           ::  set upstream
              [%info p=@p q=@tas r=nori]                ::  internal edit
              [%init p=@p]                              ::  report install
              [%into p=@p q=@tas r=khan]                ::  external edit
              [%merg p=@p q=@tas r=@p s=@tas t=germ]    ::  merge desks
              [%plug p=@p q=@tas r=@p s=@tas]           ::  unset upstream
              [%wart p=sock q=@tas r=path s=*]          ::  network request
              [%warp p=sock q=riff]                     ::  file request
          ==                                            ::
++  mery                                                ::
          $:  gem=germ                                  ::  strategy
              cas=case                                  ::  ali's case
              ali=yaki                                  ::  ali's commit
              bob=yaki                                  ::  bob's commit
              bas=yaki                                  ::  mergebase
              dal=(map path cage)                       ::  diff(bas,ali)
              dob=(map path cage)                       ::  diff(bas,bob)
              new=yaki                                  ::  merge(dal,dob)
              ank=ankh                                  ::  new state
              erg=(map path ,?)                         ::  ergoable changes
          ==                                            ::
++  moot  ,[p=case q=case r=path s=(map path lobe)]     ::  stored change range
++  move  ,[p=duct q=(mold note gift)]                  ::  local move
++  nako  $:  gar=(map ,@ud tako)                       ::  new ids
              let=@ud                                   ::  next id
              lar=(set yaki)                            ::  new commits
              bar=(set blob)                            ::  new content
          ==                                            ::
++  note                                                ::  out request $->
          $%  $:  %a                                    ::  to %ames
          $%  [%want p=sock q=path r=*]                 ::
          ==  ==                                        ::
              $:  %c                                    ::  to %clay
          $%  [%font p=@p q=@tas r=@p s=@tas]           ::
              [%info p=@p q=@tas r=nori]                ::  internal edit
              [%merg p=@p q=@tas r=mizu]                ::
              [%warp p=sock q=riff]                     ::
          ==  ==                                        ::
              $:  %d                                    ::
          $%  [%flog p=[%crud p=@tas q=(list tank)]]    ::  to %dill
          ==  ==                                        ::
              $:  %f                                    ::
          $%  [%exec p=@p q=(unit silk)]                ::
          ==  ==                                        ::
              $:  %t                                    ::
          $%  [%wait p=@da]                             ::
              [%rest p=@da]                             ::
          ==  ==  ==                                    ::
++  sign                                                ::  in result $<-
          $?  $:  %a                                    ::  by %ames
          $%  [%waft p=sock q=*]                        ::
              [%went p=ship q=cape]                     ::
          ==  ==                                        ::
              $:  %c                                    ::  by %clay
          $%  [%writ p=riot]                            ::
          ==  ==                                        ::
              $:  %f                                    ::
          $%  [%made p=(each bead (list tank))]         ::
          ==  ==                                        ::
              $:  %t                                    ::
          $%  [%wake ~]                                 ::  timer activate
          ==  ==                                        ::
              $:  @tas                                  ::  by any
          $%  [%crud p=@tas q=(list tank)]              ::
          ==  ==  ==                                    ::
++  silk                                                ::  construction layer
          $&  [p=silk q=silk]                           ::  cons
          $%  [%bake p=mark q=beam r=path]              ::  local synthesis
              [%boil p=mark q=beam r=path]              ::  general synthesis
              [%call p=silk q=silk]                     ::  slam
              [%cast p=mark q=silk]                     ::  translate
              [%diff p=silk q=silk]                     ::  diff
              [%done p=(set beam) q=gage]               ::  literal
              [%dude p=tank q=silk]                     ::  error wrap
              [%dune p=(set beam) q=(unit gage)]        ::  unit literal
              [%mute p=silk q=(list (pair wing silk))]  ::  mutant
              [%pact p=silk q=silk]                     ::  patch
              [%reef ~]                                 ::  kernel reef
              [%ride p=twig q=silk]                     ::  silk thru twig
              [%tabl p=(list (pair silk silk))]         ::  list
              [%vale p=mark q=ship r=*]                 ::  validate [our his]
          ==                                            ::
++  raft                                                ::  filesystem
          $:  fat=(map ship room)                       ::  domestic
              hoy=(map ship rung)                       ::  foreign
              ran=rang                                  ::  hashes
              sor=(map ,[p=@p q=@tas r=@p s=@tas] duct) ::  upstreams
          ==                                            ::
++  rave                                                ::  general request
          $%  [& p=mood]                                ::  single request
              [| p=moat]                                ::  change range
          ==                                            ::
++  rede                                                ::  universal project
          $:  lim=@da                                   ::  complete to
              qyx=cult                                  ::  subscribers
              ref=(unit rind)                           ::  outgoing requests
              dom=dome                                  ::  revision state
              dok=(unit dork)                           ::  outstanding diffs
              mer=(map (pair ship desk) mery)           ::  outstanding merges
          ==                                            ::
++  riff  ,[p=desk q=(unit rave)]                       ::  request/desist
++  rind                                                ::  request manager
          $:  nix=@ud                                   ::  request index
              bom=(map ,@ud ,[p=duct q=rave])           ::  outstanding
              fod=(map duct ,@ud)                       ::  current requests
              haw=(map mood (unit cage))                ::  simple cache
          ==                                            ::
++  room                                                ::  fs per ship
          $:  hun=duct                                  ::  terminal duct
              hez=(unit duct)                           ::  sync duct
              dos=(map desk dojo)                       ::  native desk
          ==                                            ::
++  rove  (each mood moot)                              ::  stored request
++  rung  $:  rus=(map desk rede)                       ::  neighbor desks
          ==                                            ::
++  dork                                                ::  diff work
          $:  sot=(list ,[p=path q=misu])               ::
              lon=(list path)                           ::
              mim=(map path mime)                       ::
          ==                                            ::
--  =>
::::::::::::::::::::::::::::::::::::::::::::::::::::::::
::              section 4cA, filesystem logic         ::
::
::
::
|%
++  de                                                ::  per desk
  |=  [now=@da hen=duct hun=duct hez=(unit duct)]
  |=  [[who=@p for=@p] syd=@ta rede ran=rang]
  =*  red  +<+>-
  =|  yel=(list ,[p=duct q=gift])
  =|  byn=(list ,[p=duct q=riot])
  =|  reg=(list ,[p=duct q=gift])
  =|  say=(list ,[p=duct q=path r=ship s=[p=@ud q=riff]])
  =|  tag=(list ,[p=duct q=path r=note])
  |%
  ++  abet
    ^-  [(list move) rede]
    :_  red
    ;:  weld
      %+  turn  (flop yel)
      |=([a=duct b=gift] [hun %give b])
    ::
      %+  turn  (flop byn)
      |=([a=duct b=riot] [a %give [%writ b]])
    ::
      %+  turn  (flop reg)
      |=([a=duct b=gift] [a %give b])
    ::
      %+  turn  (flop say)
      |=  [a=duct b=path c=ship d=[p=@ud q=riff]]
      :-  a
      [%pass b %a %want [who c] [%q %re p.q.d (scot %ud p.d) ~] q.d]
    ::
      %+  turn  (flop tag)
      |=([a=duct b=path c=note] [a %pass b c])
    ==
  ::
  ++  aver                                            ::  read
    |=  mun=mood
    ^-  (unit (unit cage))
    ?:  &(=(p.mun %u) !=(p.q.mun now))                ::  prevent bad things
      ~&  [%clay-fail p.q.mun %now now]
      !!
    =+  ezy=?~(ref ~ (~(get by haw.u.ref) mun))
    ?^  ezy  ezy
    =+  nao=(case-to-aeon:ze q.mun)
    ::  ~&  [%aver-mun nao [%from syd lim q.mun]]
    ?~(nao ~ [~ (read-at-aeon:ze u.nao mun)])
  ::
  ++  balk                                          ::  read and send
    |=  [hen=duct yon=@ud mun=mood]
    ^+  +>
    =+  vid=(read-at-aeon:ze yon mun)
    ?~  vid  (blub hen)  (blab hen mun u.vid)
  ::
  ++  bait
    |=  [hen=duct tym=@da]
    %_(+> tag :_(tag [hen /tyme %t %wait tym]))
  ::
  ++  best
    |=  [hen=duct tym=@da]
    %_(+> tag :_(tag [hen /tyme %t %rest tym]))
  ::
  ++  blab                                            ::  ship result
    |=  [hen=duct mun=mood dat=cage]
    ^+  +>
    +>(byn [[hen ~ [p.mun q.mun syd] r.mun dat] byn])
  ::
  ++  bleb                                            ::  ship sequence
    |=  [hen=duct ins=@ud hip=nako]
    ^+  +>
    (blab hen [%w [%ud ins] ~] %nako !>(hip))
  ::
  ++  blub                                            ::  ship stop
    |=  hen=duct
    %_(+> byn [[hen ~] byn])
  ::
  ++  duce                                            ::  produce request
    |=  rov=rove
    ^+  +>
    =.  qyx  (~(put by qyx) hen rov)
    ?~  ref
      (mabe rov (cury bait hen))
    |-  ^+  +>+.$                                     ::  XX  why?
    =+  rav=(reve rov)
    =+  ^=  vaw  ^-  rave
      ?.  ?=([%& %v *] rav)  rav
      [%| [%ud let.dom] `case`q.p.rav r.p.rav]
    =+  inx=nix.u.ref
    %=  +>+.$
      say        [[hen [(scot %ud inx) ~] for [inx syd ~ vaw]] say]
      nix.u.ref  +(nix.u.ref)
      bom.u.ref  (~(put by bom.u.ref) inx [hen vaw])
      fod.u.ref  (~(put by fod.u.ref) hen inx)
    ==
  ::
  ++  ease                                            ::  release request
    ^+  .
    ?~  ref
      =+  rov=(~(got by qyx) hen)
      =.  qyx  (~(del by qyx) hen)
      (mabe rov (cury best hen))
    =.  qyx  (~(del by qyx) hen)
    |-  ^+  +.$
    =+  nux=(~(get by fod.u.ref) hen)
    ?~  nux  +.$
    %=  +.$
      say        [[hen [(scot %ud u.nux) ~] for [u.nux syd ~]] say]
      fod.u.ref  (~(del by fod.u.ref) hen)
      bom.u.ref  (~(del by bom.u.ref) u.nux)
    ==
  ::
  ++  eave                                            ::  subscribe
    |=  rav=rave
    ^+  +>
    ?-    -.rav
        &
      ?:  &(=(p.p.rav %u) !=(p.q.p.rav now))
        ~&  [%clay-fail p.q.p.rav %now now]
        !!
      =+  ver=(aver p.rav)
      ?~  ver
        (duce rav)
      ?~  u.ver
        (blub hen)
      (blab hen p.rav u.u.ver)
    ::
        |
      =+  nab=(case-to-aeon:ze p.p.rav)
      ?~  nab
        ?>  =(~ (case-to-aeon:ze q.p.rav))
        (duce (rive rav))
      =+  huy=(case-to-aeon:ze q.p.rav)
      ?:  &(?=(^ huy) |((lth u.huy u.nab) &(=(0 u.huy) =(0 u.nab))))
        (blub hen)
      =+  top=?~(huy let.dom u.huy)
      =+  sar=(lobes-at-path:ze u.nab r.p.rav)
      =+  ear=(lobes-at-path:ze top r.p.rav)
      =.  +>.$
        ?:  =(sar ear)  +>.$
        =+  fud=(make-nako:ze u.nab top)
        (bleb hen u.nab fud)
      ?^  huy
        (blub hen)
      =+  ^=  ptr  ^-  case
          [%ud +(let.dom)]
      (duce `rove`[%| ptr q.p.rav r.p.rav ear])
    ==
  ::
  ++  echa                                            ::  announce raw
    |=  [wen=@da mer=mizu]
    ^+  +>
    %=    +>
        reg  ~&  %merge-announce  reg
             ::  ?~(hez reg :_(reg [u.hez [%ergo who syd let.dom]]))
        ::  yel  [[hen %note '=' %leaf ~] yel]     ::  XX do better
    ==
  ::
  ++  echo                                            ::  announce changes
    |=  [wen=@da mim=(map path mime) lem=nori]
    ^+  +>
    %_    +>.$
        yel
      =+  pre=`path`~[(scot %p for) syd (scot %ud let.dom)]
      ?-  -.lem
        |  :_  yel
           [hen %note '=' %leaf :(weld (trip p.lem) " " (spud pre))]
        &  |-  ^+  yel
           ?~  q.p.lem  yel
           :_  $(q.p.lem t.q.p.lem)
           :-  hen
           :+  %note
             ?-(-.q.i.q.p.lem %del '-', %ins '+', %mut ':', %dif ';')
           [%leaf (spud (weld pre p.i.q.p.lem))]
      ==
    ==
  ::
  ++  edit                                            ::  apply changes
    |=  [wen=@da lem=nori]
    ^+  +>
    ?:  ?=(%| -.lem)
      =^  hat  +>.$
        (edit:ze wen lem)
      ?~  hat
        +>.$
      (echo:(checkout-ankh u.hat) wen ~ lem)
    ?.  =(~ dok)
      ~&  %already-applying-changes  +>
    =+  ^=  sop
        |=  [a=path b=miso]
        ^-  ?
        ?|  ?=(%del -.b) 
            ?&  ?=(%ins -.b)
                ?=(%mime p.p.b)
                =+  (slag (dec (lent a)) a)
                ?|  =([%hook ~] -)
                    =([%hoon ~] -)
        ==  ==  ==
    =+  ^-  lon=(list path)
        (murn q.p.lem |=([a=path b=miso] ?:((sop a b) ~ (some a))))
    =+  ^-  sot=(list ,[p=path q=misu])
        %+  murn  q.p.lem
        |=([a=path b=miso] ?.((sop a b) ~ (some [a ?<(?=(%mut -.b) b)])))
    =+  ^-  mim=(map path mime)
        %-  mo
        ^-  (list ,[path mime])
        %+  murn  q.p.lem
        |=  [a=path b=miso]
        ?-  -.b
          %del  ~
          %ins  ?.(?=(%mime p.p.b) ~ (some a ((hard mime) q.q.p.b)))
          %dif  ~
          %mut  ?.(?=(%mime p.q.b) ~ (some a ((hard mime) q.q.q.b)))
        ==
    =.  dok  `[sot lon mim]
    ?~  lon
      (apply-edit wen)
    =+  ^-  los=(list ,[duct path note])
        %+  murn  q.p.lem
        |=([a=path b=miso] ?:((sop a b) ~ (some (silkify wen a b))))
    %_(+>.$ tag (welp los tag))
  ::
  ++  silkify
    |=  [wen=@da pax=path mis=miso]
    ^-  [duct path note]
    :-  hen
    ?+    -.mis  !!
        %mut
      :-  [%diffing (scot %p who) syd (scot %da wen) pax]
      :^  %f  %exec  who  :-  ~
      ^-  silk
      =+  =+  (slag (dec (lent pax)) pax)
          =+  ?~(- %$ i.-)
          [%cast - [%done ~ q.mis]]
      [%diff [%done ~ p.mis] -]
    ::
        %ins
      :-  [%casting (scot %p who) syd (scot %da wen) pax]
      :^  %f  %exec  who  :-  ~
      ^-  silk
      =+  (slag (dec (lent pax)) pax)
      =+  ?~(- %$ i.-)
      [%cast - [%done ~ p.mis]]
    ==
  ::
  ++  patch
    |=  [pax=path bar=lobe]
    ^-  [duct path note]
    :^    hen
        [%patching (scot %p who) syd pax]
      %f
    :^  %exec  who  ~
    |-  ^-  silk
    =+  bob=(~(got by lat.ran) bar)
    ?-  -.bob
      %direct    [%done ~ q.bob]
      %indirect  [%done ~ q.bob]
      %delta     [%pact $(bar q.bob) [%done ~ r.bob]]
    ==
  ::
  ++  apply-edit
    |=  wen=@da
    ^+  +>
    =+  ^=  hat
        (edit:ze wen %& *cart ?~(dok ~|(%no-changes !!) sot.u.dok))
    ?~  dok  ~&  %no-changes  !!
    ?^  lon.u.dok  ~&  %not-done-diffing  !!
    ?~  -.hat
      ([echo(dok ~)]:.(+>.$ +.hat) wen mim.u.dok %& *cart sot.u.dok)
    (checkout-ankh(lat.ran lat.ran.+.hat) u.-.hat)
  ::
  ++  take-cast
    |=  [wen=@da pax=path res=(each bead (list tank))]
    ^+  +>
    ?~  dok
      ~&  %clay-unexpected-made  +>.$
    ?.  (lien lon.u.dok |=(path =(+< pax)))
      ~&  %clay-strange-made  +>.$
    ?:  ?=(%| -.res)
      %_    +>.$
          dok  ~
        ::  XX should be here
        ::    tag
        ::  %-  welp  :_  tag
        ::  ^-  (list ,[duct path note])
        ::  %+  murn  lon.u.dok
        ::  |=  a=path
        ::  ^-  (unit ,[duct path note])
        ::  ?:  =(pax a)  ~
        ::  `[hen [%diffing (scot %p who) syd (scot %da wen) a] %f %exec who ~]
      ::
          yel
        [[hen %note '!' %rose [" " "" ""] leaf/"clay diff failed" p.res] yel]
      ==
    ?.  ?=(@ p.q.p.res)  ~|  %bad-marc  !!
    =:  lon.u.dok  (skip lon.u.dok |=(path =(+< pax)))
        sot.u.dok  [[pax %ins q.p.res] sot.u.dok]
    ==
    ?~  lon.u.dok
      (apply-edit wen)
    +>.$
  ::
  ++  take-diff
    |=  [wen=@da pax=path res=(each bead (list tank))]
    ^+  +>
    ?~  dok
      ~&  %clay-unexpected-made  +>.$
    ?.  (lien lon.u.dok |=(path =(+< pax)))
      ~&  %clay-strange-made  +>.$
    ?:  ?=(%| -.res)
      %_    +>.$
          dok  ~
        ::    tag
        ::  %-  welp  :_  tag
        ::  ^-  (list ,[duct path note])
        ::  %+  murn  lon.u.dok
        ::  |=  a=path
        ::  ^-  (unit ,[duct path note])
        ::  ?:  =(pax a)  ~
        ::  `[hen [%diffing (scot %p who) syd (scot %da wen) a] %f %exec who ~]
      ::
          yel
        [[hen %note '!' %rose [" " "" ""] leaf/"clay diff failed" p.res] yel]
      ==
    ?.  ?=(@ p.q.p.res)  ~|  %bad-marc  !!
    =:  lon.u.dok  (skip lon.u.dok |=(path =(+< pax)))
        sot.u.dok  ?:  =(%null p.q.p.res)
                     sot.u.dok
                   [[pax %dif q.p.res] sot.u.dok]
    ==
    ?~  lon.u.dok
      (apply-edit wen)
    +>.$
  ::
  ++  take-patch
    |=  res=(each bead (list tank))
    ^+  +>
    ?:  ?=(%| -.res)  
      %_    +>.$
          dok  ~
          yel
        [[hen %note '!' %rose [" " "" ""] leaf/"clay patch failed" p.res] yel]
      ==
    =^  hat  +>.$
      (edit:ze now %& *cart ?~(dok ~|(%no-changes !!) sot.u.dok))
    =.  +>.$  wake
    ?~  dok  ~&  %no-dok  +>.$
    ?^  lon.u.dok  ~&  %not-done-diffing  !!
    =>
      %=    .
          +>.$
        ?<  ?=(~ hat)
        %^    echo ::  :(checkout-ankh u.hat)
            now
          mim.u.dok
        [%& *cart sot.u.dok]
      ==
    ?~  dok  ~&  %no-dok  +>.$
    ?^  lon.u.dok  ~&  %not-done-diffing  !!
    =+  cay=q.p.res
    ?@  p.cay  ~|  %patch-bad-marc  !!
    =+  ^=  can
        |-  ^-  (list ,[path cage])
        ?~  p.p.cay
          ~
        :_  %_($ cay [[%tabl t.p.p.cay] (slot 3 q.cay)])
        ?.  ?=(%path p.i.p.p.cay)
          ~|  %patch-strange-marc-a
          !!
        ?.  ?=(@ q.i.p.p.cay)
          ~|  %patch-strange-marc-b
          !!
        =+  coy=(slot 2 q.cay)
        ?@  q.coy
          ~|  %patch-strange-coy
          !!
        :-  ((hard path) -.q.coy)
        [q.i.p.p.cay (slot 3 coy)]
    =.  ank.dom  (checkout-ankh:ze (mo can))
    ?~  hez  +>.$(dok ~)
    =+  ^=  ceq
        |=  a=miso
        ?|  ?=(%del -.a)
            &(?=(%ins -.a) ?=(%mime -.+.a))
            &(?=(%mut -.a) ?=(%mime -.+>.a))
        ==
    %_    +>.$
        dok  ~
        tag  ::  ?~(hez reg :_(reg [u.hez [%ergo who syd let.dom]]))
      :_  tag
      :^    hen
          [%ergoing (scot %p who) syd ~]
        %f
      :^  %exec  who  ~  :-  %tabl
      ^-  (list (pair silk silk))
      %+  turn  sot.u.dok
      |=  [a=path b=misu]
      ^-  (pair silk silk)
      :-  [%done ~ %path !>(a)]
      ?:  ?=(%del -.b)
        [%done ~ %null !>(~)]
      :^  %cast  %mime  %done
      =+  (~(get by mim.u.dok) a)
      `?^(- [%mime !>(u.-)] (need (read:ze %x [%ud let.dom] a)))
    ==
  ::
  ++  take-ergo
    |=  res=(each bead (list tank))
    ^+  +>
    ?:  ?=(%| -.res)
      %_    +>.$
          yel
        [[hen %note '!' %rose [" " "" ""] leaf/"clay ergo failed" p.res] yel]
      ==
    ?~  hez  ~&  %no-sync-duct  !!
    =+  cay=q.p.res
    ?@  p.cay  ~|  %patch-bad-marc  !!
    %=    +>.$
        reg
      :_  reg
      :*  u.hez  %ergo  who  syd  let.dom
          |-  ^-  (list ,[path (unit mime)])
          ?~  p.p.cay
            ~
          :_  %_($ cay [[%tabl t.p.p.cay] (slot 3 q.cay)])
          ?.  ?=(%path p.i.p.p.cay)
            ~|  %ergo-strange-marc-a
            !!
          ?.  ?=(@ q.i.p.p.cay)
            ~|  %ergo-strange-marc-b
            !!
          =+  coy=(slot 2 q.cay)
          ?@  q.coy
            ~|  %ergo-strange-coy
            !!
          :-  ((hard path) -.q.coy)
          ?.  ?=(%mime q.i.p.p.cay)
            ~
          `((hard mime) q:(slot 3 coy))
      ==
    ==
  ::
  ++  checkout-ankh
    |=  hat=(map path lobe)
    ^+  +>
    %_    +>.$
        tag
      :_  tag
      :^    hen
          [%patching (scot %p who) syd ~]
        %f
      :^  %exec  who  ~  :-  %tabl
      ^-  (list (pair silk silk))
      %+  turn  (~(tap by hat))
      |=  [a=path b=lobe]
      ^-  (pair silk silk)
      :-  [%done ~ %path !>(a)]
      |-  ^-  silk
      =+  bob=(~(got by lat.ran) b)
      ?-  -.bob
        %direct     [%done ~ q.bob]
        %indirect   [%done ~ q.bob]
        %delta      [%pact $(b q.bob) [%done ~ r.bob]]
      ==
    ==
  ::
  ++  edis                                            ::  apply subscription
    |=  nak=nako
    ^+  +>
    %=  +>
      hit.dom  (~(uni by hit.dom) gar.nak)
      let.dom  let.nak
      lat.ran  %+  roll  (~(tap in bar.nak) ~)
               =<  .(yeb lat.ran)
               |=  [sar=blob yeb=(map lobe blob)]
               =+  zax=(blob-to-lobe sar)
               %+  ~(put by yeb)  zax  sar
      hut.ran  %+  roll  (~(tap in lar.nak) ~)
               =<  .(yeb hut.ran)
               |=  [sar=yaki yeb=(map tako yaki)]
               %+  ~(put by yeb)  r.sar  sar
    ==
  ::
  ++  exec                                            ::  change and update
    |=  [wen=@da lem=nori]
    ^+  +>
    wake:(edit wen lem)
  ::
  ++  exem                                            ::  execute merge
    |=  [wen=@da her=@p sud=@tas gem=germ]            ::  aka direct change
    !!
    ::  ?.  (gte p.mer let.dom)  !!                       ::  no
    ::  =.  +>.$  %=  +>.$
    ::              hut.ran  (~(uni by hut.r.mer) hut.ran)
    ::              lat.ran  (~(uni by lat.r.mer) lat.ran)
    ::              let.dom  p.mer
    ::              hit.dom  (~(uni by q.mer) hit.dom)
    ::            ==
    ::  =+  ^=  hed                                       ::  head commit
    ::      =<  q
    ::      %-  ~(got by hut.ran)
    ::      %-  ~(got by hit.dom)
    ::      let.dom
    ::  (echa:wake:(checkout-ankh hed))
  ::
  ++  knit                                            ::  external change
    |=  [inx=@ud rot=riot]
    ^+  +>
    ?>  ?=(^ ref)
    |-  ^+  +>+.$
    =+  ruv=(~(get by bom.u.ref) inx)
    ?~  ruv  +>+.$
    =>  ?.  |(?=(~ rot) ?=(& -.q.u.ruv))  .
        %_  .
          bom.u.ref  (~(del by bom.u.ref) inx)
          fod.u.ref  (~(del by fod.u.ref) p.u.ruv)
        ==
    ?~  rot
      =+  rav=`rave`q.u.ruv
      %=    +>+.$
          lim
        ?.(&(?=(| -.rav) ?=(%da -.q.p.rav)) lim `@da`p.q.p.rav)
      ::
          haw.u.ref
        ?.  ?=(& -.rav)  haw.u.ref
        (~(put by haw.u.ref) p.rav ~)
      ==
    ?<  ?=(%v p.p.u.rot)
    =.  haw.u.ref
      (~(put by haw.u.ref) [p.p.u.rot q.p.u.rot q.u.rot] ~ r.u.rot)
    ?.  ?=(%w p.p.u.rot)  +>+.$
    |-  ^+  +>+.^$
    =+  nez=[%w [%ud let.dom] ~]
    =+  nex=(~(get by haw.u.ref) nez)
    ?~  nex  +>+.^$
    ?~  u.nex  +>+.^$  ::  should never happen
    =.  +>+.^$
      =+  roo=(edis ((hard nako) q.q.u.u.nex))
      ?>(?=(^ ref.roo) roo)
    %=  $
      haw.u.ref  (~(del by haw.u.ref) nez)
    ==
  ::
  ++  mabe                                            ::  maybe fire function
    |*  [rov=rove fun=$+(@da _+>.^$)]
    ^+  +>.$
    %-  fall  :_  +>.$
    %-  bind  :_  fun
    ^-  (unit ,@da)
    ?-    -.rov
        %&
      ?.  ?=(%da -.q.p.rov)  ~
      `p.q.p.rov
        %|
      =*  mot  p.rov
      %+  hunt
        ?.  ?=(%da -.p.mot)  ~
        ?.((lth now p.p.mot) ~ [~ p.p.mot])
      ?.  ?=(%da -.q.mot)  ~
      ?.((lth now p.q.mot) [~ now] [~ p.q.mot])
    ==
  ::
  ++  reve
    |=  rov=rove
    ^-  rave
    ?:  ?=(%& -.rov)  rov
    [%| p.p.rov q.p.rov r.p.rov]
  ::
  ++  rive
    |=  rav=[%| p=moat]
    ^-  rove
    [%| p.p.rav q.p.rav r.p.rav ~]
  ::
  ++  merge-desks
    |=  [her=@p sud=@tas gem=germ rot=riot]
    ^+  +>.$
    ?~  rot
      ~&  "autosync from {<sud>} on {<her>} to {<syd>} on {<who>} stopped"
      +>.$
    ?:  ?=(%y p.p.u.rot)
      %=    +>.$
          yel
        [[hen %note ';' %leaf "starting to sync desk {(trip syd)}..."] yel]
          tag
        :_  tag
        :*  hen  /auto/(scot %p who)/[syd]/(scot %p her)/[sud]/v
            %c  %warp  [who her]  sud
            `[%& %v q.p.u.rot /]
        ==
      ==
    ?>  ?=(%v p.p.u.rot)
    =+  der=((hard dome) r.u.rot)
    =+  ^=  lum
        ^-  (unit (unit mizu))
        ~
        ::%^  construct-merge:ze
        ::    ?:(=(0 let.dom) %init %meld)
        ::  who
        :::+  syd
        ::  `saba`[her sud [0 let.der] der]
        ::now
    ?~  lum
      ~&  "autosync from {<sud>} on {<her>} to {<syd>} on {<who>} failed"
      ~&  "please merge manually"
      +>.$
    ?~  u.lum
      ~&  "autosync from {<sud>} on {<her>} to {<syd>} on {<who>} up to date"
      +>.$
    %=    +>.$
        yel
      [[hen %note ';' %leaf "successfully synced desk {(trip syd)}..."] yel]
        tag
      :_  tag
      :*  hen  /auto/(scot %p who)/[syd]/(scot %p her)/[sud]/merg
          %c  %merg  who  syd  u.u.lum
      ==
    ==
  ::
  ++  wake                                            ::  update subscribers
    ^+  .
    =+  xiq=(~(tap by qyx) ~)
    =|  xaq=(list ,[p=duct q=rove])
    |-  ^+  ..wake
    ?~  xiq
      ..wake(qyx (~(gas by *cult) xaq))
    ?-    -.q.i.xiq
        &
      =+  cas=?~(ref ~ (~(get by haw.u.ref) `mood`p.q.i.xiq))
      ?^  cas
        %=    $
            xiq  t.xiq
            ..wake  ?~  u.cas  (blub p.i.xiq)
                    (blab p.i.xiq p.q.i.xiq u.u.cas)
        ==
      =+  nao=(case-to-aeon:ze q.p.q.i.xiq)
      ?~  nao  $(xiq t.xiq, xaq [i.xiq xaq])
      $(xiq t.xiq, ..wake (balk p.i.xiq u.nao p.q.i.xiq))
    ::
        |
      =+  mot=`moot`p.q.i.xiq
      =+  nab=(case-to-aeon:ze p.mot)
      ?~  nab
        $(xiq t.xiq, xaq [i.xiq xaq])
      =+  huy=(case-to-aeon:ze q.mot)
      ?~  huy
        =+  ptr=[%ud +(let.dom)]
        %=  $
          xiq     t.xiq
          xaq     [[p.i.xiq [%| ptr q.mot r.mot s.mot]] xaq]
          ..wake  =+  ^=  ear
                      (lobes-at-path:ze let.dom r.p.q.i.xiq)
                  ?:  =(s.p.q.i.xiq ear)  ..wake
                  =+  fud=(make-nako:ze u.nab let.dom)
                  (bleb p.i.xiq let.dom fud)
        ==
      %=  $
        xiq     t.xiq
        ..wake  =-  (blub:- p.i.xiq)
                =+  ^=  ear
                    (lobes-at-path:ze u.huy r.p.q.i.xiq)
                ?:  =(s.p.q.i.xiq ear)  (blub p.i.xiq)
                =+  fud=(make-nako:ze u.nab u.huy)
                (bleb p.i.xiq +(u.nab) fud)
      ==
    ==
  ++  ze
    |%
    ++  aeon-to-tako  ~(got by hit.dom)
    ++  aeon-to-yaki  (cork aeon-to-tako tako-to-yaki)
    ++  lobe-to-blob  ~(got by lat.ran)                 ::  grab blob
    ++  tako-to-yaki  ~(got by hut.ran)
    ++  make-direct                                     ::  make blob
      |=  [p=cage]
      ^-  blob
      [%direct (mug p) p]
    ::
    ++  make-delta                                      ::  make blob delta
      |=  [p=lobe q=cage]
      ^-  blob
      =+  t=[%delta 0 p q]
      =+  ^=  has
          %^  cat  7  (sham [%blob q.q.q])
          (sham [%lobe p])
      [%delta has p q]
    ::
    ++  make-yaki                                       ::  make yaki
      |=  [p=(list tako) q=(map path lobe) t=@da]
      ^-  yaki
      =+  ^=  has
          %^  cat  7  (sham [%yaki (roll p add) q t])
          (sham [%tako (roll p add) q t])
      [p q has t]
    ::
    ++  apply-changes                                   ::   apply-changes:ze
      |=  lar=(list ,[p=path q=misu])                   ::  store changes
      ^-  (map path blob)
      =+  ^=  hat                                       ::  current state
          ?:  =(let.dom 0)                                  ::  initial commit
            ~                                           ::  has nothing
          =<  q
          %-  aeon-to-yaki
          let.dom
      =-  =+  sar=(sa (turn lar |=([p=path *] p)))      ::  changed paths
          %+  roll  (~(tap by hat) ~)                   ::  find unchanged
          =<  .(bat bar)
          |=  [[pat=path gar=lobe] bat=(map path blob)]
          ?:  (~(has in sar) pat)                       ::  has update
            bat
          %+  ~(put by bat)  pat
          ~|((crip <pat gar (lent (~(tap by lat.ran)))>) (lobe-to-blob gar)) ::  use original
      ^=  bar  ^-  (map path blob)
      %+  roll  lar
      |=  [[pat=path mys=misu] bar=(map path blob)]
      ^+  bar
      ?-    -.mys
          %ins                                          ::  insert if not exist
        ?:  (~(has by bar) pat)  !!                     ::
        ?:  (~(has by hat) pat)  !!                     ::
        %+  ~(put by bar)  pat
        %-  make-direct
        ?:  &(?=(%mime -.p.mys) =([%hook ~] (slag (dec (lent pat)) pat)))
          `cage`[%hook [%atom %t] +.+.q.q.p.mys]
        ?:  &(?=(%mime -.p.mys) =([%hoon ~] (slag (dec (lent pat)) pat)))
          `cage`[%hoon [%atom %t] +.+.q.q.p.mys]
        p.mys
          %del                                          ::  delete if exists
        ?.  |((~(has by hat) pat) (~(has by bar) pat))  !!
        (~(del by bar) pat)
          %dif                                          ::  mutate, must exist
        =+  ber=(~(get by bar) pat)                     ::  XX  typed
        ?~  ber
          =+  har=(~(get by hat) pat)
          ?~  har  !!
          %+  ~(put by bar)  pat
          (make-delta u.har p.mys)
        %+  ~(put by bar)  pat
        (make-delta p.u.ber p.mys)
      ==
    ::
    ++  as-arch
      ^-  arch
      :+  p.ank.dom
        ?~(q.ank.dom ~ [~ p.u.q.ank.dom])
      |-  ^-  (map ,@ta ,~)
      ?~  r.ank.dom  ~
      [[p.n.r.ank.dom ~] $(r.ank.dom l.r.ank.dom) $(r.ank.dom r.r.ank.dom)]
    ::
    ++  case-to-aeon                                    ::    case-to-aeon:ze
      |=  lok=case                                      ::  act count through
      ^-  (unit aeon)
      ?-    -.lok
          %da
        ?:  (gth p.lok lim)  ~
        |-  ^-  (unit aeon)
        ?:  =(0 let.dom)  [~ 0]                             ::  avoid underflow
        ?:  %+  gte  p.lok 
            =<  t
            %-  aeon-to-yaki
            let.dom
          [~ let.dom]
        $(let.dom (dec let.dom))
      ::
          %tas  (~(get by lab.dom) p.lok)
          %ud   ?:((gth p.lok let.dom) ~ [~ p.lok])
      ==
    ::
    ++  checkout-ankh
      |=  hat=(map path cage)
      ^-  ankh
      %-  cosh
      %+  roll  (~(tap by hat) ~)
      |=  [[pat=path zar=cage] ank=ankh]
      ^-  ankh
      %-  cosh
      ?~  pat
        ank(q [~ (sham q.q.zar) zar])
      =+  nak=(~(get by r.ank) i.pat)
      %=  ank
        r  %+  ~(put by r.ank)  i.pat 
           $(pat t.pat, ank (fall nak *ankh))
      ==
    ::
    ++  cosh
      |=  ank=ankh
      %_    ank
          p
        ^-  cash
        %+  mix  ?~(q.ank 0 p.u.q.ank)
        =+  axe=1
        |-  ^-  cash
        ?~  r.ank  *@
        ;:  mix
          (shaf %dash (mix axe (shaf %dush (mix p.n.r.ank p.q.n.r.ank))))
          $(r.ank l.r.ank, axe (peg axe 2))
          $(r.ank r.r.ank, axe (peg axe 3))
        ==
      ==
    ::
    ++  construct-merge
      |=  [gem=germ her=ship sud=desk]
      !!
    ::
    ++  edit                                            ::    edit:ze
      |=  [wen=@da lem=nuri]                            ::  edit
      ^-  [(unit (map path lobe)) _..ze]
      ?-  -.lem
        &  =^  yak  lat.ran                             ::  merge objects
               %+  forge-yaki  wen
               ?:  =(let.dom 0)                         ::  initial import
                 [~ p.lem]
               [(some r:(aeon-to-yaki let.dom)) p.lem]
           ?.  ?|  =(0 let.dom)
                   !=((lent p.yak) 1)
                   !(equiv q.yak q:(aeon-to-yaki let.dom))
               ==
             `..ze                                      ::  silently ignore
           =:  let.dom  +(let.dom)
               hit.dom  (~(put by hit.dom) +(let.dom) r.yak)
               hut.ran  (~(put by hut.ran) r.yak yak)
           ==
           [`q.yak ..ze]
           ::  +>.$(ank (checkout-ankh q.yak))
        |  ?<  (~(has by lab.dom) p.lem)
           [~ ..ze(lab.dom (~(put by lab.dom) p.lem let.dom))]
      ==
    ::
    ++  equiv                                           ::  test paths
      |=  [p=(map path lobe) q=(map path lobe)]
      ^-  ?
      =-  ?.  qat  %.n
          %+  levy  (~(tap by q) ~)
          |=  [pat=path lob=lobe]
          (~(has by p) pat)
      ^=  qat
      %+  levy  (~(tap by p) ~)
      |=  [pat=path lob=lobe]
      =+  zat=(~(get by q) pat)
      ?~  zat  %.n
      =(u.zat lob)
      ::  =((lobe-to-cage u.zat) (lobe-to-cage lob))
    ::
    ++  forge-nori                                      ::    forge-nori:ze
      |=  yak=yaki                                      ::  forge nori
      ^-  nori
      !!
      ::  ?~  p.yak  !!                                 ::  no parent, no diff
      ::  :+  %&  *cart                                 ::  diff w/ 1st parent
      ::  (~(tap by (diff-yakis (tako-to-yaki i.p.yak) yak)) ~)
    ::
    ++  forge-yaki                                      ::    forge-yaki:ze
      |=  [wen=@da par=(unit tako) lem=suba]            ::  forge yaki
      =+  ^=  per
          ?~  par  ~
          ~[u.par]
      =+  gar=(update-lat (apply-changes q.lem) lat.ran)
      :-  %^  make-yaki  per  +.gar  wen                ::  from existing diff
      -.gar                                             ::  fix lat
    ::
    ++  lobes-at-path                                   ::    lobes-at-path:ze
      |=  [yon=aeon pax=path]                           ::  data at path
      ^-  (map path lobe)
      ?:  =(0 yon)  ~
      %-  mo
      %+  skim
        %.  ~
        %~  tap  by
        =<  q
        %-  aeon-to-yaki
        yon
      |=  [p=path q=lobe]
      ?|  ?=(~ pax)
          ?&  !?=(~ p)
              =(-.pax -.p)
              $(p +.p, pax +.pax)
      ==  ==
    ::
    ++  make-nako                                       ::  gack a through b
      |=  [a=aeon b=aeon]
      ^-  [(map aeon tako) aeon (set yaki) (set blob)]
      :^    hit.dom
          let.dom
        (sa `(list yaki)`(turn (~(tap by hut.ran)) |=([tako yaki] +<+)))
      (sa `(list blob)`(turn (~(tap by lat.ran)) |=([lobe blob] +<+)))
    ::
    ++  query                                           ::    query:ze
      |=  ren=?(%u %v %x %y %z)                         ::  endpoint query
      ^-  (unit cage)
      ?-  ren
        %u  [~ %rang !>(ran)]
        %v  [~ %dome !>(dom)]
        %x  ?~(q.ank.dom ~ [~ q.u.q.ank.dom])
        %y  [~ %arch !>(as-arch)]
        %z  [~ %ankh !>(ank.dom)]
      ==
    ::
    ++  reachable-takos                                 ::  reachable
      |=  p=tako                                        ::  XX slow
      ^-  (set tako)
      =+  y=(tako-to-yaki p)
      =+  t=(~(put in *(set tako)) p)
      %+  roll  p.y
      =<  .(s t)
      |=  [q=tako s=(set tako)]
      ?:  (~(has in s) q)                               ::  already done
        s                                               ::  hence skip
      (~(uni in s) ^$(p q))                             ::  otherwise traverse
    ::
    ++  read                                            ::    read:ze
      |=  mun=mood                                      ::  read at point
      ^-  (unit cage)
      ?:  ?=(%v p.mun)
        [~ %dome !>(dom)]
      ?:  &(?=(%w p.mun) !?=(%ud -.q.mun))
        ?^(r.mun ~ [~ %aeon !>(let.dom)])
      ?:  ?=(%w p.mun)
        =+  ^=  yak
            %-  aeon-to-yaki
            let.dom
        ?^(r.mun ~ [~ %w !>([t.yak (forge-nori yak)])])
      (query(ank.dom ank:(descend-path:(zu ank.dom) r.mun)) p.mun)
    ::
    ++  read-at-aeon                                    ::    read-at-aeon:ze
      |=  [yon=aeon mun=mood]                           ::  seek and read
      ^-  (unit cage)
      ?:  &(?=(%w p.mun) !?=(%ud -.q.mun))              ::  NB only for speed
        ?^(r.mun ~ [~ %aeon !>(yon)])
      %+  biff
        (rewind yon)
      |=  a=_+>.$
      (read:a mun)
    ::
    ++  rewind                                          ::    rewind:ze
      |=  yon=aeon                                      ::  rewind to aeon
      ^-  (unit ,_+>)
      ?:  =(let.dom yon)  `+>
      ?:  (gth yon let.dom)  !!                             ::  don't have version
      =+  hat=q:(aeon-to-yaki yon)
      ?:  (~(any by hat) |=(a=lobe ?=(%delta [-:(lobe-to-blob a)])))
        ~
      =+  ^-  (map path cage)
          %-  ~(run by hat)
          |=  a=lobe
          =+  (lobe-to-blob a)
          ?-(-.- %direct q.-, %indirect q.-, %delta !!)
      `+>.$(ank.dom (checkout-ankh -), let.dom yon)
    ::
    ++  update-lat                                      ::   update-lat:ze
      |=  [lag=(map path blob) sta=(map lobe blob)]     ::  fix lat
      ^-  [(map lobe blob) (map path lobe)]
      %+  roll  (~(tap by lag) ~)
      =<  .(lut sta)
      |=  [[pat=path bar=blob] [lut=(map lobe blob) gar=(map path lobe)]]
      ?~  (~(has by lut) p.bar)
        [lut (~(put by gar) pat p.bar)]
      :-  (~(put by lut) p.bar bar)
      (~(put by gar) pat p.bar)
    ::
    ++  zu                                              ::  filesystem
      |=  ank=ankh                                      ::  filesystem state
      =|  ram=path                                      ::  reverse path into
      |%
      ++  descend                                       ::  descend
        |=  lol=@ta
        ^+  +>
        =+  you=(~(get by r.ank) lol)
        +>.$(ram [lol ram], ank ?~(you [*cash ~ ~] u.you))
      ::
      ++  descend-path                                  ::  descend recursively
        |=  way=path
        ^+  +>
        ?~(way +> $(way t.way, +> (descend i.way)))
      ::
      --
    ::
    ++  me                                              ::  merge ali into bob
      |=  ali=(pair ship desk)                          ::  from
      =+  bob=`(pair ship desk)`[who syd]               ::  to
      =+  dat=(fall (~(get by mer) ali) *mery)          ::  merge data
      =|  gon=?                                         ::  keep going
      |%
      ++  abet
        ^+  ..me
        ..me(mer ?:(gon (~(put by mer) ali dat) (~(del by mer) ali)))
      ::
      ++  route
        |=  [sat=term res=(each riot (each bead (list tank)))]
        ^+  +>.$
        ?+  sat  ~|((crip <[%bad-stage sat]>) !!)
          %ali        %-  fetched-ali  ?>  ?=(%& -.res)  p.res
          %diff-ali   %-  diffed-ali   ?>  ?=(%| -.res)  p.res
          %diff-bob   %-  diffed-bob   ?>  ?=(%| -.res)  p.res
          %merge      %-  merged       ?>  ?=(%| -.res)  p.res
          %checkout   %-  checked-out  ?>  ?=(%| -.res)  p.res
          %ergo       %-  ergoed       ?>  ?=(%| -.res)  p.res
        ==
      ::
      ++  start
        |=  gem=germ
        ^+  +>
        ?:  (~(has by mer) ali)
          ~|  (crip <[%already-merging ali bob]>)
          !!
        =.  gem.dat  gem
        =.  cas.dat  [%da now]
        =.  bob.dat
          ?:  ?=(%init gem)  bob.dat
          (~(got by hut.ran) (~(got by hit.dom) let.dom))
        fetch-ali
      ::
      ++  fetch-ali
        ^+  .
        =-  %_(+ tag [- tag])
        :*  hen  [%merge (scot %p p.bob) q.bob (scot %p p.ali) q.ali %ali ~]
            %c  %warp  [p.bob p.ali]  q.ali
            `[%& %v cas.dat /]
        ==
      ::
      ++  fetched-ali
        |=  rot=riot
        ^+  +>
        ?~  rot
          ~|  (crip <[%bad-fetch-ali ali bob]>)
          !!
        =+  ^=  dum
            %-  (hard ,[ank=* let=@ud hit=(map ,@ud tako) lab=(map ,@tas ,@ud)])
            q.q.r.u.rot
        =.  ali.dat  (~(got by hut.ran) (~(got by hit.dum) let.dum))
        |-
        ?-    gem.dat
            %init
          ?.  =(let.dom 0)
            ~|  (crip <[%bad-init-merge ali bob]>)
            !!
          =.  new.dat  ali.dat
          =.  hut.ran  (~(put by hut.ran) r.new.dat new.dat)
          =.  erg.dat  (~(run by q.ali.dat) |=(lobe %&))
          checkout
        ::
            %fine
          ?:  =(r.ali.dat r.bob.dat)
            +>.^$(gon |)
          ?:  (~(has in (reachable-takos r.bob.dat)) r.ali.dat)
            +>.^$(gon |)
          ?.  (~(has in (reachable-takos r.ali.dat)) r.bob.dat)
            ~|  (crip <[%bad-fine-merge ali bob]>)
            !!
          =.  new.dat  ali.dat
          =.  erg.dat
            %-  ~(uni by `(map path ,?)`(~(run by q.bob.dat) |=(lobe %|)))
            `(map path ,?)`(~(run by q.ali.dat) |=(lobe %&))
          checkout
        ::
            %this
          ?:  =(r.ali.dat r.bob.dat)
            +>.^$(gon |)
          ?:  (~(has in (reachable-takos r.bob.dat)) r.ali.dat)
            +>.^$(gon |)
          =.  new.dat  (make-yaki [r.ali.dat r.bob.dat ~] q.bob.dat now)
          =.  hut.ran  (~(put by hut.ran) r.new.dat new.dat)
          =.  erg.dat  ~
          checkout
        ::
            %that
          ?:  =(r.ali.dat r.bob.dat)
            +>.^$(gon |)
          ?:  (~(has in (reachable-takos r.bob.dat)) r.ali.dat)
            +>.^$(gon |)
          =.  new.dat  (make-yaki [r.ali.dat r.bob.dat ~] q.ali.dat now)
          =.  hut.ran  (~(put by hut.ran) r.new.dat new.dat)
          =.  erg.dat
            %-  ~(uni by `(map path ,?)`(~(run by q.bob.dat) |=(lobe %|)))
            `(map path ,?)`(~(run by q.ali.dat) |=(lobe %&))
          checkout
        ::
            %mate
          !!
        ::
            %meld
          !!
        ==
      ::
      ++  diff-ali
        ^+  .
        =-  %_(+ tag [- tag])
        :*  hen
            [%merge (scot %p p.bob) q.bob (scot %p p.ali) q.ali %diff-ali ~]
            %f  %exec  p.bob  ~  %tabl
            ^-  (list (pair silk silk))
            !!
        ==
      ::
      ++  diffed-ali
        |=  res=(each bead (list tank))
        ^+  +>
        !!
      ::
      ++  diff-bob
        ^+  .
        !!
      ::
      ++  diffed-bob
        |=  res=(each bead (list tank))
        ^+  +>
        !!
      ::
      ++  merge
        ^+  .
        !!
      ::
      ++  merged
        |=  res=(each bead (list tank))
        ^+  +>
        !!
      ::
      ++  checkout
        ^+  .
        =-  %_(+ tag [- tag])
        :*  hen
            [%merge (scot %p p.bob) q.bob (scot %p p.ali) q.ali %checkout ~]
            %f  %exec  p.bob  ~  %tabl
            ^-  (list (pair silk silk))
            %+  turn  (~(tap by q.new.dat))
            |=  [a=path b=lobe]
            ^-  (pair silk silk)
            :-  [%done ~ %path !>(a)]
            |-  ^-  silk
            =+  bob=(~(got by lat.ran) b)
            ?-  -.bob
              %direct     [%done ~ q.bob]
              %indirect   [%done ~ q.bob]
              %delta      [%pact $(b q.bob) [%done ~ r.bob]]
            ==
        ==
      ::
      ++  checked-out
        |=  res=(each bead (list tank))
        ^+  +>
        ?:  ?=(%| -.res)  
          %_    +>.$
              dok  ~
              yel
            :_  yel
            :*  hen  %note  '!'  %rose  [" " "" ""]
                leaf/"merge checkout failed"  p.res
            ==
          ==
        =.  let.dom  +(let.dom)
        =.  hit.dom  (~(put by hit.dom) let.dom r.new.dat)
        =+  cay=q.p.res
        ?@  p.cay  ~|  %patch-bad-marc  !!
        =.  ank.dat
          %-  checkout-ankh:ze
          %-  mo
          |-  ^-  (list ,[path cage])
          ?~  p.p.cay
            ~
          :_  %_($ cay [[%tabl t.p.p.cay] (slot 3 q.cay)])
          ?.  ?=(%path p.i.p.p.cay)
            ~|  %patch-strange-marc-a
            !!
          ?.  ?=(@ q.i.p.p.cay)
            ~|  %patch-strange-marc-b
            !!
          =+  coy=(slot 2 q.cay)
          ?@  q.coy
            ~|  %patch-strange-coy
            !!
          :-  ((hard path) -.q.coy)
          [q.i.p.p.cay (slot 3 coy)]
        =.  ank.dom  ank.dat
        ?~  hez
          +>.$(gon |)                                   ::  XX  resolve
        ergo
      ::
      ++  ergo
        ^+  .
        =-  %_(+ tag [- tag])
        =+  zez=ze(ank.dom ank.dat)
        :*  hen
            [%merge (scot %p p.bob) q.bob (scot %p p.ali) q.ali %ergo ~]
            %f  %exec  p.bob  ~  %tabl
            ^-  (list (pair silk silk))
            %+  turn  (~(tap by erg.dat))
            |=  [a=path b=?]
            ^-  (pair silk silk)
            :-  [%done ~ %path !>(a)]
            ?.  b
              [%done ~ %null !>(~)]
            :^  %cast  %mime  %done
            `(need (read:zez %x [%ud let.dom] a))
        ==
      ::
      ++  ergoed
        |=  res=(each bead (list tank))
        ^+  +>
        ?:  ?=(%| -.res)
          %_    +>.$
              gon  |
              yel
            :_  yel
            [hen %note '!' %rose [" " "" ""] leaf/"merge ergo failed" p.res]
          ==
        ?~  hez
          ~|  (crip <[%no-hez ali bob]>)
          !!
        =+  cay=q.p.res
        ?@  p.cay  ~|  %patch-bad-marc  !!
        %=    +>.$
            gon  |
            reg
          :_  reg
          :*  u.hez  %ergo  who  syd  let.dom
              |-  ^-  (list ,[path (unit mime)])
              ?~  p.p.cay
                ~
              :_  %_($ cay [[%tabl t.p.p.cay] (slot 3 q.cay)])
              ?.  ?=(%path p.i.p.p.cay)
                ~|  %ergo-strange-marc-a
                !!
              ?.  ?=(@ q.i.p.p.cay)
                ~|  %ergo-strange-marc-b
                !!
              =+  coy=(slot 2 q.cay)
              ?@  q.coy
                ~|  %ergo-strange-coy
                !!
              :-  ((hard path) -.q.coy)
              ?.  ?=(%mime q.i.p.p.cay)
                ~
              `((hard mime) q:(slot 3 coy))
          ==
        ==
      --
    --
--
::
++  do
  |=  [now=@da hen=duct [who=ship him=ship] syd=@tas ruf=raft]
  =+  ^=  rug  ^-  rung
      =+  rug=(~(get by hoy.ruf) him)
      ?^(rug u.rug *rung)
  =+  ^=  red  ^-  rede
      =+  yit=(~(get by rus.rug) syd)
      ?^(yit u.yit `rede`[~2000.1.1 ~ [~ *rind] *dome ~ ~])
  ((de now hen ~ ~) [who him] syd red ran.ruf)
::
++  posh
  |=  [him=ship syd=desk red=rede ruf=raft]
  ^-  raft
  =+  ^=  rug  ^-  rung
      =+  rug=(~(get by hoy.ruf) him)
      ?^(rug u.rug *rung)
  ruf(hoy (~(put by hoy.ruf) him rug(rus (~(put by rus.rug) syd red))))
::
++  un                                                ::  domestic ship
  |=  [who=@p now=@da hen=duct ruf=raft]
  =+  ^=  yar  ^-  room
      =+  yar=(~(get by fat.ruf) who)
      ?~(yar *room u.yar)
  |%
  ++  abet  ruf(fat (~(put by fat.ruf) who yar))
  ++  pish
    |=  [syd=@ta red=rede run=rang]
    %_  +>
        ran.ruf  run
        dos.yar
      (~(put by dos.yar) syd [qyx.red dom.red dok.red mer.red])
    ==
  ::
  ++  wake
    =+  saz=(turn (~(tap by dos.yar) ~) |=([a=@tas b=*] a))
    =|  moz=(list move)
    =<  [moz ..wake]
    |-  ^+  +
    ?~  saz  +
    =+  sog=abet:wake:(di i.saz)
    $(saz t.saz, moz (weld moz -.sog), ..wake (pish i.saz +.sog ran.ruf))
  ::
  ++  di
    |=  syd=@ta
    =+  ^=  saq  ^-  dojo
        =+  saq=(~(get by dos.yar) syd)
        ?~(saq *dojo u.saq)
    %^    (de now hen hun.yar hez.yar)
        [who who]
      syd
    [[now qyx.saq ~ dom.saq dok.saq mer.saq] ran.ruf]
  --
--
::::::::::::::::::::::::::::::::::::::::::::::::::::::::
::              section 4cA, filesystem vane          ::
::                                                    ::
=|                                                    ::  instrument state
    $:  %0                                            ::  vane version
        ruf=raft                                      ::  revision tree
    ==                                                ::
|=  [now=@da eny=@ ski=sled]                          ::  activate
^?                                                    ::  opaque core
|%                                                    ::
++  call                                              ::  handle request
  |=  $:  hen=duct
          hic=(hypo (hobo kiss))
      ==
  =>  %=    .                                         ::  XX temporary
          q.hic
        ^-  kiss
        ?:  ?=(%soft -.q.hic)
          =+
          ~|([%bad-soft (,@t -.p.q.hic)] ((soft kiss) p.q.hic))
          ?~  -
            ~&  [%bad-softing (,@t -.p.q.hic)]  !!
          u.-
        ?:  (~(nest ut -:!>(*kiss)) | p.hic)  q.hic
        ~&  [%clay-call-flub (,@tas `*`-.q.hic)]
        ((hard kiss) q.hic)
      ==
  ^-  [p=(list move) q=_..^$]
  ?-    -.q.hic
      %font
    ?:  (~(has by sor.ruf) +.q.hic)  `..^$
    :_  ..^$(sor.ruf (~(put by sor.ruf) +.q.hic hen))
    ::  XX  pass %merg and handle response
    :~  :*  hen  %pass
            /auto/(scot %p p.q.hic)/[q.q.hic]/(scot %p r.q.hic)/[s.q.hic]/y
            %c  %warp  [p.q.hic r.q.hic]  s.q.hic
            `[%& %y [%da now] /]
        ==
    ==
  ::
      %init
    :_  ..^$(fat.ruf (~(put by fat.ruf) p.q.hic [hen ~ ~]))
    =+  bos=(sein p.q.hic)
    ~&  [%bos bos p.q.hic]
    ?:  =(bos p.q.hic)  ~
    ^-  (list move)
    %+  turn  (limo ~[%main %arvo %try])
    |=  syd=@tas
    [hen %pass / %c %font p.q.hic syd bos syd]
  ::
      %info
    ?:  =(%$ q.q.hic)
      [~ ..^$]
    =^  mos  ruf
      =+  une=(un p.q.hic now hen ruf)
      =+  ^=  zat
          (exec:(di:wake:une q.q.hic) now r.q.hic)
      =+  zot=abet.zat
      :-  -.zot
      =.  une  (pish:une q.q.hic +.zot ran.zat)
      abet:une
    [mos ..^$]
  ::
      %into
    =+  yar=(~(got by fat.ruf) p.q.hic)
    :_  ..^$(fat.ruf (~(put by fat.ruf) p.q.hic yar(hez [~ hen])))
    ^-  (list move)
    ?:  =(%$ q.q.hic)
      ~
    =+  dos=(~(get by dos.yar) q.q.hic)
    ?:  &(?=(^ dos) !=(0 +>-.+<.+.dos))            ::  ank.s.u.dos
      ?:  =(ank.dom.u.dos q.q.hic)
        ~
      :_  ~
      :*  hen  %slip  %c  %info  p.q.hic  q.q.hic  %&
          (khan-to-soba `ank.dom.u.dos `r.q.hic)
      ==
    =+  cos=(khan-to-soba ~ `r.q.hic)
    =+  ^-  [one=(list ,[path miso]) two=(list ,[path miso])]
        %+  skid  q.cos
        |=  [a=path b=miso]
        ?&  ?=(%ins -.b)
            ?=(%mime p.p.b)
            =+  (slag (dec (lent a)) a)
            ?|  =([%hook ~] -)
                =([%hoon ~] -)
        ==  ==
    :~  [hen %slip %c %info p.q.hic q.q.hic %& p.cos one]
        [hen %slip %c %info p.q.hic q.q.hic %& p.cos two]
    ==
  ::
      %merg                                               ::  direct state up
    ?:  =(%$ q.q.hic)
      [~ ..^$]
    =^  mos  ruf
      =+  une=(un p.q.hic now hen ruf)
      =+  ^=  zat
          abet:(start:(me:ze:(di:wake:une q.q.hic) r.q.hic s.q.hic) t.q.hic)
      =+  zot=abet.zat
      :-  -.zot
      =.  une  (pish:une q.q.hic +.zot ran.zat)
      abet:une
    [mos ..^$]
  ::
      %plug
    ?.  (~(has by sor.ruf) +.q.hic)  `..^$
    :_  ..^$(sor.ruf (~(del by sor.ruf) +.q.hic))
    =+  hyn=(~(got by sor.ruf) +.q.hic)
    :~  :*  hyn  %pass
            /auto/(scot %p p.q.hic)/[q.q.hic]/(scot %p r.q.hic)/[s.q.hic]/y
            %c  %warp  [p.q.hic r.q.hic]  s.q.hic  ~
        ==
        :*  hyn  %pass
            /auto/(scot %p p.q.hic)/[q.q.hic]/(scot %p r.q.hic)/[s.q.hic]/v
            %c  %warp  [p.q.hic r.q.hic]  s.q.hic  ~
        ==
    ==
  ::
      %warp
    =^  mos  ruf
      ?:  =(p.p.q.hic q.p.q.hic)
        =+  une=(un p.p.q.hic now hen ruf)
        =+  wex=(di:une p.q.q.hic)
        =+  ^=  wao
          ?~  q.q.q.hic
            ease:wex
          (eave:wex u.q.q.q.hic)
        =+  ^=  woo
          abet:wao
        [-.woo abet:(pish:une p.q.q.hic +.woo ran.wao)]
      =+  wex=(do now hen p.q.hic p.q.q.hic ruf)
      =+  ^=  woo
        ?~  q.q.q.hic
          abet:ease:wex
        abet:(eave:wex u.q.q.q.hic)
      [-.woo (posh q.p.q.hic p.q.q.hic +.woo ruf)]
    [mos ..^$]
  ::
      %wart
    ?>  ?=(%re q.q.hic)
    =+  ryf=((hard riff) s.q.hic)
    :_  ..^$
    :~  :-  hen
        :^  %pass  [(scot %p p.p.q.hic) (scot %p q.p.q.hic) r.q.hic]
          %c
        [%warp [p.p.q.hic p.p.q.hic] ryf]
    ==
  ==
::
++  doze
  |=  [now=@da hen=duct]
  ^-  (unit ,@da)
  ~
::
++  load
  |=  old=[%0 ruf=raft]
  ^+  ..^$
  ..^$(ruf ruf.old)
::
++  scry                                              ::  inspect
  |=  [fur=(unit (set monk)) ren=@tas his=ship syd=desk lot=coin tyl=path]
  ^-  (unit (unit cage))
  =+  got=(~(has by fat.ruf) his)
  =+  luk=?.(?=(%$ -.lot) ~ ((soft case) p.lot))
  ?~  luk  [~ ~]
  ?:  =(%$ ren)
    [~ ~]
  =+  run=((soft care) ren)
  ?~  run  [~ ~]
  %.  [u.run u.luk tyl]
  =<  aver
  ?:  got
    (di:(un his now ~ ruf) syd)
  (do now ~ [his his] syd ruf)
::
++  stay  [%0 ruf]
++  take                                              ::  accept response
  |=  [tea=wire hen=duct hin=(hypo sign)]
  ^-  [p=(list move) q=_..^$]
  ?:  ?=([%merge @ @ @ @ @ ~] tea)
    ?>  ?=(?(%writ %made) +<.q.hin)
    =+  our=(slav %p i.t.tea)
    =*  syd  i.t.t.tea
    =+  her=(slav %p i.t.t.t.tea)
    =*  sud  i.t.t.t.t.tea
    =*  sat  i.t.t.t.t.t.tea
    =+  une=(un our now hen ruf)
    =+  wex=(di:une syd)
    =+  dat=?-(+<.q.hin %writ [%& p.q.hin], %made [%| p.q.hin])
    =+  wao=abet:(route:(me:ze:wex her sud) sat dat)
    =+  woo=abet:wao
    [-.woo ..^$(ruf abet:(pish:une syd +.woo ran.wao))]
  ?-    -.+.q.hin
      %crud
    [[[hen %slip %d %flog +.q.hin] ~] ..^$]
  ::
      %made
    ?~  tea  !!
    ?+    -.tea  !!
        %casting
      ?>  ?=([@ @ @ *] t.tea)
      =+  who=(slav %p i.t.tea)
      =+  syd=(slav %tas i.t.t.tea)
      =+  wen=(slav %da i.t.t.t.tea)
      =^  mos  ruf
        =+  une=(un who now hen ruf)
        =+  ^=  zat
            (take-cast:(di:wake:une syd) wen t.t.t.t.tea p.q.hin)
        =+  zot=abet.zat
        [-.zot abet:(pish:une syd +.zot ran.zat)]
      [mos ..^$]
    ::
        %diffing
      ?>  ?=([@ @ @ *] t.tea)
      =+  who=(slav %p i.t.tea)
      =+  syd=(slav %tas i.t.t.tea)
      =+  wen=(slav %da i.t.t.t.tea)
      =^  mos  ruf
        =+  une=(un who now hen ruf)
        =+  ^=  zat
            (take-diff:(di:wake:une syd) wen t.t.t.t.tea p.q.hin)
        =+  zot=abet.zat
        [-.zot abet:(pish:une syd +.zot ran.zat)]
      [mos ..^$]
    ::
        %patching
      ?>  ?=([@ @ ~] t.tea)
      =+  who=(slav %p i.t.tea)
      =+  syd=(slav %tas i.t.t.tea)
      =^  mos  ruf
        ?:  (~(has by fat.ruf) who)
          =+  une=(un who now hen ruf)
          =+  ^=  zat
              (take-patch:(di:wake:une syd) p.q.hin)
          =+  zot=abet.zat
          [-.zot abet:(pish:une syd +.zot ran.zat)]
        =+  zax=(do now hen [who who] syd ruf)
        =+  ^=  zat
            (take-patch:zax p.q.hin)
        =+  zot=abet.zat
        [-.zot (posh who syd +.zot ruf)]
      [mos ..^$]
    ::
        %ergoing
      ?>  ?=([@ @ ~] t.tea)
      =+  who=(slav %p i.t.tea)
      =+  syd=(slav %tas i.t.t.tea)
      =^  mos  ruf
        =+  une=(un who now hen ruf)
        =+  ^=  zat
            (take-ergo:(di:wake:une syd) p.q.hin)
        =+  zot=abet.zat
        [-.zot abet:(pish:une syd +.zot ran.zat)]
      [mos ..^$]
    ==
  ::
      %waft
    ?>  ?=([@ @ ~] tea)
    =+  syd=(need (slaw %tas i.tea))
    =+  inx=(need (slaw %ud i.t.tea))
    =+  ^=  zat
      =<  wake
      (knit:(do now hen p.+.q.hin syd ruf) [inx ((hard riot) q.+.q.hin)])
    =^  mos  ruf
      =+  zot=abet.zat
      [-.zot (posh q.p.+.q.hin syd +.zot ruf)]
    [mos ..^$(ran.ruf ran.zat)]                         ::  merge in new obj
  ::
      %wake
    =+  dal=(turn (~(tap by fat.ruf) ~) |=([a=@p b=room] a))
    =|  mos=(list move)
    |-  ^-  [p=(list move) q=_..^^$]
    ?~  dal  [mos ..^^$]
    =+  une=(un i.dal now hen ruf)
    =^  som  une  wake:une
    $(dal t.dal, ruf abet:une, mos (weld som mos))
  ::
      %writ
    ?>  ?=([@ @ *] tea)
    =+  our=(need (slaw %p i.tea))
    =+  him=(need (slaw %p i.t.tea))
    :_  ..^$
    :~  :-  hen
        [%pass ~ %a [%want [our him] [%r %re %c t.t.tea] p.+.q.hin]]
    ==
  ::
      %went
    ?:  =(%good q.+.q.hin)  [~ ..^$]
    ~&  [%clay-lost p.+.q.hin tea]
    [~ ..^$]
  ==
++  khan-to-soba
  |=  [ank=(unit ankh) kan=(unit khan)]
  ^-  soba
  :-  *cart
  =|  pax=path
  |-  ^-  (list ,[p=path q=miso])
  ?~  ank
    ?~  kan
      ~
    =+  =+  (~(tap by dir.u.kan))
        |-(?~(+< ~ (weld ^$(pax [p.i pax], kan `q.i) $(+< t))))
    ?~  fil.u.kan
      -
    ?~  u.fil.u.kan
      -
    [[(flop pax) %ins u.u.fil.u.kan] -]
  ?~  kan
    =+  =+  (~(tap by r.u.ank))
        |-(?~(+< ~ (weld ^$(pax [p.i pax], ank `q.i) $(+< t))))
    ?~  q.u.ank
      -
    [[(flop pax) %del q.u.q.u.ank] -]
  =+  %+  weld
        =+  (~(tap by r.u.ank))
        |-  ^-  (list ,[p=path q=miso])
        ?~  +<  ~
        %-  weld  :_  $(+< t)
        ^$(pax [p.i pax], ank `q.i, kan (~(get by dir.u.kan) p.i))
      =+  (~(tap by dir.u.kan))
      |-  ^-  (list ,[p=path q=miso])
      ?~  +<  ~
      ?:  (~(has by r.u.ank) p.i)  $(+< t)
      %-  weld  :_  $(+< t)
      ^$(pax [p.i pax], kan `q.i, ank ~)
  ?~  q.u.ank
    ?~  fil.u.kan
      -
    ?~  u.fil.u.kan
      -
    [[(flop pax) %ins u.u.fil.u.kan] -]
  ?~  fil.u.kan
    -
  ?~  u.fil.u.kan
    [[(flop pax) %del q.u.q.u.ank] -]
  [[(flop pax) %mut q.u.q.u.ank u.u.fil.u.kan] -]
--