Resolving Hex dependencies...
Resolution completed in 0.064s
Unchanged:
  castore 1.0.18
  circular_buffer 1.0.0
  elixir_make 0.9.0
  espex 0.1.1
  interactive_cmd 0.1.3
  jason 1.4.4
  nerves 1.13.2
  nerves_discovery 0.1.2
  nerves_logging 0.2.4
  nerves_runtime 0.13.12
  nerves_system_bbb 2.29.3
  nerves_system_br 1.33.5
  nerves_system_grisp2 0.17.3
  nerves_system_mangopi_mq_pro 0.15.3
  nerves_system_osd32mp1 0.24.3
  nerves_system_qemu_aarch64 0.3.3
  nerves_system_rpi 2.0.2
  nerves_system_rpi0 2.0.2
  nerves_system_rpi0_2 2.0.2
  nerves_system_rpi2 2.0.2
  nerves_system_rpi3 2.0.2
  nerves_system_rpi4 2.0.2
  nerves_system_rpi5 2.0.2
  nerves_system_x86_64 1.33.3
  nerves_toolchain_aarch64_nerves_linux_gnu 13.2.0
  nerves_toolchain_armv6_nerves_linux_gnueabihf 13.2.0
  nerves_toolchain_armv7_nerves_linux_gnueabihf 13.2.0
  nerves_toolchain_ctng 1.10.0
  nerves_toolchain_riscv64_nerves_linux_gnu 13.2.0
  nerves_toolchain_x86_64_nerves_linux_musl 13.2.0
  nerves_uevent 0.1.3
  property_table 0.3.3
  protobuf 0.16.0
  protobuf_generate 0.2.0
  ring_logger 0.11.5
  shoehorn 0.9.3
  tablet 0.3.2
  telemetry 1.4.1
  thousand_island 1.4.3
  toolshed 0.4.2
  uboot_env 1.0.2
