let Genode =
      env:DHALL_GENODE sha256:e90438be23b5100003cf018b783986df67bc6d0e3d35e800677d0d9109ff6aa9

let Prelude = Genode.Prelude

let XML = Prelude.XML

let Init = Genode.Init

let Child = Init.Child

let TextMapType = Prelude.Map.Type Text

let Manifest/Type = TextMapType (TextMapType Text)

let Manifest/toRoutes =
      λ(manifest : Manifest/Type) →
        Prelude.List.map
          (Prelude.Map.Entry Text Text)
          Init.ServiceRoute.Type
          ( λ(entry : Prelude.Map.Entry Text Text) →
              { service =
                { name = "ROM"
                , label = Init.LabelSelector.Type.Last entry.mapKey
                }
              , route =
                  Init.Route.Type.Child
                    { name = "store_rom"
                    , label = Some entry.mapValue
                    , diag = Some True
                    }
              }
          )
          ( Prelude.List.concat
              (Prelude.Map.Entry Text Text)
              (Prelude.Map.values Text (Prelude.Map.Type Text Text) manifest)
          )

let parentROMs =
      Prelude.List.map
        Text
        Init.ServiceRoute.Type
        ( λ(label : Text) →
            { service = { name = "ROM", label = Init.LabelSelector.last label }
            , route =
                Init.Route.Type.Parent { label = Some label, diag = None Bool }
            }
        )

let wrapStore
    : Init.Type → Manifest/Type → Child.Type
    = λ(init : Init.Type) →
      λ(manifest : Manifest/Type) →
        Init.toChild
          init
          Init.Attributes::{
          , exitPropagate = True
          , resources = Init.Resources::{ ram = Genode.units.MiB 4 }
          , routes =
                [ Init.ServiceRoute.parent "IO_MEM"
                , Init.ServiceRoute.parent "IO_PORT"
                , Init.ServiceRoute.parent "IRQ"
                , Init.ServiceRoute.parent "VM"
                , Init.ServiceRoute.child "Timer" "timer"
                , Init.ServiceRoute.child "Rtc" "rtc"
                ]
              # parentROMs
                  [ "ld.lib.so"
                  , "init"
                  , "platform_info"
                  , "core_log"
                  , "kernel_log"
                  , "vfs"
                  , "vfs.lib.so"
                  , "cached_fs_rom"
                  ]
              # Manifest/toRoutes manifest
              # [ Init.ServiceRoute.child "ROM" "store_rom" ]
          }

in  λ(subinit : Init.Type) →
    λ(storeName : Text) →
    λ(storeSize : Natural) →
    λ(storeManifest : Manifest/Type) →
    λ(bootManifest : Manifest/Type) →
      Genode.Boot::{
      , config = Init::{
        , children =
            let child = Prelude.Map.keyValue Child.Type

            in  [ child
                    "timer"
                    ( Child.flat
                        Child.Attributes::{
                        , binary = "timer_drv"
                        , provides = [ "Timer" ]
                        }
                    )
                , child
                    "rtc"
                    ( Child.flat
                        Child.Attributes::{
                        , binary = "rtc_drv"
                        , provides = [ "Rtc" ]
                        , routes = [ Init.ServiceRoute.parent "IO_PORT" ]
                        }
                    )
                , child
                    "store_fs"
                    ( Child.flat
                        Child.Attributes::{
                        , binary = "vfs"
                        , config = Init.Config::{
                          , content =
                            [ XML.element
                                { name = "vfs"
                                , attributes = XML.emptyAttributes
                                , content =
                                  [ XML.leaf
                                      { name = "tar"
                                      , attributes = toMap { name = storeName }
                                      }
                                  ]
                                }
                            ]
                          , policies =
                            [ Init.Config.Policy::{
                              , service = "File_system"
                              , label = Init.LabelSelector.suffix "nix-store"
                              , attributes = toMap { root = "/nix/store" }
                              }
                            , Init.Config.Policy::{
                              , service = "File_system"
                              , label = Init.LabelSelector.prefix "store_rom"
                              , attributes = toMap { root = "/" }
                              }
                            ]
                          }
                        , provides = [ "File_system" ]
                        }
                    )
                , child
                    "store_rom"
                    ( Child.flat
                        Child.Attributes::{
                        , binary = "cached_fs_rom"
                        , provides = [ "ROM" ]
                        , resources = Init.Resources::{
                          , ram = storeSize + Genode.units.MiB 1
                          }
                        }
                    )
                , child "init" (wrapStore subinit storeManifest)
                ]
        }
      , rom =
          Genode.BootModules.toRomPaths
            ( Prelude.List.concat
                (Prelude.Map.Entry Text Text)
                ( Prelude.Map.values
                    Text
                    (Prelude.Map.Type Text Text)
                    bootManifest
                )
            )
      }