5 files changed, 114 insertions, 70 deletions

diff --git a/deep_test/deeptest.lua b/deep_test/deeptest.lua
index 09b638c..33de003 100644
--- a/deep_test/deeptest.lua
+++ b/deep_test/deeptest.lua
@@ -7,7 +7,7 @@ local dt = lanes.require "deep_test"
 local test_deep = true
 local test_clonable = true
 local test_uvtype = "string"
-local nupvals = _VERSION == "Lua 5.4" and 3 or 1
+local nupvals = _VERSION == "Lua 5.4" and 2 or 1
 
 local makeUserValue = function( obj_)
         if test_uvtype == "string" then
@@ -43,8 +43,7 @@ local performTest = function( obj_)
         obj_:setuv( 1, makeUserValue( obj_))
         -- lua 5.4 supports multiple uservalues of arbitrary types
         if nupvals > 1 then
-                -- keep uv #2 as nil
-                obj_:setuv( 3, "ENDUV")
+                obj_:setuv( 2, "ENDUV")
         end
 
         local t =
diff --git a/docs/index.html b/docs/index.html
index ed1c367..f08947e 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -684,7 +684,7 @@
                         <td>table</td>
                         <td>
                                 Sets the globals table for the launched threads. This can be used for giving them constants. The key/value pairs of <tt>table</tt> are transfered in the lane globals after the libraries have been loaded and the modules required.
-                                <br/>
+                                <br />
                                 The global values of different lanes are in no manner connected; modifying one will only affect the particular lane.
                         </td>
                 </tr>
@@ -698,11 +698,20 @@
                                 These tables are built from the modules listed here. <tt>required</tt> must be a list of strings, each one being the name of a module to be required. Each module is required with <tt>require()</tt> before the lanes function is invoked.
                                 So, from the required module's point of view, requiring it manually from inside the lane body or having it required this way doesn't change anything. From the lane body's point of view, the only difference is that a module not creating a global won't be accessible.
                                 Therefore, a lane body will also have to require a module manually, but this won't do anything more (see Lua's <tt>require</tt> documentation).
-                                <br/>
+                                <br />
                                 ATTEMPTING TO TRANSFER A FUNCTION REGISTERED BY A MODULE NOT LISTED HERE WILL RAISE AN ERROR.
                         </td>
                 </tr>
-                <tr id="Tr1" valign=top>
+                <tr id=".name" valign=top>
+                        <td>
+                                <code>.name</code>
+                        </td>
+                        <td>string</td>
+                        <td>
+                                Name of the lane. If <tt>"auto"</tt>, name is built from <tt>ar.short_src:ar.linedefined</tt>. Can be changed later from the inside of the lane with <tt>set_debug_threadname()</tt> (see below).
+                        </td>
+                </tr>
+                <tr id=".gc_cb" valign=top>
                         <td>
                                 <code>.gc_cb</code>
                         </td>
@@ -719,9 +728,9 @@
                         <td>
                                 The priority of lanes generated in the range -3..+3 (default is 0).
                                 These values are a mapping over the actual priority range of the underlying implementation.
-                                <br/>
+                                <br />
                                 Implementation and dependability of priorities varies by platform. Especially Linux kernel 2.6 is not supporting priorities in user mode.
-                                <br/>
+                                <br />
                                 A lane can also change its own thread priority dynamically with <a href="#priority"><tt>lanes.set_thread_priority()</tt></a>.
                         </td>
                 </tr>
@@ -732,7 +741,7 @@
                         <td> table</td>
                         <td>
                                 Specifying it when <code>libs_str</code> doesn't cause the <code>package</code> library to be loaded will generate an error.
-                                <br/>
+                                <br />
                                 If not specified, the created lane will receive the current values of <tt>package</tt>. Only <tt>path</tt>, <tt>cpath</tt>, <tt>preload</tt> and <tt>loaders</tt> (Lua 5.1)/<tt>searchers</tt> (Lua 5.2) are transfered.
                         </td>
                 </tr>
