sig   type 'a result = ('a, [ `Msg of string ]) Pervasives.result   val ( >>= ) :     ('a, 'b) Pervasives.result ->     ('-> ('c, 'b) Pervasives.result) -> ('c, 'b) Pervasives.result   val ( >>| ) :     ('a, 'b) Pervasives.result -> ('-> 'c) -> ('c, 'b) Pervasives.result   module R :     sig       val reword_error :         ('-> 'c) ->         ('a, 'b) Pervasives.result -> ('a, 'c) Pervasives.result       val join :         (('a, 'b) Pervasives.result, 'b) Pervasives.result ->         ('a, 'b) Pervasives.result       type msg = [ `Msg of string ]       val msgf :         ('a, Format.formatter, unit, [> B0.R.msg ]) Pervasives.format4 -> 'a       val error_msg : string -> ('b, [> B0.R.msg ]) Pervasives.result       val error_msgf :         ('a, Format.formatter, unit, ('b, [> B0.R.msg ]) Pervasives.result)         Pervasives.format4 -> 'a       val reword_error_msg :         ?replace:bool ->         (string -> B0.R.msg) ->         ('a, B0.R.msg) Pervasives.result ->         ('a, [> B0.R.msg ]) Pervasives.result       val open_error_msg :         ('a, B0.R.msg) Pervasives.result ->         ('a, [> B0.R.msg ]) Pervasives.result       val failwith_error_msg : ('a, B0.R.msg) Pervasives.result -> 'a     end   module Fmt :     sig       val pf :         Format.formatter ->         ('a, Format.formatter, unit) Pervasives.format -> 'a       type 'a t = Format.formatter -> '-> unit       val nop : 'B0.Fmt.t       val cut : unit B0.Fmt.t       val sp : unit B0.Fmt.t       val comma : unit B0.Fmt.t       val unit :         (unit, Format.formatter, unit) Pervasives.format -> unit B0.Fmt.t       val bool : bool B0.Fmt.t       val int : int B0.Fmt.t       val char : char B0.Fmt.t       val string : string B0.Fmt.t       val pair :         ?sep:unit B0.Fmt.t ->         'B0.Fmt.t -> 'B0.Fmt.t -> ('a * 'b) B0.Fmt.t       val list : ?sep:unit B0.Fmt.t -> 'B0.Fmt.t -> 'a list B0.Fmt.t       val option : ?none:unit B0.Fmt.t -> 'B0.Fmt.t -> 'a option B0.Fmt.t       val iter :         ?sep:unit B0.Fmt.t ->         (('-> unit) -> '-> unit) -> 'B0.Fmt.t -> 'B0.Fmt.t       val iter_bindings :         ?sep:unit B0.Fmt.t ->         (('-> '-> unit) -> '-> unit) ->         ('a * 'b) B0.Fmt.t -> 'B0.Fmt.t       val text : string B0.Fmt.t       val lines : string B0.Fmt.t       val exn : exn B0.Fmt.t       val exn_backtrace : (exn * Printexc.raw_backtrace) B0.Fmt.t       val box : ?indent:int -> 'B0.Fmt.t -> 'B0.Fmt.t       val hbox : 'B0.Fmt.t -> 'B0.Fmt.t       val vbox : ?indent:int -> 'B0.Fmt.t -> 'B0.Fmt.t       val hvbox : ?indent:int -> 'B0.Fmt.t -> 'B0.Fmt.t       val parens : 'B0.Fmt.t -> 'B0.Fmt.t       val brackets : 'B0.Fmt.t -> 'B0.Fmt.t       val braces : 'B0.Fmt.t -> 'B0.Fmt.t       val field_label : string B0.Fmt.t       val field : string -> 'B0.Fmt.t -> 'B0.Fmt.t     end   val strf : ('a, Format.formatter, unit, string) Pervasives.format4 -> 'a   module String :     sig       external length : string -> int = "%string_length"       external get : string -> int -> char = "%string_safe_get"       external set : bytes -> int -> char -> unit = "%string_safe_set"       external create : int -> bytes = "caml_create_string"       val make : int -> char -> string       val init : int -> (int -> char) -> string       val copy : string -> string       val sub : string -> int -> int -> string       val fill : bytes -> int -> int -> char -> unit       val blit : string -> int -> bytes -> int -> int -> unit       val concat : string -> string list -> string       val iter : (char -> unit) -> string -> unit       val iteri : (int -> char -> unit) -> string -> unit       val trim : string -> string       val escaped : string -> string       val index : string -> char -> int       val rindex : string -> char -> int       val index_from : string -> int -> char -> int       val rindex_from : string -> int -> char -> int       val contains : string -> char -> bool       val contains_from : string -> int -> char -> bool       val rcontains_from : string -> int -> char -> bool       val uppercase : string -> string       val lowercase : string -> string       val capitalize : string -> string       val uncapitalize : string -> string       val uppercase_ascii : string -> string       val lowercase_ascii : string -> string       val capitalize_ascii : string -> string       val uncapitalize_ascii : string -> string       type t = string       val compare : t -> t -> int       val equal : t -> t -> bool       external unsafe_get : string -> int -> char = "%string_unsafe_get"       external unsafe_set : bytes -> int -> char -> unit         = "%string_unsafe_set"       external unsafe_blit : string -> int -> bytes -> int -> int -> unit         = "caml_blit_string" [@@noalloc]       external unsafe_fill : bytes -> int -> int -> char -> unit         = "caml_fill_string" [@@noalloc]       val head : string -> char option       val of_char : char -> string       val is_prefix : affix:string -> string -> bool       val is_suffix : affix:string -> string -> bool       val for_all : (char -> bool) -> string -> bool       val exists : (char -> bool) -> string -> bool       val with_index_range : ?first:int -> ?last:int -> string -> string       val span : sat:(char -> bool) -> string -> string * string       val take : sat:(char -> bool) -> string -> string       val drop : sat:(char -> bool) -> string -> string       val cut : ?rev:bool -> sep:string -> string -> (string * string) option       val cuts :         ?rev:bool -> ?empty:bool -> sep:string -> string -> string list       val map : (char -> char) -> string -> string       val mapi : (int -> char -> char) -> string -> string       val pp : string B0.Fmt.t       val dump : string B0.Fmt.t       val uniquify : string list -> string list       val unique : exists:(string -> bool) -> string -> string B0.result       val edit_distance : string -> string -> int       val suggest : ?dist:int -> string list -> string -> string list       val parse_version : string -> (int * int * int * string option) option       val drop_initial_v : string -> string       type set       module Set :         sig           val empty : set           val is_empty : set -> bool           val mem : string -> set -> bool           val add : string -> set -> set           val singleton : string -> set           val remove : string -> set -> set           val union : set -> set -> set           val inter : set -> set -> set           val diff : set -> set -> set           val compare : set -> set -> int           val equal : set -> set -> bool           val subset : set -> set -> bool           val iter : (string -> unit) -> set -> unit           val fold : (string -> '-> 'a) -> set -> '-> 'a           val for_all : (string -> bool) -> set -> bool           val exists : (string -> bool) -> set -> bool           val filter : (string -> bool) -> set -> set           val partition : (string -> bool) -> set -> set * set           val cardinal : set -> int           val elements : set -> string list           val min_elt : set -> string           val max_elt : set -> string           val choose : set -> string           val split : string -> set -> set * bool * set           val find : string -> set -> string           val of_list : string list -> set           type t = B0.String.set           val pp :             ?sep:unit B0.Fmt.t -> string B0.Fmt.t -> B0.String.set B0.Fmt.t           val dump : B0.String.set B0.Fmt.t         end       type +'a map       module Map :         sig           val empty : 'a map           val is_empty : 'a map -> bool           val mem : string -> 'a map -> bool           val add : string -> '-> 'a map -> 'a map           val singleton : string -> '-> 'a map           val remove : string -> 'a map -> 'a map           val merge :             (string -> 'a option -> 'b option -> 'c option) ->             'a map -> 'b map -> 'c map           val union :             (string -> '-> '-> 'a option) -> 'a map -> 'a map -> 'a map           val compare : ('-> '-> int) -> 'a map -> 'a map -> int           val equal : ('-> '-> bool) -> 'a map -> 'a map -> bool           val iter : (string -> '-> unit) -> 'a map -> unit           val fold : (string -> '-> '-> 'b) -> 'a map -> '-> 'b           val for_all : (string -> '-> bool) -> 'a map -> bool           val exists : (string -> '-> bool) -> 'a map -> bool           val filter : (string -> '-> bool) -> 'a map -> 'a map           val partition : (string -> '-> bool) -> 'a map -> 'a map * 'a map           val cardinal : 'a map -> int           val bindings : 'a map -> (string * 'a) list           val min_binding : 'a map -> string * 'a           val max_binding : 'a map -> string * 'a           val choose : 'a map -> string * 'a           val split : string -> 'a map -> 'a map * 'a option * 'a map           val find : string -> 'a map -> 'a           val map : ('-> 'b) -> 'a map -> 'b map           val mapi : (string -> '-> 'b) -> 'a map -> 'b map           type 'a t = 'B0.String.map           val dom : 'B0.String.map -> B0.String.set           val of_list : (string * 'a) list -> 'B0.String.map           val pp :             ?sep:unit B0.Fmt.t ->             (string * 'a) B0.Fmt.t -> 'B0.String.map B0.Fmt.t           val dump : 'B0.Fmt.t -> 'B0.String.map B0.Fmt.t           val dump_string_map : string B0.String.map B0.Fmt.t         end     end   type fpath = B0_fpath.t   module Codec :     sig       type 'a t       val v : id:string -> 'B0.Codec.t       val write : 'B0.Codec.t -> B0.fpath -> '-> unit B0.result       val read : 'B0.Codec.t -> B0.fpath -> 'B0.result     end   module Conv :     sig       type 'a codec       val codec :         (string -> 'B0.result) * ('-> string B0.result) ->         'B0.Conv.codec       type 'a text       val text : (string -> 'B0.result) * 'B0.Fmt.t -> 'B0.Conv.text       type 'a t       val v :         ?docv:string ->         ?codec:'B0.Conv.codec -> 'B0.Conv.text -> 'B0.Conv.t       val with_docv : 'B0.Conv.t -> string -> 'B0.Conv.t       val parse : 'B0.Conv.t -> string -> 'B0.result       val print : 'B0.Conv.t -> 'B0.Fmt.t       val decode : 'B0.Conv.t -> string -> 'B0.result       val encode : 'B0.Conv.t -> '-> string B0.result       val docv : 'B0.Conv.t -> string       val bool : bool B0.Conv.t       val char : char B0.Conv.t       val int : int B0.Conv.t       val int32 : int32 B0.Conv.t       val int64 : int64 B0.Conv.t       val float : float B0.Conv.t       val string : string B0.Conv.t       val string_non_empty : string B0.Conv.t       val fpath : B0.fpath B0.Conv.t       val file : B0.fpath B0.Conv.t       val dir : B0.fpath B0.Conv.t       val bin : B0.fpath B0.Conv.t       val enum : ?docv:string -> (string * 'a) list -> 'B0.Conv.t       val list : ?sep:string -> 'B0.Conv.t -> 'a list B0.Conv.t       val pair :         ?sep:string -> 'B0.Conv.t -> 'B0.Conv.t -> ('a * 'b) B0.Conv.t       val option : ?none:string -> 'B0.Conv.t -> 'a option B0.Conv.t     end   module Tty :     sig       type kind = No_tty | Dumb | Term of string       val kind : out:Unix.file_descr -> B0.Tty.kind       type cap = Ansi | None       val cap : B0.Tty.kind -> B0.Tty.cap       val strip_escapes : string -> string       type color =           [ `Black           | `Blue           | `Cyan           | `Default           | `Green           | `Magenta           | `Red           | `White           | `Yellow ]       type style =           [ `Bg of B0.Tty.color           | `Blink of [ `Rapid | `Slow ]           | `Bold           | `Faint           | `Fg of B0.Tty.color           | `Italic           | `Reverse           | `Underline ]       val str_cap : B0.Tty.cap -> B0.Tty.style list -> string -> string       val set_styling_cap : B0.Tty.cap -> unit       val styling_cap : unit -> B0.Tty.cap       val str : B0.Tty.style list -> string -> string       val pp_str : B0.Tty.style list -> string B0.Fmt.t       val pp : B0.Tty.style list -> 'B0.Fmt.t -> 'B0.Fmt.t     end   module Log :     sig       type level = App | Error | Warning | Info | Debug       val level : unit -> B0.Log.level option       val set_level : B0.Log.level option -> unit       val pp_level : B0.Log.level B0.Fmt.t       val level_to_string : B0.Log.level option -> string       val level_of_string :         string -> (B0.Log.level option, [ `Msg of string ]) Pervasives.result       type ('a, 'b) msgf =           (?header:string ->            ('a, Format.formatter, unit, 'b) Pervasives.format4 -> 'a) ->           'b       type 'a log = ('a, unit) B0.Log.msgf -> unit       val msg : B0.Log.level -> 'B0.Log.log       val maybe : B0.Log.level option -> 'B0.Log.log       val app : 'B0.Log.log       val err : 'B0.Log.log       val warn : 'B0.Log.log       val info : 'B0.Log.log       val debug : 'B0.Log.log       val kmsg : (unit -> 'b) -> B0.Log.level -> ('a, 'b) B0.Log.msgf -> 'b       val on_error :         ?level:B0.Log.level ->         ?header:string ->         pp:'B0.Fmt.t -> use:('-> 'a) -> ('a, 'b) Pervasives.result -> 'a       val on_error_msg :         ?level:B0.Log.level ->         ?header:string ->         use:(unit -> 'a) -> ('a, [ `Msg of string ]) Pervasives.result -> 'a       val time :         ?level:B0.Log.level ->         ('->          (('b, Format.formatter, unit, 'a) Pervasives.format4 -> 'b) -> 'a) ->         ('-> 'a) -> '-> 'a       val err_count : unit -> int       val warn_count : unit -> int       type kmsg = {         kmsg :           ''b. (unit -> 'b) -> B0.Log.level -> ('a, 'b) B0.Log.msgf -> 'b;       }       val set_kmsg : B0.Log.kmsg -> unit     end   module Def :     sig       type loc       module Loc :         sig           type t = B0.Def.loc           val none : B0.Def.loc           val lib : string -> B0.Def.loc           val file : B0.fpath -> B0.Def.loc           val is_none : B0.Def.loc -> bool           val find_file : B0.Def.loc -> B0.fpath option           val equal : B0.Def.loc -> B0.Def.loc -> bool           val compare : B0.Def.loc -> B0.Def.loc -> int           val pp : B0.Def.loc B0.Fmt.t           val set_root : B0.fpath option -> unit           val get_root : unit -> B0.fpath option           val set_sub_root : B0.fpath option -> unit           val get_sub_root : unit -> B0.fpath option           val set_current : B0.Def.loc -> unit           val get_current : unit -> B0.Def.loc         end       module Name :         sig           val space : unit -> string           val spaced : string -> string           exception Panic         end       type t       type def = B0.Def.t       module type DEFINED =         sig           type t           val def_kind : string           val def_get : B0.Def.DEFINED.t -> B0.Def.def           val def_namespaced : bool           val def_name_tty_color : B0.Tty.color           val def_pp_info : B0.Def.DEFINED.t B0.Fmt.t         end       module type S =         sig           type t           val value_kind : string           val name : B0.Def.S.t -> string           val loc : B0.Def.S.t -> B0.Def.loc           val doc : B0.Def.S.t -> string           val equal : B0.Def.S.t -> B0.Def.S.t -> bool           val compare : B0.Def.S.t -> B0.Def.S.t -> int           val compare_by_name : B0.Def.S.t -> B0.Def.S.t -> int           val find : string -> B0.Def.S.t option           val get : string -> B0.Def.S.t           val get_or_suggest :             string -> (B0.Def.S.t, string list) Pervasives.result           val list : unit -> B0.Def.S.t list           val pp_name_str : string B0.Fmt.t           val pp_name : B0.Def.S.t B0.Fmt.t           val pp_synopsis : B0.Def.S.t B0.Fmt.t           val pp_info : B0.Def.S.t B0.Fmt.t           val pp_info_ext : B0.Def.S.t B0.Fmt.t -> B0.Def.S.t B0.Fmt.t         end       module type S_DEF =         sig           type t           val value_kind : string           val name : t -> string           val loc : t -> loc           val doc : t -> string           val equal : t -> t -> bool           val compare : t -> t -> int           val compare_by_name : t -> t -> int           val find : string -> t option           val get : string -> t           val get_or_suggest : string -> (t, string list) result           val list : unit -> t list           val pp_name_str : string Fmt.t           val pp_name : t Fmt.t           val pp_synopsis : t Fmt.t           val pp_info : t Fmt.t           val pp_info_ext : t Fmt.t -> t Fmt.t           val def : ?loc:B0.Def.loc -> ?doc:string -> string -> B0.Def.def           val def_add : B0.Def.t -> unit           val def_rem : B0.Def.t -> unit         end       module Make :         functor (V : DEFINED->           sig             type t = V.t             val value_kind : string             val name : t -> string             val loc : t -> loc             val doc : t -> string             val equal : t -> t -> bool             val compare : t -> t -> int             val compare_by_name : t -> t -> int             val find : string -> t option             val get : string -> t             val get_or_suggest : string -> (t, string list) result             val list : unit -> t list             val pp_name_str : string Fmt.t             val pp_name : t Fmt.t             val pp_synopsis : t Fmt.t             val pp_info : t Fmt.t             val pp_info_ext : t Fmt.t -> t Fmt.t             val def : ?loc:loc -> ?doc:string -> string -> def             val def_add : t -> unit             val def_rem : t -> unit           end     end   module Hmap :     sig       module type KEY =         sig           type 'a typed           type 'a info           type t = V : 'B0.Hmap.KEY.typed -> B0.Hmap.KEY.t           val v :             ?loc:B0.Def.loc ->             ?doc:string ->             string ->             'B0.Conv.t -> 'B0.Hmap.KEY.info -> 'B0.Hmap.KEY.typed           val conv : 'B0.Hmap.KEY.typed -> 'B0.Conv.t           val info : 'B0.Hmap.KEY.typed -> 'B0.Hmap.KEY.info           val of_typed : 'B0.Hmap.KEY.typed -> B0.Hmap.KEY.t           val value_kind : string           val name : t -> string           val loc : t -> Def.loc           val doc : t -> string           val equal : t -> t -> bool           val compare : t -> t -> int           val compare_by_name : t -> t -> int           val find : string -> t option           val get : string -> t           val get_or_suggest : string -> (t, string list) result           val list : unit -> t list           val pp_name_str : string Fmt.t           val pp_name : t Fmt.t           val pp_synopsis : t Fmt.t           val pp_info : t Fmt.t           val pp_info_ext : t Fmt.t -> t Fmt.t         end       module type KEY_INFO =         sig           type 'a t           val key_kind : string           val key_namespaced : bool           val key_name_tty_color : B0.Tty.color           val pp : 'B0.Fmt.t -> 'B0.Hmap.KEY_INFO.t B0.Fmt.t         end       module type MAP =         sig           type 'a key           type t           val empty : B0.Hmap.MAP.t           val is_empty : B0.Hmap.MAP.t -> bool           val mem : 'B0.Hmap.MAP.key -> B0.Hmap.MAP.t -> bool           val add :             'B0.Hmap.MAP.key -> '-> B0.Hmap.MAP.t -> B0.Hmap.MAP.t           val add_tag :             bool B0.Hmap.MAP.key -> B0.Hmap.MAP.t -> B0.Hmap.MAP.t           val singleton : 'B0.Hmap.MAP.key -> '-> B0.Hmap.MAP.t           val rem : 'B0.Hmap.MAP.key -> B0.Hmap.MAP.t -> B0.Hmap.MAP.t           val find : 'B0.Hmap.MAP.key -> B0.Hmap.MAP.t -> 'a option           val get : 'B0.Hmap.MAP.key -> B0.Hmap.MAP.t -> 'a           val get_or_suggest :             'B0.Hmap.MAP.key ->             B0.Hmap.MAP.t -> ('a, string list) Pervasives.result           val flag :             ?absent:bool -> bool B0.Hmap.MAP.key -> B0.Hmap.MAP.t -> bool           type binding = B : 'B0.Hmap.MAP.key * '-> B0.Hmap.MAP.binding           val iter : (B0.Hmap.MAP.binding -> unit) -> B0.Hmap.MAP.t -> unit           val fold :             (B0.Hmap.MAP.binding -> '-> 'a) -> B0.Hmap.MAP.t -> '-> 'a           val for_all :             (B0.Hmap.MAP.binding -> bool) -> B0.Hmap.MAP.t -> bool           val exists : (B0.Hmap.MAP.binding -> bool) -> B0.Hmap.MAP.t -> bool           val filter :             (B0.Hmap.MAP.binding -> bool) -> B0.Hmap.MAP.t -> B0.Hmap.MAP.t           val cardinal : B0.Hmap.MAP.t -> int           val any_binding : B0.Hmap.MAP.t -> B0.Hmap.MAP.binding option           val get_any_binding : B0.Hmap.MAP.t -> B0.Hmap.MAP.binding           val pp : B0.Hmap.MAP.t B0.Fmt.t           type encode_error = string * [ `Msg of string ]           val encode :             B0.Hmap.MAP.t ->             (string * string) list * B0.Hmap.MAP.encode_error list           type decode_error = string * [ `Msg of string | `Unknown ]           val decode :             (string * string) list ->             B0.Hmap.MAP.t * B0.Hmap.MAP.decode_error list         end       module type S =         sig           module Key : KEY           type 'a key = 'Key.typed           type t           val empty : t           val is_empty : t -> bool           val mem : 'a key -> t -> bool           val add : 'a key -> '-> t -> t           val add_tag : bool key -> t -> t           val singleton : 'a key -> '-> t           val rem : 'a key -> t -> t           val find : 'a key -> t -> 'a option           val get : 'a key -> t -> 'a           val get_or_suggest : 'a key -> t -> ('a, string list) result           val flag : ?absent:bool -> bool key -> t -> bool           type binding = B : 'a key * '-> binding           val iter : (binding -> unit) -> t -> unit           val fold : (binding -> '-> 'a) -> t -> '-> 'a           val for_all : (binding -> bool) -> t -> bool           val exists : (binding -> bool) -> t -> bool           val filter : (binding -> bool) -> t -> t           val cardinal : t -> int           val any_binding : t -> binding option           val get_any_binding : t -> binding           val pp : t Fmt.t           type encode_error = string * [ `Msg of string ]           val encode : t -> (string * string) list * encode_error list           type decode_error = string * [ `Msg of string | `Unknown ]           val decode : (string * string) list -> t * decode_error list         end       module Make :         functor (Key_info : KEY_INFO) () ->           sig             module Key :               sig                 type 'a typed                 type 'a info = 'Key_info.t                 type t = V : 'a typed -> t                 val v :                   ?loc:Def.loc ->                   ?doc:string -> string -> 'Conv.t -> 'a info -> 'a typed                 val conv : 'a typed -> 'Conv.t                 val info : 'a typed -> 'a info                 val of_typed : 'a typed -> t                 val value_kind : string                 val name : t -> string                 val loc : t -> Def.loc                 val doc : t -> string                 val equal : t -> t -> bool                 val compare : t -> t -> int                 val compare_by_name : t -> t -> int                 val find : string -> t option                 val get : string -> t                 val get_or_suggest : string -> (t, string list) result                 val list : unit -> t list                 val pp_name_str : string Fmt.t                 val pp_name : t Fmt.t                 val pp_synopsis : t Fmt.t                 val pp_info : t Fmt.t                 val pp_info_ext : t Fmt.t -> t Fmt.t               end             type 'a key = 'Key.typed             type t             val empty : t             val is_empty : t -> bool             val mem : 'a key -> t -> bool             val add : 'a key -> '-> t -> t             val add_tag : bool key -> t -> t             val singleton : 'a key -> '-> t             val rem : 'a key -> t -> t             val find : 'a key -> t -> 'a option             val get : 'a key -> t -> 'a             val get_or_suggest : 'a key -> t -> ('a, string list) result             val flag : ?absent:bool -> bool key -> t -> bool             type binding = B : 'a key * '-> binding             val iter : (binding -> unit) -> t -> unit             val fold : (binding -> '-> 'a) -> t -> '-> 'a             val for_all : (binding -> bool) -> t -> bool             val exists : (binding -> bool) -> t -> bool             val filter : (binding -> bool) -> t -> t             val cardinal : t -> int             val any_binding : t -> binding option             val get_any_binding : t -> binding             val pp : t Fmt.t             type encode_error = string * [ `Msg of string ]             val encode : t -> (string * string) list * encode_error list             type decode_error = string * [ `Msg of string | `Unknown ]             val decode : (string * string) list -> t * decode_error list           end     end   module Fpath :     sig       val dir_sep : string       val is_seg : string -> bool       val is_rel_seg : string -> bool       type t = B0.fpath       val v : string -> B0.Fpath.t       val of_string : string -> B0.Fpath.t B0.result       val to_string : B0.Fpath.t -> string       val add_seg : B0.Fpath.t -> string -> B0.Fpath.t       val append : B0.Fpath.t -> B0.Fpath.t -> B0.Fpath.t       val ( / ) : B0.Fpath.t -> string -> B0.Fpath.t       val ( // ) : B0.Fpath.t -> B0.Fpath.t -> B0.Fpath.t       val is_dir_path : B0.Fpath.t -> bool       val is_file_path : B0.Fpath.t -> bool       val to_dir_path : B0.Fpath.t -> B0.Fpath.t       val filename : B0.Fpath.t -> string       val filename_equal : B0.Fpath.t -> B0.Fpath.t -> bool       val basename : B0.Fpath.t -> string       val basename_equal : B0.Fpath.t -> B0.Fpath.t -> bool       val parent : B0.Fpath.t -> B0.Fpath.t       val is_rel : B0.Fpath.t -> bool       val is_abs : B0.Fpath.t -> bool       val is_root : B0.Fpath.t -> bool       val equal : B0.Fpath.t -> B0.Fpath.t -> bool       val compare : B0.Fpath.t -> B0.Fpath.t -> int       type ext = string       val get_ext : ?multi:bool -> B0.Fpath.t -> B0.Fpath.ext       val has_ext : B0.Fpath.ext -> B0.Fpath.t -> bool       val mem_ext : B0.Fpath.ext list -> B0.Fpath.t -> bool       val add_ext : B0.Fpath.ext -> B0.Fpath.t -> B0.Fpath.t       val rem_ext : ?multi:bool -> B0.Fpath.t -> B0.Fpath.t       val set_ext : ?multi:bool -> B0.Fpath.ext -> B0.Fpath.t -> B0.Fpath.t       val split_ext : ?multi:bool -> B0.Fpath.t -> B0.Fpath.t * B0.Fpath.ext       val ( + ) : B0.Fpath.t -> B0.Fpath.ext -> B0.Fpath.t       val ( -+ ) : B0.Fpath.t -> B0.Fpath.ext -> B0.Fpath.t       val pp : B0.Fpath.t B0.Fmt.t       val dump : B0.Fpath.t B0.Fmt.t       val uniquify : B0.Fpath.t list -> B0.Fpath.t list       type set       module Set :         sig           val empty : set           val is_empty : set -> bool           val mem : t -> set -> bool           val add : t -> set -> set           val singleton : t -> set           val remove : t -> set -> set           val union : set -> set -> set           val inter : set -> set -> set           val diff : set -> set -> set           val compare : set -> set -> int           val equal : set -> set -> bool           val subset : set -> set -> bool           val iter : (t -> unit) -> set -> unit           val fold : (t -> '-> 'a) -> set -> '-> 'a           val for_all : (t -> bool) -> set -> bool           val exists : (t -> bool) -> set -> bool           val filter : (t -> bool) -> set -> set           val partition : (t -> bool) -> set -> set * set           val cardinal : set -> int           val elements : set -> t list           val min_elt : set -> t           val max_elt : set -> t           val choose : set -> t           val split : t -> set -> set * bool * set           val find : t -> set -> t           val of_list : t list -> set           val pp :             ?sep:unit B0.Fmt.t ->             B0.Fpath.t B0.Fmt.t -> B0.Fpath.set B0.Fmt.t           val dump : B0.Fpath.set B0.Fmt.t           type t = B0.Fpath.set         end       type +'a map       module Map :         sig           val empty : 'a map           val is_empty : 'a map -> bool           val mem : t -> 'a map -> bool           val add : t -> '-> 'a map -> 'a map           val singleton : t -> '-> 'a map           val remove : t -> 'a map -> 'a map           val merge :             (t -> 'a option -> 'b option -> 'c option) ->             'a map -> 'b map -> 'c map           val union :             (t -> '-> '-> 'a option) -> 'a map -> 'a map -> 'a map           val compare : ('-> '-> int) -> 'a map -> 'a map -> int           val equal : ('-> '-> bool) -> 'a map -> 'a map -> bool           val iter : (t -> '-> unit) -> 'a map -> unit           val fold : (t -> '-> '-> 'b) -> 'a map -> '-> 'b           val for_all : (t -> '-> bool) -> 'a map -> bool           val exists : (t -> '-> bool) -> 'a map -> bool           val filter : (t -> '-> bool) -> 'a map -> 'a map           val partition : (t -> '-> bool) -> 'a map -> 'a map * 'a map           val cardinal : 'a map -> int           val bindings : 'a map -> (t * 'a) list           val min_binding : 'a map -> t * 'a           val max_binding : 'a map -> t * 'a           val choose : 'a map -> t * 'a           val split : t -> 'a map -> 'a map * 'a option * 'a map           val find : t -> 'a map -> 'a           val map : ('-> 'b) -> 'a map -> 'b map           val mapi : (t -> '-> 'b) -> 'a map -> 'b map           val dom : 'B0.Fpath.map -> B0.Fpath.set           val of_list : (B0.Fpath.t * 'a) list -> 'B0.Fpath.map           val pp :             ?sep:unit B0.Fmt.t ->             (B0.Fpath.t * 'a) B0.Fmt.t -> 'B0.Fpath.map B0.Fmt.t           val dump : 'B0.Fmt.t -> 'B0.Fpath.map B0.Fmt.t           type 'a t = 'B0.Fpath.map         end       module Meta :         sig           module Key :             sig               type 'a typed               type 'a info = unit               type t = V : 'a typed -> t               val v :                 ?loc:Def.loc ->                 ?doc:string -> string -> 'Conv.t -> 'a info -> 'a typed               val conv : 'a typed -> 'Conv.t               val info : 'a typed -> 'a info               val of_typed : 'a typed -> t               val value_kind : string               val name : t -> string               val loc : t -> Def.loc               val doc : t -> string               val equal : t -> t -> bool               val compare : t -> t -> int               val compare_by_name : t -> t -> int               val find : string -> t option               val get : string -> t               val get_or_suggest : string -> (t, string list) result               val list : unit -> t list               val pp_name_str : string Fmt.t               val pp_name : t Fmt.t               val pp_synopsis : t Fmt.t               val pp_info : t Fmt.t               val pp_info_ext : t Fmt.t -> t Fmt.t             end           type 'a key = 'Key.typed           type t           val empty : t           val is_empty : t -> bool           val mem : 'a key -> t -> bool           val add : 'a key -> '-> t -> t           val add_tag : bool key -> t -> t           val singleton : 'a key -> '-> t           val rem : 'a key -> t -> t           val find : 'a key -> t -> 'a option           val get : 'a key -> t -> 'a           val get_or_suggest : 'a key -> t -> ('a, string list) result           val flag : ?absent:bool -> bool key -> t -> bool           type binding = B : 'a key * '-> binding           val iter : (binding -> unit) -> t -> unit           val fold : (binding -> '-> 'a) -> t -> '-> 'a           val for_all : (binding -> bool) -> t -> bool           val exists : (binding -> bool) -> t -> bool           val filter : (binding -> bool) -> t -> t           val cardinal : t -> int           val any_binding : t -> binding option           val get_any_binding : t -> binding           val pp : t Fmt.t           type encode_error = string * [ `Msg of string ]           val encode : t -> (string * string) list * encode_error list           type decode_error = string * [ `Msg of string | `Unknown ]           val decode : (string * string) list -> t * decode_error list         end       module Meta_map :         sig           type t = B0.Fpath.Meta.t B0.Fpath.map           val empty : B0.Fpath.Meta_map.t           val mem :             B0.fpath -> 'B0.Fpath.Meta.key -> B0.Fpath.Meta_map.t -> bool           val add :             B0.fpath ->             'B0.Fpath.Meta.key ->             '-> B0.Fpath.Meta_map.t -> B0.Fpath.Meta_map.t           val rem :             B0.fpath ->             'B0.Fpath.Meta.key ->             B0.Fpath.Meta_map.t -> B0.Fpath.Meta_map.t           val find :             B0.fpath ->             'B0.Fpath.Meta.key -> B0.Fpath.Meta_map.t -> 'a option           val get :             B0.fpath -> 'B0.Fpath.Meta.key -> B0.Fpath.Meta_map.t -> 'a           val get_all : B0.fpath -> B0.Fpath.Meta_map.t -> B0.Fpath.Meta.t         end     end   module Cmd :     sig       type t       val v : string -> B0.Cmd.t       val empty : B0.Cmd.t       val is_empty : B0.Cmd.t -> bool       val ( % ) : B0.Cmd.t -> string -> B0.Cmd.t       val ( %% ) : B0.Cmd.t -> B0.Cmd.t -> B0.Cmd.t       val add_arg : B0.Cmd.t -> string -> B0.Cmd.t       val add_args : B0.Cmd.t -> B0.Cmd.t -> B0.Cmd.t       val on : bool -> B0.Cmd.t -> B0.Cmd.t       val p : B0.Fpath.t -> string       val line_exec : B0.Cmd.t -> string option       val get_line_exec : B0.Cmd.t -> string       val line_args : B0.Cmd.t -> string list       val equal : B0.Cmd.t -> B0.Cmd.t -> bool       val compare : B0.Cmd.t -> B0.Cmd.t -> int       val of_string : string -> B0.Cmd.t B0.result       val to_string : B0.Cmd.t -> string       val to_list : B0.Cmd.t -> string list       val to_rev_list : B0.Cmd.t -> string list       val of_list : ?slip:string -> string list -> B0.Cmd.t       val of_rev_list : string list -> B0.Cmd.t       val of_values : ?slip:string -> ('-> string) -> 'a list -> B0.Cmd.t       val pp : B0.Cmd.t B0.Fmt.t       val dump : B0.Cmd.t B0.Fmt.t     end   module OS :     sig       module Env :         sig           val var : string -> string option           val opt_var : string -> absent:string -> string           type t = string B0.String.map           val empty : B0.OS.Env.t           val current : unit -> B0.OS.Env.t B0.result           val override : B0.OS.Env.t -> by:B0.OS.Env.t -> B0.OS.Env.t           val of_assignments :             ?init:B0.OS.Env.t -> string list -> B0.OS.Env.t B0.result           val to_assignments : B0.OS.Env.t -> string list         end       module File :         sig           val null : B0.Fpath.t           val dash : B0.Fpath.t           val exists : B0.Fpath.t -> bool B0.result           val must_exist : B0.Fpath.t -> B0.Fpath.t B0.result           val delete : ?must_exist:bool -> B0.Fpath.t -> unit B0.result           val link :             force:bool -> target:B0.Fpath.t -> B0.Fpath.t -> unit B0.result           val with_ic :             B0.Fpath.t ->             (Pervasives.in_channel -> '-> 'b) -> '-> 'B0.result           val read : B0.Fpath.t -> string B0.result           val with_oc :             ?mode:int ->             B0.Fpath.t ->             (Pervasives.out_channel -> '-> ('c, 'd) Pervasives.result) ->             '-> ('c, 'd) Pervasives.result B0.result           val write : ?mode:int -> B0.Fpath.t -> string -> unit B0.result           val with_tmp_oc :             ?mode:int ->             B0.Fpath.t ->             (B0.Fpath.t -> Pervasives.out_channel -> '-> 'b) ->             '-> 'B0.result         end       module Dir :         sig           val exists : B0.Fpath.t -> bool B0.result           val must_exist : B0.Fpath.t -> B0.Fpath.t B0.result           val create :             ?path:bool -> ?mode:int -> B0.Fpath.t -> bool B0.result           val delete :             ?must_exist:bool -> contents:bool -> B0.Fpath.t -> unit B0.result           val contents :             ?dotfiles:bool ->             ?rel:bool -> B0.Fpath.t -> B0.Fpath.t list B0.result           val files :             ?dotfiles:bool ->             ?rel:bool -> B0.Fpath.t -> B0.Fpath.t list B0.result           val dirs :             ?dotfiles:bool ->             ?rel:bool -> B0.Fpath.t -> B0.Fpath.t list B0.result           val current : unit -> B0.Fpath.t B0.result           val set_current : B0.Fpath.t -> unit B0.result           val with_current : B0.Fpath.t -> ('-> 'b) -> '-> 'B0.result           val default_tmp : unit -> B0.Fpath.t           val set_default_tmp : B0.Fpath.t -> unit         end       module Cmd :         sig           val exists : B0.Cmd.t -> bool B0.result           val must_exist : B0.Cmd.t -> B0.Cmd.t B0.result           val which : B0.Cmd.t -> B0.Fpath.t option B0.result           val which_raw : string -> string option           val execv_raw : string -> string array -> unit B0.result           val execve_raw :             string -> string array -> env:string array -> unit B0.result           type status = [ `Exited of int | `Signaled of int ]           val pp_status : B0.OS.Cmd.status B0.Fmt.t           val run : ?err:B0.Fpath.t -> B0.Cmd.t -> unit B0.result           val run_status :             ?err:B0.Fpath.t -> B0.Cmd.t -> B0.OS.Cmd.status B0.result           type run_status = B0.Cmd.t * B0.OS.Cmd.status           val success : ('a * B0.OS.Cmd.run_status) B0.result -> 'B0.result           type run_out           val out_string :             ?trim:bool ->             B0.OS.Cmd.run_out -> (string * B0.OS.Cmd.run_status) B0.result           val out_file :             B0.Fpath.t ->             B0.OS.Cmd.run_out -> (unit * B0.OS.Cmd.run_status) B0.result           val out_stdout :             B0.OS.Cmd.run_out -> (unit * B0.OS.Cmd.run_status) B0.result           val to_string : ?trim:bool -> B0.OS.Cmd.run_out -> string B0.result           val to_file : B0.Fpath.t -> B0.OS.Cmd.run_out -> unit B0.result           val to_null : B0.OS.Cmd.run_out -> unit B0.result           val run_out : ?err:B0.Fpath.t -> B0.Cmd.t -> B0.OS.Cmd.run_out         end     end   module Time :     sig       type span       val zero : B0.Time.span       val add : B0.Time.span -> B0.Time.span -> B0.Time.span       val sub : B0.Time.span -> B0.Time.span -> B0.Time.span       val to_ns : B0.Time.span -> float       val to_uint64_ns : B0.Time.span -> int64       val of_uint64_ns : int64 -> B0.Time.span       val pp_span : B0.Time.span B0.Fmt.t       val pp_span_uint_ns : B0.Time.span B0.Fmt.t       val compare_span : B0.Time.span -> B0.Time.span -> int       type counter       val counter : unit -> B0.Time.counter       val count : B0.Time.counter -> B0.Time.span       type cpu       type cpu_counter       val cpu_counter : unit -> B0.Time.cpu_counter       val cpu_count : B0.Time.cpu_counter -> B0.Time.cpu       val cpu_zero : B0.Time.cpu       val cpu_utime_s : B0.Time.cpu -> float       val cpu_stime_s : B0.Time.cpu -> float       val cpu_children_utime_s : B0.Time.cpu -> float       val cpu_children_stime_s : B0.Time.cpu -> float       val pp_float_s : float B0.Fmt.t     end   module Hash :     sig       type t       val zero : B0.Hash.t       val string : string -> B0.Hash.t       val file : B0.Fpath.t -> B0.Hash.t       val raw_file : string -> B0.Hash.t       val to_byte_string : B0.Hash.t -> string       val to_hex : B0.Hash.t -> string       val of_hex : string -> B0.Hash.t option       val equal : B0.Hash.t -> B0.Hash.t -> bool       val compare : B0.Hash.t -> B0.Hash.t -> int       val pp : B0.Hash.t B0.Fmt.t       module Set :         sig           type elt = t           type t           val empty : t           val is_empty : t -> bool           val mem : elt -> t -> bool           val add : elt -> t -> t           val singleton : elt -> t           val remove : elt -> t -> t           val union : t -> t -> t           val inter : t -> t -> t           val diff : t -> t -> t           val compare : t -> t -> int           val equal : t -> t -> bool           val subset : t -> t -> bool           val iter : (elt -> unit) -> t -> unit           val fold : (elt -> '-> 'a) -> t -> '-> 'a           val for_all : (elt -> bool) -> t -> bool           val exists : (elt -> bool) -> t -> bool           val filter : (elt -> bool) -> t -> t           val partition : (elt -> bool) -> t -> t * t           val cardinal : t -> int           val elements : t -> elt list           val min_elt : t -> elt           val max_elt : t -> elt           val choose : t -> elt           val split : elt -> t -> t * bool * t           val find : elt -> t -> elt           val of_list : elt list -> t         end       type set = B0.Hash.Set.t       module Map :         sig           type key = t           type +'a t           val empty : 'a t           val is_empty : 'a t -> bool           val mem : key -> 'a t -> bool           val add : key -> '-> 'a t -> 'a t           val singleton : key -> '-> 'a t           val remove : key -> 'a t -> 'a t           val merge :             (key -> 'a option -> 'b option -> 'c option) ->             'a t -> 'b t -> 'c t           val union : (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t           val compare : ('-> '-> int) -> 'a t -> 'a t -> int           val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool           val iter : (key -> '-> unit) -> 'a t -> unit           val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b           val for_all : (key -> '-> bool) -> 'a t -> bool           val exists : (key -> '-> bool) -> 'a t -> bool           val filter : (key -> '-> bool) -> 'a t -> 'a t           val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t           val cardinal : 'a t -> int           val bindings : 'a t -> (key * 'a) list           val min_binding : 'a t -> key * 'a           val max_binding : 'a t -> key * 'a           val choose : 'a t -> key * 'a           val split : key -> 'a t -> 'a t * 'a option * 'a t           val find : key -> 'a t -> 'a           val map : ('-> 'b) -> 'a t -> 'b t           val mapi : (key -> '-> 'b) -> 'a t -> 'b t         end       type 'a map = 'B0.Hash.Map.t     end   module Stamp :     sig       type t       val zero : t       val string : string -> t       val file : Fpath.t -> t       val raw_file : string -> t       val to_byte_string : t -> string       val to_hex : t -> string       val of_hex : string -> t option       val equal : t -> t -> bool       val compare : t -> t -> int       val pp : t Fmt.t       module Set :         sig           type elt = t           type t           val empty : t           val is_empty : t -> bool           val mem : elt -> t -> bool           val add : elt -> t -> t           val singleton : elt -> t           val remove : elt -> t -> t           val union : t -> t -> t           val inter : t -> t -> t           val diff : t -> t -> t           val compare : t -> t -> int           val equal : t -> t -> bool           val subset : t -> t -> bool           val iter : (elt -> unit) -> t -> unit           val fold : (elt -> '-> 'a) -> t -> '-> 'a           val for_all : (elt -> bool) -> t -> bool           val exists : (elt -> bool) -> t -> bool           val filter : (elt -> bool) -> t -> t           val partition : (elt -> bool) -> t -> t * t           val cardinal : t -> int           val elements : t -> elt list           val min_elt : t -> elt           val max_elt : t -> elt           val choose : t -> elt           val split : elt -> t -> t * bool * t           val find : elt -> t -> elt           val of_list : elt list -> t         end       type set = Set.t       module Map :         sig           type key = t           type +'a t           val empty : 'a t           val is_empty : 'a t -> bool           val mem : key -> 'a t -> bool           val add : key -> '-> 'a t -> 'a t           val singleton : key -> '-> 'a t           val remove : key -> 'a t -> 'a t           val merge :             (key -> 'a option -> 'b option -> 'c option) ->             'a t -> 'b t -> 'c t           val union : (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t           val compare : ('-> '-> int) -> 'a t -> 'a t -> int           val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool           val iter : (key -> '-> unit) -> 'a t -> unit           val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b           val for_all : (key -> '-> bool) -> 'a t -> bool           val exists : (key -> '-> bool) -> 'a t -> bool           val filter : (key -> '-> bool) -> 'a t -> 'a t           val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t           val cardinal : 'a t -> int           val bindings : 'a t -> (key * 'a) list           val min_binding : 'a t -> key * 'a           val max_binding : 'a t -> key * 'a           val choose : 'a t -> key * 'a           val split : key -> 'a t -> 'a t * 'a option * 'a t           val find : key -> 'a t -> 'a           val map : ('-> 'b) -> 'a t -> 'b t           val mapi : (key -> '-> 'b) -> 'a t -> 'b t         end       type 'a map = 'Map.t       val hash : t -> B0.Hash.t       val of_hash : B0.Hash.t -> t     end   type build   module Env :     sig       type build_aim = [ `Build_os | `Host_os ]       type tool_lookup = B0.Fpath.t list -> B0.Fpath.t B0.result       val pp_tool_alts : B0.Fpath.t list B0.Fmt.t       val env_tool_lookup :         ?sep:string -> ?var:string -> B0.OS.Env.t -> B0.Env.tool_lookup       type t       val v :         ?build_lookup:B0.Env.tool_lookup ->         ?build_forced_env:B0.OS.Env.t ->         ?build_env:B0.OS.Env.t ->         ?host_lookup:B0.Env.tool_lookup ->         ?host_forced_env:B0.OS.Env.t -> B0.OS.Env.t -> B0.Env.t       val env : B0.Env.t -> B0.Env.build_aim -> B0.OS.Env.t       val forced_env : B0.Env.t -> B0.Env.build_aim -> B0.OS.Env.t       val tool :         B0.Env.t ->         B0.Env.build_aim -> B0.Fpath.t list -> B0.Fpath.t B0.result     end   module Conf :     sig       type 'a key       type t       val empty : t       val is_empty : t -> bool       val mem : 'a key -> t -> bool       val add : 'a key -> '-> t -> t       val add_tag : bool key -> t -> t       val singleton : 'a key -> '-> t       val rem : 'a key -> t -> t       val find : 'a key -> t -> 'a option       val get : 'a key -> t -> 'a       val get_or_suggest : 'a key -> t -> ('a, string list) result       val flag : ?absent:bool -> bool key -> t -> bool       type binding = B : 'a key * '-> binding       val iter : (binding -> unit) -> t -> unit       val fold : (binding -> '-> 'a) -> t -> '-> 'a       val for_all : (binding -> bool) -> t -> bool       val exists : (binding -> bool) -> t -> bool       val filter : (binding -> bool) -> t -> t       val cardinal : t -> int       val any_binding : t -> binding option       val get_any_binding : t -> binding       val pp : t Fmt.t       type encode_error = string * [ `Msg of string ]       val encode : t -> (string * string) list * encode_error list       type decode_error = string * [ `Msg of string | `Unknown ]       val decode : (string * string) list -> t * decode_error list       val load : B0.Fpath.t -> (t * decode_error list) B0.result       val save : t -> B0.Fpath.t -> encode_error list B0.result       type 'a value       val const : '-> 'B0.Conf.value       val discover :         ?store:bool ->         (B0.Env.t -> B0.Env.build_aim -> 'a key -> t -> 'B0.result) ->         'B0.Conf.value       val value :         B0.Env.t ->         B0.Env.build_aim -> 'a key -> t -> 'B0.Conf.value -> 'B0.result       val value_const : 'B0.Conf.value -> 'a option       val value_store : 'B0.Conf.value -> bool       val pp_value : 'B0.Fmt.t -> 'B0.Conf.value B0.Fmt.t       module rec Group :         sig           type t           val v : ?loc:B0.Def.loc -> ?doc:string -> string -> B0.Conf.Group.t           val none : B0.Conf.Group.t           val keys : B0.Conf.Group.t -> B0.Conf.Key.t list           val value_kind : string           val name : t -> string           val loc : t -> Def.loc           val doc : t -> string           val equal : t -> t -> bool           val compare : t -> t -> int           val compare_by_name : t -> t -> int           val find : string -> t option           val get : string -> t           val get_or_suggest : string -> (t, string list) result           val list : unit -> t list           val pp_name_str : string Fmt.t           val pp_name : t Fmt.t           val pp_synopsis : t Fmt.t           val pp_info : t Fmt.t           val pp_info_ext : t Fmt.t -> t Fmt.t         end       and Key :         sig           type 'a typed = 'a key           type 'a info           type t = V : 'a typed -> t           val conv : 'a typed -> 'Conv.t           val info : 'a typed -> 'a info           val of_typed : 'a typed -> t           val value_kind : string           val name : t -> string           val loc : t -> Def.loc           val doc : t -> string           val equal : t -> t -> bool           val compare : t -> t -> int           val compare_by_name : t -> t -> int           val find : string -> t option           val get : string -> t           val get_or_suggest : string -> (t, string list) result           val list : unit -> t list           val pp_name_str : string Fmt.t           val pp_name : t Fmt.t           val pp_synopsis : t Fmt.t           val pp_info : t Fmt.t           val pp_info_ext : t Fmt.t -> t Fmt.t           val v :             ?loc:B0.Def.loc ->             ?doc:string ->             ?group:B0.Conf.Group.t ->             string -> 'B0.Conv.t -> default:'B0.Conf.value -> 'a typed           val default : 'a typed -> 'B0.Conf.value           val group : t -> B0.Conf.Group.t         end       val key :         ?loc:B0.Def.loc ->         ?doc:string ->         ?group:B0.Conf.Group.t ->         string -> 'B0.Conv.t -> default:'B0.Conf.value -> 'a key       val get_default :         B0.Env.t -> B0.Env.build_aim -> 'a key -> t -> 'B0.result       val get_effective :         B0.Env.t ->         B0.Env.build_aim ->         'a key -> t -> ([ `Conf | `Default | `Env ] * 'a) B0.result       val keys : t -> B0.Conf.Key.t list       module Preset :         sig           type conf = t           val const : '-> 'B0.Conf.value           val discover :             ?store:bool ->             (B0.Env.t -> B0.Env.build_aim -> 'a key -> t -> 'B0.result) ->             'B0.Conf.value           type def           val def :             ?doc:string -> 'a key -> 'B0.Conf.value -> B0.Conf.Preset.def           val def_key : B0.Conf.Preset.def -> B0.Conf.Key.t           val def_doc : B0.Conf.Preset.def -> string           type binding =               B : 'a key * 'B0.Conf.value -> B0.Conf.Preset.binding           val def_binding : B0.Conf.Preset.def -> B0.Conf.Preset.binding           type t           val v :             ?loc:B0.Def.loc ->             ?doc:string ->             string -> B0.Conf.Preset.def list -> B0.Conf.Preset.t           val value_kind : string           val name : t -> string           val loc : t -> Def.loc           val doc : t -> string           val equal : t -> t -> bool           val compare : t -> t -> int           val compare_by_name : t -> t -> int           val find : string -> t option           val get : string -> t           val get_or_suggest : string -> (t, string list) result           val list : unit -> t list           val pp_name_str : string Fmt.t           val pp_name : t Fmt.t           val pp_synopsis : t Fmt.t           val pp_info : t Fmt.t           val pp_info_ext : t Fmt.t -> t Fmt.t           val defs : B0.Conf.Preset.t -> B0.Conf.Preset.def list           val find_def :             string -> B0.Conf.Preset.t -> B0.Conf.Preset.def option           val get_or_suggest_def :             string ->             B0.Conf.Preset.t ->             (B0.Conf.Preset.def, string list) Pervasives.result           val keys : B0.Conf.Preset.t -> B0.Conf.Key.t list           type def_error = string * [ `Msg of string ]           val add :             B0.Env.t ->             B0.Env.build_aim ->             B0.Conf.Preset.t ->             B0.Conf.Preset.conf ->             B0.Conf.Preset.conf * B0.Conf.Preset.def_error list           val rem :             B0.Conf.Preset.t -> B0.Conf.Preset.conf -> B0.Conf.Preset.conf         end       val of_preset :         B0.Env.t ->         B0.Env.build_aim ->         B0.Conf.Preset.t -> t * B0.Conf.Preset.def_error list     end   module Pkg :     sig       module Meta :         sig           module Key :             sig               type 'a typed               type 'a info = unit               type t = V : 'a typed -> t               val v :                 ?loc:Def.loc ->                 ?doc:string -> string -> 'Conv.t -> 'a info -> 'a typed               val conv : 'a typed -> 'Conv.t               val info : 'a typed -> 'a info               val of_typed : 'a typed -> t               val value_kind : string               val name : t -> string               val loc : t -> Def.loc               val doc : t -> string               val equal : t -> t -> bool               val compare : t -> t -> int               val compare_by_name : t -> t -> int               val find : string -> t option               val get : string -> t               val get_or_suggest : string -> (t, string list) result               val list : unit -> t list               val pp_name_str : string Fmt.t               val pp_name : t Fmt.t               val pp_synopsis : t Fmt.t               val pp_info : t Fmt.t               val pp_info_ext : t Fmt.t -> t Fmt.t             end           type 'a key = 'Key.typed           type t           val empty : t           val is_empty : t -> bool           val mem : 'a key -> t -> bool           val add : 'a key -> '-> t -> t           val add_tag : bool key -> t -> t           val singleton : 'a key -> '-> t           val rem : 'a key -> t -> t           val find : 'a key -> t -> 'a option           val get : 'a key -> t -> 'a           val get_or_suggest : 'a key -> t -> ('a, string list) result           val flag : ?absent:bool -> bool key -> t -> bool           type binding = B : 'a key * '-> binding           val iter : (binding -> unit) -> t -> unit           val fold : (binding -> '-> 'a) -> t -> '-> 'a           val for_all : (binding -> bool) -> t -> bool           val exists : (binding -> bool) -> t -> bool           val filter : (binding -> bool) -> t -> t           val cardinal : t -> int           val any_binding : t -> binding option           val get_any_binding : t -> binding           val pp : t Fmt.t           type encode_error = string * [ `Msg of string ]           val encode : t -> (string * string) list * encode_error list           type decode_error = string * [ `Msg of string | `Unknown ]           val decode : (string * string) list -> t * decode_error list         end       type t       type id = int       val create :         ?loc:B0.Def.loc ->         ?doc:string -> ?meta:B0.Pkg.Meta.t -> string -> B0.Pkg.t       val value_kind : string       val name : t -> string       val loc : t -> Def.loc       val doc : t -> string       val equal : t -> t -> bool       val compare : t -> t -> int       val compare_by_name : t -> t -> int       val find : string -> t option       val get : string -> t       val get_or_suggest : string -> (t, string list) result       val list : unit -> t list       val pp_name_str : string Fmt.t       val pp_name : t Fmt.t       val pp_synopsis : t Fmt.t       val pp_info : t Fmt.t       val pp_info_ext : t Fmt.t -> t Fmt.t       val basename : B0.Pkg.t -> string       val id : B0.Pkg.t -> B0.Pkg.id       val meta : B0.Pkg.t -> B0.Pkg.Meta.t       val meta_mem : 'B0.Pkg.Meta.key -> B0.Pkg.t -> bool       val meta_find : 'B0.Pkg.Meta.key -> B0.Pkg.t -> 'a option       val meta_get : 'B0.Pkg.Meta.key -> B0.Pkg.t -> 'a       val has_tag : bool B0.Pkg.Meta.key -> B0.Pkg.t -> bool       module Idset :         sig           type t           val empty : t           val is_empty : t -> bool           val mem : id -> t -> bool           val add : id -> t -> t           val singleton : id -> t           val remove : id -> t -> t           val union : t -> t -> t           val inter : t -> t -> t           val diff : t -> t -> t           val compare : t -> t -> int           val equal : t -> t -> bool           val subset : t -> t -> bool           val iter : (id -> unit) -> t -> unit           val fold : (id -> '-> 'a) -> t -> '-> 'a           val for_all : (id -> bool) -> t -> bool           val exists : (id -> bool) -> t -> bool           val filter : (id -> bool) -> t -> t           val partition : (id -> bool) -> t -> t * t           val cardinal : t -> int           val elements : t -> id list           val min_elt : t -> id           val max_elt : t -> id           val choose : t -> id           val split : id -> t -> t * bool * t           val find : id -> t -> id           val of_list : id list -> t           val pp :             ?sep:unit B0.Fmt.t -> B0.Pkg.id B0.Fmt.t -> B0.Pkg.t B0.Fmt.t         end       module Idmap :         sig           type +'a t           val empty : 'a t           val is_empty : 'a t -> bool           val mem : id -> 'a t -> bool           val add : id -> '-> 'a t -> 'a t           val singleton : id -> '-> 'a t           val remove : id -> 'a t -> 'a t           val merge :             (id -> 'a option -> 'b option -> 'c option) ->             'a t -> 'b t -> 'c t           val union : (id -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t           val compare : ('-> '-> int) -> 'a t -> 'a t -> int           val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool           val iter : (id -> '-> unit) -> 'a t -> unit           val fold : (id -> '-> '-> 'b) -> 'a t -> '-> 'b           val for_all : (id -> '-> bool) -> 'a t -> bool           val exists : (id -> '-> bool) -> 'a t -> bool           val filter : (id -> '-> bool) -> 'a t -> 'a t           val partition : (id -> '-> bool) -> 'a t -> 'a t * 'a t           val cardinal : 'a t -> int           val bindings : 'a t -> (id * 'a) list           val min_binding : 'a t -> id * 'a           val max_binding : 'a t -> id * 'a           val choose : 'a t -> id * 'a           val split : id -> 'a t -> 'a t * 'a option * 'a t           val find : id -> 'a t -> 'a           val map : ('-> 'b) -> 'a t -> 'b t           val mapi : (id -> '-> 'b) -> 'a t -> 'b t           val pp :             ?sep:unit B0.Fmt.t ->             (B0.Pkg.id * 'a) B0.Fmt.t -> 'B0.Pkg.t B0.Fmt.t         end       type set       module Set :         sig           val empty : set           val is_empty : set -> bool           val mem : t -> set -> bool           val add : t -> set -> set           val singleton : t -> set           val remove : t -> set -> set           val union : set -> set -> set           val inter : set -> set -> set           val diff : set -> set -> set           val compare : set -> set -> int           val equal : set -> set -> bool           val subset : set -> set -> bool           val iter : (t -> unit) -> set -> unit           val fold : (t -> '-> 'a) -> set -> '-> 'a           val for_all : (t -> bool) -> set -> bool           val exists : (t -> bool) -> set -> bool           val filter : (t -> bool) -> set -> set           val partition : (t -> bool) -> set -> set * set           val cardinal : set -> int           val elements : set -> t list           val min_elt : set -> t           val max_elt : set -> t           val choose : set -> t           val split : t -> set -> set * bool * set           val find : t -> set -> t           val of_list : t list -> set           val pp :             ?sep:unit B0.Fmt.t -> B0.Pkg.t B0.Fmt.t -> B0.Pkg.set B0.Fmt.t           type t = B0.Pkg.set         end       type +'a map       module Map :         sig           val empty : 'a map           val is_empty : 'a map -> bool           val mem : t -> 'a map -> bool           val add : t -> '-> 'a map -> 'a map           val singleton : t -> '-> 'a map           val remove : t -> 'a map -> 'a map           val merge :             (t -> 'a option -> 'b option -> 'c option) ->             'a map -> 'b map -> 'c map           val union :             (t -> '-> '-> 'a option) -> 'a map -> 'a map -> 'a map           val compare : ('-> '-> int) -> 'a map -> 'a map -> int           val equal : ('-> '-> bool) -> 'a map -> 'a map -> bool           val iter : (t -> '-> unit) -> 'a map -> unit           val fold : (t -> '-> '-> 'b) -> 'a map -> '-> 'b           val for_all : (t -> '-> bool) -> 'a map -> bool           val exists : (t -> '-> bool) -> 'a map -> bool           val filter : (t -> '-> bool) -> 'a map -> 'a map           val partition : (t -> '-> bool) -> 'a map -> 'a map * 'a map           val cardinal : 'a map -> int           val bindings : 'a map -> (t * 'a) list           val min_binding : 'a map -> t * 'a           val max_binding : 'a map -> t * 'a           val choose : 'a map -> t * 'a           val split : t -> 'a map -> 'a map * 'a option * 'a map           val find : t -> 'a map -> 'a           val map : ('-> 'b) -> 'a map -> 'b map           val mapi : (t -> '-> 'b) -> 'a map -> 'b map           val of_list : (B0.Pkg.t * 'a) list -> 'B0.Pkg.map           val pp :             ?sep:unit B0.Fmt.t ->             (B0.Pkg.t * 'a) B0.Fmt.t -> 'B0.Pkg.map B0.Fmt.t           type 'a t = 'B0.Pkg.map           val dom : 'B0.Pkg.map -> B0.Pkg.set         end     end   module Unit :     sig       module Meta :         sig           module Key :             sig               type 'a typed               type 'a info = unit               type t = V : 'a typed -> t               val v :                 ?loc:Def.loc ->                 ?doc:string -> string -> 'Conv.t -> 'a info -> 'a typed               val conv : 'a typed -> 'Conv.t               val info : 'a typed -> 'a info               val of_typed : 'a typed -> t               val value_kind : string               val name : t -> string               val loc : t -> Def.loc               val doc : t -> string               val equal : t -> t -> bool               val compare : t -> t -> int               val compare_by_name : t -> t -> int               val find : string -> t option               val get : string -> t               val get_or_suggest : string -> (t, string list) result               val list : unit -> t list               val pp_name_str : string Fmt.t               val pp_name : t Fmt.t               val pp_synopsis : t Fmt.t               val pp_info : t Fmt.t               val pp_info_ext : t Fmt.t -> t Fmt.t             end           type 'a key = 'Key.typed           type t           val empty : t           val is_empty : t -> bool           val mem : 'a key -> t -> bool           val add : 'a key -> '-> t -> t           val add_tag : bool key -> t -> t           val singleton : 'a key -> '-> t           val rem : 'a key -> t -> t           val find : 'a key -> t -> 'a option           val get : 'a key -> t -> 'a           val get_or_suggest : 'a key -> t -> ('a, string list) result           val flag : ?absent:bool -> bool key -> t -> bool           type binding = B : 'a key * '-> binding           val iter : (binding -> unit) -> t -> unit           val fold : (binding -> '-> 'a) -> t -> '-> 'a           val for_all : (binding -> bool) -> t -> bool           val exists : (binding -> bool) -> t -> bool           val filter : (binding -> bool) -> t -> t           val cardinal : t -> int           val any_binding : t -> binding option           val get_any_binding : t -> binding           val pp : t Fmt.t           type encode_error = string * [ `Msg of string ]           val encode : t -> (string * string) list * encode_error list           type decode_error = string * [ `Msg of string | `Unknown ]           val decode : (string * string) list -> t * decode_error list         end       type t       type id = int       val create :         ?loc:B0.Def.loc ->         ?src_root:B0.Fpath.t ->         ?doc:string ->         ?doc_outcome:string ->         ?only_aim:B0.Env.build_aim ->         ?pkg:B0.Pkg.t ->         ?meta:B0.Unit.Meta.t -> string -> (B0.build -> unit) -> B0.Unit.t       val value_kind : string       val name : t -> string       val loc : t -> Def.loc       val doc : t -> string       val equal : t -> t -> bool       val compare : t -> t -> int       val compare_by_name : t -> t -> int       val find : string -> t option       val get : string -> t       val get_or_suggest : string -> (t, string list) result       val list : unit -> t list       val pp_name_str : string Fmt.t       val pp_name : t Fmt.t       val pp_synopsis : t Fmt.t       val pp_info : t Fmt.t       val pp_info_ext : t Fmt.t -> t Fmt.t       val func : B0.Unit.t -> B0.build -> unit       val src_root : B0.Unit.t -> B0.Fpath.t       val basename : B0.Unit.t -> string       val doc_outcome : B0.Unit.t -> string       val id : B0.Unit.t -> B0.Unit.id       val pkg : B0.Unit.t -> B0.Pkg.t option       val meta : B0.Unit.t -> B0.Unit.Meta.t       val meta_mem : 'B0.Unit.Meta.key -> B0.Unit.t -> bool       val meta_add : 'B0.Unit.Meta.key -> '-> B0.Unit.t -> unit       val meta_find : 'B0.Unit.Meta.key -> B0.Unit.t -> 'a option       val meta_get : 'B0.Unit.Meta.key -> B0.Unit.t -> 'a       val has_tag : bool B0.Unit.Meta.key -> B0.Unit.t -> bool       module Idset :         sig           type t           val empty : t           val is_empty : t -> bool           val mem : id -> t -> bool           val add : id -> t -> t           val singleton : id -> t           val remove : id -> t -> t           val union : t -> t -> t           val inter : t -> t -> t           val diff : t -> t -> t           val compare : t -> t -> int           val equal : t -> t -> bool           val subset : t -> t -> bool           val iter : (id -> unit) -> t -> unit           val fold : (id -> '-> 'a) -> t -> '-> 'a           val for_all : (id -> bool) -> t -> bool           val exists : (id -> bool) -> t -> bool           val filter : (id -> bool) -> t -> t           val partition : (id -> bool) -> t -> t * t           val cardinal : t -> int           val elements : t -> id list           val min_elt : t -> id           val max_elt : t -> id           val choose : t -> id           val split : id -> t -> t * bool * t           val find : id -> t -> id           val of_list : id list -> t           val pp :             ?sep:unit B0.Fmt.t -> B0.Unit.id B0.Fmt.t -> B0.Unit.t B0.Fmt.t         end       module Idmap :         sig           type +'a t           val empty : 'a t           val is_empty : 'a t -> bool           val mem : id -> 'a t -> bool           val add : id -> '-> 'a t -> 'a t           val singleton : id -> '-> 'a t           val remove : id -> 'a t -> 'a t           val merge :             (id -> 'a option -> 'b option -> 'c option) ->             'a t -> 'b t -> 'c t           val union : (id -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t           val compare : ('-> '-> int) -> 'a t -> 'a t -> int           val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool           val iter : (id -> '-> unit) -> 'a t -> unit           val fold : (id -> '-> '-> 'b) -> 'a t -> '-> 'b           val for_all : (id -> '-> bool) -> 'a t -> bool           val exists : (id -> '-> bool) -> 'a t -> bool           val filter : (id -> '-> bool) -> 'a t -> 'a t           val partition : (id -> '-> bool) -> 'a t -> 'a t * 'a t           val cardinal : 'a t -> int           val bindings : 'a t -> (id * 'a) list           val min_binding : 'a t -> id * 'a           val max_binding : 'a t -> id * 'a           val choose : 'a t -> id * 'a           val split : id -> 'a t -> 'a t * 'a option * 'a t           val find : id -> 'a t -> 'a           val map : ('-> 'b) -> 'a t -> 'b t           val mapi : (id -> '-> 'b) -> 'a t -> 'b t           val pp :             ?sep:unit B0.Fmt.t ->             (B0.Unit.id * 'a) B0.Fmt.t -> 'B0.Unit.t B0.Fmt.t         end       type set       module Set :         sig           val empty : set           val is_empty : set -> bool           val mem : t -> set -> bool           val add : t -> set -> set           val singleton : t -> set           val remove : t -> set -> set           val union : set -> set -> set           val inter : set -> set -> set           val diff : set -> set -> set           val compare : set -> set -> int           val equal : set -> set -> bool           val subset : set -> set -> bool           val iter : (t -> unit) -> set -> unit           val fold : (t -> '-> 'a) -> set -> '-> 'a           val for_all : (t -> bool) -> set -> bool           val exists : (t -> bool) -> set -> bool           val filter : (t -> bool) -> set -> set           val partition : (t -> bool) -> set -> set * set           val cardinal : set -> int           val elements : set -> t list           val min_elt : set -> t           val max_elt : set -> t           val choose : set -> t           val split : t -> set -> set * bool * set           val find : t -> set -> t           val of_list : t list -> set           val pp :             ?sep:unit B0.Fmt.t -> B0.Unit.t B0.Fmt.t -> B0.Unit.set B0.Fmt.t           type t = B0.Unit.set         end       type +'a map       module Map :         sig           val empty : 'a map           val is_empty : 'a map -> bool           val mem : t -> 'a map -> bool           val add : t -> '-> 'a map -> 'a map           val singleton : t -> '-> 'a map           val remove : t -> 'a map -> 'a map           val merge :             (t -> 'a option -> 'b option -> 'c option) ->             'a map -> 'b map -> 'c map           val union :             (t -> '-> '-> 'a option) -> 'a map -> 'a map -> 'a map           val compare : ('-> '-> int) -> 'a map -> 'a map -> int           val equal : ('-> '-> bool) -> 'a map -> 'a map -> bool           val iter : (t -> '-> unit) -> 'a map -> unit           val fold : (t -> '-> '-> 'b) -> 'a map -> '-> 'b           val for_all : (t -> '-> bool) -> 'a map -> bool           val exists : (t -> '-> bool) -> 'a map -> bool           val filter : (t -> '-> bool) -> 'a map -> 'a map           val partition : (t -> '-> bool) -> 'a map -> 'a map * 'a map           val cardinal : 'a map -> int           val bindings : 'a map -> (t * 'a) list           val min_binding : 'a map -> t * 'a           val max_binding : 'a map -> t * 'a           val choose : 'a map -> t * 'a           val split : t -> 'a map -> 'a map * 'a option * 'a map           val find : t -> 'a map -> 'a           val map : ('-> 'b) -> 'a map -> 'b map           val mapi : (t -> '-> 'b) -> 'a map -> 'b map           val of_list : (B0.Unit.t * 'a) list -> 'B0.Unit.map           val pp :             ?sep:unit B0.Fmt.t ->             (B0.Unit.t * 'a) B0.Fmt.t -> 'B0.Unit.map B0.Fmt.t           type 'a t = 'B0.Unit.map           val dom : 'B0.Unit.map -> B0.Unit.set         end     end   module Tool :     sig       type env_vars = string list       val tmp_vars : B0.Tool.env_vars       type t       val v :         ?internal:B0.Tool.env_vars ->         ?env_vars:B0.Tool.env_vars -> string -> B0.Tool.t       val of_file :         ?internal:B0.Tool.env_vars ->         ?env_vars:B0.Tool.env_vars -> B0.Fpath.t -> B0.Tool.t       val of_unit_file :         B0.Unit.t ->         ?internal:B0.Tool.env_vars ->         ?env_vars:B0.Tool.env_vars -> B0.Fpath.t -> B0.Tool.t       val key :         ?loc:B0.Def.loc ->         ?doc:string ->         ?group:B0.Conf.Group.t ->         ?internal:B0.Tool.env_vars ->         ?env_vars:B0.Tool.env_vars ->         ?tools:B0.Fpath.t list -> string -> B0.Tool.t B0.Conf.key     end   module Outcome :     sig       type t       val read : B0.Fpath.t -> B0.Outcome.t B0.result       val write : B0.Fpath.t -> B0.Outcome.t -> unit B0.result       val fpath_meta : B0.Outcome.t -> B0.Fpath.Meta_map.t       val conf : B0.Outcome.t -> B0.Conf.t       val unit_names : B0.Outcome.t -> string list       val unit_id_name_map : B0.Outcome.t -> string B0.Unit.Idmap.t       val unit_id_set : string list -> B0.Outcome.t -> B0.Unit.Idset.t       val root_files : B0.Outcome.t -> B0.Fpath.set       val built_files : B0.Outcome.t -> B0.Fpath.set       module Op :         sig           type id = int           type t           val id : B0.Outcome.Op.t -> B0.Outcome.Op.id           val unit_id : B0.Outcome.Op.t -> B0.Unit.id           val aim : B0.Outcome.Op.t -> B0.Env.build_aim           val reads : B0.Outcome.Op.t -> B0.Fpath.set           val writes : B0.Outcome.Op.t -> B0.Fpath.set           val creation_time : B0.Outcome.Op.t -> B0.Time.span           val exec_start_time : B0.Outcome.Op.t -> B0.Time.span           val exec_end_time : B0.Outcome.Op.t -> B0.Time.span           val cached : B0.Outcome.Op.t -> bool           type status = Guarded | Ready | Executed | Finished           val status : B0.Outcome.Op.t -> B0.Outcome.Op.status           val pp_status : B0.Outcome.Op.status B0.Fmt.t           val stamp : B0.Outcome.Op.t -> B0.Stamp.t           type spawn_pid = int           type spawn_stdo =               [ `File of B0.Fpath.t | `Tee of B0.Fpath.t | `Ui ]           type spawn_stdo_ui =               [ `None | `Stdo of string B0.result | `Tmp_file of B0.Fpath.t ]           type spawn_env = string array           type spawn_success_codes = int list option           type spawn           val spawn_cmd : B0.Outcome.Op.spawn -> B0.Cmd.t           val spawn_env : B0.Outcome.Op.spawn -> B0.Outcome.Op.spawn_env           val spawn_cwd : B0.Outcome.Op.spawn -> B0.Fpath.t           val spawn_stdin : B0.Outcome.Op.spawn -> B0.Fpath.t option           val spawn_stdout : B0.Outcome.Op.spawn -> B0.Outcome.Op.spawn_stdo           val spawn_stderr : B0.Outcome.Op.spawn -> B0.Outcome.Op.spawn_stdo           val spawn_success_codes : B0.Outcome.Op.spawn -> int list option           val spawn_stdo_ui :             B0.Outcome.Op.spawn -> B0.Outcome.Op.spawn_stdo_ui           val set_spawn_stdo_ui :             B0.Outcome.Op.spawn -> B0.Outcome.Op.spawn_stdo_ui -> unit           val spawn_result :             B0.Outcome.Op.spawn ->             (B0.Outcome.Op.spawn_pid * B0.OS.Cmd.status) B0.result           type read           val read_file : B0.Outcome.Op.read -> B0.Fpath.t           val read_result : B0.Outcome.Op.read -> string B0.result           type write           val write :             B0.Unit.t ->             B0.Env.build_aim ->             B0.Time.span ->             reads:B0.Fpath.set -> B0.Fpath.t -> B0.Outcome.Op.t           val write_file : B0.Outcome.Op.write -> B0.Fpath.t           val write_data : B0.Outcome.Op.write -> string           val set_write_data : B0.Outcome.Op.write -> string -> unit           val write_result : B0.Outcome.Op.write -> unit B0.result           type copy_file           val copy_file_src : B0.Outcome.Op.copy_file -> B0.Fpath.t           val copy_file_dst : B0.Outcome.Op.copy_file -> B0.Fpath.t           val copy_file_linenum : B0.Outcome.Op.copy_file -> int option           val copy_file_result : B0.Outcome.Op.copy_file -> unit B0.result           type delete           val delete_file : B0.Outcome.Op.delete -> B0.Fpath.t           val delete_result : B0.Outcome.Op.delete -> unit B0.result           type mkdir           val mkdir_dir : B0.Outcome.Op.mkdir -> B0.Fpath.t           val mkdir_result : B0.Outcome.Op.mkdir -> unit B0.result           type sync           val sync_units : B0.Outcome.Op.sync -> B0.Unit.Idset.t           type kind =               Spawn of B0.Outcome.Op.spawn             | Read of B0.Outcome.Op.read             | Write of B0.Outcome.Op.write             | Copy_file of B0.Outcome.Op.copy_file             | Delete of B0.Outcome.Op.delete             | Mkdir of B0.Outcome.Op.mkdir             | Sync of B0.Outcome.Op.sync           val kind : B0.Outcome.Op.t -> B0.Outcome.Op.kind           val cycle :             B0.Outcome.Op.t ->             B0.Outcome.Op.t -> (B0.Fpath.t * B0.Fpath.t) option           val equal : B0.Outcome.Op.t -> B0.Outcome.Op.t -> bool           val compare : B0.Outcome.Op.t -> B0.Outcome.Op.t -> int           val compare_exec_start_time :             B0.Outcome.Op.t -> B0.Outcome.Op.t -> int           val pp : B0.Outcome.Op.t B0.Fmt.t           val dump : B0.Outcome.Op.t B0.Fmt.t           val pp_spawn_fail : B0.Outcome.Op.t B0.Fmt.t           val pp_log_line : B0.Outcome.Op.t B0.Fmt.t           val pp_long : B0.Outcome.Op.t B0.Fmt.t           type set           module Set :             sig               type t = set               val empty : t               val is_empty : t -> bool               val mem : t -> t -> bool               val add : t -> t -> t               val singleton : t -> t               val remove : t -> t -> t               val union : t -> t -> t               val inter : t -> t -> t               val diff : t -> t -> t               val compare : t -> t -> int               val equal : t -> t -> bool               val subset : t -> t -> bool               val iter : (t -> unit) -> t -> unit               val fold : (t -> '-> 'a) -> t -> '-> 'a               val for_all : (t -> bool) -> t -> bool               val exists : (t -> bool) -> t -> bool               val filter : (t -> bool) -> t -> t               val partition : (t -> bool) -> t -> t * t               val cardinal : t -> int               val elements : t -> t list               val min_elt : t -> t               val max_elt : t -> t               val choose : t -> t               val split : t -> t -> t * bool * t               val find : t -> t -> t               val of_list : t list -> t             end           type +'a map           module Map :             sig               val empty : 'a map               val is_empty : 'a map -> bool               val mem : t -> 'a map -> bool               val add : t -> '-> 'a map -> 'a map               val singleton : t -> '-> 'a map               val remove : t -> 'a map -> 'a map               val merge :                 (t -> 'a option -> 'b option -> 'c option) ->                 'a map -> 'b map -> 'c map               val union :                 (t -> '-> '-> 'a option) -> 'a map -> 'a map -> 'a map               val compare : ('-> '-> int) -> 'a map -> 'a map -> int               val equal : ('-> '-> bool) -> 'a map -> 'a map -> bool               val iter : (t -> '-> unit) -> 'a map -> unit               val fold : (t -> '-> '-> 'b) -> 'a map -> '-> 'b               val for_all : (t -> '-> bool) -> 'a map -> bool               val exists : (t -> '-> bool) -> 'a map -> bool               val filter : (t -> '-> bool) -> 'a map -> 'a map               val partition : (t -> '-> bool) -> 'a map -> 'a map * 'a map               val cardinal : 'a map -> int               val bindings : 'a map -> (t * 'a) list               val min_binding : 'a map -> t * 'a               val max_binding : 'a map -> t * 'a               val choose : 'a map -> t * 'a               val split : t -> 'a map -> 'a map * 'a option * 'a map               val find : t -> 'a map -> 'a               val map : ('-> 'b) -> 'a map -> 'b map               val mapi : (t -> '-> 'b) -> 'a map -> 'b map               val dom : 'B0.Outcome.Op.map -> B0.Outcome.Op.set               val of_list :                 (B0.Outcome.Op.t * 'a) list -> 'B0.Outcome.Op.map               type 'a t = 'B0.Outcome.Op.map             end         end       val ops : B0.Outcome.t -> B0.Outcome.Op.t list       val ops_to_json : B0.Outcome.t -> B0.Outcome.Op.t list -> string       val pp_stats : B0.Outcome.t B0.Fmt.t     end   module Cache :     sig       type key = B0.Hash.t       val key_of_string : string -> B0.Cache.key B0.result       val key_to_string : B0.Cache.key -> string       val pp_key : B0.Cache.key B0.Fmt.t       type elt       val elt :         variant:string ->         age:int ->         op:B0.Cmd.t ->         key:B0.Hash.t -> B0.Fpath.t -> file_stamp:B0.Stamp.t -> B0.Cache.elt       val elt_variant : B0.Cache.elt -> string       val elt_age : B0.Cache.elt -> int       val elt_op : B0.Cache.elt -> B0.Cmd.t       val elt_key : B0.Cache.elt -> B0.Cache.key       val elt_file_path : B0.Cache.elt -> B0.Fpath.t       val elt_file_stamp : B0.Cache.elt -> B0.Stamp.t       type t       val empty : index_file:B0.Fpath.t -> dir:B0.Fpath.t -> B0.Cache.t       val is_empty : B0.Cache.t -> bool       val dir : B0.Cache.t -> B0.Fpath.t       val index_file : B0.Cache.t -> B0.Fpath.t       val exists : index_file:B0.Fpath.t -> bool B0.result       val load :         index_file:B0.Fpath.t -> dir:B0.Fpath.t -> B0.Cache.t B0.result       val save : B0.Cache.t -> unit B0.result       val mem : B0.Cache.t -> B0.Cache.key -> bool       val add : B0.Cache.t -> B0.Cache.elt -> unit B0.result       val rem : B0.Cache.t -> B0.Cache.key -> unit B0.result       val find : B0.Cache.t -> B0.Cache.key -> B0.Cache.elt option       val use : B0.Cache.t -> B0.Cache.key -> bool B0.result       val verify :         repair:bool ->         B0.Cache.t ->         B0.Cache.key ->         [ `Miss_file | `Miss_index | `Ok | `Stamp_mismatch | `Unknown ]         B0.result       val foreign :         ignore_keys:bool ->         B0.Cache.t -> ([ `Key | `Other ] * B0.Fpath.t) list B0.result       val fold : (B0.Cache.elt -> '-> 'a) -> B0.Cache.t -> '-> 'a       val iter : (B0.Cache.elt -> unit) -> B0.Cache.t -> unit       val path_map : B0.Cache.t -> B0.Cache.elt B0.Fpath.Map.t     end   module Build :     sig       type t = B0.build       type run       type 'a fiber = ('-> unit) -> unit       val build_dir : B0.build -> B0.Fpath.t       val build_file : B0.build -> string -> B0.Fpath.t       val src_dir : B0.build -> B0.Fpath.t       val unit_build_dir : B0.build -> B0.Unit.t -> B0.Fpath.t       val conf : B0.build -> 'B0.Conf.key -> 'a       val tool : B0.build -> B0.Tool.t -> B0.Cmd.t -> B0.Build.run       val conf_tool :         B0.build -> B0.Tool.t B0.Conf.key -> B0.Cmd.t -> B0.Build.run       val ready : B0.build -> B0.Fpath.t -> unit       val src : B0.build -> B0.Fpath.t -> B0.Fpath.t       type stdo = [ `File of B0.Fpath.t | `Tee of B0.Fpath.t | `Ui ]       val spawn :         B0.build ->         ?reads:B0.Fpath.t list ->         ?writes:B0.Fpath.t list ->         ?success:int list ->         ?env:B0.OS.Env.t ->         ?cwd:B0.Fpath.t ->         ?stdin:B0.Fpath.t ->         ?stdout:B0.Build.stdo ->         ?stderr:B0.Build.stdo -> B0.Build.run -> unit       val read : B0.build -> B0.Fpath.t -> string B0.Build.fiber       val write :         B0.build ->         ?reads:B0.Fpath.t list -> B0.Fpath.t -> (unit -> string) -> unit       val copy_file :         ?linenum:int -> B0.build -> B0.Fpath.t -> B0.Fpath.t -> unit       val mkdir : B0.build -> B0.Fpath.t -> unit B0.Build.fiber       val await_units : B0.build -> B0.Unit.t list -> unit B0.Build.fiber       val fail :         ((('a, Format.formatter, unit, unit) Pervasives.format4 -> 'a) ->          unit) ->         'b       val fail_on_error_msg : 'B0.result -> 'a       val find_path_meta :         B0.build -> B0.Fpath.t -> 'B0.Fpath.Meta.key -> 'a option       val add_path_meta :         ?force:bool ->         B0.build -> B0.Fpath.t -> 'B0.Fpath.Meta.key -> '-> unit       val unit : B0.build -> B0.Unit.t       val units : B0.build -> B0.Unit.t list       type ctrl       val ctrl :         ?tty_cap:B0.Tty.cap -> ?max_spawn:int -> unit -> B0.Build.ctrl       val create :         ?prev_outcome:B0.Outcome.t ->         B0.Cache.t ->         B0.Build.ctrl ->         B0.Env.t ->         B0.Conf.t ->         B0.Fpath.Meta_map.t ->         dir:B0.Fpath.t ->         universe:B0.Unit.t list -> B0.Unit.t list -> B0.build B0.result       val dir : B0.build -> B0.Fpath.t       val cache : B0.build -> B0.Cache.t       val stored_conf : B0.build -> B0.Conf.t       val outcome : B0.build -> B0.Outcome.t       val start : B0.build -> unit       val finish : B0.build -> unit B0.result     end   module Variant :     sig       module Scheme :         sig           type t           type trigger = [ `After | `Before ]           type direct           val direct :             ?preset:B0.Conf.Preset.t ->             ?setup:(B0.Conf.t -> unit B0.result) ->             ?delete:(B0.Conf.t -> unit B0.result) ->             ?env:(unit -> B0.Env.t B0.result) ->             ?build:(B0.Variant.Scheme.trigger -> B0.Build.t -> unit B0.result) ->             ?stage:(B0.Variant.Scheme.trigger ->                     B0.Outcome.t -> unit B0.result) ->             unit -> B0.Variant.Scheme.direct           val direct_preset :             B0.Variant.Scheme.direct -> B0.Conf.Preset.t option           val direct_env :             B0.Variant.Scheme.direct -> unit -> B0.Env.t B0.result           type proxy_conf           val proxy_conf :             root_dir:B0.Fpath.t ->             b0_dir:B0.Fpath.t ->             variant_dir:B0.Fpath.t -> unit -> B0.Variant.Scheme.proxy_conf           val proxy_conf_root_dir :             B0.Variant.Scheme.proxy_conf -> B0.Fpath.t           val proxy_conf_b0_dir : B0.Variant.Scheme.proxy_conf -> B0.Fpath.t           val proxy_conf_variant_dir :             B0.Variant.Scheme.proxy_conf -> B0.Fpath.t           type proxy           val proxy :             ?create:(B0.Variant.Scheme.proxy_conf -> unit B0.result) ->             ?setup:(B0.Variant.Scheme.proxy_conf -> unit B0.result) ->             ?delete:(B0.Variant.Scheme.proxy_conf -> unit B0.result) ->             run:(B0.Variant.Scheme.proxy_conf ->                  B0.Cmd.t -> B0.OS.Cmd.status B0.result) ->             B0.Variant.Scheme.t -> B0.Variant.Scheme.proxy           val proxy_run :             B0.Variant.Scheme.proxy ->             B0.Variant.Scheme.proxy_conf ->             B0.Cmd.t -> B0.OS.Cmd.status B0.result           val proxy_create :             B0.Variant.Scheme.proxy ->             B0.Variant.Scheme.proxy_conf -> unit B0.result           val proxy_delete :             B0.Variant.Scheme.proxy ->             B0.Variant.Scheme.proxy_conf -> unit B0.result           val proxy_setup :             B0.Variant.Scheme.proxy ->             B0.Variant.Scheme.proxy_conf -> unit B0.result           type kind =               [ `Direct of B0.Variant.Scheme.direct               | `Proxy of B0.Variant.Scheme.proxy ]           val v :             ?loc:B0.Def.loc ->             ?doc:string ->             string -> B0.Variant.Scheme.kind -> B0.Variant.Scheme.t           val kind : B0.Variant.Scheme.t -> B0.Variant.Scheme.kind           val nop : B0.Variant.Scheme.t           val with_preset :             ?loc:B0.Def.loc ->             ?doc:string ->             B0.Variant.Scheme.t ->             B0.Conf.Preset.t option -> string -> B0.Variant.Scheme.t           val wrap :             B0.Variant.Scheme.t ->             B0.Variant.Scheme.t -> string -> B0.Variant.Scheme.t           val value_kind : string           val name : t -> string           val loc : t -> Def.loc           val doc : t -> string           val equal : t -> t -> bool           val compare : t -> t -> int           val compare_by_name : t -> t -> int           val find : string -> t option           val get : string -> t           val get_or_suggest : string -> (t, string list) result           val list : unit -> t list           val pp_name_str : string Fmt.t           val pp_name : t Fmt.t           val pp_synopsis : t Fmt.t           val pp_info : t Fmt.t           val pp_info_ext : t Fmt.t -> t Fmt.t         end       type t       val create :         ?preset:bool ->         dir:B0.Fpath.t ->         string ->         B0.Variant.Scheme.t ->         (B0.Variant.t * B0.Conf.Preset.def_error list) B0.result       val reset : B0.Variant.t -> unit B0.result       val delete :         ?force:bool ->         B0.Variant.t ->         (unit, [ `Msg of string | `Scheme of B0.R.msg ]) Pervasives.result       val scheme : B0.Variant.t -> B0.Variant.Scheme.t       val conf_path : B0.Variant.t -> B0.Fpath.t       val outcome_path : B0.Variant.t -> B0.Fpath.t       val build_path : B0.Variant.t -> B0.Fpath.t       val cache_index_path : B0.Variant.t -> B0.Fpath.t       val value_kind : string       val name : B0.Variant.t -> string       val path : B0.Variant.t -> B0.Fpath.t       val equal : B0.Variant.t -> B0.Variant.t -> bool       val compare : B0.Variant.t -> B0.Variant.t -> int       val compare_by_name : B0.Variant.t -> B0.Variant.t -> int       type unknown_scheme = [ `Unknown_scheme of string * B0.Variant.t ]       val of_unknown_scheme : B0.Variant.unknown_scheme -> B0.Variant.t       val pp_unknown_scheme : B0.Variant.unknown_scheme B0.Fmt.t       type load =           (B0.Variant.t, [ `Unknown_scheme of string * B0.Variant.t ])           Pervasives.result       val of_load : B0.Variant.load -> B0.Variant.t       val exists : dir:B0.Fpath.t -> string -> bool B0.result       val find : dir:B0.Fpath.t -> string -> B0.Variant.load option B0.result       val get : dir:B0.Fpath.t -> string -> B0.Variant.load B0.result       val get_or_suggest :         dir:B0.Fpath.t ->         string -> (B0.Variant.load, string list) Pervasives.result B0.result       val list : dir:B0.Fpath.t -> B0.Variant.load list B0.result       val list_empty : dir:B0.Fpath.t -> bool B0.result       val pp_name_str : string B0.Fmt.t       val pp_name : B0.Variant.t B0.Fmt.t       val pp_synopsis : B0.Variant.t B0.Fmt.t       val pp_info : B0.Variant.t B0.Fmt.t       val pp_info_ext : B0.Variant.t B0.Fmt.t -> B0.Variant.t B0.Fmt.t     end   module Sexp :     sig       type pos = int       type range = B0.Sexp.pos * B0.Sexp.pos       type src = File of B0.Fpath.t       type loc = B0.Sexp.src * B0.Sexp.range       val pp_loc : B0.Sexp.loc B0.Fmt.t       type t = [ `Atom of string | `List of B0.Sexp.t list ] * B0.Sexp.loc       val get_atom : B0.Sexp.t -> string       val get_list : B0.Sexp.t -> B0.Sexp.t list       val of_string : src:B0.Sexp.src -> string -> B0.Sexp.t B0.result       val of_file : B0.Fpath.t -> B0.Sexp.t B0.result       val dump_locs : B0.Sexp.t B0.Fmt.t       type map = (B0.Sexp.t * B0.Sexp.loc) B0.String.Map.t * B0.Sexp.loc       type 'a key = B0.Sexp.map -> 'a       val to_string_map :         ?known:(string -> bool) ->         B0.Sexp.t -> (B0.Sexp.map * B0.Sexp.map) B0.result       val key :         ?absent:'-> (string -> B0.Sexp.t -> 'a) -> string -> 'B0.Sexp.key       val atom_key : ?absent:'-> (string -> 'a) -> string -> 'B0.Sexp.key       val list_key :         ?empty:bool ->         ?absent:'a list ->         (string -> B0.Sexp.t -> 'a) -> string -> 'a list B0.Sexp.key       val atom_list_key :         ?empty:bool ->         ?absent:'a list -> (string -> 'a) -> string -> 'a list B0.Sexp.key       val parse_atom : string -> B0.Sexp.t -> string       val parse_list : ?empty:bool -> string -> B0.Sexp.t -> B0.Sexp.t list       val parse_atom_kind : (string -> 'a) -> string -> B0.Sexp.t -> 'a       val parse_list_kind :         ?empty:bool ->         (string -> B0.Sexp.t -> 'a) -> string -> B0.Sexp.t -> 'a list     end   module Json :     sig       type 'a seq       val empty : 'B0.Json.seq       val ( ++ ) : 'B0.Json.seq -> 'B0.Json.seq -> 'B0.Json.seq       type t       type mem       type el       val null : B0.Json.t       val bool : bool -> B0.Json.t       val int : int -> B0.Json.t       val str : string -> B0.Json.t       val el : B0.Json.t -> B0.Json.el B0.Json.seq       val el_if : bool -> (unit -> B0.Json.t) -> B0.Json.el B0.Json.seq       val arr : B0.Json.el B0.Json.seq -> B0.Json.t       val mem : string -> B0.Json.t -> B0.Json.mem B0.Json.seq       val mem_if :         bool -> string -> (unit -> B0.Json.t) -> B0.Json.mem B0.Json.seq       val obj : B0.Json.mem B0.Json.seq -> B0.Json.t       val buffer_add : Buffer.t -> B0.Json.t -> unit       val to_string : B0.Json.t -> string       val output : Pervasives.out_channel -> B0.Json.t -> unit     end end