Address PR feedback

vmoroz · vmoroz · commit 30cd40972c2b · 2025-02-10T15:54:41.000-08:00
diff --git a/src/NodeApi/Runtime/NodeEmbeddingNodeApiScope.cs b/src/NodeApi/Runtime/NodeEmbeddingNodeApiScope.cs
@@ -16,11 +16,11 @@ public sealed class NodeEmbeddingNodeApiScope : IDisposable
     public NodeEmbeddingNodeApiScope(NodeEmbeddingRuntime runtime)
     {
         _runtime = runtime;
-        NodeEmbeddingRuntime.JSRuntime.EmbeddingRuntimeOpenNodeApiScope(
+        NodeEmbedding.JSRuntime.EmbeddingRuntimeOpenNodeApiScope(
             runtime.Handle, out _nodeApiScope, out napi_env env)
             .ThrowIfFailed();
         _valueScope = new JSValueScope(
-            JSValueScopeType.Root, env, NodeEmbeddingRuntime.JSRuntime);
+            JSValueScopeType.Root, env, NodeEmbedding.JSRuntime);
     }
 
     /// <summary>
@@ -37,7 +37,7 @@ public void Dispose()
         IsDisposed = true;
 
         _valueScope.Dispose();
-        NodeEmbeddingRuntime.JSRuntime.EmbeddingRuntimeCloseNodeApiScope(
+        NodeEmbedding.JSRuntime.EmbeddingRuntimeCloseNodeApiScope(
             _runtime.Handle, _nodeApiScope)
             .ThrowIfFailed();
     }