diff --git a/src/lanes.cpp b/src/lanes.cpp
index e09956c..bce75a6 100644
--- a/src/lanes.cpp
+++ b/src/lanes.cpp
@@ -201,8 +201,8 @@ void Lane::startThread(int priority_)
  */
 #define ERROR_FULL_STACK 1 // must be either 0 or 1 as we do some index arithmetics with it!
 
-// intern the debug name in the specified lua state so that the pointer remains valid when the lane's state is closed
-static void securize_debug_threadname(lua_State* L_, Lane* lane_)
+// intern the debug name in the caller lua state so that the pointer remains valid after the lane's state is closed
+void Lane::securizeDebugName(lua_State* L_)
 {
     STACK_CHECK_START_REL(L_, 0);
     STACK_GROW(L_, 3);
@@ -212,8 +212,8 @@ static void securize_debug_threadname(lua_State* L_, Lane* lane_)
     // we don't care about the actual key, so long as it's unique and can't collide with anything.
     lua_newtable(L_);                                                                              // L_: lane ... {uv} {}
     // Lua 5.1 can't do 'lane_->debugName = lua_pushstring(L_, lane_->debugName);'
-    lua_pushstring(L_, lane_->debugName);                                                          // L_: lane ... {uv} {} name
-    lane_->debugName = lua_tostring(L_, -1);
+    lua_pushstring(L_, debugName);                                                                 // L_: lane ... {uv} {} name
+    debugName = lua_tostring(L_, -1);
     lua_rawset(L_, -3);                                                                            // L_: lane ... {uv}
     lua_pop(L_, 1);                                                                                // L_: lane
     STACK_CHECK(L_, 0);
@@ -674,23 +674,36 @@ LUAG_FUNC(set_error_reporting)
 
 // #################################################################################################
 
+void Lane::changeDebugName(int nameIdx_)
+{
+    // xxh64 of string "debugName" generated at https://www.pelock.com/products/hash-calculator
+    static constexpr RegistryUniqueKey hidden_regkey{ 0xA194E2645C57F6DDull };
+    nameIdx_ = lua_absindex(L, nameIdx_);
+    luaL_checktype(L, nameIdx_, LUA_TSTRING);                                                      // L: ... "name" ...
+    STACK_CHECK_START_REL(L, 0);
+    // store a hidden reference in the registry to make sure the string is kept around even if a lane decides to manually change the "decoda_name" global...
+    hidden_regkey.setValue(L, [nameIdx = nameIdx_](lua_State* L_) { lua_pushvalue(L_, nameIdx); });// L: ... "name" ...
+    // keep a direct pointer on the string
+    debugName = lua_tostring(L, nameIdx_);
+    // to see VM name in Decoda debugger Virtual Machine window
+    lua_pushvalue(L, nameIdx_);                                                                    // L: ... "name" ... "name"
+    lua_setglobal(L, "decoda_name");                                                               // L: ... "name" ...
+    // and finally set the OS thread name
+    THREAD_SETNAME(debugName);
+    STACK_CHECK(L, 0);
+}
+
+// #################################################################################################
+
+// upvalue #1 is the lane userdata
 LUAG_FUNC(set_debug_threadname)
 {
-    // fnv164 of string "debug_threadname" generated at https://www.pelock.com/products/hash-calculator
-    constexpr RegistryUniqueKey hidden_regkey{ 0x79C0669AAAE04440ull };
     // C s_lane structure is a light userdata upvalue
     Lane* const lane{ lua_tolightuserdata<Lane>(L_, lua_upvalueindex(1)) };
-    luaL_checktype(L_, -1, LUA_TSTRING); // "name"
+    LUA_ASSERT(L_, L_ == lane->L); // this function is exported in a lane's state, therefore it is callable only from inside the Lane's state
     lua_settop(L_, 1);
-    STACK_CHECK_START_ABS(L_, 1);
-    // store a hidden reference in the registry to make sure the string is kept around even if a lane decides to manually change the "decoda_name" global...
-    hidden_regkey.setValue(L_, [](lua_State* L_) { lua_pushvalue(L_, -2); });
-    STACK_CHECK(L_, 1);
-    lane->debugName = lua_tostring(L_, -1);
-    // keep a direct pointer on the string
-    THREAD_SETNAME(lane->debugName);
-    // to see VM name in Decoda debugger Virtual Machine window
-    lua_setglobal(L_, "decoda_name"); //
+    STACK_CHECK_START_REL(L_, 0);
+    lane->changeDebugName(-1);
     STACK_CHECK(L_, 0);
     return 0;
 }
@@ -911,13 +924,14 @@ static constexpr UniqueKey kLaneGC{ 0x5D6122141727F960ull };
 //                   , [package_tbl]
 //                   , [required_tbl]
 //                   , [gc_cb_func]
+//                   , [name]
 //                  [, ... args ...])
 //
 // Upvalues: metatable to use for 'lane_ud'
 //
 LUAG_FUNC(lane_new)
 {
-    // first 7 args: func libs priority globals package required gc_cb
+    // first 8 args: func libs priority globals package required gc_cb name
     char const* const libs_str{ lua_tostring(L_, 2) };
     bool const have_priority{ !lua_isnoneornil(L_, 3) };
     int const priority{ have_priority ? static_cast<int>(lua_tointeger(L_, 3)) : kThreadPrioDefault };
@@ -925,8 +939,9 @@ LUAG_FUNC(lane_new)
     int const package_idx{ lua_isnoneornil(L_, 5) ? 0 : 5 };
     int const required_idx{ lua_isnoneornil(L_, 6) ? 0 : 6 };
     int const gc_cb_idx{ lua_isnoneornil(L_, 7) ? 0 : 7 };
+    int const name_idx{ lua_isnoneornil(L_, 8) ? 0 : 8 };
 
-    static constexpr int kFixedArgsIdx{ 7 };
+    static constexpr int kFixedArgsIdx{ 8 };
     int const nargs{ lua_gettop(L_) - kFixedArgsIdx };
     Universe* const U{ universe_get(L_) };
     LUA_ASSERT(L_, nargs >= 0);
@@ -942,7 +957,7 @@ LUAG_FUNC(lane_new)
     DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "lane_new: setup\n" INDENT_END(U)));
 
     // populate with selected libraries at the same time. 
