11 files changed, 125 insertions, 124 deletions

diff --git a/src/cancel.cpp b/src/cancel.cpp
index 8b8977b..0f7a6af 100644
--- a/src/cancel.cpp
+++ b/src/cancel.cpp
@@ -55,8 +55,8 @@ THE SOFTWARE.
 */
 static inline CancelRequest cancel_test(lua_State* L)
 {
-    Lane* const lane{ get_lane_from_registry(L) };
-    // 's' is nullptr for the original main state (and no-one can cancel that)
+    Lane* const lane{ LANE_POINTER_REGKEY.readLightUserDataValue<Lane>(L) };
+    // 'lane' is nullptr for the original main state (and no-one can cancel that)
     return lane ? lane->cancel_request : CancelRequest::None;
 }
 
diff --git a/src/cancel.h b/src/cancel.h
index 9cd7d5b..481cca4 100644
--- a/src/cancel.h
+++ b/src/cancel.h
@@ -48,15 +48,12 @@ enum CancelOp
 // crc64/we of string "CANCEL_ERROR" generated at http://www.nitrxgen.net/hashgen/
 static constexpr UniqueKey CANCEL_ERROR{ 0xe97d41626cc97577ull }; // 'raise_cancel_error' sentinel
 
-// crc64/we of string "CANCEL_TEST_KEY" generated at http://www.nitrxgen.net/hashgen/
-static constexpr UniqueKey CANCEL_TEST_KEY{ 0xe66f5960c57d133aull }; // used as registry key
-
 CancelResult thread_cancel(lua_State* L, Lane* lane_, CancelOp op_, double secs_, bool force_, double waitkill_timeout_);
 
 [[noreturn]] static inline void raise_cancel_error(lua_State* L)
 {
     STACK_GROW(L, 1);
-    CANCEL_ERROR.push(L); // special error value
+    CANCEL_ERROR.pushKey(L); // special error value
     raise_lua_error(L); // doesn't return
 }
 
diff --git a/src/deep.cpp b/src/deep.cpp
index 652b19d..290e5ff 100644
--- a/src/deep.cpp
+++ b/src/deep.cpp
@@ -32,8 +32,9 @@ THE SOFTWARE.
 ===============================================================================
 */
 
-#include "compat.h"
 #include "deep.h"
+
+#include "compat.h"
 #include "tools.h"
 #include "uniquekey.h"
 #include "universe.h"
