LuaScriptRuntime.cpp

/*
 * This file is part of the CitizenFX project - http://citizen.re/
 *
 * See LICENSE and MENTIONS in the root of the source tree for information
 * regarding licensing.
 */

#include "StdInc.h"
#include "fxScripting.h"

#include <ScriptEngine.h>
#include <ScriptInvoker.h>

#include "LuaScriptRuntime.h"
#include "LuaScriptNatives.h"
#include "ResourceScriptingComponent.h"
#include "fxScriptBuffer.h"

#include <msgpack.hpp>
#include <json.hpp>

#include <CoreConsole.h>
#include <Profiler.h>

#include <lua.hpp>
#include <lua_cmsgpacklib.h>
#include <lua_rapidjsonlib.h>
#include <lmprof_lib.h>

#include "LuaFXLib.h"
#include "VFSManager.h"
#include <lglmlib.hpp>

extern LUA_INTERNAL_LINKAGE
{
#include <lobject.h>

#include <lmprof_state.h>
#include <collections/lmprof_record.h>
#include <collections/lmprof_traceevent.h>
#include <collections/lmprof_stack.h>
}

using namespace fx::invoker;

#if defined(GTA_FIVE)
static constexpr std::pair<const char*, ManifestVersion> g_scriptVersionPairs[] = {
	{ "natives_21e43a33.lua", guid_t{ 0 } },
	{ "natives_0193d0af.lua", "f15e72ec-3972-4fe4-9c7d-afc5394ae207" },
	{ "natives_universal.lua", "44febabe-d386-4d18-afbe-5e627f4af937" }
};
#elif defined(IS_RDR3)
static constexpr std::pair<const char*, ManifestVersion> g_scriptVersionPairs[] = {
	{ "rdr3_universal.lua", guid_t{ 0 } }
};
#elif defined(GTA_NY)
static constexpr std::pair<const char*, ManifestVersion> g_scriptVersionPairs[] = {
	{ "ny_universal.lua", guid_t{ 0 } }
};
#else
static constexpr std::pair<const char*, ManifestVersion> g_scriptVersionPairs[] = {
	{ "natives_server.lua", guid_t{ 0 } }
};
#endif

// Additional flag to denote the profiler was created by IScriptProfiler
#define LMPROF_STATE_FX_PROFILER 0x80000000