-    lua_State* const L2{ luaG_newstate(U, SourceState{ L_ }, libs_str) };                          // L_: [7 args] ...                               L2:
+    lua_State* const L2{ luaG_newstate(U, SourceState{ L_ }, libs_str) };                          // L_: [8 args] ...                               L2:
     STACK_CHECK_START_REL(L2, 0);
 
     // 'lane' is allocated from heap, not Lua, since its life span may surpass the handle's (if free running thread)
@@ -957,14 +972,16 @@ LUAG_FUNC(lane_new)
         lua_State* const m_L;
         Lane* m_lane{ nullptr };
         int const m_gc_cb_idx;
+        int const m_name_idx;
         DEBUGSPEW_CODE(Universe* const U);
         DEBUGSPEW_CODE(DebugSpewIndentScope m_scope);
 
         public:
-        OnExit(lua_State* L_, Lane* lane_, int gc_cb_idx_ DEBUGSPEW_COMMA_PARAM(Universe* U_))
+        OnExit(lua_State* L_, Lane* lane_, int gc_cb_idx_, int name_idx_ DEBUGSPEW_COMMA_PARAM(Universe* U_))
         : m_L{ L_ }
         , m_lane{ lane_ }
         , m_gc_cb_idx{ gc_cb_idx_ }
