To what session state does the script block in [scriptblock]::Create().GetSteppablePipeline() get bound?

TL;DR

None of the testing described below suggests anything unusual about the binding of the ScriptBlock in [scriptblock]::Create().GetSteppablePipeline(): It seems to behave as though it were bound to the same SessionState as the command whose whose reference is passed to the SteppablePipeline methods. In fact, Set-Variable works exactly as expected for local variables that aren't in param().

Script block binding doesn't seem to explain why param() variables aren't visible to descendant scopes.

Direct Observation of ScriptBlock.SessionStateInternal

Consider the script binding.ps1 in this reference code which creates and invokes script block $sb using the methods

# call
& $sb

# steppable
. {
    [CmdletBinding()]param()
    $pipe = $sb.GetSteppablePipeline($MyInvocation.CommandOrigin,@())
    $pipe.Begin($PSCmdlet)
    $pipe.End()
}

and extracts SessionStateInternal from each script block before and after invokation using the function getSessionState. That script produces the following results:

method    provenance              same before after
------    ----------              ---- ------ -----
call      {}                      True yes    yes
call      [scriptblock]::Create()
call      {}.Ast.GetScriptBlock()
steppable {}                      True yes    yes
steppable [scriptblock]::Create()
steppable {}.Ast.GetScriptBlock()

same in the table represents a reference-equality check of the before and after SessionStateInternal.

So SteppablePipeline does not seem to alter SessionStateInternal of the script block from which it is derived.

SessionStateInternal of Nested ScriptBlock

By the same the principle as the previous section the script block

([scriptblock]::Create({ . { getSessionState {} }}))

invoked using SteppablePipeline reveals SessionStateInternal for the nested {}. The script steppableSessionState.ps1 in the reference code, does that and compares that SessionStateInternal instance with others that are easily obtained. The instance of SessionStateInternal from the above line invoked with SteppablePipeline matches others according to the following table:

So far none of these results suggest anything unusual about the binding of the ScriptBlock in [scriptblock]::Create().GetSteppablePipeline(): It seems to behave as though it were bound to the same SessionState as the command whose whose reference is passed to the SteppablePipeline methods.

Set-Variable

If there is a session state associated with the ScriptBlock in [scriptblock]::Create().GetSteppablePipeline(), then it should be possible to set a variable there and that variable should be visible from descendent scopes. Indeed, the code

$invoke = {
    [CmdletBinding()]param(
        $SubjectScriptBlock
    )
    $pipe = $SubjectScriptBlock.GetSteppablePipeline($MyInvocation.CommandOrigin,@())
    $pipe.Begin($PSCmdlet)
    $pipe.End()
}

. $invoke { . { begin { Set-Variable y why} } | & { $y }}

outputs why. So there is a SessionState that behave as normal with respect to setting local variables. But the very similar

$invoke = {
    [CmdletBinding()]param(
        $SubjectScriptBlock,
        $a
    )
    $pipe = $SubjectScriptBlock.GetSteppablePipeline($MyInvocation.CommandOrigin,@($a))
    $pipe.Begin($PSCmdlet)
    $pipe.End()
}

. $invoke { param($__a) & { $__a }} -a aye

outputs nothing. None of the above seems to account for that difference.