@@ -95,7 +96,7 @@ static void get_deep_lookup( lua_State* L)
 {
     STACK_GROW( L, 1);
     STACK_CHECK_START_REL(L, 1);                             // a
-    DEEP_LOOKUP_KEY.query_registry(L);                       // a {}
+    DEEP_LOOKUP_KEY.pushValue(L);                            // a {}
     if( !lua_isnil( L, -1))
     {
         lua_insert( L, -2);                                  // {} a
diff --git a/src/keeper.cpp b/src/keeper.cpp
index f88d0ab..aab7abe 100644
--- a/src/keeper.cpp
+++ b/src/keeper.cpp
@@ -188,7 +188,7 @@ static void push_table(lua_State* L, int idx_)
     STACK_GROW(L, 5);
     STACK_CHECK_START_REL(L, 0);
     idx_ = lua_absindex(L, idx_);
-    FIFOS_KEY.query_registry(L);               // ud fifos
+    FIFOS_KEY.pushValue(L);                    // ud fifos
     lua_pushvalue(L, idx_);                    // ud fifos ud
     lua_rawget(L, -2);                         // ud fifos fifos[ud]
     STACK_CHECK(L, 2);
@@ -209,16 +209,17 @@ static void push_table(lua_State* L, int idx_)
 
 int keeper_push_linda_storage(Universe* U, lua_State* L, void* ptr_, uintptr_t magic_)
 {
-    Keeper* const K = which_keeper( U->keepers, magic_);
-    lua_State* const KL = K ? K->L : nullptr;
-    if( KL == nullptr) return 0;
+    Keeper* const K{ which_keeper(U->keepers, magic_) };
+    lua_State* const KL{ K ? K->L : nullptr };
+    if (KL == nullptr)
+        return 0;
     STACK_GROW(KL, 4);
     STACK_CHECK_START_REL(KL, 0);
-    FIFOS_KEY.query_registry(KL);                                 // fifos
+    FIFOS_KEY.pushValue(KL);                                      // fifos
     lua_pushlightuserdata(KL, ptr_);                              // fifos ud
     lua_rawget(KL, -2);                                           // fifos storage
     lua_remove(KL, -2);                                           // storage
-    if( !lua_istable(KL, -1))
+    if (!lua_istable(KL, -1))
     {
         lua_pop(KL, 1);                                           //
         STACK_CHECK(KL, 0);
@@ -229,7 +230,7 @@ int keeper_push_linda_storage(Universe* U, lua_State* L, void* ptr_, uintptr_t m
     STACK_GROW(L, 5);
     STACK_CHECK_START_REL(L, 0);
     lua_newtable(L);                                                                           // out
-    while( lua_next(KL, -2))                                      // storage key fifo
+    while (lua_next(KL, -2))                                      // storage key fifo
     {
         keeper_fifo* fifo = prepare_fifo_access(KL, -1);          // storage key fifotbl
         lua_pushvalue(KL, -2);                                    // storage key fifotbl key
@@ -263,7 +264,7 @@ int keepercall_clear(lua_State* L)
 {
     STACK_GROW(L, 3);
     STACK_CHECK_START_REL(L, 0);
-    FIFOS_KEY.query_registry(L);                // ud fifos
+    FIFOS_KEY.pushValue(L);                     // ud fifos
     lua_pushvalue(L, 1);                        // ud fifos ud
     lua_pushnil(L);                             // ud fifos ud nil
     lua_rawset(L, -3);                          // ud fifos
@@ -722,7 +723,7 @@ void init_keepers(Universe* U, lua_State* L)
         lua_pushfstring(K, "Keeper #%d", i + 1);                   //                              "Keeper #n"
         lua_setglobal(K, "decoda_name");                           //
         // create the fifos table in the keeper state
-        FIFOS_KEY.set_registry(K, [](lua_State* L) { lua_newtable(L); });
+        FIFOS_KEY.setValue(K, [](lua_State* L) { lua_newtable(L); });
         STACK_CHECK(K, 0);
     }
     STACK_CHECK(L, 0);
@@ -788,7 +789,7 @@ void keeper_toggle_nil_sentinels(lua_State* L, int val_i_, LookupMode const mode
         {
             if (lua_isnil(L, i))
             {
-                NIL_SENTINEL.push(L);
+                NIL_SENTINEL.pushKey(L);
                 lua_replace(L, i);
             }
         }
diff --git a/src/lanes.cpp b/src/lanes.cpp
index 86972f7..327c2df 100644
--- a/src/lanes.cpp
+++ b/src/lanes.cpp
@@ -1,6 +1,6 @@
 /*
- * LANES.C                              Copyright (c) 2007-08, Asko Kauppi
- *                                      Copyright (C) 2009-19, Benoit Germain
+ * LANES.CPP                            Copyright (c) 2007-08, Asko Kauppi
+ *                                      Copyright (C) 2009-24, Benoit Germain
  *
  * Multithreading in Lua.
  * 
@@ -56,7 +56,7 @@
 ===============================================================================
 
 Copyright (C) 2007-10 Asko Kauppi <akauppi@gmail.com>
-              2011-19 Benoit Germain <bnt.germain@gmail.com>
+              2011-24 Benoit Germain <bnt.germain@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -79,22 +79,17 @@ THE SOFTWARE.
 ===============================================================================
 */
 
-#include <string.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <ctype.h>
-#include <assert.h>
-
 #include "lanes.h"
-#include "threading.h"
+
 #include "compat.h"
-#include "tools.h"
-#include "state.h"
-#include "universe.h"
 #include "keeper.h"
 #include "lanes_private.h"
+#include "state.h"
+#include "threading.h"
+#include "tools.h"
+#include "universe.h"
 
-#if !(defined( PLATFORM_XBOX) || defined( PLATFORM_WIN32) || defined( PLATFORM_POCKETPC))
+#if !(defined(PLATFORM_XBOX) || defined(PLATFORM_WIN32) || defined(PLATFORM_POCKETPC))
 # include <sys/time.h>
 #endif
 
@@ -157,8 +152,8 @@ static bool push_registry_table( lua_State* L, UniqueKey key, bool create)
     STACK_GROW(L, 3);
     STACK_CHECK_START_REL(L, 0);
 
-    key.query_registry(L);                                                       // ?
-    if (lua_isnil(L, -1))                                                       // nil?
+    key.pushValue(L);                                                             // ?
+    if (lua_isnil(L, -1))                                                         // nil?
     {
         lua_pop(L, 1);                                                            //
         STACK_CHECK(L, 0);
@@ -168,8 +163,8 @@ static bool push_registry_table( lua_State* L, UniqueKey key, bool create)
             return false;
         }
 
-        lua_newtable( L);                                                          // t
-        key.set_registry(L, [](lua_State* L) { lua_pushvalue(L, -2); });
+        lua_newtable(L);                                                          // t
+        key.setValue(L, [](lua_State* L) { lua_pushvalue(L, -2); });
     }
     STACK_CHECK(L, 1);
     return true;    // table pushed
@@ -653,14 +648,14 @@ LUAG_FUNC( set_error_reporting)
         return luaL_error(L, "unsupported error reporting model");
     }
 done:
-    EXTENDED_STACKTRACE_REGKEY.set_registry(L, [equal](lua_State* L) { lua_pushboolean(L, equal); });
+    EXTENDED_STACKTRACE_REGKEY.setValue(L, [equal](lua_State* L) { lua_pushboolean(L, equal); });
     return 0;
 }
 
-static int lane_error( lua_State* L)
+static int lane_error(lua_State* L)
 {
     // error message (any type)
-    STACK_CHECK_START_ABS(L, 1);                                                              // some_error
+    STACK_CHECK_START_ABS(L, 1);                                                       // some_error
 
     // Don't do stack survey for cancelled lanes.
     //
@@ -670,9 +665,7 @@ static int lane_error( lua_State* L)
     }
 
     STACK_GROW(L, 3);
-    EXTENDED_STACKTRACE_REGKEY.query_registry(L);                                       // some_error basic|extended
-    bool const extended{ lua_toboolean(L, -1) ? true : false};
-    lua_pop(L, 1);                                                                     // some_error
+    bool const extended{ EXTENDED_STACKTRACE_REGKEY.readBoolValue(L) };
     STACK_CHECK(L, 1);
 
     // Place stack trace at 'registry[STACKTRACE_REGKEY]' for the 'lua_pcall()'
@@ -685,7 +678,7 @@ static int lane_error( lua_State* L)
     //
     // table of { "sourcefile.lua:<line>", ... }
     //
-    lua_newtable( L);                                                                   // some_error {}
+    lua_newtable(L);                                                                   // some_error {}
 
     // Best to start from level 1, but in some cases it might be a C function
     // and we don't get '.currentline' for that. It's okay - just keep level
@@ -697,7 +690,7 @@ static int lane_error( lua_State* L)
         lua_getinfo(L, extended ? "Sln" : "Sl", &ar);
         if (extended)
         {
-            lua_newtable( L);                                                           // some_error {} {}
+            lua_newtable(L);                                                           // some_error {} {}
 
             lua_pushstring(L, ar.source);                                              // some_error {} {} source
             lua_setfield(L, -2, "source");                                             // some_error {} {}
@@ -726,7 +719,7 @@ static int lane_error( lua_State* L)
     }
 
     // store the stack trace table in the registry
-    STACKTRACE_REGKEY.set_registry(L, [](lua_State* L) { lua_insert(L, -2); });        // some_error
+    STACKTRACE_REGKEY.setValue(L, [](lua_State* L) { lua_insert(L, -2); });            // some_error
 
     STACK_CHECK(L, 1);
     return 1; // the untouched error value
@@ -748,7 +741,7 @@ static void push_stack_trace( lua_State* L, int rc_, int stk_base_)
             // fetch the call stack table from the registry where the handler stored it
             STACK_GROW(L, 1);
             // yields nil if no stack was generated (in case of cancellation for example)
-            STACKTRACE_REGKEY.query_registry(L);                                       // err trace|nil
+            STACKTRACE_REGKEY.pushValue(L);                                            // err trace|nil
             STACK_CHECK(L, 1);
 
             // For cancellation the error message is CANCEL_ERROR, and a stack trace isn't placed
@@ -780,7 +773,7 @@ LUAG_FUNC(set_debug_threadname)
     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.set_registry(L, [](lua_State* L) { lua_pushvalue(L, -2); });
+    hidden_regkey.setValue(L, [](lua_State* L) { lua_pushvalue(L, -2); });
     STACK_CHECK(L, 1);
     lane->debug_name = lua_tostring(L, -1);
     // keep a direct pointer on the string
@@ -1213,7 +1206,7 @@ LUAG_FUNC( lane_new)
     STACK_CHECK_RESET_REL(L, 0);
     STACK_CHECK( L2, 1 + nargs);
 
-    // 's' is allocated from heap, not Lua, since its life span may surpass the handle's (if free running thread)
+    // 'lane' is allocated from heap, not Lua, since its life span may surpass the handle's (if free running thread)
     //
     // a Lane full userdata needs a single uservalue
     Lane** const ud{ lua_newuserdatauv<Lane*>(L, 1) };               // func libs priority globals package required gc_cb lane
@@ -1257,15 +1250,15 @@ LUAG_FUNC( lane_new)
     // Store the gc_cb callback in the uservalue
     if (gc_cb_idx > 0)
     {
-        GCCB_KEY.push(L);                                            // func libs priority globals package required gc_cb lane uv k
+        GCCB_KEY.pushKey(L);                                        // func libs priority globals package required gc_cb lane uv k
         lua_pushvalue(L, gc_cb_idx);                                // func libs priority globals package required gc_cb lane uv k gc_cb
         lua_rawset(L, -3);                                          // func libs priority globals package required gc_cb lane uv
     }
 
     lua_setiuservalue(L, -2, 1);                                    // func libs priority globals package required gc_cb lane
 
-    // Store 's' in the lane's registry, for 'cancel_test()' (we do cancel tests at pending send/receive).
-    CANCEL_TEST_KEY.set_registry(L2, [lane](lua_State* L) { lua_pushlightuserdata(L, lane); });                                                // func [... args ...]
+    // Store 'lane' in the lane's registry, for 'cancel_test()' (we do cancel tests at pending send/receive).
+    LANE_POINTER_REGKEY.setValue(L2, [lane](lua_State* L) { lua_pushlightuserdata(L, lane); });                                                // func [... args ...]
 
     STACK_CHECK(L, 1);
     STACK_CHECK( L2, 1 + nargs);
@@ -1298,7 +1291,7 @@ LUAG_FUNC(thread_gc)
 
     // if there a gc callback?
     lua_getiuservalue(L, 1, 1);                                          // ud uservalue
-    GCCB_KEY.push(L);                                                    // ud uservalue __gc
+    GCCB_KEY.pushKey(L);                                                 // ud uservalue __gc
     lua_rawget(L, -2);                                                   // ud uservalue gc_cb|nil
     if (!lua_isnil(L, -1))
     {
@@ -1988,12 +1981,12 @@ LUAG_FUNC(configure)
     lua_pushinteger(L, THREAD_PRIO_MAX);                                                  // settings M THREAD_PRIO_MAX
     lua_setfield(L, -2, "max_prio");                                                      // settings M
 
-    CANCEL_ERROR.push(L);                                                                 // settings M CANCEL_ERROR
+    CANCEL_ERROR.pushKey(L);                                                              // settings M CANCEL_ERROR
     lua_setfield(L, -2, "cancel_error");                                                  // settings M
 
     STACK_CHECK(L, 2); // reference stack contains only the function argument 'settings'
     // we'll need this every time we transfer some C function from/to this state
-    LOOKUP_REGKEY.set_registry(L, [](lua_State* L) { lua_newtable(L); });                 // settings M
+    LOOKUP_REGKEY.setValue(L, [](lua_State* L) { lua_newtable(L); });                     // settings M
     STACK_CHECK(L, 2);
 
     // register all native functions found in that module in the transferable functions database
@@ -2016,7 +2009,7 @@ LUAG_FUNC(configure)
     lua_pop(L, 1);                                                                        // settings
 
     // set _R[CONFIG_REGKEY] = settings
-    CONFIG_REGKEY.set_registry(L, [](lua_State* L) { lua_pushvalue(L, -2); });
+    CONFIG_REGKEY.setValue(L, [](lua_State* L) { lua_pushvalue(L, -2); });
     STACK_CHECK(L, 1);
     DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "%p: lanes.configure() END\n" INDENT_END, L));
     DEBUGSPEW_CODE(--U->debugspew_indent_depth);
@@ -2105,11 +2098,11 @@ LANES_API int luaopen_lanes_core( lua_State* L)
 
     // Create main module interface table
     // we only have 1 closure, which must be called to configure Lanes
-    lua_newtable( L);                                   // M
+    lua_newtable(L);                                   // M
     lua_pushvalue(L, 1);                               // M "lanes.core"
     lua_pushvalue(L, -2);                              // M "lanes.core" M
     lua_pushcclosure(L, LG_configure, 2);              // M LG_configure()
-    CONFIG_REGKEY.query_registry(L);                    // M LG_configure() settings
+    CONFIG_REGKEY.pushValue(L);                        // M LG_configure() settings
     if (!lua_isnil(L, -1)) // this is not the first require "lanes.core": call configure() immediately
     {
         lua_pushvalue(L, -1);                          // M LG_configure() settings settings
diff --git a/src/lanes_private.h b/src/lanes_private.h
index 85b3c52..1530b9e 100644
--- a/src/lanes_private.h
+++ b/src/lanes_private.h
@@ -72,21 +72,13 @@ struct Lane
     // For tracking only
 };
 
+// xxh64 of string "LANE_POINTER_REGKEY" generated at https://www.pelock.com/products/hash-calculator
+static constexpr UniqueKey LANE_POINTER_REGKEY{ 0xB3022205633743BCull }; // used as registry key
+
 // To allow free-running threads (longer lifespan than the handle's)
 // 'Lane' are malloc/free'd and the handle only carries a pointer.
 // This is not deep userdata since the handle's not portable among lanes.
 //
 #define lua_toLane( L, i) (*((Lane**) luaL_checkudata( L, i, "Lane")))
 
-static inline Lane* get_lane_from_registry( lua_State* L)
-{
-    STACK_GROW( L, 1);
-    STACK_CHECK_START_REL(L, 0);
-    CANCEL_TEST_KEY.query_registry(L);
-    Lane* const s{ lua_tolightuserdata<Lane>(L, -1) }; // lightuserdata (true 'Lane' pointer) / nil
-    lua_pop( L, 1);
-    STACK_CHECK( L, 0);
-    return s;
-}
-
 int push_thread_status( lua_State* L, Lane* s);
diff --git a/src/linda.cpp b/src/linda.cpp
index 77dc4cb..14eba2d 100644
--- a/src/linda.cpp
+++ b/src/linda.cpp
@@ -216,11 +216,8 @@ LUAG_FUNC(linda_protected_call)
 LUAG_FUNC(linda_send)
 {
     Linda* const linda{ lua_toLinda<false>(L, 1) };
-    bool ret{ false };
-    CancelRequest cancel{ CancelRequest::None };
-    int pushed;
-    time_d timeout = -1.0;
-    int key_i = 2; // index of first key, if timeout not there
+    time_d timeout{ -1.0 };
+    int key_i{ 2 }; // index of first key, if timeout not there
 
     if (lua_type(L, 2) == LUA_TNUMBER) // we don't want to use lua_isnumber() because of autocoercion
     {
@@ -250,7 +247,7 @@ LUAG_FUNC(linda_send)
         if (as_nil_sentinel)
         {
             // send a single nil if nothing is provided
-            NIL_SENTINEL.push(L);
+            NIL_SENTINEL.pushKey(L);
         }
         else
         {
@@ -260,9 +257,11 @@ LUAG_FUNC(linda_send)
 
     // convert nils to some special non-nil sentinel in sent values
     keeper_toggle_nil_sentinels(L, key_i + 1, eLM_ToKeeper);
-
+    bool ret{ false };
+    CancelRequest cancel{ CancelRequest::None };
+    int pushed{ 0 };
     {
-        Lane* const lane{ get_lane_from_registry(L) };
+        Lane* const lane{ LANE_POINTER_REGKEY.readLightUserDataValue<Lane>(L) };
         Keeper* const K{ which_keeper(linda->U->keepers, linda->hashSeed()) };
         lua_State* const KL{ K ? K->L : nullptr };
         if (KL == nullptr)
@@ -339,7 +338,7 @@ LUAG_FUNC(linda_send)
     {
         case CancelRequest::Soft:
         // if user wants to soft-cancel, the call returns lanes.cancel_error
-        CANCEL_ERROR.push(L);
+        CANCEL_ERROR.pushKey(L);
         return 1;
 
         case CancelRequest::Hard:
@@ -387,7 +386,7 @@ LUAG_FUNC(linda_receive)
     keeper_api_t keeper_receive;
     int expected_pushed_min{ 0 }, expected_pushed_max{ 0 };
     // are we in batched mode?
-    BATCH_SENTINEL.push(L);
+    BATCH_SENTINEL.pushKey(L);
     int const is_batched{ lua501_equal(L, key_i, -1) };
     lua_pop(L, 1);
     if (is_batched)
@@ -419,7 +418,7 @@ LUAG_FUNC(linda_receive)
         expected_pushed_min = expected_pushed_max = 2;
     }
 
-    Lane* const lane{ get_lane_from_registry(L) };
+    Lane* const lane{ LANE_POINTER_REGKEY.readLightUserDataValue<Lane>(L) };
     Keeper* const K{ which_keeper(linda->U->keepers, linda->hashSeed()) };
     if (K == nullptr)
         return 0;
@@ -492,7 +491,7 @@ LUAG_FUNC(linda_receive)
     {
         case CancelRequest::Soft:
         // if user wants to soft-cancel, the call returns CANCEL_ERROR
-        CANCEL_ERROR.push(L);
+        CANCEL_ERROR.pushKey(L);
         return 1;
 
         case CancelRequest::Hard:
@@ -551,7 +550,7 @@ LUAG_FUNC(linda_set)
     else // linda is cancelled
     {
         // do nothing and return lanes.cancel_error
-        CANCEL_ERROR.push(L);
+        CANCEL_ERROR.pushKey(L);
         pushed = 1;
     }
 
@@ -610,7 +609,7 @@ LUAG_FUNC(linda_get)
     else // linda is cancelled
     {
         // do nothing and return lanes.cancel_error
-        CANCEL_ERROR.push(L);
+        CANCEL_ERROR.pushKey(L);
         pushed = 1;
     }
     // an error can be raised if we attempt to read an unregistered function
@@ -655,7 +654,7 @@ LUAG_FUNC( linda_limit)
     else // linda is cancelled
     {
         // do nothing and return lanes.cancel_error
-        CANCEL_ERROR.push(L);
+        CANCEL_ERROR.pushKey(L);
         pushed = 1;
     }
     // propagate pushed boolean if any
@@ -961,10 +960,10 @@ static void* linda_id( lua_State* L, DeepOp op_)
             lua_setfield(L, -2, "dump");
 
             // some constants
-            BATCH_SENTINEL.push(L);
+            BATCH_SENTINEL.pushKey(L);
             lua_setfield(L, -2, "batched");
 
-            NIL_SENTINEL.push(L);
+            NIL_SENTINEL.pushKey(L);
             lua_setfield(L, -2, "null");
 
             STACK_CHECK(L, 1);
diff --git a/src/state.cpp b/src/state.cpp
index b52bdb5..2678280 100644
--- a/src/state.cpp
+++ b/src/state.cpp
@@ -203,14 +203,14 @@ static void copy_one_time_settings( Universe* U, lua_State* L, lua_State* L2)
     DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "copy_one_time_settings()\n" INDENT_END));
     DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
 
-    CONFIG_REGKEY.query_registry(L);                                               // config
+    CONFIG_REGKEY.pushValue(L);                                                    // config
     // copy settings from from source to destination registry
     if( luaG_inter_move( U, L, L2, 1, eLM_LaneBody) < 0)                           //                           // config
     {
         (void) luaL_error( L, "failed to copy settings when loading lanes.core");
     }
     // set L2:_R[CONFIG_REGKEY] = settings
-    CONFIG_REGKEY.set_registry(L2, [](lua_State* L) { lua_insert(L, -2); });                                    // config
+    CONFIG_REGKEY.setValue(L2, [](lua_State* L) { lua_insert(L, -2); });                                        // config
     STACK_CHECK( L2, 0);
     STACK_CHECK( L, 0);
     DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
@@ -273,43 +273,43 @@ lua_State* create_state( Universe* U, lua_State* from_)
 
     if (L == nullptr)
     {
-        (void) luaL_error( from_, "luaG_newstate() failed while creating state; out of memory");
+        std::ignore = luaL_error( from_, "luaG_newstate() failed while creating state; out of memory");
     }
     return L;
 }
 
-void call_on_state_create( Universe* U, lua_State* L, lua_State* from_, LookupMode mode_)
+void call_on_state_create(Universe* U, lua_State* L, lua_State* from_, LookupMode mode_)
 {
     if (U->on_state_create_func != nullptr)
     {
         STACK_CHECK_START_REL(L, 0);
-        DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "calling on_state_create()\n" INDENT_END));
-        if( U->on_state_create_func != (lua_CFunction) initialize_on_state_create)
+        DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "calling on_state_create()\n" INDENT_END));
+        if (U->on_state_create_func != (lua_CFunction) initialize_on_state_create)
         {
             // C function: recreate a closure in the new state, bypassing the lookup scheme
-            lua_pushcfunction( L, U->on_state_create_func);                             // on_state_create()
+            lua_pushcfunction(L, U->on_state_create_func); // on_state_create()
         }
         else // Lua function located in the config table, copied when we opened "lanes.core"
         {
-            if( mode_ != eLM_LaneBody)
+            if (mode_ != eLM_LaneBody)
             {
                 // if attempting to call in a keeper state, do nothing because the function doesn't exist there
                 // this doesn't count as an error though
                 STACK_CHECK(L, 0);
                 return;
             }
-            CONFIG_REGKEY.query_registry(L);                                            // {}
-            STACK_CHECK( L, 1);
-            lua_getfield( L, -1, "on_state_create");                                    // {} on_state_create()
-            lua_remove( L, -2);                                                         // on_state_create()
+            CONFIG_REGKEY.pushValue(L);                                                // {}
+            STACK_CHECK(L, 1);
+            lua_getfield(L, -1, "on_state_create");                                    // {} on_state_create()
+            lua_remove(L, -2);                                                         // on_state_create()
         }
-        STACK_CHECK( L, 1);
+        STACK_CHECK(L, 1);
         // capture error and raise it in caller state
-        if( lua_pcall( L, 0, 0, 0) != LUA_OK)
+        if (lua_pcall(L, 0, 0, 0) != LUA_OK)
         {
-            luaL_error( from_, "on_state_create failed: \"%s\"", lua_isstring( L, -1) ? lua_tostring( L, -1) : lua_typename( L, lua_type( L, -1)));
+            luaL_error(from_, "on_state_create failed: \"%s\"", lua_isstring(L, -1) ? lua_tostring(L, -1) : lua_typename(L, lua_type(L, -1)));
         }
-        STACK_CHECK( L, 0);
+        STACK_CHECK(L, 0);
     }
 }
 
@@ -339,7 +339,7 @@ lua_State* luaG_newstate( Universe* U, lua_State* from_, char const* libs_)
     STACK_CHECK(L, 0);
 
     // we'll need this every time we transfer some C function from/to this state
-    LOOKUP_REGKEY.set_registry(L, [](lua_State* L) { lua_newtable(L); });
+    LOOKUP_REGKEY.setValue(L, [](lua_State* L) { lua_newtable(L); });
     STACK_CHECK(L, 0);
 
     // neither libs (not even 'base') nor special init func: we are done
diff --git a/src/tools.cpp b/src/tools.cpp
index 52c70bc..98224ae 100644
--- a/src/tools.cpp
+++ b/src/tools.cpp
@@ -64,7 +64,7 @@ void push_registry_subtable_mode( lua_State* L, UniqueKey key_, const char* mode
     STACK_GROW(L, 3);
     STACK_CHECK_START_REL(L, 0);
 
-    key_.query_registry(L);                                               // {}|nil
+    key_.pushValue(L);                                                    // {}|nil
     STACK_CHECK(L, 1);
 
     if (lua_isnil(L, -1))
@@ -72,7 +72,7 @@ void push_registry_subtable_mode( lua_State* L, UniqueKey key_, const char* mode
         lua_pop(L, 1);                                                    //
         lua_newtable(L);                                                  // {}
         // _R[key_] = {}
-        key_.set_registry(L, [](lua_State* L) { lua_pushvalue(L, -2); }); // {}
+        key_.setValue(L, [](lua_State* L) { lua_pushvalue(L, -2); });     // {}
         STACK_CHECK(L, 1);
 
         // Set its metatable if requested
@@ -554,7 +554,7 @@ void populate_func_lookup_table( lua_State* L, int _i, char const* name_)
     DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
     STACK_GROW( L, 3);
     STACK_CHECK_START_REL(L, 0);
-    LOOKUP_REGKEY.query_registry(L);                                                 // {}
+    LOOKUP_REGKEY.pushValue(L);                                                      // {}
     STACK_CHECK( L, 1);
     ASSERT_L( lua_istable( L, -1));
     if( lua_type( L, in_base) == LUA_TFUNCTION) // for example when a module is a simple function
@@ -570,7 +570,7 @@ void populate_func_lookup_table( lua_State* L, int _i, char const* name_)
     }
     else if( lua_type( L, in_base) == LUA_TTABLE)
     {
-        lua_newtable( L);                                                            // {} {fqn}
+        lua_newtable(L);                                                             // {} {fqn}
         if( name_)
         {
             STACK_CHECK( L, 2);
@@ -584,12 +584,12 @@ void populate_func_lookup_table( lua_State* L, int _i, char const* name_)
             STACK_CHECK( L, 2);
         }
         // retrieve the cache, create it if we haven't done it yet
-        LOOKUPCACHE_REGKEY.query_registry(L);                                          // {} {fqn} {cache}?
+        LOOKUPCACHE_REGKEY.pushValue(L);                                               // {} {fqn} {cache}?
         if( lua_isnil( L, -1))
         {
             lua_pop( L, 1);                                                            // {} {fqn}
             lua_newtable( L);                                                          // {} {fqn} {cache}
-            LOOKUPCACHE_REGKEY.set_registry(L, [](lua_State* L) { lua_pushvalue(L, -2); });
+            LOOKUPCACHE_REGKEY.setValue(L, [](lua_State* L) { lua_pushvalue(L, -2); });
             STACK_CHECK( L, 3);
         }
         // process everything we find in that table, filling in lookup data for all functions and tables we see there
@@ -698,7 +698,7 @@ static char const* find_lookup_name(lua_State* L, int i, LookupMode mode_, char
     else
     {
         // fetch the name from the source state's lookup table
-        LOOKUP_REGKEY.query_registry(L);                       // ... v ... {}
+        LOOKUP_REGKEY.pushValue(L);                            // ... v ... {}
         STACK_CHECK( L, 1);
         ASSERT_L( lua_istable( L, -1));
         lua_pushvalue( L, i);                                  // ... v ... {} v
@@ -771,7 +771,7 @@ static bool lookup_table(lua_State* L2, lua_State* L, int i, LookupMode mode_, c
 
         case eLM_LaneBody:
         case eLM_FromKeeper:
-        LOOKUP_REGKEY.query_registry(L2);                                                    // {}
+        LOOKUP_REGKEY.pushValue(L2);                                                         // {}
         STACK_CHECK( L2, 1);
         ASSERT_L( lua_istable( L2, -1));
         lua_pushlstring( L2, fqn, len);                                                      // {} "f.q.n"
@@ -1072,7 +1072,7 @@ static void lookup_native_func(lua_State* L2, lua_State* L, int i, LookupMode mo
 
         case eLM_LaneBody:
         case eLM_FromKeeper:
-        LOOKUP_REGKEY.query_registry(L2);                                                    // {}
+        LOOKUP_REGKEY.pushValue(L2);                                                         // {}
         STACK_CHECK( L2, 1);
         ASSERT_L( lua_istable( L2, -1));
         lua_pushlstring( L2, fqn, len);                                                      // {} "f.q.n"
diff --git a/src/uniquekey.h b/src/uniquekey.h
index 93aaf37..bd3b61f 100644
--- a/src/uniquekey.h
+++ b/src/uniquekey.h
@@ -31,7 +31,7 @@ class UniqueKey
         return m_storage == rhs_.m_storage;
     }
 
-    void push(lua_State* const L) const
+    void pushKey(lua_State* const L) const
     {
         lua_pushlightuserdata(L, std::bit_cast<void*>(m_storage));
     }
@@ -39,17 +39,38 @@ class UniqueKey
     {
         return lua_touserdata(L, i) == std::bit_cast<void*>(m_storage);
     }
-    void query_registry(lua_State* const L) const
+    void pushValue(lua_State* const L) const
     {
-        push(L);
+        pushKey(L);
         lua_rawget(L, LUA_REGISTRYINDEX);
     }
     template <typename OP>
-    void set_registry(lua_State* L, OP operation_) const
+    void setValue(lua_State* L, OP operation_) const
     {
         // Note we can't check stack consistency because operation is not always a push (could be insert, replace, whatever)
-        push(L);                              // ... key
+        pushKey(L);                           // ... key
         operation_(L);                        // ... key value
         lua_rawset(L, LUA_REGISTRYINDEX);     // ...
     }
+    template <typename T>
+    T* readLightUserDataValue(lua_State* const L) const
+    {
+        STACK_GROW(L, 1);
+        STACK_CHECK_START_REL(L, 0);
+        pushValue(L);
+        T* const value{ lua_tolightuserdata<T>(L, -1) }; // lightuserdata/nil
+        lua_pop(L, 1);
+        STACK_CHECK(L, 0);
+        return value;
+    }
+    bool readBoolValue(lua_State* const L) const
+    {
+        STACK_GROW(L, 1);
+        STACK_CHECK_START_REL(L, 0);
+        pushValue(L);
+        bool const value{ lua_toboolean(L, -1) ? true : false}; // bool/nil
+        lua_pop(L, 1);
+        STACK_CHECK(L, 0);
+        return value;
+    }
 };
diff --git a/src/universe.cpp b/src/universe.cpp
index 3792da6..c487ac0 100644
--- a/src/universe.cpp
+++ b/src/universe.cpp
@@ -50,8 +50,8 @@ Universe* universe_create(lua_State* L)
     Universe* const U = static_cast<Universe*>(lua_newuserdatauv(L, sizeof(Universe), 0));         // universe
     U->Universe::Universe();
     STACK_CHECK_START_REL(L, 1);
-    UNIVERSE_FULL_REGKEY.set_registry(L, [](lua_State* L) { lua_pushvalue(L, -2); });
-    UNIVERSE_LIGHT_REGKEY.set_registry(L, [U](lua_State* L) { lua_pushlightuserdata( L, U); });
+    UNIVERSE_FULL_REGKEY.setValue(L, [](lua_State* L) { lua_pushvalue(L, -2); });
+    UNIVERSE_LIGHT_REGKEY.setValue(L, [U](lua_State* L) { lua_pushlightuserdata( L, U); });
     STACK_CHECK(L, 1);
     return U;
 }
@@ -62,7 +62,7 @@ void universe_store(lua_State* L, Universe* U)
 {
     ASSERT_L(universe_get(L) == nullptr);
     STACK_CHECK_START_REL(L, 0);
-    UNIVERSE_LIGHT_REGKEY.set_registry(L, [U](lua_State* L) { U ? lua_pushlightuserdata( L, U) : lua_pushnil( L); });
+    UNIVERSE_LIGHT_REGKEY.setValue(L, [U](lua_State* L) { U ? lua_pushlightuserdata( L, U) : lua_pushnil( L); });
     STACK_CHECK( L, 0);
 }
 
@@ -70,11 +70,8 @@ void universe_store(lua_State* L, Universe* U)
 
 Universe* universe_get(lua_State* L)
 {
-    STACK_GROW(L, 2);
     STACK_CHECK_START_REL(L, 0);
-    UNIVERSE_LIGHT_REGKEY.query_registry(L);
-    Universe* const universe{ lua_tolightuserdata<Universe>(L, -1) }; // nullptr if nil
-    lua_pop(L, 1);
-    STACK_CHECK(L, 0);
+    Universe* const universe{ UNIVERSE_LIGHT_REGKEY.readLightUserDataValue<Universe>(L) };
+    STACK_CHECK( L, 0);
     return universe;
 }