+        , m_name_idx{ name_idx_ }
         DEBUGSPEW_COMMA_PARAM(U{ U_ })
         DEBUGSPEW_COMMA_PARAM(m_scope{ U_ })
         {
@@ -1019,6 +1036,24 @@ LUAG_FUNC(lane_new)
             }
 
             lua_setiuservalue(m_L, -2, 1);                                                         // m_L: ... lane
+
+            lua_State* L2{ m_lane->L };
+            STACK_CHECK_START_REL(L2, 0);
+            char const* const debugName{ (m_name_idx > 0) ? lua_tostring(m_L, m_name_idx) : nullptr };
+            if (debugName)
+            {
+                if (strcmp(debugName, "auto") != 0) {
+                    lua_pushstring(L2, debugName);                                                 // m_L: ... lane                                     L2: "<name>"
+                } else {
+                    lua_Debug ar;
+                    lua_pushvalue(m_L, 1);                                                         // m_L: ... lane func
+                    lua_getinfo(m_L, ">S", &ar);                                                   // m_L: ... lane
+                    lua_pushfstring(L2, "%s:%d", ar.short_src, ar.linedefined);                    // m_L: ... lane                                     L2: "<name>"
+                }
+                m_lane->changeDebugName(-1);
+                lua_pop(L2, 1);                                                                    // m_L: ... lane                                     L2:
+            }
+            STACK_CHECK(L2, 0);
             STACK_CHECK(m_L, 1);
         }
 
@@ -1029,7 +1064,7 @@ LUAG_FUNC(lane_new)
             m_lane->ready.count_down();
             m_lane = nullptr;
         }
-    } onExit{ L_, lane, gc_cb_idx DEBUGSPEW_COMMA_PARAM(U) };
+    } onExit{ L_, lane, gc_cb_idx, name_idx DEBUGSPEW_COMMA_PARAM(U) };
     // launch the thread early, it will sync with a std::latch to parallelize OS thread warmup and L2 preparation
     DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "lane_new: launching thread\n" INDENT_END(U)));
     lane->startThread(priority);
@@ -1038,11 +1073,6 @@ LUAG_FUNC(lane_new)
     STACK_GROW(L_, 3);
     STACK_CHECK_START_REL(L_, 0);
 
-    // give a default "Lua" name to the thread to see VM name in Decoda debugger
-    lua_pushfstring(L2, "Lane #%p", L2);                                                           // L_: [7 args] args...                           L2: "<name>"
-    lua_setglobal(L2, "decoda_name");                                                              // L_: [7 args] args...                           L2:
-    LUA_ASSERT(L_, lua_gettop(L2) == 0);
-
     // package
     if (package_idx != 0) {
         DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "lane_new: update 'package'\n" INDENT_END(U)));
@@ -1062,8 +1092,8 @@ LUAG_FUNC(lane_new)
             raise_luaL_error(L_, "expected required module list as a table, got %s", luaL_typename(L_, required_idx));
         }
 