// Utility for sanitizing error messages in an unprotected states. Avoid string coercion (cvt2str) to ensure errors 
// do not compound.
#define LUA_SCRIPT_TRACE(L, MSG, ...)                  \
	try                                                \
	{                                                  \
		const char* err = Lua_GetErrorMessage(L, -1);  \
		ScriptTrace(MSG ": %s\n", ##__VA_ARGS__, err); \
	}                                                  \
	catch (...)                                        \
	{                                                  \
	}                                                  \
	lua_pop((L), 1)

static uint8_t g_awaitSentinel;

/// <summary>
/// </summary>
static fx::OMPtr<fx::LuaScriptRuntime> g_currentLuaRuntime;

/// <summary>
/// </summary>
static IScriptHost* g_lastScriptHost;

bool g_hadProfiler;

#if defined(LUA_USE_RPMALLOC)
#include "rpmalloc/rpmalloc.h"

// Global static object handling rpmalloc initializing and finalizing
struct rpmalloc_GlobalGuard
{
	rpmalloc_GlobalGuard() { rpmalloc_initialize(); }
	~rpmalloc_GlobalGuard() { rpmalloc_finalize(); }
} static rp_global_guard;

lua_State* fx::LuaStateHolder::lua_rpmalloc_state(void*& opaque)
{
	static auto lua_rpmalloc = [](void* ud, void* ptr, size_t osize, size_t nsize) -> void*
	{
		heap_t* heap = static_cast<heap_t*>(ud);
		if (nsize == 0)
		{
			rpmalloc_heap_free(heap, ptr);
			return NULL;
		}
		else if (ptr == NULL)
		{
			return rpmalloc_heap_aligned_alloc(heap, 16, nsize);
		}
		else
		{
			return rpmalloc_heap_aligned_realloc(heap, ptr, 16, nsize, osize, 0);
		}
	};

	static auto lua_panic = [](lua_State* L) -> int
	{
		const char* msg = lua_tostring(L, -1);
		if (msg == NULL)
		{
			msg = "error object is not a string";
		}

		lua_writestringerror("PANIC: unprotected error in call to Lua API (%s)\n", msg);
		return 0; /* return to Lua to abort */
	};

	heap_t* rpmalloc_heap = rpmalloc_heap_acquire();
	if (rpmalloc_heap != nullptr)
	{
		lua_State* L = lua_newstate(lua_rpmalloc, static_cast<void*>(rpmalloc_heap));
		if (L != nullptr)
		{
			opaque = static_cast<void*>(rpmalloc_heap);
			lua_atpanic(L, lua_panic);
		}
		else
		{
			rpmalloc_heap_release(rpmalloc_heap);
		}
		return L;
	}
	return nullptr;
}

void fx::LuaStateHolder::lua_rpmalloc_free(void* opaque)
{
	rpmalloc_heap_free_all(static_cast<heap_t*>(opaque));
	rpmalloc_heap_release(static_cast<heap_t*>(opaque));
}

#endif

// luaL_openlibs version without io/os libs
static const luaL_Reg lualibs[] = {
	{ "_G", luaopen_base },
	{ LUA_TABLIBNAME, luaopen_table },
	{ LUA_STRLIBNAME, luaopen_string },
	{ LUA_MATHLIBNAME, luaopen_math },
	{ LUA_COLIBNAME, luaopen_coroutine },
	{ LUA_UTF8LIBNAME, luaopen_utf8 },
	{ LUA_FX_DEBUGLIBNAME, fx::lua_fx_opendebug },
#ifdef IS_FXSERVER
	{ LUA_FX_IOLIBNAME, fx::lua_fx_openio },
	{ LUA_FX_OSLIBNAME, fx::lua_fx_openos },
#endif
	{ "msgpack", luaopen_cmsgpack },
	{ "json", luaopen_rapidjson },
	{ nullptr, nullptr }
};

/// <summary>
/// Console
/// </summary>
namespace fx
{
void ScriptTraceV(const char* string, fmt::printf_args formatList)
{
	auto t = fmt::vsprintf(string, formatList);
	console::Printf(fmt::sprintf("script:%s", LuaScriptRuntime::GetCurrent()->GetResourceName()), "%s", t);

	LuaScriptRuntime::GetCurrent()->GetScriptHost()->ScriptTrace(const_cast<char*>(t.c_str()));
}

int Lua_Print(lua_State* L)
{
	const int n = lua_gettop(L); /* number of arguments */

	lua_getglobal(L, "tostring");
	for (int i = 1; i <= n; i++)
	{
		lua_pushvalue(L, -1); /* function to be called */
		lua_pushvalue(L, i); /* value to print */
		lua_call(L, 1, 1);

		size_t l = 0;
		const char* s = lua_tolstring(L, -1, &l); /* get result */
		if (s == NULL)
			return luaL_error(L, "'tostring' must return a string to 'print'");

		if (i > 1)
			ScriptTrace("%s", std::string("\t", 1));
		ScriptTrace("%s", std::string(s, l));
		lua_pop(L, 1); /* pop result */
	}
	ScriptTrace("\n");
	return 0;
}

static const char* Lua_GetErrorMessage(lua_State* L, int index)
{
	const char* msg = "error object is not a string";
	if (lua_type(L, index) == LUA_TSTRING)
	{
		msg = lua_tostring(L, index);
	}
	else if (luaL_callmeta(L, index, "__tostring") && lua_type(L, -1) == LUA_TSTRING)
	{
		msg = lua_tostring(L, -1);
		lua_pop(L, 1);
	}
	else
	{
		lua_pop(L, 1);
	}

	return msg;
}

static void Lua_Warn(void* ud, const char* msg, int tocont)
{
	static bool cont = false;

	if (!cont)
	{
		bool newline = (msg[0] != '\0' && msg[strlen(msg) - 1] != '\n');
		console::PrintWarning(fmt::sprintf("script:%s:warning", LuaScriptRuntime::GetCurrent()->GetResourceName()), "%s%s", msg, newline ? "\n" : "");
	}
	else
	{
		console::Printf(fmt::sprintf("script:%s:warning", LuaScriptRuntime::GetCurrent()->GetResourceName()), "%s", msg);
	}

	cont = (tocont) ? true : false;
}
}

/// <summary>
/// CitizenLib
/// </summary>
namespace fx
{
struct LuaBoundary
{
	lua_Integer hint;
	lua_State* thread;
};

class LuaProfilerScope
{
private:
	fx::LuaScriptRuntime* luaRuntime;
	const bool begin;
	bool requiresClose;

public:
	LuaProfilerScope(fx::LuaScriptRuntime* luaRuntime_, bool begin_ = true)
		: luaRuntime(luaRuntime_), begin(begin_), requiresClose(false)
	{
		requiresClose = luaRuntime->IScriptProfiler_Tick(begin) != 0;
	}

	~LuaProfilerScope()
	{
		Close();
	}

	void LUA_INLINE Close()
	{
		if (requiresClose)
		{
			requiresClose = false;
			luaRuntime->IScriptProfiler_Tick(!begin);
		}
	}
};

static int Lua_Trace(lua_State* L)
{
	ScriptTrace("%s", luaL_checkstring(L, 1));
	return 0;
}

static int Lua_SetTickRoutine(lua_State* L)
{
	return 0;
}

static int Lua_SetStackTraceRoutine(lua_State* L)
{
	// push the routine to reference and add a reference
	lua_pushvalue(L, 1);

	const int ref = luaL_ref(L, LUA_REGISTRYINDEX);

	// set the tick callback in the current routine
	auto luaRuntime = LuaScriptRuntime::GetCurrent().GetRef();

	luaRuntime->SetStackTraceRoutine([=](void* start, void* end, char** blob, size_t* size)
	{
		// static array for retval output (sadly)
		static std::vector<char> retvalArray(32768);
		LuaProfilerScope _profile(luaRuntime);

		// set the error handler
		lua_pushcfunction(L, luaRuntime->GetDbTraceback());

		const int eh = lua_gettop(L);

		// get the referenced function
		lua_rawgeti(L, LUA_REGISTRYINDEX, ref);

		// push arguments on the stack
		if (start)
		{
			auto startRef = (LuaBoundary*)start;
			lua_pushinteger(L, startRef->hint);

			if (startRef->thread)
			{
				lua_pushthread(startRef->thread);
				lua_xmove(startRef->thread, L, 1);
			}
			else if (auto thread = luaRuntime->GetRunningThread())
			{
				lua_pushthread(thread);
				lua_xmove(thread, L, 1);
			}
			else
			{
				lua_pushnil(L);
			}
		}
		else
		{
			lua_pushnil(L);

			if (auto thread = luaRuntime->GetRunningThread())
			{
				lua_pushthread(thread);
				lua_xmove(thread, L, 1);
			}
			else
			{
				lua_pushnil(L);
			}
		}

		if (end)
		{
			auto endRef = (LuaBoundary*)end;
			lua_pushinteger(L, endRef->hint);

			if (endRef->thread)
			{
				lua_pushthread(endRef->thread);
				lua_xmove(endRef->thread, L, 1);
			}
			else
			{
				lua_pushnil(L);
			}
		}
		else
		{
			lua_pushnil(L);
			lua_pushnil(L);
		}

		// invoke the tick routine
		if (lua_pcall(L, 4, 1, eh) != 0)
		{
			LUA_SCRIPT_TRACE(L, "Error running stack trace function for resource %s", luaRuntime->GetResourceName());

			*blob = nullptr;
			*size = 0;
		}
		else
		{
			const char* retvalString = lua_tolstring(L, -1, size);

			if (*size > retvalArray.size())
			{
				retvalArray.resize(*size);
			}

			memcpy(&retvalArray[0], retvalString, fwMin(retvalArray.size(), *size));

			*blob = &retvalArray[0];

			lua_pop(L, 1); // as there's a result
		}

		lua_pop(L, 1);
	});

	return 0;
}

static int Lua_SetBoundaryRoutine(lua_State* L)
{
	// push the routine to reference and add a reference
	lua_pushvalue(L, 1);

	int ref = luaL_ref(L, LUA_REGISTRYINDEX);
	auto luaRuntime = LuaScriptRuntime::GetCurrent().GetRef();

	luaRuntime->SetBoundaryRoutine(ref);

	return 0;
}

static int Lua_SetEventRoutine(lua_State* L)
{
	// push the routine to reference and add a reference
	lua_pushvalue(L, 1);

	int ref = luaL_ref(L, LUA_REGISTRYINDEX);

	// set the event callback in the current routine
	auto luaRuntime = LuaScriptRuntime::GetCurrent().GetRef();

	luaRuntime->SetEventRoutine([=](const char* eventName, const char* eventPayload, size_t payloadSize, const char* eventSource)
	{
		LuaProfilerScope _profile(luaRuntime);

		// set the error handler
		lua_pushcfunction(L, luaRuntime->GetDbTraceback());

		int eh = lua_gettop(L);

		// get the referenced function
		lua_rawgeti(L, LUA_REGISTRYINDEX, ref);

		// push arguments on the stack
		lua_pushstring(L, eventName);
		lua_pushlstring(L, eventPayload, payloadSize);
		lua_pushstring(L, eventSource);

		// invoke the tick routine
		if (lua_pcall(L, 3, 0, eh) != 0)
		{
			LUA_SCRIPT_TRACE(L, "Error running system event handling function for resource %s", luaRuntime->GetResourceName());
		}

		lua_pop(L, 1);
	});

	return 0;
}

static int Lua_SetCallRefRoutine(lua_State* L)
{
	// push the routine to reference and add a reference
	lua_pushvalue(L, 1);

	const int ref = luaL_ref(L, LUA_REGISTRYINDEX);

	// set the event callback in the current routine
	auto luaRuntime = LuaScriptRuntime::GetCurrent().GetRef();

	luaRuntime->SetCallRefRoutine([=](int32_t refId, const char* argsSerialized, size_t argsSize)
	{
		LuaProfilerScope _profile(luaRuntime);

		// set the error handler
		lua_pushcfunction(L, luaRuntime->GetDbTraceback());

		const int eh = lua_gettop(L);

		// get the referenced function
		lua_rawgeti(L, LUA_REGISTRYINDEX, ref);

		// push arguments on the stack
		lua_pushinteger(L, refId);
		lua_pushlstring(L, argsSerialized, argsSize);

		// invoke the tick routine
		fx::OMPtr<IScriptBuffer> rv;

		if (lua_pcall(L, 2, 1, eh) != 0)
		{
			LUA_SCRIPT_TRACE(L, "Error running call reference function for resource %s", luaRuntime->GetResourceName());
		}
		else
		{
			size_t retvalLength = 0;
			const char* retvalString = lua_tolstring(L, -1, &retvalLength);

			rv = fx::MemoryScriptBuffer::Make(retvalString, retvalLength);

			lua_pop(L, 1); // as there's a result
		}

		lua_pop(L, 1);

		return rv;
	});

	return 0;
}

static int Lua_SetDeleteRefRoutine(lua_State* L)
{
	// push the routine to reference and add a reference
	lua_pushvalue(L, 1);

	const int ref = luaL_ref(L, LUA_REGISTRYINDEX);

	// set the event callback in the current routine
	auto luaRuntime = LuaScriptRuntime::GetCurrent().GetRef();

	luaRuntime->SetDeleteRefRoutine([=](int32_t refId)
	{
		LuaProfilerScope _profile(luaRuntime);

		// set the error handler
		lua_pushcfunction(L, luaRuntime->GetDbTraceback());

		const int eh = lua_gettop(L);

		// get the referenced function
		lua_rawgeti(L, LUA_REGISTRYINDEX, ref);

		// push arguments on the stack
		lua_pushinteger(L, refId);

		// invoke the routine
		if (lua_pcall(L, 1, 0, eh) != 0)
		{
			LUA_SCRIPT_TRACE(L, "Error running system ref deletion function for resource %s", luaRuntime->GetResourceName());
		}

		lua_pop(L, 1);
	});

	return 0;
}

static int Lua_SetDuplicateRefRoutine(lua_State* L)
{
	// push the routine to reference and add a reference
	lua_pushvalue(L, 1);

	const int ref = luaL_ref(L, LUA_REGISTRYINDEX);

	// set the event callback in the current routine
	auto luaRuntime = LuaScriptRuntime::GetCurrent().GetRef();

	luaRuntime->SetDuplicateRefRoutine([=](int32_t refId)
	{
		LuaProfilerScope _profile(luaRuntime);

		// set the error handler
		lua_pushcfunction(L, luaRuntime->GetDbTraceback());

		const int eh = lua_gettop(L);

		// get the referenced function
		lua_rawgeti(L, LUA_REGISTRYINDEX, ref);

		// push arguments on the stack
		lua_pushinteger(L, refId);

		// return value holder
		int32_t retval;

		// invoke the routine
		if (lua_pcall(L, 1, 1, eh) != 0)
		{
			LUA_SCRIPT_TRACE(L, "Error running system ref duplication function for resource %s", luaRuntime->GetResourceName());
		}
		else
		{
			retval = lua_tointeger(L, -1);
			lua_pop(L, 1);
		}

		lua_pop(L, 1);

		return retval;
	});

	return 0;
}

static int Lua_CanonicalizeRef(lua_State* L)
{
	auto& luaRuntime = LuaScriptRuntime::GetCurrent();

	char* refString;
	result_t hr = luaRuntime->GetScriptHost()->CanonicalizeRef(luaL_checkinteger(L, 1), luaRuntime->GetInstanceId(), &refString);

	lua_pushstring(L, refString);
	fwFree(refString);

	return 1;
}

static int Lua_InvokeFunctionReference(lua_State* L)
{
	// get required entries
	auto& luaRuntime = LuaScriptRuntime::GetCurrent();
	fx::OMPtr scriptHost = luaRuntime->GetScriptHost();
	LuaProfilerScope _profile(luaRuntime.GetRef(), false);

	size_t argLength;
	const char* argString = luaL_checklstring(L, 2, &argLength);

	// invoke
	fx::OMPtr<IScriptBuffer> retvalBuffer;
	if (FX_FAILED(scriptHost->InvokeFunctionReference(const_cast<char*>(luaL_checkstring(L, 1)), const_cast<char*>(argString), argLength, retvalBuffer.GetAddressOf())))
	{
		char* error = "Unknown";
		scriptHost->GetLastErrorText(&error);

		_profile.Close();
		lua_pushstring(L, va("Execution of function reference in script host failed: %s", error));
		return lua_error(L);
	}

	// get return values
	if (retvalBuffer.GetRef())
	{
		lua_pushlstring(L, retvalBuffer->GetBytes(), retvalBuffer->GetLength());
	}
	else
	{
		lua_pushnil(L);
	}

	// return as such
	return 1;
}

static int Lua_SubmitBoundaryStart(lua_State* L)
{
	// get required entries
	auto& luaRuntime = LuaScriptRuntime::GetCurrent();
	auto scriptHost = luaRuntime->GetScriptHost();

	lua_Integer val = lua_tointeger(L, 1);
	lua_State* thread = lua_tothread(L, 2);

	LuaBoundary b;
	b.hint = val;
	b.thread = thread;

	scriptHost->SubmitBoundaryStart((char*)&b, sizeof(b));

	return 0;
}

static int Lua_SubmitBoundaryEnd(lua_State* L)
{
	// get required entries
	auto& luaRuntime = LuaScriptRuntime::GetCurrent();
	auto scriptHost = luaRuntime->GetScriptHost();

	lua_Integer val = lua_tointeger(L, 1);
	lua_State* thread = lua_tothread(L, 2);

	LuaBoundary b;
	b.hint = val;
	b.thread = thread;

	scriptHost->SubmitBoundaryEnd((char*)&b, sizeof(b));

	return 0;
}

template<MetaField metaField>
static int Lua_GetMetaField(lua_State* L)
{
	lua_pushlightuserdata(L, ScriptNativeContext::GetMetaField(metaField));

	return 1;
}

static int Lua_GetAwaitSentinel(lua_State* L)
{
	lua_pushlightuserdata(L, &g_awaitSentinel);

	return 1;
}

static int Lua_ResultAsObject(lua_State* L)
{
	// push the routine to reference and add a reference
	lua_pushvalue(L, 1);

	int ref = luaL_ref(L, LUA_REGISTRYINDEX);

	// set the event callback in the current routine
	auto luaRuntime = LuaScriptRuntime::GetCurrent().GetRef();

	luaRuntime->SetResultAsObjectRoutine([luaRuntime, ref](lua_State* L, std::string_view object)
	{
		LuaProfilerScope _profile(luaRuntime);

		// set the error handler
		lua_pushcfunction(L, luaRuntime->GetDbTraceback());

		int eh = lua_gettop(L);

		// get the referenced function
		lua_rawgeti(L, LUA_REGISTRYINDEX, ref);

		// push arguments on the stack
		lua_pushlstring(L, object.data(), object.size());

		// invoke the tick routine
		if (lua_pcall(L, 1, 1, eh) != 0)
		{
			LUA_SCRIPT_TRACE(L, "Error running deserialization function for resource %s", luaRuntime->GetResourceName());
			lua_pushnil(L);
		}

		lua_remove(L, eh);
	});

	return Lua_GetMetaField<MetaField::ResultAsObject>(L);
}

template<MetaField field>
static int Lua_GetPointerField(lua_State* L)
{
	uintptr_t value = 0;

	const int type = lua_type(L, 1);

	// to prevent accidental passing of arguments like _r, we check if this is a userdata
	if (type == LUA_TNIL || type == LUA_TLIGHTUSERDATA || type == LUA_TUSERDATA)
	{
		value = 0;
	}
	else if constexpr (field == MetaField::PointerValueInteger)
	{
		value = (uint64_t)luaL_checkinteger(L, 1);
	}
	else if constexpr (field == MetaField::PointerValueFloat)
	{
		float fvalue = static_cast<float>(luaL_checknumber(L, 1));
		value = *reinterpret_cast<uint32_t*>(&value);
	}

	lua_pushlightuserdata(L, ScriptNativeContext::GetPointerField(field, value));

	return 1;
}

static int Lua_Require(lua_State* L)
{
	const char* name = luaL_checkstring(L, 1);
	lua_settop(L, 1); /* LOADED table will be at index 2 */
	lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
	lua_getfield(L, 2, name); /* LOADED[name] */
	if (lua_toboolean(L, -1)) /* is it there? */
	{
		return 1; /* package is already loaded */
	}

	if (strcmp(name, LUA_LMPROF_LIBNAME) == 0)
	{
		luaL_requiref(L, LUA_LMPROF_LIBNAME, luaopen_lmprof, 1);
		return 1;
	}
	else if (strcmp(name, LUA_GLMLIBNAME) == 0)
	{
		luaL_requiref(L, LUA_GLMLIBNAME, luaopen_glm, 1);
		return 1;
	}

	// @TODO: Consider implementing a custom 'loadlib' module that uses VFS,
	// for example, LoadSystemFile("citizen:/scripting/lua/json.lua"). Server
	// side luarocks integration would be pretty neat.

	return luaL_error(L, "module '%s' not found", name);
}

//
// Scheduling
//
lua_State* LuaScriptRuntime::GetRunningThread()
{
	if (!m_runningThreads.empty())
	{
		return m_runningThreads.front();
	}

	return nullptr;
}

static int Lua_Resume(lua_State* L)
{
	LuaScriptRuntime* lsRT = (LuaScriptRuntime*)lua_touserdata(L, lua_upvalueindex(1));

	auto bookmark = lua_tointeger(L, lua_upvalueindex(2));
	lsRT->RunBookmark(bookmark);

	return 0;
}

bool LuaScriptRuntime::RunBookmark(uint64_t bookmark)
{
	// --- get the ref
	lua_State* L = m_state;
	lua_rawgeti(L, LUA_REGISTRYINDEX, bookmark);
	// Lua stack: [t]

	// -- get the thread from the ref
	lua_rawgeti(L, -1, 1);
	// Lua stack: [coro, t]

	std::string_view name;
	lua_State* thread = lua_tothread(L, -1);

	// -- boundary ID
	lua_pop(L, 1);

	lua_rawgeti(L, -1, 3);
	// Lua stack: [bid, t]

	auto bid = lua_tointeger(L, -1);

	// -- profiler meta (name)
	bool hadProfiler = g_hadProfiler;

	if (hadProfiler)
	{
		lua_pop(L, 1);
		// Lua stack: [t]

		// -- get the name from the ref
		lua_rawgeti(L, -1, 2);
		// Lua stack: [name, t]

		{
			size_t len = 0;
			const char* nameRef = lua_tolstring(L, -1, &len);

			if (nameRef)
			{
				name = { nameRef, len };
			}
		}
	}

	// since we're done getting stuff, remove both 't' and the last field
	lua_pop(L, 2);
	// Lua stack: []

	// --- if coroutine status is dead...
	bool coroDead = false;

	{
		auto status = lua_status(thread);

		if (status == LUA_OK)
		{
			lua_Debug ar;
			if (lua_getstack(thread, 0, &ar) <= 0 && lua_gettop(thread) == 0)
			{
				coroDead = true;
			}
		}
		else if (status != LUA_YIELD)
		{
			coroDead = true;
		}
	}

	// -- kill the thread.
	if (coroDead)
	{
		luaL_unref(L, LUA_REGISTRYINDEX, bookmark);
		return false;
	}

	// -- running stack
	m_runningThreads.push_front(thread);

	// --- enter profiler scope
	if (hadProfiler)
	{
		static auto profiler = fx::ResourceManager::GetCurrent()->GetComponent<fx::ProfilerComponent>();
		profiler->EnterScope(std::string{ name });
	}

	// --- submit boundary start
	{
		LuaBoundary b;
		b.hint = bid;
		b.thread = thread;

		m_scriptHost->SubmitBoundaryStart((char*)&b, sizeof(b));
	}

	int nrv;
	int resumeValue = lua_resume(thread, L, 0, &nrv);

	if (resumeValue == LUA_YIELD)
	{
		auto type = lua_type(thread, -1);

		if (type == LUA_TNUMBER || type == LUA_TNIL)
		{
			auto wakeTime = (type == LUA_TNUMBER) ? (int64_t)lua_tonumber(thread, -1) : 0;
			lua_pop(thread, 1);

			m_bookmarkHost->ScheduleBookmark(this, bookmark, -wakeTime);
		}
		else if (type == LUA_TLIGHTUSERDATA)
		{
			auto userData = lua_touserdata(thread, -1);
			lua_pop(thread, 1);

			if (userData == &g_awaitSentinel)
			{
				// resume again with a reattach callback
				lua_pushlightuserdata(thread, this);
				// Lua stack: [runtime]

				lua_pushinteger(thread, bookmark);
				// Lua stack: [bookmark, runtime]

				lua_pushcclosure(thread, Lua_Resume, 2);
				// Lua stack: [resume func]

				resumeValue = lua_resume(thread, L, 1, &nrv);

				// if LUA_YIELD, cya later!
				if (resumeValue != LUA_YIELD)
				{
					// bye, thread
					luaL_unref(L, LUA_REGISTRYINDEX, bookmark);
				}
			}
		}
	}
	else
	{
		if (resumeValue != LUA_OK)
		{
			std::string err = Lua_GetErrorMessage(thread, -1);                    
			static auto formatStackTrace = fx::ScriptEngine::GetNativeHandler(HashString("FORMAT_STACK_TRACE"));
			std::string stackData = "(nil stack trace)";

			try
			{
				auto stack = FxNativeInvoke::Invoke<const char*>(formatStackTrace, nullptr, 0);
				if (stack)
				{
					stackData = stack;
				}
			}
			catch (...)
			{
				// We already have stackData set so we don't need to do anything
			}

			ScriptTrace("^1SCRIPT ERROR: %s^7\n", err);
			ScriptTrace("%s", stackData);
			int resetStatus = lua_resetthread(thread);

			std::string resetErr = Lua_GetErrorMessage(thread, -1);

			// We can't just check whether the resetStatus is OK because
			// if there was no error lua_resetthread returns the same status it received
			if (resetStatus != resumeValue || resetErr != err)
			{
				ScriptTrace("^1Error while closing to-be-closed variables: %s^7\n", resetErr);
			}
		}

		luaL_unref(L, LUA_REGISTRYINDEX, bookmark);
	}

	m_runningThreads.pop_front();

	if (hadProfiler)
	{