nameless admin NEWEST+WORKING+BEST

 __NA_SPLIT_SOURCE_TAG = 
 __NA_SPLIT_CONFIG = {
	testing = ;
	sourceTag = __NA_SPLIT_SOURCE_TAG;
}




 __NARootHost = (  ())    {}
 __naPrev = (__NARootHost) ==   (__NARootHost, )  
 (__naPrev) ==   (__naPrev, ) == __NARootHost  ((__naPrev, )) ==  
	__NARootHost = __naPrev.hostEnv

 __NARootPreviousNACaller = (__NARootHost) ==   (__NARootHost, )  
 __NARootErrorState = (__NARootHost) ==   (__NARootHost, )  
 (__NARootErrorState) ~=  
	__NARootErrorState = { lastIndex = ; rootCount =  }
	 (__NARootHost) ==  
		(, __NARootHost, , __NARootErrorState)
	


  ()
	 name = 
	 versionValue = 
	 (identifyexecutor) ==  
		 ok, a, b = (identifyexecutor)
		 ok 
			 a ~=   (a) ~=   name = (a) 
			 b ~=   (b) ~=   versionValue = (b) 
		
	
	 name ==   (getexecutorname) ==  
		 ok, value = (getexecutorname)
		 ok  value ~=   (value) ~=   name = (value) 
	
	 versionValue ==   (getexecutorversion) ==  
		 ok, value = (getexecutorversion)
		 ok  value ~=   (value) ~=   versionValue = (value) 
	
	 name, versionValue


  (fn)
	 source = 
	 line = 
	 name = 
	 (debug) ==   (debug.info) ==   (fn) ==  
		(()
			 s, l, n = debug.(fn, )
			 s ~=   (s) ~=   source = (s) 
			 (l)  line = (l) 
			 n ~=   (n) ~=   name = (n) 
		)
	
	 source, line, name


  ()
	 root = 
	 dir = root..
	 maxIndex = (__NARootErrorState.lastIndex)  
	 (makefolder) ==  
		(()
			 (isfolder) ~=    (root)  (root) 
		)
		(()
			 (isfolder) ~=    (dir)  (dir) 
		)
	
	 (listfiles) ==  
		 ok, entries = (listfiles, dir)
		 ok  (entries) ==  
			 _, entry  entries 
				 normalized = (entry):(, )
				 index = (normalized:())
				 index  index > maxIndex  maxIndex = index 
			
		
	
	 nextIndex = maxIndex + 
	 path = dir....(nextIndex)..
	 (isfile) ==  
		 (path) 
			nextIndex += 
			path = dir....(nextIndex)..
		
	
	__NARootErrorState.lastIndex = nextIndex
	 path, nextIndex


  (rawError, tracebackText, context, fn, options)
	options = (options) ==   options  {}
	__NARootErrorState.rootCount = ((__NARootErrorState.rootCount)  ) + 
	 logPath, fileIndex = ()
	 execName, execVersion = ()
	 fnSource, fnLine, fnName = (fn)
	 clientVersion = 
	 (version) ==  
		 ok, value = (version)
		 ok  value ~=   (value) ~=   clientVersion = (value) 
	
	 timestamp = (.time  .()  )
	 (.date) ==  
		 ok, value = (.date, )
		 ok  value  timestamp = (value) 
	
	 placeName = 
	 placeId = 
	 gameId = 
	 jobId = 
	(()
		placeName = (.Name  )
		placeId = (.PlaceId  )
		gameId = (.GameId  )
		jobId = (.JobId  )
	)
	 platform = 
	(()
		 uis = :()
		 uis  (uis.GetPlatform) ==  
			platform = (uis:())
		
	)
	 errorId = ..string.(, (fileIndex)  (__NARootErrorState.rootCount)  )
	 lines = {
		;
		..errorId;
		..(fileIndex  )..;
		..timestamp;
		..(context  options.context  );
		..string.((options.severity  ));
		;
		;
		..execName;
		..execVersion;
		..clientVersion;
		..platform;
		..__NA_SPLIT_SOURCE_TAG;
		;
		;
		;
		..placeName;
		..placeId;
		..gameId;
		..jobId;
		;
		;
		..fnName;
		..fnSource....(fnLine);
		;
		;
		(rawError  );
		;
		;
		(tracebackText  rawError  );
	}
	 (options.details) ==  
		lines[#lines + ] = 
		lines[#lines + ] = 
		 key, value  options.details 
			lines[#lines + ] = (key)....(value)
		
	
	 report = .(lines, )
	 writer = (writefile) ==   writefile  ((appendfile) ==   appendfile  )
	 saved = 
	 options.log ~=   (writer) ==  
		(()
			(logPath, report..)
			saved = 
		)
	
	 options.warn ~=   () ==  
		(, report..(saved  (..logPath)  ))
	
	 report, saved  logPath  , errorId


  (fnOrOptions, ...)
	 options = {}
	 fn
	 args
	 (fnOrOptions) ==   ((, ...)) ==  
		 key, value  fnOrOptions  options[key] = value 
		fn = (, ...)
		args = .((, ...))
	
		fn = fnOrOptions
		args = .(...)
	
	 (fn) ~=  
		 message = ..(fn)
		(message, message, options.context  , , options)
		 , message
	
	 rawError
	 results = .((()
		 (.(args, , args.n))
	, (message)
		rawError = (message  )
		 (debug) ==   (debug.traceback) ==  
			 ok, trace = (debug.traceback, rawError, )
			 ok  (trace) ==   trace ~=    trace 
		
		 rawError
	))
	  results[] 
		 trace = (results[]  rawError  )
		(rawError  trace, trace, options.context  , fn, options)
		 options.rethrow ==   (trace, ) 
	
	 .(results, , results.n)


 __NA_SPLIT_LOAD_TOKEN = {}
 __NA_GLOBAL_STATE_KEY = 
 __NA_SPLIT_SESSION = (.PlaceId)....(.JobId)
  ()
	 reg
	 get = (__NARootHost, )  getreg
	 (get) ==  
		(() reg = () )
	
	 dbg = (__NARootHost, )  debug
	 (reg) ~=   (dbg) ==   (dbg.getregistry) ==  
		(() reg = dbg.() )
	
	 (reg) ~=   reg = __NARootHost 
	 root = (reg, )
	 state = (root) ==   (root, __NA_GLOBAL_STATE_KEY)
	 (root) ~=   ((state) ==   state.session ~=   state.session ~= __NA_SPLIT_SESSION) 
		root = {}
		(reg, , root)
	
	 root, reg

 __NA_GLOBAL_ENV, __NA_SPLIT_REG = ()
 __NA_GLOBAL_PREVIOUS_STATE = (__NA_GLOBAL_ENV) ==   (__NA_GLOBAL_ENV, __NA_GLOBAL_STATE_KEY)  
  (state)
	 (state) ~=     
	 state.loaded ==   state.session ==     
	 state.session ~= __NA_SPLIT_SESSION    
	 state.loaded ==  
		 
	
	 state.loading ==  
		 (state.thread) ==  
			 ok, status = (.status, state.thread)
			 ok   status ~=  
		
		 updated = (state.updated  state.started)
		  updated  .() - updated < 
	
	 


 (__NA_GLOBAL_PREVIOUS_STATE) 
	


  ()
	 () ~=   (.wait) ~=  
		 , 
	
	 deadline = .() + 
	  (check, stage)
		 .() < deadline 
			 ok, ready = (check)
			 ok  ready    
			.()
		
		 , stage..
	
	 ready, err = (()  :() , )
	  ready   , err 
	 players = :()
	ready, err = (()  players.LocalPlayer , )
	  ready   , err 
	ready, err = (()  players.LocalPlayer:() , )
	  ready   , err 
	ready, err = (()  .CurrentCamera , )
	  ready   , err 
	 


 __NA_SPLIT_READY, __NA_SPLIT_READY_ERR = ()
  __NA_SPLIT_READY 
	(__NA_SPLIT_READY_ERR, __NA_SPLIT_READY_ERR, , , { severity =  })
	


__NA_SPLIT_SESSION = (.PlaceId)....(.JobId)
__NA_GLOBAL_ENV, __NA_SPLIT_REG = ()
__NA_GLOBAL_PREVIOUS_STATE = (__NA_GLOBAL_ENV) ==   (__NA_GLOBAL_ENV, __NA_GLOBAL_STATE_KEY)  
 (__NA_GLOBAL_PREVIOUS_STATE) 
	


 __NA_SPLIT_HOST_STATE = (__NARootHost, __NA_GLOBAL_STATE_KEY)
 (__NA_SPLIT_HOST_STATE) ==   __NA_SPLIT_HOST_STATE.session ~=   __NA_SPLIT_HOST_STATE.session ~= __NA_SPLIT_SESSION 
	(__NARootHost, __NA_GLOBAL_STATE_KEY, )
	(__NARootHost, , )
	(__NARootHost, , )
	(__NARootHost, , )


 __NA_SPLIT_STALE = (__NA_GLOBAL_PREVIOUS_STATE) == 
 __NA_SPLIT_STALE  () ==  
	(, ..(__NA_GLOBAL_PREVIOUS_STATE.stage  )..)

 __NA_SPLIT_STALE  (__NARootHost) ==  
	(__NARootHost, , )
	 __NA_GLOBAL_PREVIOUS_STATE.loaded ~=  
		(__NARootHost, , )
		(__NARootHost, , )
	


 __NA_GLOBAL_STATE = {
	loading = ;
	loaded = ;
	source = __NA_SPLIT_SOURCE_TAG;
	token = __NA_SPLIT_LOAD_TOKEN;
	session = __NA_SPLIT_SESSION;
	started = .();
	thread = .();
	stage = ;
}
__NA_GLOBAL_STATE.updated = __NA_GLOBAL_STATE.started
 (__NA_GLOBAL_ENV) ==  
	(__NA_GLOBAL_ENV, __NA_GLOBAL_STATE_KEY, __NA_GLOBAL_STATE)
	 (__NA_GLOBAL_ENV, __NA_GLOBAL_STATE_KEY) ~= __NA_GLOBAL_STATE 
		
	


  ()
	 (__NA_SPLIT_REG, ) == __NA_GLOBAL_ENV
		 (__NA_GLOBAL_ENV, __NA_GLOBAL_STATE_KEY) == __NA_GLOBAL_STATE
		 (.PlaceId)....(.JobId) == __NA_SPLIT_SESSION


  (stage)
	__NA_GLOBAL_STATE.stage = stage
	__NA_GLOBAL_STATE.updated = .()


 (__NARootHost) ==    (__NA_GLOBAL_PREVIOUS_STATE) 
	 (__NARootHost, ) ~=   __NA_GLOBAL_PREVIOUS_STATE ==  
		(__NARootHost, , )
		(__NARootHost, , )
		(__NARootHost, , )
	

 __NA_SPLIT_HOST_LOADING = (__NARootHost) ==   (__NARootHost, )  
 __NA_SPLIT_HOST_LOADED = (__NARootHost) ==   ((__NARootHost, )  (__NARootHost, ))
 __NA_SPLIT_HOST_LOADING  __NA_SPLIT_HOST_LOADED 
	 (__NA_GLOBAL_ENV) ==   (__NA_GLOBAL_ENV, __NA_GLOBAL_STATE_KEY) == __NA_GLOBAL_STATE 
		(__NA_GLOBAL_ENV, __NA_GLOBAL_STATE_KEY, )
	
	

 (__NARootHost) ==  
	(__NARootHost, __NA_GLOBAL_STATE_KEY, __NA_GLOBAL_STATE)
	(__NARootHost, , __NA_SPLIT_LOAD_TOKEN)
	 (__NARootHost, ) ~= __NA_SPLIT_LOAD_TOKEN 
		
	

  ()
	 (__NARootHost) ==   (__NARootHost, ) == __NA_SPLIT_LOAD_TOKEN 
		(__NARootHost, , )
	


  ()
	 (isfolder) ~=   (delfolder) ~=    
	 key = __NA_SPLIT_SESSION:(, )
	 path = ..key
	 ok, exists = (isfolder, path)
	 ok  exists 
		 removed = (delfolder, path)
		 removed  () ==  
			(, ..path)
		
	

()
 (__NARootHost) ==  
	(, __NARootHost, , __NARootNACaller)


  (success)
	 (__NA_GLOBAL_ENV) ==   (__NA_GLOBAL_ENV, __NA_GLOBAL_STATE_KEY) == __NA_GLOBAL_STATE 
		 success 
			__NA_GLOBAL_STATE.loading = 
			__NA_GLOBAL_STATE.loaded = 
			__NA_GLOBAL_STATE.thread = 
			__NA_GLOBAL_STATE.token = 
			()
		
			(__NA_GLOBAL_ENV, __NA_GLOBAL_STATE_KEY, )
		
	
	  success  (__NARootHost, __NA_GLOBAL_STATE_KEY) == __NA_GLOBAL_STATE 
		(__NARootHost, __NA_GLOBAL_STATE_KEY, )
		(__NARootHost, , )
		(__NARootHost, , )
	
	()


()
 __NA_SPLIT_REMOTE_ROOT = (__NARootHost, )
 (__NA_SPLIT_REMOTE_ROOT) ~=   __NA_SPLIT_REMOTE_ROOT ==  
	__NA_SPLIT_REMOTE_ROOT = 

 __NA_SPLIT_REMOTE_ROOT:(-) ~=  
	__NA_SPLIT_REMOTE_ROOT ..= 


 __NA_SPLIT_LIMITED = () ~=   (getconnections) ~= 

 __NA_SPLIT_LOCAL_ROOTS = {
	;
	;
	;
}

 __NA_SPLIT_REMOTE_QUERY = 

  (root, name)
	 (readfile) ~=  
		 
	
	 ok, data = (readfile, root..name)
	 ok  (data) ==   data ~=   data  


  (name, fresh, base)
	 url = (base  __NA_SPLIT_REMOTE_ROOT)..name..__NA_SPLIT_REMOTE_QUERY
	 fresh 
		url ..= (url:(, , )    )....(.())....(.(.() * ))
	
	 requestFn = (__NARootHost, )
		 (__NARootHost, )
		 (() ==   .request)
	 (requestFn) ==  
		 ok, response = (requestFn, {
			Method = ;
			Url = url;
			Headers = fresh  { [] = ; }  ;
		})
		 status = (response) ==   (response.StatusCode  response.statusCode  response.Status)  
		 body = (response) ==   (response.Body  response.body)  
		 ok  (body) ==   body ~=   ( status  status < ) 
			 body
		
	
	 () ~=   () ~=  
		 
	
	 ok, data = (()
		 :(url)
	)
	 ok  (data) ==   data ~=   data  


  (source, name)
	 (source) ~=  
		 
	
	 loader = (__NARootHost, )    load
	 (loader) ~=  
		 
	
	 okCompile, chunk = (loader, source, ..name)
	  okCompile  (chunk) ~=  
		 
	
	 okRun, manifest = (chunk)
	 count = (manifest) ==   (manifest.count)
	 okRun  count  count >=   count <=   count %  ==  
		manifest.count = count
		 manifest
	
	 


  ()
	 () ==   (.wait) ==  
		.()
	


  (meta, partName)
	 parts = (meta) ==   meta.parts  
	 value = (parts) ==   parts[partName]  
	 (value) ==   #value ==   value:() 
		 value
	
	 


  (source, meta, name)
	 (source) ~=   source ==     
	 checks = (meta) ==   meta.integrity  
	 checks ==     
	 check = (checks) ==   checks[name]  
	 (check) ~=   #source ~= check[]  (check[]) ~=     
	 a, b = , 
	 nextYield = .() + 
	 start = , #source,  
		 index = start, .(start + , #source) 
			a += .(source, index)
			b += a
		
		a %= 
		b %= 
		 start +  < #source  .() >= nextYield 
			()
			nextYield = .() + 
		
	
	 b *  + a == check[]


  (root, meta, name)
	 fingerprint = (meta, name)
	 fingerprint 
		 path = root....fingerprint..
		 exists = 
		 (isfile) ==  
			 ok, value = (isfile, path)
			exists = ok  value
		
		 exists 
			 source = (root.., fingerprint..)
			 (source, meta, name)   source 
		
	
	 source = (root, name)
	 (source, meta, name)  source  


 __NA_SPLIT_LOCAL_ROOT = 
 __NA_SPLIT_LOCAL_META = 
 __NA_SPLIT_FALLBACK_ROOT = 
 __NA_SPLIT_FALLBACK_META = 
 _, root  __NA_SPLIT_LOCAL_ROOTS 
	 manifest = ((root, ), root..)
	 manifest 
		 complete = 
		 (isfile) ==  
			 index = , manifest.count 
				 name = .(, index)
				 fingerprint = (manifest, name)
				 ok, exists = , 
				 fingerprint  ok, exists = (isfile, root....fingerprint..) 
				  (ok  exists)  ok, exists = (isfile, root..name) 
				  (ok  exists)  complete = ;  
			
		
		 complete 
			__NA_SPLIT_LOCAL_ROOT = root
			__NA_SPLIT_LOCAL_META = manifest
			
		  __NA_SPLIT_FALLBACK_ROOT 
			__NA_SPLIT_FALLBACK_ROOT = root
			__NA_SPLIT_FALLBACK_META = manifest
		
	

  __NA_SPLIT_LOCAL_ROOT 
	__NA_SPLIT_LOCAL_ROOT = __NA_SPLIT_FALLBACK_ROOT
	__NA_SPLIT_LOCAL_META = __NA_SPLIT_FALLBACK_META


 __NA_SPLIT_REMOTE_MANIFEST_SOURCE = (..(.()))
 __NA_SPLIT_REMOTE_META = (__NA_SPLIT_REMOTE_MANIFEST_SOURCE, )
 __NA_SPLIT_REMOTE_META  (__NA_SPLIT_REMOTE_META.version) ==   __NA_SPLIT_REMOTE_META.version ~=  
	__NA_SPLIT_REMOTE_QUERY = ..__NA_SPLIT_REMOTE_META.version

 __NA_SPLIT_REMOTE_CHANGED = __NA_SPLIT_REMOTE_META ~= 
	 (__NA_SPLIT_LOCAL_META ==   __NA_SPLIT_REMOTE_META.version ~= __NA_SPLIT_LOCAL_META.version)
 __NA_SPLIT_COUNT = .(, .((
	(__NA_SPLIT_REMOTE_META  __NA_SPLIT_REMOTE_META.count)
		 (__NA_SPLIT_LOCAL_META  __NA_SPLIT_LOCAL_META.count)
		 
)  ))
 __NA_SPLIT_CACHE_ROOT = __NA_SPLIT_LOCAL_ROOT  __NA_SPLIT_LOCAL_ROOTS[]
 __NA_SPLIT_PENDING_CACHE = {}
 __NA_SPLIT_CACHE_OK = (writefile) == 
 __NA_SPLIT_CACHE_READY = 
 __NA_SPLIT_CACHE_MANIFEST = __NA_SPLIT_REMOTE_META ~=   (
	__NA_SPLIT_LOCAL_META == 
	 __NA_SPLIT_REMOTE_CHANGED
	 (__NA_SPLIT_LOCAL_META.parts) ~= 
	 __NA_SPLIT_LOCAL_META.loader_version ~= __NA_SPLIT_REMOTE_META.loader_version
)

  (partName)
	  __NA_SPLIT_REMOTE_META 
		 source = __NA_SPLIT_LOCAL_ROOT  (__NA_SPLIT_LOCAL_ROOT, __NA_SPLIT_LOCAL_META, partName)
		 source   source 
		(..partName, )
	

	 remoteFingerprint = (__NA_SPLIT_REMOTE_META, partName)
	 localFingerprint = (__NA_SPLIT_LOCAL_META, partName)
	 __NA_SPLIT_LOCAL_ROOT  ((remoteFingerprint  remoteFingerprint == localFingerprint)
		 ( __NA_SPLIT_REMOTE_CHANGED   localFingerprint)) 
		 source = (__NA_SPLIT_LOCAL_ROOT, __NA_SPLIT_REMOTE_META, partName)
		 source   source 
	

	 attempt = ,  
		 source = (partName, attempt == )
		 (source, __NA_SPLIT_REMOTE_META, partName) 
			__NA_SPLIT_PENDING_CACHE[partName] = source
			 source
		
	
	(..partName, )


  (partName)
	 source = __NA_SPLIT_PENDING_CACHE[partName]
	__NA_SPLIT_PENDING_CACHE[partName] = 
	  source   
	__NA_SPLIT_CACHE_MANIFEST = 
	 fingerprint = (__NA_SPLIT_REMOTE_META, partName)
	  __NA_SPLIT_CACHE_OK   fingerprint 
		__NA_SPLIT_CACHE_OK = 
		
	
	  __NA_SPLIT_CACHE_READY 
		 (makefolder) ==  
			 current = 
			 segment  (__NA_SPLIT_CACHE_ROOT..):() 
				current = current ==   segment  current....segment
				(makefolder, current)
			
		
		__NA_SPLIT_CACHE_READY = 
	
	  (writefile, __NA_SPLIT_CACHE_ROOT....fingerprint.., source) 
		__NA_SPLIT_CACHE_OK = 
	


  ()
	  __NA_SPLIT_CACHE_OK   __NA_SPLIT_CACHE_MANIFEST   __NA_SPLIT_REMOTE_MANIFEST_SOURCE   
	  (writefile, __NA_SPLIT_CACHE_ROOT.., __NA_SPLIT_REMOTE_MANIFEST_SOURCE)   
	 (listfiles) ~=   (delfile) ~=    
	 ok, files = (listfiles, __NA_SPLIT_CACHE_ROOT..)
	  ok  (files) ~=    
	 keep = {}
	 _, value  __NA_SPLIT_REMOTE_META.parts  {}  keep[value] =  
	 _, path  files 
		 name = (path):(, ):()
		 name  #name ==    keep[name]  (delfile, path) 
		()
	


  (source, chunkName, environment)
	 loader = (__NARootHost, )    load
	 (loader) ~=  
		(, )
	
	 okCompile, chunk, compileError = (loader, source, ..chunkName)
	  okCompile  (chunk) ~=  
		((compileError  chunk  ), )
	
	 setter = (__NARootHost, )  setfenv
	 (setter) ~=  
		(, )
	
	 okEnv, envError = (setter, chunk, environment)
	  okEnv 
		((envError), )
	
	 chunk


  (value)
	 text = (value)
	 (debug) ==   (debug.traceback) ==  
		 ok, trace = (debug.traceback, text, )
		 ok  (trace) ==   trace ~=  
			 trace
		
	
	 text


  (meta)
	 (meta) ~=   (meta.loader_version) ~=    
	 (writefile) ~=  
		
	

	 host = (() ==   ())    {}
	 state = (host) ==   (host, )  
	 sourceTag = __NA_SPLIT_SOURCE_TAG
	 sourceTag ~=   sourceTag ~=  
		
	

	 roots = {
		;
		;
		;
	}
	 root = roots[]
	 (isfile) ==  
		 _, candidate  roots 
			 ok, exists = (isfile, candidate..)
			 ok  exists 
				root = candidate
				
			
		
	

	 cachePath = root..sourceTag
	 versionPath = root....sourceTag:(, )..
	 (readfile) ==  
		 okVersion, cachedVersion = (readfile, versionPath)
		 okLoader, exists = , 
		 (isfile) ==   okLoader, exists = (isfile, cachePath) 
		 okVersion  cachedVersion == meta.loader_version  okLoader  exists 
			
		
	

	 remoteName = sourceTag:(, )
	 loaderRoot = __NA_SPLIT_REMOTE_ROOT:(, )
	 loaderRoot == __NA_SPLIT_REMOTE_ROOT   
	 url = loaderRoot..remoteName....meta.loader_version
	 requestFn = (host) ==   ((host, )  (host, ))  
	 synTable = (host) ==   (host, )  
	 (requestFn) ~=   (synTable) ==  
		requestFn = synTable.request
	

	 source
	 (requestFn) ==  
		 ok, response = (requestFn, { Method = ; Url = url; })
		 status = (response) ==   (response.StatusCode  response.statusCode  response.Status)  
		 body = (response) ==   (response.Body  response.body)  
		 ok  (body) ==   body ~=   ( status  status < ) 
			source = body
		
	

	  source  (() ==   () == ) 
		 ok, body = (()
			 :(url)
		)
		 ok  (body) ==   body ~=  
			source = body
		
	
	  source 
		
	

	 loader = (host) ==   (host, )  
	loader = loader    load
	 (loader) ~=  
		
	
	 okCompile, chunk = (loader, source, ..sourceTag)
	  okCompile  (chunk) ~=  
		
	

	 (makefolder) ==  
		 parent = root:(, )
		 current = 
		 segment  parent:() 
			current = current ==   segment  current....segment
			(makefolder, current)
		
	
	 (writefile, cachePath, source) 
		(writefile, versionPath, meta.loader_version)
	



  ()
	 (isfolder) ~=   (delfolder) ~=     
	  (root, path, depth)
		 depth >    
		 ok, exists = (isfolder, path)
		  ok   exists   
		 (listfiles) ==  
			 listed, items = (listfiles, path)
			 listed  (items) ==  
				 _, entry  items 
					 name = (entry):(, ):(, ):(, )
					 name:(, #root + ) == root..
						  name:(, , )  name:(-) ~=  
						 valid, isDir = (isfolder, name)
						 valid  isDir 
							(root, name, depth + )
						 (delfile) ==  
							(delfile, name)
						
					
				
			
		
		(delfolder, path)
	
	 removed = 
	 _, root  { , ,  } 
		 ok, exists = (isfolder, root)
		 ok  exists 
			(root, root, )
			 checked, remains = (isfolder, root)
			 checked   remains  removed +=  
		
	
	 removed


  (key)
	 (key) ~=    key:()    
	 __NA_SPLIT_CACHE_ROOT....key..


  (data, url)
	 (data) ~=   (url) ~=   url ==   url:()    
	 prefix = url..
	 data:(, #prefix) ~= prefix    
	 source = data:(#prefix + )
	 source ==     
	 loader = (__NARootHost, )    load
	 (loader) ~=     
	 ok, chunk = (loader, source, ..url)
	 ok  (chunk) ==   source  


  (key, url)
	 path = (key)
	  path  (readfile) ~=     
	 paths = {path, path..}
	 _, name  paths 
		 ok, data = (readfile, name)
		 source = ok  (data, url)
		 source   source 
	
	 


  (key, url, source)
	 path = (key)
	  path  (readfile) ~=   (writefile) ~=   (source) ~=     
	 (url) ~=   url ==   url:()    
	 data = url....source
	  (data, url)    
	 okOld, old = (readfile, path)
	 okOld  old == data    
	 (makefolder) ==  
		 current = 
		 segment  (__NA_SPLIT_CACHE_ROOT..):() 
			current = current ==   segment  current....segment
			(makefolder, current)
		
	
	 okOld  (old, url) 
		  (writefile, path.., old)    
		 okBackup, backup = (readfile, path..)
		  okBackup  backup ~= old    
	
	  (writefile, path, data)    
	 okRead, written = (readfile, path)
	 okRead  written == data


 __NA_SPLIT_ENV
 __NA_LAZY_FILES = {}
 __NA_LAZY_ORDER = {}
 __NA_MODULE_REFRESH = {}

 __NA_SPLIT_DEFER

  (name, source)
	 __NA_LAZY_FILES[name]   
	__NA_LAZY_FILES[name] = source
	__NA_LAZY_ORDER[#__NA_LAZY_ORDER + ] = name
	 #__NA_LAZY_ORDER >  
		__NA_LAZY_FILES[.(__NA_LAZY_ORDER, )] = 
	


  (name)
	 __NA_LAZY_FILES[name]   __NA_LAZY_FILES[name] 
	 source = __NA_SPLIT_PENDING_CACHE[name]
	  source 
		 meta = __NA_SPLIT_REMOTE_META  __NA_SPLIT_LOCAL_META
		 (meta) ~=   (, ) 
		source = (name)
	
	(name, source)
	 source


  ()
	 meta = __NA_SPLIT_REMOTE_META  __NA_SPLIT_LOCAL_META
	  __NA_SPLIT_LIMITED   (meta, )   
	 ok, source = (__NA_SPLIT_READ_PART, )
	  ok   
	 valid, chunk = (__NA_SPLIT_LOAD_PART, source, , {})
	  valid   
	 ran, data = (chunk)
	 ran  (data) ==  
		__NA_SPLIT_DEFER = data
		()
	


  (source, name)
	 rows = __NA_SPLIT_DEFER  __NA_SPLIT_DEFER[name]
	 (rows) ~=   #rows ==    source 
	 out, pos = {}, 
	 _, row  rows 
		 (row) ~=    source 
		 first, last, cut, line, prefix = .(row, , )
		 (first) ~=   (last) ~=   (cut) ~= 
			 (line) ~=   (prefix) ~=   first < pos  last < first  last > #source
			 first %  ~=   last %  ~=   cut %  ~=   line %  ~= 
			 (cut ~=   (cut < first  cut > last))   source 
		out[#out + ] = source:(pos, first - )
		 label = ..name....(line)
		out[#out + ] = prefix....string.(, name, first, last, cut, label)..
		pos = last + 
	
	out[#out + ] = source:(pos)
	(name, source)
	 .(out)


  (name, first, last, cut, label)
	 fn, busy
	 (...)
		 busy  .(busy) ~=   .() 
		  fn 
			busy = .()
			 ok, result = (()
				 source = (name)
				 body = cut >   ..source:(cut, last)  source:(first, last)
				 env = __NA_SPLIT_ENV
				 boot = (env) ==   (env, )
				env = (boot) ==   boot.runtimeEnv  env
				 chunk = (..body, label, env)
				 value = ()
				 (value) ~=   (..label, ) 
				 value
			)
			busy = 
			  ok  (result, ) 
			fn = result
		
		 (...)
	


  (key, url, fetch)
	 (fetch) ==  
		__NA_MODULE_REFRESH[key] = {url = url, fetch = fetch}
	


  ()
	  __NA_SPLIT_LIMITED   __NA_SPLIT_REMOTE_META  (.spawn) ~=    
	.(()
		 key, record  __NA_MODULE_REFRESH 
			  ()   
			 ok, source = (record.fetch)
			 ok  (source) ==   () 
				(__NA_SPLIT_SAVE_MODULE, key, record.url, source)
			
			__NA_MODULE_REFRESH[key] = 
			.()
		
		.(__NA_MODULE_REFRESH)
	)


  ()
	()
	__NA_SPLIT_CONFIG.state = __NA_GLOBAL_STATE
	__NA_SPLIT_CONFIG.privateRoot = __NA_GLOBAL_ENV
	__NA_SPLIT_CONFIG.privateRegistry = __NA_SPLIT_REG
	__NA_SPLIT_CONFIG.cacheRoot = __NA_SPLIT_CACHE_ROOT
	__NA_SPLIT_CONFIG.offline = __NA_SPLIT_REMOTE_META == 
	__NA_SPLIT_CONFIG.fastStart = __NA_SPLIT_LIMITED
	__NA_SPLIT_CONFIG.moduleRefresh = __NA_SPLIT_QUEUE_REFRESH
	__NA_SPLIT_CONFIG.moduleRead = __NA_SPLIT_READ_MODULE
	__NA_SPLIT_CONFIG.moduleWrite = __NA_SPLIT_SAVE_MODULE
	 environment = ({
		__NA_SPLIT_CONFIG = __NA_SPLIT_CONFIG;
		__NA_SPLIT_LAZY = __NA_SPLIT_LAZY;
		NACaller = __NARootNACaller;
		__NARootHost = __NARootHost;
		__NARootPreviousNACaller = __NARootPreviousNACaller;
		__NARootErrorState = __NARootErrorState;
		__NARootExecutorInfo = __NARootExecutorInfo;
		__NARootDebugInfo = __NARootDebugInfo;
		__NARootNextErrorPath = __NARootNextErrorPath;
		__NARootReportError = __NARootReportError;
		__NARootNACaller = __NARootNACaller;
	}, {
		__index = (target, key)
			 boot = (target, )
			 runtime = (boot) ==   boot.runtimeEnv
			 (runtime) ==  
				 value = (runtime, key)
				 value ~=  
					 value
				
			
			 __NARootHost[key]
		;
		__newindex = (target, key, value)
			 boot = (target, )
			 runtime = (boot) ==   boot.runtimeEnv
			 (runtime) ==   key ~=   key ~=   key ~=  
				(runtime, key, value)
			
				(target, key, value)
			
		;
	})
	__NA_SPLIT_ENV = environment
	 index = , __NA_SPLIT_COUNT 
		  () 
			(, )
		
		 partName = .(, index)
		__NA_GLOBAL_STATE.details.stage = partName
		__NA_GLOBAL_STATE.details.fingerprint = (__NA_SPLIT_REMOTE_META  __NA_SPLIT_LOCAL_META, partName)
		(partName)
		 source = (partName)
		  ()  (, ) 
		 chunk = ((source, partName), ..partName, environment)
		 okRun, runError = (chunk, __NA_SPLIT_FORMAT_ERROR)
		chunk = 
		source = 
		  okRun 
			((runError), )
		
		 index ==  
			 runError ==  
				__NA_SPLIT_CONFIG.duplicate = 
				__NA_SPLIT_ENV = 
				
			
			 boot = (environment, )
			 (boot) ~=   (boot.runtimeEnv) ~=  
				(, )
			
			 migrated = {}
			 key, value  environment 
				 key ~=   key ~=   key ~=   key ~=   key ~=  
					migrated[key] = value
				
			
			 key, value  migrated 
				(boot.runtimeEnv, key, value)
				(environment, key, )
			
			environment = boot.runtimeEnv
			__NA_SPLIT_ENV = environment
		
		(partName)
		()
	
	  () 
		(, )
	
	()
	__NA_GLOBAL_STATE.details.stage = 
	()
	(__NA_SPLIT_CACHE_LOADER, __NA_SPLIT_REMOTE_META  __NA_SPLIT_LOCAL_META)
	 saved = ((__NA_SPLIT_CACHE_ROOT, ), __NA_SPLIT_CACHE_ROOT..)
	 expected = __NA_SPLIT_REMOTE_META  __NA_SPLIT_LOCAL_META
	 __NA_SPLIT_CACHE_OK  saved  expected  saved.version == expected.version 
		(__NA_SPLIT_CLEAR_LEGACY)
	


  ()
	  ()   
	 environment = __NA_SPLIT_ENV
	 (environment) ~=    
	 boot = (environment, )
	 (boot) ==   (boot.splitConfig) ==   boot.splitConfig.state ~= __NA_GLOBAL_STATE   
	 runtime = (boot) ==   boot.runtimeEnv  environment
	 manage = (runtime, )
	 unload = (manage) ==   (manage, )
	 (unload) ==  
		 ok, done = (unload, { silent =  })
		 ok  done ~=    
	
	 (manage) ==   (manage._runtimeState) ==  
		manage._runtimeState.unloading = 
		manage._runtimeState.runToken = 
	
	 seen = {}
	 current = .()
	  (thread)
		 (manage) ==   (manage.CancelRuntimeTask) ==  
			(manage.CancelRuntimeTask, thread)
		 () ==  
			(.cancel, thread)
		
	
	  (value)
		 (value) ~=   seen[value]   
		 (boot) ==   (value == boot  value == boot.hostEnv
			 value == boot.privateRegistry  value == boot.privateRoot  value == runtime)   
		seen[value] = 
		 (value, ) ~=   ((value, )) ==  
			((value, ), value)
		
		 key, child  , value 
			 (child) ==  
				(() child:() )
			 (child) ==   child ~= current  .(child) ~=   () ==  
				(child)
			 (child) ==  
				(child)
			
			 (key) ==   key ~= current  .(key) ~=   () ==   (key) 
		
	
	 _, name  { , , , , , ,  }  ((runtime, name)) 
	 stuff = (runtime, )
	 (stuff) ==   (stuff.NASCREENGUI) ==  
		(() stuff.NASCREENGUI:() )
	
	 assets = (runtime, )
	 (assets) ==   (assets.ui) ==  
		(() assets.ui:() )
	
	 (boot) ==   (boot.privateRoot) ==  
		 root = boot.privateRoot
		 owned = (runtime, )
		 ownsRoot = (owned) ==   root.testing == owned
		 protector = (runtime, )
		 (protector) ~=   ownsRoot  protector = root.uiProtector 
		 (protector) ==   (ownsRoot  root.uiProtector ~= protector) 
			 (protector.destroy) ==   (protector.destroy) 
			 root.uiProtector == protector  root.uiProtector =  
		
		 ownsRoot 
			root.testing = 
			root.naRuns = 
		
	


__NA_GLOBAL_STATE.details = {
	stage = ;
	session = (.PlaceId)....(.JobId);
	build = (__NA_SPLIT_REMOTE_META  __NA_SPLIT_REMOTE_META.version)  (__NA_SPLIT_LOCAL_META  __NA_SPLIT_LOCAL_META.version)  ;
}

 __NARootResult = .(({
	context = ;
	details = __NA_GLOBAL_STATE.details;
	severity = ;
	 = ;
	log = ;
}, __NA_SPLIT_RUN))

  __NARootResult[]  (__NA_SPLIT_ABORT) 

 ( __NARootResult[]  __NA_SPLIT_CONFIG.duplicate)  (__NARootHost) == 
	 (__NARootHost, ) == __NARootNACaller 
	(()
		 __NARootPreviousNACaller ~=  
			(__NARootHost, , __NARootPreviousNACaller)
		
			(__NARootHost, , )
		
	)


 __NARootResult[] 
	( __NA_SPLIT_CONFIG.duplicate)
	  __NA_SPLIT_CONFIG.duplicate  () 
	 .(__NARootResult, , __NARootResult.n)


()