-        lua_pushnil(L_);                                                                           // L_: [7 args] args... nil                       L2:
-        while (lua_next(L_, required_idx) != 0) {                                                  // L_: [7 args] args... n "modname"               L2:
+        lua_pushnil(L_);                                                                           // L_: [8 args] args... nil                       L2:
+        while (lua_next(L_, required_idx) != 0) {                                                  // L_: [8 args] args... n "modname"               L2:
             if (lua_type(L_, -1) != LUA_TSTRING || lua_type(L_, -2) != LUA_TNUMBER || lua_tonumber(L_, -2) != nbRequired) {
                 raise_luaL_error(L_, "required module list should be a list of strings");
             } else {
@@ -1073,30 +1103,30 @@ LUAG_FUNC(lane_new)
                 DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "lane_new: require '%s'\n" INDENT_END(U), name));
 
                 // require the module in the target lane
-                lua_getglobal(L2, "require");                                                      // L_: [7 args] args... n "modname"               L2: require()?
+                lua_getglobal(L2, "require");                                                      // L_: [8 args] args... n "modname"               L2: require()?
                 if (lua_isnil(L2, -1)) {
-                    lua_pop(L2, 1);                                                                // L_: [7 args] args... n "modname"               L2:
+                    lua_pop(L2, 1);                                                                // L_: [8 args] args... n "modname"               L2:
                     raise_luaL_error(L_, "cannot pre-require modules without loading 'package' library first");
                 } else {
-                    lua_pushlstring(L2, name, len);                                                // L_: [7 args] args... n "modname"               L2: require() name
-                    if (lua_pcall(L2, 1, 1, 0) != LUA_OK) {                                        // L_: [7 args] args... n "modname"               L2: ret/errcode
+                    lua_pushlstring(L2, name, len);                                                // L_: [8 args] args... n "modname"               L2: require() name
+                    if (lua_pcall(L2, 1, 1, 0) != LUA_OK) {                                        // L_: [8 args] args... n "modname"               L2: ret/errcode
                         // propagate error to main state if any
                         InterCopyContext c{ U, DestState{ L_ }, SourceState{ L2 }, {}, {}, {}, {}, {} };
-                        std::ignore = c.inter_move(1);                                             // L_: [7 args] args... n "modname" error         L2:
+                        std::ignore = c.inter_move(1);                                             // L_: [8 args] args... n "modname" error         L2:
                         raise_lua_error(L_);
                     }
-                    // here the module was successfully required                                   // L_: [7 args] args... n "modname"               L2: ret
+                    // here the module was successfully required                                   // L_: [8 args] args... n "modname"               L2: ret
                     // after requiring the module, register the functions it exported in our name<->function database
                     populate_func_lookup_table(L2, -1, name);
-                    lua_pop(L2, 1);                                                                // L_: [7 args] args... n "modname"               L2:
+                    lua_pop(L2, 1);                                                                // L_: [8 args] args... n "modname"               L2:
                 }
             }
             lua_pop(L_, 1); // L_: func libs priority globals package required gc_cb [... args ...] n
             ++nbRequired;
-        }                                                                                          // L_: [7 args] args...
+        }                                                                                          // L_: [8 args] args...
     }
     STACK_CHECK(L_, 0);
-    STACK_CHECK(L2, 0);                                                                            // L_: [7 args] args...                           L2:
+    STACK_CHECK(L2, 0);                                                                            // L_: [8 args] args...                           L2:
 
     // Appending the specified globals to the global environment
     // *after* stdlibs have been loaded and modules required, in case we transfer references to native functions they exposed...
@@ -1108,17 +1138,17 @@ LUAG_FUNC(lane_new)
         }
 
         DEBUGSPEW_CODE(DebugSpewIndentScope scope{ U });
-        lua_pushnil(L_);                                                                           // L_: [7 args] args... nil                       L2:
+        lua_pushnil(L_);                                                                           // L_: [8 args] args... nil                       L2:
         // Lua 5.2 wants us to push the globals table on the stack
         InterCopyContext c{ U, DestState{ L2 }, SourceState{ L_ }, {}, {}, {}, {}, {} };
