Starting process from UI - local variables vs rule inputs

Hi,

I have the following situation:

- one interface that is embedded inside the other larger interface

- first interface has non submit button that starts process upon click

- first interface has 4 rule inputs that are used as parameters for starting the process

- these 4 rule inputs are calculated also on the button click, just before sending them to process as parameters

Behavior on test:

- if I test this interface "manually" from designer, process is successfully started and all the parameters are passed to the process

- if I test this interface through the process which contains its "parent" interface, parameters are not forwarded

So, this code for the first interface doesn't work:

a!localVariables(
...
    a!buttonLayout(
        primaryButtons: {
            a!buttonWidget(
                label: "Start process",
                saveInto: {
                  a!save(
                    ri!firstProc_cdt,
                    rule!DLS_mapFirstProcParam(
                      input: local!valuesOne
                    )
                  ),
                  a!save(
                    ri!secondProc_cdt,
                    rule!DLS_mapSecondProcParam(
                      input: local!valuesTwo
                    )
                  ),
                  a!save(
                    ri!thirdProc_cdt,
                    rule!DLS_mapThirdProcParam(
                      input: local!valuesThree
                    )
                  ),
                  a!save(
                    ri!fourthProc_cdt,
                    rule!DLS_mapFourthProcParam(
                      input: local!valuesFour
                    )
                  ),
                  a!startProcess(
                    processModel: cons!PROCESS,
                    processParameters: {
                      paramOne: ri!firstProc_cdt,
                      paramTwo: ri!secondProc_cdt,
                      paramThree: ri!thirdProc_cdt,
                      paramFour: ri!fourthProc_cdt
                    }
                  )
                }

and this one does work:

a!localVariables(
local!firstParam,
local!secondParam,
local!thirdParam,
local!fourthParam,
...
    a!buttonLayout(
        primaryButtons: {
            a!buttonWidget(
                label: "Start process",
                saveInto: {
                  a!save(
                    local!firstParam,
                    rule!DLS_mapFirstProcParam(
                      input: local!valuesOne
                    )
                  ),
                  a!save(
                    local!secondParam,
                    rule!DLS_mapSecondProcParam(
                      input: local!valuesTwo
                    )
                  ),
                  a!save(
                    local!thirdParam,
                    rule!DLS_mapThirdProcParam(
                      input: local!valuesThree
                    )
                  ),
                  a!save(
                    local!fourthParam,
                    rule!DLS_mapFourthProcParam(
                      input: local!valuesFour
                    )
                  ),
                  a!startProcess(
                    processModel: cons!PROCESS,
                    processParameters: {
                      paramOne: local!firstParam,
                      paramTwo: local!secondParam,
                      paramThree: local!thirdParam,
                      paramFour: local!fourthParam
                    }
                  )
                }

Basically, only difference is that in the first example rule inputs of the interface are used as input parameters for process model. In the second one there are no rule inputs, only local variables. They have the same content since expression rules for mapping create the same data type as the rule inputs.

Can someone explain to me why parameters were null in process instance monitoring in the case when rule inputs are used. Are rule inputs "evaluated" at some other point in time than local variables when interface is used as component of larger interface and inside the process model?