Actual executor test

const Delay = 


 Total, Passed, Undefined = , , 
const VENV = ()


 Function = (...unknown) -> ... unknown
 Callback = () -> boolean|

const  (Closure: Function): boolean
	 (()
			(Closure, (Closure))
		) 
		 
	

	const L, S = debug.(Closure, )
	 L ~= -  S ~=     

	 


const  (Closure: Function): 
	 hash = 
	 _, value  {debug.(Closure, )}  hash ..= (value) 

	 hash


@native const  (A: Function, B: Function): boolean
	 A == B  (A) == (B)


@native const  (Aliases: {}): {}
	const MissingAliases = {}
	 _, Alias  , Aliases 
		  VENV[Alias] 
			Undefined += 
			.(MissingAliases, Alias)
		
	

	 MissingAliases


@native const  (Name: , Callback: Callback)
	Total += 

	
	 Total >   Delay >  
		.(Delay)
	

	const CallSuccess, Return = (Callback)

	
	  CallSuccess  Return ~=  
		(,  Name, , Return)
		
	

	
	Passed += 
	(, Name)

	


@native const  (Global: , Aliases: {}, Callback: Callback)
	
	  VENV[Global]  
		(, Global)
		 
	

	
	const MissingAliases = (Aliases)
	 #MissingAliases >  
		(, .(MissingAliases, ))
		
	

	 (Global, Callback)


@native const  ()
	const SuccessRate = .(Passed / Total * )
	const Failed = Total - Passed

	()
	(.(, ))
	()
	()
	()
	


@native const  ()
	()
	(, ())
	(.(, ), )
	.()
	



()


(, ()
	
	 (()
			 :()
		) 
		 
	

	
	  (.HttpGetAsync) 
		 
	

	
	 (.HttpGetAsync, .HttpGet) 
		 
	

	
	const Return = :()
	 (Return) ~=   #Return <  
		 
	

	 
)

(, () 
	const Previous = 
	().require = 
	const New = ().require
	().require = Previous

	
	 New == Previous 
		 
	

	 
)

(, ()
	 () ==   .Parent ==   .GetActor ~=   ()() ==    .(, )
)

(, ()
    const Globals = ()

    
     #Globals ~=  
         
    

    
     ((Globals).__index) ~=  
         
    

    
     Name, Func  , Globals 
         (Func) ==   (Func) 
             
        
    

     
)

(, ()
    const Thread = .(()
        :():(, )
    )

    const Success, Error = .(Thread)
     Success   Error 
         
    

    
     .(Thread) ~=  
         
    

	 
)

(, {}, ()
	
	(, ()
		 
	)

	const Success, Return = ()
    const FuncENVPass = () == ()
    (restorefunction, )

    
      FuncENVPass 
         
    

    
	  Success  Return ~=  
		 
	

	
	 Previous; Previous = (writefile, (()
		 ()
	))

    const Success, Return = (writefile)
    (restorefunction, writefile)

	 Success   (Return) ==    Return:() 
		 
	

    
    const CFunc = (() )
    (CFunc, ()
         ()
    )

     (, (CFunc)):() 
         
    

	 
)

(, {}, ()
	const Timeout = 
	 Return, IsRunning = , 

	
	const Thread = .(()
		IsRunning = 
		Return = :(, Timeout)
	)

	
	 .()  IsRunning

	
	 Previous; Previous = (, , (...)
		 (...)
	)
	.(Timeout+)

	
	 Return 
		 
	

	
	 Return ~=   .(Thread) ~=  
		 
	

    
    const Saar = ({}, {
        __index = loadfile
    })
    const Success, Error = (, Saar, , ()
         
    )

    
      Success 
         
    

    (loadfile)
	 Saar.pls == 
)


()