All dependencies have been fetched
==> circular_buffer
Compiling 1 file (.ex)
Generated circular_buffer app
==> jason
Compiling 10 files (.ex)
Generated jason app
==> tablet
Compiling 2 files (.ex)
Generated tablet app
==> protobuf
Compiling 46 files (.ex)
    warning: a struct for Protobuf.Protoc.Context is expected on struct update:

        %Protobuf.Protoc.Context{
          ctx
          | comments: Protobuf.Protoc.Generator.Comment.parse(desc),
            syntax: syntax(desc.syntax),
            package: desc.package,
            dep_type_mapping: get_dep_type_mapping(ctx, desc.dependency, desc.name)
        }

    but got type:

        dynamic()

    where "ctx" was given the type:

        # type: dynamic()
        # from: lib/protobuf/protoc/generator.ex:35:36
        ctx

    when defining the variable "ctx", you must also pattern match on "%Protobuf.Protoc.Context{}".

    hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of:

        user = some_function()
        %User{user | name: "John Doe"}

    it is enough to write:

        %User{} = user = some_function()
        %{user | name: "John Doe"}

    typing violation found at:
    │
 37 │       %Context{
    │       ~
    │
    └─ lib/protobuf/protoc/generator.ex:37:7: Protobuf.Protoc.Generator.generate_module_definitions/2

    warning: a struct for Protobuf.Protoc.Context is expected on struct update:

        %Protobuf.Protoc.Context{
          Protobuf.Protoc.Context.append_comment_path(ctx, <<"6.", to_string(index)::binary>>)
          | namespace: ctx.namespace ++ [Macro.camelize(desc.name)]
        }

    but got type:

        dynamic(%{..., current_comment_path: term()})

    where "ctx" was given the type:

        # type: dynamic(%Protobuf.Protoc.Context{})
        # from: lib/protobuf/protoc/generator/extension.ex:84:48
        %Protobuf.Protoc.Context{} = ctx

    where "index" was given the type:

        # type: dynamic()
        # from: lib/protobuf/protoc/generator/extension.ex
        {desc, index}

    you must assign "Protobuf.Protoc.Context.append_comment_path(ctx, <<"6.", String.Chars.to_string(index)::binary>>)" to variable and pattern match on "%Protobuf.Protoc.Context{}".

    hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of:

        user = some_function()
        %User{user | name: "John Doe"}

    it is enough to write:

        %User{} = user = some_function()
        %{user | name: "John Doe"}

    typing violation found at:
    │
 90 │           %Context{
    │           ~
    │
    └─ lib/protobuf/protoc/generator/extension.ex:90:11: Protobuf.Protoc.Generator.Extension.get_extensions_from_messages/3

     warning: a struct for Protobuf.Protoc.Context is expected on struct update:

         %Protobuf.Protoc.Context{ctx | plugins: String.split(plugins, "+")}

     but got type:

         dynamic()

     where "ctx" was given the type:

         # type: dynamic()
         # from: lib/protobuf/protoc/cli.ex:105:43
         ctx

     when defining the variable "ctx", you must also pattern match on "%Protobuf.Protoc.Context{}".

     hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of:

         user = some_function()
         %User{user | name: "John Doe"}

     it is enough to write:

         %User{} = user = some_function()
         %{user | name: "John Doe"}

     typing violation found at:
     │
 106 │     %Context{ctx | plugins: String.split(plugins, "+")}
     │     ~
     │
     └─ lib/protobuf/protoc/cli.ex:106:5: Protobuf.Protoc.CLI.parse_param/2

     warning: a struct for Protobuf.Protoc.Context is expected on struct update:

         %Protobuf.Protoc.Context{ctx | gen_descriptors?: true}

     but got type:

         dynamic()

     where "ctx" was given the type:

         # type: dynamic()
         # from: lib/protobuf/protoc/cli.ex:109:49
         ctx

     when defining the variable "ctx", you must also pattern match on "%Protobuf.Protoc.Context{}".

     hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of:

         user = some_function()
         %User{user | name: "John Doe"}

     it is enough to write:

         %User{} = user = some_function()
         %{user | name: "John Doe"}

     typing violation found at:
     │
 112 │         %Context{ctx | gen_descriptors?: true}
     │         ~
     │
     └─ lib/protobuf/protoc/cli.ex:112:9: Protobuf.Protoc.CLI.parse_param/2

     warning: a struct for Protobuf.Protoc.Context is expected on struct update:

         %Protobuf.Protoc.Context{ctx | package_prefix: package}

     but got type:

         dynamic()

     where "ctx" was given the type:

         # type: dynamic()
         # from: lib/protobuf/protoc/cli.ex:119:50
         ctx

     when defining the variable "ctx", you must also pattern match on "%Protobuf.Protoc.Context{}".

     hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of:

         user = some_function()
         %User{user | name: "John Doe"}

     it is enough to write:

         %User{} = user = some_function()
         %{user | name: "John Doe"}

     typing violation found at:
     │
 123 │       %Context{ctx | package_prefix: package}
     │       ~
     │
     └─ lib/protobuf/protoc/cli.ex:123:7: Protobuf.Protoc.CLI.parse_param/2

     warning: a struct for Protobuf.Protoc.Context is expected on struct update:

         %Protobuf.Protoc.Context{ctx | transform_module: Module.concat([module])}

     but got type:

         dynamic()

     where "ctx" was given the type:

         # type: dynamic()
         # from: lib/protobuf/protoc/cli.ex:127:51
         ctx

     when defining the variable "ctx", you must also pattern match on "%Protobuf.Protoc.Context{}".

     hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of:

         user = some_function()
         %User{user | name: "John Doe"}

     it is enough to write:

         %User{} = user = some_function()
         %{user | name: "John Doe"}

     typing violation found at:
     │
 128 │     %Context{ctx | transform_module: Module.concat([module])}
     │     ~
     │
     └─ lib/protobuf/protoc/cli.ex:128:5: Protobuf.Protoc.CLI.parse_param/2

     warning: a struct for Protobuf.Protoc.Context is expected on struct update:

         %Protobuf.Protoc.Context{ctx | one_file_per_module?: true}

     but got type:

         dynamic()

     where "ctx" was given the type:

         # type: dynamic()
         # from: lib/protobuf/protoc/cli.ex:131:53
         ctx

     when defining the variable "ctx", you must also pattern match on "%Protobuf.Protoc.Context{}".

     hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of:

         user = some_function()
         %User{user | name: "John Doe"}

     it is enough to write:

         %User{} = user = some_function()
         %{user | name: "John Doe"}

     typing violation found at:
     │
 134 │         %Context{ctx | one_file_per_module?: true}
     │         ~
     │
     └─ lib/protobuf/protoc/cli.ex:134:9: Protobuf.Protoc.CLI.parse_param/2

     warning: a struct for Protobuf.Protoc.Context is expected on struct update:

         %Protobuf.Protoc.Context{ctx | include_docs?: true}

     but got type:

         dynamic()

     where "ctx" was given the type:

         # type: dynamic()
         # from: lib/protobuf/protoc/cli.ex:141:46
         ctx

     when defining the variable "ctx", you must also pattern match on "%Protobuf.Protoc.Context{}".

     hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of:

         user = some_function()
         %User{user | name: "John Doe"}

     it is enough to write:

         %User{} = user = some_function()
         %{user | name: "John Doe"}

     typing violation found at:
     │
 144 │         %Context{ctx | include_docs?: true}
     │         ~
     │
     └─ lib/protobuf/protoc/cli.ex:144:9: Protobuf.Protoc.CLI.parse_param/2

     warning: a struct for Protobuf.FieldProps is expected on struct update:

         %Protobuf.FieldProps{acc | optional?: optional?}

     but got type:

         dynamic()

     where "acc" was given the type:

         # type: dynamic()
         # from: lib/protobuf/dsl.ex:328:31
         acc

     when defining the variable "acc", you must also pattern match on "%Protobuf.FieldProps{}".

     hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of:

         user = some_function()
         %User{user | name: "John Doe"}

     it is enough to write:

         %User{} = user = some_function()
         %{user | name: "John Doe"}

     typing violation found at:
     │
 329 │         %FieldProps{acc | optional?: optional?}
     │         ~
     │
     └─ lib/protobuf/dsl.ex:329:9: Protobuf.DSL.parse_field_opts_to_field_props/2

     warning: a struct for Protobuf.FieldProps is expected on struct update:

         %Protobuf.FieldProps{acc | proto3_optional?: proto3_optional?}

     but got type:

         dynamic()

     where "acc" was given the type:

         # type: dynamic()
         # from: lib/protobuf/dsl.ex:331:45
         acc

     when defining the variable "acc", you must also pattern match on "%Protobuf.FieldProps{}".

     hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of:

         user = some_function()
         %User{user | name: "John Doe"}

     it is enough to write:

         %User{} = user = some_function()
         %{user | name: "John Doe"}

     typing violation found at:
     │
 332 │         %FieldProps{acc | proto3_optional?: proto3_optional?}
     │         ~
     │
     └─ lib/protobuf/dsl.ex:332:9: Protobuf.DSL.parse_field_opts_to_field_props/2

     warning: a struct for Protobuf.FieldProps is expected on struct update:

         %Protobuf.FieldProps{acc | required?: required?}

     but got type:

         dynamic()

     where "acc" was given the type:

         # type: dynamic()
         # from: lib/protobuf/dsl.ex:334:31
         acc

     when defining the variable "acc", you must also pattern match on "%Protobuf.FieldProps{}".

     hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of:

         user = some_function()
         %User{user | name: "John Doe"}

     it is enough to write:

         %User{} = user = some_function()
         %{user | name: "John Doe"}

     typing violation found at:
     │
 335 │         %FieldProps{acc | required?: required?}
     │         ~
     │
     └─ lib/protobuf/dsl.ex:335:9: Protobuf.DSL.parse_field_opts_to_field_props/2

     warning: a struct for Protobuf.FieldProps is expected on struct update:

         %Protobuf.FieldProps{acc | enum?: enum?}

     but got type:

         dynamic()

     where "acc" was given the type:

         # type: dynamic()
         # from: lib/protobuf/dsl.ex:337:23
         acc

     when defining the variable "acc", you must also pattern match on "%Protobuf.FieldProps{}".

     hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of:

         user = some_function()
         %User{user | name: "John Doe"}

     it is enough to write:

         %User{} = user = some_function()
         %{user | name: "John Doe"}

     typing violation found at:
     │
 338 │         %FieldProps{acc | enum?: enum?}
     │         ~
     │
     └─ lib/protobuf/dsl.ex:338:9: Protobuf.DSL.parse_field_opts_to_field_props/2

     warning: a struct for Protobuf.FieldProps is expected on struct update:

         %Protobuf.FieldProps{acc | map?: map?}

     but got type:

         dynamic()

     where "acc" was given the type:

         # type: dynamic()
         # from: lib/protobuf/dsl.ex:340:21
         acc

     when defining the variable "acc", you must also pattern match on "%Protobuf.FieldProps{}".

     hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of:

         user = some_function()
         %User{user | name: "John Doe"}

     it is enough to write:

         %User{} = user = some_function()
         %{user | name: "John Doe"}

     typing violation found at:
     │
 341 │         %FieldProps{acc | map?: map?}
     │         ~
     │
     └─ lib/protobuf/dsl.ex:341:9: Protobuf.DSL.parse_field_opts_to_field_props/2

     warning: a struct for Protobuf.FieldProps is expected on struct update:

         %Protobuf.FieldProps{acc | repeated?: repeated?}

     but got type:

         dynamic()

     where "acc" was given the type:

         # type: dynamic()
         # from: lib/protobuf/dsl.ex:343:31
         acc

     when defining the variable "acc", you must also pattern match on "%Protobuf.FieldProps{}".

     hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of:

         user = some_function()
         %User{user | name: "John Doe"}

     it is enough to write:

         %User{} = user = some_function()
         %{user | name: "John Doe"}

     typing violation found at:
     │
 344 │         %FieldProps{acc | repeated?: repeated?}
     │         ~
     │
     └─ lib/protobuf/dsl.ex:344:9: Protobuf.DSL.parse_field_opts_to_field_props/2

     warning: a struct for Protobuf.FieldProps is expected on struct update:

         %Protobuf.FieldProps{acc | embedded?: embedded}

     but got type:

         dynamic()

     where "acc" was given the type:

         # type: dynamic()
         # from: lib/protobuf/dsl.ex:346:30
         acc

     when defining the variable "acc", you must also pattern match on "%Protobuf.FieldProps{}".

     hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of:

         user = some_function()
         %User{user | name: "John Doe"}

     it is enough to write:

         %User{} = user = some_function()
         %{user | name: "John Doe"}

     typing violation found at:
     │
 347 │         %FieldProps{acc | embedded?: embedded}
     │         ~
     │
     └─ lib/protobuf/dsl.ex:347:9: Protobuf.DSL.parse_field_opts_to_field_props/2

     warning: a struct for Protobuf.FieldProps is expected on struct update:

         %Protobuf.FieldProps{acc | deprecated?: deprecated?}

     but got type:

         dynamic()

     where "acc" was given the type:

         # type: dynamic()
         # from: lib/protobuf/dsl.ex:349:35
         acc

     when defining the variable "acc", you must also pattern match on "%Protobuf.FieldProps{}".

     hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of:

         user = some_function()
         %User{user | name: "John Doe"}

     it is enough to write:

         %User{} = user = some_function()
         %{user | name: "John Doe"}

     typing violation found at:
     │
 350 │         %FieldProps{acc | deprecated?: deprecated?}
     │         ~
     │
     └─ lib/protobuf/dsl.ex:350:9: Protobuf.DSL.parse_field_opts_to_field_props/2

     warning: a struct for Protobuf.FieldProps is expected on struct update:

         %Protobuf.FieldProps{acc | packed?: packed?}

     but got type:

         dynamic()

     where "acc" was given the type:

         # type: dynamic()
         # from: lib/protobuf/dsl.ex:352:27
         acc

     when defining the variable "acc", you must also pattern match on "%Protobuf.FieldProps{}".

     hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of:

         user = some_function()
         %User{user | name: "John Doe"}

     it is enough to write:

         %User{} = user = some_function()
         %{user | name: "John Doe"}

     typing violation found at:
     │
 353 │         %FieldProps{acc | packed?: packed?}
     │         ~
     │
     └─ lib/protobuf/dsl.ex:353:9: Protobuf.DSL.parse_field_opts_to_field_props/2

     warning: a struct for Protobuf.FieldProps is expected on struct update:

         %Protobuf.FieldProps{acc | type: type}

     but got type:

         dynamic()

     where "acc" was given the type:

         # type: dynamic()
         # from: lib/protobuf/dsl.ex:355:22
         acc

     when defining the variable "acc", you must also pattern match on "%Protobuf.FieldProps{}".

     hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of:

         user = some_function()
         %User{user | name: "John Doe"}

     it is enough to write:

         %User{} = user = some_function()
         %{user | name: "John Doe"}

     typing violation found at:
     │
 356 │         %FieldProps{acc | type: type}
     │         ~
     │
     └─ lib/protobuf/dsl.ex:356:9: Protobuf.DSL.parse_field_opts_to_field_props/2

     warning: a struct for Protobuf.FieldProps is expected on struct update:

         %Protobuf.FieldProps{acc | default: default}

     but got type:

         dynamic()

     where "acc" was given the type:

         # type: dynamic()
         # from: lib/protobuf/dsl.ex:358:28
         acc

     when defining the variable "acc", you must also pattern match on "%Protobuf.FieldProps{}".

     hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of:

         user = some_function()
         %User{user | name: "John Doe"}

     it is enough to write:

         %User{} = user = some_function()
         %{user | name: "John Doe"}

     typing violation found at:
     │
 359 │         %FieldProps{acc | default: default}
     │         ~
     │
     └─ lib/protobuf/dsl.ex:359:9: Protobuf.DSL.parse_field_opts_to_field_props/2

     warning: a struct for Protobuf.FieldProps is expected on struct update:

         %Protobuf.FieldProps{acc | oneof: oneof}

     but got type:

         dynamic()

     where "acc" was given the type:

         # type: dynamic()
         # from: lib/protobuf/dsl.ex:361:24
         acc

     when defining the variable "acc", you must also pattern match on "%Protobuf.FieldProps{}".

     hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of:

         user = some_function()
         %User{user | name: "John Doe"}

     it is enough to write:

         %User{} = user = some_function()
         %{user | name: "John Doe"}

     typing violation found at:
     │
 362 │         %FieldProps{acc | oneof: oneof}
     │         ~
     │
     └─ lib/protobuf/dsl.ex:362:9: Protobuf.DSL.parse_field_opts_to_field_props/2

     warning: a struct for Protobuf.FieldProps is expected on struct update:

         %Protobuf.FieldProps{acc | json_name: json_name}

     but got type:

         dynamic()

     where "acc" was given the type:

         # type: dynamic()
         # from: lib/protobuf/dsl.ex:364:32
         acc

     when defining the variable "acc", you must also pattern match on "%Protobuf.FieldProps{}".

     hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of:

         user = some_function()
         %User{user | name: "John Doe"}

     it is enough to write:

         %User{} = user = some_function()
         %{user | name: "John Doe"}

     typing violation found at:
     │
 365 │         %FieldProps{acc | json_name: json_name}
     │         ~
     │
     └─ lib/protobuf/dsl.ex:365:9: Protobuf.DSL.parse_field_opts_to_field_props/2

     warning: a struct for Protobuf.FieldProps is expected on struct update:

         %Protobuf.FieldProps{props | json_name: props.name}

     but got type:

         dynamic()

     where "props" was given the type:

         # type: dynamic()
         # from: lib/protobuf/dsl.ex:390:22
         props

     when defining the variable "props", you must also pattern match on "%Protobuf.FieldProps{}".

     hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of:

         user = some_function()
         %User{user | name: "John Doe"}

     it is enough to write:

         %User{} = user = some_function()
         %{user | name: "John Doe"}

     typing violation found at:
     │
 390 │   defp cal_json_name(props), do: %FieldProps{props | json_name: props.name}
     │                                  ~
     │
     └─ lib/protobuf/dsl.ex:390:34: Protobuf.DSL.cal_json_name/1

     warning: a struct for Protobuf.FieldProps is expected on struct update:

         %Protobuf.FieldProps{props | packed?: false}

     but got type:

         dynamic()

     where "props" was given the type:

         # type: dynamic()
         # from: lib/protobuf/dsl.ex:426:19
         props

     when defining the variable "props", you must also pattern match on "%Protobuf.FieldProps{}".

     hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of:

         user = some_function()
         %User{user | name: "John Doe"}

     it is enough to write:

         %User{} = user = some_function()
         %{user | name: "John Doe"}

     typing violation found at:
     │
 426 │   defp cal_packed(props, _syntax), do: %FieldProps{props | packed?: false}
     │                                        ~
     │
     └─ lib/protobuf/dsl.ex:426:40: Protobuf.DSL.cal_packed/2

Generated protobuf app
==> elixir_make
Compiling 8 files (.ex)
Generated elixir_make app
==> nerves_logging
 CC kmsg_tailer.o
 LD kmsg_tailer
Not crosscompiling. To test locally, the port binary needs extra permissions.
Set SUDO=sudo to set permissions. The default is to skip this step.
SUDO_ASKPASS=/usr/bin/ssh-askpass
SUDO=true
Compiling 5 files (.ex)
Generated nerves_logging app
==> castore
Compiling 1 file (.ex)
Generated castore app
==> nerves_discovery
Compiling 5 files (.ex)
Generated nerves_discovery app
==> ring_logger
Compiling 7 files (.ex)
Generated ring_logger app
==> shoehorn
Compiling 8 files (.ex)
Generated shoehorn app
==> interactive_cmd
Compiling 1 file (.ex)
Generated interactive_cmd app
==> nerves
HOST_CC port.o
HOST_LD port
Compiling 52 files (.ex)
Generated nerves app
==> nerves_compatibility_test
===> Analyzing applications...
===> Compiling telemetry
==> thousand_island
Compiling 18 files (.ex)
Generated thousand_island app
==> protobuf_generate
Compiling 9 files (.ex)
Generated protobuf_generate app
==> espex
Compiling 24 files (.ex)
Generated espex app
==> uboot_env
Compiling 5 files (.ex)
Generated uboot_env app
==> property_table
Compiling 8 files (.ex)
Generated property_table app
==> nerves_uevent
 CC uevent.o
 LD uevent
Not crosscompiling. To test locally, the port binary needs extra permissions.
Set SUDO=sudo to set permissions. The default is to skip this step.
SUDO_ASKPASS=/usr/bin/ssh-askpass
SUDO=true
Compiling 3 files (.ex)
Generated nerves_uevent app
==> nerves_runtime
Compiling 14 files (.ex)
Generated nerves_runtime app
==> toolshed
Compiling 5 files (.ex)
Generated toolshed app
==> nerves_compatibility_test

Nerves environment
  MIX_TARGET:   host
  MIX_ENV:      prod

Checking for prebuilt Nerves artifacts...
Compiling 2 files (.ex)
Generated nerves_compatibility_test app