sig
  module Tty :
    sig
      type t = [ `Dumb | `Term of string ] option
      val of_fd : Unix.file_descr -> B0_std.Tty.t
      type cap = [ `Ansi | `None ]
      val cap : B0_std.Tty.t -> B0_std.Tty.cap
      type color =
          [ `Black
          | `Blue
          | `Cyan
          | `Default
          | `Green
          | `Magenta
          | `Red
          | `White
          | `Yellow ]
      type style =
          [ `Bg of B0_std.Tty.color
          | `Blink of [ `Rapid | `Slow ]
          | `Bold
          | `Faint
          | `Fg of B0_std.Tty.color
          | `Italic
          | `Reverse
          | `Underline ]
      val styled_str :
        B0_std.Tty.cap -> B0_std.Tty.style list -> string -> string
      val strip_escapes : string -> string
    end
  module Fmt :
    sig
      val stdout : Stdlib.Format.formatter
      val stderr : Stdlib.Format.formatter
      val flush : Stdlib.Format.formatter -> unit
      val pf :
        Stdlib.Format.formatter ->
        ('a, Stdlib.Format.formatter, unit) Stdlib.format -> 'a
      val pr : ('a, Stdlib.Format.formatter, unit) Stdlib.format -> 'a
      val epr : ('a, Stdlib.Format.formatter, unit) Stdlib.format -> 'a
      val str :
        ('a, Stdlib.Format.formatter, unit, string) Stdlib.format4 -> 'a
      val kpf :
        (Stdlib.Format.formatter -> 'a) ->
        Stdlib.Format.formatter ->
        ('b, Stdlib.Format.formatter, unit, 'a) Stdlib.format4 -> 'b
      val kstr :
        (string -> 'a) ->
        ('b, Stdlib.Format.formatter, unit, 'a) Stdlib.format4 -> 'b
      val failwith :
        ('b, Stdlib.Format.formatter, unit, 'a) Stdlib.format4 -> 'b
      val failwith_notrace :
        ('b, Stdlib.Format.formatter, unit, 'a) Stdlib.format4 -> 'b
      val invalid_arg :
        ('b, Stdlib.Format.formatter, unit, 'a) Stdlib.format4 -> 'b
      val error :
        ('b, Stdlib.Format.formatter, unit, ('a, string) Stdlib.result)
        Stdlib.format4 -> 'b
      type 'a t = Stdlib.Format.formatter -> '-> unit
      val nop : 'B0_std.Fmt.t
      val unit :
        (unit, Stdlib.Format.formatter, unit) Stdlib.Pervasives.format ->
        unit B0_std.Fmt.t
      val cut : unit B0_std.Fmt.t
      val sp : unit B0_std.Fmt.t
      val comma : unit B0_std.Fmt.t
      val bool : bool B0_std.Fmt.t
      val int : int B0_std.Fmt.t
      val int32 : int32 B0_std.Fmt.t
      val int64 : int64 B0_std.Fmt.t
      val float : float B0_std.Fmt.t
      val char : char B0_std.Fmt.t
      val string : string B0_std.Fmt.t
      val elided_string : max:int -> string B0_std.Fmt.t
      val pair :
        ?sep:unit B0_std.Fmt.t ->
        'B0_std.Fmt.t -> 'B0_std.Fmt.t -> ('a * 'b) B0_std.Fmt.t
      val list :
        ?empty:unit B0_std.Fmt.t ->
        ?sep:unit B0_std.Fmt.t -> 'B0_std.Fmt.t -> 'a list B0_std.Fmt.t
      val array :
        ?empty:unit B0_std.Fmt.t ->
        ?sep:unit B0_std.Fmt.t -> 'B0_std.Fmt.t -> 'a array B0_std.Fmt.t
      val option :
        ?none:unit B0_std.Fmt.t -> 'B0_std.Fmt.t -> 'a option B0_std.Fmt.t
      val none : unit B0_std.Fmt.t
      val iter :
        ?sep:unit B0_std.Fmt.t ->
        (('-> unit) -> '-> unit) -> 'B0_std.Fmt.t -> 'B0_std.Fmt.t
      val iter_bindings :
        ?sep:unit B0_std.Fmt.t ->
        (('-> '-> unit) -> '-> unit) ->
        ('a * 'b) B0_std.Fmt.t -> 'B0_std.Fmt.t
      val text : string B0_std.Fmt.t
      val lines : string B0_std.Fmt.t
      val exn : exn B0_std.Fmt.t
      val exn_backtrace : (exn * Stdlib.Printexc.raw_backtrace) B0_std.Fmt.t
      val sys_signal : int B0_std.Fmt.t
      val box : ?indent:int -> 'B0_std.Fmt.t -> 'B0_std.Fmt.t
      val hbox : 'B0_std.Fmt.t -> 'B0_std.Fmt.t
      val vbox : ?indent:int -> 'B0_std.Fmt.t -> 'B0_std.Fmt.t
      val hvbox : ?indent:int -> 'B0_std.Fmt.t -> 'B0_std.Fmt.t
      val squotes : 'B0_std.Fmt.t -> 'B0_std.Fmt.t
      val dquotes : 'B0_std.Fmt.t -> 'B0_std.Fmt.t
      val parens : 'B0_std.Fmt.t -> 'B0_std.Fmt.t
      val brackets : 'B0_std.Fmt.t -> 'B0_std.Fmt.t
      val braces : 'B0_std.Fmt.t -> 'B0_std.Fmt.t
      val set_tty_styling_cap : B0_std.Tty.cap -> unit
      val tty_styling_cap : unit -> B0_std.Tty.cap
      val tty_string : B0_std.Tty.style list -> string B0_std.Fmt.t
      val tty : B0_std.Tty.style list -> 'B0_std.Fmt.t -> 'B0_std.Fmt.t
      val one_of :
        ?empty:unit B0_std.Fmt.t -> 'B0_std.Fmt.t -> 'a list B0_std.Fmt.t
      val did_you_mean :
        ?pre:unit B0_std.Fmt.t ->
        ?post:unit B0_std.Fmt.t ->
        kind:string -> 'B0_std.Fmt.t -> ('a * 'a list) B0_std.Fmt.t
      val field :
        ?style:B0_std.Tty.style list ->
        string -> 'B0_std.Fmt.t -> 'B0_std.Fmt.t
      val si_size : scale:int -> string -> int B0_std.Fmt.t
      val byte_size : int B0_std.Fmt.t
      val uint64_ns_span : int64 B0_std.Fmt.t
    end
  module Option :
    sig
      type 'a t = 'a option = None | Some of 'a
      val none : 'a option
      val some : '-> 'a option
      val value : 'a option -> default:'-> 'a
      val get : 'a option -> 'a
      val bind : 'a option -> ('-> 'b option) -> 'b option
      val join : 'a option option -> 'a option
      val map : ('-> 'b) -> 'a option -> 'b option
      val fold : none:'-> some:('-> 'a) -> 'b option -> 'a
      val iter : ('-> unit) -> 'a option -> unit
      val is_none : 'a option -> bool
      val is_some : 'a option -> bool
      val equal : ('-> '-> bool) -> 'a option -> 'a option -> bool
      val compare : ('-> '-> int) -> 'a option -> 'a option -> int
      val to_result : none:'-> 'a option -> ('a, 'e) Stdlib.result
      val to_list : 'a option -> 'a list
    end
  module Result :
    sig
      type ('a, 'e) t = ('a, 'e) Stdlib.result = Ok of '| Error of 'e
      val ok : '-> ('a, 'e) Stdlib.result
      val error : '-> ('a, 'e) Stdlib.result
      val value : ('a, 'e) Stdlib.result -> default:'-> 'a
      val get_ok : ('a, 'e) Stdlib.result -> 'a
      val get_error : ('a, 'e) Stdlib.result -> 'e
      val bind :
        ('a, 'e) Stdlib.result ->
        ('-> ('b, 'e) Stdlib.result) -> ('b, 'e) Stdlib.result
      val join :
        (('a, 'e) Stdlib.result, 'e) Stdlib.result -> ('a, 'e) Stdlib.result
      val map :
        ('-> 'b) -> ('a, 'e) Stdlib.result -> ('b, 'e) Stdlib.result
      val map_error :
        ('-> 'f) -> ('a, 'e) Stdlib.result -> ('a, 'f) Stdlib.result
      val fold :
        ok:('-> 'c) -> error:('-> 'c) -> ('a, 'e) Stdlib.result -> 'c
      val iter : ('-> unit) -> ('a, 'e) Stdlib.result -> unit
      val iter_error : ('-> unit) -> ('a, 'e) Stdlib.result -> unit
      val is_ok : ('a, 'e) Stdlib.result -> bool
      val is_error : ('a, 'e) Stdlib.result -> bool
      val equal :
        ok:('-> '-> bool) ->
        error:('-> '-> bool) ->
        ('a, 'e) Stdlib.result -> ('a, 'e) Stdlib.result -> bool
      val compare :
        ok:('-> '-> int) ->
        error:('-> '-> int) ->
        ('a, 'e) Stdlib.result -> ('a, 'e) Stdlib.result -> int
      val to_failure : ('a, string) Stdlib.result -> 'a
      val catch_failure : (unit -> 'a) -> ('a, string) Stdlib.result
      val catch_sys_error : (unit -> 'a) -> ('a, string) Stdlib.result
      val to_option : ('a, 'e) Stdlib.result -> 'a option
      val to_list : ('a, 'e) Stdlib.result -> 'a list
    end
  module Char :
    sig
      external code : char -> int = "%identity"
      val chr : int -> char
      val escaped : char -> string
      val lowercase : char -> char
      val uppercase : char -> char
      val lowercase_ascii : char -> char
      val uppercase_ascii : char -> char
      type t = char
      val compare : t -> t -> int
      val equal : t -> t -> bool
      external unsafe_chr : int -> char = "%identity"
      module Ascii :
        sig
          val is_digit : char -> bool
          val is_hex_digit : char -> bool
          val hex_digit_value : char -> int
          val lower_hex_digit : int -> char
          val upper_hex_digit : int -> char
          val is_valid : char -> bool
          val is_upper : char -> bool
          val is_lower : char -> bool
          val is_letter : char -> bool
          val is_alphanum : char -> bool
          val is_white : char -> bool
          val is_blank : char -> bool
          val is_graphic : char -> bool
          val is_print : char -> bool
          val is_control : char -> bool
          val uppercase : char -> char
          val lowercase : char -> char
        end
    end
  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 index_opt : string -> char -> int option
      val rindex : string -> char -> int
      val rindex_opt : string -> char -> int option
      val index_from : string -> int -> char -> int
      val index_from_opt : string -> int -> char -> int option
      val rindex_from : string -> int -> char -> int
      val rindex_from_opt : string -> int -> char -> int option
      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
      val split_on_char : char -> string -> string list
      val to_seq : t -> char Seq.t
      val to_seqi : t -> (int * char) Seq.t
      val of_seq : char Seq.t -> t
      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 empty : string
      val head : string -> char option
      val of_char : char -> string
      val is_empty : string -> bool
      val is_prefix : affix:string -> string -> bool
      val is_infix : 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 take_left : int -> string -> string
      val take_right : int -> string -> string
      val drop_left : int -> string -> string
      val drop_right : int -> string -> string
      val break_left : int -> string -> string * string
      val break_right : int -> string -> string * string
      val keep_left : (char -> bool) -> string -> string
      val keep_right : (char -> bool) -> string -> string
      val lose_left : (char -> bool) -> string -> string
      val lose_right : (char -> bool) -> string -> string
      val span_left : (char -> bool) -> string -> string * string
      val span_right : (char -> bool) -> string -> string * string
      val cut_left : sep:string -> string -> (string * string) option
      val cut_right : sep:string -> string -> (string * string) option
      val cuts_left : ?drop_empty:bool -> sep:string -> string -> string list
      val cuts_right :
        ?drop_empty:bool -> sep:string -> string -> string list
      val map : (char -> char) -> string -> string
      val mapi : (int -> char -> char) -> string -> string
      val pp : string B0_std.Fmt.t
      val dump : string B0_std.Fmt.t
      val uniquify : string list -> string list
      val unique :
        exists:(string -> bool) -> string -> (string, string) Stdlib.result
      val edit_distance : string -> string -> int
      val suggest : ?dist:int -> string list -> string -> string list
      val escaper :
        (char -> int) -> (bytes -> int -> char -> int) -> string -> string
      exception Illegal_escape of int
      val unescaper :
        (string -> int -> int) ->
        (bytes -> int -> string -> int -> int) ->
        string -> (string, int) Stdlib.result
      module Ascii :
        sig
          val is_valid : string -> bool
          val uppercase : string -> string
          val lowercase : string -> string
          val capitalize : string -> string
          val uncapitalize : string -> string
          val to_hex : string -> string
          val of_hex : string -> (string, int) Stdlib.result
          val escape : string -> string
          val unescape : string -> (string, int) Stdlib.result
          val ocaml_string_escape : string -> string
          val ocaml_unescape : string -> (string, int) Stdlib.result
        end
      module Set :
        sig
          type t
          val empty : t
          val is_empty : t -> bool
          val mem : string -> t -> bool
          val add : string -> t -> t
          val singleton : string -> t
          val remove : string -> 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 : (string -> unit) -> t -> unit
          val map : (string -> string) -> t -> t
          val fold : (string -> '-> 'a) -> t -> '-> 'a
          val for_all : (string -> bool) -> t -> bool
          val exists : (string -> bool) -> t -> bool
          val filter : (string -> bool) -> t -> t
          val partition : (string -> bool) -> t -> t * t
          val cardinal : t -> int
          val elements : t -> string list
          val min_elt : t -> string
          val min_elt_opt : t -> string option
          val max_elt : t -> string
          val max_elt_opt : t -> string option
          val choose : t -> string
          val choose_opt : t -> string option
          val split : string -> t -> t * bool * t
          val find : string -> t -> string
          val find_opt : string -> t -> string option
          val find_first : (string -> bool) -> t -> string
          val find_first_opt : (string -> bool) -> t -> string option
          val find_last : (string -> bool) -> t -> string
          val find_last_opt : (string -> bool) -> t -> string option
          val of_list : string list -> t
          val to_seq_from : string -> t -> string Seq.t
          val to_seq : t -> string Seq.t
          val add_seq : string Seq.t -> t -> t
          val of_seq : string Seq.t -> t
          val pp :
            ?sep:unit B0_std.Fmt.t -> string B0_std.Fmt.t -> t B0_std.Fmt.t
          val dump : t B0_std.Fmt.t
        end
      module Map :
        sig
          type +'a t
          val empty : 'a t
          val is_empty : 'a t -> bool
          val mem : string -> 'a t -> bool
          val add : string -> '-> 'a t -> 'a t
          val update : string -> ('a option -> 'a option) -> 'a t -> 'a t
          val singleton : string -> '-> 'a t
          val remove : string -> 'a t -> 'a t
          val merge :
            (string -> 'a option -> 'b option -> 'c option) ->
            'a t -> 'b t -> 'c t
          val union :
            (string -> '-> '-> '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 : (string -> '-> unit) -> 'a t -> unit
          val fold : (string -> '-> '-> 'b) -> 'a t -> '-> 'b
          val for_all : (string -> '-> bool) -> 'a t -> bool
          val exists : (string -> '-> bool) -> 'a t -> bool
          val filter : (string -> '-> bool) -> 'a t -> 'a t
          val partition : (string -> '-> bool) -> 'a t -> 'a t * 'a t
          val cardinal : 'a t -> int
          val bindings : 'a t -> (string * 'a) list
          val min_binding : 'a t -> string * 'a
          val min_binding_opt : 'a t -> (string * 'a) option
          val max_binding : 'a t -> string * 'a
          val max_binding_opt : 'a t -> (string * 'a) option
          val choose : 'a t -> string * 'a
          val choose_opt : 'a t -> (string * 'a) option
          val split : string -> 'a t -> 'a t * 'a option * 'a t
          val find : string -> 'a t -> 'a
          val find_opt : string -> 'a t -> 'a option
          val find_first : (string -> bool) -> 'a t -> string * 'a
          val find_first_opt :
            (string -> bool) -> 'a t -> (string * 'a) option
          val find_last : (string -> bool) -> 'a t -> string * 'a
          val find_last_opt :
            (string -> bool) -> 'a t -> (string * 'a) option
          val map : ('-> 'b) -> 'a t -> 'b t
          val mapi : (string -> '-> 'b) -> 'a t -> 'b t
          val to_seq : 'a t -> (string * 'a) Seq.t
          val to_seq_from : string -> 'a t -> (string * 'a) Seq.t
          val add_seq : (string * 'a) Seq.t -> 'a t -> 'a t
          val of_seq : (string * 'a) Seq.t -> 'a t
          val dom : 'a t -> B0_std.String.Set.t
          val of_list : (string * 'a) list -> 'a t
          val pp :
            ?sep:unit B0_std.Fmt.t ->
            (string * 'a) B0_std.Fmt.t -> 'a t B0_std.Fmt.t
          val dump : 'B0_std.Fmt.t -> 'a t B0_std.Fmt.t
          val dump_string_map : string t B0_std.Fmt.t
        end
    end
  module List :
    sig
      val length : 'a list -> int
      val compare_lengths : 'a list -> 'b list -> int
      val compare_length_with : 'a list -> int -> int
      val cons : '-> 'a list -> 'a list
      val hd : 'a list -> 'a
      val tl : 'a list -> 'a list
      val nth : 'a list -> int -> 'a
      val nth_opt : 'a list -> int -> 'a option
      val rev : 'a list -> 'a list
      val init : int -> (int -> 'a) -> 'a list
      val append : 'a list -> 'a list -> 'a list
      val rev_append : 'a list -> 'a list -> 'a list
      val concat : 'a list list -> 'a list
      val flatten : 'a list list -> 'a list
      val iter : ('-> unit) -> 'a list -> unit
      val iteri : (int -> '-> unit) -> 'a list -> unit
      val map : ('-> 'b) -> 'a list -> 'b list
      val mapi : (int -> '-> 'b) -> 'a list -> 'b list
      val rev_map : ('-> 'b) -> 'a list -> 'b list
      val fold_left : ('-> '-> 'a) -> '-> 'b list -> 'a
      val fold_right : ('-> '-> 'b) -> 'a list -> '-> 'b
      val iter2 : ('-> '-> unit) -> 'a list -> 'b list -> unit
      val map2 : ('-> '-> 'c) -> 'a list -> 'b list -> 'c list
      val rev_map2 : ('-> '-> 'c) -> 'a list -> 'b list -> 'c list
      val fold_left2 :
        ('-> '-> '-> 'a) -> '-> 'b list -> 'c list -> 'a
      val fold_right2 :
        ('-> '-> '-> 'c) -> 'a list -> 'b list -> '-> 'c
      val for_all : ('-> bool) -> 'a list -> bool
      val exists : ('-> bool) -> 'a list -> bool
      val for_all2 : ('-> '-> bool) -> 'a list -> 'b list -> bool
      val exists2 : ('-> '-> bool) -> 'a list -> 'b list -> bool
      val mem : '-> 'a list -> bool
      val memq : '-> 'a list -> bool
      val find : ('-> bool) -> 'a list -> 'a
      val find_opt : ('-> bool) -> 'a list -> 'a option
      val filter : ('-> bool) -> 'a list -> 'a list
      val find_all : ('-> bool) -> 'a list -> 'a list
      val partition : ('-> bool) -> 'a list -> 'a list * 'a list
      val assoc : '-> ('a * 'b) list -> 'b
      val assoc_opt : '-> ('a * 'b) list -> 'b option
      val assq : '-> ('a * 'b) list -> 'b
      val assq_opt : '-> ('a * 'b) list -> 'b option
      val mem_assoc : '-> ('a * 'b) list -> bool
      val mem_assq : '-> ('a * 'b) list -> bool
      val remove_assoc : '-> ('a * 'b) list -> ('a * 'b) list
      val remove_assq : '-> ('a * 'b) list -> ('a * 'b) list
      val split : ('a * 'b) list -> 'a list * 'b list
      val combine : 'a list -> 'b list -> ('a * 'b) list
      val sort : ('-> '-> int) -> 'a list -> 'a list
      val stable_sort : ('-> '-> int) -> 'a list -> 'a list
      val fast_sort : ('-> '-> int) -> 'a list -> 'a list
      val sort_uniq : ('-> '-> int) -> 'a list -> 'a list
      val merge : ('-> '-> int) -> 'a list -> 'a list -> 'a list
      val to_seq : 'a list -> 'Seq.t
      val of_seq : 'Seq.t -> 'a list
      val classify :
        ?cmp_elts:('-> '-> int) ->
        ?cmp_classes:('-> '-> int) ->
        classes:('-> 'b list) -> 'a list -> ('b * 'a list) list
    end
  module Conv :
    sig
      exception Error of int * int * string
      module Bin :
        sig
          type 'a enc = Stdlib.Buffer.t -> '-> unit
          val enc_err :
            kind:string ->
            ('a, Stdlib.Format.formatter, unit, 'b) Stdlib.format4 -> 'a
          val enc_byte : int B0_std.Conv.Bin.enc
          val enc_bytes : string B0_std.Conv.Bin.enc
          val enc_list :
            'B0_std.Conv.Bin.enc -> 'a list B0_std.Conv.Bin.enc
          type 'a dec = string -> start:int -> int * 'a
          val dec_err :
            kind:string ->
            int ->
            ('a, Stdlib.Format.formatter, unit, 'b) Stdlib.format4 -> 'a
          val dec_err_eoi : kind:string -> int -> 'a
          val dec_err_exceed : kind:string -> int -> int -> max:int -> 'a
          val dec_need :
            kind:string -> string -> start:int -> len:int -> unit
          val dec_byte : kind:string -> int B0_std.Conv.Bin.dec
          val dec_bytes : kind:string -> string B0_std.Conv.Bin.dec
          val dec_list :
            'B0_std.Conv.Bin.dec ->
            kind:string -> 'a list B0_std.Conv.Bin.dec
        end
      module Txt :
        sig
          type 'a enc = Stdlib.Format.formatter -> '-> unit
          type 'a dec = string -> start:int -> int * 'a
          val enc_err :
            kind:string ->
            ('a, Stdlib.Format.formatter, unit, 'b) Stdlib.format4 -> 'a
          val enc_atom : string B0_std.Conv.Txt.enc
          val enc_list :
            'B0_std.Conv.Txt.enc -> 'a list B0_std.Conv.Txt.enc
          type lexeme = [ `Atom of string | `Le | `Ls ]
          val dec_err :
            kind:string ->
            int ->
            ('a, Stdlib.Format.formatter, unit, 'b) Stdlib.format4 -> 'a
          val dec_err_eoi : kind:string -> int -> 'a
          val dec_err_lexeme :
            kind:string ->
            int ->
            B0_std.Conv.Txt.lexeme -> exp:B0_std.Conv.Txt.lexeme list -> 'a
          val dec_err_atom :
            kind:string -> int -> string -> exp:string list -> 'a
          val dec_skip : kind:string -> string -> start:int -> int
          val dec_lexeme :
            kind:string -> (int * B0_std.Conv.Txt.lexeme) B0_std.Conv.Txt.dec
          val dec_ls : kind:string -> string -> start:int -> int
          val dec_le : kind:string -> string -> start:int -> int
          val dec_atom : kind:string -> string B0_std.Conv.Txt.dec
          val dec_list :
            'B0_std.Conv.Txt.dec ->
            kind:string -> 'a list B0_std.Conv.Txt.dec
          val dec_list_tail :
            'B0_std.Conv.Txt.dec ->
            kind:string -> ls:int -> 'a list B0_std.Conv.Txt.dec
        end
      type 'a t
      val v :
        kind:string ->
        docvar:string ->
        'B0_std.Conv.Bin.enc ->
        'B0_std.Conv.Bin.dec ->
        'B0_std.Conv.Txt.enc -> 'B0_std.Conv.Txt.dec -> 'B0_std.Conv.t
      val kind : 'B0_std.Conv.t -> string
      val docvar : 'B0_std.Conv.t -> string
      val bin_enc : 'B0_std.Conv.t -> 'B0_std.Conv.Bin.enc
      val bin_dec : 'B0_std.Conv.t -> 'B0_std.Conv.Bin.dec
      val txt_enc : 'B0_std.Conv.t -> 'B0_std.Conv.Txt.enc
      val txt_dec : 'B0_std.Conv.t -> 'B0_std.Conv.Txt.dec
      val with_kind :
        ?docvar:string -> string -> 'B0_std.Conv.t -> 'B0_std.Conv.t
      val with_docvar : string -> 'B0_std.Conv.t -> 'B0_std.Conv.t
      val with_conv :
        kind:string ->
        docvar:string ->
        ('-> 'a) -> ('-> 'b) -> 'B0_std.Conv.t -> 'B0_std.Conv.t
      val to_bin :
        ?buf:Stdlib.Buffer.t ->
        'B0_std.Conv.t -> '-> (string, string) Stdlib.result
      val of_bin : 'B0_std.Conv.t -> string -> ('a, string) Stdlib.result
      val to_txt :
        ?buf:Stdlib.Buffer.t ->
        'B0_std.Conv.t -> '-> (string, string) Stdlib.result
      val of_txt : 'B0_std.Conv.t -> string -> ('a, string) Stdlib.result
      val to_pp : 'B0_std.Conv.t -> 'B0_std.Fmt.t
      val bool : bool B0_std.Conv.t
      val byte : int B0_std.Conv.t
      val int : int B0_std.Conv.t
      val int31 : int B0_std.Conv.t
      val int32 : int32 B0_std.Conv.t
      val int64 : int64 B0_std.Conv.t
      val float : float B0_std.Conv.t
      val string_bytes : string B0_std.Conv.t
      val atom : string B0_std.Conv.t
      val atom_non_empty : string B0_std.Conv.t
      val option :
        ?kind:string ->
        ?docvar:string -> 'B0_std.Conv.t -> 'a option B0_std.Conv.t
      val some : 'B0_std.Conv.t -> 'a option B0_std.Conv.t
      val result :
        ?kind:string ->
        ?docvar:string ->
        'B0_std.Conv.t ->
        'B0_std.Conv.t -> ('a, 'b) Stdlib.result B0_std.Conv.t
      val list :
        ?kind:string ->
        ?docvar:string -> 'B0_std.Conv.t -> 'a list B0_std.Conv.t
      val array :
        ?kind:string ->
        ?docvar:string -> 'B0_std.Conv.t -> 'a array B0_std.Conv.t
      val pair :
        ?kind:string ->
        ?docvar:string ->
        'B0_std.Conv.t -> 'B0_std.Conv.t -> ('a * 'b) B0_std.Conv.t
      val enum :
        kind:string ->
        docvar:string ->
        ?eq:('-> '-> bool) -> (string * 'a) list -> 'B0_std.Conv.t
      val string_only : string B0_std.Conv.t
    end
  module Fpath :
    sig
      val dir_sep_char : char
      val dir_sep : string
      val is_seg : string -> bool
      val is_rel_seg : string -> bool
      type t
      val v : string -> B0_std.Fpath.t
      val add_seg : B0_std.Fpath.t -> string -> B0_std.Fpath.t
      val append : B0_std.Fpath.t -> B0_std.Fpath.t -> B0_std.Fpath.t
      val ( / ) : B0_std.Fpath.t -> string -> B0_std.Fpath.t
      val ( // ) : B0_std.Fpath.t -> B0_std.Fpath.t -> B0_std.Fpath.t
      val is_dir_path : B0_std.Fpath.t -> bool
      val to_dir_path : B0_std.Fpath.t -> B0_std.Fpath.t
      val basename : B0_std.Fpath.t -> string
      val parent : B0_std.Fpath.t -> B0_std.Fpath.t
      val is_rel : B0_std.Fpath.t -> bool
      val is_abs : B0_std.Fpath.t -> bool
      val is_root : B0_std.Fpath.t -> bool
      val is_current_dir : B0_std.Fpath.t -> bool
      val is_parent_dir : B0_std.Fpath.t -> bool
      val equal : B0_std.Fpath.t -> B0_std.Fpath.t -> bool
      val equal_basename : B0_std.Fpath.t -> B0_std.Fpath.t -> bool
      val compare : B0_std.Fpath.t -> B0_std.Fpath.t -> int
      type ext = string
      val get_ext : ?multi:bool -> B0_std.Fpath.t -> B0_std.Fpath.ext
      val has_ext : B0_std.Fpath.ext -> B0_std.Fpath.t -> bool
      val mem_ext : B0_std.Fpath.ext list -> B0_std.Fpath.t -> bool
      val add_ext : B0_std.Fpath.ext -> B0_std.Fpath.t -> B0_std.Fpath.t
      val rem_ext : ?multi:bool -> B0_std.Fpath.t -> B0_std.Fpath.t
      val set_ext :
        ?multi:bool -> B0_std.Fpath.ext -> B0_std.Fpath.t -> B0_std.Fpath.t
      val cut_ext :
        ?multi:bool -> B0_std.Fpath.t -> B0_std.Fpath.t * B0_std.Fpath.ext
      val ( + ) : B0_std.Fpath.t -> B0_std.Fpath.ext -> B0_std.Fpath.t
      val ( -+ ) : B0_std.Fpath.t -> B0_std.Fpath.ext -> B0_std.Fpath.t
      val of_string : string -> (B0_std.Fpath.t, string) Stdlib.result
      val to_string : B0_std.Fpath.t -> string
      val conv : B0_std.Fpath.t B0_std.Conv.t
      val conv_only : B0_std.Fpath.t B0_std.Conv.t
      val pp : B0_std.Fpath.t B0_std.Fmt.t
      val pp_quoted : B0_std.Fpath.t B0_std.Fmt.t
      val dump : B0_std.Fpath.t B0_std.Fmt.t
      val uniquify : B0_std.Fpath.t list -> B0_std.Fpath.t list
      type path = B0_std.Fpath.t
      module Set :
        sig
          type t
          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 map : (t -> t) -> t -> t
          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 min_elt_opt : t -> t option
          val max_elt : t -> t
          val max_elt_opt : t -> t option
          val choose : t -> t
          val choose_opt : t -> t option
          val split : t -> t -> t * bool * t
          val find : t -> t -> t
          val find_opt : t -> t -> t option
          val find_first : (t -> bool) -> t -> t
          val find_first_opt : (t -> bool) -> t -> t option
          val find_last : (t -> bool) -> t -> t
          val find_last_opt : (t -> bool) -> t -> t option
          val of_list : t list -> t
          val to_seq_from : t -> t -> t Seq.t
          val to_seq : t -> t Seq.t
          val add_seq : t Seq.t -> t -> t
          val of_seq : t Seq.t -> t
          val pp :
            ?sep:unit B0_std.Fmt.t ->
            B0_std.Fpath.path B0_std.Fmt.t -> B0_std.Fpath.t B0_std.Fmt.t
          val dump : B0_std.Fpath.t B0_std.Fmt.t
        end
      module Map :
        sig
          type +'a t
          val empty : 'a t
          val is_empty : 'a t -> bool
          val mem : t -> 'a t -> bool
          val add : t -> '-> 'a t -> 'a t
          val update : t -> ('a option -> 'a option) -> 'a t -> 'a t
          val singleton : t -> '-> 'a t
          val remove : t -> 'a t -> 'a t
          val merge :
            (t -> 'a option -> 'b option -> 'c option) ->
            'a t -> 'b t -> 'c t
          val union : (t -> '-> '-> '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 : (t -> '-> unit) -> 'a t -> unit
          val fold : (t -> '-> '-> 'b) -> 'a t -> '-> 'b
          val for_all : (t -> '-> bool) -> 'a t -> bool
          val exists : (t -> '-> bool) -> 'a t -> bool
          val filter : (t -> '-> bool) -> 'a t -> 'a t
          val partition : (t -> '-> bool) -> 'a t -> 'a t * 'a t
          val cardinal : 'a t -> int
          val bindings : 'a t -> (t * 'a) list
          val min_binding : 'a t -> t * 'a
          val min_binding_opt : 'a t -> (t * 'a) option
          val max_binding : 'a t -> t * 'a
          val max_binding_opt : 'a t -> (t * 'a) option
          val choose : 'a t -> t * 'a
          val choose_opt : 'a t -> (t * 'a) option
          val split : t -> 'a t -> 'a t * 'a option * 'a t
          val find : t -> 'a t -> 'a
          val find_opt : t -> 'a t -> 'a option
          val find_first : (t -> bool) -> 'a t -> t * 'a
          val find_first_opt : (t -> bool) -> 'a t -> (t * 'a) option
          val find_last : (t -> bool) -> 'a t -> t * 'a
          val find_last_opt : (t -> bool) -> 'a t -> (t * 'a) option
          val map : ('-> 'b) -> 'a t -> 'b t
          val mapi : (t -> '-> 'b) -> 'a t -> 'b t
          val to_seq : 'a t -> (t * 'a) Seq.t
          val to_seq_from : t -> 'a t -> (t * 'a) Seq.t
          val add_seq : (t * 'a) Seq.t -> 'a t -> 'a t
          val of_seq : (t * 'a) Seq.t -> 'a t
          val dom : 'B0_std.Fpath.t -> B0_std.Fpath.Set.t
          val of_list : (B0_std.Fpath.path * 'a) list -> 'B0_std.Fpath.t
          val pp :
            ?sep:unit B0_std.Fmt.t ->
            (B0_std.Fpath.path * 'a) B0_std.Fmt.t ->
            'B0_std.Fpath.t B0_std.Fmt.t
          val dump : 'B0_std.Fmt.t -> 'B0_std.Fpath.t B0_std.Fmt.t
        end
      val search_path_sep : string
      val list_of_search_path :
        ?sep:string -> string -> (B0_std.Fpath.t list, string) Stdlib.result
    end
  module Hash :
    sig
      type t
      val nil : B0_std.Hash.t
      val length : B0_std.Hash.t -> int
      val is_nil : B0_std.Hash.t -> bool
      val equal : B0_std.Hash.t -> B0_std.Hash.t -> bool
      val compare : B0_std.Hash.t -> B0_std.Hash.t -> int
      val to_bytes : B0_std.Hash.t -> string
      val of_bytes : string -> B0_std.Hash.t
      val to_hex : B0_std.Hash.t -> string
      val of_hex : string -> (B0_std.Hash.t, int) Stdlib.result
      val conv : B0_std.Hash.t B0_std.Conv.t
      val pp : B0_std.Hash.t B0_std.Fmt.t
      module type T =
        sig
          val id : string
          val length : int
          val string : string -> B0_std.Hash.t
          val fd : Unix.file_descr -> B0_std.Hash.t
          val file : B0_std.Fpath.t -> (B0_std.Hash.t, string) Stdlib.result
        end
      module Murmur3_128 : T
      module Xxh_64 : T
      val funs : unit -> (module B0_std.Hash.T) list
      val add_fun : (module B0_std.Hash.T-> unit
    end
  module Time :
    sig
      type span
      module Span :
        sig
          type t = B0_std.Time.span
          val zero : B0_std.Time.span
          val one : B0_std.Time.span
          val add : B0_std.Time.span -> B0_std.Time.span -> B0_std.Time.span
          val abs_diff :
            B0_std.Time.span -> B0_std.Time.span -> B0_std.Time.span
          val equal : B0_std.Time.span -> B0_std.Time.span -> bool
          val compare : B0_std.Time.span -> B0_std.Time.span -> int
          val to_uint64_ns : B0_std.Time.span -> int64
          val of_uint64_ns : int64 -> B0_std.Time.span
          val conv : B0_std.Time.span B0_std.Conv.t
          val pp : B0_std.Time.span B0_std.Fmt.t
          val pp_ns : B0_std.Time.span B0_std.Fmt.t
        end
      type counter
      val counter : unit -> B0_std.Time.counter
      val count : B0_std.Time.counter -> B0_std.Time.span
      type cpu_span
      val cpu_zero : B0_std.Time.cpu_span
      val cpu_utime : B0_std.Time.cpu_span -> B0_std.Time.span
      val cpu_stime : B0_std.Time.cpu_span -> B0_std.Time.span
      val cpu_children_utime : B0_std.Time.cpu_span -> B0_std.Time.span
      val cpu_children_stime : B0_std.Time.cpu_span -> B0_std.Time.span
      val cpu_span_conv : B0_std.Time.cpu_span B0_std.Conv.t
      type cpu_counter
      val cpu_counter : unit -> B0_std.Time.cpu_counter
      val cpu_count : B0_std.Time.cpu_counter -> B0_std.Time.cpu_span
    end
  module Cmd :
    sig
      type t
      val is_empty : B0_std.Cmd.t -> bool
      val empty : B0_std.Cmd.t
      val arg : string -> B0_std.Cmd.t
      val append : B0_std.Cmd.t -> B0_std.Cmd.t -> B0_std.Cmd.t
      val shield : B0_std.Cmd.t -> B0_std.Cmd.t
      val ( % ) : B0_std.Cmd.t -> string -> B0_std.Cmd.t
      val ( %% ) : B0_std.Cmd.t -> B0_std.Cmd.t -> B0_std.Cmd.t
      val if' : bool -> B0_std.Cmd.t -> B0_std.Cmd.t
      val path : B0_std.Fpath.t -> B0_std.Cmd.t
      val spath : B0_std.Fpath.t -> B0_std.Cmd.t
      val args : ?slip:string -> string list -> B0_std.Cmd.t
      val rev_args : ?slip:string -> string list -> B0_std.Cmd.t
      val of_list : ?slip:string -> ('-> string) -> 'a list -> B0_std.Cmd.t
      val of_rev_list :
        ?slip:string -> ('-> string) -> 'a list -> B0_std.Cmd.t
      val paths : ?slip:string -> B0_std.Fpath.t list -> B0_std.Cmd.t
      val rev_paths : ?slip:string -> B0_std.Fpath.t list -> B0_std.Cmd.t
      type tool = B0_std.Fpath.t
      val tool : B0_std.Cmd.t -> B0_std.Cmd.tool option
      val set_tool : B0_std.Cmd.tool -> B0_std.Cmd.t -> B0_std.Cmd.t option
      val get_tool : B0_std.Cmd.t -> B0_std.Cmd.tool
      val is_singleton : B0_std.Cmd.t -> bool
      val to_list : B0_std.Cmd.t -> string list
      val to_sig : B0_std.Cmd.t -> string list
      val to_list_and_sig : B0_std.Cmd.t -> string list * string list
      val to_string : B0_std.Cmd.t -> string
      val of_string : string -> (B0_std.Cmd.t, string) Stdlib.result
      val conv : B0_std.Cmd.t B0_std.Conv.t
      val pp : B0_std.Cmd.t B0_std.Fmt.t
      val dump : B0_std.Cmd.t B0_std.Fmt.t
    end
  module Os :
    sig
      module Env :
        sig
          val find : empty_to_none:bool -> string -> string option
          val find_value :
            (string -> ('a, string) Stdlib.result) ->
            empty_to_none:bool -> string -> ('a, string) Stdlib.result option
          type t = string B0_std.String.Map.t
          val empty : B0_std.Os.Env.t
          val override :
            B0_std.Os.Env.t -> by:B0_std.Os.Env.t -> B0_std.Os.Env.t
          val current : unit -> (B0_std.Os.Env.t, string) Stdlib.result
          type assignments = string list
          val current_assignments :
            unit -> (B0_std.Os.Env.assignments, string) Stdlib.result
          val of_assignments :
            ?init:B0_std.Os.Env.t ->
            string list -> (B0_std.Os.Env.t, string) Stdlib.result
          val to_assignments : B0_std.Os.Env.t -> B0_std.Os.Env.assignments
        end
      module Path :
        sig
          val exists : B0_std.Fpath.t -> (bool, string) Stdlib.result
          val must_exist : B0_std.Fpath.t -> (unit, string) Stdlib.result
          val delete :
            recurse:bool -> B0_std.Fpath.t -> (bool, string) Stdlib.result
          val rename :
            force:bool ->
            make_path:bool ->
            src:B0_std.Fpath.t ->
            B0_std.Fpath.t -> (unit, string) Stdlib.result
          val copy :
            ?rel:bool ->
            ?atomic:bool ->
            ?allow_hardlinks:bool ->
            ?follow_symlinks:bool ->
            ?prune:(Unix.stats -> string -> B0_std.Fpath.t -> bool) ->
            make_path:bool ->
            recurse:bool ->
            src:B0_std.Fpath.t ->
            B0_std.Fpath.t -> (unit, string) Stdlib.result
          val get_mode : B0_std.Fpath.t -> (int, string) Stdlib.result
          val set_mode :
            B0_std.Fpath.t -> int -> (unit, string) Stdlib.result
          val stat : B0_std.Fpath.t -> (Unix.stats, string) Stdlib.result
          val symlink :
            force:bool ->
            make_path:bool ->
            src:B0_std.Fpath.t ->
            B0_std.Fpath.t -> (unit, string) Stdlib.result
          val symlink_link :
            B0_std.Fpath.t -> (B0_std.Fpath.t, string) Stdlib.result
          val symlink_stat :
            B0_std.Fpath.t -> (Unix.stats, string) Stdlib.result
          type tmp_name = (string -> string, unit, string) Stdlib.format
          val tmp :
            ?make_path:bool ->
            ?dir:B0_std.Fpath.t ->
            ?name:B0_std.Os.Path.tmp_name ->
            unit -> (B0_std.Fpath.t, string) Stdlib.result
        end
      module File :
        sig
          val null : B0_std.Fpath.t
          val dash : B0_std.Fpath.t
          val exists : B0_std.Fpath.t -> (bool, string) Stdlib.result
          val must_exist : B0_std.Fpath.t -> (unit, string) Stdlib.result
          val is_executable : B0_std.Fpath.t -> bool
          val delete : B0_std.Fpath.t -> (bool, string) Stdlib.result
          val truncate :
            B0_std.Fpath.t -> int -> (unit, string) Stdlib.result
          val link :
            force:bool ->
            make_path:bool ->
            src:B0_std.Fpath.t ->
            B0_std.Fpath.t -> (unit, string) Stdlib.result
          val read_with_fd :
            B0_std.Fpath.t ->
            (Unix.file_descr -> 'b) -> ('b, string) Stdlib.result
          val read_with_ic :
            B0_std.Fpath.t ->
            (Stdlib.in_channel -> 'b) -> ('b, string) Stdlib.result
          val read : B0_std.Fpath.t -> (string, string) Stdlib.result
          val write_with_fd :
            ?atomic:bool ->
            ?mode:int ->
            force:bool ->
            make_path:bool ->
            B0_std.Fpath.t ->
            (Unix.file_descr -> ('a, 'b) Stdlib.Pervasives.result) ->
            (('a, 'b) Stdlib.Pervasives.result, string) Stdlib.result
          val write_with_oc :
            ?atomic:bool ->
            ?mode:int ->
            force:bool ->
            make_path:bool ->
            B0_std.Fpath.t ->
            (Stdlib.out_channel -> ('a, 'b) Stdlib.Pervasives.result) ->
            (('a, 'b) Stdlib.Pervasives.result, string) Stdlib.result
          val write :
            ?atomic:bool ->
            ?mode:int ->
            force:bool ->
            make_path:bool ->
            B0_std.Fpath.t -> string -> (unit, string) Stdlib.result
          val copy :
            ?atomic:bool ->
            ?mode:int ->
            force:bool ->
            make_path:bool ->
            src:B0_std.Fpath.t ->
            B0_std.Fpath.t -> (unit, string) Stdlib.result
          val with_tmp_fd :
            ?flags:Unix.open_flag list ->
            ?mode:int ->
            ?make_path:bool ->
            ?dir:B0_std.Fpath.t ->
            ?name:B0_std.Os.Path.tmp_name ->
            (B0_std.Fpath.t -> Unix.file_descr -> 'b) ->
            ('b, string) Stdlib.result
          val open_tmp_fd :
            ?flags:Unix.open_flag list ->
            ?mode:int ->
            ?make_path:bool ->
            ?dir:B0_std.Fpath.t ->
            ?name:B0_std.Os.Path.tmp_name ->
            unit -> (B0_std.Fpath.t * Unix.file_descr, string) Stdlib.result
          val with_tmp_oc :
            ?flags:Unix.open_flag list ->
            ?mode:int ->
            ?make_path:bool ->
            ?dir:B0_std.Fpath.t ->
            ?name:B0_std.Os.Path.tmp_name ->
            (B0_std.Fpath.t -> Stdlib.out_channel -> 'b) ->
            ('b, string) Stdlib.result
        end
      module Dir :
        sig
          val exists : B0_std.Fpath.t -> (bool, string) Stdlib.result
          val must_exist : B0_std.Fpath.t -> (unit, string) Stdlib.result
          val create :
            ?mode:int ->
            make_path:bool -> B0_std.Fpath.t -> (bool, string) Stdlib.result
          val fold :
            ?rel:bool ->
            ?dotfiles:bool ->
            ?follow_symlinks:bool ->
            ?prune:(Unix.stats -> string -> B0_std.Fpath.t -> bool) ->
            recurse:bool ->
            (Unix.stats -> string -> B0_std.Fpath.t -> '-> 'a) ->
            B0_std.Fpath.t -> '-> ('a, string) Stdlib.result
          val fold_files :
            ?rel:bool ->
            ?dotfiles:bool ->
            ?follow_symlinks:bool ->
            ?prune:(Unix.stats -> string -> B0_std.Fpath.t -> bool) ->
            recurse:bool ->
            (Unix.stats -> string -> B0_std.Fpath.t -> '-> 'a) ->
            B0_std.Fpath.t -> '-> ('a, string) Stdlib.result
          val fold_dirs :
            ?rel:bool ->
            ?dotfiles:bool ->
            ?follow_symlinks:bool ->
            ?prune:(Unix.stats -> string -> B0_std.Fpath.t -> bool) ->
            recurse:bool ->
            (Unix.stats -> string -> B0_std.Fpath.t -> '-> 'a) ->
            B0_std.Fpath.t -> '-> ('a, string) Stdlib.result
          val path_list :
            Unix.stats ->
            string ->
            B0_std.Fpath.t -> B0_std.Fpath.t list -> B0_std.Fpath.t list
          val copy :
            ?rel:bool ->
            ?atomic:bool ->
            ?allow_hardlinks:bool ->
            ?follow_symlinks:bool ->
            ?prune:(Unix.stats -> string -> B0_std.Fpath.t -> bool) ->
            make_path:bool ->
            recurse:bool ->
            src:B0_std.Fpath.t ->
            B0_std.Fpath.t -> (unit, string) Stdlib.result
          val cwd : unit -> (B0_std.Fpath.t, string) Stdlib.result
          val set_cwd : B0_std.Fpath.t -> (unit, string) Stdlib.result
          val with_cwd :
            B0_std.Fpath.t -> (unit -> 'a) -> ('a, string) Stdlib.result
          val default_tmp : unit -> B0_std.Fpath.t
          val set_default_tmp : B0_std.Fpath.t -> unit
          val with_tmp :
            ?mode:int ->
            ?make_path:bool ->
            ?dir:B0_std.Fpath.t ->
            ?name:B0_std.Os.Path.tmp_name ->
            (B0_std.Fpath.t -> 'a) -> ('a, string) Stdlib.result
          val tmp :
            ?mode:int ->
            ?make_path:bool ->
            ?dir:B0_std.Fpath.t ->
            ?name:B0_std.Os.Path.tmp_name ->
            unit -> (B0_std.Fpath.t, string) Stdlib.result
          val user : unit -> (B0_std.Fpath.t, string) Stdlib.result
          val config : unit -> (B0_std.Fpath.t, string) Stdlib.result
          val data : unit -> (B0_std.Fpath.t, string) Stdlib.result
          val cache : unit -> (B0_std.Fpath.t, string) Stdlib.result
          val runtime : unit -> (B0_std.Fpath.t, string) Stdlib.result
        end
      module Fd :
        sig
          val unix_buffer_size : int
          val apply :
            close:(Unix.file_descr -> unit) ->
            Unix.file_descr -> (Unix.file_descr -> 'a) -> 'a
          val copy :
            ?buf:Stdlib.Bytes.t ->
            src:Unix.file_descr -> Unix.file_descr -> unit
          val to_string : Unix.file_descr -> string
          val read_file : string -> Unix.file_descr -> string
        end
      module Cmd :
        sig
          val find_tool :
            ?search:B0_std.Fpath.t list ->
            B0_std.Cmd.tool -> (B0_std.Fpath.t option, string) Stdlib.result
          val must_find_tool :
            ?search:B0_std.Fpath.t list ->
            B0_std.Cmd.tool -> (B0_std.Fpath.t, string) Stdlib.result
          val find_first_tool :
            ?search:B0_std.Fpath.t list ->
            B0_std.Cmd.tool list ->
            (B0_std.Fpath.t option, string) Stdlib.result
          val find :
            ?search:B0_std.Fpath.t list ->
            B0_std.Cmd.t -> (B0_std.Cmd.t option, string) Stdlib.result
          val must_find :
            ?search:B0_std.Fpath.t list ->
            B0_std.Cmd.t -> (B0_std.Cmd.t, string) Stdlib.result
          val find_first :
            ?search:B0_std.Fpath.t list ->
            B0_std.Cmd.t list -> (B0_std.Cmd.t option, string) Stdlib.result
          type status = [ `Exited of int | `Signaled of int ]
          val pp_status : B0_std.Os.Cmd.status B0_std.Fmt.t
          val pp_cmd_status :
            (B0_std.Cmd.t * B0_std.Os.Cmd.status) B0_std.Fmt.t
          type stdi
          val in_string : string -> B0_std.Os.Cmd.stdi
          val in_file : B0_std.Fpath.t -> B0_std.Os.Cmd.stdi
          val in_fd : close:bool -> Unix.file_descr -> B0_std.Os.Cmd.stdi
          val in_stdin : B0_std.Os.Cmd.stdi
          val in_null : B0_std.Os.Cmd.stdi
          type stdo
          val out_file : B0_std.Fpath.t -> B0_std.Os.Cmd.stdo
          val out_fd : close:bool -> Unix.file_descr -> B0_std.Os.Cmd.stdo
          val out_stdout : B0_std.Os.Cmd.stdo
          val out_stderr : B0_std.Os.Cmd.stdo
          val out_null : B0_std.Os.Cmd.stdo
          val run_status :
            ?env:B0_std.Os.Env.assignments ->
            ?cwd:B0_std.Fpath.t ->
            ?stdin:B0_std.Os.Cmd.stdi ->
            ?stdout:B0_std.Os.Cmd.stdo ->
            ?stderr:B0_std.Os.Cmd.stdo ->
            B0_std.Cmd.t -> (B0_std.Os.Cmd.status, string) Stdlib.result
          val run_status_out :
            ?env:B0_std.Os.Env.assignments ->
            ?cwd:B0_std.Fpath.t ->
            ?stdin:B0_std.Os.Cmd.stdi ->
            ?stderr:[ `Out | `Stdo of B0_std.Os.Cmd.stdo ] ->
            ?trim:bool ->
            B0_std.Cmd.t ->
            (B0_std.Os.Cmd.status * string, string) Stdlib.result
          val run :
            ?env:B0_std.Os.Env.assignments ->
            ?cwd:B0_std.Fpath.t ->
            ?stdin:B0_std.Os.Cmd.stdi ->
            ?stdout:B0_std.Os.Cmd.stdo ->
            ?stderr:B0_std.Os.Cmd.stdo ->
            B0_std.Cmd.t -> (unit, string) Stdlib.result
          val run_out :
            ?env:B0_std.Os.Env.assignments ->
            ?cwd:B0_std.Fpath.t ->
            ?stdin:B0_std.Os.Cmd.stdi ->
            ?stderr:[ `Out | `Stdo of B0_std.Os.Cmd.stdo ] ->
            ?trim:bool -> B0_std.Cmd.t -> (string, string) Stdlib.result
          type pid
          val pid_to_int : B0_std.Os.Cmd.pid -> int
          val spawn :
            ?env:B0_std.Os.Env.assignments ->
            ?cwd:B0_std.Fpath.t ->
            ?stdin:B0_std.Os.Cmd.stdi ->
            ?stdout:B0_std.Os.Cmd.stdo ->
            ?stderr:B0_std.Os.Cmd.stdo ->
            B0_std.Cmd.t -> (B0_std.Os.Cmd.pid, string) Stdlib.result
          val spawn_poll_status :
            B0_std.Os.Cmd.pid ->
            (B0_std.Os.Cmd.status option, string) Stdlib.result
          val spawn_wait_status :
            B0_std.Os.Cmd.pid -> (B0_std.Os.Cmd.status, string) Stdlib.result
          type spawn_tracer =
              B0_std.Os.Cmd.pid ->
              B0_std.Os.Env.assignments option ->
              cwd:B0_std.Fpath.t option -> B0_std.Cmd.t -> unit
          val spawn_tracer_nop : B0_std.Os.Cmd.spawn_tracer
          val spawn_tracer : unit -> B0_std.Os.Cmd.spawn_tracer
          val set_spawn_tracer : B0_std.Os.Cmd.spawn_tracer -> unit
          val execv :
            ?env:B0_std.Os.Env.assignments ->
            ?cwd:B0_std.Fpath.t ->
            B0_std.Fpath.t -> B0_std.Cmd.t -> (unit, string) Stdlib.result
        end
    end
  module Log :
    sig
      type level = Quiet | App | Error | Warning | Info | Debug
      val level : unit -> B0_std.Log.level
      val set_level : B0_std.Log.level -> unit
      val pp_level : B0_std.Log.level B0_std.Fmt.t
      val level_to_string : B0_std.Log.level -> string
      val level_of_string :
        string -> (B0_std.Log.level, string) Stdlib.Pervasives.result
      type ('a, 'b) msgf =
          (?header:string ->
           ('a, Stdlib.Format.formatter, unit, 'b) Stdlib.format4 -> 'a) ->
          'b
      type 'a log = ('a, unit) B0_std.Log.msgf -> unit
      val msg : B0_std.Log.level -> 'B0_std.Log.log
      val quiet : 'B0_std.Log.log
      val app : 'B0_std.Log.log
      val err : 'B0_std.Log.log
      val warn : 'B0_std.Log.log
      val info : 'B0_std.Log.log
      val debug : 'B0_std.Log.log
      val kmsg :
        (unit -> 'b) -> B0_std.Log.level -> ('a, 'b) B0_std.Log.msgf -> 'b
      val if_error :
        ?level:B0_std.Log.level ->
        ?header:string ->
        use:'-> ('a, string) Stdlib.Pervasives.result -> 'a
      val warn_if_error :
        ?header:string ->
        use:'-> ('a, string) Stdlib.Pervasives.result -> 'a
      val if_error_pp :
        ?level:B0_std.Log.level ->
        ?header:string ->
        'B0_std.Fmt.t -> use:'-> ('a, 'b) Stdlib.Pervasives.result -> 'a
      val time :
        ?level:B0_std.Log.level ->
        ('->
         (('b, Stdlib.Format.formatter, unit, 'a) Stdlib.format4 -> 'b) -> 'a) ->
        (unit -> 'a) -> 'a
      val err_count : unit -> int
      val warn_count : unit -> int
      type kmsg = {
        kmsg :
          ''b.
            (unit -> 'b) ->
            B0_std.Log.level -> ('a, 'b) B0_std.Log.msgf -> 'b;
      }
      val kmsg_nop : B0_std.Log.kmsg
      val kmsg_default : B0_std.Log.kmsg
      val set_kmsg : B0_std.Log.kmsg -> unit
    end
end