diff --git a/src/NodeApi/Runtime/NodeEmbeddingPlatform.cs b/src/NodeApi/Runtime/NodeEmbeddingPlatform.cs
@@ -41,7 +41,7 @@ public NodeEmbeddingPlatform(string libNodePath, NodeEmbeddingPlatformSettings?
 
         using FunctorRef<node_embedding_platform_configure_callback> functorRef =
             CreatePlatformConfigureFunctorRef(settings?.CreateConfigurePlatformCallback());
-        JSRuntime.EmbeddingCreatePlatform(
+        NodeEmbedding.JSRuntime.EmbeddingCreatePlatform(
             settings?.Args ?? new string[] { "node" },
             functorRef.Callback,
             functorRef.Data,
@@ -61,8 +61,6 @@ public NodeEmbeddingPlatform(string libNodePath, NodeEmbeddingPlatformSettings?
     /// </summary>
     public static NodeEmbeddingPlatform? Current { get; private set; }
 
-    public static JSRuntime JSRuntime => NodeEmbedding.JSRuntime;
-
     /// <summary>
     /// Disposes the platform. After disposal, another platform instance may not be initialized
     /// in the current process.
@@ -71,7 +69,7 @@ public void Dispose()
     {
         if (IsDisposed) return;
         IsDisposed = true;
-        JSRuntime.EmbeddingDeletePlatform(_platform);
+        NodeEmbedding.JSRuntime.EmbeddingDeletePlatform(_platform);
     }
 
     /// <summary>
@@ -98,7 +96,7 @@ public unsafe string[] GetParsedArgs()
 
         int argc = 0;
         nint argv = 0;
-        JSRuntime.EmbeddingPlatformGetParsedArgs(
+        NodeEmbedding.JSRuntime.EmbeddingPlatformGetParsedArgs(
             _platform, (nint)(&argc), (nint)(&argv), 0, 0).ThrowIfFailed();
         return Utf8StringArray.ToStringArray(argv, argc);
     }
@@ -109,7 +107,7 @@ public unsafe string[] GetRuntimeParsedArgs()
 
         int argc = 0;
         nint argv = 0;
-        JSRuntime.EmbeddingPlatformGetParsedArgs(
+        NodeEmbedding.JSRuntime.EmbeddingPlatformGetParsedArgs(
             _platform, 0, 0, (nint)(&argc), (nint)(&argv)).ThrowIfFailed();
         return Utf8StringArray.ToStringArray(argv, argc);
     }
diff --git a/src/NodeApi/Runtime/NodeEmbeddingPlatformSettings.cs b/src/NodeApi/Runtime/NodeEmbeddingPlatformSettings.cs
@@ -12,14 +12,12 @@ public class NodeEmbeddingPlatformSettings
     public string[]? Args { get; set; }
     public ConfigurePlatformCallback? ConfigurePlatform { get; set; }
 
-    public static JSRuntime JSRuntime => NodeEmbedding.JSRuntime;
-
     public unsafe ConfigurePlatformCallback CreateConfigurePlatformCallback()
         => new((config) =>
         {
             if (PlatformFlags != null)
             {
-                JSRuntime.EmbeddingPlatformConfigSetFlags(config, PlatformFlags.Value)
+                NodeEmbedding.JSRuntime.EmbeddingPlatformConfigSetFlags(config, PlatformFlags.Value)
                     .ThrowIfFailed();
             }
             ConfigurePlatform?.Invoke(config);
diff --git a/src/NodeApi/Runtime/NodeEmbeddingRuntime.cs b/src/NodeApi/Runtime/NodeEmbeddingRuntime.cs
@@ -21,14 +21,12 @@ public sealed class NodeEmbeddingRuntime : IDisposable
 {
     private bool _mustDeleteRuntime; // Only delete runtime if it was created by calling Create.
 
-    public static JSRuntime JSRuntime => NodeEmbedding.JSRuntime;
-
     public static unsafe NodeEmbeddingRuntime Create(
         NodeEmbeddingPlatform platform, NodeEmbeddingRuntimeSettings? settings = null)
     {
         using FunctorRef<node_embedding_runtime_configure_callback> functorRef =
             CreateRuntimeConfigureFunctorRef(settings?.CreateConfigureRuntimeCallback());
-        JSRuntime.EmbeddingCreateRuntime(
+        NodeEmbedding.JSRuntime.EmbeddingCreateRuntime(
             platform.Handle,
             functorRef.Callback,
             functorRef.Data,
@@ -48,14 +46,15 @@ private NodeEmbeddingRuntime(node_embedding_runtime runtime)
 
     public static unsafe NodeEmbeddingRuntime FromHandle(node_embedding_runtime runtime)
     {
-        JSRuntime.EmbeddingRuntimeGetUserData(runtime, out nint userData).ThrowIfFailed();
+        NodeEmbedding.JSRuntime.EmbeddingRuntimeGetUserData(runtime, out nint userData)
+            .ThrowIfFailed();
         if (userData != default)
         {
             return (NodeEmbeddingRuntime)GCHandle.FromIntPtr(userData).Target!;
         }
 
         NodeEmbeddingRuntime result = new(runtime);
-        JSRuntime.EmbeddingRuntimeSetUserData(
+        NodeEmbedding.JSRuntime.EmbeddingRuntimeSetUserData(
             runtime,
             (nint)GCHandle.Alloc(result),
             new node_embedding_data_release_callback(s_releaseRuntimeCallback))
@@ -68,7 +67,8 @@ public static unsafe void Run(
     {
         using FunctorRef<node_embedding_runtime_configure_callback> functorRef =
             CreateRuntimeConfigureFunctorRef(settings?.CreateConfigureRuntimeCallback());
-        JSRuntime.EmbeddingRunRuntime(platform.Handle, functorRef.Callback, functorRef.Data)
+        NodeEmbedding.JSRuntime.EmbeddingRunRuntime(
+            platform.Handle, functorRef.Callback, functorRef.Data)
             .ThrowIfFailed();
     }
 
@@ -85,36 +85,38 @@ public void Dispose()
         if (IsDisposed || !_mustDeleteRuntime) return;
         IsDisposed = true;
 
-        JSRuntime.EmbeddingDeleteRuntime(Handle).ThrowIfFailed();
+        NodeEmbedding.JSRuntime.EmbeddingDeleteRuntime(Handle).ThrowIfFailed();
     }
 
     public unsafe void RunEventLoop()
     {
         if (IsDisposed) throw new ObjectDisposedException(nameof(NodeEmbeddingRuntime));
 
-        JSRuntime.EmbeddingRuntimeRunEventLoop(Handle).ThrowIfFailed();
+        NodeEmbedding.JSRuntime.EmbeddingRuntimeRunEventLoop(Handle).ThrowIfFailed();
     }
 
     public unsafe void TerminateEventLoop()
     {
         if (IsDisposed) throw new ObjectDisposedException(nameof(NodeEmbeddingRuntime));
 
-        JSRuntime.EmbeddingRuntimeTerminateEventLoop(Handle).ThrowIfFailed();
+        NodeEmbedding.JSRuntime.EmbeddingRuntimeTerminateEventLoop(Handle).ThrowIfFailed();
     }
 
     public unsafe bool RunEventLoopOnce()
     {
         if (IsDisposed) throw new ObjectDisposedException(nameof(NodeEmbeddingRuntime));
 
-        JSRuntime.EmbeddingRuntimeRunOnceEventLoop(Handle, out bool result).ThrowIfFailed();
+        NodeEmbedding.JSRuntime.EmbeddingRuntimeRunOnceEventLoop(Handle, out bool result)
+            .ThrowIfFailed();
         return result;
     }
 
     public unsafe bool RunEventLoopNoWait()
     {
         if (IsDisposed) throw new ObjectDisposedException(nameof(NodeEmbeddingRuntime));
 
-        JSRuntime.EmbeddingRuntimeRunNoWaitEventLoop(Handle, out bool result).ThrowIfFailed();
+        NodeEmbedding.JSRuntime.EmbeddingRuntimeRunNoWaitEventLoop(Handle, out bool result)
+            .ThrowIfFailed();
         return result;
     }
 
@@ -124,7 +126,8 @@ public unsafe void RunNodeApi(RunNodeApiCallback runNodeApi)
 
         using FunctorRef<node_embedding_node_api_run_callback> functorRef =
             CreateNodeApiRunFunctorRef(runNodeApi);
-        JSRuntime.EmbeddingRuntimeRunNodeApi(Handle, functorRef.Callback, functorRef.Data)
+        NodeEmbedding.JSRuntime.EmbeddingRuntimeRunNodeApi(
+            Handle, functorRef.Callback, functorRef.Data)
             .ThrowIfFailed();
     }
 
@@ -152,7 +155,7 @@ private static unsafe NodeEmbeddingStatus ReleaseRuntimeCallbackAdapter(nint dat
             }
             catch (Exception ex)
             {
-                JSRuntime.EmbeddingSetLastErrorMessage(ex.Message.AsSpan());
+                NodeEmbedding.JSRuntime.EmbeddingSetLastErrorMessage(ex.Message.AsSpan());
                 return NodeEmbeddingStatus.GenericError;
             }
         }
diff --git a/src/NodeApi/Runtime/NodeEmbeddingRuntimeSettings.cs b/src/NodeApi/Runtime/NodeEmbeddingRuntimeSettings.cs
@@ -23,33 +23,31 @@ public class NodeEmbeddingRuntimeSettings
     public PostTaskCallback? OnPostTask { get; set; }
     public ConfigureRuntimeCallback? ConfigureRuntime { get; set; }
 
-    public static JSRuntime JSRuntime => NodeEmbedding.JSRuntime;
-
     public unsafe ConfigureRuntimeCallback CreateConfigureRuntimeCallback()
         => new((platform, config) =>
         {
             if (NodeApiVersion != null)
             {
-                JSRuntime.EmbeddingRuntimeConfigSetNodeApiVersion(
+                NodeEmbedding.JSRuntime.EmbeddingRuntimeConfigSetNodeApiVersion(
                     config, NodeApiVersion.Value)
                     .ThrowIfFailed();
             }
             if (RuntimeFlags != null)
             {
-                JSRuntime.EmbeddingRuntimeConfigSetFlags(config, RuntimeFlags.Value)
+                NodeEmbedding.JSRuntime.EmbeddingRuntimeConfigSetFlags(config, RuntimeFlags.Value)
                     .ThrowIfFailed();
             }
             if (Args != null || RuntimeArgs != null)
             {
-                JSRuntime.EmbeddingRuntimeConfigSetArgs(config, Args, RuntimeArgs)
+                NodeEmbedding.JSRuntime.EmbeddingRuntimeConfigSetArgs(config, Args, RuntimeArgs)
                     .ThrowIfFailed();
             }
 
             if (OnPreload != null)
             {
                 Functor<node_embedding_runtime_preload_callback> functor =
                     CreateRuntimePreloadFunctor(OnPreload);
-                JSRuntime.EmbeddingRuntimeConfigOnPreload(
+                NodeEmbedding.JSRuntime.EmbeddingRuntimeConfigOnPreload(
                     config, functor.Callback, functor.Data, functor.DataRelease)
                     .ThrowIfFailed();
             }
@@ -64,15 +62,15 @@ JSValue onLoading(NodeEmbeddingRuntime runtime,
 
                 Functor<node_embedding_runtime_loading_callback> functor =
                     CreateRuntimeLoadingFunctor(onLoading);
-                JSRuntime.EmbeddingRuntimeConfigOnLoading(
+                NodeEmbedding.JSRuntime.EmbeddingRuntimeConfigOnLoading(
                     config, functor.Callback, functor.Data, functor.DataRelease)
                     .ThrowIfFailed();
             }
             else if (OnLoading != null)
             {
                 Functor<node_embedding_runtime_loading_callback> functor =
                     CreateRuntimeLoadingFunctor(OnLoading);
-                JSRuntime.EmbeddingRuntimeConfigOnLoading(
+                NodeEmbedding.JSRuntime.EmbeddingRuntimeConfigOnLoading(
                     config, functor.Callback, functor.Data, functor.DataRelease)
                     .ThrowIfFailed();
             }
@@ -81,7 +79,7 @@ JSValue onLoading(NodeEmbeddingRuntime runtime,
             {
                 Functor<node_embedding_runtime_loaded_callback> functor =
                     CreateRuntimeLoadedFunctor(OnLoaded);
-                JSRuntime.EmbeddingRuntimeConfigOnLoaded(
+                NodeEmbedding.JSRuntime.EmbeddingRuntimeConfigOnLoaded(
                     config, functor.Callback, functor.Data, functor.DataRelease)
                     .ThrowIfFailed();
             }
@@ -92,7 +90,7 @@ JSValue onLoading(NodeEmbeddingRuntime runtime,
                 {
                     Functor<node_embedding_module_initialize_callback> functor =
                         CreateModuleInitializeFunctor(module.OnInitialize);
-                    JSRuntime.EmbeddingRuntimeConfigAddModule(
+                    NodeEmbedding.JSRuntime.EmbeddingRuntimeConfigAddModule(
                         config,
                         module.Name.AsSpan(),
                         functor.Callback,
@@ -107,7 +105,7 @@ JSValue onLoading(NodeEmbeddingRuntime runtime,
             {
                 Functor<node_embedding_task_post_callback> functor =
                     CreateTaskPostFunctor(OnPostTask);
-                JSRuntime.EmbeddingRuntimeConfigSetTaskRunner(
+                NodeEmbedding.JSRuntime.EmbeddingRuntimeConfigSetTaskRunner(
                     config,
                     new node_embedding_task_post_callback(s_taskPostCallback),
                     (nint)GCHandle.Alloc(OnPostTask),
diff --git a/src/NodeApi/Runtime/NodeEmbeddingThreadRuntime.cs b/src/NodeApi/Runtime/NodeEmbeddingThreadRuntime.cs
@@ -86,8 +86,6 @@ internal NodeEmbeddingThreadRuntime(
         SynchronizationContext = syncContext;
     }
 
-    public static JSRuntime JSRuntime => NodeEmbedding.JSRuntime;
-
     private static void InitializeModuleImportFunctions(
         JSRuntimeContext runtimeContext,
         string baseDir)
diff --git a/test/GCTests.cs b/test/GCTests.cs
@@ -15,10 +15,13 @@ public class GCTests
     [Fact]
     public void GCHandles()
     {
-        using NodeEmbeddingThreadRuntime nodejs = NodejsEmbeddingTests.CreateNodejsEnvironment();
+        using NodeEmbeddingThreadRuntime nodejs =
+            NodejsEmbeddingTests.CreateNodeEmbeddingThreadRuntime();
 
         nodejs.Run(() =>
         {
+            // 3 GC handles are created in the NodeEmbeddingThreadRuntime constructor
+            // to define the 'require', 'resolve', and ' import' functions.
             Assert.Equal(3, JSRuntimeContext.Current.GCHandleCount);
 
             JSClassBuilder<DotnetClass> classBuilder =
@@ -48,7 +51,7 @@ public void GCHandles()
             // Two more handles should have been allocated by the JS create-instance function call.
             // - One for the 'external' type value passed to the constructor.
             // - One for the JS object wrapper.
-            Assert.Equal(3 + 7, JSRuntimeContext.Current.GCHandleCount);
+            Assert.Equal(3 + 5 + 2, JSRuntimeContext.Current.GCHandleCount);
         });
 
         nodejs.GC();
@@ -63,7 +66,8 @@ public void GCHandles()
     [Fact]
     public void GCObjects()
     {
-        using NodeEmbeddingThreadRuntime nodejs = NodejsEmbeddingTests.CreateNodejsEnvironment();
+        using NodeEmbeddingThreadRuntime nodejs =
+            NodejsEmbeddingTests.CreateNodeEmbeddingThreadRuntime();
 
         nodejs.Run(() =>
         {
diff --git a/test/NodejsEmbeddingTests.cs b/test/NodejsEmbeddingTests.cs

Original file line number	Diff line number	Diff line change
`@@ -12,14 +12,12 @@ public class NodeEmbeddingPlatformSettings`
`12`	`12`	`public string[]? Args { get; set; }`
`13`	`13`	`public ConfigurePlatformCallback? ConfigurePlatform { get; set; }`
`14`	`14`
`15`		`- public static JSRuntime JSRuntime => NodeEmbedding.JSRuntime;`
`16`		`-`
`17`	`15`	`public unsafe ConfigurePlatformCallback CreateConfigurePlatformCallback()`
`18`	`16`	`=> new((config) =>`
`19`	`17`	`{`
`20`	`18`	`if (PlatformFlags != null)`
`21`	`19`	`{`
`22`		`- JSRuntime.EmbeddingPlatformConfigSetFlags(config, PlatformFlags.Value)`
	`20`	`+ NodeEmbedding.JSRuntime.EmbeddingPlatformConfigSetFlags(config, PlatformFlags.Value)`
`23`	`21`	`.ThrowIfFailed();`
`24`	`22`	`}`
`25`	`23`	`ConfigurePlatform?.Invoke(config);`
Original file line number	Diff line number	Diff line change
`@@ -21,14 +21,12 @@ public sealed class NodeEmbeddingRuntime : IDisposable`
`21`	`21`	`{`
`22`	`22`	`private bool _mustDeleteRuntime; // Only delete runtime if it was created by calling Create.`
`23`	`23`
`24`		`- public static JSRuntime JSRuntime => NodeEmbedding.JSRuntime;`
`25`		`-`
`26`	`24`	`public static unsafe NodeEmbeddingRuntime Create(`
`27`	`25`	`NodeEmbeddingPlatform platform, NodeEmbeddingRuntimeSettings? settings = null)`
`28`	`26`	`{`
`29`	`27`	`using FunctorRef<node_embedding_runtime_configure_callback> functorRef =`
`30`	`28`	`CreateRuntimeConfigureFunctorRef(settings?.CreateConfigureRuntimeCallback());`
`31`		`- JSRuntime.EmbeddingCreateRuntime(`
	`29`	`+ NodeEmbedding.JSRuntime.EmbeddingCreateRuntime(`
`32`	`30`	`platform.Handle,`
`33`	`31`	`functorRef.Callback,`
`34`	`32`	`functorRef.Data,`
`@@ -48,14 +46,15 @@ private NodeEmbeddingRuntime(node_embedding_runtime runtime)`
`48`	`46`
`49`	`47`	`public static unsafe NodeEmbeddingRuntime FromHandle(node_embedding_runtime runtime)`
`50`	`48`	`{`
`51`		`- JSRuntime.EmbeddingRuntimeGetUserData(runtime, out nint userData).ThrowIfFailed();`
	`49`	`+ NodeEmbedding.JSRuntime.EmbeddingRuntimeGetUserData(runtime, out nint userData)`
	`50`	`+ .ThrowIfFailed();`
`52`	`51`	`if (userData != default)`
`53`	`52`	`{`
`54`	`53`	`return (NodeEmbeddingRuntime)GCHandle.FromIntPtr(userData).Target!;`
`55`	`54`	`}`
`56`	`55`
`57`	`56`	`NodeEmbeddingRuntime result = new(runtime);`
`58`		`- JSRuntime.EmbeddingRuntimeSetUserData(`
	`57`	`+ NodeEmbedding.JSRuntime.EmbeddingRuntimeSetUserData(`
`59`	`58`	`runtime,`
`60`	`59`	`(nint)GCHandle.Alloc(result),`
`61`	`60`	`new node_embedding_data_release_callback(s_releaseRuntimeCallback))`
`@@ -68,7 +67,8 @@ public static unsafe void Run(`
`68`	`67`	`{`
`69`	`68`	`using FunctorRef<node_embedding_runtime_configure_callback> functorRef =`
`70`	`69`	`CreateRuntimeConfigureFunctorRef(settings?.CreateConfigureRuntimeCallback());`
`71`		`- JSRuntime.EmbeddingRunRuntime(platform.Handle, functorRef.Callback, functorRef.Data)`
	`70`	`+ NodeEmbedding.JSRuntime.EmbeddingRunRuntime(`
	`71`	`+ platform.Handle, functorRef.Callback, functorRef.Data)`
`72`	`72`	`.ThrowIfFailed();`
`73`	`73`	`}`
`74`	`74`
`@@ -85,36 +85,38 @@ public void Dispose()`
`85`	`85`	`if (IsDisposed \|\| !_mustDeleteRuntime) return;`
`86`	`86`	`IsDisposed = true;`
`87`	`87`
`88`		`- JSRuntime.EmbeddingDeleteRuntime(Handle).ThrowIfFailed();`
	`88`	`+ NodeEmbedding.JSRuntime.EmbeddingDeleteRuntime(Handle).ThrowIfFailed();`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`public unsafe void RunEventLoop()`
`92`	`92`	`{`
`93`	`93`	`if (IsDisposed) throw new ObjectDisposedException(nameof(NodeEmbeddingRuntime));`
`94`	`94`
`95`		`- JSRuntime.EmbeddingRuntimeRunEventLoop(Handle).ThrowIfFailed();`
	`95`	`+ NodeEmbedding.JSRuntime.EmbeddingRuntimeRunEventLoop(Handle).ThrowIfFailed();`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`public unsafe void TerminateEventLoop()`
`99`	`99`	`{`
`100`	`100`	`if (IsDisposed) throw new ObjectDisposedException(nameof(NodeEmbeddingRuntime));`
`101`	`101`
`102`		`- JSRuntime.EmbeddingRuntimeTerminateEventLoop(Handle).ThrowIfFailed();`
	`102`	`+ NodeEmbedding.JSRuntime.EmbeddingRuntimeTerminateEventLoop(Handle).ThrowIfFailed();`
`103`	`103`	`}`
`104`	`104`
`105`	`105`	`public unsafe bool RunEventLoopOnce()`
`106`	`106`	`{`
`107`	`107`	`if (IsDisposed) throw new ObjectDisposedException(nameof(NodeEmbeddingRuntime));`
`108`	`108`
`109`		`- JSRuntime.EmbeddingRuntimeRunOnceEventLoop(Handle, out bool result).ThrowIfFailed();`
	`109`	`+ NodeEmbedding.JSRuntime.EmbeddingRuntimeRunOnceEventLoop(Handle, out bool result)`
	`110`	`+ .ThrowIfFailed();`
`110`	`111`	`return result;`
`111`	`112`	`}`
`112`	`113`
`113`	`114`	`public unsafe bool RunEventLoopNoWait()`
`114`	`115`	`{`
`115`	`116`	`if (IsDisposed) throw new ObjectDisposedException(nameof(NodeEmbeddingRuntime));`
`116`	`117`
`117`		`- JSRuntime.EmbeddingRuntimeRunNoWaitEventLoop(Handle, out bool result).ThrowIfFailed();`
	`118`	`+ NodeEmbedding.JSRuntime.EmbeddingRuntimeRunNoWaitEventLoop(Handle, out bool result)`
	`119`	`+ .ThrowIfFailed();`
`118`	`120`	`return result;`
`119`	`121`	`}`
`120`	`122`
`@@ -124,7 +126,8 @@ public unsafe void RunNodeApi(RunNodeApiCallback runNodeApi)`
`124`	`126`
`125`	`127`	`using FunctorRef<node_embedding_node_api_run_callback> functorRef =`
`126`	`128`	`CreateNodeApiRunFunctorRef(runNodeApi);`
`127`		`- JSRuntime.EmbeddingRuntimeRunNodeApi(Handle, functorRef.Callback, functorRef.Data)`
	`129`	`+ NodeEmbedding.JSRuntime.EmbeddingRuntimeRunNodeApi(`
	`130`	`+ Handle, functorRef.Callback, functorRef.Data)`
`128`	`131`	`.ThrowIfFailed();`
`129`	`132`	`}`
`130`	`133`
`@@ -152,7 +155,7 @@ private static unsafe NodeEmbeddingStatus ReleaseRuntimeCallbackAdapter(nint dat`
`152`	`155`	`}`
`153`	`156`	`catch (Exception ex)`
`154`	`157`	`{`
`155`		`- JSRuntime.EmbeddingSetLastErrorMessage(ex.Message.AsSpan());`
	`158`	`+ NodeEmbedding.JSRuntime.EmbeddingSetLastErrorMessage(ex.Message.AsSpan());`
`156`	`159`	`return NodeEmbeddingStatus.GenericError;`
`157`	`160`	`}`
`158`	`161`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,33 +23,31 @@ public class NodeEmbeddingRuntimeSettings`
`23`	`23`	`public PostTaskCallback? OnPostTask { get; set; }`
`24`	`24`	`public ConfigureRuntimeCallback? ConfigureRuntime { get; set; }`
`25`	`25`
`26`		`- public static JSRuntime JSRuntime => NodeEmbedding.JSRuntime;`
`27`		`-`
`28`	`26`	`public unsafe ConfigureRuntimeCallback CreateConfigureRuntimeCallback()`
`29`	`27`	`=> new((platform, config) =>`
`30`	`28`	`{`
`31`	`29`	`if (NodeApiVersion != null)`
`32`	`30`	`{`
`33`		`- JSRuntime.EmbeddingRuntimeConfigSetNodeApiVersion(`
	`31`	`+ NodeEmbedding.JSRuntime.EmbeddingRuntimeConfigSetNodeApiVersion(`
`34`	`32`	`config, NodeApiVersion.Value)`
`35`	`33`	`.ThrowIfFailed();`
`36`	`34`	`}`
`37`	`35`	`if (RuntimeFlags != null)`
`38`	`36`	`{`
`39`		`- JSRuntime.EmbeddingRuntimeConfigSetFlags(config, RuntimeFlags.Value)`
	`37`	`+ NodeEmbedding.JSRuntime.EmbeddingRuntimeConfigSetFlags(config, RuntimeFlags.Value)`
`40`	`38`	`.ThrowIfFailed();`
`41`	`39`	`}`
`42`	`40`	`if (Args != null \|\| RuntimeArgs != null)`
`43`	`41`	`{`
`44`		`- JSRuntime.EmbeddingRuntimeConfigSetArgs(config, Args, RuntimeArgs)`
	`42`	`+ NodeEmbedding.JSRuntime.EmbeddingRuntimeConfigSetArgs(config, Args, RuntimeArgs)`
`45`	`43`	`.ThrowIfFailed();`
`46`	`44`	`}`
`47`	`45`
`48`	`46`	`if (OnPreload != null)`
`49`	`47`	`{`
`50`	`48`	`Functor<node_embedding_runtime_preload_callback> functor =`
`51`	`49`	`CreateRuntimePreloadFunctor(OnPreload);`
`52`		`- JSRuntime.EmbeddingRuntimeConfigOnPreload(`
	`50`	`+ NodeEmbedding.JSRuntime.EmbeddingRuntimeConfigOnPreload(`
`53`	`51`	`config, functor.Callback, functor.Data, functor.DataRelease)`
`54`	`52`	`.ThrowIfFailed();`
`55`	`53`	`}`
`@@ -64,15 +62,15 @@ JSValue onLoading(NodeEmbeddingRuntime runtime,`
`64`	`62`
`65`	`63`	`Functor<node_embedding_runtime_loading_callback> functor =`
`66`	`64`	`CreateRuntimeLoadingFunctor(onLoading);`
`67`		`- JSRuntime.EmbeddingRuntimeConfigOnLoading(`
	`65`	`+ NodeEmbedding.JSRuntime.EmbeddingRuntimeConfigOnLoading(`
`68`	`66`	`config, functor.Callback, functor.Data, functor.DataRelease)`
`69`	`67`	`.ThrowIfFailed();`
`70`	`68`	`}`
`71`	`69`	`else if (OnLoading != null)`
`72`	`70`	`{`
`73`	`71`	`Functor<node_embedding_runtime_loading_callback> functor =`
`74`	`72`	`CreateRuntimeLoadingFunctor(OnLoading);`
`75`		`- JSRuntime.EmbeddingRuntimeConfigOnLoading(`
	`73`	`+ NodeEmbedding.JSRuntime.EmbeddingRuntimeConfigOnLoading(`
`76`	`74`	`config, functor.Callback, functor.Data, functor.DataRelease)`
`77`	`75`	`.ThrowIfFailed();`
`78`	`76`	`}`
`@@ -81,7 +79,7 @@ JSValue onLoading(NodeEmbeddingRuntime runtime,`
`81`	`79`	`{`
`82`	`80`	`Functor<node_embedding_runtime_loaded_callback> functor =`
`83`	`81`	`CreateRuntimeLoadedFunctor(OnLoaded);`
`84`		`- JSRuntime.EmbeddingRuntimeConfigOnLoaded(`
	`82`	`+ NodeEmbedding.JSRuntime.EmbeddingRuntimeConfigOnLoaded(`
`85`	`83`	`config, functor.Callback, functor.Data, functor.DataRelease)`
`86`	`84`	`.ThrowIfFailed();`
`87`	`85`	`}`
`@@ -92,7 +90,7 @@ JSValue onLoading(NodeEmbeddingRuntime runtime,`
`92`	`90`	`{`
`93`	`91`	`Functor<node_embedding_module_initialize_callback> functor =`
`94`	`92`	`CreateModuleInitializeFunctor(module.OnInitialize);`
`95`		`- JSRuntime.EmbeddingRuntimeConfigAddModule(`
	`93`	`+ NodeEmbedding.JSRuntime.EmbeddingRuntimeConfigAddModule(`
`96`	`94`	`config,`
`97`	`95`	`module.Name.AsSpan(),`
`98`	`96`	`functor.Callback,`
`@@ -107,7 +105,7 @@ JSValue onLoading(NodeEmbeddingRuntime runtime,`
`107`	`105`	`{`
`108`	`106`	`Functor<node_embedding_task_post_callback> functor =`
`109`	`107`	`CreateTaskPostFunctor(OnPostTask);`
`110`		`- JSRuntime.EmbeddingRuntimeConfigSetTaskRunner(`
	`108`	`+ NodeEmbedding.JSRuntime.EmbeddingRuntimeConfigSetTaskRunner(`
`111`	`109`	`config,`
`112`	`110`	`new node_embedding_task_post_callback(s_taskPostCallback),`
`113`	`111`	`(nint)GCHandle.Alloc(OnPostTask),`
Original file line number	Diff line number	Diff line change
`@@ -86,8 +86,6 @@ internal NodeEmbeddingThreadRuntime(`
`86`	`86`	`SynchronizationContext = syncContext;`
`87`	`87`	`}`
`88`	`88`
`89`		`- public static JSRuntime JSRuntime => NodeEmbedding.JSRuntime;`
`90`		`-`
`91`	`89`	`private static void InitializeModuleImportFunctions(`
`92`	`90`	`JSRuntimeContext runtimeContext,`
`93`	`91`	`string baseDir)`