-        lua_pushglobaltable(L2);                                                                   // L_: [7 args] args... nil                       L2: _G
-        while (lua_next(L_, globals_idx)) {                                                        // L_: [7 args] args... k v                       L2: _G
-            std::ignore = c.inter_copy(2);                                                         // L_: [7 args] args... k v                       L2: _G k v
+        lua_pushglobaltable(L2);                                                                   // L_: [8 args] args... nil                       L2: _G
+        while (lua_next(L_, globals_idx)) {                                                        // L_: [8 args] args... k v                       L2: _G
+            std::ignore = c.inter_copy(2);                                                         // L_: [8 args] args... k v                       L2: _G k v
             // assign it in L2's globals table
-            lua_rawset(L2, -3);                                                                    // L_: [7 args] args... k v                       L2: _G
-            lua_pop(L_, 1);                                                                        // L_: [7 args] args... k
-        }                                                                                          // L_: [7 args] args...
-        lua_pop(L2, 1);                                                                            // L_: [7 args] args...                           L2:
+            lua_rawset(L2, -3);                                                                    // L_: [8 args] args... k v                       L2: _G
+            lua_pop(L_, 1);                                                                        // L_: [8 args] args... k
+        }                                                                                          // L_: [8 args] args...
+        lua_pop(L2, 1);                                                                            // L_: [8 args] args...                           L2:
     }
     STACK_CHECK(L_, 0);
     STACK_CHECK(L2, 0);
@@ -1128,16 +1158,16 @@ LUAG_FUNC(lane_new)
     if (func_type == LuaType::FUNCTION) {
         DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "lane_new: transfer lane body\n" INDENT_END(U)));
         DEBUGSPEW_CODE(DebugSpewIndentScope scope{ U });
-        lua_pushvalue(L_, 1);                                                                      // L_: [7 args] args... func                      L2:
+        lua_pushvalue(L_, 1);                                                                      // L_: [8 args] args... func                      L2:
         InterCopyContext c{ U, DestState{ L2 }, SourceState{ L_ }, {}, {}, {}, {}, {} };
-        InterCopyResult const res{ c.inter_move(1) };                                              // L_: [7 args] args...                           L2: func
+        InterCopyResult const res{ c.inter_move(1) };                                              // L_: [8 args] args...                           L2: func
         if (res != InterCopyResult::Success) {
             raise_luaL_error(L_, "tried to copy unsupported types");
         }
     } else if (func_type == LuaType::STRING) {
         DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "lane_new: compile lane body\n" INDENT_END(U)));
         // compile the string
-        if (luaL_loadstring(L2, lua_tostring(L_, 1)) != 0) {                                       // L_: [7 args] args...                           L2: func
+        if (luaL_loadstring(L2, lua_tostring(L_, 1)) != 0) {                                       // L_: [8 args] args...                           L2: func
             raise_luaL_error(L_, "error when parsing lane function code");
         }
     } else {
@@ -1152,7 +1182,7 @@ LUAG_FUNC(lane_new)
         DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "lane_new: transfer lane arguments\n" INDENT_END(U)));
         DEBUGSPEW_CODE(DebugSpewIndentScope scope{ U });
         InterCopyContext c{ U, DestState{ L2 }, SourceState{ L_ }, {}, {}, {}, {}, {} };
-        InterCopyResult const res{ c.inter_move(nargs) };                                          // L_: [7 args]                                   L2: func args...
+        InterCopyResult const res{ c.inter_move(nargs) };                                          // L_: [8 args]                                   L2: func args...
         if (res != InterCopyResult::Success) {
             raise_luaL_error(L_, "tried to copy unsupported types");
         }
@@ -1161,12 +1191,12 @@ LUAG_FUNC(lane_new)
     LUA_ASSERT(L_, lua_gettop(L_) == kFixedArgsIdx);
 
     // Store 'lane' in the lane's registry, for 'cancel_test()' (we do cancel tests at pending send/receive).
-    kLanePointerRegKey.setValue(L2, [lane](lua_State* L_) { lua_pushlightuserdata(L_, lane); });   // L_: [7 args]                                   L2: func args...
+    kLanePointerRegKey.setValue(L2, [lane](lua_State* L_) { lua_pushlightuserdata(L_, lane); });   // L_: [8 args]                                   L2: func args...
     STACK_CHECK(L2, 1 + nargs);
 
     STACK_CHECK_RESET_REL(L_, 0);
     // all went well, the lane's thread can start working
