Invoke a pipelined command in a new runspace using the same thread

[MatejKafka]

I'm writing a C# cmdlet, lets call it Invoke-InRunspace, which invokes a command in a new runspace, to get a clean session state with no custom modules, variables,... However, I'd like to

1. support pipelining, so 1,2,3 | Invoke-InRunspace | ... works as if the command inside the new runspace was called directly,
2. run in the original thread (without creating a new thread just for the runspace invocation).

I believed I could do the following (just a PoC, there's missing error handling, disposal,...):

[Cmdlet(VerbsLifecycle.Invoke, "InRunspace")]
public class InvokeInRunspaceCommand : PSCmdlet {
    private readonly PowerShell _ps = PowerShell.Create();
    private readonly PSDataCollection<PSObject> _inputCollection = new();
    private readonly PSDataCollection<PSObject> _outputCollection = new();

    [Parameter(Mandatory = true, ValueFromPipeline = true)]
    public PSObject? InputObject;

    protected override void BeginProcessing() {
        base.BeginProcessing();

        var iss = InitialSessionState.CreateDefault2();
        iss.ThreadOptions = PSThreadOptions.UseCurrentThread;
        var runspace = RunspaceFactory.CreateRunspace(Host, iss);
        runspace.Open();

        _outputCollection.DataAdded += delegate {
            foreach (var o in _outputCollection.ReadAll()) {
                WriteObject(o);
            }
        };

        _ps.Runspace = runspace;
        // example command
        _ps.AddCommand("Where-Object").AddArgument(ScriptBlock.Create("$_ -ge 2"));
        _ps.Invoke(_inputCollection, _outputCollection, new PSInvocationSettings());
    }

    protected override void ProcessRecord() {
        base.ProcessRecord();
        _inputCollection.Add(InputObject!);
    }

    protected override void EndProcessing() {
        base.EndProcessing();
        _inputCollection.Complete();
    }

    protected override void StopProcessing() {
        base.StopProcessing();
        _ps.Stop();
    }
}

I expected this to work ok – the runspace would initialize the Where-Object command, add event for items added to _inputCollection, return control back to the main runspace, which would call ProcessRecord, which would cause the command inside to process the input,...

However, this deadlocks, because apparently implementation of Invoke instead starts a blocking wait on the collection, thus never returning control back to the main instance. The output works correctly without deadlocking, it's just the input that's causing the deadlock.

Is there a way to implement this, or do I have to pick between accepting pipeline input and running in a single thread?