For a compiled Cmdlet, how can I output each object immediately from an invoked scriptblock?

You're essentially asking for what's known as streaming, if you're invoking the scriptblock synchronously it isn't very hard to implement, you will need to subscribe to the DataAdding event from each of the PowerShell.Streams and pass-in your output (success) stream as the as the TOutput.

NOTE

• This example only shows how to set Success and Verbose output, the rest of streams still need to be set. If you need an example on how to set up the rest look here: PSOutputStreams.cs#L38-L60, here: PSOutputData.cs#L16-L38 and here: InvokeParallelCommand.cs#L138-L173.
• This code will not compile ad-hoc with Add-Type in Windows PowerShell 5.1, you will need to make it C# 5 compatible or precompile it.

using System.Threading;
using System.Management.Automation;
using System;

[Cmdlet(VerbsLifecycle.Invoke, "SomeScriptBlockThing")]
public sealed class InvokeSomeScriptBlockThing : PSCmdlet, IDisposable
{
    private readonly CancellationTokenSource _src = new();

    [Parameter(Mandatory = true, Position = 0)]
    public ScriptBlock ScriptBlock { get; set; }

    protected override void EndProcessing()
    {
        using PSDataCollection<PSObject> output = [];
        using PowerShell ps = PowerShell
            .Create(RunspaceMode.CurrentRunspace)
            .AddScript(ScriptBlock.ToString(), useLocalScope: true)
            .AddArgument(_src.Token);

        ps.Streams.Verbose.DataAdding += (s, e) => WriteVerbose(((VerboseRecord)e.ItemAdded).Message);
        output.DataAdding += (s, e) => WriteObject(e.ItemAdded);
        ps.Invoke(null, output); // hook output and null input
    }

    protected override void StopProcessing() => _src.Cancel();

    public void Dispose()
    {
        _src.Dispose();
        GC.SuppressFinalize(this);
    }
}

There is another much easier option to make a binary cmdlet that can stream output when invoking a scriptblock synchronously, that is using a SteppablePipeline as iRon points out in his comment.

using System;
using System.Management.Automation;
using System.Threading;

[Cmdlet(VerbsLifecycle.Invoke, "SomeScriptBlockThing")]
public sealed class InvokeSomeScriptBlockThing : PSCmdlet, IDisposable
{
    private SteppablePipeline _pipe;

    private readonly CancellationTokenSource _src = new CancellationTokenSource();

    [Parameter(ValueFromPipeline = true)]
    public object InputObject { get; set; }

    [Parameter(Mandatory = true, Position = 0)]
    public ScriptBlock ScriptBlock { get; set; }

    [Parameter]
    public SwitchParameter UseLocalScope { get; set; }

    protected override void BeginProcessing()
    {
        _pipe = ScriptBlock
            .Create(
                string.Format(
                    "param($__sb, $__token) {0} $__sb $__token",
                    UseLocalScope.IsPresent ? "." : "&"))
            .GetSteppablePipeline(
                CommandOrigin.Internal,
                new object[] { ScriptBlock, _src.Token });

        _pipe.Begin(this);
    }

    protected override void ProcessRecord()
    {
        _pipe.Process(InputObject);
    }

    protected override void EndProcessing()
    {
        _pipe.End();
    }

    protected override void StopProcessing()
    {
        _src.Cancel();
    }

    public void Dispose()
    {
        _src.Dispose();
        _pipe.Dispose();
        GC.SuppressFinalize(this);
    }
}

Then using this cmdlet you can pass-in a CancellationToken to your .NET method and it will respond correctly to CTRL + C:

Invoke-SomeScriptBlockThing {
    param($Token)

    [System.Threading.Tasks.Task]::Delay(-1, $Token).GetAwaiter().GetResult()
}

I confess I got lost tracing through Invoke-Command, and I'm not currently set up to step through with a debugger. I did come up with this hybrid approach which works to solve the real challenge, but it doesn't cover the case where the compiled Cmdlet needs access to the output of the scriptblock. For that, I think the technique from Santiago's answer might be the better option.

The hybrid approach is shown below. It outputs the following:

VERBOSE: downstream_
VERBOSE: downstream_System.Threading.CancellationToken
VERBOSE: downstream_parent
VERBOSE: downstream_a
VERBOSE: a
VERBOSE: downstream_b
VERBOSE: b
Write-Error: C:\test.ps1:41
Line |
  41 |                  $_input | & $ScriptBlock -CancellationToken $_
     |                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     | some error

which demonstrates the following:

• downstream streaming occurs
• variables are available from the parent scope
• the CancellationToken is available from the compiled Cmdlet
• the location of the error message is preserved

function Using-CancellationToken {
    param (
        [Parameter(ValueFromPipeline)]
        $InputObject,

        [Parameter(Mandatory,Position=1)]
        [scriptblock]
        $private:ScriptBlock
    )
    $private:_input = $input
    Add-Type      `
        -PassThru `
        -TypeDefinition @'
using System.Threading;
using System.Management.Automation;

namespace n {
    [Cmdlet("Using","CancellationTokenImpl")]
    [OutputType(typeof(CancellationToken))]
    public class UsingCancellationTokenImplCommand : Cmdlet
    {
        CancellationTokenSource cts;
        protected override void BeginProcessing() {
            cts = new CancellationTokenSource();
        }
        protected override void EndProcessing() {
            WriteObject(cts.Token);
        }
        protected override void StopProcessing () {
            cts.Cancel();
        }
    }
}
'@ |
    % Assembly |
    Import-Module -WarningAction SilentlyContinue

    Using-CancellationTokenImpl |
        . {
            process {
                $_input | & $ScriptBlock -CancellationToken $_
            }
        }
}

try {
    $parent = 'parent'
    'a','b' |
        Using-CancellationToken {
            param($CancellationToken)
            begin {
                $ScriptBlock
                $CancellationToken
                $parent
            }
            process {
                $_
                Write-Verbose $_ -Verbose
            }
            end {
                Write-Error 'some error'
            }
        } |
        . { process { Write-Verbose "downstream_$_" -Verbose } }
}
catch {
    $_
}