-    onExit.success();                                                                              // L_: [7 args] lane                              L2: <living its own life>
+    onExit.success();                                                                              // L_: [8 args] lane                              L2: <living its own life>
     // we should have the lane userdata on top of the stack
     STACK_CHECK(L_, 1);
     return 1;
@@ -1298,7 +1328,7 @@ LUAG_FUNC(thread_join)
     Universe* const U{ lane->U };
     // debugName is a pointer to string possibly interned in the lane's state, that no longer exists when the state is closed
     // so store it in the userdata uservalue at a key that can't possibly collide
-    securize_debug_threadname(L_, lane);
+    lane->securizeDebugName(L_);
     switch (lane->status) {
     case Lane::Done:
         {
diff --git a/src/lanes.lua b/src/lanes.lua
index 8a2592b..f95dddf 100644
--- a/src/lanes.lua
+++ b/src/lanes.lua
@@ -208,25 +208,29 @@ end
 
 local opt_validators =
 {
-    priority = function(v_)
+    gc_cb = function(v_)
         local tv = type(v_)
-        return (tv == "number") and v_ or raise_option_error("priority", tv, v_)
+        return (tv == "function") and v_ or raise_option_error("gc_cb", tv, v_)
     end,
     globals = function(v_)
         local tv = type(v_)
         return (tv == "table") and v_ or raise_option_error("globals", tv, v_)
     end,
+    name = function(v_)
+        local tv = type(v_)
+        return (tv == "string") and v_ or raise_option_error("name", tv, v_)
+    end,
     package = function(v_)
         local tv = type(v_)
         return (tv == "table") and v_ or raise_option_error("package", tv, v_)
     end,
-    required = function(v_)
+    priority = function(v_)
         local tv = type(v_)
-        return (tv == "table") and v_ or raise_option_error("required", tv, v_)
+        return (tv == "number") and v_ or raise_option_error("priority", tv, v_)
     end,
-    gc_cb = function(v_)
+    required = function(v_)
         local tv = type(v_)
-        return (tv == "function") and v_ or raise_option_error("gc_cb", tv, v_)
+        return (tv == "table") and v_ or raise_option_error("required", tv, v_)
     end
 }
 
@@ -338,10 +342,10 @@ local gen = function(...)
     end
 
     local core_lane_new = assert(core.lane_new)
-    local priority, globals, package, required, gc_cb = opt.priority, opt.globals, opt.package or package, opt.required, opt.gc_cb
+    local priority, globals, package, required, gc_cb, name = opt.priority, opt.globals, opt.package or package, opt.required, opt.gc_cb, opt.name
     return function(...)
         -- must pass functions args last else they will be truncated to the first one
-        return core_lane_new(func, libs, priority, globals, package, required, gc_cb, ...)
+        return core_lane_new(func, libs, priority, globals, package, required, gc_cb, name, ...)
     end
 end -- gen()
 
@@ -569,7 +573,7 @@ local configure_timers = function()
                 end
             end
         end -- timer_body()
-        timer_lane = gen("*", { package= {}, priority = core.max_prio}, timer_body)() -- "*" instead of "io,package" for LuaJIT compatibility...
+        timer_lane = gen("*", { package= {}, priority = core.max_prio, name = "LanesTimer"}, timer_body)() -- "*" instead of "io,package" for LuaJIT compatibility...
     end -- first_time
 
     -----
diff --git a/src/lanes_private.h b/src/lanes_private.h
index 01630ba..309b632 100644
--- a/src/lanes_private.h
+++ b/src/lanes_private.h
@@ -89,6 +89,8 @@ class Lane
     [[nodiscard]] bool waitForCompletion(lua_Duration duration_);
     void startThread(int priority_);
     void pushThreadStatus(lua_State* L_);
+    void changeDebugName(int nameIdx_);
+    void securizeDebugName(lua_State* L_);
 };
 
 // xxh64 of string "kLanePointerRegKey" generated at https://www.pelock.com/products/hash-calculator