[browser][mt] JSWebWorker crashes the runtime

[kekekeks]

Description

Upcoming JSWebWorker API crashes the runtime when used.

Reproduction Steps

using System;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;

public static class Program
{
    class JSWebWorkerWrapper
    {
        [DynamicDependency(DynamicallyAccessedMemberTypes.PublicMethods, "System.Runtime.InteropServices.JavaScript.JSWebWorker", 
            "System.Runtime.InteropServices.JavaScript")]
        [UnconditionalSuppressMessage("Trimming", 
            "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code",
            Justification = "WIP runtime API")]
        static JSWebWorkerWrapper()
        {
            var type = typeof(System.Runtime.InteropServices.JavaScript.JSHost)
                .Assembly!.GetType("System.Runtime.InteropServices.JavaScript.JSWebWorker");
#pragma warning disable IL2075
            var m = type!

                .GetMethods(BindingFlags.Static | BindingFlags.Public
                ).First(m => m.Name == "RunAsync"
                             && m.ReturnType == typeof(Task)
                             && m.GetParameters() is { } parameters
                             && parameters.Length == 1
                             && parameters[0].ParameterType == typeof(Func<Task>));

#pragma warning restore IL2075
            RunAsync = (Func<Func<Task>, Task>) Delegate.CreateDelegate(typeof(Func<Func<Task>, Task>), m);

        }

        public static Func<Func<Task>, Task> RunAsync { get; set; }
    }

    public static async Task Main()
    {
        Console.WriteLine("Entering infinite loop on the main thread");

        _ = JSWebWorkerWrapper.RunAsync(() =>
        {
            Console.WriteLine("Worker started, returning an never-finishing task");
            return new TaskCompletionSource().Task;
        }).ContinueWith(_ =>
        {
            Console.WriteLine("Worker exited");
        });

        while (true)
        {
            for (int c = 0; c < 1000; c++)
                Alloc(60000);
            GC.Collect();
            await Task.Delay(1);
        }
    }

    static byte[] Alloc(int size) => new byte[size];
    
}

Expected behavior

JSWebWorker spawns a WebWorker that is allowed to await on tasks.

Actual behavior

JSWebWorker instance gets finalized and crashes the runtime

[MONO] Process terminated.
[MONO] JSWebWorker was disposed while running, 
ManagedThreadId: 3. at System.Environment.get_StackTrace() 
at System.Runtime.InteropServices.JavaScript.JSWebWorker.JSWebWorkerInstance`1[[System.Int32, System.Private.CoreLib, Version=9.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e]].Dispose(Boolean disposing) 
at System.Runtime.InteropServices.JavaScript.JSWebWorker.JSWebWorkerInstance`1[[System.Int32, System.Private.CoreLib, Version=9.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e]].Finalize()

Uncaught ExitStatus

Regression?

No response

Known Workarounds

Manually call JSHostImplementation.SetHasExternalEventLoop and JSSynchronizationContext.InstallWebWorkerInterop from user code

Configuration

.NET 9 nightlies, browser-wasm, MT

Other information

@pavelsavara

[pavelsavara]

What is supposed to keep the instance of JSWebWorker from being collected ?

[kekekeks]

The worker is supposed to run until the Task returned from Func<Task> passed to JSWebWorker.RunAsync() is finished.

The returned Task has a subscriber in a form if ContinueWith. So the API usage is definitely correct.

Is the API user supposed to keep the task returned from JSWebWorker.RunAsync GC-rooted? It's not the case for other task-based APIs in the BCL, I think

[kekekeks]

    private static Task SavedTask;
    public static async Task Main()
    {
        Console.WriteLine("Entering infinite loop on the main thread");

        _ = (SavedTask = JSWebWorkerWrapper.RunAsync(() =>
        {
            Console.WriteLine("Worker started, returning an never-finishing task");
            return new TaskCompletionSource().Task;
        })).ContinueWith(_ =>
        {
            Console.WriteLine("Worker exited");
        });

        while (true)
        {
            for (int c = 0; c < 1000; c++)
                Alloc(60000);
            GC.Collect();
            await Task.Delay(1);
        }
    }

This code still crashes the runtime, so it seems that the API consumer has no way to ensure that JSWorkerInstance is GC-rooted