47 files changed, 6940 insertions, 8189 deletions

diff --git a/CHANGES b/CHANGES
index 34bd2d9..3725674 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,753 +1,6 @@
 CHANGES:
 
-CHANGE 160: BGe 11-Apr-24
-   * add manual control over GC behavior in keeper states
-   * update a bunch of test scripts
-   * minor internal fixes
-   * probably the last C implementation update, unless a critical bug creeps up
-   * internal version bumped to 3.17.0
-
-CHANGE 159: BGe 19-Mar-24
-   * fix small internal issue with when hitting timeout on thread kill during thread_cancel() in pthread implementation
-
-CHANGE 158: BGe 22-Feb-24
-   * naive luajit detection in PUC-Lua-based builds, and vice-versa to detect mismatches
-   * internal version bumped to 3.16.3
-
-CHANGE 157: Mitalie 17-Aug-23
-   * Prevent crash on linux as non-root
-   * internal version bumped to 3.16.2
-
-CHANGE 156: BGe 9-Aug-23
-   * new configuration option .internal_allocator to help LuaJIT users.
-   * internal version bumped to 3.16.1
-
-CHANGE 155: BGe 28-Jul-23
-   * tweaks to linux thread priority management: do nothing if not super-user. if super-user, do nothing if nothing is provided (instead of trying to force a prio when LINUX_SCHED_RR is defined).
-
-CHANGE 154: eligovision 1-Mar-22
-   * Fix 3-parametrized __lanesclone
-
-CHANGE 153: BGe 17-Feb-22
-   * NEVER use allocator obtained from lua_getallocf to allocate stuff manually when compiling for LuaJIT
-
-CHANGE 152: BGe 7-Feb-22
-   * bumped version to 3.16.0
-   * __lanesclone is now called only once with 3 parameters dest, source, size -> BREAKS CUSTOM DEEP USERDATA API
-
-CHANGE 151: BGe 7-Feb-22
-   * bumped version to 3.15.2
-   * Lanes no longer relies on malloc/free for internal allocations, but uses the primary alloc function from the master Lua state
-
-CHANGE 150: BGe 22-Sep-21
-   * fix require() wrapper to return all values returned by original require()
-
-CHANGE 149: BGe 8-Jul-21
-   * bumped version to 3.15.1
-   * fix function transfer with lua_dump for Lua 5.4 failing for functions big enough to necessitate a buffer reallocation
-
-CHANGE 148: BGe 23-Jun-21
-   * __lanesclone now receives the original as light userdata the first time it is called -> BREAKS CUSTOM DEEP USERDATA API
-
-CHANGE 147: BGe 16-Jun-21
-   * changed lanes.threads() output so that several lanes with the same name don't clobber each other in the result table -> BREAKS API
-   * bumped version to 3.15 because of the API change
-
-CHANGE 146: BGe 26-Apr-19
-   * lane:cancel() rework (see doc).
-   * opt.cancelstep is gone, hook is installed by lane:cancel() if requested
-
-CHANGE 145: BGe 28-Nov-18
-   * more code refacto
-   * don't test __lanesignore for POD types (-> slightly faster when trasnfering lots of data)
-
-CHANGE 144: BGe 28-Nov-18
-   * some code refacto
-
-CHANGE 143: BGe 27-Nov-18
-   * Lua 5.4 support
-   * __lanesclone and  lanes.nameof support userdata uservalue(s)
-
-CHANGE 142: BGe 26-Nov-18
-   * Version is available in public header
-
-CHANGE 141: BGe 25-Nov-18
-   * protect_allocator configure option is gone, long live allocator (more embedders-friendly)
-
-CHANGE 140: BGe 22-Nov-18
-   * Raise an error instead of crashing when attempting to transfer a non-deep full userdata
-
-CHANGE 139: BGe 21-Nov-18
-   * more DEBUGSPEW
-
-CHANGE 138: BGe 19-Nov-18
-   * Registry access code utility macros
-   * CONFIG_REGKEY and LOOKUP_REGKEY are now lightuserdata instead of strings
-   * Stack checking debug macros improvements
-
-CHANGE 137: BGe 15-Nov-18
-   * Deep userdata must embed DeepPrelude to save an allocation (also changes Deep protocol)
-
-CHANGE 136: BGe 15-Nov-18
-   * split linda code in a separate file
-   * rockspec for version v3.13.0
-
-CHANGE 135: BGe 11-Nov-18
-   * fix a bunch of compilation warnings
-
-CHANGE 134: BGe 3-Dec-13
-   * new API lanes.set_thread_affinity()
-   * set_debug_threadname implemented with win32 pthread
-
-CHANGE 133: BGe 8-Nov-18
-   * Make sure any linda operation that can raise an error won't ever leave a mutex unreleased
-   * lane:join() now returns nil, "timeout" in case of timeout
-
-CHANGE 132: BGe 7-Nov-18
-   * __lanesclone mechanism should actually work now
-
-CHANGE 131: BGe 7-Nov-18
-   * Fix potential crash at application shutdown when deep userdata were created before Lanes is required
-
-CHANGE 130: BGe 2-Nov-18
-   * always duplicate the config structure in new lanes even when no libraries are initialized by the generator
-     (fixes an internal error trying to call on_state_create in a lane without any libs loaded)
-
-CHANGE 129: BGe 2-Nov-18
-   * Bumped version to 3.13
-   * fix error when autodetecting protect_allocator when running under LuaJIT
-
-CHANGE 128: BGe 31-Oct-18
-   * Better default value autodetection for protect_allocator setting
-
-CHANGE 127: BGe 30-Oct-18
-   * restrict internal light userdata constants to 47 significant bits when building against LuaJIT-x64
-
-CHANGE 126: Bge 29-Oct-18
-   * Add deep user data cloning support
-
-CHANGE 125: BGe 25-Oct-18
-   * Fix Lanes build by reorganizing types around a bit
-
-CHANGE 124: BGe 9-Jul-18
-   * Fix a stack overflow when copying large tables with verbose_errors option enabled
-   * Support for integer formatting in verbose errors
-
-CHANGE 123: BGe 2-Aug-17
-   * added support for user-provided __gc in deep userdata
-   * more complete deep userdata sample
-
-CHANGE 122: BGe 1-Aug-17
-   * fix crash trying to use a deep-aware module while not requiring Lanes
-   * bumped version to 3.12
-
-CHANGE 121: BGe 13-Jun-17
-   * no longer internally assert when an error message is not a string
-
-CHANGE 120: BGe 5-Jun-17
-   * new API function lanes.register( "name", module) to manually register a module table after it was required
-   * Transfering registered module tables will link the equivalent in the destination state instead of cloning it
-   * bumped version to 3.11
-
-CHANGE 119: BGe 10-May-17
-   * Fixed some compilation warnings
-   * Improved LuaJIT support
-
-CHANGE 118: trukanduk 21-Nov-16
-   * bumped version to 3.10.1
-   * objects with a metatable that contains __lanesignore are skipped during data transfers
-
-CHANGE 117: mpeterv 21-Nov-16
-   * Fix an implicit number-to-string conversion
-
-CHANGE 116: BGe, mpeterv 27-Apr-15
-   * bumped version to 3.10.0
-   * segfault fixed in LG_lane_new
-   * Lua 5.3 support
-
-CHANGE 115: BGe 18-Sep-14
-   * bumped version to 3.9.7
-   * new function lanes.sleep()
-
-CHANGE 114: BGe 8-Jul-14
-   * Postponed _G scan for function lookup database to after on_state_create invocation
-   * Fixed a crash when USE_DEBUG_SPEW == 1
-
-CHANGE 113: BGe 17-Jun-14
-   * bumped version to 3.9.6
-   * separate deep userdata code in a dedicated file to allow external modules to implement Lanes-compatible deep userdata without requiring a binary dependency against the Lanes module
-     because of this linda_id function(eDO_metatable) must push 2 values on the stack: a metatable and a deep version string obtained from luaG_pushdeepversion()
-
-CHANGE 112 BGe 16-May-14
-   * bumped version to 3.9.5
-   * fix linda.__towatch to return non-nil when the linda is empty
-   * lanes.gen() error reporting improvements
-
-CHANGE 111 BGe 24-Apr-14
-   * fixed linda:send() possibly returning an undefined value
-
-CHANGE 110 Stepets 20-Apr-14
-   * fix LuaJIT detection issues
-
-CHANGE 109 BGe 03-Apr-14
-   * moved some Lua-version compatibility code in separate source files
-
-CHANGE 108: BGe 20-Mar-14
-   * bumped version to 3.9.4
-   * set_finalizer throws an error if provided finalizer isn't a function
-   * fix error handling when the error doesn't generate an error handler call (IOW, all errors but LUA_ERRRUN)
-   * provide callstack if LUA_ERRRUN occurs inside a finalizer
-
-CHANGE 107: BGe 19-Mar-14
-   * Make sure we don't mutex-wrap require() more than once, just in case
-
-CHANGE 106: BGe 17-Mar-14
-   * Fixed crash when using protect_allocator option
-
-CHANGE 105: BGe 27-Feb-14
-   * Bumped version to 3.9.3
-   * new exposed variable linda.null that exposes the internal NIL_SENTINEL marker
-   * linda:send() interprets send key linda.null as authorization to silently send a single nil when not provided with anything to send
-     (useful when sending results of a function that can return nothing)
-
-CHANGE 104: BGe 25-Feb-14
-   * Bumped version to 3.9.2
-   * Internal rework: the whole Lanes engine now works "per universe" to allow concurrent Lanes execution in more than one embedded master state
-   * this universe is a full userdata created in the master state, selfdestruct_gc is the __gc for this userdata
-   * most of what was initialized only once is now per-universe
-   * Fixed potential crashes at desinit if problems occur during keeper states initialisation
-   * Fixed require() not always serialized properly
-   * Raise an error instead of crashing on deep userdata prelude memory allocation failure
-   * Added forgotten mutex desinitialisation at universe shutdown
-
-CHANGE 103: BGe 24-Feb-14
-   * Fix lookup database table not being created when it should if Lanes is required in more than one Lua master state
-
-CHANGE 102: BGe 18-Feb-14
-   * raise an error instead of dereferencing a NULL pointer on deep userdata creation and lane struct creation
-
-CHANGE 101: BGe 18-Feb-14
-   * version 3.9.1
-   * removed some keeper desinit legacy dead code
-   * keeper array is allocated with master state's alloc function instead of malloc()/free()
-   * prevent application crash when specifying a very large number of keepers in the configuration options
-   * any error occuring during one-time inits is raised outside the one-time mutex protected code region
-
-CHANGE 100: BGe 17-Feb-14
-   * lanes.linda() accepts an optional integer group to give control on keeper state repartition
-
-CHANGE 99: BGe 17-Feb-14
-   * version 3.9.0
-   * keepers now require "package", receive package.path & package.cpath, and call on_state_create() if it is a C function
-   * changed the deep public API (improved deep idfunc signature, renamed luaG_deep_userdata to luaG_newdeepuserdata)
-   * if an error occurs while copying a deep userdata, don't raise inside the keeper state
-   * fixed situations where raised errors could lead to memory leaks (deep gc)
-
-CHANGE 98: BGe 13-Feb-14
-   * version 3.8.5
-   * linda:limit() returns lanes.cancel_error on a limited linda
-   * lanes.genlock() and lanes.genatomic() support cancelled lindas by returning lanes.cancel_error whenever appropriate
-   * fixed a possible Lua stack overflow when calling linda:dump()
-   * fixed cases where linda:send() and linda:receive() would not return lanes.cancel_error when they should
-
-CHANGE 97: BGe 10-Feb-14
-   * version 3.8.4
-   * new API linda:cancel("read"|"write"|"both"|"none")
-   * all linda operations return lanes.cancel_error on a cancelled linda
-   * raised an internal string length so that longer linda names are fully output before truncation applies when doing tostring( linda)
-
-CHANGE 96: BGe 24-Jan-14
-   * another Lua stack overflow fix when sending complex function through lindas or as lane body
-
-CHANGE 95: BGe 22-Jan-14
-   * version 3.8.3
-   * fixed a possible Lua stack overflow when sending complex function through lindas or as lane body
-   * experimental: lanes.nameof() scans the registry if a regular search didn't yield anything interesting
-   * fixed lanes.nameof() misbehaving when encountering a LUA_TTHREAD object
-
-CHANGE 94: BGe 22-Jan-14
-   * version 3.8.2
-   * new lane launcher option gc_cb to set a callback that is invoked when a lane is garbage collected
-   * Fix more invalid memory accesses when fetching the name of a joined lane with lanes:threads() (because its lua_State is closed)
-
-CHANGE 93: BGe 20-Jan-14
-   * slightly improve linda performance when the producer/consumer scenario leaves leave the key empty
-
-CHANGE 92: BGe 20-Jan-14
-   * version 3.8.1
-   * new function lane:get_debug_threadname()
-   * Fix invalid memory accesses when fetching the name of a joined lane with lanes:threads() (because its lua_State is closed)
-   * use luaL_newmetatable() to create the metatable for lane objects
-   * prevent malicious code from crashing by calling lane methods without passing the lane as first argument (raise an error instead)
-   * set_debug_threadname() is no longer registered in the function lookup databases because it holds a C pointer as upvalue and it might crash if used maliciously
-
-CHANGE 91: BGe 20-Jan-14
-   * version 3.8.0
-   * linda:set() accepts multiple values to set in the specified slot
-   * linda:get() accepts an optional count to peek several values at once
-
-CHANGE 90: BGe 16-Jan-14
-   * version 3.7.8
-   * lane:cancel() now accepts a boolean second argument when soft cancelling (negative timeout) to wake the thread if necessary
-   * if a blocked linda send() or receive() call is interrupted by a cancellation request,
-     it returns CANCEL_ERROR so that this case can be differentiated from a simple timeout
-   * fixed WIN32 THREAD_CREATE() wrong _beginthreadex() error detection
-   * fatal WIN32 threading errors retrieve and output the error description string with FormatMessage()
-   * fixed missing lanes.set_singlethreaded
-   * fixed perftest.lua
-   * added test/cancel.lua
-
-CHANGE 89: BGe 09-Jan-14
-   * version 3.7.7
-   * fix crash when calling linda:count() on unknown keys
-   * purge key storage with linda:set( key, nil) on an unlimited key to reduce memory usage with lots of keys
-   * linda:limit() wakes write-blocked threads if necessary when the new limit enables writes to occur again
-   * linda:set() wakes write-blocked threads if necessary if the operation created some room to write into
-
-CHANGE 88: BGe 06-Jan-14
-   * version 3.7.6
-   * if config.on_state_create() is a C function, call it by direct C closure reconstruction in newly created states
-
-CHANGE 87: BGe 20-Dec-13
-   * version 3.7.5
-   * fixed a crash that can occur at shutdown when an object stored inside a keeper state performs a linda operation on a linda making use of another keeper
-   * new setting demote_full_userdata to select between light userdata demotion or raising an error when attempting to transfer a non-deep full userdata
-
-CHANGE 86: BGe 3-Dec-13
-   * version 3.7.4
-   * internal refactoring of pthread priority management code
-   * new API lanes.set_thread_priority()
-
-CHANGE 85: BGe 28-Nov-13
-   * version 3.7.3
-   * set pthread thread cancel type to PTHREAD_CANCEL_ASYNCHRONOUS
-   * lane_h:cancel() accepts a 3rd timeout argument used when waiting for actual thread termination (hitting the timeout raises an error)
-   * added PROPAGATE_ALLOCF macro to select state creation mode (lua_newstate or luaL_newstate)
-
-CHANGE 84: BGe 18-Nov-13
-   * Fix a deadlock when GCing during a linda operation.
-   * Fix a compilation warning about an unused variable
-   * Get rid of uintptr_t to remove dependency on stdint.h
-   * Fix internal error at lane creation when the generator doesn't open any base library
-
-CHANGE 83: BGe 16-Nov-13
-   * version 3.7.2
-   * Fixed function returned by lanes.genlock() not handling numeric keys properly when release lock
-   * Enable lanes.genlock() to attempt lock with an optional "try" mode
-   * make EnableCrashingOnCrashes a one-time operation
-
-CHANGE 82: BGe 13-Nov-13
-   * Fix a case where an error could be raised inside a keeper state
-
-CHANGE 81: BGe 07-Nov-13
-   * Make set_finalizer(), set_debug_threadname(), cancel_test() and set_error_reporting() transferable from lane to lane
-   * Improved some DEBUGSPEW output
-
-CHANGE 80: BGe 06-Nov-13
-   * Fix a few compilation warnings about uninitialized variables
-   * Fixed a bad extern variable declaration resulting in multiple instances (crashes the Pelles-C build)
-
-CHANGE 79: BGe 04-Nov-13
-   * Fix lanes.nameof() crashing when encountering a light userdata
-
-CHANGE 78: BGe 25-Oct-13
-   * Fix windows build not exporting public 'deep' API
-   * Don't call on_state_create in keeper states, as it is no longer necessary
-   * Remove inclusion of stdint.h
-   * Fix windows build for WINVER > 0x400
-
-CHANGE 77: BGe 22-Oct-13
-   * version 3.7.1
-   * errors inside finalizers generate a full stack just like any other error
-
-CHANGE 76: BGe 10-Oct-13
-   * version 3.7.0
-   * fix lanes.threads() not being available in a lane where lanes.configure() settings didn't contain track_lanes although the initial configure() call did.
-
-CHANGE 75: BGe 7-Oct-13
-   * require "lanes".configure() sequence is only necessary at the first require "lanes".
-
-CHANGE 74: BGe 7-Oct-13
-   * fix a crash at application shutdown where in some situations we could deinitialize the protected allocator mutex while a lane was still using it.
-
-CHANGE 73: BGe 4-Oct-13
-   * fix timers broken by change 69
-
-CHANGE 72: BGe 3-Oct-13
-   * bugfix: no longer create a global named "lanes.core" inside lanes having "*" as library list
-
-CHANGE 71: BGe 30-Sept-13
-   * version 3.6.6
-   * properly handle cases when a Lua C module is a C function
-
-CHANGE 70: BGe 27-Step-13
-   * no longer call core.configure with dummy params when requiring lanes more than once (fixes potential multithreading issues with LuaJIT allocator)
-   * activated EnableCrashingOnCrashes() is active on Win32 debug builds
-   * fixed some comments in code
-
-CHANGE 69: BGe 26-Sept-13
-   * version 3.6.5
-   * Reduce memory footprint, simplify module order setup in conjuction with Lanes, and send over native functions a bit faster as well
-   * Lanes no longer has to internally require modules inside the keeper states because they no longer need a lookup database
-     the lookup name is stored as-is and actually converted in the destination state
-   * optimisation: bypass cache when sending native functions over
-   * removed all the KEEPER_MODEL_LUA code, as it can no longer work anyway
-
-CHANGE 68: BGe 24-Sept-13
-   * version 3.6.4
-   * Fix possible application hang at shutdown if a keeper state referenced a linda.
-
-CHANGE 67: BGe 2-Aug-13
-   * version 3.6.3
-   * lane:cancel(<negative-timeout>) only causes cancel_test() to return true but won't interrupt execution of the lane during linda operations
-
-CHANGE 66: BGe 31-Jul-13
-   * more explicit errors when trying to transfer unknown source functions (with new configure option verbose_errors)
-
-CHANGE 65: BGe 23-Jul-13
-   * default options wrap allocator around a mutex when run by LuaJIT
-
-CHANGE 64: BGe 20-Jul-13
-   * WIN32 builds against pre-Vista versions no longer use PulseEvent to fix occasional hangs when a wake event is missed
-
-CHANGE 63: BGe 20-May-13
-   * version 3.6.2
-   * WIN32 builds use condition variables instead of PulseEvent() when available.
-   * first steps toward fixing make-vc.cmd
-
-CHANGE 62: BGe 05-Apr-13
-   * version 3.6.1
-   * function lookup database population keeps the 'smaller' name in case of multiple hits, to remove the no-LUA_COMPAT_ALL restriction on Lua5.2 builds
-
-CHANGE 61: BGe 14-Mar-13
-   * version 3.6.0
-   * protect_allocator is an API change -> version bump
-   * bugfix: allocator protection should be done once per primary Lua state, not once only the first time ever Lanes is required
-
-CHANGE 60: BGe 13-Mar-13
-   * version 3.5.2
-   * stricter validation of with_timers config option: validator was accepting any non-boolean value
-   * new configuration option protect_allocator for VMs with thread unsafe allocators (such as LuaJIT)
-   * removed some obsolete bits of dead code
-
-CHANGE 59: BGe 12-Feb-13
-   * version 3.5.1
-   * new lanes.h header and API call luaopen_lanes_embedded() for embedders
-   * "lanes.core" is an acceptable library in the generator libs argument
-   * library "*" wildcard also opens lanes.core
-   * tweaked code for Xbox 360 build
-
-CHANGE 58: BGe 30-Jan-13
-   * version 3.5.0
-   * new: API lanes.require(), use it instead of regular require() for modules that export C functions you need to send over.
-   * new: lanes no longer require 'lanes.core' by default in every created state. Use {required={"lanes.core"}} if you need to transfer lanes functions.
-   * internal: because of the above, reworked the timer implementation to remove upvalue-dependency on lanes.core
-   * new: API lanes.timer_lane, to be able to operate on timer lane if need be
-   * improved: if a module is a full userdata, scan its metatable for function database population
-   * improved: on_state_create can be a Lua function
-   * changed: on_state_create is called after the base libraries are loaded
-   * package[loaders|searchers] is no longer transfered as function naming depends on slot order
-   * internal: changed separator from '.' to '/' in lookup databases to be able to distinguish search levels and dot coming from module names
-   * added some mode debug spew
-   * updated tests to reflect the above changes
-
-CHANGE 57: BGe 28-Jan-13
-   * More detailed DEBUG_SPEW logs
-   * A bit of code cosmetics
-
-CHANGE 56: BGe 25-Jan-13
-   * version 3.4.4
-   * bugfix: take into account the fact that "coroutine" is no longer part of base library in Lua 5.2
-   * bugfix: if "bit32" was listed in the libraries, it wouldn't open (library list parsing failing on digits)
-   * bugfix: Use luaL_requiref() to open standard libraries in Lua 5.2 as we should
-   * bugfix: any Lua state created by Lanes reuses the allocator function of the originating state
-   * bugfix: don't call on_state_create() while GC is suspended during lua state initialization
-
-CHANGE 55: BGe 24-Jan-13
-   * version 3.4.3
-   * raise an error if lane generator libs specification contains a lib more than once
-   * bit32 is a valid lib name in the libs specification (silently ignored by the Lua 5.1 build)
-   * improved lanes.nameof to search inside table- and userdata- metatables for an object's name
-   * bugfix: fixed an unwarranted error when trying to discover a function name upon a failed transfer
-   * contents of package.[path,cpath,preload,loaders|searchers] are pulled *only once* inside keeper states at initialisation
-   * Lua function upvalues equal to the global environment aren't copied by value, but bound to the destination's global environment
-     especially useful for Lua 5.2 _ENV
-   * bugfix: fixed loading of base libraries that didn't create the global tables when built for Lua 5.2
-
-CHANGE 54: BGe 10-Jan-13
-   * version 3.4.2
-   * Don't pull "package" settings in the timer lane
-   * removed a limitation preventing Lua functions with indirect recursive upvalue references from being transferable
-
-CHANGE 53: BGe 11-Dec-2012
-   * version 3.4.1
-   * new function lanes.timers(), returns a list of all active timers.
-
-CHANGE 52: BGe 03-Dec-2012
-   * linda:send() and linda:receive() no longer triggers string->number autocoercion when checking for the optional timeout argument:
-      a string is always a linda slot, even if coercible.
-
-CHANGE 51: BGe 27-Nov-2012
-   * linux flavors with older glibc use prctl instead of pthread_setname_np
-   * selfdestruct chain handling is now the same on all platforms
-
-CHANGE 50: BGe 22-Nov-2012
-   * bugfix: linda:set() no longer clears the storage limit
-
-CHANGE 49: BGe 21-Nov-2012
-   * fix application shutdown crash by not registering anything with atexit()
-   * rockspec for version v3.4.0
-
-CHANGE 48: BGe 25-Sep-2012
-   * version 3.4.0
-   * new method linda:dump() that outputs the full contents of a linda as a table, also linked to __towatch for Decoda support
-   * linda:receive() API change!
-   * instead of [val, key], linda:receive( timeout, key) returns [key, val]
-   * instead of [val, [...]], linda:receive( timeout, linda.batched key) returns [key, val[, ...]]
-     this is to unify the return values of regular and batched mode, and to be able to tell when batched mode is interrupted by a lane cancellation
-   * fixed Lua 5.2 build to take into account the "loaders"->"searchers" name change in 'package' module.
-   * a bit of html cleanup and added some infos in the documentation regarding the Lanes internals
-
-CHANGE 47: BGe 13-Sep-2012
-   * implemented set_debug_threadname() for pthread builds where possible
-   * refactored linda __tostring and __concat
-
-CHANGE 46: BGe 10-Sep-2012
-   * version 3.3.0
-   * lane.status can return "killed" if lane was forcefully killed with lanes:cancel()
-   * lane:join(): return nil, "killed" if called on a killed lane.
-   * lane[<n>]: produces [1] = nil, [2] = "killed" if the lane was killed
-   * lane:join(): fixed an assertion in debug builds when joining a lane forcefully cancelled with lane:cancel( <x>, true).
-   * indexing a lane with a string other than "join", "cancel" or "status" raises an error.
-   * fixed configure() to correctly apply defaults when they are missing from the provided settings
-   * added a shutdown_timeout to control the duration Lanes will wait for graceful termination of running lanes at application shutdown. Default is 0.25.
-
-CHANGE 45: BGe 21-Aug-2012
-   * keeper internals implemented in C instead of Lua for better performances
-   * fixed arguments checks in linda:limit() and linda:set()
-
-CHANGE 44: BGe 13-Aug-2012
-   * lanes code updated to build against Lua 5.1 and Lua 5.2
-   * removed the search for MSVCR80.DLL when building for MinGW32 since it no longer seems to be necessary
-
-CHANGE 43: BGe 09-Aug-2012
-   * fix possible crash at application shutdown when a race condition causes linda objects to be collected after the keeper states are cleaned up.
-
-CHANGE 42: BGe 06-Aug-2012
-   * lanes.linda() accepts an optional name for debug purposes
-
-CHANGE 41: BGe 07-Jul-2012
-   * lua51-lanes renamed lanes/core
-   * keeper state microcode is no longer embedded inside lanes.core, but located and loaded with package.loaders[2]
-   * changed rockspec build type from "make" to "builtin"
-
-CHANGE 40: BGe 26-Jun-2012
-   * when a transfered function is not found in source, guess its name to help the user find out what's wrong
-   * new function lanes.nameof()
-
-CHANGE 39: BGe 23-Jun-2012
-   * lanes.timer() accepts a first_secs=nil to stop a timer
-   * timer lane catches errors and prints them
-   * fixed some typos in manual
-
-CHANGE 38: BGe 11-Jun-2012
-   * linda:receive() batched mode now accepts a max_count optional argument
-
-CHANGE 37: BGe 4-Jun-2012 (fix and idea courtesy of sonoro1234)
-   * fixed thread_cancel() not working when called without argument
-   * new lane-global function set_error_reporting() to enable more data detailed data provided by lane_error()
-
-CHANGE 36 BGe 26-Apr-2012
-   * improved LuaJIT2 compatibility by handling "*" library set through luaL_openlibs()
-
-CHANGE 35 BGe 17-Feb-2012
-   * changed lanes.configure signature to receive a table instead of individual parameters
-   * added support for an on_state_create callback called to load custom functions in a state in addition to the base libraries
-
-CHANGE 34 BGe 14-Nov-2011
-   * removed packagepath and packagecpath options, replaced by a package table, whose fields path, cpath, loaders, preload are transfered
-   * code cleanup to facilitate transition between WIN32 and PTHREAD implementations
-   * tentative fix for desinit crashes when free running lanes are killed at process shutdown
-
-CHANGE 33 BGe 5-Nov-2011: Lanes version 3.0-beta
-   * process exit change: close everything at GC when main state closes, not when atexit() handlers are processed
-   * Lua 5.2-style module:
-      * module() is no longer used to implement lanes.lua
-      * a global "lanes" variable is no longer created when the module is required
-      * the Lanes module table is returned instead
-   * Lanes must be initialized before used:
-      * the first occurence of 'require "lanes"' produces a minimal interface that only contains a configure() function
-      * the remainder of the interface is made available once this function is called
-      * subsequent calls to configure() do nothing
-      * configure() controls the number of keeper states and the startup of timers
-   * LuaJIT 2 compatibility
-      * non-Lua functions are no longer copied by creating a C closure from a C pointer, but through 2-way lookup tables
-      * this means that if a lane function body pulls non-Lua functions, the lane generator description must contain the list of libraries and modules that exports them
-      * introduces a change in configuration .globals management: contents are copied *after* std libs are loaded
-      * new .required configuration entry to list modules that must be require()'ed before lane body is transferred
-   * lane:cancel() wakes up waiting lindas like what is done at lane shutdown
-
-CHANGE 32 BGe 14-May-2011
-   * raise an error when linda:send() has nothing to send
-
-CHANGE 31 BGe 17-Apr-2011
-   * linda uses a fast FIFO implementation to speed up data exchanges
-   * new linda:count() method
-   * new linda batched data read mode
-   * proper key type check in all linda methods
-   * fix setup-vc.cmd to support Visual Studio 2010 and Windows 7 64 bits
-   * bugfix: release keeper state mutex at desinit
-
-CHANGE 30 BGe 30-Mar-2011
-   * linda honors __tostring and __concat
-   * new accessor linda:keys(), to retrieve the list of keys with pending data inside a linda
-   * new lanes options packagepath and packagecpath, in case one needs to set them differently than the default
-
-CHANGE 29 BGe 1-Mar-2011
-    fixed potential crash at application shutdown when calling lua_close() on a killed thread's VM.
-    exposed cancel_test() in the lanes to enable manual testing for cancellation requests.
-    removed kludgy {globals={threadName}} support, replaced with a new function set_debug_threadname().
-
-CHANGE 28 BGe 18-Feb-2011
-    - moved keeper-related code in a separate source file
-    - keeper.lua is now embedded in text form instead of bytecode to improve LuaJIT2-compatibility
-
-CHANGE 27 BGe 17-Feb-2011
-    - we know Lanes is loaded in the master state, so we don't force it
-      to be required in every lane too when a linda deep userdata is copied
-    - Refactor lane proxy implementation: it is now a full userdata instead
-      of a table, and its methods are implemented in C instead of Lua
-      * its metatable is no longer accessible
-      * writing to the proxy raises an error
-      * it is no longer possible to overwrite its join() and cancel() methods
-    - when a deep userdata idfunc requests a module to be required, manually
-      check that it is not loaded before requiring it instead of relying on
-      the require function's loop detection feature
-    - when a module must be required, raise an error if the 'require' function
-      is not found in the target state
-
-CHANGE 26 BGe 14-Feb-2011:
-    Fixed application hang-up because keeper state was not released in case of errors thrown by
-    inter-state data copy for unsupported types
-
-CHANGE 25 BGe 12-Feb-2011:
-    Changed idfunc signature and contract to clarify that fact it is not lua-callable
-    and to be able to require the module it was exported from in the target lanes
-
-CHANGE 24 DPtr 25-Jan-2011:
-    Changed lanes.c to export functions as a module rather than writing them directly to the globals table.
-
-CHANGE 23 DPtr 23-Jan-2011:
-    Fixed bug where reference to Linda object was dropped for a short time ( crashing if GC was run during that time ).
-    Changed the atexit code to trip the timer thread's write signal. 
-
-CHANGE 22 DPtr 19-Jan-2011:
-    Changed luaG_push_proxy to cache deep userdata proxies.
-
-CHANGE 21 (bugfixes) BGe 3-Jan-2011:
-    Several fixes by Martin Krpan:
-    - linda_send was waiting on the wrong signal
-    - buildfix when using i586-mingw32msvc-gcc cross compiler
-    - lanes_h:cancel() returns a boolean as it should
-    - timers could get blocked sometimes because they were initialized with negative values
-    - prepare_timeout could generate an illegal setting
-
-CHANGE 20 BGe 3-Dec-2010:
-    Enable to specify a string as lane code instead of a function so that we dont use lua_dump, which
-    isn't supported by LuaJIT.
-
-CHANGE 19 BGe 2-Dec-2010:
-    No longer rely on global function 'tostring' to generate unique identifiers when caching data being transfered through la linda. Should fix a compatilibity issue with LuaJIT2.
-
-CHANGE 18 BGe 6-Oct-2010:
-    Fixed 'memory leak' in some situations where a free running lane is collected before application shutdown
-    A bit of code cleanup
-
-CHANGE 17 BGe 21-Sept-2010:
-    Fixed stupid compilation errors.
-
-CHANGE 16 PLM 24-Aug-2010:
-    Releasing memory at gc / atexit.
-    Finalizers actually get error strings.
-    Fixed missing argument propagation in lane:cancel
-    Added variable threadName sent trough globals-table. Set in s_lane, and in debuggers on windows.
-    Added argument checking for linda-objects, where missing them caused crashes.
-
-CHANGE 15 (minor) BGe 27-Jul-2010:
-    Version bump for a true upgrade release (2.0.4 package was only a renamed 2.0.3)
-
-CHANGE 14 (bug fix) BGe 09-Jul-2010:
-    Fixed lane status to be correctly returned as "waiting" when it should.
-
-CHANGE 13 (fix for multithreaded host apps) AKa 24-Jun-2009:
-    <borisusun-at-gmail> mentioned Lanes expects the host application to be singlethreaded,
-    and there are troubles if Lanes is used from multiple threads, opened by the host
-    (before requiring Lanes). This is true, and fix should now be in place.
-
-CHANGE 12 (bug fix on Windows, 2.0.3) AKa 25-Jan-2009:
-    Did CHANGE 9 the way it should be done.
-
-CHANGE 11 (new feature, 2.0.3) AKa 23-Jan-2009:
-    Finalizers ('set_finalizer()') for being able to do cleanup of a lane's
-    resources, whether it returned succesfully or via an error.
-
-CHANGE 10 (new feature, 2.0.3) AKa 23-Jan-2009:
-    Call stack showing where an error occurred is not merged with the error
-    message, but delivered as a separate stack table ({ "filename:line" [, ...] }).
-    Getting call stacks of errorred lanes is now possible.
-
-CHANGE 9 (bug fix on Windows) AKa 10-Dec-2008 (> 2.0.2):
-    Applied patch from Kriss Daniels to avoid issues on 'now_time()' in Win32
-    (http://luaforge.net/forum/forum.php?thread_id=22704&forum_id=1781).
-
-CHANGE 8 (bug fix) AKa 26-Oct-2008:
-    Avoids occasional segfault at process exit (on multicore CPUs). Does this
-    by keeping track of "free running" threads (s.a. the time thread) and
-    cancelling them at process exit.
-
-    Tested (2.0.2) on Linux 64,x86, OS X, WinXP.
-
-CHANGE 7 (bug fix) AKa 15-Oct-2008:
-    Recursive functions that use themselves as direct upvalue can now be
-    passed to other lanes, and used as a lane function.
-
-CHANGE 6 (bug fix) AKa 15-Oct-2008:
-    Added local caches of the following to src/lanes.lua (was otherwise getting
-    errors at least in 'tests/irayo_recursive.lua').
-
-        local assert= assert
-        local string_gmatch= assert( string.gmatch )
-        local select= assert( select )
-        local type= assert( type )
-        local pairs= assert( pairs )
-        local tostring= assert( tostring )
-        local error= assert( error )
-        local setmetatable= assert( setmetatable )
-        local rawget= assert( rawget )
-
-    Thanks to Irayo for detecting and reporting this.
-
-CHANGE 5 (new feature):
-    Modifying Makefile so it's better suited to LuaRocks.
-
-CHANGE 4 (new feature):
-    Metatable copying, allowing Lua objects to be copied across lanes.
-
-CHANGE 3 (bug fix) AKa 5-Aug-2008:
-    The '__gc' method was not tied to thread userdata, at all. Caused memory
-    lifespan problems at least on OS X when threads were cancelled (EINVAL).
-
-CHANGE 2 (bug fix) AKa 5-Aug-2008:
-    Better calculation of timeouts, always making them absolute (even in Win32)
-    to allow for events that wake the lane up but don't read/write the Linda
-    key that it was observing.
-
-CHANGE 1 (bug fix) AKa 4-Aug-2008:
-    Signalling woke up only one waiting thread, not all. This caused i.e.
-    receive to not wake up if there was another thread waiting on the same
-    Linda object.
-
-    PThread fix: using 'pthread_cond_broadcast()' instead of 'pthread_cond_signal()'
-    Win32 fix: using manual events and 'PulseEvent()'
+CHANGE 1: BGe 9-Apr-24
+   * reset changelog, next entry will list API changes since last C-implementation.
 
 (end)
diff --git a/Makefile b/Makefile
index 08888e4..32f39ba 100644
--- a/Makefile
+++ b/Makefile
@@ -42,7 +42,7 @@ _PREFIX=LUA_CPATH="./src/?.$(_SO)" LUA_PATH="./src/?.lua;./tests/?.lua"
 #---
 all: $(_TARGET_SO)
 
-$(_TARGET_SO): src/*.lua src/*.c src/*.h
+$(_TARGET_SO): src/*.lua src/*.cpp src/*.h
         cd src && $(MAKE) LUA=$(LUA)
 
 clean:
diff --git a/deep_test/deep_test.args.json b/deep_test/deep_test.args.json
new file mode 100644
index 0000000..a540fc2
--- /dev/null
+++ b/deep_test/deep_test.args.json
@@ -0,0 +1,16 @@
+{
+  "FileVersion": 2,
+  "Id": "4c40bd18-3bab-46d7-8f14-602a6fbe5910",
+  "Items": [
+    {
+      "Id": "d9d87866-8c63-44a8-b88a-1d42097985d4",
+      "Command": "DeepTest",
+      "Items": [
+        {
+          "Id": "10e30bb2-dc23-4882-b918-b5939c14e588",
+          "Command": "-i deeptest.lua"
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/deep_test/deep_test.c b/deep_test/deep_test.c
deleted file mode 100644
index cb89741..0000000
--- a/deep_test/deep_test.c
+++ /dev/null
@@ -1,273 +0,0 @@
-#include <malloc.h>
-#include <memory.h>
-#include <assert.h>
-
-#include "lua.h"
-#include "lualib.h"
-#include "lauxlib.h"
-
-#include "lanes/src/deep.h"
-#include "lanes/src/compat.h"
-
-#if (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC)
-#define LANES_API __declspec(dllexport)
-#else
-#define LANES_API
-#endif // (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC)
-
-// ################################################################################################
-
-// a lanes-deep userdata. needs DeepPrelude and luaG_newdeepuserdata from Lanes code.
-struct s_MyDeepUserdata
-{
-        DeepPrelude prelude; // Deep userdata MUST start with this header
-        lua_Integer val;
-};
-static void* deep_test_id( lua_State* L, enum eDeepOp op_);
-
-// ################################################################################################
-
-static int deep_set( lua_State* L)
-{
-        struct s_MyDeepUserdata* self = luaG_todeep( L, deep_test_id, 1);
-        lua_Integer i = lua_tointeger( L, 2);
-        self->val = i;
-        return 0;
-}
-
-// ################################################################################################
-
-// won't actually do anything as deep userdata don't have uservalue slots
-static int deep_setuv( lua_State* L)
-{
-        struct s_MyDeepUserdata* self = luaG_todeep( L, deep_test_id, 1);
-        int uv = (int) luaL_optinteger( L, 2, 1);
-        lua_settop( L, 3);
-        lua_pushboolean( L, lua_setiuservalue( L, 1, uv) != 0);
-        return 1;
-}
-
-// ################################################################################################
-
-// won't actually do anything as deep userdata don't have uservalue slots
-static int deep_getuv( lua_State* L)
-{
-        struct s_MyDeepUserdata* self = luaG_todeep( L, deep_test_id, 1);
-        int uv = (int) luaL_optinteger( L, 2, 1);
-        lua_getiuservalue( L, 1, uv);
-        return 1;
-}
-
-// ################################################################################################
-
-static int deep_tostring( lua_State* L)
-{
-        struct s_MyDeepUserdata* self = luaG_todeep( L, deep_test_id, 1);
-        lua_pushfstring( L, "%p:deep(%d)", lua_topointer( L, 1), self->val);
-        return 1;
-}
-
-// ################################################################################################
-
-static int deep_gc( lua_State* L)
-{
-        struct s_MyDeepUserdata* self = luaG_todeep( L, deep_test_id, 1);
-        return 0;
-}
-
-// ################################################################################################
-
-static luaL_Reg const deep_mt[] =
-{
-        { "__tostring", deep_tostring},
-        { "__gc", deep_gc},
-        { "set", deep_set},
-        { "setuv", deep_setuv},
-        { "getuv", deep_getuv},
-        { NULL, NULL }
-};
-
-// ################################################################################################
-
-static void* deep_test_id( lua_State* L, enum eDeepOp op_)
-{
-        switch( op_)
-        {
-                case eDO_new:
-                {
-                        struct s_MyDeepUserdata* deep_test = (struct s_MyDeepUserdata*) malloc( sizeof(struct s_MyDeepUserdata));
-                        deep_test->prelude.magic.value = DEEP_VERSION.value;
-                        deep_test->val = 0;
-                        return deep_test;
-                }
-
-                case eDO_delete:
-                {
-                        struct s_MyDeepUserdata* deep_test = (struct s_MyDeepUserdata*) lua_touserdata( L, 1);
-                        free( deep_test);
-                        return NULL;
-                }
-
-                case eDO_metatable:
-                {
-                        luaL_getmetatable( L, "deep");             // mt
-                        return NULL;
-                }
-
-                case eDO_module:
-                return "deep_test";
-
-                default:
-                {
-                        return NULL;
-                }
-        }
-}
-
-// ################################################################################################
-
-int luaD_new_deep( lua_State* L)
-{
-        int nuv = (int) luaL_optinteger( L, 1, 0);
-        // no additional parameter to luaG_newdeepuserdata!
-        lua_settop( L, 0);
-        return luaG_newdeepuserdata( L, deep_test_id, nuv);
-}
-
-// ################################################################################################
-// ################################################################################################
-
-struct s_MyClonableUserdata
-{
-        lua_Integer val;
-};
-
-// ################################################################################################
-
-static int clonable_set( lua_State* L)
-{
-        struct s_MyClonableUserdata* self = (struct s_MyClonableUserdata*) lua_touserdata( L, 1);
-        lua_Integer i = lua_tointeger( L, 2);
-        self->val = i;
-        return 0;
-}
-
-// ################################################################################################
-
-static int clonable_setuv( lua_State* L)
-{
-        struct s_MyClonableUserdata* self = (struct s_MyClonableUserdata*) lua_touserdata( L, 1);
-        int uv = (int) luaL_optinteger( L, 2, 1);
-        lua_settop( L, 3);
-        lua_pushboolean( L, lua_setiuservalue( L, 1, uv) != 0);
-        return 1;
-}
-
-// ################################################################################################
-
-static int clonable_getuv( lua_State* L)
-{
-        struct s_MyClonableUserdata* self = (struct s_MyClonableUserdata*) lua_touserdata( L, 1);
-        int uv = (int) luaL_optinteger( L, 2, 1);
-        lua_getiuservalue( L, 1, uv);
-        return 1;
-}
-
-// ################################################################################################
-
-static int clonable_tostring(lua_State* L)
-{
-        struct s_MyClonableUserdata* self = (struct s_MyClonableUserdata*) lua_touserdata( L, 1);
-        lua_pushfstring( L, "%p:clonable(%d)", lua_topointer( L, 1), self->val);
-        return 1;
-}
-
-// ################################################################################################
-
-static int clonable_gc( lua_State* L)
-{
-        struct s_MyClonableUserdata* self = (struct s_MyClonableUserdata*) lua_touserdata( L, 1);
-        return 0;
-}
-
-// ################################################################################################
-
-// this is all we need to make a userdata lanes-clonable. no dependency on Lanes code.
-static int clonable_lanesclone( lua_State* L)
-{
-        switch( lua_gettop( L))
-        {
-                case 3:
-                {
-                        struct s_MyClonableUserdata* self = lua_touserdata( L, 1);
-                        struct s_MyClonableUserdata* from = lua_touserdata( L, 2);
-                        size_t len = lua_tointeger( L, 3);
-                        assert( len == sizeof(struct s_MyClonableUserdata));
-                        *self = *from;
-                }
-                return 0;
-
-                default:
-                (void) luaL_error( L, "Lanes called clonable_lanesclone with unexpected parameters");
-        }
-        return 0;
-}
-
-// ################################################################################################
-
-static luaL_Reg const clonable_mt[] =
-{
-        { "__tostring", clonable_tostring},
-        { "__gc", clonable_gc},
-        { "__lanesclone", clonable_lanesclone},
-        { "set", clonable_set},
-        { "setuv", clonable_setuv},
-        { "getuv", clonable_getuv},
-        { NULL, NULL }
-};
-
-// ################################################################################################
-
-int luaD_new_clonable( lua_State* L)
-{
-        int nuv = (int) luaL_optinteger( L, 1, 1);
-        lua_newuserdatauv( L, sizeof( struct s_MyClonableUserdata), nuv);
-        luaL_setmetatable( L, "clonable");
-        return 1;
-}
-
-// ################################################################################################
-// ################################################################################################
-
-static luaL_Reg const deep_module[] =
-{
-        { "new_deep", luaD_new_deep},
-        { "new_clonable", luaD_new_clonable},
-        { NULL, NULL}
-};
-
-// ################################################################################################
-
-extern int __declspec(dllexport) luaopen_deep_test(lua_State* L)
-{
-        luaL_newlib( L, deep_module);                           // M
-
-        // preregister the metatables for the types we can instantiate so that Lanes can know about them
-        if( luaL_newmetatable( L, "clonable"))                  // M mt
-        {
-                luaL_setfuncs( L, clonable_mt, 0);
-                lua_pushvalue(L, -1);                                 // M mt mt
-                lua_setfield(L, -2, "__index");                       // M mt
-        }
-        lua_setfield(L, -2, "__clonableMT");                    // M
-
-        if( luaL_newmetatable( L, "deep"))                      // mt
-        {
-                luaL_setfuncs( L, deep_mt, 0);
-                lua_pushvalue(L, -1);                                 // mt mt
-                lua_setfield(L, -2, "__index");                       // mt
-        }
-        lua_setfield(L, -2, "__deepMT");                    // M
-
-        return 1;
-}
diff --git a/deep_test/deep_test.cpp b/deep_test/deep_test.cpp
new file mode 100644
index 0000000..3467939
--- /dev/null
+++ b/deep_test/deep_test.cpp
@@ -0,0 +1,259 @@
+#include "lanes/src/deep.h"
+#include "lanes/src/compat.h"
+
+#include <malloc.h>
+#include <memory.h>
+#include <assert.h>
+
+// ################################################################################################
+
+// a lanes-deep userdata. needs DeepPrelude and luaG_newdeepuserdata from Lanes code.
+struct MyDeepUserdata : public DeepPrelude // Deep userdata MUST start with a DeepPrelude
+{
+    lua_Integer val{ 0 };
+};
+
+// ################################################################################################
+
+[[nodiscard]] static void* deep_test_id(lua_State* L, DeepOp op_)
+{
+    switch( op_)
+    {
+        case DeepOp::New:
+        {
+            MyDeepUserdata* deep_test = new MyDeepUserdata;
+            return deep_test;
+        }
+
+        case DeepOp::Delete:
+        {
+            MyDeepUserdata* deep_test = static_cast<MyDeepUserdata*>(lua_touserdata( L, 1));
+            delete deep_test;
+            return nullptr;
+        }
+
+        case DeepOp::Metatable:
+        {
+            luaL_getmetatable( L, "deep");             // mt
+            return nullptr;
+        }
+
+        case DeepOp::Module:
+        return (void*)"deep_test";
+
+        default:
+        {
+            return nullptr;
+        }
+    }
+}
+
+// ################################################################################################
+
+[[nodiscard]] static int deep_set(lua_State* L)
+{
+    MyDeepUserdata* self = static_cast<MyDeepUserdata*>(luaG_todeep(L, deep_test_id, 1));
+    lua_Integer i = lua_tointeger( L, 2);
+    self->val = i;
+    return 0;
+}
+
+// ################################################################################################
+
+// won't actually do anything as deep userdata don't have uservalue slots
+[[nodiscard]] static int deep_setuv(lua_State* L)
+{
+    MyDeepUserdata* self = static_cast<MyDeepUserdata*>(luaG_todeep(L, deep_test_id, 1));
+    int uv = (int) luaL_optinteger(L, 2, 1);
+    lua_settop( L, 3);
+    lua_pushboolean( L, lua_setiuservalue( L, 1, uv) != 0);
+    return 1;
+}
+
+// ################################################################################################
+
+// won't actually do anything as deep userdata don't have uservalue slots
+[[nodiscard]] static int deep_getuv(lua_State* L)
+{
+    MyDeepUserdata* self = static_cast<MyDeepUserdata*>(luaG_todeep(L, deep_test_id, 1));
+    int uv = (int) luaL_optinteger(L, 2, 1);
+    lua_getiuservalue( L, 1, uv);
+    return 1;
+}
+
+// ################################################################################################
+
+[[nodiscard]] static int deep_tostring(lua_State* L)
+{
+    MyDeepUserdata* self = static_cast<MyDeepUserdata*>(luaG_todeep(L, deep_test_id, 1));
+    lua_pushfstring(L, "%p:deep(%d)", lua_topointer(L, 1), self->val);
+    return 1;
+}
+
+// ################################################################################################
+
+[[nodiscard]] static int deep_gc(lua_State* L)
+{
+    MyDeepUserdata* self = static_cast<MyDeepUserdata*>(luaG_todeep(L, deep_test_id, 1));
+    return 0;
+}
+
+// ################################################################################################
+
+static luaL_Reg const deep_mt[] =
+{
+    { "__tostring", deep_tostring},
+    { "__gc", deep_gc},
+    { "set", deep_set},
+    { "setuv", deep_setuv},
+    { "getuv", deep_getuv},
+    { nullptr, nullptr }
+};
+
+// ################################################################################################
+
+int luaD_new_deep( lua_State* L)
+{
+    int const nuv{ static_cast<int>(luaL_optinteger(L, 1, 0)) };
+    // no additional parameter to luaG_newdeepuserdata!
+    lua_settop(L, 0);
+    return luaG_newdeepuserdata(Dest{ L }, deep_test_id, nuv);
+}
+
+// ################################################################################################
+// ################################################################################################
+
+struct MyClonableUserdata
+{
+    lua_Integer val;
+};
+
+// ################################################################################################
+
+[[nodiscard]] static int clonable_set(lua_State* L)
+{
+    MyClonableUserdata* self = static_cast<MyClonableUserdata*>(lua_touserdata(L, 1));
+    lua_Integer i = lua_tointeger(L, 2);
+    self->val = i;
+    return 0;
+}
+
+// ################################################################################################
+
+[[nodiscard]] static int clonable_setuv(lua_State* L)
+{
+    MyClonableUserdata* self = static_cast<MyClonableUserdata*>(lua_touserdata(L, 1));
+    int uv = (int) luaL_optinteger(L, 2, 1);
+    lua_settop( L, 3);
+    lua_pushboolean( L, lua_setiuservalue( L, 1, uv) != 0);
+    return 1;
+}
+
+// ################################################################################################
+
+[[nodiscard]] static int clonable_getuv(lua_State* L)
+{
+    MyClonableUserdata* self = static_cast<MyClonableUserdata*>(lua_touserdata(L, 1));
+    int uv = (int) luaL_optinteger(L, 2, 1);
+    lua_getiuservalue( L, 1, uv);
+    return 1;
+}
+
+// ################################################################################################
+
+[[nodiscard]] static int clonable_tostring(lua_State* L)
+{
+    MyClonableUserdata* self = static_cast<MyClonableUserdata*>(lua_touserdata(L, 1));
+    lua_pushfstring(L, "%p:clonable(%d)", lua_topointer(L, 1), self->val);
+    return 1;
+}
+
+// ################################################################################################
+
+[[nodiscard]] static int clonable_gc(lua_State* L)
+{
+    MyClonableUserdata* self = static_cast<MyClonableUserdata*>(lua_touserdata(L, 1));
+    return 0;
+}
+
+// ################################################################################################
+
+// this is all we need to make a userdata lanes-clonable. no dependency on Lanes code.
+[[nodiscard]] static int clonable_lanesclone(lua_State* L)
+{
+    switch( lua_gettop( L))
+    {
+        case 3:
+        {
+            MyClonableUserdata* self = static_cast<MyClonableUserdata*>(lua_touserdata(L, 1));
+            MyClonableUserdata* from = static_cast<MyClonableUserdata*>(lua_touserdata(L, 2));
+            size_t len = lua_tointeger( L, 3);
+            assert( len == sizeof(MyClonableUserdata));
+            *self = *from;
+        }
+        return 0;
+
+        default:
+        (void) luaL_error( L, "Lanes called clonable_lanesclone with unexpected parameters");
+    }
+    return 0;
+}
+
+// ################################################################################################
+
+static luaL_Reg const clonable_mt[] =
+{
+    { "__tostring", clonable_tostring},
+    { "__gc", clonable_gc},
+    { "__lanesclone", clonable_lanesclone},
+    { "set", clonable_set},
+    { "setuv", clonable_setuv},
+    { "getuv", clonable_getuv},
+    { nullptr, nullptr }
+};
+
+// ################################################################################################
+
+int luaD_new_clonable( lua_State* L)
+{
+    int const nuv{ static_cast<int>(luaL_optinteger(L, 1, 1)) };
+    lua_newuserdatauv( L, sizeof(MyClonableUserdata), nuv);
+    luaL_setmetatable( L, "clonable");
+    return 1;
+}
+
+// ################################################################################################
+// ################################################################################################
+
+static luaL_Reg const deep_module[] =
+{
+    { "new_deep", luaD_new_deep},
+    { "new_clonable", luaD_new_clonable},
+    { nullptr, nullptr }
+};
+
+// ################################################################################################
+
+LANES_API int luaopen_deep_test(lua_State* L)
+{
+    luaL_newlib( L, deep_module);                           // M
+
+    // preregister the metatables for the types we can instantiate so that Lanes can know about them
+    if( luaL_newmetatable( L, "clonable"))                  // M mt
+    {
+        luaL_setfuncs( L, clonable_mt, 0);
+        lua_pushvalue(L, -1);                               // M mt mt
+        lua_setfield(L, -2, "__index");                     // M mt
+    }
+    lua_setfield(L, -2, "__clonableMT");                    // M
+
+    if( luaL_newmetatable( L, "deep"))                      // mt
+    {
+        luaL_setfuncs( L, deep_mt, 0);
+        lua_pushvalue(L, -1);                               // mt mt
+        lua_setfield(L, -2, "__index");                     // mt
+    }
+    lua_setfield(L, -2, "__deepMT");                        // M
+
+    return 1;
+}
diff --git a/deep_test/deep_test.vcxproj b/deep_test/deep_test.vcxproj
index 6ff7685..5cd3c55 100644
--- a/deep_test/deep_test.vcxproj
+++ b/deep_test/deep_test.vcxproj
@@ -342,6 +342,7 @@
       <AdditionalIncludeDirectories>$(SolutionDir)..\Lua53\include;$(SolutionDir)Lanes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
       <PreprocessorDefinitions>_WINDLL;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <Link>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
@@ -350,8 +351,8 @@
       <AdditionalLibraryDirectories>$(SolutionDir)..\Lua53\bin\$(Platform)\Release</AdditionalLibraryDirectories>
     </Link>
     <PostBuildEvent>
-      <Command>xcopy /R /F /Y /I "$(TargetPath)" $(SolutionDir)..\framework\</Command>
-      <Message>Copy to framework</Message>
+      <Command>xcopy /R /F /Y /I "$(TargetPath)" $(SolutionDir)..\Lua53\bin\$(Platform)\Release\</Command>
+      <Message>Copy to Lua 5.3</Message>
     </PostBuildEvent>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release 5.4|x64'">
@@ -365,6 +366,7 @@
       <AdditionalIncludeDirectories>$(SolutionDir)..\Lua54\include;$(SolutionDir)Lanes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
       <PreprocessorDefinitions>_WINDLL;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <Link>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
@@ -385,6 +387,7 @@
       <ConformanceMode>true</ConformanceMode>
       <AdditionalIncludeDirectories>$(SolutionDir)..\Lua53\include;$(SolutionDir)Lanes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <PostBuildEvent>
       <Command>xcopy /R /F /Y /I "$(TargetPath)" $(SolutionDir)..\Lua53\bin\$(Platform)\Debug\</Command>
@@ -403,6 +406,7 @@
       <ConformanceMode>true</ConformanceMode>
       <AdditionalIncludeDirectories>$(SolutionDir)..\Lua51\include;$(SolutionDir)Lanes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <PostBuildEvent>
       <Command>xcopy /R /F /Y /I "$(TargetPath)" $(SolutionDir)..\Lua51\bin\$(Platform)\Debug\</Command>
@@ -421,6 +425,7 @@
       <ConformanceMode>true</ConformanceMode>
       <AdditionalIncludeDirectories>$(SolutionDir)..\Lua51\include;$(SolutionDir)Lanes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <PostBuildEvent>
       <Command>xcopy /R /F /Y /I "$(TargetPath)" $(SolutionDir)..\Lua52\bin\$(Platform)\Debug\</Command>
@@ -440,6 +445,7 @@
       <AdditionalIncludeDirectories>$(SolutionDir)..\LuaJIT-2.1.0-beta3\src;$(SolutionDir)Lanes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <PostBuildEvent>
       <Command>xcopy /R /F /Y /I "$(TargetPath)" $(SolutionDir)..\LuaJIT-2.1.0-beta3\bin\$(Platform)\</Command>
@@ -459,6 +465,7 @@
       <AdditionalIncludeDirectories>$(SolutionDir)..\LuaJIT-2.0.5\src;$(SolutionDir)Lanes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <PostBuildEvent>
       <Command>xcopy /R /F /Y /I "$(TargetPath)" $(SolutionDir)..\LuaJIT-2.0.5\bin\$(Platform)\</Command>
@@ -477,6 +484,7 @@
       <ConformanceMode>true</ConformanceMode>
       <AdditionalIncludeDirectories>$(SolutionDir)..\Lua54\include;$(SolutionDir)Lanes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <PostBuildEvent>
       <Command>xcopy /R /F /Y /I "$(TargetPath)" $(SolutionDir)..\framework\</Command>
@@ -495,6 +503,7 @@
       <ConformanceMode>true</ConformanceMode>
       <AdditionalIncludeDirectories>$(SolutionDir)..\MoonJIT\src;$(SolutionDir)Lanes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <PostBuildEvent>
       <Command>xcopy /R /F /Y /I "$(TargetPath)" $(SolutionDir)..\MoonJIT\bin\$(Platform)\</Command>
@@ -514,10 +523,11 @@
       <AdditionalIncludeDirectories>$(SolutionDir)..\Lua53\include;$(SolutionDir)Lanes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
       <PreprocessorDefinitions>_WINDLL;_DEBUG;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <PostBuildEvent>
       <Command>xcopy /R /F /Y /I "$(TargetPath)" $(SolutionDir)..\Lua53\bin\$(Platform)\Debug\</Command>
-      <Message>Lua 5.3</Message>
+      <Message>Copy to Lua 5.3</Message>
     </PostBuildEvent>
     <Link>
       <AdditionalDependencies>lua53.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
@@ -533,14 +543,15 @@
       <AdditionalIncludeDirectories>$(SolutionDir)..\Lua51\include;$(SolutionDir)Lanes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
       <PreprocessorDefinitions>_WINDLL;_DEBUG;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <PostBuildEvent>
       <Command>xcopy /R /F /Y /I "$(TargetPath)" $(SolutionDir)..\Lua51\bin\$(Platform)\Debug\</Command>
       <Message>Copy to Lua 5.2</Message>
     </PostBuildEvent>
     <Link>
-      <AdditionalDependencies>lua52.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <AdditionalLibraryDirectories>$(SolutionDir)..\Lua52\bin\$(Platform)\Debug</AdditionalLibraryDirectories>
+      <AdditionalDependencies>lua51.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(SolutionDir)..\Lua51\bin\$(Platform)\Debug</AdditionalLibraryDirectories>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug 5.2|x64'">
@@ -549,17 +560,18 @@
       <Optimization>Disabled</Optimization>
       <SDLCheck>true</SDLCheck>
       <ConformanceMode>true</ConformanceMode>
-      <AdditionalIncludeDirectories>$(SolutionDir)..\Lua51\include;$(SolutionDir)Lanes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(SolutionDir)..\Lua52\include;$(SolutionDir)Lanes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
       <PreprocessorDefinitions>_WINDLL;_DEBUG;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <PostBuildEvent>
       <Command>xcopy /R /F /Y /I "$(TargetPath)" $(SolutionDir)..\Lua52\bin\$(Platform)\Debug\</Command>
       <Message>Copy to Lua 5.2</Message>
     </PostBuildEvent>
     <Link>
-      <AdditionalDependencies>lua51.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <AdditionalLibraryDirectories>$(SolutionDir)..\Lua51\bin\$(Platform)\Debug</AdditionalLibraryDirectories>
+      <AdditionalDependencies>lua52.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(SolutionDir)..\Lua52\bin\$(Platform)\Debug</AdditionalLibraryDirectories>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug LuaJIT 2.1.0-beta3|x64'">
@@ -571,6 +583,7 @@
       <AdditionalIncludeDirectories>$(SolutionDir)..\LuaJIT-2.1.0-beta3\src;$(SolutionDir)Lanes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
       <PreprocessorDefinitions>_WINDLL;_DEBUG;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <PostBuildEvent>
       <Command>xcopy /R /F /Y /I "$(TargetPath)" $(SolutionDir)..\LuaJIT-2.1.0-beta3\bin\$(Platform)\</Command>
@@ -590,6 +603,7 @@
       <AdditionalIncludeDirectories>$(SolutionDir)..\LuaJIT-2.0.5\src;$(SolutionDir)Lanes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
       <PreprocessorDefinitions>_WINDLL;_DEBUG;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <PostBuildEvent>
       <Command>xcopy /R /F /Y /I "$(TargetPath)" $(SolutionDir)..\LuaJIT-2.0.5\bin\$(Platform)\</Command>
@@ -609,6 +623,7 @@
       <AdditionalIncludeDirectories>$(SolutionDir)..\Lua54\include;$(SolutionDir)Lanes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
       <PreprocessorDefinitions>_WINDLL;_DEBUG;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <PostBuildEvent>
       <Command>xcopy /R /F /Y /I "$(TargetPath)" $(SolutionDir)..\framework\</Command>
@@ -628,6 +643,7 @@
       <AdditionalIncludeDirectories>$(SolutionDir)..\MoonJIT\src;$(SolutionDir)Lanes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
       <PreprocessorDefinitions>_WINDLL;_DEBUG;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <PostBuildEvent>
       <Command>xcopy /R /F /Y /I "$(TargetPath)" $(SolutionDir)..\MoonJIT\bin\$(Platform)\</Command>
@@ -648,6 +664,7 @@
       <ConformanceMode>true</ConformanceMode>
       <AdditionalIncludeDirectories>$(SolutionDir)..\Lua53\include;$(SolutionDir)Lanes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <Link>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
@@ -666,6 +683,7 @@
       <ConformanceMode>true</ConformanceMode>
       <AdditionalIncludeDirectories>$(SolutionDir)..\Lua54\include;$(SolutionDir)Lanes;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <Link>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
@@ -675,11 +693,11 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
-    <ClCompile Include="..\src\compat.c" />
-    <ClCompile Include="..\src\deep.c" />
-    <ClCompile Include="..\src\tools.c" />
-    <ClCompile Include="..\src\universe.c" />
-    <ClCompile Include="deep_test.c" />
+    <ClCompile Include="..\src\compat.cpp" />
+    <ClCompile Include="..\src\deep.cpp" />
+    <ClCompile Include="..\src\tools.cpp" />
+    <ClCompile Include="..\src\universe.cpp" />
+    <ClCompile Include="deep_test.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\src\compat.h" />
diff --git a/deep_test/deep_test.vcxproj.filters b/deep_test/deep_test.vcxproj.filters
index be47da9..814301f 100644
--- a/deep_test/deep_test.vcxproj.filters
+++ b/deep_test/deep_test.vcxproj.filters
@@ -15,21 +15,21 @@
     </Filter>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="deep_test.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\src\deep.c">
+    <ClCompile Include="..\src\compat.cpp">
       <Filter>Lanes</Filter>
     </ClCompile>
-    <ClCompile Include="..\src\universe.c">
+    <ClCompile Include="..\src\deep.cpp">
       <Filter>Lanes</Filter>
     </ClCompile>
-    <ClCompile Include="..\src\compat.c">
+    <ClCompile Include="..\src\tools.cpp">
       <Filter>Lanes</Filter>
     </ClCompile>
-    <ClCompile Include="..\src\tools.c">
+    <ClCompile Include="..\src\universe.cpp">
       <Filter>Lanes</Filter>
     </ClCompile>
+    <ClCompile Include="deep_test.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\src\deep.h">
diff --git a/deep_test/deep_test.vcxproj.user b/deep_test/deep_test.vcxproj.user
index 96d9b1d..24e3d31 100644
--- a/deep_test/deep_test.vcxproj.user
+++ b/deep_test/deep_test.vcxproj.user
@@ -33,8 +33,9 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug 5.4|x64'">
     <LocalDebuggerCommand>$(SolutionDir)..\framework\lua54.exe</LocalDebuggerCommand>
     <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
-    <LocalDebuggerCommandArguments>-i deeptest.lua</LocalDebuggerCommandArguments>
+    <LocalDebuggerCommandArguments>deeptest.lua</LocalDebuggerCommandArguments>
     <LocalDebuggerWorkingDirectory>$(SolutionDir)Lanes\lanes\deep_test\</LocalDebuggerWorkingDirectory>
+    <RemoteDebuggerCommandArguments>deeptest.lua</RemoteDebuggerCommandArguments>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MoonJIT|x64'">
     <LocalDebuggerCommand>$(SolutionDir)..\MoonJIT\bin\$(Platform)\moonjit.exe</LocalDebuggerCommand>
diff --git a/docs/index.html b/docs/index.html
index da94898..3e535a6 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -64,13 +64,13 @@
                 <font size="-1">
                         <p>
                                 <br/>
-                                <i>Copyright &copy; 2007-23 Asko Kauppi, Benoit Germain. All rights reserved.</i>
+                                <i>Copyright &copy; 2007-24 Asko Kauppi, Benoit Germain. All rights reserved.</i>
                                 <br/>
                                 Lua Lanes is published under the same <a href="http://en.wikipedia.org/wiki/MIT_License">MIT license</a> as Lua 5.1, 5.2, 5.3 and 5.4.
                         </p>
 
                         <p>
-                                This document was revised on 11-Apr-24, and applies to version <tt>3.17.0</tt>.
+                                This document was revised on 9-Apr-24, and applies to version <tt>4.0.0</tt>.
                         </p>
                 </font>
         </center>
@@ -88,7 +88,7 @@
         Lanes is included into your software by the regular <tt>require "lanes"</tt> method. No C side programming is needed; all APIs are Lua side, and most existing extension modules should work seamlessly together with the multiple lanes.
 </p>
 <p>
-        Starting with version 3.1.6, Lanes should build and run identically with either Lua 5.1 or Lua 5.2. Version 3.10.0 supports Lua 5.3.
+        Lanes should build and run identically with either Lua 5.1 to Lua 5.4, as well as LuaJIT.
 </p>
 <p>
         See <A HREF="comparison.html">comparison</A> of Lua Lanes with other Lua multithreading solutions.
@@ -152,7 +152,7 @@
 <h2 id="installing">Building and Installing</h2>
 
 <p>
-        Lua Lanes is built simply by <tt>make</tt> on the supported platforms (<tt>make-vc</tt> for Visual C++). See <tt>README</tt> for system specific details and limitations.
+        Lua Lanes is implemented in C++20. It is built simply by <tt>make</tt> on the supported platforms (<tt>make-vc</tt> for Visual C++). See <tt>README</tt> for system specific details and limitations.
 </p>
 
 <p>
@@ -178,14 +178,14 @@
 <table border=1 bgcolor="#E0E0FF" cellpadding="10" style="width:50%">
         <tr>
                 <td>
-                        <pre>   extern void LANES_API luaopen_lanes_embedded( lua_State* L, lua_CFunction _luaopen_lanes);</pre>
+                        <pre>   extern void LANES_API luaopen_lanes_embedded(lua_State* L, lua_CFunction _luaopen_lanes);</pre>
                 </td>
         </tr>
 </table>
 <p>
         <tt>luaopen_lanes_embedded</tt> leaves the module table on the stack. <tt>lanes.configure()</tt> must still be called in order to use Lanes.
         <br/>
-        If <tt>_luaopen_lanes</tt> is <tt>NULL</tt>, a default loader will simply attempt the equivalent of <tt>luaL_dofile( L, "lanes.lua")</tt>.
+        If <tt>_luaopen_lanes</tt> is <tt>NULL</tt>, a default loader will simply attempt the equivalent of <tt>luaL_dofile(L, "lanes.lua")</tt>.
 </p>
 
 <p>
@@ -198,30 +198,30 @@
                         <td>
                                 <pre>   #include "lanes.h"</pre>
                                 <br/>
-                                <pre>   int load_lanes_lua( lua_State* L)</pre>
+                                <pre>   int load_lanes_lua(lua_State* L)</pre>
                                 <pre>   {</pre>
                                 <pre>           // retrieve lanes.lua from wherever it is stored and return the result of its execution</pre>
                                 <pre>           // trivial example 1:</pre>
-                                <pre>           luaL_dofile( L, "lanes.lua");</pre>
+                                <pre>           luaL_dofile(L, "lanes.lua");</pre>
                                 <br/>
                                 <pre>           // trivial example 2:</pre>
-                                <pre>           luaL_dostring( L, bin2c_lanes_lua);</pre>
+                                <pre>           luaL_dostring(L, bin2c_lanes_lua);</pre>
                                 <pre>   }</pre>
                                 <br/>
-                                <pre>   void embed_lanes( lua_State* L)</pre>
+                                <pre>   void embed_lanes(lua_State* L)</pre>
                                 <pre>   {</pre>
                                 <pre>           // we need base libraries for Lanes for work</pre>
-                                <pre>           luaL_openlibs( L);</pre>
+                                <pre>           luaL_openlibs(L);</pre>
                                 <pre>           ...</pre>
-                                <pre>           // will attempt luaL_dofile( L, "lanes.lua");</pre>
-                                <pre>           luaopen_lanes_embedded( L, NULL);</pre>
-                                <pre>           lua_pop( L, 1);</pre>
+                                <pre>           // will attempt luaL_dofile(L, "lanes.lua");</pre>
+                                <pre>           luaopen_lanes_embedded(L, nullptr);</pre>
+                                <pre>           lua_pop(L, 1);</pre>
                                 <pre>           // another example with a custom loader</pre>
-                                <pre>           luaopen_lanes_embedded( L, load_lanes_lua);</pre>
-                                <pre>           lua_pop( L, 1);</pre>
+                                <pre>           luaopen_lanes_embedded(L, load_lanes_lua);</pre>
+                                <pre>           lua_pop(L, 1);</pre>
                                 <br/>
                                 <pre>           // a little test to make sure things work as expected</pre>
-                                <pre>           luaL_dostring( L, "local lanes = require 'lanes'.configure{with_timers = false}; local l = lanes.linda()");</pre>
+                                <pre>           luaL_dostring(L, "local lanes = require 'lanes'.configure{with_timers = false}; local l = lanes.linda()");</pre>
                                 <pre>   }</pre>
                         </td>
                 </tr>
@@ -246,7 +246,7 @@
 </table>
 
 <p>
-        Starting with version 3.0-beta, requiring the module follows Lua 5.2 rules: the module is not available under the global name "lanes", but has to be accessed through <tt>require</tt>'s return value.
+        Requiring the module follows Lua 5.2+ rules: the module is not available under the global name "lanes", but has to be accessed through <tt>require</tt>'s return value.
 </p>
 <p>
         After lanes is required, it is necessary to call <tt>lanes.configure()</tt>, which is the only function exposed by the module at this point. Calling <tt>configure()</tt> will perform one-time initializations and make the rest of the API available.
@@ -259,14 +259,14 @@
         It remains to be seen whether this is actually useful or not: If a module is already threadsafe, protecting its initialization isn't useful. And if it is not, any parallel operation may crash without Lanes being able to do anything about it.
 </p>
 <p>
-        <b>IMPORTANT NOTE:</b> Starting with version 3.7.0, only the first occurence of <tt>require "lanes"</tt> must be followed by a call to <tt>.configure()</tt>. From this point, a simple <tt>require "lanes"</tt> will do wherever you need to require lanes again.
+        <b>IMPORTANT NOTE:</b> Only the first occurence of <tt>require "lanes"</tt> must be followed by a call to <tt>.configure()</tt>. From this point, a simple <tt>require "lanes"</tt> will do wherever you need to require lanes again.
 </p>
 
 <p>
         <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%">
                 <tr>
                         <td>
-                                <pre>   lanes.configure( [opt_tbl])</pre>
+                                <pre>   lanes.configure([opt_tbl])</pre>
                         </td>
                 </tr>
         </table>
@@ -296,9 +296,8 @@
                         </td>
                         <td>integer</td>
                         <td>
-                                (Since v3.17.0)<br/>
-                                If &lt;0, GC runs automatically. This is the default.<br />
-                                If 0, GC runs after *every* keeper operation.<br />
+                                If &lt;0, GC runs automatically. This is the default.<br/>
+                                If 0, GC runs after *every* keeper operation.<br/>
                                 If &gt;0, Keepers run GC manually with <tt>lua_gc(LUA_GCCOLLECT)</tt> whenever memory usage reported by <tt>lua_gc(LUA_GCCOUNT)</tt> reaches this threshold. Check is made after every keeper operation (see <a href="#lindas">below</a>). If memory usage remains above threshold after the GC cycle, an error is raised.
                         </td>
                 </tr>
@@ -324,26 +323,12 @@
                                 <tt>nil</tt>/<tt>false</tt>/<tt>true</tt>
                         </td>
                         <td>
-                                (Since v3.6.3) If equal to <tt>true</tt>, Lanes will collect more information when transfering stuff across Lua states to help identify errors (with a cost).
+                                If equal to <tt>true</tt>, Lanes will collect more information when transfering stuff across Lua states to help identify errors (with a cost).
                                 Default is <tt>false</tt>.
                         </td>
                 </tr>
 
                 <tr valign=top>
-                        <td id="protect_allocator">
-                                <code>.protect_allocator</code>
-                        </td>
-                        <td>
-                                <tt>nil</tt>/<tt>false</tt>/<tt>true</tt>
-                        </td>
-                        <td>
-                                REPLACED BY <tt>allocator="protected"</tt> AS OF VERSION v3.13.0.
-                                (Since v3.5.2) If equal to <tt>true</tt>, Lanes wraps all calls to the state's allocator function inside a mutex. Since v3.6.3, when left unset, Lanes attempts to autodetect this value for LuaJIT (the guess might be wrong if <tt>"ffi"</tt> isn't loaded though).
-                                Default is <tt>true</tt> when Lanes detects it is run by LuaJIT, else <tt>nil</tt>.
-                        </td>
-                </tr>
-
-                <tr valign=top>
                         <td id="allocator">
                                 <code>.allocator</code>
                         </td>
@@ -351,18 +336,17 @@
                                 <tt>nil</tt>/<tt>"protected"</tt>/function
                         </td>
                         <td>
-                                (Since v3.13.0)<br />
                                 If <tt>nil</tt>, Lua states are created with <tt>lua_newstate()</tt> and reuse the allocator from the master state.<br />
                                 If <tt>"protected"</tt>, The default allocator obtained from <tt>lua_getallocf()</tt> in the master state is wrapped inside a critical section and used in all newly created states.<br />
                                 If a <tt>function</tt>, this function is called prior to creating the state. It should return a full userdata containing the following structure:
                                 <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%">
                                         <tr>
                                                 <td>
-                                                        <pre>   struct { lua_Alloc allocF; void* allocUD;}</pre>
+                                                        <pre>   struct { lua_Alloc allocF; void* allocUD; }</pre>
                                                 </td>
                                         </tr>
                                 </table>
-                                The contents will be used to create the state with <tt>lua_newstate( allocF, allocUD)</tt>.
+                                The contents will be used to create the state with <tt>lua_newstate(allocF, allocUD)</tt>.
                                 This option is mostly useful for embedders that want to provide different allocators to each lane, for example to have each one work in a different memory pool thus preventing the need for the allocator itself to be threadsafe.
                         </td>
                 </tr>
@@ -375,7 +359,6 @@
                                 <tt>"libc"</tt>/<tt>"allocator"</tt>
                         </td>
                         <td>
-                                (Since v3.16.1)<br />
                                 Controls which allocator is used for Lanes internal allocations (for keeper, linda and lane management).
                                 If <tt>"libc"</tt>, Lanes uses <tt>realloc</tt> and <tt>free</tt>.<br />
                                 If <tt>"allocator"</tt>, Lanes uses whatever was obtained from the <tt>"allocator"</tt> setting.<br />
@@ -391,7 +374,7 @@
                                 <tt>nil</tt>/<tt>false</tt>/<tt>true</tt>
                         </td>
                         <td>
-                                (Since v3.7.5) If equal to <tt>false</tt> or <tt>nil</tt>, Lanes raises an error when attempting to transfer a non-deep full userdata, else it will be demoted to a light userdata in the destination.
+                                If equal to <tt>false</tt> or <tt>nil</tt>, Lanes raises an error when attempting to transfer a non-deep full userdata, else it will be demoted to a light userdata in the destination.
                                 Default is <tt>false</tt> (set to <tt>true</tt> to get the legacy behaviour).
                         </td>
                 </tr>
@@ -428,7 +411,7 @@
                                 </ul>
                                 That way, all changes in the state can be properly taken into account when building the function lookup database. Default is <tt>nil</tt>.
                                 <br />
-                                (Since version 3.7.6) If <tt>on_state_create()</tt> is a Lua function, it will be transfered normally before the call.
+                                If <tt>on_state_create()</tt> is a Lua function, it will be transfered normally before the call.
                                 <br />
                                 If it is a C function, a C closure will be reconstructed in the created state from the C pointer. Lanes will raise an error if the function has upvalues.
                         </td>
@@ -442,25 +425,36 @@
                                 number >= 0
                         </td>
                         <td>
-                                (Since v3.3.0) Sets the duration in seconds Lanes will wait for graceful termination of running lanes at application shutdown. Irrelevant for builds using pthreads. Default is <tt>0.25</tt>.
+                                Sets the duration in seconds Lanes will wait for graceful termination of running lanes at application shutdown. Default is <tt>0.25</tt>.
+                        </td>
+                </tr>
+                <tr valign=top>
+                        <td id="shutdown_mode">
+                                <code>.shutdown_mode</code>
+                        </td>
+                        <td>
+                                <tt>"hard"</tt>/<tt>"soft"</tt>/<tt>"call"</tt>/<tt>"ret"</tt>/<tt>"line"</tt>/<tt>"count"</tt>
+                        </td>
+                        <td>
+                                Select the cancellation mode used at Lanes shutdown to request free running lane termination. See <a href="#cancelling">lane cancellation</a>. Default is <tt>"hard"</tt>.
                         </td>
                 </tr>
         </table>
 </p>
 
 <p>
-        (Since v3.5.0) Once Lanes is configured, one should register with Lanes the modules exporting functions that will be transferred either during lane generation or through <a href="#lindas">lindas</a>.
+        Once Lanes is configured, one should register with Lanes the modules exporting functions that will be transferred either during lane generation or through <a href="#lindas">lindas</a>.
         <br/>
         Use <tt>lanes.require()</tt> for this purpose. This will call the original <tt>require()</tt>, then add the result to the lookup databases.
         <br/>
-        (Since version 3.11) It is also possible to register a given module with <tt>lanes.register()</tt>. This function will raise an error if the registered module is not a function or table.
+        It is also possible to register a given module with <tt>lanes.register()</tt>. This function will raise an error if the registered module is not a function or table.
 </p>
 
 <table border="1" bgcolor="#FFFFE0" cellpadding="10" style="width:50%">
         <tr>
                 <td>
                         <pre>   local m = lanes.require "modname"</pre>
-                        <pre>   lanes.register( "modname", module)</pre>
+                        <pre>   lanes.register("modname", module)</pre>
                 </td>
         </tr>
 </table>
@@ -477,11 +471,11 @@
                 <td>
                         <pre>   local lanes = require "lanes".configure()</pre>
                         <br/>
-                        <pre>   f = lanes.gen( function( n) return 2 * n end)</pre>
-                        <pre>   a = f( 1)</pre>
-                        <pre>   b = f( 2)</pre>
+                        <pre>   f = lanes.gen(function(n) return 2 * n end)</pre>
+                        <pre>   a = f(1)</pre>
+                        <pre>   b = f(2)</pre>
                         <br/>
-                        <pre>   print( a[1], b[1] )     -- 2    4</pre>
+                        <pre>   print(a[1], b[1])     -- 2    4</pre>
                 </td>
         </tr>
 </table>
@@ -489,8 +483,8 @@
 <table border=1 bgcolor="#E0E0FF" cellpadding="10" style="width:50%">
         <tr>
                 <td>
-                        <pre>   func = lanes.gen( [libs_str | opt_tbl [, ...],] lane_func)</pre>
-                        <pre>   lane_h = func( ...)</pre>
+                        <pre>   func = lanes.gen([libs_str | opt_tbl [, ...],] lane_func)</pre>
+                        <pre>   lane_h = func(...)</pre>
                 </td>
         </tr>
 </table>
@@ -714,7 +708,7 @@
                         </td>
                         <td>function</td>
                         <td>
-                                (Since version 3.8.2) Callback that gets invoked when the lane is garbage collected. The function receives two arguments (the lane name and a string, either <tt>"closed"</tt> or <tt>"selfdestruct"</tt>).
+                                Callback that gets invoked when the lane is garbage collected. The function receives two arguments (the lane name and a string, either <tt>"closed"</tt> or <tt>"selfdestruct"</tt>).
                         </td>
                 </tr>
                 <tr valign=top>
@@ -737,8 +731,6 @@
                         </td>
                         <td> table</td>
                         <td>
-                                Introduced at version 3.0.
-                                <br/>
                                 Specifying it when <code>libs_str</code> doesn't cause the <code>package</code> library to be loaded will generate an error.
                                 <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.
@@ -749,26 +741,22 @@
 <p>
         Each lane also gets a global function <tt>set_debug_threadname()</tt> that it can use anytime to do as the name says. Supported debuggers are Microsoft Visual Studio (for the C side) and Decoda (for the Lua side).
         <br/>
-        Starting with version 3.8.1, the lane has a new method <tt>lane:get_debug_threadname()</tt> that gives access to that name from the caller side (returns <tt>"&lt;unnamed&gt;"</tt> if unset, <tt>"&lt;closed&gt;"</tt> if the internal Lua state is closed).
+        The lane also has a method <tt>lane:get_debug_threadname()</tt> that gives access to that name from the caller side (returns <tt>"&lt;unnamed&gt;"</tt> if unset, <tt>"&lt;closed&gt;"</tt> if the internal Lua state is closed).
 </p>
 
 <p>
         If a lane body pulls a C function imported by a module required before Lanes itself (thus not through a hooked <tt>require</tt>), the lane generator creation will raise an error.
-        The function name it shows is a path where it was found by scanning <tt>_G</tt>. As a utility, the name guessing functionality is exposed as such:
+        The function name it shows is a path where it was found by scanning <tt>_G</tt> and the registry. As a utility, the name guessing functionality is exposed as such:
 
         <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%">
                 <tr>
                         <td>
-                                <pre>   "type", "name" = lanes.nameof( o)</pre>
+                                <pre>   "type", "name" = lanes.nameof(o)</pre>
                         </td>
                 </tr>
         </table>
 </p>
 
-<p>
-        Starting with version 3.8.3, <tt>lanes.nameof()</tt> searches the registry as well.
-</p>
-
 <h3>Free running lanes</h3>
 
 <p>
@@ -777,7 +765,7 @@
         <table border="1" bgcolor="#FFFFE0" cellpadding="10" style="width:50%">
                 <tr>
                         <td>
-                                <pre>   lanes.gen( function( params) ... end ) ( ...)</pre>
+                                <pre>   lanes.gen(function(params) ... end ) (...)</pre>
                         </td>
                 </tr>
         </table>
@@ -793,7 +781,7 @@
         <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%">
                 <tr>
                         <td>
-                                <pre>   lanes.set_thread_priority( prio)</pre>
+                                <pre>   lanes.set_thread_priority(prio)</pre>
                         </td>
                 </tr>
         </table>
@@ -811,7 +799,7 @@
         <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%">
                 <tr>
                         <td>
-                                <pre>   lanes.set_thread_affinity( affinity)</pre>
+                                <pre>   lanes.set_thread_affinity(affinity)</pre>
                         </td>
                 </tr>
         </table>
@@ -898,16 +886,6 @@
                                 received <a href="#cancelling">cancellation</a> and finished itself.
                         </td>
                 </tr>
-                <tr>
-                        <td/>
-                        <td>
-                                <tt>"killed"</tt>
-                        </td>
-                        <td/>
-                        <td>
-                                was forcefully killed by <tt>lane_h:cancel()</tt> (since v3.3.0)
-                        </td>
-        </tr>
         </table>
 </p>
 
@@ -929,7 +907,7 @@
         </table>
 
 <p>
-        Only available if lane tracking feature is compiled (see <tt>HAVE_LANE_TRACKING</tt> in <tt>lanes.c</tt>) and <a href="#track_lanes"><tt>track_lanes</tt></a> is set.
+        Only available if lane tracking feature is compiled (see <tt>HAVE_LANE_TRACKING</tt> in <tt>lanes.cpp</tt>) and <a href="#track_lanes"><tt>track_lanes</tt></a> is set.
         <br/>
         Returns an array table where each entry is a table containing a lane's name and status. Returns <tt>nil</tt> if no lane is running.
 </p>
@@ -940,7 +918,7 @@
 <h2 id="results">Results and errors</h2>
 
 <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
-        set_error_reporting( "basic"|"extended")
+        set_error_reporting("basic"|"extended")
 </pre></td></tr></table>
 
 <p>
@@ -962,11 +940,11 @@
 </p>
 
 <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
-        [...]|[nil,err,stack_tbl]= lane_h:join( [timeout_secs] )
+        [...]|[nil,err,stack_tbl]= lane_h:join([timeout_secs])
 </pre></td></tr></table>
 
 <p>
-        Waits until the lane finishes, or <tt>timeout</tt> seconds have passed. Returns <tt>nil, "timeout"</tt> on timeout (since v3.13), <tt>nil,err,stack_tbl</tt> if the lane hit an error, <tt>nil, "killed"</tt> if forcefully killed (starting with v3.3.0), or the return values of the lane.
+        Waits until the lane finishes, or <tt>timeout</tt> seconds have passed. Returns <tt>nil, "timeout"</tt> on timeout, <tt>nil,err,stack_tbl</tt> if the lane hit an error, <tt>nil, "killed"</tt> if forcefully killed, or the return values of the lane.
         Unlike in reading the results in table fashion, errors are not propagated.
 </p>
 
@@ -987,14 +965,14 @@
 <table border=1 bgcolor="#FFFFE0" cellpadding="10" style="width:50%"><tr><td><pre>
         require "lanes".configure()
 
-        f = lanes.gen( function() error "!!!" end)
-        a = f( 1)
+        f = lanes.gen(function() error "!!!" end)
+        a = f(1)
 
-        --print( a[1])   -- propagates error
+        --print(a[1])   -- propagates error
 
         v, err = a:join()   -- no propagation
         if v == nil then
-                error( "'a' faced error"..tostring(err))   -- manual propagation
+                error("'a' faced error"..tostring(err))   -- manual propagation
         end
 </pre></td></tr></table>
 
@@ -1006,12 +984,12 @@
         require "lanes".configure()
 
         local sync_linda = lanes.linda()
-        f = lanes.gen( function() dostuff() sync_linda:send( "done", true) end)
+        f = lanes.gen(function() dostuff() sync_linda:send("done", true) end)
         a = f()
         b = f()
         c = f()
 
-        sync_linda:receive( nil, sync_linda.batched, "done", 3) -- wait for 3 lanes to write something in "done" slot of sync_linda
+        sync_linda:receive(nil, sync_linda.batched, "done", 3) -- wait for 3 lanes to write something in "done" slot of sync_linda
 </pre></td></tr></table>
 
 <!-- cancelling +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
@@ -1019,39 +997,36 @@
 <h2 id="cancelling">Cancelling</h2>
 
 <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
-        bool[,reason] = lane_h:cancel( "soft" [, timeout] [, wake_bool])
-        bool[,reason] = lane_h:cancel( "hard" [, timeout] [, force [, forcekill_timeout]])
-        bool[,reason] = lane_h:cancel( [mode, hookcount] [, timeout] [, force [, forcekill_timeout]])
+        bool[,reason] = lane_h:cancel("soft" [, timeout] [, wake_lane])
+        bool[,reason] = lane_h:cancel("hard" [, timeout] [, wake_lane])
+        bool[,reason] = lane_h:cancel([mode, hookcount] [, timeout] [, wake_lane])
 </pre></td></tr></table>
 
 <p>
         <tt>cancel()</tt> sends a cancellation request to the lane.<br/>
-        First argument is a <tt>mode</tt> can be one of <tt>"hard"</tt>, <tt>"soft"</tt>, <tt>"count"</tt>, <tt>"line"</tt>, <tt>"call"</tt>, <tt>"ret"</tt>.
+        First argument is a <tt>mode</tt> can be one of <tt>"hard"</tt>, <tt>"soft"</tt>, <tt>"call"</tt>, <tt>"ret"</tt>, <tt>"line"</tt>, <tt>"count"</tt>.
         If <tt>mode</tt> is not specified, it defaults to <tt>"hard"</tt>.
+        If <tt>wake_lane</tt> is <tt>true</tt>, the lane is also signalled so that execution returns from any pending linda operation. Linda operations detecting the cancellation request return <tt>lanes.cancel_error</tt>.
 </p>
 <p>
         If <tt>mode</tt> is <tt>"soft"</tt>, cancellation will only cause <tt>cancel_test()</tt> to return <tt>true</tt>, so that the lane can cleanup manually.<br/>
-        If <tt>wake_bool</tt> is <tt>true</tt>, the lane is also signalled so that execution returns from any pending linda operation. Linda operations detecting the cancellation request return <tt>lanes.cancel_error</tt>.
 </p>
 <p>
         If <tt>mode</tt> is <tt>"hard"</tt>, waits for the request to be processed, or a timeout to occur. Linda operations detecting the cancellation request will raise a special cancellation error (meaning they won't return in that case).<br/>
-        <tt>timeout</tt> defaults to 0 if not specified.
+        <tt>wake_lane</tt> defaults to <tt>true</tt>, and <tt>timeout</tt> defaults to 0 if not specified.
 </p>
 <p>
         Other values of <tt>mode</tt> will asynchronously install the corresponding hook, then behave as <tt>"hard"</tt>.
 </p>
 <p>
-        If <tt>force_kill_bool</tt> is <tt>true</tt>, <tt>forcekill_timeout</tt> can be set to tell how long lanes will wait for the OS thread to terminate before raising an error. Windows threads always terminate immediately, but it might not always be the case with some pthread implementations.
-</p>
-<p>
         Returns <tt>true, lane_h.status</tt> if lane was already done (in <tt>"done"</tt>, <tt>"error"</tt> or <tt>"cancelled"</tt> status), or the cancellation was fruitful within <tt>timeout_secs</tt> timeout period.<br/>
         Returns <tt>false, "timeout"</tt> otherwise.
 </p>
 <p>
-        If the lane is still running after the timeout expired and <tt>force_kill</tt> is <tt>true</tt>, the OS thread running the lane is forcefully killed. This means no GC, probable OS resource leaks (thread stack, locks, DLL notifications), and should generally be the last resort.
+        If the lane is still running after the timeout expired, there is a chance lanes will raise an error at shutdown when failing to terminate all free-running lanes within the specified timeout.
 </p>
 <p>
-        Cancellation is tested <u>before</u> going to sleep in <tt>receive()</tt> or <tt>send()</tt> calls and after executing <tt>cancelstep</tt> Lua statements. Starting with version 3.0-beta, a pending <tt>receive()</tt>or <tt>send()</tt> call is awakened.
+        Cancellation is tested <u>before</u> going to sleep in <tt>receive()</tt> or <tt>send()</tt> calls and after executing <tt>cancelstep</tt> Lua statements. A pending <tt>receive()</tt>or <tt>send()</tt> call is awakened.
         <br/>
         This means the execution of the lane will resume although the operation has not completed, to give the lane a chance to detect cancellation (even in the case the code waits on a <a href="#lindas">linda</a> with infinite timeout).
         <br/>
@@ -1066,9 +1041,9 @@
 <h2 id="finalizers">Finalizers</h2>
 
 <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
-        set_finalizer( finalizer_func)
+        set_finalizer(finalizer_func)
 
-        void = finalizer_func( [err, stack_tbl])
+        void = finalizer_func([err, stack_tbl])
 </pre></td></tr></table>
 
 <p>
@@ -1088,16 +1063,16 @@
 
 <table border="1" bgcolor="#FFFFE0" cellpadding="10" style="width:50%"><tr><td><pre>
         local lane_body = function()
-                set_finalizer( function( err, stk)
-                        if err and type( err) ~= "userdata" then
+                set_finalizer(function(err, stk)
+                        if err and type(err) ~= "userdata" then
                                 -- no special error: true error
-                                print( " error: "..tostring(err))
-                        elseif type( err) == "userdata" then
+                                print(" error: "..tostring(err))
+                        elseif type(err) == "userdata" then
                                 -- lane <a href="#cancelling">cancellation</a> is performed by throwing a special userdata as error
-                                print( "after cancel")
+                                print("after cancel")
                         else
                                 -- no error: we just got finalized
-                                print( "finalized")
+                                print("finalized")
                         end
                 end)
         end
@@ -1123,22 +1098,22 @@
 
         local linda = lanes.linda()
 
-        local function loop( max)
+        local function loop(max)
                 for i = 1, max do
-                        print( "sending: " .. i)
-                        linda:send( "x", i)    -- linda as upvalue
+                        print("sending: " .. i)
+                        linda:send("x", i)    -- linda as upvalue
                 end
         end
 
-        a = lanes.gen( "", loop)( 10000)
+        a = lanes.gen("", loop)(10000)
 
         while true do
-                local key, val = linda:receive( 3.0, "x")    -- timeout in seconds
+                local key, val = linda:receive(3.0, "x")    -- timeout in seconds
                 if val == nil then
-                        print( "timed out")
+                        print("timed out")
                         break
                 end
-                print( tostring( linda) .. " received: " .. val)
+                print(tostring(linda) .. " received: " .. val)
         end
 </pre></td></tr></table>
 
@@ -1153,23 +1128,23 @@
                 <li>two producer-side methods: <tt>:send</tt> and <tt>:set</tt> (not out).</li>
                 <li><tt>send</tt> allows for sending multiple values -atomically- to a given key.</li>
                 <li><tt>receive</tt> can wait for multiple keys at once.</li>
-                <li><tt>receive</tt> has a batched mode to consume more than one value from a single key, as in <tt>linda:receive( 1.0, linda.batched, "key", 3, 6).</tt></li>
+                <li><tt>receive</tt> has a batched mode to consume more than one value from a single key, as in <tt>linda:receive(1.0, linda.batched, "key", 3, 6).</tt></li>
                 <li>individual keys' queue length can be limited, balancing speed differences in a producer/consumer scenario (making <tt>:send</tt> wait).</li>
-                <li><tt>tostring( linda)</tt> returns a string of the form <tt>"Linda: &lt;opt_name&gt;"</tt></li>
-                <li>several lindas may share the same keeper state. Since version 3.9.1, state assignation can be controlled with the linda's group (an integer). All lindas belonging to the same group will share the same keeper state. One keeper state may be shared by several groups.</li>
+                <li><tt>tostring(linda)</tt> returns a string of the form <tt>"Linda: &lt;opt_name&gt;"</tt></li>
+                <li>several lindas may share the same keeper state. State assignation can be controlled with the linda's group (an integer). All lindas belonging to the same group will share the same keeper state. One keeper state may be shared by several groups.</li>
         </ul>
 </p>
 
 <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
-        h = lanes.linda( [opt_name, [opt_group]])
+        h = lanes.linda([opt_name, [opt_group]])
 
-        [true|lanes.cancel_error] = h:send( [timeout_secs,] [h.null,] key, ...)
+        [true|lanes.cancel_error] = h:send([timeout_secs,] [h.null,] key, ...)
 
-        [key, val]|[lanes.cancel_error] = h:receive( [timeout_secs,] key [, ...])
+        [key, val]|[lanes.cancel_error] = h:receive([timeout_secs,] key [, ...])
 
-        [key, val [, ...]]|[lanes.cancel_error] = h:receive( timeout, h.batched, key, n_uint_min[, n_uint_max])
+        [key, val [, ...]]|[lanes.cancel_error] = h:receive(timeout, h.batched, key, n_uint_min[, n_uint_max])
 
-        [true|lanes.cancel_error] = h:limit( key, n_uint)
+        [true|lanes.cancel_error] = h:limit(key, n_uint)
 </pre></td></tr></table>
 
 <p>
@@ -1181,7 +1156,7 @@
         <br/>
         A limit of 0 is allowed to block everything.
         <br/>
-        (Since version 3.7.7) if the key was full but the limit change added some room, <tt>limit()</tt> returns <tt>true</tt> and the linda is signalled so that <tt>send()</tt>-blocked threads are awakened.
+        If the key was full but the limit change added some room, <tt>limit()</tt> returns <tt>true</tt> and the linda is signalled so that <tt>send()</tt>-blocked threads are awakened.
 </p>
 
 <p>
@@ -1195,9 +1170,9 @@
 <p>
         <tt>send()</tt> returns <tt>true</tt> if the sending succeeded, and <tt>false</tt> if the queue limit was met, and the queue did not empty enough during the given timeout.
         <br/>
-        (Since version 3.7.8) <tt>send()</tt> returns <tt>lanes.cancel_error</tt> if interrupted by a soft cancel request.
+        <tt>send()</tt> returns <tt>lanes.cancel_error</tt> if interrupted by a soft cancel request.
         <br/>
-        If no data is provided after the key, <tt>send()</tt> raises an error. Since version 3.9.3,  if provided with <tt>linda.null</tt> before the actual key and there is no data to send, <tt>send()</tt> sends a single <tt>nil</tt>.
+        If no data is provided after the key, <tt>send()</tt> raises an error. If provided with <tt>linda.null</tt> before the actual key and there is no data to send, <tt>send()</tt> sends a single <tt>nil</tt>.
         <br/>
         Also, if <tt>linda.null</tt> is sent as data in a linda, it will be read as a <tt>nil</tt>.
 </p>
@@ -1205,9 +1180,7 @@
 <p>
         Equally, <tt>receive()</tt> returns a key and the value extracted from it, or nothing for timeout. Note that <tt>nil</tt>s can be sent and received; the <tt>key</tt> value will tell it apart from a timeout.
         <br/>
-        Version 3.4.0 introduces an API change in the returned values: <tt>receive()</tt> returns the key followed by the value(s), in that order, and not the other way around.
-        <br/>
-        (Since version 3.7.8) <tt>receive()</tt> returns <tt>lanes.cancel_error</tt> if interrupted by a soft cancel request.
+        <tt>receive()</tt> returns <tt>lanes.cancel_error</tt> if interrupted by a soft cancel request.
 </p>
 
 <p>
@@ -1220,9 +1193,9 @@
 </p>
 
 <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
-        bool|lanes.cancel_error = linda_h:set( key [, val [, ...]])
+        bool|lanes.cancel_error = linda_h:set(key [, val [, ...]])
 
-        [[val [, ...]]|lanes.cancel_error] = linda_h:get( key [, count = 1])
+        [[val [, ...]]|lanes.cancel_error] = linda_h:get(key [, count = 1])
 </pre></td></tr></table>
 
 <p>
@@ -1238,21 +1211,21 @@
 <p>
         <tt>set()</tt> signals the linda for write if a value is stored. If nothing special happens, <tt>set() </tt>returns nothing.
         <br/>
-        Since version 3.7.7, if the key was full but the new data count of the key after <tt>set()</tt> is below its limit, <tt>set()</tt> returns <tt>true</tt> and the linda is also signaled for read so that <tt>send()</tt>-blocked threads are awakened.
+        If the key was full but the new data count of the key after <tt>set()</tt> is below its limit, <tt>set()</tt> returns <tt>true</tt> and the linda is also signaled for read so that <tt>send()</tt>-blocked threads are awakened.
 </p>
 
 <p>
-        Since version 3.8.0, <tt>set()</tt> can write several values at the specified key, writing <tt>nil</tt> values is now possible, and clearing the contents at the specified key is done by not providing any value.
+        <tt>set()</tt> can write several values at the specified key, writing <tt>nil</tt> values is now possible, and clearing the contents at the specified key is done by not providing any value.
         <br/>
         Also, <tt>get()</tt> can read several values at once. If the key contains no data, <tt>get()</tt> returns no value. This can be used to separate the case when reading stored <tt>nil</tt> values.
 </p>
 
 <p>
-        Since version 3.8.4, trying to send or receive data through a cancelled linda does nothing and returns <tt>lanes.cancel_error</tt>.
+        Trying to send or receive data through a cancelled linda does nothing and returns <tt>lanes.cancel_error</tt>.
 </p>
 
 <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
-        [val] = linda_h:count( [key[,...]])
+        [val] = linda_h:count([key[,...]])
 </pre></td></tr></table>
 
 <p>
@@ -1280,7 +1253,7 @@
 </pre></td></tr></table>
 
 <p>
-        (Starting with version 3.8.4) Signals the linda so that lanes waiting for read, write, or both, wake up.
+        Signals the linda so that lanes waiting for read, write, or both, wake up.
         All linda operations (including <tt>get()</tt> and <tt>set()</tt>) will return <tt>lanes.cancel_error</tt> as when the calling lane is <a href="#cancelling">soft-cancelled</a> as long as the linda is marked as cancelled.
         <br/>
         <tt>"none"</tt> reset the linda's cancel status, but doesn't signal it.
@@ -1342,7 +1315,7 @@ events to a common Linda, but... :).</font>
 <h2 id="timers">Timers</h2>
 
 <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
-        void = lanes.timer( linda_h, key, date_tbl|first_secs [,period_secs])
+        void = lanes.timer(linda_h, key, date_tbl|first_secs [,period_secs])
 </pre></td></tr></table>
 
 <p>
@@ -1369,18 +1342,18 @@ events to a common Linda, but... :).</font>
 
         -- First timer once a second, not synchronized to wall clock
         --
-        lanes.timer( linda, "sec", 1, 1)
+        lanes.timer(linda, "sec", 1, 1)
 
         -- Timer to a future event (next even minute); wall clock synchronized
         --
-        local t = os.date( "*t", os.time() + 60)    -- now + 1min
+        local t = os.date("*t", os.time() + 60)    -- now + 1min
         t.sec = 0
 
-        lanes.timer( linda, "min", t, 60)   -- reoccur every minute (sharp)
+        lanes.timer(linda, "min", t, 60)   -- reoccur every minute (sharp)
 
         while true do
-                local key, v = linda:receive( "sec", "min")
-                print( "Timer "..key..": "..v)
+                local key, v = linda:receive("sec", "min")
+                print("Timer "..key..": "..v)
         end
 </pre></td></tr></table>
 
@@ -1394,7 +1367,7 @@ events to a common Linda, but... :).</font>
                 <td>
                         <font size="-1">
                         Having the API as <tt>lanes.timer()</tt> is intentional. Another alternative would be <tt>linda_h:timer()</tt> but timers are not traditionally seen to be part of Lindas. Also, it would mean any lane getting a Linda handle would be able to modify timers on it.
-                        A third choice could be abstracting the timers out of Linda realm altogether (<tt>timer_h= lanes.timer( date|first_secs, period_secs )</tt>) but that would mean separate waiting functions for timers, and lindas.
+                        A third choice could be abstracting the timers out of Linda realm altogether (<tt>timer_h= lanes.timer(date|first_secs, period_secs )</tt>) but that would mean separate waiting functions for timers, and lindas.
                         Even if a linda object and key was returned, that key couldn't be waited upon simultaneously with one's general linda events.
                         The current system gives maximum capabilities with minimum API, and any smoothenings can easily be crafted in Lua at the application level.
                         </font>
@@ -1413,14 +1386,22 @@ events to a common Linda, but... :).</font>
 </p>
 
 <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
-        void = lanes.sleep( [seconds|false])
+        void = lanes.sleep([seconds|false])
 </pre></td></tr></table>
 
 <p>
-        (Since version 3.9.7) A very simple way of sleeping when nothing else is available. Is implemented by attempting to read some data in an unused channel of the internal linda used for timers (this linda exists even when timers aren't enabled).
+        A very simple way of sleeping when nothing else is available. Is implemented by attempting to read some data in an unused channel of the internal linda used for timers (this linda exists even when timers aren't enabled).
         Default duration is null, which should only cause a thread context switch.
 </p>
 
+<table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
+        number = lanes.now_secs()
+</pre></td></tr></table>
+
+<p>
+        Returns the current value of the clock used by timers and lindas.
+</p>
+
 <!-- locks +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
 <hr/>
 <h2 id="locks">Locks etc.</h2>
@@ -1430,11 +1411,11 @@ events to a common Linda, but... :).</font>
 </p>
 
 <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
-        lock_func|lanes.cancel_error = lanes.genlock( linda_h, key [,N_uint=1])
+        lock_func|lanes.cancel_error = lanes.genlock(linda_h, key [,N_uint=1])
 
-        bool|lanes.cancel_error = lock_func( M_uint [, "try"] )     -- acquire
+        bool|lanes.cancel_error = lock_func(M_uint [, "try"] )     -- acquire
         ..
-        bool|lanes.cancel_error = lock_func( -M_uint)    -- release
+        bool|lanes.cancel_error = lock_func(-M_uint)    -- release
 </pre></td></tr></table>
 
 <p>
@@ -1456,9 +1437,9 @@ events to a common Linda, but... :).</font>
 <p>
 
 <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
-        atomic_func|lanes.cancel_error = lanes.genatomic( linda_h, key [,initial_num=0.0])
+        atomic_func|lanes.cancel_error = lanes.genatomic(linda_h, key [,initial_num=0.0])
 
-        new_num|lanes.cancel_error = atomic_func( [diff_num=+1.0])
+        new_num|lanes.cancel_error = atomic_func([diff_num=+1.0])
 </pre></td></tr></table>
 
 <p>
@@ -1483,9 +1464,6 @@ events to a common Linda, but... :).</font>
 <p>
         <ul>
                 <li>Booleans, numbers, strings, light userdata, Lua functions and tables of such can always be passed.</li>
-                        <ul>
-                                <li>Versions 3.4.1 and earlier had an undocumented limitation: Lua functions with an indirect recursive Lua function upvalue raised an error when transfered. This limitation disappeared with version 3.4.2.</li>
-                        </ul>
                 <li>
                         Cyclic tables and/or duplicate references are allowed and reproduced appropriately, but only <u>within the same transmission</u>.
                         <ul>
@@ -1514,7 +1492,7 @@ events to a common Linda, but... :).</font>
                         </ul>
                 </li>
                 <li>Coroutines cannot be passed. A coroutine's Lua state is tied to the Lua state that created it, and there is no way the mixed C/Lua stack of a coroutine can be transfered from one Lua state to another.</li>
-                <li>Starting with version 3.10.1, if the metatable contains <tt>__lanesignore</tt>, the object is skipped and <tt>nil</tt> is transfered instead.</li>
+                <li>If the metatable contains <tt>__lanesignore</tt>, the object is skipped and <tt>nil</tt> is transfered instead.</li>
         </ul>
 </p>
 
@@ -1527,14 +1505,14 @@ events to a common Linda, but... :).</font>
 
 <table border="1" bgcolor="#FFFFE0" cellpadding="10" style="width:50%"><tr><td><pre>
         // expects a C function on top of the source Lua stack
-        copy_func( lua_State *dest, lua_State* source)
+        copy_func(lua_State *dest, lua_State* source)
         {
                 // extract C function pointer from source
-                lua_CFunction func = lua_tocfunction( source, -1);
+                lua_CFunction func = lua_tocfunction(source, -1);
                 // transfer upvalues
-                int nup = transfer_upvalues( dest, source);
+                int nup = transfer_upvalues(dest, source);
                 // dest Lua stack contains a copy of all upvalues
-                lua_pushcfunction( dest, func, nup);
+                lua_pushcfunction(dest, func, nup);
         }
 </pre></td></tr></table>
 
@@ -1546,12 +1524,12 @@ events to a common Linda, but... :).</font>
 
 <table border="1" bgcolor="#FFFFE0" cellpadding="10" style="width:50%"><tr><td><pre>
         // expects a C function on top of the source Lua stack
-        copy_func( lua_State *dest, lua_State* source)
+        copy_func(lua_State *dest, lua_State* source)
         {
                 // fetch function 'name' from source lookup database
-                char const* funcname = lookup_func_name( source, -1);
+                char const* funcname = lookup_func_name(source, -1);
                 // lookup a function bound to this name in the destination state, and push it on the stack
-                push_resolved_func( dest, funcname);
+                push_resolved_func(dest, funcname);
         }
 </pre></td></tr></table>
 
@@ -1612,7 +1590,7 @@ events to a common Linda, but... :).</font>
 </p>
 
 <table border="1" bgcolor="#FFFFE0" cellpadding="10" style="width:50%"><tr><td><pre>
-        int luaopen_module( lua_State *L )
+        int luaopen_module(lua_State *L )
         {
                 static char been_here;  /* 0 by ANSI C */
 
@@ -1628,27 +1606,27 @@ events to a common Linda, but... :).</font>
 
 <h3 id="clonable_userdata">Clonable full userdata in your own apps</h3>
 <p>
-        Starting with version 3.13.0, a new way of passing full userdata across lanes uses a new <tt>__lanesclone</tt> metamethod.
+        An alternative way of passing full userdata across lanes uses a new <tt>__lanesclone</tt> metamethod.
         When a deep userdata is cloned, Lanes calls <tt>__lanesclone</tt> once, in the context of the source lane.<br/>
         The call receives the clone and original as light userdata, plus the actual userdata size, as in <tt>clone:__lanesclone(original,size)</tt>, and should perform the actual cloning.<br/>
-        A typical implementation would look like (BEWARE, THIS CHANGED WITH VERSION 3.16.0):
+        A typical implementation would look like:
 <table border="1" bgcolor="#FFFFE0" cellpadding="10" style="width:50%"><tr><td><pre>
-static int clonable_lanesclone( lua_State* L)
+static int clonable_lanesclone(lua_State* L)
 {
-        switch( lua_gettop( L))
+        switch(lua_gettop(L))
         {
                 case 3:
                 {
-                        struct s_MyClonableUserdata* self = lua_touserdata( L, 1);
-                        struct s_MyClonableUserdata* from = lua_touserdata( L, 2);
-                        size_t len = lua_tointeger( L, 3);
-                        assert( len == sizeof(struct s_MyClonableUserdata));
+                        struct s_MyClonableUserdata* self = lua_touserdata(L, 1);
+                        struct s_MyClonableUserdata* from = lua_touserdata(L, 2);
+                        size_t len = lua_tointeger(L, 3);
+                        assert(len == sizeof(struct s_MyClonableUserdata));
                         *self = *from;
                 }
                 return 0;
 
                 default:
-                (void) luaL_error( L, "Lanes called clonable_lanesclone with unexpected parameters");
+                std::ignore = luaL_error(L, "Lanes called clonable_lanesclone with unexpected parameters");
         }
         return 0;
 }
@@ -1661,20 +1639,20 @@ static int clonable_lanesclone( lua_State* L)
 <table border="1" bgcolor="#FFFFE0" cellpadding="10" style="width:50%"><tr><td><pre>
 int luaopen_deep_test(lua_State* L)
 {
-        luaL_newlib( L, deep_module);
+        luaL_newlib(L, deep_module);
 
         // preregister the metatables for the types we can instanciate so that Lanes can know about them
-        if( luaL_newmetatable( L, "clonable"))
+        if (luaL_newmetatable(L, "clonable"))
         {
-                luaL_setfuncs( L, clonable_mt, 0);
+                luaL_setfuncs(L, clonable_mt, 0);
                 lua_pushvalue(L, -1);
                 lua_setfield(L, -2, "__index");
         }
         lua_setfield(L, -2, "__clonableMT"); // actual name is not important
 
-        if( luaL_newmetatable( L, "deep"))
+        if (luaL_newmetatable(L, "deep"))
         {
-                luaL_setfuncs( L, deep_mt, 0);
+                luaL_setfuncs(L, deep_mt, 0);
                 lua_pushvalue(L, -1);
                 lua_setfield(L, -2, "__index");
         }
@@ -1688,10 +1666,10 @@ int luaopen_deep_test(lua_State* L)
 <p>
         Then a new clonable userdata instance can just do like any non-Lanes aware userdata, as long as its metatable contains the aforementionned <tt>__lanesclone</tt> method.
 <table border="1" bgcolor="#FFFFE0" cellpadding="10" style="width:50%"><tr><td><pre>
-int luaD_new_clonable( lua_State* L)
+int luaD_new_clonable(lua_State* L)
 {
-        lua_newuserdata( L, sizeof( struct s_MyClonableUserdata));
-        luaL_setmetatable( L, "clonable");
+        lua_newuserdata(L, sizeof(struct s_MyClonableUserdata));
+        luaL_setmetatable(L, "clonable");
         return 1;
 }
 </pre></td></tr></table>
@@ -1706,17 +1684,17 @@ int luaD_new_clonable( lua_State* L)
 <ol>
         <li>
                 Provide an <i>identity function</i> for your userdata, in C. This function is used for creation and deletion of your deep userdata (the shared resource), and for making metatables for the state-specific proxies for accessing it. The prototype is
-                <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>    void* idfunc( lua_State* L, DeepOp op_);</pre></td></tr></table>
+                <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>    void* idfunc(lua_State* L, DeepOp op_);</pre></td></tr></table>
                 <tt>op_</tt> can be one of:
                 <ul>
-                        <li><tt>eDO_new</tt>: requests the creation of a new object, whose pointer is returned. Starting with version 3.13.0, object should embed <tt>DeepPrelude</tt> structure as header and initialize its <tt>magic</tt> member with the current <tt>DEEP_VERSION</tt>.</li>
-                        <li><tt>eDO_delete</tt>: receives this same pointer on the stack as a light userdata, and should cleanup the object.</li>
-                        <li><tt>eDO_metatable</tt>: should build a metatable for the object. Don't cache the metatable yourself, Lanes takes care of it (<tt>eDO_metatable</tt> should only be invoked once per state). Just push the metatable on the stack.</li>
-                        <li><tt>eDO_module</tt>: requests the name of the module that exports the idfunc, to be returned. It is necessary so that Lanes can require it in any lane state that receives a userdata. This is to prevent crashes in situations where the module could be unloaded while the idfunc pointer is still held.</li>
+                        <li><tt>DeepOp::New</tt>: requests the creation of a new object, whose pointer is returned. Said object must derive from <tt>DeepPrelude</tt>.</li>
+                        <li><tt>DeepOp::Delete</tt>: receives this same pointer on the stack as a light userdata, and should cleanup the object.</li>
+                        <li><tt>DeepOp::Metatable</tt>: should build a metatable for the object. Don't cache the metatable yourself, Lanes takes care of it (<tt>DeepOp::Metatable</tt> should only be invoked once per state). Just push the metatable on the stack.</li>
+                        <li><tt>DeepOp::Module</tt>: requests the name of the module that exports the idfunc, to be returned. It is necessary so that Lanes can require it in any lane state that receives a userdata. This is to prevent crashes in situations where the module could be unloaded while the idfunc pointer is still held.</li>
                 </ul>
-                Take a look at <tt>linda_id</tt> in <tt>lanes.c</tt> or <tt>deep_test_id</tt> in <tt>deep_test.c</tt>.
+                Take a look at <tt>linda_id</tt> in <tt>lanes.cpp</tt> or <tt>deep_test_id</tt> in <tt>deep_test.cpp</tt>.
         </li>
-        <li>Include <tt>"deep.h"</tt> and either link against Lanes or statically compile <tt>compat.c deep.c tools.c universe.c</tt> into your module if you want to avoid a runtime dependency for users that will use your module without Lanes.
+        <li>Include <tt>"deep.h"</tt> and either link against Lanes or statically compile <tt>compat.cpp deep.cpp tools.cpp universe.cpp</tt> into your module if you want to avoid a runtime dependency for users that will use your module without Lanes.
         <li>Instanciate your userdata using <tt>luaG_newdeepuserdata()</tt>, instead of the regular <tt>lua_newuserdata()</tt>. Given an <tt>idfunc</tt>, it sets up the support structures and returns a state-specific proxy userdata for accessing your data. This proxy can also be copied over to other lanes.</li>
         <li>Accessing the deep userdata from your C code, use <tt>luaG_todeep()</tt> instead of the regular <tt>lua_touserdata()</tt>.</li>
 </ol>
@@ -1726,17 +1704,17 @@ int luaD_new_clonable( lua_State* L)
 </p>
 
 <p>
-        Deep userdata in transit inside keeper states (sent in a linda but not yet consumed) don't call <tt>idfunc(eDO_delete)</tt> and aren't considered by reference counting. The rationale is the following:
+        Deep userdata in transit inside keeper states (sent in a linda but not yet consumed) don't call <tt>idfunc(DeepOp::Delete)</tt> and aren't considered by reference counting. The rationale is the following:
         <br />
         If some non-keeper state holds a deep userdata for some deep object, then even if the keeper collects its own deep userdata, it shouldn't be cleaned up since the refcount is not 0.
         <br />
         OTOH, if a keeper state holds the last deep userdata for some deep object, then no lane can do actual work with it. Deep userdata's <tt>idfunc()</tt> is never called from a keeper state.
         <br />
-        Therefore, Lanes can just call <tt>idfunc(eDO_delete)</tt> when the last non-keeper-held deep userdata is collected, as long as it doesn't do the same in a keeper state after that, since any remaining deep userdata in keeper states now hold stale pointers.
+        Therefore, Lanes can just call <tt>idfunc(DeepOp::Delete)</tt> when the last non-keeper-held deep userdata is collected, as long as it doesn't do the same in a keeper state after that, since any remaining deep userdata in keeper states now hold stale pointers.
 </p>
 
 <p>
-        <b>NOTE</b>: The lifespan of deep userdata may exceed that of the Lua state that created it. The allocation of the data storage should not be tied to the Lua state used. In other words, use <tt>malloc()</tt>/<tt>free()</tt> or similar memory handling mechanism.
+        <b>NOTE</b>: The lifespan of deep userdata may exceed that of the Lua state that created it. The allocation of the data storage should not be tied to the Lua state used. In other words, use <tt>new</tt>/<tt>delete</tt>, <tt>malloc()</tt>/<tt>free()</tt> or similar memory handling mechanism.
 </p>
 
 
@@ -1757,8 +1735,8 @@ int luaD_new_clonable( lua_State* L)
         In multithreaded scenarios, giving multiple parameters to <tt>print()</tt> or <tt>file:write()</tt> may cause them to be overlapped in the output, something like this:
 
 <table border="1" bgcolor="#FFFFE0" cellpadding="10" style="width:50%"><tr><td><pre>
-        A:  print( 1, 2, 3, 4 )
-        B:  print( 'a', 'b', 'c', 'd' )
+        A:  print(1, 2, 3, 4 )
+        B:  print('a', 'b', 'c', 'd' )
 
         1   a   b   2   3   c   d   4
 </pre></td></tr></table>
@@ -1824,4 +1802,4 @@ int luaD_new_clonable( lua_State* L)
 </p>
 
 </body>
-</html>
\ No newline at end of file
+</html>
diff --git a/lanes-3.17.0-0.rockspec b/lanes-4.0.0-0.rockspec
index 69ee515..4e1b370 100644
--- a/lanes-3.17.0-0.rockspec
+++ b/lanes-4.0.0-0.rockspec
@@ -7,11 +7,11 @@
 
 package = "Lanes"
 
-version = "3.17.0-0"
+version = "4.0.0-0"
 
 source= {
         url= "git+https://github.com/LuaLanes/lanes.git",
-        branch= "v3.17.0"
+        branch= "v4.0.0"
 }
 
 description = {
@@ -60,16 +60,16 @@ build = {
                 {
                         sources =
                         {
-                                "src/cancel.c",
-                                "src/compat.c",
-                                "src/deep.c",
-                                "src/keeper.c",
-                                "src/lanes.c",
-                                "src/linda.c",
-                                "src/tools.c",
-                                "src/state.c",
-                                "src/threading.c",
-                                "src/universe.c"
+                                "src/cancel.cpp",
+                                "src/compat.cpp",
+                                "src/deep.cpp",
+                                "src/keeper.cpp",
+                                "src/lanes.cpp",
+                                "src/linda.cpp",
+                                "src/tools.cpp",
+                                "src/state.cpp",
+                                "src/threading.cpp",
+                                "src/universe.cpp"
                         },
                         incdirs = { "src"},
                 },
diff --git a/make-vc.cmd b/make-vc.cmd
index 6b63b21..f4cd412 100644
--- a/make-vc.cmd
+++ b/make-vc.cmd
@@ -130,8 +130,8 @@ goto ERR_NOLUA
 @REM

 @set FLAGS=/O2 /LD

 

-cl %WARN% %FLAGS% /I "%LUA51%\include" /Felanes\core.dll src\*.c "%LUA_LIB%\lua5.1.lib"

-@REM cl %WARN% %FLAGS% /I "%LUA51%\include" /Felanes\core.dll src\*.c "%LUA_LIB%\lua5.1.lib" /link /NODEFAULTLIB:libcmt

+cl %WARN% %FLAGS% /I "%LUA51%\include" /Felanes\core.dll src\*.cpp "%LUA_LIB%\lua5.1.lib"

+@REM cl %WARN% %FLAGS% /I "%LUA51%\include" /Felanes\core.dll src\*.cpp "%LUA_LIB%\lua5.1.lib" /link /NODEFAULTLIB:libcmt

 

 @del lanes\core.lib

 @del lanes\core.exp

diff --git a/src/Makefile b/src/Makefile
index c4d4c30..cef4174 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -119,7 +119,7 @@ MODULE_DIR=$(MODULE)
 #---
 all: $(MODULE)/core.$(_SO)
 
-%.o: %.c *.h Makefile
+%.o: %.cpp *.h Makefile
 
 # Note: Don't put $(LUA_LIBS) ahead of $^; MSYS will not like that (I think)
 #
diff --git a/src/cancel.c b/src/cancel.c
deleted file mode 100644
index d739ff9..0000000
--- a/src/cancel.c
+++ /dev/null
@@ -1,302 +0,0 @@
-/*
---
--- CANCEL.C
---
--- Lane cancellation support
---
--- Author: Benoit Germain <bnt.germain@gmail.com>
---
---[[
-===============================================================================
-
-Copyright (C) 2011-2019 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
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
-===============================================================================
-]]--
-*/
-
-#include <assert.h>
-#include <string.h>
-
-#include "threading.h"
-#include "cancel.h"
-#include "tools.h"
-#include "lanes_private.h"
-
-// ################################################################################################
-// ################################################################################################
-
-/*
-* Check if the thread in question ('L') has been signalled for cancel.
-*
-* Called by cancellation hooks and/or pending Linda operations (because then
-* the check won't affect performance).
-*
-* Returns TRUE if any locks are to be exited, and 'cancel_error()' called,
-* to make execution of the lane end.
-*/
-static inline enum e_cancel_request cancel_test( lua_State* L)
-{
-    Lane* const s = get_lane_from_registry( L);
-    // 's' is NULL for the original main state (and no-one can cancel that)
-    return s ? s->cancel_request : CANCEL_NONE;
-}
-
-// ################################################################################################
-
-//---
-// bool = cancel_test()
-//
-// Available inside the global namespace of lanes
-// returns a boolean saying if a cancel request is pending
-//
-LUAG_FUNC( cancel_test)
-{
-    enum e_cancel_request test = cancel_test( L);
-    lua_pushboolean( L, test != CANCEL_NONE);
-    return 1;
-}
-
-// ################################################################################################
-// ################################################################################################
-
-static void cancel_hook( lua_State* L, lua_Debug* ar)
-{
-    (void)ar;
-    DEBUGSPEW_CODE( fprintf( stderr, "cancel_hook\n"));
-    if( cancel_test( L) != CANCEL_NONE)
-    {
-        lua_sethook( L, NULL, 0, 0);
-        cancel_error( L);
-    }
-}
-
-// ################################################################################################
-// ################################################################################################
-
-//---
-// = thread_cancel( lane_ud [,timeout_secs=0.0] [,force_kill_bool=false] )
-//
-// The originator thread asking us specifically to cancel the other thread.
-//
-// 'timeout': <0: wait forever, until the lane is finished
-//            0.0: just signal it to cancel, no time waited
-//            >0: time to wait for the lane to detect cancellation
-//
-// 'force_kill': if true, and lane does not detect cancellation within timeout,
-//            it is forcefully killed. Using this with 0.0 timeout means just kill
-//            (unless the lane is already finished).
-//
-// Returns: true if the lane was already finished (DONE/ERROR_ST/CANCELLED) or if we
-//          managed to cancel it.
-//          false if the cancellation timed out, or a kill was needed.
-//
-
-// ################################################################################################
-
-static cancel_result thread_cancel_soft( Lane* s, double secs_, bool_t wake_lindas_)
-{
-    s->cancel_request = CANCEL_SOFT; // it's now signaled to stop
-    // negative timeout: we don't want to truly abort the lane, we just want it to react to cancel_test() on its own
-    if( wake_lindas_) // wake the thread so that execution returns from any pending linda operation if desired
-    {
-        SIGNAL_T *waiting_on = s->waiting_on;
-        if( s->status == WAITING && waiting_on != NULL)
-        {
-            SIGNAL_ALL( waiting_on);
-        }
-    }
-
-    return THREAD_WAIT( &s->thread, secs_, &s->done_signal, &s->done_lock, &s->status) ? CR_Cancelled : CR_Timeout;
-}
-
-// ################################################################################################
-
-static cancel_result thread_cancel_hard( lua_State* L, Lane* s, double secs_, bool_t force_, double waitkill_timeout_)
-{
-    cancel_result result;
-
-    s->cancel_request = CANCEL_HARD;    // it's now signaled to stop
-    {
-        SIGNAL_T *waiting_on = s->waiting_on;
-        if( s->status == WAITING && waiting_on != NULL)
-        {
-            SIGNAL_ALL( waiting_on);
-        }
-    }
-
-    result = THREAD_WAIT( &s->thread, secs_, &s->done_signal, &s->done_lock, &s->status) ? CR_Cancelled : CR_Timeout;
-
-    if( (result == CR_Timeout) && force_)
-    {
-        // Killing is asynchronous; we _will_ wait for it to be done at
-        // GC, to make sure the data structure can be released (alternative
-        // would be use of "cancellation cleanup handlers" that at least
-        // PThread seems to have).
-        //
-        THREAD_KILL( &s->thread);
-#if THREADAPI == THREADAPI_PTHREAD
-        // pthread: make sure the thread is really stopped!
-        // note that this may block forever if the lane doesn't call a cancellation point and pthread doesn't honor PTHREAD_CANCEL_ASYNCHRONOUS
-        result = THREAD_WAIT( &s->thread, waitkill_timeout_, &s->done_signal, &s->done_lock, &s->status) ? CR_Killed : CR_Timeout;
-        if( result == CR_Timeout)
-        {
-            (void) luaL_error( L, "force-killed lane failed to terminate within %f second%s", waitkill_timeout_, waitkill_timeout_ > 1 ? "s" : "");
-        }
-#else
-        (void) waitkill_timeout_; // unused
-        (void) L; // unused
-#endif // THREADAPI == THREADAPI_PTHREAD
-        s->mstatus = KILLED; // mark 'gc' to wait for it
-        // note that s->status value must remain to whatever it was at the time of the kill
-        // because we need to know if we can lua_close() the Lua State or not.
-        result = CR_Killed;
-    }
-    return result;
-}
-
-// ################################################################################################
-
-cancel_result thread_cancel( lua_State* L, Lane* s, CancelOp op_, double secs_, bool_t force_, double waitkill_timeout_)
-{
-    // remember that lanes are not transferable: only one thread can cancel a lane, so no multithreading issue here
-    // We can read 's->status' without locks, but not wait for it (if Posix no PTHREAD_TIMEDJOIN)
-    if( s->mstatus == KILLED)
-    {
-        return CR_Killed;
-    }
-
-    if( s->status >= DONE)
-    {
-        // say "ok" by default, including when lane is already done
-        return CR_Cancelled;
-    }
-
-    // signal the linda the wake up the thread so that it can react to the cancel query
-    // let us hope we never land here with a pointer on a linda that has been destroyed...
-    if( op_ == CO_Soft)
-    {
-        return thread_cancel_soft( s, secs_, force_);
-    }
-
-    return thread_cancel_hard( L, s, secs_, force_, waitkill_timeout_);
-}
-
-// ################################################################################################
-// ################################################################################################
-
-// > 0: the mask
-// = 0: soft
-// < 0: hard
-static CancelOp which_op( lua_State* L, int idx_)
-{
-    if( lua_type( L, idx_) == LUA_TSTRING)
-    {
-        CancelOp op = CO_Invalid;
-        char const* str = lua_tostring( L, idx_);
-        if( strcmp( str, "soft") == 0)
-        {
-            op = CO_Soft;
-        }
-        else if( strcmp( str, "count") == 0)
-        {
-            op = CO_Count;
-        }
-        else if( strcmp( str, "line") == 0)
-        {
-            op = CO_Line;
-        }
-        else if( strcmp( str, "call") == 0)
-        {
-            op = CO_Call;
-        }
-        else if( strcmp( str, "ret") == 0)
-        {
-            op = CO_Ret;
-        }
-        else if( strcmp( str, "hard") == 0)
-        {
-            op = CO_Hard;
-        }
-        lua_remove( L, idx_); // argument is processed, remove it
-        if( op == CO_Invalid)
-        {
-            luaL_error( L, "invalid hook option %s", str);
-        }
-        return op;
-    }
-    return CO_Hard;
-}
-// ################################################################################################
-
-// bool[,reason] = lane_h:cancel( [mode, hookcount] [, timeout] [, force [, forcekill_timeout]])
-LUAG_FUNC( thread_cancel)
-{
-    Lane* s = lua_toLane( L, 1);
-    double secs = 0.0;
-    CancelOp op = which_op( L, 2); // this removes the op string from the stack
-
-    if( op > 0) // hook is requested
-    {
-        int hook_count = (int) lua_tointeger( L, 2);
-        lua_remove( L, 2); // argument is processed, remove it
-        if( hook_count < 1)
-        {
-            return luaL_error( L, "hook count cannot be < 1");
-        }
-        lua_sethook( s->L, cancel_hook, op, hook_count);
-    }
-
-    if( lua_type( L, 2) == LUA_TNUMBER)
-    {
-        secs = lua_tonumber( L, 2);
-        lua_remove( L, 2); // argument is processed, remove it
-        if( secs < 0.0)
-        {
-            return luaL_error( L, "cancel timeout cannot be < 0");
-        }
-    }
-
-    {
-        bool_t force = lua_toboolean( L, 2);     // FALSE if nothing there
-        double forcekill_timeout = luaL_optnumber( L, 3, 0.0);
-
-        switch( thread_cancel( L, s, op, secs, force, forcekill_timeout))
-        {
-            case CR_Timeout:
-            lua_pushboolean( L, 0);
-            lua_pushstring( L, "timeout");
-            return 2;
-
-            case CR_Cancelled:
-            lua_pushboolean( L, 1);
-            push_thread_status( L, s);
-            return 2;
-
-            case CR_Killed:
-            lua_pushboolean( L, 1);
-            push_thread_status( L, s);
-            return 2;
-        }
-    }
-    // should never happen, only here to prevent the compiler from complaining of "not all control paths returning a value"
-    return 0;
-}
diff --git a/src/cancel.cpp b/src/cancel.cpp
new file mode 100644
index 0000000..b3e52b6
--- /dev/null
+++ b/src/cancel.cpp
@@ -0,0 +1,282 @@
+/*
+--
+-- CANCEL.CPP
+--
+-- Lane cancellation support
+--
+-- Author: Benoit Germain <bnt.germain@gmail.com>
+--
+--[[
+===============================================================================
+
+Copyright (C) 2011-2024 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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+===============================================================================
+]]--
+*/
+
+#include "cancel.h"
+
+#include "lanes_private.h"
+#include "threading.h"
+#include "tools.h"
+
+// ################################################################################################
+// ################################################################################################
+
+/*
+* Check if the thread in question ('L') has been signalled for cancel.
+*
+* Called by cancellation hooks and/or pending Linda operations (because then
+* the check won't affect performance).
+*
+* Returns CANCEL_SOFT/HARD if any locks are to be exited, and 'raise_cancel_error()' called,
+* to make execution of the lane end.
+*/
+[[nodiscard]] static inline CancelRequest cancel_test(lua_State* L)
+{
+    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;
+}
+
+// ################################################################################################
+
+//---
+// bool = cancel_test()
+//
+// Available inside the global namespace of lanes
+// returns a boolean saying if a cancel request is pending
+//
+LUAG_FUNC( cancel_test)
+{
+    CancelRequest test{ cancel_test(L) };
+    lua_pushboolean(L, test != CancelRequest::None);
+    return 1;
+}
+
+// ################################################################################################
+// ################################################################################################
+
+[[nodiscard]] static void cancel_hook(lua_State* L, [[maybe_unused]] lua_Debug* ar)
+{
+    DEBUGSPEW_CODE(fprintf(stderr, "cancel_hook\n"));
+    if (cancel_test(L) != CancelRequest::None)
+    {
+        lua_sethook(L, nullptr, 0, 0);
+        raise_cancel_error(L);
+    }
+}
+
+// ################################################################################################
+// ################################################################################################
+
+//---
+// = thread_cancel( lane_ud [,timeout_secs=0.0] [,wake_lindas_bool=false] )
+//
+// The originator thread asking us specifically to cancel the other thread.
+//
+// 'timeout': <0: wait forever, until the lane is finished
+//            0.0: just signal it to cancel, no time waited
+//            >0: time to wait for the lane to detect cancellation
+//
+// 'wake_lindas_bool': if true, signal any linda the thread is waiting on
+//                     instead of waiting for its timeout (if any)
+//
+// Returns: true if the lane was already finished (Done/Error/Cancelled) or if we
+//          managed to cancel it.
+//          false if the cancellation timed out, or a kill was needed.
+//
+
+// ################################################################################################
+
+[[nodiscard]] static CancelResult thread_cancel_soft(Lane* lane_, lua_Duration duration_, bool wake_lane_)
+{
+    lane_->cancel_request = CancelRequest::Soft; // it's now signaled to stop
+    // negative timeout: we don't want to truly abort the lane, we just want it to react to cancel_test() on its own
+    if (wake_lane_) // wake the thread so that execution returns from any pending linda operation if desired
+    {
+        std::condition_variable* const waiting_on{ lane_->m_waiting_on };
+        if (lane_->m_status == Lane::Waiting && waiting_on != nullptr)
+        {
+            waiting_on->notify_all();
+        }
+    }
+
+    return lane_->waitForCompletion(duration_) ? CancelResult::Cancelled : CancelResult::Timeout;
+}
+
+// ################################################################################################
+
+[[nodiscard]] static CancelResult thread_cancel_hard(Lane* lane_, lua_Duration duration_, bool wake_lane_)
+{
+    lane_->cancel_request = CancelRequest::Hard; // it's now signaled to stop
+    //lane_->m_thread.get_stop_source().request_stop();
+    if (wake_lane_) // wake the thread so that execution returns from any pending linda operation if desired
+    {
+        std::condition_variable* waiting_on = lane_->m_waiting_on;
+        if (lane_->m_status == Lane::Waiting && waiting_on != nullptr)
+        {
+            waiting_on->notify_all();
+        }
+    }
+
+    CancelResult result{ lane_->waitForCompletion(duration_) ? CancelResult::Cancelled : CancelResult::Timeout };
+    return result;
+}
+
+// ################################################################################################
+
+CancelResult thread_cancel(Lane* lane_, CancelOp op_, int hook_count_, lua_Duration duration_, bool wake_lane_)
+{
+    // remember that lanes are not transferable: only one thread can cancel a lane, so no multithreading issue here
+    // We can read 'lane_->status' without locks, but not wait for it (if Posix no PTHREAD_TIMEDJOIN)
+    if (lane_->m_status >= Lane::Done)
+    {
+        // say "ok" by default, including when lane is already done
+        return CancelResult::Cancelled;
+    }
+
+    // signal the linda the wake up the thread so that it can react to the cancel query
+    // let us hope we never land here with a pointer on a linda that has been destroyed...
+    if (op_ == CancelOp::Soft)
+    {
+        return thread_cancel_soft(lane_, duration_, wake_lane_);
+    }
+    else if (static_cast<int>(op_) > static_cast<int>(CancelOp::Soft))
+    {
+        lua_sethook(lane_->L, cancel_hook, static_cast<int>(op_), hook_count_);
+    }
+
+    return thread_cancel_hard(lane_, duration_, wake_lane_);
+}
+
+// ################################################################################################
+// ################################################################################################
+
+CancelOp which_cancel_op(char const* op_string_)
+{
+    CancelOp op{ CancelOp::Invalid };
+    if (strcmp(op_string_, "hard") == 0)
+    {
+        op = CancelOp::Hard;
+    }
+    else if (strcmp(op_string_, "soft") == 0)
+    {
+        op = CancelOp::Soft;
+    }
+    else if (strcmp(op_string_, "call") == 0)
+    {
+        op = CancelOp::MaskCall;
+    }
+    else if (strcmp(op_string_, "ret") == 0)
+    {
+        op = CancelOp::MaskRet;
+    }
+    else if (strcmp(op_string_, "line") == 0)
+    {
+        op = CancelOp::MaskLine;
+    }
+    else if (strcmp(op_string_, "count") == 0)
+    {
+        op = CancelOp::MaskCount;
+    }
+    return op;
+}
+
+// ################################################################################################
+
+[[nodiscard]] static CancelOp which_cancel_op(lua_State* L, int idx_)
+{
+    if (lua_type(L, idx_) == LUA_TSTRING)
+    {
+        char const* const str{ lua_tostring(L, idx_) };
+        CancelOp op{ which_cancel_op(str) };
+        lua_remove(L, idx_); // argument is processed, remove it
+        if (op == CancelOp::Invalid)
+        {
+            luaL_error(L, "invalid hook option %s", str); // doesn't return
+        }
+        return op;
+    }
+    return CancelOp::Hard;
+}
+
+// ################################################################################################
+
+// bool[,reason] = lane_h:cancel( [mode, hookcount] [, timeout] [, wake_lindas])
+LUAG_FUNC(thread_cancel)
+{
+    Lane* const lane{ lua_toLane(L, 1) };
+    CancelOp const op{ which_cancel_op(L, 2) }; // this removes the op string from the stack
+
+    int hook_count{ 0 };
+    if (static_cast<int>(op) > static_cast<int>(CancelOp::Soft)) // hook is requested
+    {
+        hook_count = static_cast<int>(luaL_checkinteger(L, 2));
+        lua_remove(L, 2); // argument is processed, remove it
+        if (hook_count < 1)
+        {
+            return luaL_error(L, "hook count cannot be < 1");
+        }
+    }
+
+    lua_Duration wait_timeout{ 0.0 };
+    if (lua_type(L, 2) == LUA_TNUMBER)
+    {
+        wait_timeout = lua_Duration{ lua_tonumber(L, 2) };
+        lua_remove(L, 2); // argument is processed, remove it
+        if (wait_timeout.count() < 0.0)
+        {
+            return luaL_error(L, "cancel timeout cannot be < 0");
+        }
+    }
+    // we wake by default in "hard" mode (remember that hook is hard too), but this can be turned off if desired
+    bool wake_lane{ op != CancelOp::Soft };
+    if (lua_gettop(L) >= 2)
+    {
+        if (!lua_isboolean(L, 2))
+        {
+            return luaL_error(L, "wake_lindas parameter is not a boolean");
+        }
+        wake_lane = lua_toboolean(L, 2);
+        lua_remove(L, 2); // argument is processed, remove it
+    }
+    STACK_CHECK_START_REL(L, 0);
+    switch (thread_cancel(lane, op, hook_count, wait_timeout, wake_lane))
+    {
+        default: // should never happen unless we added a case and forgot to handle it
+        ASSERT_L(false);
+        break;
+
+        case CancelResult::Timeout:
+        lua_pushboolean(L, 0);                // false
+        lua_pushstring(L, "timeout");         // false "timeout"
+        break;
+
+        case CancelResult::Cancelled:
+        lua_pushboolean(L, 1);                // true
+        push_thread_status(L, lane);          // true status
+        break;
+    }
+    STACK_CHECK(L, 2);
+    return 2;
+}
diff --git a/src/cancel.h b/src/cancel.h
index b25d9f9..060edb3 100644
--- a/src/cancel.h
+++ b/src/cancel.h
@@ -1,63 +1,68 @@
-#if !defined( __LANES_CANCEL_H__)
-#define __LANES_CANCEL_H__ 1
+#pragma once
 
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
 #include "lua.h"
 #include "lualib.h"
 #include "lauxlib.h"
+#ifdef __cplusplus
+}
+#endif // __cplusplus
 
 #include "uniquekey.h"
 #include "macros_and_utils.h"
 
+#include <chrono>
+
 // ################################################################################################
 
-typedef struct s_Lane Lane; // forward
+class Lane; // forward
 
 /*
  * Lane cancellation request modes
  */
-enum e_cancel_request
+enum class CancelRequest
 {
-    CANCEL_NONE, // no pending cancel request
-    CANCEL_SOFT, // user wants the lane to cancel itself manually on cancel_test()
-    CANCEL_HARD  // user wants the lane to be interrupted (meaning code won't return from those functions) from inside linda:send/receive calls
+    None, // no pending cancel request
+    Soft, // user wants the lane to cancel itself manually on cancel_test()
+    Hard  // user wants the lane to be interrupted (meaning code won't return from those functions) from inside linda:send/receive calls
 };
 
-typedef enum
+enum class CancelResult
 {
-    CR_Timeout,
-    CR_Cancelled,
-    CR_Killed
-} cancel_result;
+    Timeout,
+    Cancelled
+};
 
-typedef enum
+enum class CancelOp
 {
-    CO_Invalid = -2,
-    CO_Hard = -1,
-    CO_Soft = 0,
-    CO_Count = LUA_MASKCOUNT,
-    CO_Line = LUA_MASKLINE,
-    CO_Call = LUA_MASKCALL,
-    CO_Ret = LUA_MASKRET,
-} CancelOp;
+    Invalid = -2,
+    Hard = -1,
+    Soft = 0,
+    MaskCall = LUA_MASKCALL,
+    MaskRet = LUA_MASKRET,
+    MaskLine = LUA_MASKLINE,
+    MaskCount = LUA_MASKCOUNT,
+};
 
 // crc64/we of string "CANCEL_ERROR" generated at http://www.nitrxgen.net/hashgen/
-static DECLARE_CONST_UNIQUE_KEY(CANCEL_ERROR, 0xe97d41626cc97577); // 'cancel_error' sentinel
+static constexpr UniqueKey CANCEL_ERROR{ 0xe97d41626cc97577ull }; // 'raise_cancel_error' sentinel
 
-cancel_result thread_cancel( lua_State* L, Lane* s, CancelOp op_, double secs_, bool_t force_, double waitkill_timeout_);
+[[nodiscard]] CancelOp which_cancel_op(char const* op_string_);
+[[nodiscard]] CancelResult thread_cancel(Lane* lane_, CancelOp op_, int hook_count_, lua_Duration secs_, bool wake_lindas_);
 
-static inline int cancel_error( lua_State* L)
+[[noreturn]] static inline void raise_cancel_error(lua_State* L)
 {
-    STACK_GROW( L, 1);
-    push_unique_key( L, CANCEL_ERROR); // special error value
-    return lua_error( L); // doesn't return
+    STACK_GROW(L, 1);
+    CANCEL_ERROR.pushKey(L); // special error value
+    raise_lua_error(L); // doesn't return
 }
 
 // ################################################################################################
 // ################################################################################################
 
-LUAG_FUNC( cancel_test);
-LUAG_FUNC( thread_cancel);
+LUAG_FUNC(cancel_test);
+LUAG_FUNC(thread_cancel);
 
 // ################################################################################################
-
-#endif // __LANES_CANCEL_H__
diff --git a/src/compat.c b/src/compat.cpp
index bc39d4c..73d0f6b 100644
--- a/src/compat.c
+++ b/src/compat.cpp
@@ -14,7 +14,8 @@
 #if LUA_VERSION_NUM == 501
 // ################################################################################################
 // ################################################################################################
-static int luaL_getsubtable (lua_State *L, int idx, const char *fname)
+
+static int luaL_getsubtable(lua_State* L, int idx, const char* fname)
 {
     lua_getfield(L, idx, fname);
     if (lua_istable(L, -1))
@@ -32,7 +33,7 @@ static int luaL_getsubtable (lua_State *L, int idx, const char *fname)
 
 // ################################################################################################
 
-void luaL_requiref (lua_State *L, const char *modname, lua_CFunction openf, int glb)
+void luaL_requiref(lua_State *L, const char *modname, lua_CFunction openf, int glb)
 {
     lua_pushcfunction(L, openf);
     lua_pushstring(L, modname);  /* argument to open function */
@@ -58,21 +59,21 @@ void luaL_requiref (lua_State *L, const char *modname, lua_CFunction openf, int
 void* lua_newuserdatauv( lua_State* L, size_t sz, int nuvalue)
 {
     ASSERT_L( nuvalue <= 1);
-    return lua_newuserdata( L, sz);
+    return lua_newuserdata(L, sz);
 }
 
 // ################################################################################################
 
 // push on stack uservalue #n of full userdata at idx
-int lua_getiuservalue( lua_State* L, int idx, int n)
+int lua_getiuservalue(lua_State* L, int idx, int n)
 {
     // full userdata can have only 1 uservalue before 5.4
     if( n > 1)
     {
-        lua_pushnil( L);
+        lua_pushnil(L);
         return LUA_TNONE;
     }
-    lua_getuservalue( L, idx);
+    lua_getuservalue(L, idx);
 
 #if LUA_VERSION_NUM == 501
     /* default environment is not a nil (see lua_getfenv) */
@@ -80,33 +81,33 @@ int lua_getiuservalue( lua_State* L, int idx, int n)
     if (lua_rawequal(L, -2, -1) || lua_rawequal(L, -2, LUA_GLOBALSINDEX))
     {
         lua_pop(L, 2);
-        lua_pushnil( L);
+        lua_pushnil(L);
 
         return LUA_TNONE;
     }
     lua_pop(L, 1);      /* remove package */
 #endif
 
-    return lua_type( L, -1);
+    return lua_type(L, -1);
 }
 
 // ################################################################################################
 
 // Pops a value from the stack and sets it as the new n-th user value associated to the full userdata at the given index.
 // Returns 0 if the userdata does not have that value.
-int lua_setiuservalue( lua_State* L, int idx, int n)
+int lua_setiuservalue(lua_State* L, int idx, int n)
 {
     if( n > 1
 #if LUA_VERSION_NUM == 501
-        || lua_type( L, -1) != LUA_TTABLE
+        || lua_type(L, -1) != LUA_TTABLE
 #endif
         )
     {
-        lua_pop( L, 1);
+        lua_pop(L, 1);
         return 0;
     }
 
-    (void) lua_setuservalue( L, idx);
+    lua_setuservalue(L, idx);
     return 1; // I guess anything non-0 is ok
 }
 
diff --git a/src/compat.h b/src/compat.h
index fbcbee1..8d10e78 100644
--- a/src/compat.h
+++ b/src/compat.h
@@ -1,9 +1,14 @@
-#if !defined( __COMPAT_H__)
-#define __COMPAT_H__ 1
+#pragma once
 
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
 #include "lua.h"
 #include "lualib.h"
 #include "lauxlib.h"
+#ifdef __cplusplus
+}
+#endif // __cplusplus
 
 // try to detect if we are building against LuaJIT or MoonJIT
 #if defined(LUA_JITLIBNAME)
@@ -31,7 +36,7 @@
 #define lua_setuservalue lua_setfenv
 #define lua_getuservalue lua_getfenv
 #define lua_rawlen lua_objlen
-#define luaG_registerlibfuncs( L, _funcs) luaL_register( L, NULL, _funcs)
+#define luaG_registerlibfuncs(L, _funcs) luaL_register(L, nullptr, _funcs)
 #define LUA_OK 0
 #define LUA_ERRGCMM 666 // doesn't exist in Lua 5.1, we don't care about the actual value
 void luaL_requiref (lua_State* L, const char* modname, lua_CFunction openf, int glb); // implementation copied from Lua 5.2 sources
@@ -94,4 +99,29 @@ int lua_setiuservalue( lua_State* L, int idx, int n);
 
 #endif // LUA_VERSION_NUM == 504
 
-#endif // __COMPAT_H__
+// #################################################################################################
+
+// a wrapper over lua types to see them easier in a debugger
+enum class LuaType
+{
+    NONE = LUA_TNONE,
+    NIL = LUA_TNIL,
+    BOOLEAN = LUA_TBOOLEAN,
+    LIGHTUSERDATA = LUA_TLIGHTUSERDATA,
+    NUMBER = LUA_TNUMBER,
+    STRING = LUA_TSTRING,
+    TABLE = LUA_TTABLE,
+    FUNCTION = LUA_TFUNCTION,
+    USERDATA = LUA_TUSERDATA,
+    THREAD = LUA_TTHREAD,
+    CDATA = 10 // LuaJIT CDATA
+};
+
+inline LuaType lua_type_as_enum(lua_State* L, int idx_)
+{
+    return static_cast<LuaType>(lua_type(L, idx_));
+}
+inline char const* lua_typename(lua_State* L, LuaType t_)
+{
+    return lua_typename(L, static_cast<int>(t_));
+}
diff --git a/src/deep.c b/src/deep.cpp
index a1f078a..d0b8123 100644
--- a/src/deep.c
+++ b/src/deep.cpp
@@ -1,5 +1,5 @@
 /*
- * DEEP.C                         Copyright (c) 2017, Benoit Germain
+ * DEEP.CPP                         Copyright (c) 2024, Benoit Germain
  *
  * Deep userdata support, separate in its own source file to help integration
  * without enforcing a Lanes dependency
@@ -9,7 +9,7 @@
 ===============================================================================
 
 Copyright (C) 2002-10 Asko Kauppi <akauppi@gmail.com>
-              2011-17 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
@@ -32,20 +32,15 @@ THE SOFTWARE.
 ===============================================================================
 */
 
-#include <stdio.h>
-#include <assert.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdlib.h>
-#if !defined(__APPLE__)
-#include <malloc.h>
-#endif
+#include "deep.h"
 
 #include "compat.h"
-#include "deep.h"
 #include "tools.h"
-#include "universe.h"
 #include "uniquekey.h"
+#include "universe.h"
+
+#include <bit>
+#include <cassert>
 
 /*-- Metatable copying --*/
 
@@ -59,61 +54,65 @@ THE SOFTWARE.
 *   idfunc      ->  metatable
 */
 // crc64/we of string "DEEP_LOOKUP_KEY" generated at http://www.nitrxgen.net/hashgen/
-static DECLARE_CONST_UNIQUE_KEY( DEEP_LOOKUP_KEY, 0x9fb9b4f3f633d83d);
+static constexpr UniqueKey DEEP_LOOKUP_KEY{ 0x9fb9b4f3f633d83dull };
 
 /*
  * The deep proxy cache is a weak valued table listing all deep UD proxies indexed by the deep UD that they are proxying
  * crc64/we of string "DEEP_PROXY_CACHE_KEY" generated at http://www.nitrxgen.net/hashgen/
 */
-static DECLARE_CONST_UNIQUE_KEY( DEEP_PROXY_CACHE_KEY, 0x05773d6fc26be106);
+static constexpr UniqueKey DEEP_PROXY_CACHE_KEY{ 0x05773d6fc26be106ull };
 
 /*
 * Sets up [-1]<->[-2] two-way lookups, and ensures the lookup table exists.
 * Pops the both values off the stack.
 */
-static void set_deep_lookup( lua_State* L)
+static void set_deep_lookup(lua_State* L)
 {
     STACK_GROW( L, 3);
-    STACK_CHECK( L, 2);                                      // a b
+    STACK_CHECK_START_REL(L, 2);                             // a b
     push_registry_subtable( L, DEEP_LOOKUP_KEY);             // a b {}
-    STACK_MID( L, 3);
+    STACK_CHECK( L, 3);
     lua_insert( L, -3);                                      // {} a b
     lua_pushvalue( L, -1);                                   // {} a b b
     lua_pushvalue( L,-3);                                    // {} a b b a
     lua_rawset( L, -5);                                      // {} a b
     lua_rawset( L, -3);                                      // {}
     lua_pop( L, 1);                                          //
-    STACK_END( L, 0);
+    STACK_CHECK( L, 0);
 }
 
+// ################################################################################################
+
 /*
 * Pops the key (metatable or idfunc) off the stack, and replaces with the
 * deep lookup value (idfunc/metatable/nil).
 */
-static void get_deep_lookup( lua_State* L)
+static void get_deep_lookup(lua_State* L)
 {
     STACK_GROW( L, 1);
-    STACK_CHECK( L, 1);                                      // a
-    REGISTRY_GET( L, DEEP_LOOKUP_KEY);                       // a {}
+    STACK_CHECK_START_REL(L, 1);                             // a
+    DEEP_LOOKUP_KEY.pushValue(L);                            // a {}
     if( !lua_isnil( L, -1))
     {
-        lua_insert( L, -2);                                    // {} a
-        lua_rawget( L, -2);                                    // {} b
+        lua_insert( L, -2);                                  // {} a
+        lua_rawget( L, -2);                                  // {} b
     }
     lua_remove( L, -2);                                      // a|b
-    STACK_END( L, 1);
+    STACK_CHECK( L, 1);
 }
 
+// ################################################################################################
+
 /*
 * Return the registered ID function for 'index' (deep userdata proxy),
-* or NULL if 'index' is not a deep userdata proxy.
+* or nullptr if 'index' is not a deep userdata proxy.
 */
-static inline luaG_IdFunction get_idfunc( lua_State* L, int index, LookupMode mode_)
+[[nodiscard]] static inline luaG_IdFunction get_idfunc(lua_State* L, int index, LookupMode mode_)
 {
     // when looking inside a keeper, we are 100% sure the object is a deep userdata
-    if( mode_ == eLM_FromKeeper)
+    if (mode_ == LookupMode::FromKeeper)
     {
-        DeepPrelude** proxy = (DeepPrelude**) lua_touserdata( L, index);
+        DeepPrelude** const proxy{ lua_tofulluserdata<DeepPrelude*>(L, index) };
         // we can (and must) cast and fetch the internally stored idfunc
         return (*proxy)->idfunc;
     }
@@ -122,34 +121,38 @@ static inline luaG_IdFunction get_idfunc( lua_State* L, int index, LookupMode mo
         // essentially we are making sure that the metatable of the object we want to copy is stored in our metatable/idfunc database
         // it is the only way to ensure that the userdata is indeed a deep userdata!
         // of course, we could just trust the caller, but we won't
-        luaG_IdFunction ret;
         STACK_GROW( L, 1);
-        STACK_CHECK( L, 0);
+        STACK_CHECK_START_REL(L, 0);
 
         if( !lua_getmetatable( L, index))       // deep ... metatable?
         {
-            return NULL;    // no metatable: can't be a deep userdata object!
+            return nullptr; // no metatable: can't be a deep userdata object!
         }
 
         // replace metatable with the idfunc pointer, if it is actually a deep userdata
         get_deep_lookup( L);                    // deep ... idfunc|nil
 
-        ret = (luaG_IdFunction) lua_touserdata( L, -1); // NULL if not a userdata
+        luaG_IdFunction const ret{ *lua_tolightuserdata<luaG_IdFunction>(L, -1) }; // nullptr if not a userdata
         lua_pop( L, 1);
-        STACK_END( L, 0);
+        STACK_CHECK( L, 0);
         return ret;
     }
 }
 
+// ################################################################################################
 
-void free_deep_prelude( lua_State* L, DeepPrelude* prelude_)
+void free_deep_prelude(lua_State* L, DeepPrelude* prelude_)
 {
+    ASSERT_L(prelude_->idfunc);
+    STACK_CHECK_START_REL(L, 0);
     // Call 'idfunc( "delete", deep_ptr )' to make deep cleanup
     lua_pushlightuserdata( L, prelude_);
-    ASSERT_L( prelude_->idfunc);
-    prelude_->idfunc( L, eDO_delete);
+    prelude_->idfunc( L, DeepOp::Delete);
+    lua_pop(L, 1);
+    STACK_CHECK(L, 0);
 }
 
+// ################################################################################################
 
 /*
  * void= mt.__gc( proxy_ud )
@@ -157,23 +160,19 @@ void free_deep_prelude( lua_State* L, DeepPrelude* prelude_)
  * End of life for a proxy object; reduce the deep reference count and clean it up if reaches 0.
  *
  */
-static int deep_userdata_gc( lua_State* L)
+[[nodiscard]] static int deep_userdata_gc(lua_State* L)
 {
-    DeepPrelude** proxy = (DeepPrelude**) lua_touserdata( L, 1);
+    DeepPrelude** const proxy{ lua_tofulluserdata<DeepPrelude*>(L, 1) };
     DeepPrelude* p = *proxy;
-    Universe* U = universe_get( L);
-    int v;
 
     // can work without a universe if creating a deep userdata from some external C module when Lanes isn't loaded
     // in that case, we are not multithreaded and locking isn't necessary anyway
-    if( U) MUTEX_LOCK( &U->deep_lock);
-    v = -- (p->refcount);
-    if (U) MUTEX_UNLOCK( &U->deep_lock);
+    bool const isLastRef{ p->m_refcount.fetch_sub(1, std::memory_order_relaxed) == 1 };
 
-    if( v == 0)
+    if (isLastRef)
     {
         // retrieve wrapped __gc
-        lua_pushvalue( L, lua_upvalueindex( 1));                            // self __gc?
+        lua_pushvalue( L, lua_upvalueindex( 1));                              // self __gc?
         if( !lua_isnil( L, -1))
         {
             lua_insert( L, -2);                                               // __gc self
@@ -186,164 +185,157 @@ static int deep_userdata_gc( lua_State* L)
         // top was set to 0, then userdata was pushed. "delete" might want to pop the userdata (we don't care), but should not push anything!
         if ( lua_gettop( L) > 1)
         {
-            luaL_error( L, "Bad idfunc(eDO_delete): should not push anything");
+            return luaL_error( L, "Bad idfunc(DeepOp::Delete): should not push anything");
         }
     }
-    *proxy = NULL;  // make sure we don't use it any more, just in case
+    *proxy = nullptr; // make sure we don't use it any more, just in case
     return 0;
 }
 
+// ################################################################################################
 
 /*
  * Push a proxy userdata on the stack.
- * returns NULL if ok, else some error string related to bad idfunc behavior or module require problem
- * (error cannot happen with mode_ == eLM_ToKeeper)
+ * returns nullptr if ok, else some error string related to bad idfunc behavior or module require problem
+ * (error cannot happen with mode_ == LookupMode::ToKeeper)
  *
  * Initializes necessary structures if it's the first time 'idfunc' is being
  * used in this Lua state (metatable, registring it). Otherwise, increments the
  * reference count.
  */
-char const* push_deep_proxy( Universe* U, lua_State* L, DeepPrelude* prelude, int nuv_, LookupMode mode_)
+char const* push_deep_proxy(Dest L, DeepPrelude* prelude, int nuv_, LookupMode mode_)
 {
-    DeepPrelude** proxy;
-
     // Check if a proxy already exists
     push_registry_subtable_mode( L, DEEP_PROXY_CACHE_KEY, "v");                                        // DPC
     lua_pushlightuserdata( L, prelude);                                                                // DPC deep
     lua_rawget( L, -2);                                                                                // DPC proxy
     if ( !lua_isnil( L, -1))
     {
-        lua_remove( L, -2);                                                                              // proxy
-        return NULL;
+        lua_remove( L, -2);                                                                            // proxy
+        return nullptr;
     }
     else
     {
-        lua_pop( L, 1);                                                                                  // DPC
+        lua_pop( L, 1);                                                                                // DPC
     }
 
-    // can work without a universe if creating a deep userdata from some external C module when Lanes isn't loaded
-    // in that case, we are not multithreaded and locking isn't necessary anyway
-    if( U) MUTEX_LOCK( &U->deep_lock);
-    ++ (prelude->refcount);  // one more proxy pointing to this deep data
-    if( U) MUTEX_UNLOCK( &U->deep_lock);
-
     STACK_GROW( L, 7);
-    STACK_CHECK( L, 0);
+    STACK_CHECK_START_REL(L, 0);
 
     // a new full userdata, fitted with the specified number of uservalue slots (always 1 for Lua < 5.4)
-    proxy = lua_newuserdatauv( L, sizeof(DeepPrelude*), nuv_);                                         // DPC proxy
+    DeepPrelude** proxy = (DeepPrelude**) lua_newuserdatauv(L, sizeof(DeepPrelude*), nuv_);            // DPC proxy
     ASSERT_L( proxy);
     *proxy = prelude;
+    prelude->m_refcount.fetch_add(1, std::memory_order_relaxed); // one more proxy pointing to this deep data
 
     // Get/create metatable for 'idfunc' (in this state)
-    lua_pushlightuserdata( L, (void*)(uintptr_t)(prelude->idfunc));                                    // DPC proxy idfunc
+    lua_pushlightuserdata( L, std::bit_cast<void*>(prelude->idfunc));                                  // DPC proxy idfunc
     get_deep_lookup( L);                                                                               // DPC proxy metatable?
 
     if( lua_isnil( L, -1)) // // No metatable yet.
     {
         char const* modname;
-        int oldtop = lua_gettop( L);                                                                     // DPC proxy nil
-        lua_pop( L, 1);                                                                                  // DPC proxy
+        int oldtop = lua_gettop( L);                                                                   // DPC proxy nil
+        lua_pop( L, 1);                                                                                // DPC proxy
         // 1 - make one and register it
-        if( mode_ != eLM_ToKeeper)
+        if (mode_ != LookupMode::ToKeeper)
         {
-            (void) prelude->idfunc( L, eDO_metatable);                                                     // DPC proxy metatable
+            (void) prelude->idfunc( L, DeepOp::Metatable);                                                 // DPC proxy metatable
             if( lua_gettop( L) - oldtop != 0 || !lua_istable( L, -1))
             {
-                lua_settop( L, oldtop);                                                                      // DPC proxy X
-                lua_pop( L, 3);                                                                              //
+                lua_settop( L, oldtop);                                                                // DPC proxy X
+                lua_pop( L, 3);                                                                        //
                 return "Bad idfunc(eOP_metatable): unexpected pushed value";
             }
             // if the metatable contains a __gc, we will call it from our own
-            lua_getfield( L, -1, "__gc");                                                                  // DPC proxy metatable __gc
+            lua_getfield( L, -1, "__gc");                                                              // DPC proxy metatable __gc
         }
         else
         {
             // keepers need a minimal metatable that only contains our own __gc
-            lua_newtable( L);                                                                              // DPC proxy metatable
-            lua_pushnil( L);                                                                               // DPC proxy metatable nil
+            lua_newtable( L);                                                                          // DPC proxy metatable
+            lua_pushnil( L);                                                                           // DPC proxy metatable nil
         }
         if( lua_isnil( L, -1))
         {
             // Add our own '__gc' method
-            lua_pop( L, 1);                                                                                // DPC proxy metatable
-            lua_pushcfunction( L, deep_userdata_gc);                                                       // DPC proxy metatable deep_userdata_gc
+            lua_pop( L, 1);                                                                            // DPC proxy metatable
+            lua_pushcfunction( L, deep_userdata_gc);                                                   // DPC proxy metatable deep_userdata_gc
         }
         else
         {
             // Add our own '__gc' method wrapping the original
-            lua_pushcclosure( L, deep_userdata_gc, 1);                                                     // DPC proxy metatable deep_userdata_gc
+            lua_pushcclosure( L, deep_userdata_gc, 1);                                                 // DPC proxy metatable deep_userdata_gc
         }
-        lua_setfield( L, -2, "__gc");                                                                    // DPC proxy metatable
+        lua_setfield( L, -2, "__gc");                                                                  // DPC proxy metatable
 
         // Memorize for later rounds
-        lua_pushvalue( L, -1);                                                                           // DPC proxy metatable metatable
-        lua_pushlightuserdata( L, (void*)(uintptr_t)(prelude->idfunc));                                  // DPC proxy metatable metatable idfunc
-        set_deep_lookup( L);                                                                             // DPC proxy metatable
+        lua_pushvalue( L, -1);                                                                         // DPC proxy metatable metatable
+        lua_pushlightuserdata( L, std::bit_cast<void*>(prelude->idfunc));                              // DPC proxy metatable metatable idfunc
+        set_deep_lookup( L);                                                                           // DPC proxy metatable
 
         // 2 - cause the target state to require the module that exported the idfunc
         // this is needed because we must make sure the shared library is still loaded as long as we hold a pointer on the idfunc
         {
             int oldtop_module = lua_gettop( L);
-            modname = (char const*) prelude->idfunc( L, eDO_module);                                       // DPC proxy metatable
+            modname = (char const*) prelude->idfunc( L, DeepOp::Module);                               // DPC proxy metatable
             // make sure the function pushed nothing on the stack!
             if( lua_gettop( L) - oldtop_module != 0)
             {
-                lua_pop( L, 3);                                                                              //
+                lua_pop( L, 3);                                                                        //
                 return "Bad idfunc(eOP_module): should not push anything";
             }
         }
-        if( NULL != modname) // we actually got a module name
+        if (nullptr != modname) // we actually got a module name
         {
             // L.registry._LOADED exists without having registered the 'package' library.
-            lua_getglobal( L, "require");                                                                  // DPC proxy metatable require()
+            lua_getglobal( L, "require");                                                              // DPC proxy metatable require()
             // check that the module is already loaded (or being loaded, we are happy either way)
             if( lua_isfunction( L, -1))
             {
-                lua_pushstring( L, modname);                                                                 // DPC proxy metatable require() "module"
-                lua_getfield( L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);                                       // DPC proxy metatable require() "module" _R._LOADED
+                lua_pushstring( L, modname);                                                           // DPC proxy metatable require() "module"
+                lua_getfield( L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);                                 // DPC proxy metatable require() "module" _R._LOADED
                 if( lua_istable( L, -1))
                 {
-                    bool_t alreadyloaded;
-                    lua_pushvalue( L, -2);                                                                     // DPC proxy metatable require() "module" _R._LOADED "module"
-                    lua_rawget( L, -2);                                                                        // DPC proxy metatable require() "module" _R._LOADED module
-                    alreadyloaded = lua_toboolean( L, -1);
+                    lua_pushvalue( L, -2);                                                             // DPC proxy metatable require() "module" _R._LOADED "module"
+                    lua_rawget( L, -2);                                                                // DPC proxy metatable require() "module" _R._LOADED module
+                    int const alreadyloaded = lua_toboolean( L, -1);
                     if( !alreadyloaded) // not loaded
                     {
                         int require_result;
-                        lua_pop( L, 2);                                                                          // DPC proxy metatable require() "module"
+                        lua_pop( L, 2);                                                                // DPC proxy metatable require() "module"
                         // require "modname"
-                        require_result = lua_pcall( L, 1, 0, 0);                                                 // DPC proxy metatable error?
+                        require_result = lua_pcall( L, 1, 0, 0);                                       // DPC proxy metatable error?
                         if( require_result != LUA_OK)
                         {
                             // failed, return the error message
                             lua_pushfstring( L, "error while requiring '%s' identified by idfunc(eOP_module): ", modname);
-                            lua_insert( L, -2);                                                                    // DPC proxy metatable prefix error
-                            lua_concat( L, 2);                                                                     // DPC proxy metatable error
+                            lua_insert( L, -2);                                                        // DPC proxy metatable prefix error
+                            lua_concat( L, 2);                                                         // DPC proxy metatable error
                             return lua_tostring( L, -1);
                         }
                     }
                     else // already loaded, we are happy
                     {
-                        lua_pop( L, 4);                                                                          // DPC proxy metatable
+                        lua_pop( L, 4);                                                                // DPC proxy metatable
                     }
                 }
                 else // no L.registry._LOADED; can this ever happen?
                 {
-                    lua_pop( L, 6);                                                                            //
+                    lua_pop( L, 6);                                                                    //
                     return "unexpected error while requiring a module identified by idfunc(eOP_module)";
                 }
             }
             else // a module name, but no require() function :-(
             {
-                lua_pop( L, 4);                                                                              //
+                lua_pop( L, 4);                                                                        //
                 return "lanes receiving deep userdata should register the 'package' library";
             }
         }
     }
-    STACK_MID( L, 2);                                                                                  // DPC proxy metatable
-    ASSERT_L( lua_isuserdata( L, -2));
-    ASSERT_L( lua_istable( L, -1));
+    STACK_CHECK(L, 2);                                                                                 // DPC proxy metatable
+    ASSERT_L(lua_type(L, -2) == LUA_TUSERDATA);
+    ASSERT_L(lua_istable( L, -1));
     lua_setmetatable( L, -2);                                                                          // DPC proxy
 
     // If we're here, we obviously had to create a new proxy, so cache it.
@@ -351,11 +343,13 @@ char const* push_deep_proxy( Universe* U, lua_State* L, DeepPrelude* prelude, in
     lua_pushvalue( L, -2);                                                                             // DPC proxy deep proxy
     lua_rawset( L, -4);                                                                                // DPC proxy
     lua_remove( L, -2);                                                                                // proxy
-    ASSERT_L( lua_isuserdata( L, -1));
-    STACK_END( L, 0);
-    return NULL;
+    ASSERT_L(lua_type(L, -1) == LUA_TUSERDATA);
+    STACK_CHECK(L, 0);
+    return nullptr;
 }
 
+// ################################################################################################
+
 /*
 * Create a deep userdata
 *
@@ -366,9 +360,9 @@ char const* push_deep_proxy( Universe* U, lua_State* L, DeepPrelude* prelude, in
 *
 * 'idfunc' must fulfill the following features:
 *
-*   lightuserdata = idfunc( eDO_new [, ...] )      -- creates a new deep data instance
-*   void = idfunc( eDO_delete, lightuserdata )     -- releases a deep data instance
-*   tbl = idfunc( eDO_metatable )                  -- gives metatable for userdata proxies
+*   lightuserdata = idfunc( DeepOp::New [, ...] )      -- creates a new deep data instance
+*   void = idfunc( DeepOp::Delete, lightuserdata )     -- releases a deep data instance
+*   tbl = idfunc( DeepOp::Metatable )                  -- gives metatable for userdata proxies
 *
 * Reference counting and true userdata proxying are taken care of for the
 * actual data type.
@@ -378,46 +372,46 @@ char const* push_deep_proxy( Universe* U, lua_State* L, DeepPrelude* prelude, in
 *
 * Returns:  'proxy' userdata for accessing the deep data via 'luaG_todeep()'
 */
-int luaG_newdeepuserdata( lua_State* L, luaG_IdFunction idfunc, int nuv_)
+int luaG_newdeepuserdata(Dest L, luaG_IdFunction idfunc, int nuv_)
 {
-    char const* errmsg;
-
     STACK_GROW( L, 1);
-    STACK_CHECK( L, 0);
+    STACK_CHECK_START_REL(L, 0);
+    int const oldtop{ lua_gettop(L) };
+    DeepPrelude* const prelude{ static_cast<DeepPrelude*>(idfunc(L, DeepOp::New)) };
+    if (prelude == nullptr)
     {
-        int const oldtop = lua_gettop( L);
-        DeepPrelude* prelude = idfunc( L, eDO_new);
-        if( prelude == NULL)
-        {
-            return luaL_error( L, "idfunc(eDO_new) failed to create deep userdata (out of memory)");
-        }
-        if( prelude->magic.value != DEEP_VERSION.value)
-        {
-            // just in case, don't leak the newly allocated deep userdata object
-            lua_pushlightuserdata( L, prelude);
-            idfunc( L, eDO_delete);
-            return luaL_error( L, "Bad idfunc(eDO_new): DEEP_VERSION is incorrect, rebuild your implementation with the latest deep implementation");
-        }
-        prelude->refcount = 0; // 'push_deep_proxy' will lift it to 1
-        prelude->idfunc = idfunc;
+        return luaL_error( L, "idfunc(DeepOp::New) failed to create deep userdata (out of memory)");
+    }
 
-        if( lua_gettop( L) - oldtop != 0)
-        {
-            // just in case, don't leak the newly allocated deep userdata object
-            lua_pushlightuserdata( L, prelude);
-            idfunc( L, eDO_delete);
-            return luaL_error( L, "Bad idfunc(eDO_new): should not push anything on the stack");
-        }
-        errmsg = push_deep_proxy( universe_get( L), L, prelude, nuv_, eLM_LaneBody);  // proxy
-        if( errmsg != NULL)
-        {
-            return luaL_error( L, errmsg);
-        }
+    if( prelude->magic != DEEP_VERSION)
+    {
+        // just in case, don't leak the newly allocated deep userdata object
+        lua_pushlightuserdata( L, prelude);
+        idfunc( L, DeepOp::Delete);
+        return luaL_error( L, "Bad idfunc(DeepOp::New): DEEP_VERSION is incorrect, rebuild your implementation with the latest deep implementation");
+    }
+
+    ASSERT_L(prelude->m_refcount.load(std::memory_order_relaxed) == 0); // 'push_deep_proxy' will lift it to 1
+    prelude->idfunc = idfunc;
+
+    if( lua_gettop( L) - oldtop != 0)
+    {
+        // just in case, don't leak the newly allocated deep userdata object
+        lua_pushlightuserdata( L, prelude);
+        idfunc( L, DeepOp::Delete);
+        return luaL_error( L, "Bad idfunc(DeepOp::New): should not push anything on the stack");
     }
-    STACK_END( L, 1);
+
+    char const* const errmsg{ push_deep_proxy(L, prelude, nuv_, LookupMode::LaneBody) }; // proxy
+    if (errmsg != nullptr)
+    {
+        return luaL_error( L, errmsg);
+    }
+    STACK_CHECK( L, 1);
     return 1;
 }
 
+// ################################################################################################
 
 /*
 * Access deep userdata through a proxy.
@@ -425,80 +419,76 @@ int luaG_newdeepuserdata( lua_State* L, luaG_IdFunction idfunc, int nuv_)
 * Reference count is not changed, and access to the deep userdata is not
 * serialized. It is the module's responsibility to prevent conflicting usage.
 */
-void* luaG_todeep( lua_State* L, luaG_IdFunction idfunc, int index)
+DeepPrelude* luaG_todeep(lua_State* L, luaG_IdFunction idfunc, int index)
 {
-    DeepPrelude** proxy;
-
-    STACK_CHECK( L, 0);
+    STACK_CHECK_START_REL(L, 0);
     // ensure it is actually a deep userdata
-    if( get_idfunc( L, index, eLM_LaneBody) != idfunc)
+    if (get_idfunc(L, index, LookupMode::LaneBody) != idfunc)
     {
-        return NULL;    // no metatable, or wrong kind
+        return nullptr; // no metatable, or wrong kind
     }
+    STACK_CHECK(L, 0);
 
-    proxy = (DeepPrelude**) lua_touserdata( L, index);
-    STACK_END( L, 0);
-
+    DeepPrelude** const proxy{ lua_tofulluserdata<DeepPrelude*>(L, index) };
     return *proxy;
 }
 
+// ################################################################################################
 
 /*
  * Copy deep userdata between two separate Lua states (from L to L2)
  *
  * Returns:
- *   the id function of the copied value, or NULL for non-deep userdata
+ *   the id function of the copied value, or nullptr for non-deep userdata
  *   (not copied)
  */
-bool_t copydeep( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State* L, uint_t i, LookupMode mode_, char const* upName_)
+bool copydeep(Universe* U, Dest L2, int L2_cache_i, Source L, int i, LookupMode mode_, char const* upName_)
 {
-    char const* errmsg;
-    luaG_IdFunction idfunc = get_idfunc( L, i, mode_);
-    int nuv = 0;
-
-    if( idfunc == NULL)
+    luaG_IdFunction const idfunc { get_idfunc(L, i, mode_) };
+    if (idfunc == nullptr)
     {
-        return FALSE;   // not a deep userdata
+        return false;   // not a deep userdata
     }
 
-    STACK_CHECK( L, 0);
-    STACK_CHECK( L2, 0);
+    STACK_CHECK_START_REL(L, 0);
+    STACK_CHECK_START_REL(L2, 0);
 
     // extract all uservalues of the source
-    while( lua_getiuservalue( L, i, nuv + 1) != LUA_TNONE)                               // ... u [uv]* nil
+    int nuv = 0;
+    while (lua_getiuservalue(L, i, nuv + 1) != LUA_TNONE)                                // ... u [uv]* nil
     {
         ++ nuv;
     }
     // last call returned TNONE and pushed nil, that we don't need
     lua_pop( L, 1);                                                                      // ... u [uv]*
-    STACK_MID( L, nuv);
+    STACK_CHECK( L, nuv);
 
-    errmsg = push_deep_proxy( U, L2, *(DeepPrelude**) lua_touserdata( L, i), nuv, mode_);                   // u
+    char const* errmsg{ push_deep_proxy(L2, *lua_tofulluserdata<DeepPrelude*>(L, i), nuv, mode_) };         // u
 
     // transfer all uservalues of the source in the destination
     {
         int const clone_i = lua_gettop( L2);
         while( nuv)
         {
-            if(!inter_copy_one( U, L2, L2_cache_i, L,  lua_absindex( L, -1), VT_NORMAL, mode_, upName_))    // u uv
+            if (!inter_copy_one(U, L2, L2_cache_i, L, lua_absindex(L, -1), VT::NORMAL, mode_, upName_))     // u uv
             {
                 return luaL_error(L, "Cannot copy upvalue type '%s'", luaL_typename(L, -1));
             }
             lua_pop( L, 1);                                                              // ... u [uv]*
             // this pops the value from the stack
-            lua_setiuservalue( L2, clone_i, nuv);                                                           // u
+            lua_setiuservalue(L2, clone_i, nuv);                                                            // u
             -- nuv;
         }
     }
 
-    STACK_END( L2, 1);
-    STACK_END( L, 0);
+    STACK_CHECK(L2, 1);
+    STACK_CHECK(L, 0);
 
-    if( errmsg != NULL)
+    if (errmsg != nullptr)
     {
         // raise the error in the proper state (not the keeper)
-        lua_State* errL = (mode_ == eLM_FromKeeper) ? L2 : L;
-        luaL_error( errL, errmsg);
+        lua_State* const errL{ (mode_ == LookupMode::FromKeeper) ? L2 : L };
+        luaL_error(errL, errmsg); // doesn't return
     }
-    return TRUE;
+    return true;
 }
\ No newline at end of file
diff --git a/src/deep.h b/src/deep.h
index 9b00b70..7be5c5d 100644
--- a/src/deep.h
+++ b/src/deep.h
@@ -1,66 +1,61 @@
-#ifndef __LANES_DEEP_H__
-#define __LANES_DEEP_H__ 1
+#pragma once
 
 /*
  * public 'deep' API to be used by external modules if they want to implement Lanes-aware userdata
  * said modules will have to link against lanes (it is not really possible to separate the 'deep userdata' implementation from the rest of Lanes)
  */
 
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
 #include "lua.h"
-#include "platform.h"
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#include "lanesconf.h"
 #include "uniquekey.h"
 
-// forwards
-struct s_Universe;
-typedef struct s_Universe Universe;
+#include <atomic>
 
-#if !defined LANES_API // when deep is compiled standalone outside Lanes
-#if (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC)
-#define LANES_API __declspec(dllexport)
-#else
-#define LANES_API
-#endif // (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC)
-#endif // LANES_API
+// forwards
+class Universe;
 
-enum eLookupMode
+enum class LookupMode
 {
-    eLM_LaneBody, // send the lane body directly from the source to the destination lane
-    eLM_ToKeeper, // send a function from a lane to a keeper state
-    eLM_FromKeeper // send a function from a keeper state to a lane
+    LaneBody, // send the lane body directly from the source to the destination lane
+    ToKeeper, // send a function from a lane to a keeper state
+    FromKeeper // send a function from a keeper state to a lane
 };
-typedef enum eLookupMode LookupMode;
 
-enum eDeepOp
+enum class DeepOp
 {
-    eDO_new,
-    eDO_delete,
-    eDO_metatable,
-    eDO_module,
+    New,
+    Delete,
+    Metatable,
+    Module,
 };
-typedef enum eDeepOp DeepOp;
 
-typedef void* (*luaG_IdFunction)( lua_State* L, DeepOp op_);
+using luaG_IdFunction = void*(*)(lua_State* L, DeepOp op_);
 
 // ################################################################################################
 
-// fnv164 of string "DEEP_VERSION_2" generated at https://www.pelock.com/products/hash-calculator
-static DECLARE_CONST_UNIQUE_KEY( DEEP_VERSION, 0xB4B0119C10642B29);
+// xxh64 of string "DEEP_VERSION_3" generated at https://www.pelock.com/products/hash-calculator
+static constexpr UniqueKey DEEP_VERSION{ 0xB2CC0FD9C0AE9674ull };
 
-// should be used as header for full userdata
-struct s_DeepPrelude
+// should be used as header for deep userdata
+// a deep userdata is a full userdata that stores a single pointer to the actual DeepPrelude-derived object
+struct DeepPrelude
 {
-    DECLARE_UNIQUE_KEY( magic); // must be filled by the Deep userdata idfunc that allocates it on eDO_new operation
+    UniqueKey const magic{ DEEP_VERSION };
     // when stored in a keeper state, the full userdata doesn't have a metatable, so we need direct access to the idfunc
-    luaG_IdFunction idfunc;
+    luaG_IdFunction idfunc { nullptr };
     // data is destroyed when refcount is 0
-    volatile int refcount;
+    std::atomic<int> m_refcount{ 0 };
 };
-typedef struct s_DeepPrelude DeepPrelude;
-
-char const* push_deep_proxy( Universe* U, lua_State* L, DeepPrelude* prelude, int nuv_, LookupMode mode_);
-void free_deep_prelude( lua_State* L, DeepPrelude* prelude_);
 
-extern LANES_API int luaG_newdeepuserdata( lua_State* L, luaG_IdFunction idfunc, int nuv_);
-extern LANES_API void* luaG_todeep( lua_State* L, luaG_IdFunction idfunc, int index);
+[[nodiscard]] char const* push_deep_proxy(Dest L, DeepPrelude* prelude, int nuv_, LookupMode mode_);
+void free_deep_prelude(lua_State* L, DeepPrelude* prelude_);
 
-#endif // __LANES_DEEP_H__
+LANES_API [[nodiscard]] int luaG_newdeepuserdata(Dest L, luaG_IdFunction idfunc, int nuv_);
+LANES_API [[nodiscard]] DeepPrelude* luaG_todeep(lua_State* L, luaG_IdFunction idfunc, int index);
diff --git a/src/keeper.c b/src/keeper.c
deleted file mode 100644
index a1505b7..0000000
--- a/src/keeper.c
+++ /dev/null
@@ -1,862 +0,0 @@
-/*
- --
- -- KEEPER.C
- --
- -- Keeper state logic
- --
- -- This code is read in for each "keeper state", which are the hidden, inter-
- -- mediate data stores used by Lanes inter-state communication objects.
- --
- -- Author: Benoit Germain <bnt.germain@gmail.com>
- --
- -- C implementation replacement of the original keeper.lua
- --
- --[[
- ===============================================================================
-
- Copyright (C) 2011-2013 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
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be included in
- all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- THE SOFTWARE.
-
- ===============================================================================
- ]]--
- */
-
-#include <string.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <ctype.h>
-#include <assert.h>
-
-#include "keeper.h"
-#include "compat.h"
-#include "tools.h"
-#include "state.h"
-#include "universe.h"
-#include "uniquekey.h"
-
-//###################################################################################
-// Keeper implementation
-//###################################################################################
-
-#ifndef __min
-#define __min( a, b) (((a) < (b)) ? (a) : (b))
-#endif // __min
-
-typedef struct
-{
-    lua_Integer first;
-    lua_Integer count;
-    lua_Integer limit;
-} keeper_fifo;
-
-static int const CONTENTS_TABLE = 1;
-
-// replaces the fifo ud by its uservalue on the stack
-static keeper_fifo* prepare_fifo_access( lua_State* L, int idx_)
-{
-    keeper_fifo* fifo = (keeper_fifo*) lua_touserdata( L, idx_);
-    if( fifo != NULL)
-    {
-        idx_ = lua_absindex( L, idx_);
-        STACK_GROW( L, 1);
-        // we can replace the fifo userdata in the stack without fear of it being GCed, there are other references around
-        lua_getiuservalue( L, idx_, CONTENTS_TABLE);
-        lua_replace( L, idx_);
-    }
-    return fifo;
-}
-
-// in: nothing
-// out: { first = 1, count = 0, limit = -1}
-static void fifo_new( lua_State* L)
-{
-    keeper_fifo* fifo;
-    STACK_GROW( L, 2);
-    // a fifo full userdata has one uservalue, the table that holds the actual fifo contents
-    fifo = (keeper_fifo*)lua_newuserdatauv( L, sizeof( keeper_fifo), 1);
-    fifo->first = 1;
-    fifo->count = 0;
-    fifo->limit = -1;
-    lua_newtable( L);
-    lua_setiuservalue( L, -2, CONTENTS_TABLE);
-}
-
-// in: expect fifo ... on top of the stack
-// out: nothing, removes all pushed values from the stack
-static void fifo_push( lua_State* L, keeper_fifo* fifo_, lua_Integer count_)
-{
-    int const idx = lua_gettop( L) - (int) count_;
-    lua_Integer start = fifo_->first + fifo_->count - 1;
-    lua_Integer i;
-    // pop all additional arguments, storing them in the fifo
-    for( i = count_; i >= 1; -- i)
-    {
-        // store in the fifo the value at the top of the stack at the specified index, popping it from the stack
-        lua_rawseti( L, idx, (int)(start + i));
-    }
-    fifo_->count += count_;
-}
-
-// in: fifo
-// out: ...|nothing
-// expects exactly 1 value on the stack!
-// currently only called with a count of 1, but this may change in the future
-// function assumes that there is enough data in the fifo to satisfy the request
-static void fifo_peek( lua_State* L, keeper_fifo* fifo_, lua_Integer count_)
-{
-    lua_Integer i;
-    STACK_GROW( L, (int) count_);
-    for( i = 0; i < count_; ++ i)
-    {
-        lua_rawgeti( L, 1, (int)( fifo_->first + i));
-    }
-}
-
-// in: fifo
-// out: remove the fifo from the stack, push as many items as required on the stack (function assumes they exist in sufficient number)
-static void fifo_pop( lua_State* L, keeper_fifo* fifo_, lua_Integer count_)
-{
-    int const fifo_idx = lua_gettop( L);     // ... fifo
-    int i;
-    // each iteration pushes a value on the stack!
-    STACK_GROW( L, (int) count_ + 2);
-    // skip first item, we will push it last
-    for( i = 1; i < count_; ++ i)
-    {
-        int const at = (int)( fifo_->first + i);
-        // push item on the stack
-        lua_rawgeti( L, fifo_idx, at);         // ... fifo val
-        // remove item from the fifo
-        lua_pushnil( L);                       // ... fifo val nil
-        lua_rawseti( L, fifo_idx, at);         // ... fifo val
-    }
-    // now process first item
-    {
-        int const at = (int)( fifo_->first);
-        lua_rawgeti( L, fifo_idx, at);         // ... fifo vals val
-        lua_pushnil( L);                       // ... fifo vals val nil
-        lua_rawseti( L, fifo_idx, at);         // ... fifo vals val
-        lua_replace( L, fifo_idx);             // ... vals
-    }
-    {
-        // avoid ever-growing indexes by resetting each time we detect the fifo is empty
-        lua_Integer const new_count = fifo_->count - count_;
-        fifo_->first = (new_count == 0) ? 1 : (fifo_->first + count_);
-        fifo_->count = new_count;
-    }
-}
-
-// in: linda_ud expected at *absolute* stack slot idx
-// out: fifos[ud]
-// crc64/we of string "FIFOS_KEY" generated at http://www.nitrxgen.net/hashgen/
-static DECLARE_CONST_UNIQUE_KEY( FIFOS_KEY, 0xdce50bbc351cd465);
-static void push_table( lua_State* L, int idx_)
-{
-    STACK_GROW( L, 5);
-    STACK_CHECK( L, 0);
-    idx_ = lua_absindex( L, idx_);
-    REGISTRY_GET( L, FIFOS_KEY);                 // ud fifos
-    lua_pushvalue( L, idx_);                     // ud fifos ud
-    lua_rawget( L, -2);                          // ud fifos fifos[ud]
-    STACK_MID( L, 2);
-    if( lua_isnil( L, -1))
-    {
-        lua_pop( L, 1);                            // ud fifos
-        // add a new fifos table for this linda
-        lua_newtable( L);                          // ud fifos fifos[ud]
-        lua_pushvalue( L, idx_);                   // ud fifos fifos[ud] ud
-        lua_pushvalue( L, -2);                     // ud fifos fifos[ud] ud fifos[ud]
-        lua_rawset( L, -4);                        // ud fifos fifos[ud]
-    }
-    lua_remove( L, -2);                          // ud fifos[ud]
-    STACK_END( L, 1);
-}
-
-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 : NULL;
-    if( KL == NULL) return 0;
-    STACK_GROW( KL, 4);
-    STACK_CHECK( KL, 0);
-    REGISTRY_GET( KL, FIFOS_KEY);                               // fifos
-    lua_pushlightuserdata( KL, ptr_);                           // fifos ud
-    lua_rawget( KL, -2);                                        // fifos storage
-    lua_remove( KL, -2);                                        // storage
-    if( !lua_istable( KL, -1))
-    {
-        lua_pop( KL, 1);                                          //
-        STACK_MID( KL, 0);
-        return 0;
-    }
-    // move data from keeper to destination state                  KEEPER                       MAIN
-    lua_pushnil( KL);                                           // storage nil
-    STACK_GROW( L, 5);
-    STACK_CHECK( L, 0);
-    lua_newtable( L);                                                                        // out
-    while( lua_next( KL, -2))                                   // storage key fifo
-    {
-        keeper_fifo* fifo = prepare_fifo_access( KL, -1);         // storage key fifo
-        lua_pushvalue( KL, -2);                                   // storage key fifo key
-        luaG_inter_move( U, KL, L, 1, eLM_FromKeeper);            // storage key fifo          // out key
-        STACK_MID( L, 2);
-        lua_newtable( L);                                                                      // out key keyout
-        luaG_inter_move( U, KL, L, 1, eLM_FromKeeper);            // storage key               // out key keyout fifo
-        lua_pushinteger( L, fifo->first);                                                      // out key keyout fifo first
-        STACK_MID( L, 5);
-        lua_setfield( L, -3, "first");                                                         // out key keyout fifo
-        lua_pushinteger( L, fifo->count);                                                      // out key keyout fifo count
-        STACK_MID( L, 5);
-        lua_setfield( L, -3, "count");                                                         // out key keyout fifo
-        lua_pushinteger( L, fifo->limit);                                                      // out key keyout fifo limit
-        STACK_MID( L, 5);
-        lua_setfield( L, -3, "limit");                                                         // out key keyout fifo
-        lua_setfield( L, -2, "fifo");                                                          // out key keyout
-        lua_rawset( L, -3);                                                                    // out
-        STACK_MID( L, 1);
-    }
-    STACK_END( L, 1);
-    lua_pop( KL, 1);                                            //
-    STACK_END( KL, 0);
-    return 1;
-}
-
-// in: linda_ud
-int keepercall_clear( lua_State* L)
-{
-    STACK_GROW( L, 3);
-    STACK_CHECK( L, 0);
-    REGISTRY_GET( L, FIFOS_KEY);                 // ud fifos
-    lua_pushvalue( L, 1);                        // ud fifos ud
-    lua_pushnil( L);                             // ud fifos ud nil
-    lua_rawset( L, -3);                          // ud fifos
-    lua_pop( L, 1);                              // ud
-    STACK_END( L, 0);
-    return 0;
-}
-
-
-// in: linda_ud, key, ...
-// out: true|false
-int keepercall_send( lua_State* L)
-{
-    keeper_fifo* fifo;
-    int n = lua_gettop( L) - 2;
-    push_table( L, 1);                           // ud key ... fifos
-    // get the fifo associated to this key in this linda, create it if it doesn't exist
-    lua_pushvalue( L, 2);                        // ud key ... fifos key
-    lua_rawget( L, -2);                          // ud key ... fifos fifo
-    if( lua_isnil( L, -1))
-    {
-        lua_pop( L, 1);                            // ud key ... fifos
-        fifo_new( L);                              // ud key ... fifos fifo
-        lua_pushvalue( L, 2);                      // ud key ... fifos fifo key
-        lua_pushvalue( L, -2);                     // ud key ... fifos fifo key fifo
-        lua_rawset( L, -4);                        // ud key ... fifos fifo
-    }
-    lua_remove( L, -2);                          // ud key ... fifo
-    fifo = (keeper_fifo*) lua_touserdata( L, -1);
-    if( fifo->limit >= 0 && fifo->count + n > fifo->limit)
-    {
-        lua_settop( L, 0);                         //
-        lua_pushboolean( L, 0);                    // false
-    }
-    else
-    {
-        fifo = prepare_fifo_access( L, -1);
-        lua_replace( L, 2);                        // ud fifo ...
-        fifo_push( L, fifo, n);                    // ud fifo
-        lua_settop( L, 0);                         //
-        lua_pushboolean( L, 1);                    // true
-    }
-    return 1;
-}
-
-// in: linda_ud, key [, key]?
-// out: (key, val) or nothing
-int keepercall_receive( lua_State* L)
-{
-    int top = lua_gettop( L);
-    int i;
-    push_table( L, 1);                           // ud keys fifos
-    lua_replace( L, 1);                          // fifos keys
-    for( i = 2; i <= top; ++ i)
-    {
-        keeper_fifo* fifo;
-        lua_pushvalue( L, i);                      // fifos keys key[i]
-        lua_rawget( L, 1);                         // fifos keys fifo
-        fifo = prepare_fifo_access( L, -1);        // fifos keys fifo
-        if( fifo != NULL && fifo->count > 0)
-        {
-            fifo_pop( L, fifo, 1);                   // fifos keys val
-            if( !lua_isnil( L, -1))
-            {
-                lua_replace( L, 1);                    // val keys
-                lua_settop( L, i);                     // val keys key[i]
-                if( i != 2)
-                {
-                    lua_replace( L, 2);                  // val key keys
-                    lua_settop( L, 2);                   // val key
-                }
-                lua_insert( L, 1);                     // key, val
-                return 2;
-            }
-        }
-        lua_settop( L, top);                       // data keys
-    }
-    // nothing to receive
-    return 0;
-}
-
-//in: linda_ud key mincount [maxcount]
-int keepercall_receive_batched( lua_State* L)
-{
-    lua_Integer const min_count = lua_tointeger( L, 3);
-    if( min_count > 0)
-    {
-        keeper_fifo* fifo;
-        lua_Integer const max_count = luaL_optinteger( L, 4, min_count);
-        lua_settop( L, 2);                                    // ud key
-        lua_insert( L, 1);                                    // key ud
-        push_table( L, 2);                                    // key ud fifos
-        lua_remove( L, 2);                                    // key fifos
-        lua_pushvalue( L, 1);                                 // key fifos key
-        lua_rawget( L, 2);                                    // key fifos fifo
-        lua_remove( L, 2);                                    // key fifo
-        fifo = prepare_fifo_access( L, 2);                    // key fifo
-        if( fifo != NULL && fifo->count >= min_count)
-        {
-            fifo_pop( L, fifo, __min( max_count, fifo->count)); // key ...
-        }
-        else
-        {
-            lua_settop( L, 0);
-        }
-        return lua_gettop( L);
-    }
-    else
-    {
-        return 0;
-    }
-}
-
-// in: linda_ud key n
-// out: true or nil
-int keepercall_limit( lua_State* L)
-{
-    keeper_fifo* fifo;
-    lua_Integer limit = lua_tointeger( L, 3);
-    push_table( L, 1);                                 // ud key n fifos
-    lua_replace( L, 1);                                // fifos key n
-    lua_pop( L, 1);                                    // fifos key
-    lua_pushvalue( L, -1);                             // fifos key key
-    lua_rawget( L, -3);                                // fifos key fifo|nil
-    fifo = (keeper_fifo*) lua_touserdata( L, -1);
-    if( fifo ==  NULL)
-    {                                                  // fifos key nil
-        lua_pop( L, 1);                                  // fifos key
-        fifo_new( L);                                    // fifos key fifo
-        fifo = (keeper_fifo*) lua_touserdata( L, -1);
-        lua_rawset( L, -3);                              // fifos
-    }
-    // remove any clutter on the stack
-    lua_settop( L, 0);
-    // return true if we decide that blocked threads waiting to write on that key should be awakened
-    // this is the case if we detect the key was full but it is no longer the case
-    if(
-             ((fifo->limit >= 0) && (fifo->count >= fifo->limit)) // the key was full if limited and count exceeded the previous limit
-        && ((limit < 0) || (fifo->count < limit)) // the key is not full if unlimited or count is lower than the new limit
-    )
-    {
-        lua_pushboolean( L, 1);
-    }
-    // set the new limit
-    fifo->limit = limit;
-    // return 0 or 1 value
-    return lua_gettop( L);
-}
-
-//in: linda_ud key [[val] ...]
-//out: true or nil
-int keepercall_set( lua_State* L)
-{
-    bool_t should_wake_writers = FALSE;
-    STACK_GROW( L, 6);
-
-    // retrieve fifos associated with the linda
-    push_table( L, 1);                                // ud key [val [, ...]] fifos
-    lua_replace( L, 1);                               // fifos key [val [, ...]]
-
-    // make sure we have a value on the stack
-    if( lua_gettop( L) == 2)                          // fifos key
-    {
-        keeper_fifo* fifo;
-        lua_pushvalue( L, -1);                          // fifos key key
-        lua_rawget( L, 1);                              // fifos key fifo|nil
-        // empty the fifo for the specified key: replace uservalue with a virgin table, reset counters, but leave limit unchanged!
-        fifo = (keeper_fifo*) lua_touserdata( L, -1);
-        if( fifo != NULL) // might be NULL if we set a nonexistent key to nil
-        {                                               // fifos key fifo
-            if( fifo->limit < 0) // fifo limit value is the default (unlimited): we can totally remove it
-            {
-                lua_pop( L, 1);                             // fifos key
-                lua_pushnil( L);                            // fifos key nil
-                lua_rawset( L, -3);                         // fifos
-            }
-            else
-            {
-                // we create room if the fifo was full but it is no longer the case
-                should_wake_writers = (fifo->limit > 0) && (fifo->count >= fifo->limit);
-                lua_remove( L, -2);                         // fifos fifo
-                lua_newtable( L);                           // fifos fifo {}
-                lua_setiuservalue( L, -2, CONTENTS_TABLE);  // fifos fifo
-                fifo->first = 1;
-                fifo->count = 0;
-            }
-        }
-    }
-    else // set/replace contents stored at the specified key?
-    {
-        lua_Integer count = lua_gettop( L) - 2; // number of items we want to store
-        keeper_fifo* fifo;                              // fifos key [val [, ...]]
-        lua_pushvalue( L, 2);                           // fifos key [val [, ...]] key
-        lua_rawget( L, 1);                              // fifos key [val [, ...]] fifo|nil
-        fifo = (keeper_fifo*) lua_touserdata( L, -1);
-        if( fifo == NULL) // can be NULL if we store a value at a new key
-        {                                               // fifos key [val [, ...]] nil
-            // no need to wake writers in that case, because a writer can't wait on an inexistent key
-            lua_pop( L, 1);                               // fifos key [val [, ...]]
-            fifo_new( L);                                 // fifos key [val [, ...]] fifo
-            lua_pushvalue( L, 2);                         // fifos key [val [, ...]] fifo key
-            lua_pushvalue( L, -2);                        // fifos key [val [, ...]] fifo key fifo
-            lua_rawset( L, 1);                            // fifos key [val [, ...]] fifo
-        }
-        else // the fifo exists, we just want to update its contents
-        {                                               // fifos key [val [, ...]] fifo
-            // we create room if the fifo was full but it is no longer the case
-            should_wake_writers = (fifo->limit > 0) && (fifo->count >= fifo->limit) && (count < fifo->limit);
-            // empty the fifo for the specified key: replace uservalue with a virgin table, reset counters, but leave limit unchanged!
-            lua_newtable( L);                             // fifos key [val [, ...]] fifo {}
-            lua_setiuservalue( L, -2, CONTENTS_TABLE);    // fifos key [val [, ...]] fifo
-            fifo->first = 1;
-            fifo->count = 0;
-        }
-        fifo = prepare_fifo_access( L, -1);
-        // move the fifo below the values we want to store
-        lua_insert( L, 3);                              // fifos key fifo [val [, ...]]
-        fifo_push( L, fifo, count);                     // fifos key fifo
-    }
-    return should_wake_writers ? (lua_pushboolean( L, 1), 1) : 0;
-}
-
-// in: linda_ud key [count]
-// out: at most <count> values
-int keepercall_get( lua_State* L)
-{
-    keeper_fifo* fifo;
-    lua_Integer count = 1;
-    if( lua_gettop( L) == 3)                          // ud key count
-    {
-        count = lua_tointeger( L, 3);
-        lua_pop( L, 1);                                 // ud key
-    }
-    push_table( L, 1);                                // ud key fifos
-    lua_replace( L, 1);                               // fifos key
-    lua_rawget( L, 1);                                // fifos fifo
-    fifo = prepare_fifo_access( L, -1);               // fifos fifo
-    if( fifo != NULL && fifo->count > 0)
-    {
-        lua_remove( L, 1);                              // fifo
-        count = __min( count, fifo->count);
-        // read <count> value off the fifo
-        fifo_peek( L, fifo, count);                     // fifo ...
-        return (int) count;
-    }
-    // no fifo was ever registered for this key, or it is empty
-    return 0;
-}
-
-// in: linda_ud [, key [, ...]]
-int keepercall_count( lua_State* L)
-{
-    push_table( L, 1);                                   // ud keys fifos
-    switch( lua_gettop( L))
-    {
-        // no key is specified: return a table giving the count of all known keys
-        case 2:                                            // ud fifos
-        lua_newtable( L);                                  // ud fifos out
-        lua_replace( L, 1);                                // out fifos
-        lua_pushnil( L);                                   // out fifos nil
-        while( lua_next( L, 2))                            // out fifos key fifo
-        {
-            keeper_fifo* fifo = prepare_fifo_access( L, -1); // out fifos key fifo
-            lua_pop( L, 1);                                  // out fifos key
-            lua_pushvalue( L, -1);                           // out fifos key key
-            lua_pushinteger( L, fifo->count);                // out fifos key key count
-            lua_rawset( L, -5);                              // out fifos key
-        }
-        lua_pop( L, 1);                                    // out
-        break;
-
-        // 1 key is specified: return its count
-        case 3:                                            // ud key fifos
-        {
-            keeper_fifo* fifo;
-            lua_replace( L, 1);                              // fifos key
-            lua_rawget( L, -2);                              // fifos fifo|nil
-            if( lua_isnil( L, -1)) // the key is unknown
-            {                                                // fifos nil
-                lua_remove( L, -2);                            // nil
-            }
-            else // the key is known
-            {                                                // fifos fifo
-                fifo = prepare_fifo_access( L, -1);            // fifos fifo
-                lua_pushinteger( L, fifo->count);              // fifos fifo count
-                lua_replace( L, -3);                           // count fifo
-                lua_pop( L, 1);                                // count
-            }
-        }
-        break;
-
-        // a variable number of keys is specified: return a table of their counts
-        default:                                           // ud keys fifos
-        lua_newtable( L);                                  // ud keys fifos out
-        lua_replace( L, 1);                                // out keys fifos
-        // shifts all keys up in the stack. potentially slow if there are a lot of them, but then it should be bearable
-        lua_insert( L, 2);                                 // out fifos keys
-        while( lua_gettop( L) > 2)
-        {
-            keeper_fifo* fifo;
-            lua_pushvalue( L, -1);                           // out fifos keys key
-            lua_rawget( L, 2);                               // out fifos keys fifo|nil
-            fifo = prepare_fifo_access( L, -1);              // out fifos keys fifo|nil
-            lua_pop( L, 1);                                  // out fifos keys
-            if( fifo != NULL) // the key is known
-            {
-                lua_pushinteger( L, fifo->count);              // out fifos keys count
-                lua_rawset( L, 1);                             // out fifos keys
-            }
-            else // the key is unknown
-            {
-                lua_pop( L, 1);                                // out fifos keys
-            }
-        } // all keys are exhausted                            // out fifos
-        lua_pop( L, 1);                                    // out
-    }
-    ASSERT_L( lua_gettop( L) == 1);
-    return 1;
-}
-
-//###################################################################################
-// Keeper API, accessed from linda methods
-//###################################################################################
-
-/*---=== Keeper states ===---
-*/
-
-/*
-* Pool of keeper states
-*
-* Access to keeper states is locked (only one OS thread at a time) so the 
-* bigger the pool, the less chances of unnecessary waits. Lindas map to the
-* keepers randomly, by a hash.
-*/
-
-// called as __gc for the keepers array userdata
-void close_keepers( Universe* U)
-{
-    if( U->keepers != NULL)
-    {
-        int i;
-        int nbKeepers = U->keepers->nb_keepers;
-        // NOTE: imagine some keeper state N+1 currently holds a linda that uses another keeper N, and a _gc that will make use of it
-        // when keeper N+1 is closed, object is GCed, linda operation is called, which attempts to acquire keeper N, whose Lua state no longer exists
-        // in that case, the linda operation should do nothing. which means that these operations must check for keeper acquisition success
-        // which is early-outed with a U->keepers->nbKeepers null-check
-        U->keepers->nb_keepers = 0;
-        for( i = 0; i < nbKeepers; ++ i)
-        {
-            lua_State* K = U->keepers->keeper_array[i].L;
-            U->keepers->keeper_array[i].L = NULL;
-            if( K != NULL)
-            {
-                lua_close( K);
-            }
-            else
-            {
-                // detected partial init: destroy only the mutexes that got initialized properly
-                nbKeepers = i;
-            }
-        }
-        for( i = 0; i < nbKeepers; ++ i)
-        {
-            MUTEX_FREE( &U->keepers->keeper_array[i].keeper_cs);
-        }
-        // free the keeper bookkeeping structure
-        {
-            AllocatorDefinition* const allocD = &U->internal_allocator;
-            (void) allocD->allocF( allocD->allocUD, U->keepers, sizeof( Keepers) + (nbKeepers - 1) * sizeof( Keeper), 0);
-            U->keepers = NULL;
-        }
-    }
-}
-
-/*
- * Initialize keeper states
- *
- * If there is a problem, returns NULL and pushes the error message on the stack
- * else returns the keepers bookkeeping structure.
- *
- * Note: Any problems would be design flaws; the created Lua state is left
- *       unclosed, because it does not really matter. In production code, this
- *       function never fails.
- * settings table is at position 1 on the stack
- */
-void init_keepers( Universe* U, lua_State* L)
-{
-    int i;
-    int nb_keepers;
-    int keepers_gc_threshold;
-
-    STACK_CHECK( L, 0);                                    // L                            K
-    lua_getfield( L, 1, "nb_keepers");                     // nb_keepers
-    nb_keepers = (int) lua_tointeger( L, -1);
-    lua_pop( L, 1);                                        //
-    if( nb_keepers < 1)
-    {
-        (void) luaL_error( L, "Bad number of keepers (%d)", nb_keepers);
-    }
-    STACK_MID(L, 0);
-
-    lua_getfield(L, 1, "keepers_gc_threshold");            // keepers_gc_threshold
-    keepers_gc_threshold = (int) lua_tointeger(L, -1);
-    lua_pop(L, 1);                                         //
-    STACK_MID(L, 0);
-
-    // Keepers contains an array of 1 s_Keeper, adjust for the actual number of keeper states
-    {
-        size_t const bytes = sizeof( Keepers) + (nb_keepers - 1) * sizeof( Keeper);
-        {
-            AllocatorDefinition* const allocD = &U->internal_allocator;
-            U->keepers = (Keepers*) allocD->allocF( allocD->allocUD, NULL, 0, bytes);
-        }
-        if( U->keepers == NULL)
-        {
-            (void) luaL_error( L, "init_keepers() failed while creating keeper array; out of memory");
-            return;
-        }
-        memset( U->keepers, 0, bytes);
-        U->keepers->gc_threshold = keepers_gc_threshold;
-        U->keepers->nb_keepers = nb_keepers;
-    }
-    for( i = 0; i < nb_keepers; ++ i)                      // keepersUD
-    {
-        // note that we will leak K if we raise an error later
-        lua_State* K = create_state( U, L);
-        if( K == NULL)
-        {
-            (void) luaL_error( L, "init_keepers() failed while creating keeper states; out of memory");
-            return;
-        }
-
-        U->keepers->keeper_array[i].L = K;
-        MUTEX_INIT( &U->keepers->keeper_array[i].keeper_cs);
-
-        if (U->keepers->gc_threshold >= 0)
-        {
-            lua_gc(K, LUA_GCSTOP, 0);
-        }
-
-        STACK_CHECK( K, 0);
-
-        // copy the universe pointer in the keeper itself
-        universe_store( K, U);
-        STACK_MID( K, 0);
-
-        // make sure 'package' is initialized in keeper states, so that we have require()
-        // this because this is needed when transferring deep userdata object
-        luaL_requiref( K, "package", luaopen_package, 1);                                 // package
-        lua_pop( K, 1);                                                                   //
-        STACK_MID( K, 0);
-        serialize_require( DEBUGSPEW_PARAM_COMMA( U) K);
-        STACK_MID( K, 0);
-
-        // copy package.path and package.cpath from the source state
-        lua_getglobal( L, "package");                        // "..." keepersUD package
-        if( !lua_isnil( L, -1))
-        {
-            // when copying with mode eLM_ToKeeper, error message is pushed at the top of the stack, not raised immediately
-            if( luaG_inter_copy_package( U, L, K, -1, eLM_ToKeeper) != eICR_Success)
-            {
-                // if something went wrong, the error message is at the top of the stack
-                lua_remove( L, -2);                              // error_msg
-                (void) lua_error( L);
-                return;
-            }
-        }
-        lua_pop( L, 1);                                      //
-        STACK_MID( L, 0);
-
-        // attempt to call on_state_create(), if we have one and it is a C function
-        // (only support a C function because we can't transfer executable Lua code in keepers)
-        // will raise an error in L in case of problem
-        call_on_state_create( U, K, L, eLM_ToKeeper);
-
-        // to see VM name in Decoda debugger
-        lua_pushfstring( K, "Keeper #%d", i + 1);                                         // "Keeper #n"
-        lua_setglobal( K, "decoda_name");                                                 //
-
-        // create the fifos table in the keeper state
-        REGISTRY_SET( K, FIFOS_KEY, lua_newtable( K));
-        STACK_END( K, 0);
-    }
-    STACK_END( L, 0);
-}
-
-// should be called only when inside a keeper_acquire/keeper_release pair (see linda_protected_call)
-Keeper* which_keeper(Keepers* keepers_, uintptr_t magic_)
-{
-    int const nbKeepers = keepers_->nb_keepers;
-    if (nbKeepers)
-    {
-        unsigned int i = (unsigned int)((magic_ >> KEEPER_MAGIC_SHIFT) % nbKeepers);
-        return &keepers_->keeper_array[i];
-    }
-    return NULL;
-}
-
-Keeper* keeper_acquire( Keepers* keepers_, uintptr_t magic_)
-{
-    int const nbKeepers = keepers_->nb_keepers;
-    // can be 0 if this happens during main state shutdown (lanes is being GC'ed -> no keepers)
-    if( nbKeepers)
-    {
-        /*
-        * Any hashing will do that maps pointers to 0..GNbKeepers-1 
-        * consistently.
-        *
-        * Pointers are often aligned by 8 or so - ignore the low order bits
-        * have to cast to unsigned long to avoid compilation warnings about loss of data when converting pointer-to-integer
-        */
-        unsigned int i = (unsigned int)((magic_ >> KEEPER_MAGIC_SHIFT) % nbKeepers);
-        Keeper* K = &keepers_->keeper_array[i];
-
-        MUTEX_LOCK( &K->keeper_cs);
-        //++ K->count;
-        return K;
-    }
-    return NULL;
-}
-
-void keeper_release( Keeper* K_)
-{
-    //-- K->count;
-    if( K_) MUTEX_UNLOCK( &K_->keeper_cs);
-}
-
-void keeper_toggle_nil_sentinels( lua_State* L, int val_i_, LookupMode const mode_)
-{
-    int i, n = lua_gettop( L);
-    for( i = val_i_; i <= n; ++ i)
-    {
-        if( mode_ == eLM_ToKeeper)
-        {
-            if( lua_isnil( L, i))
-            {
-                push_unique_key( L, NIL_SENTINEL);
-                lua_replace( L, i);
-            }
-        }
-        else
-        {
-            if( equal_unique_key( L, i, NIL_SENTINEL))
-            {
-                lua_pushnil( L);
-                lua_replace( L, i);
-            }
-        }
-    }
-}
-
-/*
-* Call a function ('func_name') in the keeper state, and pass on the returned
-* values to 'L'.
-*
-* 'linda':          deep Linda pointer (used only as a unique table key, first parameter)
-* 'starting_index': first of the rest of parameters (none if 0)
-*
-* Returns: number of return values (pushed to 'L') or -1 in case of error
-*/
-int keeper_call( Universe* U, lua_State* K, keeper_api_t func_, lua_State* L, void* linda, uint_t starting_index)
-{
-    int const args = starting_index ? (lua_gettop( L) - starting_index + 1) : 0;
-    int const Ktos = lua_gettop( K);
-    int retvals = -1;
-
-    STACK_GROW( K, 2);
-
-    PUSH_KEEPER_FUNC( K, func_);
-
-    lua_pushlightuserdata( K, linda);
-
-    if( (args == 0) || luaG_inter_copy( U, L, K, args, eLM_ToKeeper) == eICR_Success) // L->K
-    {
-        lua_call( K, 1 + args, LUA_MULTRET);
-
-        retvals = lua_gettop( K) - Ktos;
-        // note that this can raise a luaL_error while the keeper state (and its mutex) is acquired
-        // this may interrupt a lane, causing the destruction of the underlying OS thread
-        // after this, another lane making use of this keeper can get an error code from the mutex-locking function
-        // when attempting to grab the mutex again (WINVER <= 0x400 does this, but locks just fine, I don't know about pthread)
-        if( (retvals > 0) && luaG_inter_move( U, K, L, retvals, eLM_FromKeeper) != eICR_Success) // K->L
-        {
-            retvals = -1;
-        }
-    }
-    // whatever happens, restore the stack to where it was at the origin
-    lua_settop( K, Ktos);
-
-
-    // don't do this for this particular function, as it is only called during Linda destruction, and we don't want to raise an error, ever
-    if (func_ != KEEPER_API(clear))
-    {
-        // since keeper state GC is stopped, let's run a step once in a while if required
-        int const gc_threshold = U->keepers->gc_threshold;
-        if (gc_threshold == 0)
-        {
-            lua_gc(K, LUA_GCSTEP, 0);
-        }
-        else if (gc_threshold > 0)
-        {
-            int const gc_usage = lua_gc(K, LUA_GCCOUNT, 0);
-            if (gc_usage >= gc_threshold)
-            {
-                lua_gc(K, LUA_GCCOLLECT, 0);
-                int const gc_usage_after = lua_gc(K, LUA_GCCOUNT, 0);
-                if (gc_usage_after > gc_threshold)
-                {
-                    luaL_error(L, "Keeper GC threshold is too low, need at least %d", gc_usage_after);
-                }
-            }
-        }
-    }
-
-    return retvals;
-}
diff --git a/src/keeper.cpp b/src/keeper.cpp
new file mode 100644
index 0000000..f56c50c
--- /dev/null
+++ b/src/keeper.cpp
@@ -0,0 +1,884 @@
+/*
+ --
+ -- KEEPER.CPP
+ --
+ -- Keeper state logic
+ --
+ -- This code is read in for each "keeper state", which are the hidden, inter-
+ -- mediate data stores used by Lanes inter-state communication objects.
+ --
+ -- Author: Benoit Germain <bnt.germain@gmail.com>
+ --
+ -- C implementation replacement of the original keeper.lua
+ --
+ --[[
+ ===============================================================================
+
+ Copyright (C) 2011-2024 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
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+
+ ===============================================================================
+ ]]--
+ */
+#include "keeper.h"
+
+#include "compat.h"
+#include "state.h"
+#include "tools.h"
+#include "uniquekey.h"
+#include "universe.h"
+
+#include <algorithm>
+#include <cassert>
+
+// ###################################################################################
+// Keeper implementation
+// ###################################################################################
+
+class keeper_fifo
+{
+    public:
+
+    int first{ 1 };
+    int count{ 0 };
+    int limit{ -1 };
+
+    // a fifo full userdata has one uservalue, the table that holds the actual fifo contents
+    [[nodiscard]] static void* operator new([[maybe_unused]] size_t size_, lua_State* L) noexcept { return lua_newuserdatauv<keeper_fifo>(L, 1); }
+    // always embedded somewhere else or "in-place constructed" as a full userdata
+    // can't actually delete the operator because the compiler generates stack unwinding code that could call it in case of exception
+    static void operator delete([[maybe_unused]] void* p_, lua_State* L) { ASSERT_L(!"should never be called") };
+
+    [[nodiscard]] static keeper_fifo* getPtr(lua_State* L, int idx_)
+    {
+        return lua_tofulluserdata<keeper_fifo>(L, idx_);
+    }
+};
+
+static constexpr int CONTENTS_TABLE{ 1 };
+
+// ##################################################################################################
+
+// replaces the fifo ud by its uservalue on the stack
+[[nodiscard]] static keeper_fifo* prepare_fifo_access(lua_State* L, int idx_)
+{
+    keeper_fifo* const fifo{ keeper_fifo::getPtr(L, idx_) };
+    if (fifo != nullptr)
+    {
+        idx_ = lua_absindex(L, idx_);
+        STACK_GROW(L, 1);
+        // we can replace the fifo userdata in the stack without fear of it being GCed, there are other references around
+        lua_getiuservalue(L, idx_, CONTENTS_TABLE);
+        lua_replace(L, idx_);
+    }
+    return fifo;
+}
+
+// ##################################################################################################
+
+// in: nothing
+// out: { first = 1, count = 0, limit = -1}
+[[nodiscard]] static keeper_fifo* fifo_new(lua_State* L)
+{
+    STACK_GROW(L, 2);
+    STACK_CHECK_START_REL(L, 0);
+    keeper_fifo* const fifo{ new (L) keeper_fifo{} };
+    STACK_CHECK(L, 1);
+    lua_newtable(L);
+    lua_setiuservalue(L, -2, CONTENTS_TABLE);
+    STACK_CHECK(L, 1);
+    return fifo;
+}
+
+// ##################################################################################################
+
+// in: expect fifo ... on top of the stack
+// out: nothing, removes all pushed values from the stack
+static void fifo_push(lua_State* L, keeper_fifo* fifo_, int count_)
+{
+    int const idx{ lua_gettop(L) - count_ };
+    int const start{ fifo_->first + fifo_->count - 1 };
+    // pop all additional arguments, storing them in the fifo
+    for (int i = count_; i >= 1; --i)
+    {
+        // store in the fifo the value at the top of the stack at the specified index, popping it from the stack
+        lua_rawseti(L, idx, start + i);
+    }
+    fifo_->count += count_;
+}
+
+// ##################################################################################################
+
+// in: fifo
+// out: ...|nothing
+// expects exactly 1 value on the stack!
+// currently only called with a count of 1, but this may change in the future
+// function assumes that there is enough data in the fifo to satisfy the request
+static void fifo_peek(lua_State* L, keeper_fifo* fifo_, int count_)
+{
+    STACK_GROW(L, count_);
+    for (int i = 0; i < count_; ++i)
+    {
+        lua_rawgeti(L, 1, (fifo_->first + i));
+    }
+}
+
+// ##################################################################################################
+
+// in: fifo
+// out: remove the fifo from the stack, push as many items as required on the stack (function assumes they exist in sufficient number)
+static void fifo_pop( lua_State* L, keeper_fifo* fifo_, int count_)
+{
+    ASSERT_L(lua_istable(L, -1));
+    int const fifo_idx{ lua_gettop(L) };       // ... fifotbl
+    // each iteration pushes a value on the stack!
+    STACK_GROW(L, count_ + 2);
+    // skip first item, we will push it last
+    for (int i = 1; i < count_; ++i)
+    {
+        int const at{ fifo_->first + i };
+        // push item on the stack
+        lua_rawgeti(L, fifo_idx, at);          // ... fifotbl val
+        // remove item from the fifo
+        lua_pushnil(L);                        // ... fifotbl val nil
+        lua_rawseti(L, fifo_idx, at);          // ... fifotbl val
+    }
+    // now process first item
+    {
+        int const at{ fifo_->first };
+        lua_rawgeti(L, fifo_idx, at);          // ... fifotbl vals val
+        lua_pushnil(L);                        // ... fifotbl vals val nil
+        lua_rawseti(L, fifo_idx, at);          // ... fifotbl vals val
+        lua_replace(L, fifo_idx);              // ... vals
+    }
+
+    // avoid ever-growing indexes by resetting each time we detect the fifo is empty
+    {
+        int const new_count{ fifo_->count - count_ };
+        fifo_->first = (new_count == 0) ? 1 : (fifo_->first + count_);
+        fifo_->count = new_count;
+    }
+}
+
+// ##################################################################################################
+
+// in: linda_ud expected at stack slot idx
+// out: fifos[ud]
+// crc64/we of string "FIFOS_KEY" generated at http://www.nitrxgen.net/hashgen/
+static constexpr UniqueKey FIFOS_KEY{ 0xdce50bbc351cd465ull };
+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.pushValue(L);                    // ud fifos
+    lua_pushvalue(L, idx_);                    // ud fifos ud
+    lua_rawget(L, -2);                         // ud fifos fifos[ud]
+    STACK_CHECK(L, 2);
+    if (lua_isnil(L, -1))
+    {
+        lua_pop(L, 1);                         // ud fifos
+        // add a new fifos table for this linda
+        lua_newtable(L);                       // ud fifos fifos[ud]
+        lua_pushvalue(L, idx_);                // ud fifos fifos[ud] ud
+        lua_pushvalue(L, -2);                  // ud fifos fifos[ud] ud fifos[ud]
+        lua_rawset(L, -4);                     // ud fifos fifos[ud]
+    }
+    lua_remove(L, -2);                         // ud fifos[ud]
+    STACK_CHECK(L, 1);
+}
+
+// ##################################################################################################
+
+int keeper_push_linda_storage(Universe* U, Dest L, void* ptr_, uintptr_t magic_)
+{
+    Keeper* const K{ which_keeper(U->keepers, magic_) };
+    Source const KL{ K ? K->L : nullptr };
+    if (KL == nullptr)
+        return 0;
+    STACK_GROW(KL, 4);                                                      // KEEPER                       MAIN
+    STACK_CHECK_START_REL(KL, 0);
+    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))
+    {
+        lua_pop(KL, 1);                                                     //
+        STACK_CHECK(KL, 0);
+        return 0;
+    }
+    // move data from keeper to destination state
+    lua_pushnil(KL);                                                        // storage nil
+    STACK_GROW(L, 5);
+    STACK_CHECK_START_REL(L, 0);
+    lua_newtable(L);                                                                           // out
+    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
+        std::ignore = luaG_inter_move(U, KL, L, 1, LookupMode::FromKeeper); // storage key fifotbl       // out key
+        STACK_CHECK(L, 2);
+        lua_newtable(L);                                                                                 // out key keyout
+        std::ignore = luaG_inter_move(U, KL, L, 1, LookupMode::FromKeeper); // storage key               // out key keyout fifotbl
+        lua_pushinteger(L, fifo->first);                                                                 // out key keyout fifotbl first
+        STACK_CHECK(L, 5);
+        lua_setfield(L, -3, "first");                                                                    // out key keyout fifotbl
+        lua_pushinteger(L, fifo->count);                                                                 // out key keyout fifobtl count
+        STACK_CHECK(L, 5);
+        lua_setfield(L, -3, "count");                                                                    // out key keyout fifotbl
+        lua_pushinteger(L, fifo->limit);                                                                 // out key keyout fifotbl limit
+        STACK_CHECK(L, 5);
+        lua_setfield(L, -3, "limit");                                                                    // out key keyout fifotbl
+        lua_setfield(L, -2, "fifo");                                                                     // out key keyout
+        lua_rawset(L, -3);                                                                               // out
+        STACK_CHECK(L, 1);
+    }
+    STACK_CHECK(L, 1);
+    lua_pop(KL, 1);                                                         //
+    STACK_CHECK(KL, 0);
+    return 1;
+}
+
+// ##################################################################################################
+
+// in: linda_ud
+int keepercall_clear(lua_State* L)
+{
+    STACK_GROW(L, 3);
+    STACK_CHECK_START_REL(L, 0);
+    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
+    lua_pop(L, 1);                              // ud
+    STACK_CHECK(L, 0);
+    return 0;
+}
+
+// ##################################################################################################
+
+// in: linda_ud, key, ...
+// out: true|false
+int keepercall_send(lua_State* L)
+{
+    int const n{ lua_gettop(L) - 2 };
+    push_table(L, 1);                             // ud key ... fifos
+    // get the fifo associated to this key in this linda, create it if it doesn't exist
+    lua_pushvalue(L, 2);                          // ud key ... fifos key
+    lua_rawget(L, -2);                            // ud key ... fifos fifo
+    if( lua_isnil(L, -1))
+    {
+        lua_pop(L, 1);                            // ud key ... fifos
+        std::ignore = fifo_new(L);                // ud key ... fifos fifo
+        lua_pushvalue(L, 2);                      // ud key ... fifos fifo key
+        lua_pushvalue(L, -2);                     // ud key ... fifos fifo key fifo
+        lua_rawset(L, -4);                        // ud key ... fifos fifo
+    }
+    lua_remove(L, -2);                            // ud key ... fifo
+    keeper_fifo* fifo{ keeper_fifo::getPtr(L, -1) };
+    if (fifo->limit >= 0 && fifo->count + n > fifo->limit)
+    {
+        lua_settop(L, 0);                         //
+        lua_pushboolean(L, 0);                    // false
+    }
+    else
+    {
+        fifo = prepare_fifo_access(L, -1);        // ud fifotbl
+        lua_replace(L, 2);                        // ud fifotbl ...
+        fifo_push(L, fifo, n);                    // ud fifotbl
+        lua_settop(L, 0);                         //
+        lua_pushboolean(L, 1);                    // true
+    }
+    return 1;
+}
+
+// ##################################################################################################
+
+// in: linda_ud, key [, key]?
+// out: (key, val) or nothing
+int keepercall_receive(lua_State* L)
+{
+    int const top{ lua_gettop(L) };
+    push_table(L, 1);                                          // ud keys fifos
+    lua_replace(L, 1);                                         // fifos keys
+    for (int i = 2; i <= top; ++i)
+    {
+        lua_pushvalue(L, i);                                   // fifos keys key[i]
+        lua_rawget(L, 1);                                      // fifos keys fifo
+        keeper_fifo* const fifo{ prepare_fifo_access(L, -1) }; // fifos keys fifotbl
+        if (fifo != nullptr && fifo->count > 0)
+        {
+            fifo_pop(L, fifo, 1);                              // fifos keys val
+            if (!lua_isnil(L, -1))
+            {
+                lua_replace(L, 1);                             // val keys
+                lua_settop(L, i);                              // val keys key[i]
+                if (i != 2)
+                {
+                    lua_replace(L, 2);                         // val key keys
+                    lua_settop(L, 2);                          // val key
+                }
+                lua_insert(L, 1);                              // key, val
+                return 2;
+            }
+        }
+        lua_settop(L, top);                                    // data keys
+    }
+    // nothing to receive
+    return 0;
+}
+
+// ##################################################################################################
+
+// in: linda_ud key mincount [maxcount]
+int keepercall_receive_batched(lua_State* L)
+{
+    int const min_count{ static_cast<int>(lua_tointeger(L, 3)) };
+    if( min_count > 0)
+    {
+        int const max_count{ static_cast<int>(luaL_optinteger(L, 4, min_count)) };
+        lua_settop(L, 2);                                         // ud key
+        lua_insert(L, 1);                                         // key ud
+        push_table(L, 2);                                         // key ud fifos
+        lua_remove(L, 2);                                         // key fifos
+        lua_pushvalue(L, 1);                                      // key fifos key
+        lua_rawget(L, 2);                                         // key fifos fifo
+        lua_remove(L, 2);                                         // key fifo
+        keeper_fifo* const fifo{ prepare_fifo_access(L, 2) };     // key fifotbl
+        if( fifo != nullptr && fifo->count >= min_count)
+        {
+            fifo_pop(L, fifo, std::min( max_count, fifo->count)); // key ...
+        }
+        else
+        {
+            lua_settop(L, 0);                                     //
+        }
+        return lua_gettop(L);
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+// ##################################################################################################
+
+// in: linda_ud key n
+// out: true or nil
+int keepercall_limit(lua_State* L)
+{
+    int const limit{ static_cast<int>(lua_tointeger(L, 3)) };
+    push_table(L, 1);                                   // ud key n fifos
+    lua_replace(L, 1);                                  // fifos key n
+    lua_pop(L, 1);                                      // fifos key
+    lua_pushvalue(L, -1);                               // fifos key key
+    lua_rawget(L, -3);                                  // fifos key fifo|nil
+    keeper_fifo* fifo{ keeper_fifo::getPtr(L, -1) };
+    if (fifo == nullptr)
+    {                                                   // fifos key nil
+        lua_pop(L, 1);                                  // fifos key
+        fifo = fifo_new(L);                             // fifos key fifo
+        lua_rawset(L, -3);                              // fifos
+    }
+    // remove any clutter on the stack
+    lua_settop(L, 0);
+    // return true if we decide that blocked threads waiting to write on that key should be awakened
+    // this is the case if we detect the key was full but it is no longer the case
+    if(
+           ((fifo->limit >= 0) && (fifo->count >= fifo->limit)) // the key was full if limited and count exceeded the previous limit
+        && ((limit < 0) || (fifo->count < limit))       // the key is not full if unlimited or count is lower than the new limit
+    )
+    {
+        lua_pushboolean(L, 1);                          // true
+    }
+    // set the new limit
+    fifo->limit = limit;
+    // return 0 or 1 value
+    return lua_gettop(L);
+}
+
+// ##################################################################################################
+
+// in: linda_ud key [[val] ...]
+//out: true or nil
+int keepercall_set(lua_State* L)
+{
+    bool should_wake_writers{ false };
+    STACK_GROW(L, 6);
+
+    // retrieve fifos associated with the linda
+    push_table(L, 1);                                      // ud key [val [, ...]] fifos
+    lua_replace(L, 1);                                     // fifos key [val [, ...]]
+
+    // make sure we have a value on the stack
+    if (lua_gettop(L) == 2)                                // fifos key
+    {
+        lua_pushvalue(L, -1);                              // fifos key key
+        lua_rawget(L, 1);                                  // fifos key fifo|nil
+        // empty the fifo for the specified key: replace uservalue with a virgin table, reset counters, but leave limit unchanged!
+        keeper_fifo* const fifo{ keeper_fifo::getPtr(L, -1) };
+        if (fifo != nullptr) // might be nullptr if we set a nonexistent key to nil
+        {                                                  // fifos key fifo
+            if (fifo->limit < 0) // fifo limit value is the default (unlimited): we can totally remove it
+            {
+                lua_pop(L, 1);                             // fifos key
+                lua_pushnil(L);                            // fifos key nil
+                lua_rawset(L, -3);                         // fifos
+            }
+            else
+            {
+                // we create room if the fifo was full but it is no longer the case
+                should_wake_writers = (fifo->limit > 0) && (fifo->count >= fifo->limit);
+                lua_remove(L, -2);                         // fifos fifo
+                lua_newtable(L);                           // fifos fifo {}
+                lua_setiuservalue(L, -2, CONTENTS_TABLE);  // fifos fifo
+                fifo->first = 1;
+                fifo->count = 0;
+            }
+        }
+    }
+    else // set/replace contents stored at the specified key?
+    {
+        int const count{ lua_gettop(L) - 2 }; // number of items we want to store
+        lua_pushvalue(L, 2);                               // fifos key [val [, ...]] key
+        lua_rawget(L, 1);                                  // fifos key [val [, ...]] fifo|nil
+        keeper_fifo* fifo{ keeper_fifo::getPtr(L, -1) };
+        if( fifo == nullptr) // can be nullptr if we store a value at a new key
+        {                                                  // fifos key [val [, ...]] nil
+            // no need to wake writers in that case, because a writer can't wait on an inexistent key
+            lua_pop(L, 1);                                 // fifos key [val [, ...]]
+            std::ignore = fifo_new(L);                     // fifos key [val [, ...]] fifo
+            lua_pushvalue(L, 2);                           // fifos key [val [, ...]] fifo key
+            lua_pushvalue(L, -2);                          // fifos key [val [, ...]] fifo key fifo
+            lua_rawset(L, 1);                              // fifos key [val [, ...]] fifo
+        }
+        else // the fifo exists, we just want to update its contents
+        {                                                  // fifos key [val [, ...]] fifo
+            // we create room if the fifo was full but it is no longer the case
+            should_wake_writers = (fifo->limit > 0) && (fifo->count >= fifo->limit) && (count < fifo->limit);
+            // empty the fifo for the specified key: replace uservalue with a virgin table, reset counters, but leave limit unchanged!
+            lua_newtable(L);                               // fifos key [val [, ...]] fifo {}
+            lua_setiuservalue(L, -2, CONTENTS_TABLE);      // fifos key [val [, ...]] fifo
+            fifo->first = 1;
+            fifo->count = 0;
+        }
+        fifo = prepare_fifo_access(L, -1);                 // fifos key [val [, ...]] fifotbl
+        // move the fifo below the values we want to store
+        lua_insert(L, 3);                                  // fifos key fifotbl [val [, ...]]
+        fifo_push(L, fifo, count);                         // fifos key fifotbl
+    }
+    return should_wake_writers ? (lua_pushboolean(L, 1), 1) : 0;
+}
+
+// ##################################################################################################
+
+// in: linda_ud key [count]
+// out: at most <count> values
+int keepercall_get(lua_State* L)
+{
+    int count{ 1 };
+    if (lua_gettop(L) == 3)                                // ud key count
+    {
+        count = static_cast<int>(lua_tointeger(L, 3));
+        lua_pop(L, 1);                                     // ud key
+    }
+    push_table(L, 1);                                      // ud key fifos
+    lua_replace(L, 1);                                     // fifos key
+    lua_rawget(L, 1);                                      // fifos fifo
+    keeper_fifo* const fifo{ prepare_fifo_access(L, -1) }; // fifos fifotbl
+    if (fifo != nullptr && fifo->count > 0)
+    {
+        lua_remove(L, 1);                                  // fifotbl
+        count = std::min(count, fifo->count);
+        // read <count> value off the fifo
+        fifo_peek(L, fifo, count);                         // fifotbl ...
+        return count;
+    }
+    // no fifo was ever registered for this key, or it is empty
+    return 0;
+}
+
+// ##################################################################################################
+
+// in: linda_ud [, key [, ...]]
+int keepercall_count(lua_State* L)
+{
+    push_table(L, 1);                                              // ud keys fifos
+    switch (lua_gettop(L))
+    {
+        // no key is specified: return a table giving the count of all known keys
+        case 2:                                                    // ud fifos
+        lua_newtable(L);                                           // ud fifos out
+        lua_replace(L, 1);                                         // out fifos
+        lua_pushnil(L);                                            // out fifos nil
+        while (lua_next(L, 2))                                     // out fifos key fifo
+        {
+            keeper_fifo* const fifo{ keeper_fifo::getPtr(L, -1) };
+            lua_pop(L, 1);                                         // out fifos key
+            lua_pushvalue(L, -1);                                  // out fifos key key
+            lua_pushinteger(L, fifo->count);                       // out fifos key key count
+            lua_rawset(L, -5);                                     // out fifos key
+        }
+        lua_pop(L, 1);                                             // out
+        break;
+
+        // 1 key is specified: return its count
+        case 3:                                                    // ud key fifos
+        lua_replace(L, 1);                                         // fifos key
+        lua_rawget(L, -2);                                         // fifos fifo|nil
+        if (lua_isnil(L, -1))                                      // the key is unknown
+        {                                                          // fifos nil
+            lua_remove(L, -2);                                     // nil
+        }
+        else // the key is known
+        {                                                          // fifos fifo
+            keeper_fifo* const fifo{ keeper_fifo::getPtr(L, -1) };
+            lua_pushinteger(L, fifo->count);                       // fifos fifo count
+            lua_replace(L, -3);                                    // count fifo
+            lua_pop(L, 1);                                         // count
+        }
+        break;
+
+        // a variable number of keys is specified: return a table of their counts
+        default: // ud keys fifos
+        lua_newtable(L);                                           // ud keys... fifos out
+        lua_replace(L, 1);                                         // out keys... fifos
+        // shifts all keys up in the stack. potentially slow if there are a lot of them, but then it should be bearable
+        lua_insert(L, 2);                                          // out fifos keys...
+        while (lua_gettop(L) > 2)
+        {
+            lua_pushvalue(L, -1);                                  // out fifos keys... key
+            lua_rawget(L, 2);                                      // out fifos keys... fifo|nil
+            keeper_fifo* const fifo{ keeper_fifo::getPtr(L, -1) };
+            lua_pop(L, 1);                                         // out fifos keys...
+            if (fifo != nullptr)                                   // the key is known
+            {
+                lua_pushinteger(L, fifo->count);                   // out fifos keys... count
+                lua_rawset(L, 1);                                  // out fifos keys...
+            }
+            else // the key is unknown
+            {
+                lua_pop(L, 1);                                     // out fifos keys...
+            }
+        } // all keys are exhausted                                // out fifos
+        lua_pop(L, 1);                                             // out
+    }
+    ASSERT_L(lua_gettop(L) == 1);
+    return 1;
+}
+
+//###################################################################################
+// Keeper API, accessed from linda methods
+//###################################################################################
+
+/*---=== Keeper states ===---
+*/
+
+/*
+* Pool of keeper states
+*
+* Access to keeper states is locked (only one OS thread at a time) so the 
+* bigger the pool, the less chances of unnecessary waits. Lindas map to the
+* keepers randomly, by a hash.
+*/
+
+// called as __gc for the keepers array userdata
+void close_keepers(Universe* U)
+{
+    if (U->keepers != nullptr)
+    {
+        int nbKeepers = U->keepers->nb_keepers;
+        // NOTE: imagine some keeper state N+1 currently holds a linda that uses another keeper N, and a _gc that will make use of it
+        // when keeper N+1 is closed, object is GCed, linda operation is called, which attempts to acquire keeper N, whose Lua state no longer exists
+        // in that case, the linda operation should do nothing. which means that these operations must check for keeper acquisition success
+        // which is early-outed with a U->keepers->nbKeepers null-check
+        U->keepers->nb_keepers = 0;
+        for (int i = 0; i < nbKeepers; ++i)
+        {
+            lua_State* K = U->keepers->keeper_array[i].L;
+            U->keepers->keeper_array[i].L = nullptr;
+            if (K != nullptr)
+            {
+                lua_close(K);
+            }
+            else
+            {
+                // detected partial init: destroy only the mutexes that got initialized properly
+                nbKeepers = i;
+            }
+        }
+        for (int i = 0; i < nbKeepers; ++i)
+        {
+            U->keepers->keeper_array[i].~Keeper();
+        }
+        // free the keeper bookkeeping structure
+        U->internal_allocator.free(U->keepers, sizeof(Keepers) + (nbKeepers - 1) * sizeof(Keeper));
+        U->keepers = nullptr;
+    }
+}
+
+// ##################################################################################################
+
+/*
+ * Initialize keeper states
+ *
+ * If there is a problem, returns nullptr and pushes the error message on the stack
+ * else returns the keepers bookkeeping structure.
+ *
+ * Note: Any problems would be design flaws; the created Lua state is left
+ *       unclosed, because it does not really matter. In production code, this
+ *       function never fails.
+ * settings table is at position 1 on the stack
+ */
+void init_keepers(Universe* U, lua_State* L)
+{
+    STACK_CHECK_START_REL(L, 0);                                   // L                            K
+    lua_getfield(L, 1, "nb_keepers");                              // nb_keepers
+    int const nb_keepers{ static_cast<int>(lua_tointeger(L, -1)) };
+    lua_pop(L, 1);                                                 //
+    if (nb_keepers < 1)
+    {
+        luaL_error(L, "Bad number of keepers (%d)", nb_keepers); // doesn't return
+    }
+    STACK_CHECK(L, 0);
+
+    lua_getfield(L, 1, "keepers_gc_threshold");                    // keepers_gc_threshold
+    int const keepers_gc_threshold{ static_cast<int>(lua_tointeger(L, -1)) };
+    lua_pop(L, 1);                                                 //
+    STACK_CHECK(L, 0);
+
+    // Keepers contains an array of 1 Keeper, adjust for the actual number of keeper states
+    {
+        size_t const bytes = sizeof(Keepers) + (nb_keepers - 1) * sizeof(Keeper);
+        U->keepers = static_cast<Keepers*>(U->internal_allocator.alloc(bytes));
+        if (U->keepers == nullptr)
+        {
+            luaL_error(L, "init_keepers() failed while creating keeper array; out of memory"); // doesn't return
+        }
+        U->keepers->Keepers::Keepers();
+        U->keepers->gc_threshold = keepers_gc_threshold;
+        U->keepers->nb_keepers = nb_keepers;
+
+        for (int i = 0; i < nb_keepers; ++i)
+        {
+            U->keepers->keeper_array[i].Keeper::Keeper();
+        }
+    }
+    for (int i = 0; i < nb_keepers; ++i)                           // keepersUD
+    {
+        // note that we will leak K if we raise an error later
+        lua_State* const K{ create_state(U, L) };
+        if (K == nullptr)
+        {
+            luaL_error(L, "init_keepers() failed while creating keeper states; out of memory"); // doesn't return
+        }
+
+        U->keepers->keeper_array[i].L = K;
+
+        if (U->keepers->gc_threshold >= 0)
+        {
+            lua_gc(K, LUA_GCSTOP, 0);
+        }
+
+        STACK_CHECK_START_ABS(K, 0);
+
+        // copy the universe pointer in the keeper itself
+        universe_store(K, U);
+        STACK_CHECK(K, 0);
+
+        // make sure 'package' is initialized in keeper states, so that we have require()
+        // this because this is needed when transferring deep userdata object
+        luaL_requiref(K, "package", luaopen_package, 1);           //                              package
+        lua_pop(K, 1);                                             //
+        STACK_CHECK(K, 0);
+        serialize_require(DEBUGSPEW_PARAM_COMMA(U) K);
+        STACK_CHECK(K, 0);
+
+        // copy package.path and package.cpath from the source state
+        lua_getglobal(L, "package");                               // "..." keepersUD package
+        if (!lua_isnil(L, -1))
+        {
+            // when copying with mode LookupMode::ToKeeper, error message is pushed at the top of the stack, not raised immediately
+            if (luaG_inter_copy_package(U, Source{ L }, Dest{ K }, -1, LookupMode::ToKeeper) != InterCopyResult::Success)
+            {
+                // if something went wrong, the error message is at the top of the stack
+                lua_remove(L, -2);                                 // error_msg
+                raise_lua_error(L);
+            }
+        }
+        lua_pop(L, 1);                                             //
+        STACK_CHECK(L, 0);
+
+        // attempt to call on_state_create(), if we have one and it is a C function
+        // (only support a C function because we can't transfer executable Lua code in keepers)
+        // will raise an error in L in case of problem
+        call_on_state_create(U, K, L, LookupMode::ToKeeper);
+
+        // to see VM name in Decoda debugger
+        lua_pushfstring(K, "Keeper #%d", i + 1);                   //                              "Keeper #n"
+        lua_setglobal(K, "decoda_name");                           //
+        // create the fifos table in the keeper state
+        FIFOS_KEY.setValue(K, [](lua_State* L) { lua_newtable(L); });
+        STACK_CHECK(K, 0);
+    }
+    STACK_CHECK(L, 0);
+}
+
+// ##################################################################################################
+
+// should be called only when inside a keeper_acquire/keeper_release pair (see linda_protected_call)
+Keeper* which_keeper(Keepers* keepers_, uintptr_t magic_)
+{
+    int const nbKeepers{ keepers_->nb_keepers };
+    if (nbKeepers)
+    {
+        unsigned int i = (unsigned int) ((magic_ >> KEEPER_MAGIC_SHIFT) % nbKeepers);
+        return &keepers_->keeper_array[i];
+    }
+    return nullptr;
+}
+
+// ##################################################################################################
+
+Keeper* keeper_acquire(Keepers* keepers_, uintptr_t magic_)
+{
+    int const nbKeepers{ keepers_->nb_keepers };
+    // can be 0 if this happens during main state shutdown (lanes is being GC'ed -> no keepers)
+    if (nbKeepers)
+    {
+        /*
+        * Any hashing will do that maps pointers to 0..GNbKeepers-1 
+        * consistently.
+        *
+        * Pointers are often aligned by 8 or so - ignore the low order bits
+        * have to cast to unsigned long to avoid compilation warnings about loss of data when converting pointer-to-integer
+        */
+        unsigned int i = (unsigned int)((magic_ >> KEEPER_MAGIC_SHIFT) % nbKeepers);
+        Keeper* K = &keepers_->keeper_array[i];
+        K->m_mutex.lock();
+        //++ K->count;
+        return K;
+    }
+    return nullptr;
+}
+
+// ##################################################################################################
+
+void keeper_release(Keeper* K)
+{
+    //-- K->count;
+    if (K)
+    {
+        K->m_mutex.unlock();
+    }
+}
+
+// ##################################################################################################
+
+void keeper_toggle_nil_sentinels(lua_State* L, int val_i_, LookupMode const mode_)
+{
+    int const n{ lua_gettop(L) };
+    for (int i = val_i_; i <= n; ++i)
+    {
+        if (mode_ == LookupMode::ToKeeper)
+        {
+            if (lua_isnil(L, i))
+            {
+                NIL_SENTINEL.pushKey(L);
+                lua_replace(L, i);
+            }
+        }
+        else
+        {
+            if (NIL_SENTINEL.equals(L, i))
+            {
+                lua_pushnil(L);
+                lua_replace(L, i);
+            }
+        }
+    }
+}
+
+// ##################################################################################################
+
+/*
+* Call a function ('func_name') in the keeper state, and pass on the returned
+* values to 'L'.
+*
+* 'linda':          deep Linda pointer (used only as a unique table key, first parameter)
+* 'starting_index': first of the rest of parameters (none if 0)
+*
+* Returns: number of return values (pushed to 'L') or -1 in case of error
+*/
+int keeper_call(Universe* U, lua_State* K, keeper_api_t func_, lua_State* L, void* linda, int starting_index)
+{
+    int const args{ starting_index ? (lua_gettop(L) - starting_index + 1) : 0 };
+    int const Ktos{ lua_gettop(K) };
+    int retvals = -1;
+
+    STACK_GROW(K, 2);
+
+    PUSH_KEEPER_FUNC(K, func_);
+
+    lua_pushlightuserdata(K, linda);
+
+    if ((args == 0) || luaG_inter_copy(U, Source{ L }, Dest{ K }, args, LookupMode::ToKeeper) == InterCopyResult::Success) // L->K
+    {
+        lua_call(K, 1 + args, LUA_MULTRET);
+        retvals = lua_gettop(K) - Ktos;
+        // note that this can raise a luaL_error while the keeper state (and its mutex) is acquired
+        // this may interrupt a lane, causing the destruction of the underlying OS thread
+        // after this, another lane making use of this keeper can get an error code from the mutex-locking function
+        // when attempting to grab the mutex again (WINVER <= 0x400 does this, but locks just fine, I don't know about pthread)
+        if ((retvals > 0) && luaG_inter_move(U, Source{ K }, Dest{ L }, retvals, LookupMode::FromKeeper) != InterCopyResult::Success) // K->L
+        {
+            retvals = -1;
+        }
+    }
+    // whatever happens, restore the stack to where it was at the origin
+    lua_settop(K, Ktos);
+
+    // don't do this for this particular function, as it is only called during Linda destruction, and we don't want to raise an error, ever
+    if (func_ != KEEPER_API(clear)) [[unlikely]]
+    {
+        // since keeper state GC is stopped, let's run a step once in a while if required
+        int const gc_threshold{ U->keepers->gc_threshold };
+        if (gc_threshold == 0) [[unlikely]]
+        {
+            lua_gc(K, LUA_GCSTEP, 0);
+        }
+        else if (gc_threshold > 0) [[likely]]
+        {
+            int const gc_usage{ lua_gc(K, LUA_GCCOUNT, 0) };
+            if (gc_usage >= gc_threshold)
+            {
+                lua_gc(K, LUA_GCCOLLECT, 0);
+                int const gc_usage_after{ lua_gc(K, LUA_GCCOUNT, 0) };
+                if (gc_usage_after > gc_threshold) [[unlikely]]
+                {
+                    luaL_error(L, "Keeper GC threshold is too low, need at least %d", gc_usage_after);
+                }
+            }
+        }
+    }
+
+    return retvals;
+}
diff --git a/src/keeper.h b/src/keeper.h
index 7c55809..627c7ea 100644
--- a/src/keeper.h
+++ b/src/keeper.h
@@ -1,58 +1,60 @@
-#if !defined( __keeper_h__)
-#define __keeper_h__ 1
+#pragma once
 
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
 #include "lua.h"
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
 #include "threading.h"
 #include "uniquekey.h"
 
+#include <mutex>
+
 // forwards
-struct s_Universe;
-typedef struct s_Universe Universe;
-enum eLookupMode;
-typedef enum eLookupMode LookupMode;
+enum class LookupMode;
+class Universe;
 
-struct s_Keeper
+struct Keeper
 {
-    MUTEX_T keeper_cs;
-    lua_State* L;
-    //int count;
+    std::mutex m_mutex;
+    lua_State* L{ nullptr };
+    // int count;
 };
-typedef struct s_Keeper Keeper;
 
-struct s_Keepers
+struct Keepers
 {
-    int gc_threshold;
-    int nb_keepers;
+    int gc_threshold{ 0 };
+    int nb_keepers{ 0 };
     Keeper keeper_array[1];
 };
-typedef struct s_Keepers Keepers;
 
-void init_keepers( Universe* U, lua_State* L);
-void close_keepers( Universe* U);
+static constexpr uintptr_t KEEPER_MAGIC_SHIFT{ 3 };
+// crc64/we of string "NIL_SENTINEL" generated at http://www.nitrxgen.net/hashgen/
+static constexpr UniqueKey NIL_SENTINEL{ 0x7eaafa003a1d11a1ull };
 
-Keeper* which_keeper( Keepers* keepers_, uintptr_t magic_);
-Keeper* keeper_acquire( Keepers* keepers_, uintptr_t magic_);
-#define KEEPER_MAGIC_SHIFT 3
-void keeper_release( Keeper* K_);
-void keeper_toggle_nil_sentinels( lua_State* L, int val_i_, LookupMode const mode_);
-int keeper_push_linda_storage( Universe* U, lua_State* L, void* ptr_, uintptr_t magic_);
+void init_keepers(Universe* U, lua_State* L);
+void close_keepers(Universe* U);
 
-// crc64/we of string "NIL_SENTINEL" generated at http://www.nitrxgen.net/hashgen/
-static DECLARE_CONST_UNIQUE_KEY( NIL_SENTINEL, 0x7eaafa003a1d11a1);
+[[nodiscard]] Keeper* which_keeper(Keepers* keepers_, uintptr_t magic_);
+[[nodiscard]] Keeper* keeper_acquire(Keepers* keepers_, uintptr_t magic_);
+void keeper_release(Keeper* K_);
+void keeper_toggle_nil_sentinels(lua_State* L, int val_i_, LookupMode const mode_);
+[[nodiscard]] int keeper_push_linda_storage(Universe* U, Dest L, void* ptr_, uintptr_t magic_);
 
-typedef lua_CFunction keeper_api_t;
-#define KEEPER_API( _op) keepercall_ ## _op
+using keeper_api_t = lua_CFunction;
+#define KEEPER_API(_op) keepercall_##_op
 #define PUSH_KEEPER_FUNC lua_pushcfunction
-// lua_Cfunctions to run inside a keeper state (formerly implemented in Lua)
-int keepercall_clear( lua_State* L);
-int keepercall_send( lua_State* L);
-int keepercall_receive( lua_State* L);
-int keepercall_receive_batched( lua_State* L);
-int keepercall_limit( lua_State* L);
-int keepercall_get( lua_State* L);
-int keepercall_set( lua_State* L);
-int keepercall_count( lua_State* L);
-
-int keeper_call( Universe* U, lua_State* K, keeper_api_t _func, lua_State* L, void* linda, uint_t starting_index);
-
-#endif // __keeper_h__
\ No newline at end of file
+// lua_Cfunctions to run inside a keeper state
+[[nodiscard]] int keepercall_clear(lua_State* L);
+[[nodiscard]] int keepercall_send(lua_State* L);
+[[nodiscard]] int keepercall_receive(lua_State* L);
+[[nodiscard]] int keepercall_receive_batched(lua_State* L);
+[[nodiscard]] int keepercall_limit(lua_State* L);
+[[nodiscard]] int keepercall_get(lua_State* L);
+[[nodiscard]] int keepercall_set(lua_State* L);
+[[nodiscard]] int keepercall_count(lua_State* L);
+
+[[nodiscard]] int keeper_call(Universe* U, lua_State* K, keeper_api_t _func, lua_State* L, void* linda, int starting_index);
diff --git a/src/lanes.c b/src/lanes.c
deleted file mode 100644
index ca2b53a..0000000
--- a/src/lanes.c
+++ /dev/null
@@ -1,2147 +0,0 @@
-/*
- * LANES.C                              Copyright (c) 2007-08, Asko Kauppi
- *                                      Copyright (C) 2009-19, Benoit Germain
- *
- * Multithreading in Lua.
- * 
- * History:
- *      See CHANGES
- *
- * Platforms (tested internally):
- *      OS X (10.5.7 PowerPC/Intel)
- *      Linux x86 (Ubuntu 8.04)
- *      Win32 (Windows XP Home SP2, Visual C++ 2005/2008 Express)
- *
- * Platforms (tested externally):
- *      Win32 (MSYS) by Ross Berteig.
- *
- * Platforms (testers appreciated):
- *      Win64 - should work???
- *      Linux x64 - should work
- *      FreeBSD - should work
- *      QNX - porting shouldn't be hard
- *      Sun Solaris - porting shouldn't be hard
- *
- * References:
- *      "Porting multithreaded applications from Win32 to Mac OS X":
- *      <http://developer.apple.com/macosx/multithreadedprogramming.html>
- *
- *      Pthreads:
- *      <http://vergil.chemistry.gatech.edu/resources/programming/threads.html>
- *
- *      MSDN: <http://msdn2.microsoft.com/en-us/library/ms686679.aspx>
- *
- *      <http://ridiculousfish.com/blog/archives/2007/02/17/barrier>
- *
- * Defines:
- *      -DLINUX_SCHED_RR: all threads are lifted to SCHED_RR category, to
- *          allow negative priorities [-3,-1] be used. Even without this,
- *          using priorities will require 'sudo' privileges on Linux.
- *
- *      -DUSE_PTHREAD_TIMEDJOIN: use 'pthread_timedjoin_np()' for waiting
- *          for threads with a timeout. This changes the thread cleanup
- *          mechanism slightly (cleans up at the join, not once the thread
- *          has finished). May or may not be a good idea to use it.
- *          Available only in selected operating systems (Linux).
- *
- * Bugs:
- *
- * To-do:
- *
- * Make waiting threads cancellable.
- *      ...
- */
-
-/*
-===============================================================================
-
-Copyright (C) 2007-10 Asko Kauppi <akauppi@gmail.com>
-              2011-19 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
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-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"
-
-#if !(defined( PLATFORM_XBOX) || defined( PLATFORM_WIN32) || defined( PLATFORM_POCKETPC))
-# include <sys/time.h>
-#endif
-
-/* geteuid() */
-#ifdef PLATFORM_LINUX
-# include <unistd.h>
-# include <sys/types.h>
-#endif
-
-/* Do you want full call stacks, or just the line where the error happened?
-*
-* TBD: The full stack feature does not seem to work (try 'make error').
-*/
-#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* s)
-{
-    STACK_CHECK( L, 0);
-    STACK_GROW( L, 3);
-    lua_getiuservalue( L, 1, 1);
-    lua_newtable( L);
-    // Lua 5.1 can't do 's->debug_name = lua_pushstring( L, s->debug_name);'
-    lua_pushstring( L, s->debug_name);
-    s->debug_name = lua_tostring( L, -1);
-    lua_rawset( L, -3);
-    lua_pop( L, 1);
-    STACK_END( L, 0);
-}
-
-#if ERROR_FULL_STACK
-static int lane_error( lua_State* L);
-// crc64/we of string "STACKTRACE_REGKEY" generated at http://www.nitrxgen.net/hashgen/
-static DECLARE_CONST_UNIQUE_KEY( STACKTRACE_REGKEY, 0x534af7d3226a429f);
-#endif // ERROR_FULL_STACK
-
-/*
-* registry[FINALIZER_REG_KEY] is either nil (no finalizers) or a table
-* of functions that Lanes will call after the executing 'pcall' has ended.
-*
-* We're NOT using the GC system for finalizer mainly because providing the
-* error (and maybe stack trace) parameters to the finalizer functions would
-* anyways complicate that approach.
-*/
-// crc64/we of string "FINALIZER_REGKEY" generated at http://www.nitrxgen.net/hashgen/
-static DECLARE_CONST_UNIQUE_KEY( FINALIZER_REGKEY, 0x188fccb8bf348e09);
-
-struct s_Linda;
-
-/*
-* Push a table stored in registry onto Lua stack.
-*
-* If there is no existing table, create one if 'create' is TRUE.
-* 
-* Returns: TRUE if a table was pushed
-*          FALSE if no table found, not created, and nothing pushed
-*/
-static bool_t push_registry_table( lua_State* L, UniqueKey key, bool_t create)
-{
-    STACK_GROW( L, 3);
-    STACK_CHECK( L, 0);
-
-    REGISTRY_GET( L, key);                                                       // ?
-    if( lua_isnil( L, -1))                                                       // nil?
-    {
-        lua_pop( L, 1);                                                            //
-
-        if( !create)
-        {
-            return FALSE;
-        }
-
-        lua_newtable( L);                                                          // t
-        REGISTRY_SET( L, key, lua_pushvalue( L, -2));
-    }
-    STACK_END( L, 1);
-    return TRUE;    // table pushed
-}
-
-#if HAVE_LANE_TRACKING()
-
-// The chain is ended by '(Lane*)(-1)', not NULL:
-// 'tracking_first -> ... -> ... -> (-1)'
-#define TRACKING_END ((Lane *)(-1))
-
-/*
- * Add the lane to tracking chain; the ones still running at the end of the
- * whole process will be cancelled.
- */
-static void tracking_add( Lane* s)
-{
-
-    MUTEX_LOCK( &s->U->tracking_cs);
-    {
-        assert( s->tracking_next == NULL);
-
-        s->tracking_next = s->U->tracking_first;
-        s->U->tracking_first = s;
-    }
-    MUTEX_UNLOCK( &s->U->tracking_cs);
-}
-
-/*
- * A free-running lane has ended; remove it from tracking chain
- */
-static bool_t tracking_remove( Lane* s)
-{
-    bool_t found = FALSE;
-    MUTEX_LOCK( &s->U->tracking_cs);
-    {
-        // Make sure (within the MUTEX) that we actually are in the chain
-        // still (at process exit they will remove us from chain and then
-        // cancel/kill).
-        //
-        if( s->tracking_next != NULL)
-        {
-            Lane** ref = (Lane**) &s->U->tracking_first;
-
-            while( *ref != TRACKING_END)
-            {
-                if( *ref == s)
-                {
-                    *ref = s->tracking_next;
-                    s->tracking_next = NULL;
-                    found = TRUE;
-                    break;
-                }
-                ref = (Lane**) &((*ref)->tracking_next);
-            }
-            assert( found);
-        }
-    }
-    MUTEX_UNLOCK( &s->U->tracking_cs);
-    return found;
-}
-
-#endif // HAVE_LANE_TRACKING()
-
-//---
-// low-level cleanup
-
-static void lane_cleanup( Lane* s)
-{
-    // Clean up after a (finished) thread
-    //
-#if THREADWAIT_METHOD == THREADWAIT_CONDVAR
-    SIGNAL_FREE( &s->done_signal);
-    MUTEX_FREE( &s->done_lock);
-#endif // THREADWAIT_METHOD == THREADWAIT_CONDVAR
-
-#if HAVE_LANE_TRACKING()
-    if( s->U->tracking_first != NULL)
-    {
-        // Lane was cleaned up, no need to handle at process termination
-        tracking_remove( s);
-    }
-#endif // HAVE_LANE_TRACKING()
-
-    {
-        AllocatorDefinition* const allocD = &s->U->internal_allocator;
-        (void) allocD->allocF(allocD->allocUD, s, sizeof(Lane), 0);
-    }
-}
-
-/*
- * ###############################################################################################
- * ########################################## Finalizer ##########################################
- * ###############################################################################################
- */
-
-//---
-// void= finalizer( finalizer_func )
-//
-// finalizer_func( [err, stack_tbl] )
-//
-// Add a function that will be called when exiting the lane, either via
-// normal return or an error.
-//
-LUAG_FUNC( set_finalizer)
-{
-    luaL_argcheck( L, lua_isfunction( L, 1), 1, "finalizer should be a function");
-    luaL_argcheck( L, lua_gettop( L) == 1, 1, "too many arguments");
-    // Get the current finalizer table (if any)
-    push_registry_table( L, FINALIZER_REGKEY, TRUE /*do create if none*/);      // finalizer {finalisers}
-    STACK_GROW( L, 2);
-    lua_pushinteger( L, lua_rawlen( L, -1) + 1);                                 // finalizer {finalisers} idx
-    lua_pushvalue( L, 1);                                                        // finalizer {finalisers} idx finalizer
-    lua_rawset( L, -3);                                                          // finalizer {finalisers}
-    lua_pop( L, 2);                                                              //
-    return 0;
-}
-
-
-//---
-// Run finalizers - if any - with the given parameters
-//
-// If 'rc' is nonzero, error message and stack index (the latter only when ERROR_FULL_STACK == 1) are available as:
-//      [-1]: stack trace (table)
-//      [-2]: error message (any type)
-//
-// Returns:
-//      0 if finalizers were run without error (or there were none)
-//      LUA_ERRxxx return code if any of the finalizers failed
-//
-// TBD: should we add stack trace on failing finalizer, wouldn't be hard..
-//
-static void push_stack_trace( lua_State* L, int rc_, int stk_base_);
-
-static int run_finalizers( lua_State* L, int lua_rc)
-{
-    int finalizers_index;
-    int n;
-    int err_handler_index = 0;
-    int rc = LUA_OK;                                                                // ...
-    if( !push_registry_table( L, FINALIZER_REGKEY, FALSE))                          // ... finalizers?
-    {
-        return 0;   // no finalizers
-    }
-
-    STACK_GROW( L, 5);
-
-    finalizers_index = lua_gettop( L);
-
-#if ERROR_FULL_STACK
-    lua_pushcfunction( L, lane_error);                                              // ... finalizers lane_error
-    err_handler_index = lua_gettop( L);
-#endif // ERROR_FULL_STACK
-
-    for( n = (int) lua_rawlen( L, finalizers_index); n > 0; -- n)
-    {
-        int args = 0;
-        lua_pushinteger( L, n);                                                       // ... finalizers lane_error n
-        lua_rawget( L, finalizers_index);                                             // ... finalizers lane_error finalizer
-        ASSERT_L( lua_isfunction( L, -1));
-        if( lua_rc != LUA_OK) // we have an error message and an optional stack trace at the bottom of the stack
-        {
-            ASSERT_L( finalizers_index == 2 || finalizers_index == 3);
-            //char const* err_msg = lua_tostring( L, 1);
-            lua_pushvalue( L, 1);                                                       // ... finalizers lane_error finalizer err_msg
-            // note we don't always have a stack trace for example when CANCEL_ERROR, or when we got an error that doesn't call our handler, such as LUA_ERRMEM
-            if( finalizers_index == 3)
-            {
-                lua_pushvalue( L, 2);                                                     // ... finalizers lane_error finalizer err_msg stack_trace
-            }
-            args = finalizers_index - 1;
-        }
-
-        // if no error from the main body, finalizer doesn't receive any argument, else it gets the error message and optional stack trace
-        rc = lua_pcall( L, args, 0, err_handler_index);                               // ... finalizers lane_error err_msg2?
-        if( rc != LUA_OK)
-        {
-            push_stack_trace( L, rc, lua_gettop( L));
-            // If one finalizer fails, don't run the others. Return this
-            // as the 'real' error, replacing what we could have had (or not)
-            // from the actual code.
-            break;
-        }
-        // no error, proceed to next finalizer                                        // ... finalizers lane_error
-    }
-
-    if( rc != LUA_OK)
-    {
-        // ERROR_FULL_STACK accounts for the presence of lane_error on the stack
-        int nb_err_slots = lua_gettop( L) - finalizers_index - ERROR_FULL_STACK;
-        // a finalizer generated an error, this is what we leave of the stack
-        for( n = nb_err_slots; n > 0; -- n)
-        {
-            lua_replace( L, n);
-        }
-        // leave on the stack only the error and optional stack trace produced by the error in the finalizer
-        lua_settop( L, nb_err_slots);
-    }
-    else // no error from the finalizers, make sure only the original return values from the lane body remain on the stack
-    {
-        lua_settop( L, finalizers_index - 1);
-    }
-
-    return rc;
-}
-
-/*
- * ###############################################################################################
- * ########################################### Threads ###########################################
- * ###############################################################################################
- */
-
-//
-// Protects modifying the selfdestruct chain
-
-#define SELFDESTRUCT_END ((Lane*)(-1))
-//
-// The chain is ended by '(Lane*)(-1)', not NULL:
-//      'selfdestruct_first -> ... -> ... -> (-1)'
-
-/*
- * Add the lane to selfdestruct chain; the ones still running at the end of the
- * whole process will be cancelled.
- */
-static void selfdestruct_add( Lane* s)
-{
-    MUTEX_LOCK( &s->U->selfdestruct_cs);
-    assert( s->selfdestruct_next == NULL);
-
-    s->selfdestruct_next = s->U->selfdestruct_first;
-    s->U->selfdestruct_first= s;
-    MUTEX_UNLOCK( &s->U->selfdestruct_cs);
-}
-
-/*
- * A free-running lane has ended; remove it from selfdestruct chain
- */
-static bool_t selfdestruct_remove( Lane* s)
-{
-    bool_t found = FALSE;
-    MUTEX_LOCK( &s->U->selfdestruct_cs);
-    {
-        // Make sure (within the MUTEX) that we actually are in the chain
-        // still (at process exit they will remove us from chain and then
-        // cancel/kill).
-        //
-        if( s->selfdestruct_next != NULL)
-        {
-            Lane** ref = (Lane**) &s->U->selfdestruct_first;
-
-            while( *ref != SELFDESTRUCT_END )
-            {
-                if( *ref == s)
-                {
-                    *ref = s->selfdestruct_next;
-                    s->selfdestruct_next = NULL;
-                    // the terminal shutdown should wait until the lane is done with its lua_close()
-                    ++ s->U->selfdestructing_count;
-                    found = TRUE;
-                    break;
-                }
-                ref = (Lane**) &((*ref)->selfdestruct_next);
-            }
-            assert( found);
-        }
-    }
-    MUTEX_UNLOCK( &s->U->selfdestruct_cs);
-    return found;
-}
-
-/*
-* Process end; cancel any still free-running threads
-*/
-static int universe_gc( lua_State* L)
-{
-    Universe* U = (Universe*) lua_touserdata( L, 1);
-
-    while( U->selfdestruct_first != SELFDESTRUCT_END) // true at most once!
-    {
-        // Signal _all_ still running threads to exit (including the timer thread)
-        //
-        MUTEX_LOCK( &U->selfdestruct_cs);
-        {
-            Lane* s = U->selfdestruct_first;
-            while( s != SELFDESTRUCT_END)
-            {
-                // attempt a regular unforced hard cancel with a small timeout
-                bool_t cancelled = THREAD_ISNULL( s->thread) || (thread_cancel( L, s, CO_Hard, 0.0001, FALSE, 0.0) != CR_Timeout);
-                // if we failed, and we know the thread is waiting on a linda
-                if( cancelled == FALSE && s->status == WAITING && s->waiting_on != NULL)
-                {
-                    // signal the linda to wake up the thread so that it can react to the cancel query
-                    // let us hope we never land here with a pointer on a linda that has been destroyed...
-                    SIGNAL_T* waiting_on = s->waiting_on;
-                    //s->waiting_on = NULL; // useful, or not?
-                    SIGNAL_ALL( waiting_on);
-                }
-                s = s->selfdestruct_next;
-            }
-        }
-        MUTEX_UNLOCK( &U->selfdestruct_cs);
-
-        // When noticing their cancel, the lanes will remove themselves from
-        // the selfdestruct chain.
-
-        // TBD: Not sure if Windows (multi core) will require the timed approach,
-        //      or single Yield. I don't have machine to test that (so leaving
-        //      for timed approach).    -- AKa 25-Oct-2008
-
-        // OS X 10.5 (Intel) needs more to avoid segfaults.
-        //
-        // "make test" is okay. 100's of "make require" are okay.
-        //
-        // Tested on MacBook Core Duo 2GHz and 10.5.5:
-        //  -- AKa 25-Oct-2008
-        //
-        {
-            lua_Number const shutdown_timeout = lua_tonumber( L, lua_upvalueindex( 1));
-            double const t_until = now_secs() + shutdown_timeout;
-
-            while( U->selfdestruct_first != SELFDESTRUCT_END)
-            {
-                YIELD();    // give threads time to act on their cancel
-                {
-                    // count the number of cancelled thread that didn't have the time to act yet
-                    int n = 0;
-                    double t_now = 0.0;
-                    MUTEX_LOCK( &U->selfdestruct_cs);
-                    {
-                        Lane* s = U->selfdestruct_first;
-                        while( s != SELFDESTRUCT_END)
-                        {
-                            if( s->cancel_request == CANCEL_HARD)
-                                ++ n;
-                            s = s->selfdestruct_next;
-                        }
-                    }
-                    MUTEX_UNLOCK( &U->selfdestruct_cs);
-                    // if timeout elapsed, or we know all threads have acted, stop waiting
-                    t_now = now_secs();
-                    if( n == 0 || (t_now >= t_until))
-                    {
-                        DEBUGSPEW_CODE( fprintf( stderr, "%d uncancelled lane(s) remain after waiting %fs at process end.\n", n, shutdown_timeout - (t_until - t_now)));
-                        break;
-                    }
-                }
-            }
-        }
-
-        // If some lanes are currently cleaning after themselves, wait until they are done.
-        // They are no longer listed in the selfdestruct chain, but they still have to lua_close().
-        while( U->selfdestructing_count > 0)
-        {
-            YIELD();
-        }
-
-        //---
-        // Kill the still free running threads
-        //
-        if( U->selfdestruct_first != SELFDESTRUCT_END)
-        {
-            unsigned int n = 0;
-            // first thing we did was to raise the linda signals the threads were waiting on (if any)
-            // therefore, any well-behaved thread should be in CANCELLED state
-            // these are not running, and the state can be closed
-            MUTEX_LOCK( &U->selfdestruct_cs);
-            {
-                Lane* s = U->selfdestruct_first;
-                while( s != SELFDESTRUCT_END)
-                {
-                    Lane* next_s = s->selfdestruct_next;
-                    s->selfdestruct_next = NULL;     // detach from selfdestruct chain
-                    if( !THREAD_ISNULL( s->thread)) // can be NULL if previous 'soft' termination succeeded
-                    {
-                        THREAD_KILL( &s->thread);
-#if THREADAPI == THREADAPI_PTHREAD
-                        // pthread: make sure the thread is really stopped!
-                        THREAD_WAIT( &s->thread, -1, &s->done_signal, &s->done_lock, &s->status);
-#endif // THREADAPI == THREADAPI_PTHREAD
-                    }
-                    // NO lua_close() in this case because we don't know where execution of the state was interrupted
-                    lane_cleanup( s);
-                    s = next_s;
-                    ++ n;
-                }
-                U->selfdestruct_first = SELFDESTRUCT_END;
-            }
-            MUTEX_UNLOCK( &U->selfdestruct_cs);
-
-            DEBUGSPEW_CODE( fprintf( stderr, "Killed %d lane(s) at process end.\n", n));
-        }
-    }
-
-    // If some lanes are currently cleaning after themselves, wait until they are done.
-    // They are no longer listed in the selfdestruct chain, but they still have to lua_close().
-    while( U->selfdestructing_count > 0)
-    {
-        YIELD();
-    }
-
-    // necessary so that calling free_deep_prelude doesn't crash because linda_id expects a linda lightuserdata at absolute slot 1
-    lua_settop( L, 0);
-    // no need to mutex-protect this as all threads in the universe are gone at that point
-    if( U->timer_deep != NULL) // test ins case some early internal error prevented Lanes from creating the deep timer
-    {
-        -- U->timer_deep->refcount; // should be 0 now
-        free_deep_prelude( L, (DeepPrelude*) U->timer_deep);
-        U->timer_deep = NULL;
-    }
-
-    close_keepers( U);
-
-    // remove the protected allocator, if any
-    cleanup_allocator_function( U, L);
-
-#if HAVE_LANE_TRACKING()
-    MUTEX_FREE( &U->tracking_cs);
-#endif // HAVE_LANE_TRACKING()
-    // Linked chains handling
-    MUTEX_FREE( &U->selfdestruct_cs);
-    MUTEX_FREE( &U->require_cs);
-    // Locks for 'tools.c' inc/dec counters
-    MUTEX_FREE( &U->deep_lock);
-    MUTEX_FREE( &U->mtid_lock);
-    // universe is no longer available (nor necessary)
-    // we need to do this in case some deep userdata objects were created before Lanes was initialized,
-    // as potentially they will be garbage collected after Lanes at application shutdown
-    universe_store( L, NULL);
-    return 0;
-}
-
-
-//---
-// = _single( [cores_uint=1] )
-//
-// Limits the process to use only 'cores' CPU cores. To be used for performance
-// testing on multicore devices. DEBUGGING ONLY!
-//
-LUAG_FUNC( set_singlethreaded)
-{
-    lua_Integer cores = luaG_optunsigned( L, 1, 1);
-    (void) cores; // prevent "unused" warning
-
-#ifdef PLATFORM_OSX
-#ifdef _UTILBINDTHREADTOCPU
-    if( cores > 1)
-    {
-        return luaL_error( L, "Limiting to N>1 cores not possible");
-    }
-    // requires 'chudInitialize()'
-    utilBindThreadToCPU(0);     // # of CPU to run on (we cannot limit to 2..N CPUs?)
-    return 0;
-#else
-    return luaL_error( L, "Not available: compile with _UTILBINDTHREADTOCPU");
-#endif
-#else
-    return luaL_error( L, "not implemented");
-#endif
-}
-
-
-/*
-* str= lane_error( error_val|str )
-*
-* Called if there's an error in some lane; add call stack to error message 
-* just like 'lua.c' normally does.
-*
-* ".. will be called with the error message and its return value will be the 
-*     message returned on the stack by lua_pcall."
-*
-* Note: Rather than modifying the error message itself, it would be better
-*     to provide the call stack (as string) completely separated. This would
-*     work great with non-string error values as well (current system does not).
-*     (This is NOT possible with the Lua 5.1 'lua_pcall()'; we could of course
-*     implement a Lanes-specific 'pcall' of our own that does this). TBD!!! :)
-*       --AKa 22-Jan-2009
-*/
-#if ERROR_FULL_STACK
-
-// crc64/we of string "EXTENDED_STACKTRACE_REGKEY" generated at http://www.nitrxgen.net/hashgen/
-static DECLARE_CONST_UNIQUE_KEY( EXTENDED_STACKTRACE_REGKEY, 0x2357c69a7c92c936); // used as registry key
-
-LUAG_FUNC( set_error_reporting)
-{
-    luaL_checktype(L, 1, LUA_TSTRING);
-    char const* mode = lua_tostring(L, 1);
-    bool_t const extended = (strcmp(mode, "extended") == 0);
-    bool_t const basic = (strcmp(mode, "basic") == 0);
-    if (!extended && !basic)
-    {
-        return luaL_error(L, "unsupported error reporting model %s", mode);
-    }
-
-    REGISTRY_SET( L, EXTENDED_STACKTRACE_REGKEY, lua_pushboolean( L, extended ? 1 : 0));
-    return 0;
-}
-
-static int lane_error( lua_State* L)
-{
-    lua_Debug ar;
-    int n;
-    bool_t extended;
-
-    // error message (any type)
-    STACK_CHECK_ABS( L, 1);                                                         // some_error
-
-    // Don't do stack survey for cancelled lanes.
-    //
-    if( equal_unique_key( L, 1, CANCEL_ERROR))
-    {
-        return 1;   // just pass on
-    }
-
-    STACK_GROW( L, 3);
-    REGISTRY_GET( L, EXTENDED_STACKTRACE_REGKEY);                                   // some_error basic|extended
-    extended = lua_toboolean( L, -1);
-    lua_pop( L, 1);                                                                 // some_error
-
-    // Place stack trace at 'registry[lane_error]' for the 'lua_pcall()'
-    // caller to fetch. This bypasses the Lua 5.1 limitation of only one
-    // return value from error handler to 'lua_pcall()' caller.
-
-    // It's adequate to push stack trace as a table. This gives the receiver
-    // of the stack best means to format it to their liking. Also, it allows
-    // us to add more stack info later, if needed.
-    //
-    // table of { "sourcefile.lua:<line>", ... }
-    //
-    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
-    // and table index growing separate.    --AKa 22-Jan-2009
-    //
-    for( n = 1; lua_getstack( L, n, &ar); ++ n)
-    {
-        lua_getinfo( L, extended ? "Sln" : "Sl", &ar);
-        if( extended)
-        {
-            lua_newtable( L);                                                           // some_error {} {}
-
-            lua_pushstring( L, ar.source);                                              // some_error {} {} source
-            lua_setfield( L, -2, "source");                                             // some_error {} {}
-
-            lua_pushinteger( L, ar.currentline);                                        // some_error {} {} currentline
-            lua_setfield( L, -2, "currentline");                                        // some_error {} {}
-
-            lua_pushstring( L, ar.name);                                                // some_error {} {} name
-            lua_setfield( L, -2, "name");                                               // some_error {} {}
-
-            lua_pushstring( L, ar.namewhat);                                            // some_error {} {} namewhat
-            lua_setfield( L, -2, "namewhat");                                           // some_error {} {}
-
-            lua_pushstring( L, ar.what);                                                // some_error {} {} what
-            lua_setfield( L, -2, "what");                                               // some_error {} {}
-        }
-        else if( ar.currentline > 0)
-        {
-            lua_pushfstring( L, "%s:%d", ar.short_src, ar.currentline);                 // some_error {} "blah:blah"
-        }
-        else
-        {
-            lua_pushfstring( L, "%s:?", ar.short_src);                                  // some_error {} "blah"
-        }
-        lua_rawseti( L, -2, (lua_Integer) n);                                         // some_error {}
-    }
-
-    REGISTRY_SET( L, STACKTRACE_REGKEY, lua_insert( L, -2));                        // some_error
-
-    STACK_END( L, 1);
-    return 1;   // the untouched error value
-}
-#endif // ERROR_FULL_STACK
-
-static void push_stack_trace( lua_State* L, int rc_, int stk_base_)
-{
-    // Lua 5.1 error handler is limited to one return value; it stored the stack trace in the registry
-    switch( rc_)
-    {
-        case LUA_OK: // no error, body return values are on the stack
-        break;
-
-        case LUA_ERRRUN: // cancellation or a runtime error
-#if ERROR_FULL_STACK // when ERROR_FULL_STACK, we installed a handler
-        {
-            STACK_CHECK( L, 0);
-            // 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)
-            REGISTRY_GET( L, STACKTRACE_REGKEY);                                       // err trace|nil
-            STACK_END( L, 1);
-
-            // For cancellation the error message is CANCEL_ERROR, and a stack trace isn't placed
-            // For other errors, the message can be whatever was thrown, and we should have a stack trace table
-            ASSERT_L( lua_type( L, 1 + stk_base_) == (equal_unique_key( L, stk_base_, CANCEL_ERROR) ? LUA_TNIL : LUA_TTABLE));
-            // Just leaving the stack trace table on the stack is enough to get it through to the master.
-            break;
-        }
-#endif // fall through if not ERROR_FULL_STACK
-
-        case LUA_ERRMEM: // memory allocation error (handler not called)
-        case LUA_ERRERR: // error while running the error handler (if any, for example an out-of-memory condition)
-        default:
-        // we should have a single value which is either a string (the error message) or CANCEL_ERROR
-        ASSERT_L( (lua_gettop( L) == stk_base_) && ((lua_type( L, stk_base_) == LUA_TSTRING) || equal_unique_key( L, stk_base_, CANCEL_ERROR)));
-        break;
-    }
-}
-
-LUAG_FUNC( set_debug_threadname)
-{
-    // fnv164 of string "debug_threadname" generated at https://www.pelock.com/products/hash-calculator
-    static DECLARE_CONST_UNIQUE_KEY( hidden_regkey, 0x79C0669AAAE04440);
-    // C s_lane structure is a light userdata upvalue
-    Lane* s = lua_touserdata( L, lua_upvalueindex( 1));
-    luaL_checktype( L, -1, LUA_TSTRING);                           // "name"
-    lua_settop( L, 1);
-    STACK_CHECK_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...
-    REGISTRY_SET( L, hidden_regkey, lua_pushvalue( L, -2));
-    STACK_MID( L, 1);
-    s->debug_name = lua_tostring( L, -1);
-    // keep a direct pointer on the string
-    THREAD_SETNAME( s->debug_name);
-    // to see VM name in Decoda debugger Virtual Machine window
-    lua_setglobal( L, "decoda_name");                              //
-    STACK_END( L, 0);
-    return 0;
-}
-
-LUAG_FUNC( get_debug_threadname)
-{
-    Lane* const s = lua_toLane( L, 1);
-    luaL_argcheck( L, lua_gettop( L) == 1, 2, "too many arguments");
-    lua_pushstring( L, s->debug_name);
-    return 1;
-}
-
-LUAG_FUNC( set_thread_priority)
-{
-    int const prio = (int) luaL_checkinteger( L, 1);
-    // public Lanes API accepts a generic range -3/+3
-    // that will be remapped into the platform-specific scheduler priority scheme
-    // On some platforms, -3 is equivalent to -2 and +3 to +2
-    if( prio < THREAD_PRIO_MIN || prio > THREAD_PRIO_MAX)
-    {
-        return luaL_error( L, "priority out of range: %d..+%d (%d)", THREAD_PRIO_MIN, THREAD_PRIO_MAX, prio);
-    }
-    THREAD_SET_PRIORITY( prio);
-    return 0;
-}
-
-LUAG_FUNC( set_thread_affinity)
-{
-    lua_Integer affinity = luaL_checkinteger( L, 1);
-    if( affinity <= 0)
-    {
-        return luaL_error( L, "invalid affinity (%d)", affinity);
-    }
-    THREAD_SET_AFFINITY( (unsigned int) affinity);
-    return 0;
-}
-
-#if USE_DEBUG_SPEW()
-// can't use direct LUA_x errcode indexing because the sequence is not the same between Lua 5.1 and 5.2 :-(
-// LUA_ERRERR doesn't have the same value
-struct errcode_name
-{
-    int code;
-    char const* name;
-};
-
-static struct errcode_name s_errcodes[] =
-{
-    { LUA_OK, "LUA_OK"},
-    { LUA_YIELD, "LUA_YIELD"},
-    { LUA_ERRRUN, "LUA_ERRRUN"},
-    { LUA_ERRSYNTAX, "LUA_ERRSYNTAX"},
-    { LUA_ERRMEM, "LUA_ERRMEM"},
-    { LUA_ERRGCMM, "LUA_ERRGCMM"},
-    { LUA_ERRERR, "LUA_ERRERR"},
-};
-static char const* get_errcode_name( int _code)
-{
-    int i;
-    for( i = 0; i < 7; ++ i)
-    {
-        if( s_errcodes[i].code == _code)
-        {
-            return s_errcodes[i].name;
-        }
-    }
-    return "<NULL>";
-}
-#endif // USE_DEBUG_SPEW()
-
-#if THREADWAIT_METHOD == THREADWAIT_CONDVAR // implies THREADAPI == THREADAPI_PTHREAD
-static void thread_cleanup_handler( void* opaque)
-{
-    Lane* s= (Lane*) opaque;
-    MUTEX_LOCK( &s->done_lock);
-    s->status = CANCELLED;
-    SIGNAL_ONE( &s->done_signal);   // wake up master (while 's->done_lock' is on)
-    MUTEX_UNLOCK( &s->done_lock);
-}
-#endif // THREADWAIT_METHOD == THREADWAIT_CONDVAR
-
-static THREAD_RETURN_T THREAD_CALLCONV lane_main( void* vs)
-{
-    Lane* s = (Lane*) vs;
-    int rc, rc2;
-    lua_State* L = s->L;
-    // Called with the lane function and arguments on the stack
-    int const nargs = lua_gettop( L) - 1;
-    DEBUGSPEW_CODE( Universe* U = universe_get( L));
-    THREAD_MAKE_ASYNCH_CANCELLABLE();
-    THREAD_CLEANUP_PUSH( thread_cleanup_handler, s);
-    s->status = RUNNING;  // PENDING -> RUNNING
-
-    // Tie "set_finalizer()" to the state
-    lua_pushcfunction( L, LG_set_finalizer);
-    populate_func_lookup_table( L, -1, "set_finalizer");
-    lua_setglobal( L, "set_finalizer");
-
-    // Tie "set_debug_threadname()" to the state
-    // But don't register it in the lookup database because of the s_lane pointer upvalue
-    lua_pushlightuserdata( L, s);
-    lua_pushcclosure( L, LG_set_debug_threadname, 1);
-    lua_setglobal( L, "set_debug_threadname");
-
-    // Tie "cancel_test()" to the state
-    lua_pushcfunction( L, LG_cancel_test);
-    populate_func_lookup_table( L, -1, "cancel_test");
-    lua_setglobal( L, "cancel_test");
-
-    // this could be done in lane_new before the lane body function is pushed on the stack to avoid unnecessary stack slot shifting around
-#if ERROR_FULL_STACK
-    // Tie "set_error_reporting()" to the state
-    lua_pushcfunction( L, LG_set_error_reporting);
-    populate_func_lookup_table( L, -1, "set_error_reporting");
-    lua_setglobal( L, "set_error_reporting");
-
-    STACK_GROW( L, 1);
-    lua_pushcfunction( L, lane_error);                                           // func args handler
-    lua_insert( L, 1);                                                           // handler func args
-#endif // ERROR_FULL_STACK
-
-    rc = lua_pcall( L, nargs, LUA_MULTRET, ERROR_FULL_STACK);                    // retvals|err
-
-#if ERROR_FULL_STACK
-    lua_remove( L, 1);                                                           // retvals|error
-#       endif // ERROR_FULL_STACK
-
-    // in case of error and if it exists, fetch stack trace from registry and push it
-    push_stack_trace( L, rc, 1);                                                 // retvals|error [trace]
-
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "Lane %p body: %s (%s)\n" INDENT_END, L, get_errcode_name( rc), equal_unique_key( L, 1, CANCEL_ERROR) ? "cancelled" : lua_typename( L, lua_type( L, 1))));
-    //STACK_DUMP(L);
-    // Call finalizers, if the script has set them up.
-    //
-    rc2 = run_finalizers( L, rc);
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "Lane %p finalizer: %s\n" INDENT_END, L, get_errcode_name( rc2)));
-    if( rc2 != LUA_OK) // Error within a finalizer!
-    {
-        // the finalizer generated an error, and left its own error message [and stack trace] on the stack
-        rc = rc2;    // we're overruling the earlier script error or normal return
-    }
-    s->waiting_on = NULL; // just in case
-    if( selfdestruct_remove( s)) // check and remove (under lock!)
-    {
-        // We're a free-running thread and no-one's there to clean us up.
-        //
-        lua_close( s->L);
-
-        MUTEX_LOCK( &s->U->selfdestruct_cs);
-        // done with lua_close(), terminal shutdown sequence may proceed
-        -- s->U->selfdestructing_count;
-        MUTEX_UNLOCK( &s->U->selfdestruct_cs);
-
-        lane_cleanup( s); // s is freed at this point
-    }
-    else
-    {
-        // leave results (1..top) or error message + stack trace (1..2) on the stack - master will copy them
-
-        enum e_status st = (rc == 0) ? DONE : equal_unique_key( L, 1, CANCEL_ERROR) ? CANCELLED : ERROR_ST;
-
-        // Posix no PTHREAD_TIMEDJOIN:
-        // 'done_lock' protects the -> DONE|ERROR_ST|CANCELLED state change
-        //
-#if THREADWAIT_METHOD == THREADWAIT_CONDVAR
-        MUTEX_LOCK( &s->done_lock);
-        {
-#endif // THREADWAIT_METHOD == THREADWAIT_CONDVAR
-            s->status = st;
-#if THREADWAIT_METHOD == THREADWAIT_CONDVAR
-            SIGNAL_ONE( &s->done_signal);   // wake up master (while 's->done_lock' is on)
-        }
-        MUTEX_UNLOCK( &s->done_lock);
-#endif // THREADWAIT_METHOD == THREADWAIT_CONDVAR
-    }
-    THREAD_CLEANUP_POP( FALSE);
-    return 0;   // ignored
-}
-
-// --- If a client wants to transfer stuff of a given module from the current state to another Lane, the module must be required
-// with lanes.require, that will call the regular 'require', then populate the lookup database in the source lane
-// module = lanes.require( "modname")
-// upvalue[1]: _G.require
-LUAG_FUNC( require)
-{
-    char const* name = lua_tostring( L, 1);
-    int const nargs = lua_gettop( L);
-    DEBUGSPEW_CODE( Universe* U = universe_get( L));
-    STACK_CHECK( L, 0);
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lanes.require %s BEGIN\n" INDENT_END, name));
-    DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
-    lua_pushvalue( L, lua_upvalueindex(1));   // "name" require
-    lua_insert( L, 1);                        // require "name"
-    lua_call( L, nargs, 1);                   // module
-    populate_func_lookup_table( L, -1, name);
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lanes.require %s END\n" INDENT_END, name));
-    DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
-    STACK_END( L, 0);
-    return 1;
-}
-
-
-// --- If a client wants to transfer stuff of a previously required module from the current state to another Lane, the module must be registered
-// to populate the lookup database in the source lane (and in the destination too, of course)
-// lanes.register( "modname", module)
-LUAG_FUNC( register)
-{
-    char const* name = luaL_checkstring( L, 1);
-    int const mod_type = lua_type( L, 2);
-    // ignore extra parameters, just in case
-    lua_settop( L, 2);
-    luaL_argcheck( L, (mod_type == LUA_TTABLE) || (mod_type == LUA_TFUNCTION), 2, "unexpected module type");
-    DEBUGSPEW_CODE( Universe* U = universe_get( L));
-    STACK_CHECK( L, 0);                          // "name" mod_table
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lanes.register %s BEGIN\n" INDENT_END, name));
-    DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
-    populate_func_lookup_table( L, -1, name);
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lanes.register %s END\n" INDENT_END, name));
-    DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
-    STACK_END( L, 0);
-    return 0;
-}
-
-// crc64/we of string "GCCB_KEY" generated at http://www.nitrxgen.net/hashgen/
-static DECLARE_CONST_UNIQUE_KEY( GCCB_KEY, 0xcfb1f046ef074e88);
-
-//---
-// lane_ud = lane_new( function
-//                   , [libs_str]
-//                   , [priority_int=0]
-//                   , [globals_tbl]
-//                   , [package_tbl]
-//                   , [required_tbl]
-//                   , [gc_cb_func]
-//                  [, ... args ...])
-//
-// Upvalues: metatable to use for 'lane_ud'
-//
-LUAG_FUNC( lane_new)
-{
-    lua_State* L2;
-    Lane* s;
-    Lane** ud;
-
-    char const* libs_str = lua_tostring( L, 2);
-    bool_t const have_priority = !lua_isnoneornil( L, 3);
-    int const priority = have_priority ? (int) lua_tointeger( L, 3) : THREAD_PRIO_DEFAULT;
-    int const globals_idx = lua_isnoneornil( L, 4) ? 0 : 4;
-    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;
-
-#define FIXED_ARGS 7
-    int const nargs = lua_gettop(L) - FIXED_ARGS;
-    Universe* const U = universe_get( L);
-    ASSERT_L( nargs >= 0);
-
-    // public Lanes API accepts a generic range -3/+3
-    // that will be remapped into the platform-specific scheduler priority scheme
-    // On some platforms, -3 is equivalent to -2 and +3 to +2
-    if( have_priority && (priority < THREAD_PRIO_MIN || priority > THREAD_PRIO_MAX))
-    {
-        return luaL_error( L, "Priority out of range: %d..+%d (%d)", THREAD_PRIO_MIN, THREAD_PRIO_MAX, priority);
-    }
-
-    /* --- Create and prepare the sub state --- */
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lane_new: setup\n" INDENT_END));
-    DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
-
-    // populate with selected libraries at the same time
-    L2 = luaG_newstate( U, L, libs_str);                             // L                                                                      // L2
-
-    STACK_GROW( L2, nargs + 3);                                                                                                                //
-    STACK_CHECK( L2, 0);
-
-    STACK_GROW( L, 3);                                               // func libs priority globals package required gc_cb [... args ...]
-    STACK_CHECK( L, 0);
-
-    // give a default "Lua" name to the thread to see VM name in Decoda debugger
-    lua_pushfstring( L2, "Lane #%p", L2);                                                                                                      // "..."
-    lua_setglobal( L2, "decoda_name");                                                                                                         //
-    ASSERT_L( lua_gettop( L2) == 0);
-
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lane_new: update 'package'\n" INDENT_END));
-    // package
-    if( package_idx != 0)
-    {
-        // when copying with mode eLM_LaneBody, should raise an error in case of problem, not leave it one the stack
-        InterCopyResult const ret = luaG_inter_copy_package( U, L, L2, package_idx, eLM_LaneBody);
-        ASSERT_L(ret == eICR_Success); // either all went well, or we should not even get here
-    }
-
-    // modules to require in the target lane *before* the function is transfered!
-
-    if( required_idx != 0)
-    {
-        int nbRequired = 1;
-        DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lane_new: require 'required' list\n" INDENT_END));
-        DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
-        // should not happen, was checked in lanes.lua before calling lane_new()
-        if( lua_type( L, required_idx) != LUA_TTABLE)
-        {
-            return luaL_error( L, "expected required module list as a table, got %s", luaL_typename( L, required_idx));
-        }
-
-        lua_pushnil( L);                                             // func libs priority globals package required gc_cb [... args ...] nil
-        while( lua_next( L, required_idx) != 0)                      // func libs priority globals package required gc_cb [... args ...] n "modname"
-        {
-            if( lua_type( L, -1) != LUA_TSTRING || lua_type( L, -2) != LUA_TNUMBER || lua_tonumber( L, -2) != nbRequired)
-            {
-                return luaL_error( L, "required module list should be a list of strings");
-            }
-            else
-            {
-                // require the module in the target state, and populate the lookup table there too
-                size_t len;
-                char const* name = lua_tolstring( L, -1, &len);
-                DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lane_new: require '%s'\n" INDENT_END, name));
-
-                // require the module in the target lane
-                lua_getglobal( L2, "require");                                                                                                 // require()?
-                if( lua_isnil( L2, -1))
-                {
-                    lua_pop( L2, 1);                                                                                                           //
-                    luaL_error( L, "cannot pre-require modules without loading 'package' library first");
-                }
-                else
-                {
-                    lua_pushlstring( L2, name, len);                                                                                           // require() name
-                    if( lua_pcall( L2, 1, 1, 0) != LUA_OK)                                                                                     // ret/errcode
-                    {
-                        // propagate error to main state if any
-                        luaG_inter_move( U, L2, L, 1, eLM_LaneBody); // func libs priority globals package required gc_cb [... args ...] n "modname" error
-                        return lua_error( L);
-                    }
-                    // 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);                                                                                                           //
-                }
-            }
-            lua_pop( L, 1);                                          // func libs priority globals package required gc_cb [... args ...] n
-            ++ nbRequired;
-        }                                                            // func libs priority globals package required gc_cb [... args ...]
-        DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
-    }
-    STACK_MID( L, 0);
-    STACK_MID( L2, 0);                                                                                                                         //
-
-    // 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...
-    //
-    if( globals_idx != 0)
-    {
-        DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lane_new: transfer globals\n" INDENT_END));
-        if( !lua_istable( L, globals_idx))
-        {
-            return luaL_error( L, "Expected table, got %s", luaL_typename( L, globals_idx));
-        }
-
-        DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
-        lua_pushnil( L);                                             // func libs priority globals package required gc_cb [... args ...] nil
-        // Lua 5.2 wants us to push the globals table on the stack
-        lua_pushglobaltable( L2);                                                                                                              // _G
-        while( lua_next( L, globals_idx))                            // func libs priority globals package required gc_cb [... args ...] k v
-        {
-            luaG_inter_copy( U, L, L2, 2, eLM_LaneBody);                                                                                       // _G k v
-            // assign it in L2's globals table
-            lua_rawset( L2, -3);                                                                                                               // _G
-            lua_pop( L, 1);                                          // func libs priority globals package required gc_cb [... args ...] k
-        }                                                            // func libs priority globals package required gc_cb [... args ...]
-        lua_pop( L2, 1);                                                                                                                       //
-
-        DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
-    }
-    STACK_MID( L, 0);
-    STACK_MID( L2, 0);
-
-    // Lane main function
-    {
-        int const func_type = lua_type(L, 1);
-        if (func_type == LUA_TFUNCTION)
-        {
-            InterCopyResult res;
-            DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "lane_new: transfer lane body\n" INDENT_END));
-            DEBUGSPEW_CODE(++U->debugspew_indent_depth);
-            lua_pushvalue(L, 1);                                     // func libs priority globals package required gc_cb [... args ...] func
-            res = luaG_inter_move(U, L, L2, 1, eLM_LaneBody);        // func libs priority globals package required gc_cb [... args ...]       // func
-            DEBUGSPEW_CODE(--U->debugspew_indent_depth);
-            if (res != eICR_Success)
-            {
-                return luaL_error(L, "tried to copy unsupported types");
-            }
-        }
-        else if (func_type == LUA_TSTRING)
-        {
-            // compile the string
-            if (luaL_loadstring(L2, lua_tostring(L, 1)) != 0)                                                                                  // func
-            {
-                return luaL_error(L, "error when parsing lane function code");
-            }
-        }
-        else
-        {
-            luaL_error(L, "Expected function, got %s", lua_typename(L, func_type)); // doesn't return
-        }
-    }
-    STACK_MID( L, 0);
-    STACK_MID( L2, 1);
-    ASSERT_L( lua_isfunction( L2, 1));
-
-    // revive arguments
-    if( nargs > 0)
-    {
-        InterCopyResult res;
-        DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lane_new: transfer lane arguments\n" INDENT_END));
-        DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
-        res = luaG_inter_move( U, L, L2, nargs, eLM_LaneBody);       // func libs priority globals package required gc_cb                      // func [... args ...]
-        DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
-        if( res != eICR_Success)
-        {
-            return luaL_error( L, "tried to copy unsupported types");
-        }
-    }
-    STACK_END( L, -nargs);
-    ASSERT_L( lua_gettop( L) == FIXED_ARGS);
-    STACK_CHECK( L, 0);
-    STACK_MID( L2, 1 + nargs);
-
-    // 's' 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
-    ud = lua_newuserdatauv( L, sizeof( Lane*), 1);                   // func libs priority globals package required gc_cb lane
-    {
-        AllocatorDefinition* const allocD = &U->internal_allocator;
-        s = *ud = (Lane*) allocD->allocF(allocD->allocUD, NULL, 0, sizeof(Lane));
-    }
-    if( s == NULL)
-    {
-        return luaL_error( L, "could not create lane: out of memory");
-    }
-
-    s->L = L2;
-    s->U = U;
-    s->status = PENDING;
-    s->waiting_on = NULL;
-    s->debug_name = "<unnamed>";
-    s->cancel_request = CANCEL_NONE;
-
-#if THREADWAIT_METHOD == THREADWAIT_CONDVAR
-    MUTEX_INIT( &s->done_lock);
-    SIGNAL_INIT( &s->done_signal);
-#endif // THREADWAIT_METHOD == THREADWAIT_CONDVAR
-    s->mstatus = NORMAL;
-    s->selfdestruct_next = NULL;
-#if HAVE_LANE_TRACKING()
-    s->tracking_next = NULL;
-    if( s->U->tracking_first)
-    {
-        tracking_add( s);
-    }
-#endif // HAVE_LANE_TRACKING()
-
-    // Set metatable for the userdata
-    //
-    lua_pushvalue( L, lua_upvalueindex( 1));                         // func libs priority globals package required gc_cb lane mt
-    lua_setmetatable( L, -2);                                        // func libs priority globals package required gc_cb lane
-    STACK_MID( L, 1);
-
-    // Create uservalue for the userdata
-    // (this is where lane body return values will be stored when the handle is indexed by a numeric key)
-    lua_newtable( L);                                                // func libs cancelstep priority globals package required gc_cb lane uv
-
-    // Store the gc_cb callback in the uservalue
-    if( gc_cb_idx > 0)
-    {
-        push_unique_key( L, GCCB_KEY);                               // 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).
-    REGISTRY_SET( L2, LANE_POINTER_REGKEY, lua_pushlightuserdata( L2, s));                                                                     // func [... args ...]
-
-    STACK_END( L, 1);
-    STACK_END( L2, 1 + nargs);
-
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lane_new: launching thread\n" INDENT_END));
-    THREAD_CREATE( &s->thread, lane_main, s, priority);
-
-    DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
-    return 1;
-}
-
-
-//---
-// = thread_gc( lane_ud )
-//
-// Cleanup for a thread userdata. If the thread is still executing, leave it
-// alive as a free-running thread (will clean up itself).
-//
-// * Why NOT cancel/kill a loose thread: 
-//
-// At least timer system uses a free-running thread, they should be handy
-// and the issue of canceling/killing threads at gc is not very nice, either
-// (would easily cause waits at gc cycle, which we don't want).
-//
-LUAG_FUNC( thread_gc)
-{
-    bool_t have_gc_cb = FALSE;
-    Lane* s = lua_toLane( L, 1);                                        // ud
-
-    // if there a gc callback?
-    lua_getiuservalue( L, 1, 1);                                        // ud uservalue
-    push_unique_key( L, GCCB_KEY);                                      // ud uservalue __gc
-    lua_rawget( L, -2);                                                 // ud uservalue gc_cb|nil
-    if( !lua_isnil( L, -1))
-    {
-        lua_remove( L, -2);                                               // ud gc_cb|nil
-        lua_pushstring( L, s->debug_name);                                // ud gc_cb name
-        have_gc_cb = TRUE;
-    }
-    else
-    {
-        lua_pop( L, 2);                                                   // ud
-    }
-
-    // We can read 's->status' without locks, but not wait for it
-    // test KILLED state first, as it doesn't need to enter the selfdestruct chain
-    if( s->mstatus == KILLED)
-    {
-        // Make sure a kill has proceeded, before cleaning up the data structure.
-        //
-        // NO lua_close() in this case because we don't know where execution of the state was interrupted
-        DEBUGSPEW_CODE( fprintf( stderr, "** Joining with a killed thread (needs testing) **"));
-        // make sure the thread is no longer running, just like thread_join()
-        if(! THREAD_ISNULL( s->thread))
-        {
-            THREAD_WAIT( &s->thread, -1, &s->done_signal, &s->done_lock, &s->status);
-        }
-        if( s->status >= DONE && s->L)
-        {
-            // we know the thread was killed while the Lua VM was not doing anything: we should be able to close it without crashing
-            // now, thread_cancel() will not forcefully kill a lane with s->status >= DONE, so I am not sure it can ever happen
-            lua_close( s->L);
-            s->L = 0;
-            // just in case, but s will be freed soon so...
-            s->debug_name = "<gc>";
-        }
-        DEBUGSPEW_CODE( fprintf( stderr, "** Joined ok **"));
-    }
-    else if( s->status < DONE)
-    {
-        // still running: will have to be cleaned up later
-        selfdestruct_add( s);
-        assert( s->selfdestruct_next);
-        if( have_gc_cb)
-        {
-            lua_pushliteral( L, "selfdestruct");                            // ud gc_cb name status
-            lua_call( L, 2, 0);                                             // ud
-        }
-        return 0;
-    }
-    else if( s->L)
-    {
-        // no longer accessing the Lua VM: we can close right now
-        lua_close( s->L);
-        s->L = 0;
-        // just in case, but s will be freed soon so...
-        s->debug_name = "<gc>";
-    }
-
-    // Clean up after a (finished) thread
-    lane_cleanup( s);
-
-    // do this after lane cleanup in case the callback triggers an error
-    if( have_gc_cb)
-    {
-        lua_pushliteral( L, "closed");                                    // ud gc_cb name status
-        lua_call( L, 2, 0);                                               // ud
-    }
-    return 0;
-}
-
-//---
-// str= thread_status( lane )
-//
-// Returns: "pending"   not started yet
-//          -> "running"   started, doing its work..
-//             <-> "waiting"   blocked in a receive()
-//                -> "done"     finished, results are there
-//                   / "error"     finished at an error, error value is there
-//                   / "cancelled"   execution cancelled by M (state gone)
-//
-static char const * thread_status_string( Lane* s)
-{
-    enum e_status st = s->status;    // read just once (volatile)
-    char const* str =
-        (s->mstatus == KILLED) ? "killed" : // new to v3.3.0!
-        (st == PENDING) ? "pending" :
-        (st == RUNNING) ? "running" :    // like in 'co.status()'
-        (st == WAITING) ? "waiting" :
-        (st == DONE) ? "done" :
-        (st == ERROR_ST) ? "error" :
-        (st == CANCELLED) ? "cancelled" : NULL;
-    return str;
-}
-
-int push_thread_status( lua_State* L, Lane* s)
-{
-    char const* const str = thread_status_string( s);
-    ASSERT_L( str);
-
-    lua_pushstring( L, str);
-    return 1;
-}
-
-
-//---
-// [...] | [nil, err_any, stack_tbl]= thread_join( lane_ud [, wait_secs=-1] )
-//
-//  timeout:   returns nil
-//  done:      returns return values (0..N)
-//  error:     returns nil + error value [+ stack table]
-//  cancelled: returns nil
-//
-LUAG_FUNC( thread_join)
-{
-    Lane* const s = lua_toLane( L, 1);
-    double wait_secs = luaL_optnumber( L, 2, -1.0);
-    lua_State* L2 = s->L;
-    int ret;
-    bool_t done = THREAD_ISNULL( s->thread) || THREAD_WAIT( &s->thread, wait_secs, &s->done_signal, &s->done_lock, &s->status);
-    if( !done || !L2)
-    {
-        STACK_GROW( L, 2);
-        lua_pushnil( L);
-        lua_pushliteral( L, "timeout");
-        return 2;
-    }
-
-    STACK_CHECK( L, 0);
-    // Thread is DONE/ERROR_ST/CANCELLED; all ours now
-
-    if( s->mstatus == KILLED) // OS thread was killed if thread_cancel was forced
-    {
-        // in that case, even if the thread was killed while DONE/ERROR_ST/CANCELLED, ignore regular return values
-        STACK_GROW( L, 2);
-        lua_pushnil( L);
-        lua_pushliteral( L, "killed");
-        ret = 2;
-    }
-    else
-    {
-        Universe* U = universe_get( L);
-        // debug_name 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, s);
-        switch( s->status)
-        {
-            case DONE:
-            {
-                int n = lua_gettop( L2);       // whole L2 stack
-                if( (n > 0) && (luaG_inter_move( U, L2, L, n, eLM_LaneBody) != eICR_Success))
-                {
-                    return luaL_error( L, "tried to copy unsupported types");
-                }
-                ret = n;
-            }
-            break;
-
-            case ERROR_ST:
-            {
-                int const n = lua_gettop( L2);
-                STACK_GROW( L, 3);
-                lua_pushnil( L);
-                // even when ERROR_FULL_STACK, if the error is not LUA_ERRRUN, the handler wasn't called, and we only have 1 error message on the stack ...
-                if( luaG_inter_move( U, L2, L, n, eLM_LaneBody) != eICR_Success)  // nil "err" [trace]
-                {
-                    return luaL_error( L, "tried to copy unsupported types: %s", lua_tostring( L, -n));
-                }
-                ret = 1 + n;
-            }
-            break;
-
-            case CANCELLED:
-            ret = 0;
-            break;
-
-            default:
-            DEBUGSPEW_CODE( fprintf( stderr, "Status: %d\n", s->status));
-            ASSERT_L( FALSE);
-            ret = 0;
-        }
-        lua_close( L2);
-    }
-    s->L = 0;
-    STACK_END( L, ret);
-    return ret;
-}
-
-
-//---
-// thread_index( ud, key) -> value
-//
-// If key is found in the environment, return it
-// If key is numeric, wait until the thread returns and populate the environment with the return values
-// If the return values signal an error, propagate it
-// If key is "status" return the thread status
-// Else raise an error
-LUAG_FUNC( thread_index)
-{
-    int const UD = 1;
-    int const KEY = 2;
-    int const USR = 3;
-    Lane* const s = lua_toLane( L, UD);
-    ASSERT_L( lua_gettop( L) == 2);
-
-    STACK_GROW( L, 8); // up to 8 positions are needed in case of error propagation
-
-    // If key is numeric, wait until the thread returns and populate the environment with the return values
-    if( lua_type( L, KEY) == LUA_TNUMBER)
-    {
-        // first, check that we don't already have an environment that holds the requested value
-        {
-            // If key is found in the uservalue, return it
-            lua_getiuservalue( L, UD, 1);
-            lua_pushvalue( L, KEY);
-            lua_rawget( L, USR);
-            if( !lua_isnil( L, -1))
-            {
-                return 1;
-            }
-            lua_pop( L, 1);
-        }
-        {
-            // check if we already fetched the values from the thread or not
-            bool_t fetched;
-            lua_Integer key = lua_tointeger( L, KEY);
-            lua_pushinteger( L, 0);
-            lua_rawget( L, USR);
-            fetched = !lua_isnil( L, -1);
-            lua_pop( L, 1); // back to our 2 args + uservalue on the stack
-            if( !fetched)
-            {
-                lua_pushinteger( L, 0);
-                lua_pushboolean( L, 1);
-                lua_rawset( L, USR);
-                // wait until thread has completed
-                lua_pushcfunction( L, LG_thread_join);
-                lua_pushvalue( L, UD);
-                lua_call( L, 1, LUA_MULTRET); // all return values are on the stack, at slots 4+
-                switch( s->status)
-                {
-                    default:
-                    if( s->mstatus != KILLED)
-                    {
-                        // this is an internal error, we probably never get here
-                        lua_settop( L, 0);
-                        lua_pushliteral( L, "Unexpected status: ");
-                        lua_pushstring( L, thread_status_string( s));
-                        lua_concat( L, 2);
-                        lua_error( L);
-                        break;
-                    }
-                    // fall through if we are killed, as we got nil, "killed" on the stack
-
-                    case DONE: // got regular return values
-                    {
-                        int i, nvalues = lua_gettop( L) - 3;
-                        for( i = nvalues; i > 0; -- i)
-                        {
-                            // pop the last element of the stack, to store it in the uservalue at its proper index
-                            lua_rawseti( L, USR, i);
-                        }
-                    }
-                    break;
-
-                    case ERROR_ST: // got 3 values: nil, errstring, callstack table
-                    // me[-2] could carry the stack table, but even 
-                    // me[-1] is rather unnecessary (and undocumented);
-                    // use ':join()' instead.   --AKa 22-Jan-2009
-                    ASSERT_L( lua_isnil( L, 4) && !lua_isnil( L, 5) && lua_istable( L, 6));
-                    // store errstring at key -1
-                    lua_pushnumber( L, -1);
-                    lua_pushvalue( L, 5);
-                    lua_rawset( L, USR);
-                    break;
-
-                    case CANCELLED:
-                     // do nothing
-                    break;
-                }
-            }
-            lua_settop( L, 3);                                                // UD KEY ENV
-            if( key != -1)
-            {
-                lua_pushnumber( L, -1);                                         // UD KEY ENV -1
-                lua_rawget( L, USR);                                            // UD KEY ENV "error"
-                if( !lua_isnil( L, -1)) // an error was stored
-                {
-                    // Note: Lua 5.1 interpreter is not prepared to show
-                    //       non-string errors, so we use 'tostring()' here
-                    //       to get meaningful output.  --AKa 22-Jan-2009
-                    //
-                    //       Also, the stack dump we get is no good; it only
-                    //       lists our internal Lanes functions. There seems
-                    //       to be no way to switch it off, though.
-                    //
-                    // Level 3 should show the line where 'h[x]' was read
-                    // but this only seems to work for string messages
-                    // (Lua 5.1.4). No idea, why.   --AKa 22-Jan-2009
-                    lua_getmetatable( L, UD);                                     // UD KEY ENV "error" mt
-                    lua_getfield( L, -1, "cached_error");                         // UD KEY ENV "error" mt error()
-                    lua_getfield( L, -2, "cached_tostring");                      // UD KEY ENV "error" mt error() tostring()
-                    lua_pushvalue( L, 4);                                         // UD KEY ENV "error" mt error() tostring() "error"
-                    lua_call( L, 1, 1); // tostring( errstring) -- just in case   // UD KEY ENV "error" mt error() "error"
-                    lua_pushinteger( L, 3);                                       // UD KEY ENV "error" mt error() "error" 3
-                    lua_call( L, 2, 0); // error( tostring( errstring), 3)        // UD KEY ENV "error" mt
-                }
-                else
-                {
-                    lua_pop( L, 1); // back to our 3 arguments on the stack
-                }
-            }
-            lua_rawgeti( L, USR, (int)key);
-        }
-        return 1;
-    }
-    if( lua_type( L, KEY) == LUA_TSTRING)
-    {
-        char const * const keystr = lua_tostring( L, KEY);
-        lua_settop( L, 2); // keep only our original arguments on the stack
-        if( strcmp( keystr, "status") == 0)
-        {
-            return push_thread_status( L, s); // push the string representing the status
-        }
-        // return UD.metatable[key]
-        lua_getmetatable( L, UD); // UD KEY mt
-        lua_replace( L, -3);      // mt KEY
-        lua_rawget( L, -2);       // mt value
-        // only "cancel" and "join" are registered as functions, any other string will raise an error
-        if( lua_iscfunction( L, -1))
-        {
-            return 1;
-        }
-        return luaL_error( L, "can't index a lane with '%s'", keystr);
-    }
-    // unknown key
-    lua_getmetatable( L, UD);
-    lua_getfield( L, -1, "cached_error");
-    lua_pushliteral( L, "Unknown key: ");
-    lua_pushvalue( L, KEY);
-    lua_concat( L, 2);
-    lua_call( L, 1, 0); // error( "Unknown key: " .. key) -> doesn't return
-    return 0;
-}
-
-#if HAVE_LANE_TRACKING()
-//---
-// threads() -> {}|nil
-//
-// Return a list of all known lanes
-LUAG_FUNC( threads)
-{
-  int const top = lua_gettop( L);
-  Universe* U = universe_get( L);
-
-  // List _all_ still running threads
-  //
-  MUTEX_LOCK( &U->tracking_cs);
-  if( U->tracking_first && U->tracking_first != TRACKING_END)
-  {
-    Lane* s = U->tracking_first;
-    int index = 0;
-    lua_newtable( L);                                          // {}
-    while( s != TRACKING_END)
-    {
-      // insert a { name, status } tuple, so that several lanes with the same name can't clobber each other
-      lua_newtable( L);                                        // {} {}
-      lua_pushstring( L, s->debug_name);                       // {} {} "name"
-      lua_setfield( L, -2, "name");                            // {} {}
-      push_thread_status( L, s);                               // {} {} "status"
-      lua_setfield( L, -2, "status");                          // {} {}
-      lua_rawseti( L, -2, ++ index);                           // {}
-      s = s->tracking_next;
-    }
-  }
-  MUTEX_UNLOCK( &U->tracking_cs);
-  return lua_gettop( L) - top; // 0 or 1
-}
-#endif // HAVE_LANE_TRACKING()
-
-/*
- * ###############################################################################################
- * ######################################## Timer support ########################################
- * ###############################################################################################
- */
-
-/*
-* secs= now_secs()
-*
-* Returns the current time, as seconds (millisecond resolution).
-*/
-LUAG_FUNC( now_secs )
-{
-    lua_pushnumber( L, now_secs() );
-    return 1;
-}
-
-/*
-* wakeup_at_secs= wakeup_conv( date_tbl )
-*/
-LUAG_FUNC( wakeup_conv )
-{
-    int year, month, day, hour, min, sec, isdst;
-    struct tm t;
-    memset( &t, 0, sizeof( t));
-        //
-        // .year (four digits)
-        // .month (1..12)
-        // .day (1..31)
-        // .hour (0..23)
-        // .min (0..59)
-        // .sec (0..61)
-        // .yday (day of the year)
-        // .isdst (daylight saving on/off)
-
-    STACK_CHECK( L, 0);
-    lua_getfield( L, 1, "year" ); year= (int)lua_tointeger(L,-1); lua_pop(L,1);
-    lua_getfield( L, 1, "month" ); month= (int)lua_tointeger(L,-1); lua_pop(L,1);
-    lua_getfield( L, 1, "day" ); day= (int)lua_tointeger(L,-1); lua_pop(L,1);
-    lua_getfield( L, 1, "hour" ); hour= (int)lua_tointeger(L,-1); lua_pop(L,1);
-    lua_getfield( L, 1, "min" ); min= (int)lua_tointeger(L,-1); lua_pop(L,1);
-    lua_getfield( L, 1, "sec" ); sec= (int)lua_tointeger(L,-1); lua_pop(L,1);
-
-    // If Lua table has '.isdst' we trust that. If it does not, we'll let
-    // 'mktime' decide on whether the time is within DST or not (value -1).
-    //
-    lua_getfield( L, 1, "isdst" );
-    isdst= lua_isboolean(L,-1) ? lua_toboolean(L,-1) : -1;
-    lua_pop(L,1);
-    STACK_END( L, 0);
-
-    t.tm_year= year-1900;
-    t.tm_mon= month-1;     // 0..11
-    t.tm_mday= day;        // 1..31
-    t.tm_hour= hour;       // 0..23
-    t.tm_min= min;         // 0..59
-    t.tm_sec= sec;         // 0..60
-    t.tm_isdst= isdst;     // 0/1/negative
-
-    lua_pushnumber( L, (double) mktime( &t));   // ms=0
-    return 1;
-}
-
-/*
- * ###############################################################################################
- * ######################################## Module linkage #######################################
- * ###############################################################################################
- */
-
-extern int LG_linda( lua_State* L);
-static const struct luaL_Reg lanes_functions [] = {
-    {"linda", LG_linda},
-    {"now_secs", LG_now_secs},
-    {"wakeup_conv", LG_wakeup_conv},
-    {"set_thread_priority", LG_set_thread_priority},
-    {"set_thread_affinity", LG_set_thread_affinity},
-    {"nameof", luaG_nameof},
-    {"register", LG_register},
-    {"set_singlethreaded", LG_set_singlethreaded},
-    {NULL, NULL}
-};
-
-/*
- * One-time initializations
- * settings table it at position 1 on the stack
- * pushes an error string on the stack in case of problem
- */
-static void init_once_LOCKED( void)
-{
-#if (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC)
-    now_secs();     // initialize 'now_secs()' internal offset
-#endif
-
-#if (defined PLATFORM_OSX) && (defined _UTILBINDTHREADTOCPU)
-    chudInitialize();
-#endif
-
-    //---
-    // Linux needs SCHED_RR to change thread priorities, and that is only
-    // allowed for sudo'ers. SCHED_OTHER (default) has no priorities.
-    // SCHED_OTHER threads are always lower priority than SCHED_RR.
-    //
-    // ^-- those apply to 2.6 kernel.  IF **wishful thinking** these 
-    //     constraints will change in the future, non-sudo priorities can 
-    //     be enabled also for Linux.
-    //
-#ifdef PLATFORM_LINUX
-    sudo = (geteuid() == 0); // we are root?
-
-    // If lower priorities (-2..-1) are wanted, we need to lift the main
-    // thread to SCHED_RR and 50 (medium) level. Otherwise, we're always below 
-    // the launched threads (even -2).
-    //
-#ifdef LINUX_SCHED_RR
-    if( sudo)
-    {
-        struct sched_param sp;
-        sp.sched_priority = _PRIO_0;
-        PT_CALL( pthread_setschedparam( pthread_self(), SCHED_RR, &sp));
-    }
-#endif // LINUX_SCHED_RR
-#endif // PLATFORM_LINUX
-}
-
-static volatile long s_initCount = 0;
-
-// upvalue 1: module name
-// upvalue 2: module table
-// param 1: settings table
-LUAG_FUNC( configure)
-{
-    Universe* U = universe_get( L);
-    bool_t const from_master_state = (U == NULL);
-    char const* name = luaL_checkstring( L, lua_upvalueindex( 1));
-    _ASSERT_L( L, lua_type( L, 1) == LUA_TTABLE);
-
-    /*
-    ** Making one-time initializations.
-    **
-    ** When the host application is single-threaded (and all threading happens via Lanes)
-    ** there is no problem. But if the host is multithreaded, we need to lock around the
-    ** initializations.
-    */
-#if THREADAPI == THREADAPI_WINDOWS
-    {
-        static volatile int /*bool*/ go_ahead; // = 0
-        if( InterlockedCompareExchange( &s_initCount, 1, 0) == 0)
-        {
-            init_once_LOCKED();
-            go_ahead = 1; // let others pass
-        }
-        else
-        {
-            while( !go_ahead) { Sleep(1); } // changes threads
-        }
-    }
-#else // THREADAPI == THREADAPI_PTHREAD
-    if( s_initCount == 0)
-    {
-        static pthread_mutex_t my_lock = PTHREAD_MUTEX_INITIALIZER;
-        pthread_mutex_lock( &my_lock);
-        {
-            // Recheck now that we're within the lock
-            //
-            if( s_initCount == 0)
-            {
-                init_once_LOCKED();
-                s_initCount = 1;
-            }
-        }
-        pthread_mutex_unlock( &my_lock);
-    }
-#endif // THREADAPI == THREADAPI_PTHREAD
-
-    STACK_GROW( L, 4);
-    STACK_CHECK_ABS( L, 1);                                                                // settings
-
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "%p: lanes.configure() BEGIN\n" INDENT_END, L));
-    DEBUGSPEW_CODE( if( U) ++ U->debugspew_indent_depth);
-
-    if( U == NULL)
-    {
-        U = universe_create( L);                                                           // settings universe
-        DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
-        lua_newtable( L);                                                                  // settings universe mt
-        lua_getfield( L, 1, "shutdown_timeout");                                           // settings universe mt shutdown_timeout
-        lua_pushcclosure( L, universe_gc, 1);                                              // settings universe mt universe_gc
-        lua_setfield( L, -2, "__gc");                                                      // settings universe mt
-        lua_setmetatable( L, -2);                                                          // settings universe
-        lua_pop( L, 1);                                                                    // settings
-        lua_getfield( L, 1, "verbose_errors");                                             // settings verbose_errors
-        U->verboseErrors = lua_toboolean( L, -1);
-        lua_pop( L, 1);                                                                    // settings
-        lua_getfield( L, 1, "demote_full_userdata");                                       // settings demote_full_userdata
-        U->demoteFullUserdata = lua_toboolean( L, -1);
-        lua_pop( L, 1);                                                                    // settings
-#if HAVE_LANE_TRACKING()
-        MUTEX_INIT( &U->tracking_cs);
-        lua_getfield( L, 1, "track_lanes");                                                // settings track_lanes
-        U->tracking_first = lua_toboolean( L, -1) ? TRACKING_END : NULL;
-        lua_pop( L, 1);                                                                    // settings
-#endif // HAVE_LANE_TRACKING()
-        // Linked chains handling
-        MUTEX_INIT( &U->selfdestruct_cs);
-        MUTEX_RECURSIVE_INIT( &U->require_cs);
-        // Locks for 'tools.c' inc/dec counters
-        MUTEX_INIT( &U->deep_lock);
-        MUTEX_INIT( &U->mtid_lock);
-        U->selfdestruct_first = SELFDESTRUCT_END;
-        initialize_allocator_function( U, L);
-        initialize_on_state_create( U, L);
-        init_keepers( U, L);
-        STACK_MID( L, 1);
-
-        // Initialize 'timer_deep'; a common Linda object shared by all states
-        lua_pushcfunction( L, LG_linda);                                                   // settings lanes.linda
-        lua_pushliteral( L, "lanes-timer");                                                // settings lanes.linda "lanes-timer"
-        lua_call( L, 1, 1);                                                                // settings linda
-        STACK_MID( L, 2);
-
-        // Proxy userdata contents is only a 'DEEP_PRELUDE*' pointer
-        U->timer_deep = *(DeepPrelude**) lua_touserdata( L, -1);
-        // increment refcount so that this linda remains alive as long as the universe exists.
-        ++ U->timer_deep->refcount;
-        lua_pop( L, 1);                                                                    // settings
-    }
-    STACK_MID( L, 1);
-
-    // Serialize calls to 'require' from now on, also in the primary state
-    serialize_require( DEBUGSPEW_PARAM_COMMA( U) L);
-
-    // Retrieve main module interface table
-    lua_pushvalue( L, lua_upvalueindex( 2));                                               // settings M
-    // remove configure() (this function) from the module interface
-    lua_pushnil( L);                                                                       // settings M nil
-    lua_setfield( L, -2, "configure");                                                     // settings M
-    // add functions to the module's table
-    luaG_registerlibfuncs( L, lanes_functions);
-#if HAVE_LANE_TRACKING()
-    // register core.threads() only if settings say it should be available
-    if( U->tracking_first != NULL)
-    {
-        lua_pushcfunction( L, LG_threads);                                                 // settings M LG_threads()
-        lua_setfield( L, -2, "threads");                                                   // settings M
-    }
-#endif // HAVE_LANE_TRACKING()
-    STACK_MID( L, 2);
-
-    {
-        char const* errmsg;
-        errmsg = push_deep_proxy( U, L, (DeepPrelude*) U->timer_deep, 0, eLM_LaneBody);    // settings M timer_deep
-        if( errmsg != NULL)
-        {
-            return luaL_error( L, errmsg);
-        }
-        lua_setfield( L, -2, "timer_gateway");                                             // settings M
-    }
-    STACK_MID( L, 2);
-
-    // prepare the metatable for threads
-    // contains keys: { __gc, __index, cached_error, cached_tostring, cancel, join, get_debug_threadname }
-    //
-    if( luaL_newmetatable( L, "Lane"))                                                     // settings M mt
-    {
-        lua_pushcfunction( L, LG_thread_gc);                                               // settings M mt LG_thread_gc
-        lua_setfield( L, -2, "__gc");                                                      // settings M mt
-        lua_pushcfunction( L, LG_thread_index);                                            // settings M mt LG_thread_index
-        lua_setfield( L, -2, "__index");                                                   // settings M mt
-        lua_getglobal( L, "error");                                                        // settings M mt error
-        ASSERT_L( lua_isfunction( L, -1));
-        lua_setfield( L, -2, "cached_error");                                              // settings M mt
-        lua_getglobal( L, "tostring");                                                     // settings M mt tostring
-        ASSERT_L( lua_isfunction( L, -1));
-        lua_setfield( L, -2, "cached_tostring");                                           // settings M mt
-        lua_pushcfunction( L, LG_thread_join);                                             // settings M mt LG_thread_join
-        lua_setfield( L, -2, "join");                                                      // settings M mt
-        lua_pushcfunction( L, LG_get_debug_threadname);                                    // settings M mt LG_get_debug_threadname
-        lua_setfield( L, -2, "get_debug_threadname");                                      // settings M mt
-        lua_pushcfunction( L, LG_thread_cancel);                                           // settings M mt LG_thread_cancel
-        lua_setfield( L, -2, "cancel");                                                    // settings M mt
-        lua_pushliteral( L, "Lane");                                                       // settings M mt "Lane"
-        lua_setfield( L, -2, "__metatable");                                               // settings M mt
-    }
-
-    lua_pushcclosure( L, LG_lane_new, 1);                                                  // settings M lane_new
-    lua_setfield( L, -2, "lane_new");                                                      // settings M
-
-    // we can't register 'lanes.require' normally because we want to create an upvalued closure
-    lua_getglobal( L, "require");                                                          // settings M require
-    lua_pushcclosure( L, LG_require, 1);                                                   // settings M lanes.require
-    lua_setfield( L, -2, "require");                                                       // settings M
-
-    lua_pushfstring(
-        L, "%d.%d.%d"
-        , LANES_VERSION_MAJOR, LANES_VERSION_MINOR, LANES_VERSION_PATCH
-    );                                                                                     // settings M VERSION
-    lua_setfield( L, -2, "version");                                                       // settings M
-
-    lua_pushinteger(L, THREAD_PRIO_MAX);                                                   // settings M THREAD_PRIO_MAX
-    lua_setfield( L, -2, "max_prio");                                                      // settings M
-
-    push_unique_key( L, CANCEL_ERROR);                                                     // settings M CANCEL_ERROR
-    lua_setfield( L, -2, "cancel_error");                                                  // settings M
-
-    STACK_MID( 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
-    REGISTRY_SET( L, LOOKUP_REGKEY, lua_newtable( L));
-    STACK_MID( L, 2);
-
-    // register all native functions found in that module in the transferable functions database
-    // we process it before _G because we don't want to find the module when scanning _G (this would generate longer names)
-    // for example in package.loaded["lanes.core"].*
-    populate_func_lookup_table( L, -1, name);
-    STACK_MID( L, 2);
-
-    // record all existing C/JIT-fast functions
-    // Lua 5.2 no longer has LUA_GLOBALSINDEX: we must push globals table on the stack
-    if( from_master_state)
-    {
-        // don't do this when called during the initialization of a new lane,
-        // because we will do it after on_state_create() is called,
-        // and we don't want to skip _G because of caching in case globals are created then
-        lua_pushglobaltable( L);                                                           // settings M _G
-        populate_func_lookup_table( L, -1, NULL);
-        lua_pop( L, 1);                                                                    // settings M
-    }
-    lua_pop( L, 1);                                                                        // settings
-
-    // set _R[CONFIG_REGKEY] = settings 
-    REGISTRY_SET( L, CONFIG_REGKEY, lua_pushvalue( L, -2)); // -2 because CONFIG_REGKEY is pushed before the value itself
-    STACK_END( L, 1);
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "%p: lanes.configure() END\n" INDENT_END, L));
-    DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
-    // Return the settings table
-    return 1;
-}
-
-#if defined PLATFORM_WIN32 && !defined NDEBUG
-#include <signal.h>
-#include <conio.h>
-
-void signal_handler( int signal)
-{
-    if( signal == SIGABRT)
-    {
-        _cprintf( "caught abnormal termination!");
-        abort();
-    }
-}
-
-// helper to have correct callstacks when crashing a Win32 running on 64 bits Windows
-// don't forget to toggle Debug/Exceptions/Win32 in visual Studio too!
-static volatile long s_ecoc_initCount = 0;
-static volatile int s_ecoc_go_ahead = 0;
-static void EnableCrashingOnCrashes( void)
-{
-    if( InterlockedCompareExchange( &s_ecoc_initCount, 1, 0) == 0)
-    {
-        typedef BOOL (WINAPI* tGetPolicy)( LPDWORD lpFlags);
-        typedef BOOL (WINAPI* tSetPolicy)( DWORD dwFlags);
-        const DWORD EXCEPTION_SWALLOWING = 0x1;
-
-        HMODULE kernel32 = LoadLibraryA("kernel32.dll");
-        if (kernel32)
-        {
-            tGetPolicy pGetPolicy = (tGetPolicy)GetProcAddress(kernel32, "GetProcessUserModeExceptionPolicy");
-            tSetPolicy pSetPolicy = (tSetPolicy)GetProcAddress(kernel32, "SetProcessUserModeExceptionPolicy");
-            if( pGetPolicy && pSetPolicy)
-            {
-                DWORD dwFlags;
-                if( pGetPolicy( &dwFlags))
-                {
-                    // Turn off the filter
-                    pSetPolicy( dwFlags & ~EXCEPTION_SWALLOWING);
-                }
-            }
-            FreeLibrary(kernel32);
-        }
-        //typedef void (* SignalHandlerPointer)( int);
-        /*SignalHandlerPointer previousHandler =*/ signal( SIGABRT, signal_handler);
-
-        s_ecoc_go_ahead = 1; // let others pass
-    }
-    else
-    {
-        while( !s_ecoc_go_ahead) { Sleep(1); } // changes threads
-    }
-}
-#endif // PLATFORM_WIN32 && !defined NDEBUG
-
-int LANES_API luaopen_lanes_core( lua_State* L)
-{
-#if defined PLATFORM_WIN32 && !defined NDEBUG
-    EnableCrashingOnCrashes();
-#endif // defined PLATFORM_WIN32 && !defined NDEBUG
-
-    STACK_GROW( L, 4);
-    STACK_CHECK( L, 0);
-
-    // Prevent PUC-Lua/LuaJIT mismatch. Hopefully this works for MoonJIT too
-    lua_getglobal( L, "jit");                           // {jit?}
-#if LUAJIT_FLAVOR() == 0
-    if (!lua_isnil( L, -1))
-        return luaL_error( L, "Lanes is built for PUC-Lua, don't run from LuaJIT");
-#else
-    if (lua_isnil( L, -1))
-        return luaL_error( L, "Lanes is built for LuaJIT, don't run from PUC-Lua");
-#endif
-    lua_pop( L, 1);                                     //
-
-    // Create main module interface table
-    // we only have 1 closure, which must be called to configure Lanes
-    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()
-    REGISTRY_GET( L, CONFIG_REGKEY);                    // 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
-        lua_setfield( L, -4, "settings");               // M LG_configure() settings
-        lua_call( L, 1, 0);                             // M
-    }
-    else
-    {
-        // will do nothing on first invocation, as we haven't stored settings in the registry yet
-        lua_setfield( L, -3, "settings");               // M LG_configure()
-        lua_setfield( L, -2, "configure");              // M
-    }
-
-    STACK_END( L, 1);
-    return 1;
-}
-
-static int default_luaopen_lanes( lua_State* L)
-{
-    int rc = luaL_loadfile( L, "lanes.lua") || lua_pcall( L, 0, 1, 0);
-    if( rc != LUA_OK)
-    {
-        return luaL_error( L, "failed to initialize embedded Lanes");
-    }
-    return 1;
-}
-
-// call this instead of luaopen_lanes_core() when embedding Lua and Lanes in a custom application
-void LANES_API luaopen_lanes_embedded( lua_State* L, lua_CFunction _luaopen_lanes)
-{
-    STACK_CHECK( L, 0);
-    // pre-require lanes.core so that when lanes.lua calls require "lanes.core" it finds it is already loaded
-    luaL_requiref( L, "lanes.core", luaopen_lanes_core, 0);                                       // ... lanes.core
-    lua_pop( L, 1);                                                                               // ...
-    STACK_MID( L, 0);
-    // call user-provided function that runs the chunk "lanes.lua" from wherever they stored it
-    luaL_requiref( L, "lanes", _luaopen_lanes ? _luaopen_lanes : default_luaopen_lanes, 0);       // ... lanes
-    STACK_END( L, 1);
-}
diff --git a/src/lanes.cpp b/src/lanes.cpp
new file mode 100644
index 0000000..1f795cc
--- /dev/null
+++ b/src/lanes.cpp
@@ -0,0 +1,2054 @@
+/*
+ * LANES.CPP                            Copyright (c) 2007-08, Asko Kauppi
+ *                                      Copyright (C) 2009-24, Benoit Germain
+ *
+ * Multithreading in Lua.
+ * 
+ * History:
+ *      See CHANGES
+ *
+ * Platforms (tested internally):
+ *      OS X (10.5.7 PowerPC/Intel)
+ *      Linux x86 (Ubuntu 8.04)
+ *      Win32 (Windows XP Home SP2, Visual C++ 2005/2008 Express)
+ *
+ * Platforms (tested externally):
+ *      Win32 (MSYS) by Ross Berteig.
+ *
+ * Platforms (testers appreciated):
+ *      Win64 - should work???
+ *      Linux x64 - should work
+ *      FreeBSD - should work
+ *      QNX - porting shouldn't be hard
+ *      Sun Solaris - porting shouldn't be hard
+ *
+ * References:
+ *      "Porting multithreaded applications from Win32 to Mac OS X":
+ *      <http://developer.apple.com/macosx/multithreadedprogramming.html>
+ *
+ *      Pthreads:
+ *      <http://vergil.chemistry.gatech.edu/resources/programming/threads.html>
+ *
+ *      MSDN: <http://msdn2.microsoft.com/en-us/library/ms686679.aspx>
+ *
+ *      <http://ridiculousfish.com/blog/archives/2007/02/17/barrier>
+ *
+ * Defines:
+ *      -DLINUX_SCHED_RR: all threads are lifted to SCHED_RR category, to
+ *          allow negative priorities [-3,-1] be used. Even without this,
+ *          using priorities will require 'sudo' privileges on Linux.
+ *
+ *      -DUSE_PTHREAD_TIMEDJOIN: use 'pthread_timedjoin_np()' for waiting
+ *          for threads with a timeout. This changes the thread cleanup
+ *          mechanism slightly (cleans up at the join, not once the thread
+ *          has finished). May or may not be a good idea to use it.
+ *          Available only in selected operating systems (Linux).
+ *
+ * Bugs:
+ *
+ * To-do:
+ *
+ * Make waiting threads cancellable.
+ *      ...
+ */
+
+/*
+===============================================================================
+
+Copyright (C) 2007-10 Asko Kauppi <akauppi@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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+===============================================================================
+*/
+
+#include "lanes.h"
+
+#include "compat.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))
+# include <sys/time.h>
+#endif
+
+/* geteuid() */
+#ifdef PLATFORM_LINUX
+# include <unistd.h>
+# include <sys/types.h>
+#endif
+
+#include <atomic>
+
+// forwarding (will do things better later)
+static void tracking_add(Lane* lane_);
+
+Lane::Lane(Universe* U_, lua_State* L_)
+: U{ U_ }
+, L{ L_ }
+{
+#if HAVE_LANE_TRACKING()
+    if (U->tracking_first)
+    {
+        tracking_add(this);
+    }
+#endif // HAVE_LANE_TRACKING()
+}
+
+bool Lane::waitForCompletion(lua_Duration duration_)
+{
+    std::chrono::time_point<std::chrono::steady_clock> until{ std::chrono::time_point<std::chrono::steady_clock>::max() };
+    if (duration_.count() >= 0.0)
+    {
+        until = std::chrono::steady_clock::now() + std::chrono::duration_cast<std::chrono::steady_clock::duration>(duration_);
+    }
+
+    std::unique_lock lock{ m_done_mutex };
+    //std::stop_token token{ m_thread.get_stop_token() };
+    //return m_done_signal.wait_until(lock, token, secs_, [this](){ return m_status >= Lane::Done; });
+    return m_done_signal.wait_until(lock, until, [this](){ return m_status >= Lane::Done; });
+}
+
+static void lane_main(Lane* lane);
+void Lane::startThread(int priority_)
+{
+    m_thread = std::jthread([this]() { lane_main(this); });
+    if (priority_ != THREAD_PRIO_DEFAULT)
+    {
+        JTHREAD_SET_PRIORITY(m_thread, priority_, U->m_sudo);
+    }
+}
+
+/* Do you want full call stacks, or just the line where the error happened?
+*
+* TBD: The full stack feature does not seem to work (try 'make error').
+*/
+#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_)
+{
+    STACK_CHECK_START_REL(L, 0);
+    STACK_GROW(L, 3);
+    lua_getiuservalue(L, 1, 1);
+    lua_newtable(L);
+    // Lua 5.1 can't do 'lane_->debug_name = lua_pushstring(L, lane_->debug_name);'
+    lua_pushstring(L, lane_->debug_name);
+    lane_->debug_name = lua_tostring(L, -1);
+    lua_rawset(L, -3);
+    lua_pop(L, 1);
+    STACK_CHECK(L, 0);
+}
+
+#if ERROR_FULL_STACK
+[[nodiscard]] static int lane_error(lua_State* L);
+// crc64/we of string "STACKTRACE_REGKEY" generated at http://www.nitrxgen.net/hashgen/
+static constexpr UniqueKey STACKTRACE_REGKEY{ 0x534af7d3226a429full };
+#endif // ERROR_FULL_STACK
+
+/*
+* registry[FINALIZER_REG_KEY] is either nil (no finalizers) or a table
+* of functions that Lanes will call after the executing 'pcall' has ended.
+*
+* We're NOT using the GC system for finalizer mainly because providing the
+* error (and maybe stack trace) parameters to the finalizer functions would
+* anyways complicate that approach.
+*/
+// crc64/we of string "FINALIZER_REGKEY" generated at http://www.nitrxgen.net/hashgen/
+static constexpr UniqueKey FINALIZER_REGKEY{ 0x188fccb8bf348e09ull };
+
+// #################################################################################################
+
+/*
+* Push a table stored in registry onto Lua stack.
+*
+* If there is no existing table, create one if 'create' is true.
+* 
+* Returns: true if a table was pushed
+*          false if no table found, not created, and nothing pushed
+*/
+[[nodiscard]] static bool push_registry_table(lua_State* L, UniqueKey key, bool create)
+{
+    STACK_GROW(L, 3);
+    STACK_CHECK_START_REL(L, 0);
+
+    key.pushValue(L);                                                             // ?
+    if (lua_isnil(L, -1))                                                         // nil?
+    {
+        lua_pop(L, 1);                                                            //
+        STACK_CHECK(L, 0);
+
+        if (!create)
+        {
+            return false;
+        }
+
+        lua_newtable(L);                                                          // t
+        key.setValue(L, [](lua_State* L) { lua_pushvalue(L, -2); });
+    }
+    STACK_CHECK(L, 1);
+    return true;    // table pushed
+}
+
+// #################################################################################################
+
+#if HAVE_LANE_TRACKING()
+
+// The chain is ended by '(Lane*)(-1)', not nullptr:
+// 'tracking_first -> ... -> ... -> (-1)'
+#define TRACKING_END ((Lane *)(-1))
+
+/*
+ * Add the lane to tracking chain; the ones still running at the end of the
+ * whole process will be cancelled.
+ */
+static void tracking_add(Lane* lane_)
+{
+    std::lock_guard<std::mutex> guard{ lane_->U->tracking_cs };
+    assert(lane_->tracking_next == nullptr);
+
+    lane_->tracking_next = lane_->U->tracking_first;
+    lane_->U->tracking_first = lane_;
+}
+
+// #################################################################################################
+
+/*
+ * A free-running lane has ended; remove it from tracking chain
+ */
+[[nodiscard]] static bool tracking_remove(Lane* lane_)
+{
+    bool found{ false };
+    std::lock_guard<std::mutex> guard{ lane_->U->tracking_cs };
+    // Make sure (within the MUTEX) that we actually are in the chain
+    // still (at process exit they will remove us from chain and then
+    // cancel/kill).
+    //
+    if (lane_->tracking_next != nullptr)
+    {
+        Lane** ref = (Lane**) &lane_->U->tracking_first;
+
+        while( *ref != TRACKING_END)
+        {
+            if (*ref == lane_)
+            {
+                *ref = lane_->tracking_next;
+                lane_->tracking_next = nullptr;
+                found = true;
+                break;
+            }
+            ref = (Lane**) &((*ref)->tracking_next);
+        }
+        assert( found);
+    }
+    return found;
+}
+
+#endif // HAVE_LANE_TRACKING()
+
+// #################################################################################################
+
+Lane::~Lane()
+{
+    // Clean up after a (finished) thread
+    //
+#if HAVE_LANE_TRACKING()
+    if (U->tracking_first != nullptr)
+    {
+        // Lane was cleaned up, no need to handle at process termination
+        std::ignore = tracking_remove(this);
+    }
+#endif // HAVE_LANE_TRACKING()
+}
+
+/*
+ * ###############################################################################################
+ * ########################################## Finalizer ##########################################
+ * ###############################################################################################
+ */
+
+//---
+// void= finalizer( finalizer_func )
+//
+// finalizer_func( [err, stack_tbl] )
+//
+// Add a function that will be called when exiting the lane, either via
+// normal return or an error.
+//
+LUAG_FUNC( set_finalizer)
+{
+    luaL_argcheck(L, lua_isfunction(L, 1), 1, "finalizer should be a function");
+    luaL_argcheck(L, lua_gettop( L) == 1, 1, "too many arguments");
+    // Get the current finalizer table (if any), create one if it doesn't exist
+    std::ignore = push_registry_table(L, FINALIZER_REGKEY, true);               // finalizer {finalisers}
+    STACK_GROW(L, 2);
+    lua_pushinteger(L, lua_rawlen(L, -1) + 1);                                  // finalizer {finalisers} idx
+    lua_pushvalue(L, 1);                                                        // finalizer {finalisers} idx finalizer
+    lua_rawset(L, -3);                                                          // finalizer {finalisers}
+    lua_pop(L, 2);                                                              //
+    return 0;
+}
+
+
+//---
+// Run finalizers - if any - with the given parameters
+//
+// If 'rc' is nonzero, error message and stack index (the latter only when ERROR_FULL_STACK == 1) are available as:
+//      [-1]: stack trace (table)
+//      [-2]: error message (any type)
+//
+// Returns:
+//      0 if finalizers were run without error (or there were none)
+//      LUA_ERRxxx return code if any of the finalizers failed
+//
+// TBD: should we add stack trace on failing finalizer, wouldn't be hard..
+//
+static void push_stack_trace( lua_State* L, int rc_, int stk_base_);
+
+[[nodiscard]] static int run_finalizers(lua_State* L, int lua_rc)
+{
+    int finalizers_index;
+    int n;
+    int err_handler_index = 0;
+    int rc = LUA_OK;                                                                // ...
+    if (!push_registry_table(L, FINALIZER_REGKEY, false))                          // ... finalizers?
+    {
+        return 0;   // no finalizers
+    }
+
+    STACK_GROW(L, 5);
+
+    finalizers_index = lua_gettop( L);
+
+#if ERROR_FULL_STACK
+    lua_pushcfunction(L, lane_error);                                              // ... finalizers lane_error
+    err_handler_index = lua_gettop( L);
+#endif // ERROR_FULL_STACK
+
+    for( n = (int) lua_rawlen(L, finalizers_index); n > 0; -- n)
+    {
+        int args = 0;
+        lua_pushinteger(L, n);                                                       // ... finalizers lane_error n
+        lua_rawget(L, finalizers_index);                                             // ... finalizers lane_error finalizer
+        ASSERT_L( lua_isfunction(L, -1));
+        if (lua_rc != LUA_OK) // we have an error message and an optional stack trace at the bottom of the stack
+        {
+            ASSERT_L( finalizers_index == 2 || finalizers_index == 3);
+            //char const* err_msg = lua_tostring(L, 1);
+            lua_pushvalue(L, 1);                                                       // ... finalizers lane_error finalizer err_msg
+            // note we don't always have a stack trace for example when CANCEL_ERROR, or when we got an error that doesn't call our handler, such as LUA_ERRMEM
+            if (finalizers_index == 3)
+            {
+                lua_pushvalue(L, 2);                                                     // ... finalizers lane_error finalizer err_msg stack_trace
+            }
+            args = finalizers_index - 1;
+        }
+
+        // if no error from the main body, finalizer doesn't receive any argument, else it gets the error message and optional stack trace
+        rc = lua_pcall(L, args, 0, err_handler_index);                               // ... finalizers lane_error err_msg2?
+        if (rc != LUA_OK)
+        {
+            push_stack_trace(L, rc, lua_gettop( L));
+            // If one finalizer fails, don't run the others. Return this
+            // as the 'real' error, replacing what we could have had (or not)
+            // from the actual code.
+            break;
+        }
+        // no error, proceed to next finalizer                                        // ... finalizers lane_error
+    }
+
+    if (rc != LUA_OK)
+    {
+        // ERROR_FULL_STACK accounts for the presence of lane_error on the stack
+        int nb_err_slots = lua_gettop( L) - finalizers_index - ERROR_FULL_STACK;
+        // a finalizer generated an error, this is what we leave of the stack
+        for( n = nb_err_slots; n > 0; -- n)
+        {
+            lua_replace(L, n);
+        }
+        // leave on the stack only the error and optional stack trace produced by the error in the finalizer
+        lua_settop(L, nb_err_slots);
+    }
+    else // no error from the finalizers, make sure only the original return values from the lane body remain on the stack
+    {
+        lua_settop(L, finalizers_index - 1);
+    }
+
+    return rc;
+}
+
+/*
+ * ###############################################################################################
+ * ########################################### Threads ###########################################
+ * ###############################################################################################
+ */
+
+//
+// Protects modifying the selfdestruct chain
+
+#define SELFDESTRUCT_END ((Lane*)(-1))
+//
+// The chain is ended by '(Lane*)(-1)', not nullptr:
+//      'selfdestruct_first -> ... -> ... -> (-1)'
+
+/*
+ * Add the lane to selfdestruct chain; the ones still running at the end of the
+ * whole process will be cancelled.
+ */
+static void selfdestruct_add(Lane* lane_)
+{
+    std::lock_guard<std::mutex> guard{ lane_->U->selfdestruct_cs };
+    assert(lane_->selfdestruct_next == nullptr);
+
+    lane_->selfdestruct_next = lane_->U->selfdestruct_first;
+    lane_->U->selfdestruct_first = lane_;
+}
+
+// ###############################################################################################
+
+/*
+ * A free-running lane has ended; remove it from selfdestruct chain
+ */
+[[nodiscard]] static bool selfdestruct_remove(Lane* lane_)
+{
+    bool found{ false };
+    std::lock_guard<std::mutex> guard{ lane_->U->selfdestruct_cs };
+    // Make sure (within the MUTEX) that we actually are in the chain
+    // still (at process exit they will remove us from chain and then
+    // cancel/kill).
+    //
+    if (lane_->selfdestruct_next != nullptr)
+    {
+        Lane** ref = (Lane**) &lane_->U->selfdestruct_first;
+
+        while (*ref != SELFDESTRUCT_END)
+        {
+            if (*ref == lane_)
+            {
+                *ref = lane_->selfdestruct_next;
+                lane_->selfdestruct_next = nullptr;
+                // the terminal shutdown should wait until the lane is done with its lua_close()
+                lane_->U->selfdestructing_count.fetch_add(1, std::memory_order_release);
+                found = true;
+                break;
+            }
+            ref = (Lane**) &((*ref)->selfdestruct_next);
+        }
+        assert(found);
+    }
+    return found;
+}
+
+// ###############################################################################################
+
+/*
+* Process end; cancel any still free-running threads
+*/
+[[nodiscard]] static int universe_gc(lua_State* L)
+{
+    Universe* const U{ lua_tofulluserdata<Universe>(L, 1) };
+    lua_Duration const shutdown_timeout{ lua_tonumber(L, lua_upvalueindex(1)) };
+    [[maybe_unused]] char const* const op_string{ lua_tostring(L, lua_upvalueindex(2)) };
+    CancelOp const op{ which_cancel_op(op_string) };
+
+    if (U->selfdestruct_first != SELFDESTRUCT_END)
+    {
+
+        // Signal _all_ still running threads to exit (including the timer thread)
+        //
+        {
+            std::lock_guard<std::mutex> guard{ U->selfdestruct_cs };
+            Lane* lane{ U->selfdestruct_first };
+            lua_Duration timeout{ 1us };
+            while (lane != SELFDESTRUCT_END)
+            {
+                // attempt the requested cancel with a small timeout.
+                // if waiting on a linda, they will raise a cancel_error.
+                // if a cancellation hook is desired, it will be installed to try to raise an error
+                if (lane->m_thread.joinable())
+                {
+                    std::ignore = thread_cancel(lane, op, 1, timeout, true);
+                }
+                lane = lane->selfdestruct_next;
+            }
+        }
+
+        // When noticing their cancel, the lanes will remove themselves from
+        // the selfdestruct chain.
+        {
+            std::chrono::time_point<std::chrono::steady_clock> t_until{ std::chrono::steady_clock::now() + std::chrono::duration_cast<std::chrono::steady_clock::duration>(shutdown_timeout) };
+
+            while (U->selfdestruct_first != SELFDESTRUCT_END)
+            {
+                // give threads time to act on their cancel
+                std::this_thread::yield();
+                // count the number of cancelled thread that didn't have the time to act yet
+                int n{ 0 };
+                {
+                    std::lock_guard<std::mutex> guard{ U->selfdestruct_cs };
+                    Lane* lane{ U->selfdestruct_first };
+                    while (lane != SELFDESTRUCT_END)
+                    {
+                        if (lane->cancel_request != CancelRequest::None)
+                            ++n;
+                        lane = lane->selfdestruct_next;
+                    }
+                }
+                // if timeout elapsed, or we know all threads have acted, stop waiting
+                std::chrono::time_point<std::chrono::steady_clock> t_now = std::chrono::steady_clock::now();
+                if (n == 0 || (t_now >= t_until))
+                {
+                    DEBUGSPEW_CODE(fprintf(stderr, "%d uncancelled lane(s) remain after waiting %fs at process end.\n", n, shutdown_timeout.count()));
+                    break;
+                }
+            }
+        }
+
+        // If some lanes are currently cleaning after themselves, wait until they are done.
+        // They are no longer listed in the selfdestruct chain, but they still have to lua_close().
+        while (U->selfdestructing_count.load(std::memory_order_acquire) > 0)
+        {
+            std::this_thread::yield();
+        }
+    }
+
+    // If after all this, we still have some free-running lanes, it's an external user error, they should have stopped appropriately
+    {
+        std::lock_guard<std::mutex> guard{ U->selfdestruct_cs };
+        Lane* lane{ U->selfdestruct_first };
+        if (lane != SELFDESTRUCT_END)
+        {
+            // this causes a leak because we don't call U's destructor (which could be bad if the still running lanes are accessing it)
+            luaL_error(L, "Zombie thread %s refuses to die!", lane->debug_name); // doesn't return
+        }
+    }
+
+    // necessary so that calling free_deep_prelude doesn't crash because linda_id expects a linda lightuserdata at absolute slot 1
+    lua_settop(L, 0);
+    // no need to mutex-protect this as all threads in the universe are gone at that point
+    if (U->timer_deep != nullptr) // test ins case some early internal error prevented Lanes from creating the deep timer
+    {
+        [[maybe_unused]] int const prev_ref_count{ U->timer_deep->m_refcount.fetch_sub(1, std::memory_order_relaxed) };
+        ASSERT_L(prev_ref_count == 1); // this should be the last reference
+        free_deep_prelude(L, U->timer_deep);
+        U->timer_deep = nullptr;
+    }
+
+    close_keepers(U);
+
+    // remove the protected allocator, if any
+    U->protected_allocator.removeFrom(L);
+
+    U->Universe::~Universe();
+
+    // universe is no longer available (nor necessary)
+    // we need to do this in case some deep userdata objects were created before Lanes was initialized,
+    // as potentially they will be garbage collected after Lanes at application shutdown
+    universe_store(L, nullptr);
+    return 0;
+}
+
+// ###############################################################################################
+
+//---
+// = _single( [cores_uint=1] )
+//
+// Limits the process to use only 'cores' CPU cores. To be used for performance
+// testing on multicore devices. DEBUGGING ONLY!
+//
+LUAG_FUNC( set_singlethreaded)
+{
+    lua_Integer cores = luaL_optinteger(L, 1, 1);
+    (void) cores; // prevent "unused" warning
+
+#ifdef PLATFORM_OSX
+#ifdef _UTILBINDTHREADTOCPU
+    if (cores > 1)
+    {
+        return luaL_error(L, "Limiting to N>1 cores not possible");
+    }
+    // requires 'chudInitialize()'
+    utilBindThreadToCPU(0);     // # of CPU to run on (we cannot limit to 2..N CPUs?)
+    return 0;
+#else
+    return luaL_error(L, "Not available: compile with _UTILBINDTHREADTOCPU");
+#endif
+#else
+    return luaL_error(L, "not implemented");
+#endif
+}
+
+// ###############################################################################################
+
+/*
+* str= lane_error( error_val|str )
+*
+* Called if there's an error in some lane; add call stack to error message 
+* just like 'lua.c' normally does.
+*
+* ".. will be called with the error message and its return value will be the 
+*     message returned on the stack by lua_pcall."
+*
+* Note: Rather than modifying the error message itself, it would be better
+*     to provide the call stack (as string) completely separated. This would
+*     work great with non-string error values as well (current system does not).
+*     (This is NOT possible with the Lua 5.1 'lua_pcall()'; we could of course
+*     implement a Lanes-specific 'pcall' of our own that does this). TBD!!! :)
+*       --AKa 22-Jan-2009
+*/
+#if ERROR_FULL_STACK
+
+// crc64/we of string "EXTENDED_STACKTRACE_REGKEY" generated at http://www.nitrxgen.net/hashgen/
+static constexpr UniqueKey EXTENDED_STACKTRACE_REGKEY{ 0x2357c69a7c92c936ull }; // used as registry key
+
+LUAG_FUNC( set_error_reporting)
+{
+    luaL_checktype(L, 1, LUA_TSTRING);
+    char const* mode{ lua_tostring(L, 1) };
+    lua_pushliteral(L, "extended");
+    bool const extended{ strcmp(mode, "extended") == 0 };
+    bool const basic{ strcmp(mode, "basic") == 0 };
+    if (!extended && !basic)
+    {
+        return luaL_error(L, "unsupported error reporting model %s", mode);
+    }
+
+    EXTENDED_STACKTRACE_REGKEY.setValue(L, [extended](lua_State* L) { lua_pushboolean(L, extended ? 1 : 0); });
+    return 0;
+}
+
+[[nodiscard]] static int lane_error(lua_State* L)
+{
+    // error message (any type)
+    STACK_CHECK_START_ABS(L, 1);                                                       // some_error
+
+    // Don't do stack survey for cancelled lanes.
+    //
+    if (CANCEL_ERROR.equals(L, 1))
+    {
+        return 1;   // just pass on
+    }
+
+    STACK_GROW(L, 3);
+    bool const extended{ EXTENDED_STACKTRACE_REGKEY.readBoolValue(L) };
+    STACK_CHECK(L, 1);
+
+    // Place stack trace at 'registry[STACKTRACE_REGKEY]' for the 'lua_pcall()'
+    // caller to fetch. This bypasses the Lua 5.1 limitation of only one
+    // return value from error handler to 'lua_pcall()' caller.
+
+    // It's adequate to push stack trace as a table. This gives the receiver
+    // of the stack best means to format it to their liking. Also, it allows
+    // us to add more stack info later, if needed.
+    //
+    // table of { "sourcefile.lua:<line>", ... }
+    //
+    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
+    // and table index growing separate.    --AKa 22-Jan-2009
+    //
+    lua_Debug ar;
+    for (int n = 1; lua_getstack(L, n, &ar); ++n)
+    {
+        lua_getinfo(L, extended ? "Sln" : "Sl", &ar);
+        if (extended)
+        {
+            lua_newtable(L);                                                           // some_error {} {}
+
+            lua_pushstring(L, ar.source);                                              // some_error {} {} source
+            lua_setfield(L, -2, "source");                                             // some_error {} {}
+
+            lua_pushinteger(L, ar.currentline);                                        // some_error {} {} currentline
+            lua_setfield(L, -2, "currentline");                                        // some_error {} {}
+
+            lua_pushstring(L, ar.name);                                                // some_error {} {} name
+            lua_setfield(L, -2, "name");                                               // some_error {} {}
+
+            lua_pushstring(L, ar.namewhat);                                            // some_error {} {} namewhat
+            lua_setfield(L, -2, "namewhat");                                           // some_error {} {}
+
+            lua_pushstring(L, ar.what);                                                // some_error {} {} what
+            lua_setfield(L, -2, "what");                                               // some_error {} {}
+        }
+        else if (ar.currentline > 0)
+        {
+            lua_pushfstring(L, "%s:%d", ar.short_src, ar.currentline);                 // some_error {} "blah:blah"
+        }
+        else
+        {
+            lua_pushfstring(L, "%s:?", ar.short_src);                                  // some_error {} "blah"
+        }
+        lua_rawseti(L, -2, (lua_Integer) n);                                           // some_error {}
+    }
+
+    // store the stack trace table in the registry
+    STACKTRACE_REGKEY.setValue(L, [](lua_State* L) { lua_insert(L, -2); });            // some_error
+
+    STACK_CHECK(L, 1);
+    return 1; // the untouched error value
+}
+#endif // ERROR_FULL_STACK
+
+static void push_stack_trace( lua_State* L, int rc_, int stk_base_)
+{
+    // Lua 5.1 error handler is limited to one return value; it stored the stack trace in the registry
+    switch( rc_)
+    {
+        case LUA_OK: // no error, body return values are on the stack
+        break;
+
+        case LUA_ERRRUN: // cancellation or a runtime error
+#if ERROR_FULL_STACK // when ERROR_FULL_STACK, we installed a handler
+        {
+            STACK_CHECK_START_REL(L, 0);
+            // 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.pushValue(L);                                            // err trace|nil
+            STACK_CHECK(L, 1);
+
+            // For cancellation the error message is CANCEL_ERROR, and a stack trace isn't placed
+            // For other errors, the message can be whatever was thrown, and we should have a stack trace table
+            ASSERT_L(lua_type(L, 1 + stk_base_) == (CANCEL_ERROR.equals(L, stk_base_) ? LUA_TNIL : LUA_TTABLE));
+            // Just leaving the stack trace table on the stack is enough to get it through to the master.
+            break;
+        }
+#endif // fall through if not ERROR_FULL_STACK
+
+        case LUA_ERRMEM: // memory allocation error (handler not called)
+        case LUA_ERRERR: // error while running the error handler (if any, for example an out-of-memory condition)
+        default:
+        // we should have a single value which is either a string (the error message) or CANCEL_ERROR
+        ASSERT_L((lua_gettop(L) == stk_base_) && ((lua_type(L, stk_base_) == LUA_TSTRING) || CANCEL_ERROR.equals(L, stk_base_)));
+        break;
+    }
+}
+
+// #################################################################################################
+
+LUAG_FUNC(set_debug_threadname)
+{
+    // fnv164 of string "debug_threadname" generated at https://www.pelock.com/products/hash-calculator
+    constexpr UniqueKey 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_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->debug_name = lua_tostring(L, -1);
+    // keep a direct pointer on the string
+    THREAD_SETNAME(lane->debug_name);
+    // to see VM name in Decoda debugger Virtual Machine window
+    lua_setglobal(L, "decoda_name"); //
+    STACK_CHECK(L, 0);
+    return 0;
+}
+
+// #################################################################################################
+
+LUAG_FUNC(get_debug_threadname)
+{
+    Lane* const lane{ lua_toLane(L, 1) };
+    luaL_argcheck(L, lua_gettop(L) == 1, 2, "too many arguments");
+    lua_pushstring(L, lane->debug_name);
+    return 1;
+}
+
+// #################################################################################################
+
+LUAG_FUNC(set_thread_priority)
+{
+    lua_Integer const prio{ luaL_checkinteger(L, 1) };
+    // public Lanes API accepts a generic range -3/+3
+    // that will be remapped into the platform-specific scheduler priority scheme
+    // On some platforms, -3 is equivalent to -2 and +3 to +2
+    if (prio < THREAD_PRIO_MIN || prio > THREAD_PRIO_MAX)
+    {
+        return luaL_error(L, "priority out of range: %d..+%d (%d)", THREAD_PRIO_MIN, THREAD_PRIO_MAX, prio);
+    }
+    THREAD_SET_PRIORITY(static_cast<int>(prio), universe_get(L)->m_sudo);
+    return 0;
+}
+
+// #################################################################################################
+
+LUAG_FUNC(set_thread_affinity)
+{
+    lua_Integer const affinity{ luaL_checkinteger(L, 1) };
+    if (affinity <= 0)
+    {
+        return luaL_error(L, "invalid affinity (%d)", affinity);
+    }
+    THREAD_SET_AFFINITY( static_cast<unsigned int>(affinity));
+    return 0;
+}
+
+#if USE_DEBUG_SPEW()
+// can't use direct LUA_x errcode indexing because the sequence is not the same between Lua 5.1 and 5.2 :-(
+// LUA_ERRERR doesn't have the same value
+struct errcode_name
+{
+    int code;
+    char const* name;
+};
+
+static struct errcode_name s_errcodes[] =
+{
+    { LUA_OK, "LUA_OK"},
+    { LUA_YIELD, "LUA_YIELD"},
+    { LUA_ERRRUN, "LUA_ERRRUN"},
+    { LUA_ERRSYNTAX, "LUA_ERRSYNTAX"},
+    { LUA_ERRMEM, "LUA_ERRMEM"},
+    { LUA_ERRGCMM, "LUA_ERRGCMM"},
+    { LUA_ERRERR, "LUA_ERRERR"},
+};
+static char const* get_errcode_name( int _code)
+{
+    int i;
+    for( i = 0; i < 7; ++ i)
+    {
+        if (s_errcodes[i].code == _code)
+        {
+            return s_errcodes[i].name;
+        }
+    }
+    return "<nullptr>";
+}
+#endif // USE_DEBUG_SPEW()
+
+static void lane_main(Lane* lane)
+{
+    lua_State* const L{ lane->L };
+    // wait until the launching thread has finished preparing L
+    lane->m_ready.wait();
+    int rc{ LUA_ERRRUN };
+    if (lane->m_status == Lane::Pending) // nothing wrong happened during preparation, we can work
+    {
+        // At this point, the lane function and arguments are on the stack
+        int const nargs{ lua_gettop(L) - 1 };
+        DEBUGSPEW_CODE(Universe* U = universe_get(L));
+        lane->m_status = Lane::Running; // Pending -> Running
+
+        // Tie "set_finalizer()" to the state
+        lua_pushcfunction(L, LG_set_finalizer);
+        populate_func_lookup_table(L, -1, "set_finalizer");
+        lua_setglobal(L, "set_finalizer");
+
+        // Tie "set_debug_threadname()" to the state
+        // But don't register it in the lookup database because of the Lane pointer upvalue
+        lua_pushlightuserdata(L, lane);
+        lua_pushcclosure(L, LG_set_debug_threadname, 1);
+        lua_setglobal(L, "set_debug_threadname");
+
+        // Tie "cancel_test()" to the state
+        lua_pushcfunction(L, LG_cancel_test);
+        populate_func_lookup_table(L, -1, "cancel_test");
+        lua_setglobal(L, "cancel_test");
+
+        // this could be done in lane_new before the lane body function is pushed on the stack to avoid unnecessary stack slot shifting around
+#if ERROR_FULL_STACK
+        // Tie "set_error_reporting()" to the state
+        lua_pushcfunction(L, LG_set_error_reporting);
+        populate_func_lookup_table(L, -1, "set_error_reporting");
+        lua_setglobal(L, "set_error_reporting");
+
+        STACK_GROW(L, 1);
+        lua_pushcfunction(L, lane_error); // func args handler
+        lua_insert(L, 1); // handler func args
+#endif // ERROR_FULL_STACK
+
+        rc = lua_pcall(L, nargs, LUA_MULTRET, ERROR_FULL_STACK); // retvals|err
+
+#if ERROR_FULL_STACK
+        lua_remove(L, 1); // retvals|error
+#endif // ERROR_FULL_STACK
+
+        // in case of error and if it exists, fetch stack trace from registry and push it
+        push_stack_trace(L, rc, 1); // retvals|error [trace]
+
+        DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "Lane %p body: %s (%s)\n" INDENT_END, L, get_errcode_name(rc), CANCEL_ERROR.equals(L, 1) ? "cancelled" : lua_typename(L, lua_type(L, 1))));
+        // STACK_DUMP(L);
+        //  Call finalizers, if the script has set them up.
+        //
+        int rc2{ run_finalizers(L, rc) };
+        DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "Lane %p finalizer: %s\n" INDENT_END, L, get_errcode_name(rc2)));
+        if (rc2 != LUA_OK) // Error within a finalizer!
+        {
+            // the finalizer generated an error, and left its own error message [and stack trace] on the stack
+            rc = rc2; // we're overruling the earlier script error or normal return
+        }
+        lane->m_waiting_on = nullptr; // just in case
+        if (selfdestruct_remove(lane)) // check and remove (under lock!)
+        {
+            // We're a free-running thread and no-one's there to clean us up.
+            lua_close(lane->L);
+            lane->L = nullptr; // just in case
+            lane->U->selfdestruct_cs.lock();
+            // done with lua_close(), terminal shutdown sequence may proceed
+            lane->U->selfdestructing_count.fetch_sub(1, std::memory_order_release);
+            lane->U->selfdestruct_cs.unlock();
+
+            // we destroy our jthread member from inside the thread body, so we have to detach so that we don't try to join, as this doesn't seem a good idea
+            lane->m_thread.detach();
+            delete lane;
+            lane = nullptr;
+        }
+    }
+    if (lane)
+    {
+        // leave results (1..top) or error message + stack trace (1..2) on the stack - master will copy them
+
+        Lane::Status st = (rc == LUA_OK) ? Lane::Done : CANCEL_ERROR.equals(L, 1) ? Lane::Cancelled : Lane::Error;
+
+        {
+            // 'm_done_mutex' protects the -> Done|Error|Cancelled state change
+            std::lock_guard lock{ lane->m_done_mutex };
+            lane->m_status = st;
+            lane->m_done_signal.notify_one();// wake up master (while 'lane->m_done_mutex' is on)
+        }
+    }
+}
+
+// #################################################################################################
+
+// --- If a client wants to transfer stuff of a given module from the current state to another Lane, the module must be required
+// with lanes.require, that will call the regular 'require', then populate the lookup database in the source lane
+// module = lanes.require( "modname")
+// upvalue[1]: _G.require
+LUAG_FUNC(require)
+{
+    char const* name = lua_tostring(L, 1);
+    int const nargs = lua_gettop(L);
+    DEBUGSPEW_CODE(Universe* U = universe_get(L));
+    STACK_CHECK_START_REL(L, 0);
+    DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "lanes.require %s BEGIN\n" INDENT_END, name));
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
+    lua_pushvalue(L, lua_upvalueindex(1)); // "name" require
+    lua_insert(L, 1); // require "name"
+    lua_call(L, nargs, 1); // module
+    populate_func_lookup_table(L, -1, name);
+    DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "lanes.require %s END\n" INDENT_END, name));
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
+    STACK_CHECK(L, 0);
+    return 1;
+}
+
+// #################################################################################################
+
+// --- If a client wants to transfer stuff of a previously required module from the current state to another Lane, the module must be registered
+// to populate the lookup database in the source lane (and in the destination too, of course)
+// lanes.register( "modname", module)
+LUAG_FUNC(register)
+{
+    char const* name = luaL_checkstring(L, 1);
+    LuaType const mod_type{ lua_type_as_enum(L, 2) };
+    // ignore extra parameters, just in case
+    lua_settop(L, 2);
+    luaL_argcheck(L, (mod_type == LuaType::TABLE) || (mod_type == LuaType::FUNCTION), 2, "unexpected module type");
+    DEBUGSPEW_CODE(Universe* U = universe_get(L));
+    STACK_CHECK_START_REL(L, 0); // "name" mod_table
+    DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "lanes.register %s BEGIN\n" INDENT_END, name));
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
+    populate_func_lookup_table(L, -1, name);
+    DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "lanes.register %s END\n" INDENT_END, name));
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
+    STACK_CHECK(L, 0);
+    return 0;
+}
+
+// #################################################################################################
+
+// crc64/we of string "GCCB_KEY" generated at http://www.nitrxgen.net/hashgen/
+static constexpr UniqueKey GCCB_KEY{ 0xcfb1f046ef074e88ull };
+
+//---
+// lane_ud = lane_new( function
+//                   , [libs_str]
+//                   , [priority_int=0]
+//                   , [globals_tbl]
+//                   , [package_tbl]
+//                   , [required_tbl]
+//                   , [gc_cb_func]
+//                  [, ... args ...])
+//
+// Upvalues: metatable to use for 'lane_ud'
+//
+LUAG_FUNC(lane_new)
+{
+    char const* const libs_str{ lua_tostring(L, 2) };
+    bool const have_priority{ !lua_isnoneornil(L, 3) };
+    int const priority{ have_priority ? (int) lua_tointeger(L, 3) : THREAD_PRIO_DEFAULT };
+    int const globals_idx{ lua_isnoneornil(L, 4) ? 0 : 4 };
+    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 };
+
+    static constexpr int FIXED_ARGS{ 7 };
+    int const nargs{ lua_gettop(L) - FIXED_ARGS };
+    Universe* const U{ universe_get(L) };
+    ASSERT_L( nargs >= 0);
+
+    // public Lanes API accepts a generic range -3/+3
+    // that will be remapped into the platform-specific scheduler priority scheme
+    // On some platforms, -3 is equivalent to -2 and +3 to +2
+    if (have_priority && (priority < THREAD_PRIO_MIN || priority > THREAD_PRIO_MAX))
+    {
+        return luaL_error(L, "Priority out of range: %d..+%d (%d)", THREAD_PRIO_MIN, THREAD_PRIO_MAX, priority);
+    }
+
+    /* --- Create and prepare the sub state --- */
+    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lane_new: setup\n" INDENT_END));
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
+
+    // populate with selected libraries at the same time
+    lua_State* const L2{ luaG_newstate(U, Source{ L }, libs_str) };         // L                                                                    // L2
+
+    // 'lane' is allocated from heap, not Lua, since its life span may surpass the handle's (if free running thread)
+    Lane* const lane{ new (U) Lane{ U, L2 } };
+    if (lane == nullptr)
+    {
+        return luaL_error(L, "could not create lane: out of memory");
+    }
+
+    class OnExit
+    {
+        private:
+
+        lua_State* const m_L;
+        Lane* m_lane{ nullptr };
+        int const m_gc_cb_idx;
+        DEBUGSPEW_CODE(Universe* const U); // for DEBUGSPEW only (hence the absence of m_ prefix)
+
+        public:
+
+        OnExit(lua_State* L_, Lane* lane_, int gc_cb_idx_ DEBUGSPEW_COMMA_PARAM(Universe* U_))
+        : m_L{ L_ }
+        , m_lane{ lane_ }
+        , m_gc_cb_idx{ gc_cb_idx_ }
+        DEBUGSPEW_COMMA_PARAM(U{ U_ })
+        {}
+
+        ~OnExit()
+        {
+            if (m_lane)
+            {
+                // we still need a full userdata so that garbage collection can do its thing
+                prepareUserData();
+                // leave a single cancel_error on the stack for the caller
+                lua_settop(m_lane->L, 0);
+                CANCEL_ERROR.pushKey(m_lane->L);
+                {
+                    std::lock_guard lock{ m_lane->m_done_mutex };
+                    m_lane->m_status = Lane::Cancelled;
+                    m_lane->m_done_signal.notify_one(); // wake up master (while 'lane->m_done_mutex' is on)
+                }
+                // unblock the thread so that it can terminate gracefully
+                m_lane->m_ready.count_down();
+            }
+        }
+
+        private:
+
+        void prepareUserData()
+        {
+            DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "lane_new: preparing lane userdata\n" INDENT_END));
+            STACK_CHECK_START_REL(m_L, 0);
+            // a Lane full userdata needs a single uservalue
+            Lane** const ud{ lua_newuserdatauv<Lane*>(m_L, 1) };                     // ... lane
+            *ud = m_lane; // don't forget to store the pointer in the userdata!
+
+            // Set metatable for the userdata
+            //
+            lua_pushvalue(m_L, lua_upvalueindex(1));                                 // ... lane mt
+            lua_setmetatable(m_L, -2);                                               // ... lane
+            STACK_CHECK(m_L, 1);
+
+            // Create uservalue for the userdata
+            // (this is where lane body return values will be stored when the handle is indexed by a numeric key)
+            lua_newtable(m_L);                                                       // ... lane uv
+
+            // Store the gc_cb callback in the uservalue
+            if (m_gc_cb_idx > 0)
+            {
+                GCCB_KEY.pushKey(m_L);                                               // ... lane uv k
+                lua_pushvalue(m_L, m_gc_cb_idx);                                     // ... lane uv k gc_cb
+                lua_rawset(m_L, -3);                                                 // ... lane uv
+            }
+
+            lua_setiuservalue(m_L, -2, 1);                                           // ... lane
+            STACK_CHECK(m_L, 1);
+        }
+
+        public:
+
+        void success()
+        {
+            prepareUserData();
+            m_lane->m_ready.count_down();
+            m_lane = nullptr;
+        }
+    } onExit{ L, lane, gc_cb_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));
+    lane->startThread(priority);
+
+    STACK_GROW( L2, nargs + 3);                                                                                                                     //
+    STACK_CHECK_START_REL(L2, 0);
+
+    STACK_GROW(L, 3);                                                       // func libs priority globals package required gc_cb [... args ...]
+    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);                                                                                                           // "..."
+    lua_setglobal( L2, "decoda_name");                                                                                                              //
+    ASSERT_L( lua_gettop( L2) == 0);
+
+    // package
+    if (package_idx != 0)
+    {
+        DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "lane_new: update 'package'\n" INDENT_END));
+        // when copying with mode LookupMode::LaneBody, should raise an error in case of problem, not leave it one the stack
+        [[maybe_unused]] InterCopyResult const ret{ luaG_inter_copy_package(U, Source{ L }, Dest{ L2 }, package_idx, LookupMode::LaneBody) };
+        ASSERT_L(ret == InterCopyResult::Success); // either all went well, or we should not even get here
+    }
+
+    // modules to require in the target lane *before* the function is transfered!
+    if (required_idx != 0)
+    {
+        int nbRequired = 1;
+        DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lane_new: require 'required' list\n" INDENT_END));
+        DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
+        // should not happen, was checked in lanes.lua before calling lane_new()
+        if (lua_type(L, required_idx) != LUA_TTABLE)
+        {
+            luaL_error(L, "expected required module list as a table, got %s", luaL_typename(L, required_idx)); // doesn't return
+        }
+
+        lua_pushnil(L);                                                     // func libs priority globals package required gc_cb [... args ...] nil
+        while (lua_next(L, required_idx) != 0)                              // func libs priority globals package required gc_cb [... args ...] n "modname"
+        {
+            if (lua_type(L, -1) != LUA_TSTRING || lua_type(L, -2) != LUA_TNUMBER || lua_tonumber(L, -2) != nbRequired)
+            {
+                luaL_error(L, "required module list should be a list of strings"); // doesn't return
+            }
+            else
+            {
+                // require the module in the target state, and populate the lookup table there too
+                size_t len;
+                char const* name = lua_tolstring(L, -1, &len);
+                DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lane_new: require '%s'\n" INDENT_END, name));
+
+                // require the module in the target lane
+                lua_getglobal( L2, "require");                                                                                                      // require()?
+                if (lua_isnil( L2, -1))
+                {
+                    lua_pop( L2, 1);                                                                                                                //
+                    luaL_error(L, "cannot pre-require modules without loading 'package' library first"); // doesn't return
+                }
+                else
+                {
+                    lua_pushlstring( L2, name, len);                                                                                                // require() name
+                    if (lua_pcall( L2, 1, 1, 0) != LUA_OK)                                                                                          // ret/errcode
+                    {
+                        // propagate error to main state if any
+                        std::ignore = luaG_inter_move(U
+                            , Source{ L2 }, Dest{ L }
+                            , 1, LookupMode::LaneBody
+                        );                                                  // func libs priority globals package required gc_cb [... args ...] n "modname" error
+                        raise_lua_error(L);
+                    }
+                    // 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);                                                                                                                //
+                }
+            }
+            lua_pop(L, 1);                                                  // func libs priority globals package required gc_cb [... args ...] n
+            ++ nbRequired;
+        }                                                                   // func libs priority globals package required gc_cb [... args ...]
+        DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
+    }
+    STACK_CHECK(L, 0);
+    STACK_CHECK(L2, 0);                                                                                                                             //
+
+    // 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...
+    //
+    if (globals_idx != 0)
+    {
+        DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lane_new: transfer globals\n" INDENT_END));
+        if (!lua_istable(L, globals_idx))
+        {
+            luaL_error(L, "Expected table, got %s", luaL_typename(L, globals_idx)); // doesn't return
+        }
+
+        DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
+        lua_pushnil(L);                                                     // func libs priority globals package required gc_cb [... args ...] nil
+        // Lua 5.2 wants us to push the globals table on the stack
+        lua_pushglobaltable(L2);                                                                                                                    // _G
+        while( lua_next(L, globals_idx))                                    // func libs priority globals package required gc_cb [... args ...] k v
+        {
+            std::ignore = luaG_inter_copy(U, Source{ L }, Dest{ L2 }, 2, LookupMode::LaneBody);                                                     // _G k v
+            // assign it in L2's globals table
+            lua_rawset(L2, -3);                                                                                                                     // _G
+            lua_pop(L, 1);                                                  // func libs priority globals package required gc_cb [... args ...] k
+        }                                                                   // func libs priority globals package required gc_cb [... args ...]
+        lua_pop( L2, 1);                                                                                                                            //
+
+        DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
+    }
+    STACK_CHECK(L, 0);
+    STACK_CHECK(L2, 0);
+
+    // Lane main function
+    LuaType const func_type{ lua_type_as_enum(L, 1) };
+    if (func_type == LuaType::FUNCTION)
+    {
+        DEBUGSPEW_CODE(fprintf( stderr, INDENT_BEGIN "lane_new: transfer lane body\n" INDENT_END));
+        DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
+        lua_pushvalue(L, 1);                                                // func libs priority globals package required gc_cb [... args ...] func
+        InterCopyResult const res{ luaG_inter_move(U, Source{ L }, Dest{ L2 }, 1, LookupMode::LaneBody) }; // func libs priority globals package required gc_cb [... args ...]     // func
+        DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
+        if (res != InterCopyResult::Success)
+        {
+            luaL_error(L, "tried to copy unsupported types"); // doesn't return
+        }
+    }
+    else if (func_type == LuaType::STRING)
+    {
+        DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "lane_new: compile lane body\n" INDENT_END));
+        // compile the string
+        if (luaL_loadstring(L2, lua_tostring(L, 1)) != 0)                                                                                           // func
+        {
+            luaL_error(L, "error when parsing lane function code"); // doesn't return
+        }
+    }
+    else
+    {
+        luaL_error(L, "Expected function, got %s", lua_typename(L, func_type)); // doesn't return
+    }
+    STACK_CHECK(L, 0);
+    STACK_CHECK(L2, 1);
+    ASSERT_L(lua_isfunction(L2, 1));
+
+    // revive arguments
+    if (nargs > 0)
+    {
+        DEBUGSPEW_CODE(fprintf( stderr, INDENT_BEGIN "lane_new: transfer lane arguments\n" INDENT_END));
+        DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
+        InterCopyResult const res{ luaG_inter_move(U, Source{ L }, Dest{ L2 }, nargs, LookupMode::LaneBody) }; // func libs priority globals package required gc_cb                // func [... args ...]
+        DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
+        if (res != InterCopyResult::Success)
+        {
+            luaL_error(L, "tried to copy unsupported types"); // doesn't return
+        }
+    }
+    STACK_CHECK(L, -nargs);
+    ASSERT_L(lua_gettop( L) == FIXED_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(L2, 1 + nargs);
+
+    STACK_CHECK_RESET_REL(L, 0);
+    // all went well, the lane's thread can start working
+    onExit.success();
+    // we should have the lane userdata on top of the stack
+    STACK_CHECK(L, 1);
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
+    return 1;
+}
+
+// #################################################################################################
+
+//---
+// = thread_gc( lane_ud )
+//
+// Cleanup for a thread userdata. If the thread is still executing, leave it
+// alive as a free-running thread (will clean up itself).
+//
+// * Why NOT cancel/kill a loose thread: 
+//
+// At least timer system uses a free-running thread, they should be handy
+// and the issue of canceling/killing threads at gc is not very nice, either
+// (would easily cause waits at gc cycle, which we don't want).
+//
+[[nodiscard]] static int lane_gc(lua_State* L)
+{
+    bool have_gc_cb{ false };
+    Lane* const lane{ lua_toLane(L, 1) };                                // ud
+
+    // if there a gc callback?
+    lua_getiuservalue(L, 1, 1);                                          // ud uservalue
+    GCCB_KEY.pushKey(L);                                                 // ud uservalue __gc
+    lua_rawget(L, -2);                                                   // ud uservalue gc_cb|nil
+    if (!lua_isnil(L, -1))
+    {
+        lua_remove(L, -2);                                               // ud gc_cb|nil
+        lua_pushstring(L, lane->debug_name);                             // ud gc_cb name
+        have_gc_cb = true;
+    }
+    else
+    {
+        lua_pop(L, 2);                                                   // ud
+    }
+
+    // We can read 'lane->status' without locks, but not wait for it
+    if (lane->m_status < Lane::Done)
+    {
+        // still running: will have to be cleaned up later
+        selfdestruct_add(lane);
+        assert(lane->selfdestruct_next);
+        if (have_gc_cb)
+        {
+            lua_pushliteral(L, "selfdestruct");                          // ud gc_cb name status
+            lua_call(L, 2, 0);                                           // ud
+        }
+        return 0;
+    }
+    else if (lane->L)
+    {
+        // no longer accessing the Lua VM: we can close right now
+        lua_close(lane->L);
+        lane->L = nullptr;
+        // just in case, but s will be freed soon so...
+        lane->debug_name = "<gc>";
+    }
+
+    // Clean up after a (finished) thread
+    delete lane;
+
+    // do this after lane cleanup in case the callback triggers an error
+    if (have_gc_cb)
+    {
+        lua_pushliteral(L, "closed");                                    // ud gc_cb name status
+        lua_call(L, 2, 0);                                               // ud
+    }
+    return 0;
+}
+
+// #################################################################################################
+
+//---
+// str= thread_status( lane )
+//
+// Returns: "pending"   not started yet
+//          -> "running"   started, doing its work..
+//             <-> "waiting"   blocked in a receive()
+//                -> "done"     finished, results are there
+//                   / "error"     finished at an error, error value is there
+//                   / "cancelled"   execution cancelled by M (state gone)
+//
+[[nodiscard]] static char const* thread_status_string(Lane* lane_)
+{
+    Lane::Status const st{ lane_->m_status }; // read just once (volatile)
+    char const* str =
+        (st == Lane::Pending) ? "pending" :
+        (st == Lane::Running) ? "running" :    // like in 'co.status()'
+        (st == Lane::Waiting) ? "waiting" :
+        (st == Lane::Done) ? "done" :
+        (st == Lane::Error) ? "error" :
+        (st == Lane::Cancelled) ? "cancelled" : nullptr;
+    return str;
+}
+
+// #################################################################################################
+
+void push_thread_status(lua_State* L, Lane* lane_)
+{
+    char const* const str{ thread_status_string(lane_) };
+    ASSERT_L(str);
+
+    std::ignore = lua_pushstring(L, str);
+}
+
+// #################################################################################################
+
+//---
+// [...] | [nil, err_any, stack_tbl]= thread_join( lane_ud [, wait_secs=-1] )
+//
+//  timeout:   returns nil
+//  done:      returns return values (0..N)
+//  error:     returns nil + error value [+ stack table]
+//  cancelled: returns nil
+//
+LUAG_FUNC(thread_join)
+{
+    Lane* const lane{ lua_toLane(L, 1) };
+    lua_Duration const duration{ luaL_optnumber(L, 2, -1.0) };
+    lua_State* const L2{ lane->L };
+
+    bool const done{ !lane->m_thread.joinable() || lane->waitForCompletion(duration) };
+    if (!done || !L2)
+    {
+        STACK_GROW(L, 2);
+        lua_pushnil(L);
+        lua_pushliteral(L, "timeout");
+        return 2;
+    }
+
+    STACK_CHECK_START_REL(L, 0);
+    // Thread is Done/Error/Cancelled; all ours now
+
+    int ret{ 0 };
+    Universe* const U{ lane->U };
+    // debug_name 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);
+    switch (lane->m_status)
+    {
+        case Lane::Done:
+        {
+            int const n{ lua_gettop(L2) }; // whole L2 stack
+            if ((n > 0) && (luaG_inter_move(U, Source{ L2 }, Dest{ L }, n, LookupMode::LaneBody) != InterCopyResult::Success))
+            {
+                luaL_error(L, "tried to copy unsupported types"); // doesn't return
+            }
+            ret = n;
+        }
+        break;
+
+        case Lane::Error:
+        {
+            int const n{ lua_gettop(L2) };
+            STACK_GROW(L, 3);
+            lua_pushnil(L);
+            // even when ERROR_FULL_STACK, if the error is not LUA_ERRRUN, the handler wasn't called, and we only have 1 error message on the stack ...
+            if (luaG_inter_move(U, Source{ L2 }, Dest{ L }, n, LookupMode::LaneBody) != InterCopyResult::Success) // nil "err" [trace]
+            {
+                luaL_error(L, "tried to copy unsupported types: %s", lua_tostring(L, -n)); // doesn't return
+            }
+            ret = 1 + n;
+        }
+        break;
+
+        case Lane::Cancelled:
+        ret = 0;
+        break;
+
+        default:
+        DEBUGSPEW_CODE(fprintf(stderr, "Status: %d\n", lane->m_status));
+        ASSERT_L(false);
+        ret = 0;
+    }
+    lua_close(L2);
+    lane->L = nullptr;
+    STACK_CHECK(L, ret);
+    return ret;
+}
+
+
+//---
+// thread_index( ud, key) -> value
+//
+// If key is found in the environment, return it
+// If key is numeric, wait until the thread returns and populate the environment with the return values
+// If the return values signal an error, propagate it
+// If key is "status" return the thread status
+// Else raise an error
+LUAG_FUNC(thread_index)
+{
+    static constexpr int UD{ 1 };
+    static constexpr int KEY{ 2 };
+    static constexpr int USR{ 3 };
+    Lane* const lane{ lua_toLane(L, UD) };
+    ASSERT_L(lua_gettop(L) == 2);
+
+    STACK_GROW(L, 8); // up to 8 positions are needed in case of error propagation
+
+    // If key is numeric, wait until the thread returns and populate the environment with the return values
+    if (lua_type(L, KEY) == LUA_TNUMBER)
+    {
+        // first, check that we don't already have an environment that holds the requested value
+        {
+            // If key is found in the uservalue, return it
+            lua_getiuservalue(L, UD, 1);
+            lua_pushvalue(L, KEY);
+            lua_rawget(L, USR);
+            if (!lua_isnil(L, -1))
+            {
+            return 1;
+            }
+            lua_pop(L, 1);
+        }
+        {
+            // check if we already fetched the values from the thread or not
+            lua_Integer key = lua_tointeger(L, KEY);
+            lua_pushinteger(L, 0);
+            lua_rawget(L, USR);
+            bool const fetched{ !lua_isnil(L, -1) };
+            lua_pop(L, 1); // back to our 2 args + uservalue on the stack
+            if (!fetched)
+            {
+                lua_pushinteger(L, 0);
+                lua_pushboolean(L, 1);
+                lua_rawset(L, USR);
+                // wait until thread has completed
+                lua_pushcfunction(L, LG_thread_join);
+                lua_pushvalue(L, UD);
+                lua_call(L, 1, LUA_MULTRET); // all return values are on the stack, at slots 4+
+                switch (lane->m_status)
+                {
+                    default:
+                    // this is an internal error, we probably never get here
+                    lua_settop(L, 0);
+                    lua_pushliteral(L, "Unexpected status: ");
+                    lua_pushstring(L, thread_status_string(lane));
+                    lua_concat(L, 2);
+                    raise_lua_error(L);
+                    [[fallthrough]]; // fall through if we are killed, as we got nil, "killed" on the stack
+
+                    case Lane::Done: // got regular return values
+                    {
+                        int const nvalues{ lua_gettop(L) - 3 };
+                        for (int i = nvalues; i > 0; --i)
+                        {
+                            // pop the last element of the stack, to store it in the uservalue at its proper index
+                            lua_rawseti(L, USR, i);
+                        }
+                    }
+                    break;
+
+                    case Lane::Error: // got 3 values: nil, errstring, callstack table
+                    // me[-2] could carry the stack table, but even
+                    // me[-1] is rather unnecessary (and undocumented);
+                    // use ':join()' instead.   --AKa 22-Jan-2009
+                    ASSERT_L(lua_isnil(L, 4) && !lua_isnil(L, 5) && lua_istable(L, 6));
+                    // store errstring at key -1
+                    lua_pushnumber(L, -1);
+                    lua_pushvalue(L, 5);
+                    lua_rawset(L, USR);
+                    break;
+
+                    case Lane::Cancelled:
+                     // do nothing
+                    break;
+                }
+            }
+            lua_settop(L, 3);                                                    // UD KEY ENV
+            if (key != -1)
+            {
+                lua_pushnumber(L, -1);                                           // UD KEY ENV -1
+                lua_rawget(L, USR);                                              // UD KEY ENV "error"
+                if (!lua_isnil(L, -1)) // an error was stored
+                {
+                    // Note: Lua 5.1 interpreter is not prepared to show
+                    //       non-string errors, so we use 'tostring()' here
+                    //       to get meaningful output.  --AKa 22-Jan-2009
+                    //
+                    //       Also, the stack dump we get is no good; it only
+                    //       lists our internal Lanes functions. There seems
+                    //       to be no way to switch it off, though.
+                    //
+                    // Level 3 should show the line where 'h[x]' was read
+                    // but this only seems to work for string messages
+                    // (Lua 5.1.4). No idea, why.   --AKa 22-Jan-2009
+                    lua_getmetatable(L, UD);                                     // UD KEY ENV "error" mt
+                    lua_getfield(L, -1, "cached_error");                         // UD KEY ENV "error" mt error()
+                    lua_getfield(L, -2, "cached_tostring");                      // UD KEY ENV "error" mt error() tostring()
+                    lua_pushvalue(L, 4);                                         // UD KEY ENV "error" mt error() tostring() "error"
+                    lua_call(L, 1, 1); // tostring( errstring) -- just in case   // UD KEY ENV "error" mt error() "error"
+                    lua_pushinteger(L, 3);                                       // UD KEY ENV "error" mt error() "error" 3
+                    lua_call(L, 2, 0); // error( tostring( errstring), 3)        // UD KEY ENV "error" mt
+                }
+                else
+                {
+                    lua_pop(L, 1); // back to our 3 arguments on the stack
+                }
+            }
+            lua_rawgeti(L, USR, (int)key);
+        }
+        return 1;
+    }
+    if (lua_type(L, KEY) == LUA_TSTRING)
+    {
+        char const* const keystr{ lua_tostring(L, KEY) };
+        lua_settop(L, 2); // keep only our original arguments on the stack
+        if (strcmp( keystr, "status") == 0)
+        {
+            push_thread_status(L, lane); // push the string representing the status
+            return 1;
+        }
+        // return UD.metatable[key]
+        lua_getmetatable(L, UD); // UD KEY mt
+        lua_replace(L, -3);      // mt KEY
+        lua_rawget(L, -2);       // mt value
+        // only "cancel" and "join" are registered as functions, any other string will raise an error
+        if (lua_iscfunction(L, -1))
+        {
+            return 1;
+        }
+        return luaL_error(L, "can't index a lane with '%s'", keystr);
+    }
+    // unknown key
+    lua_getmetatable(L, UD);
+    lua_getfield(L, -1, "cached_error");
+    lua_pushliteral(L, "Unknown key: ");
+    lua_pushvalue(L, KEY);
+    lua_concat(L, 2);
+    lua_call(L, 1, 0); // error( "Unknown key: " .. key) -> doesn't return
+    return 0;
+}
+
+#if HAVE_LANE_TRACKING()
+//---
+// threads() -> {}|nil
+//
+// Return a list of all known lanes
+LUAG_FUNC(threads)
+{
+    int const top{ lua_gettop(L) };
+    Universe* const U{ universe_get(L) };
+
+    // List _all_ still running threads
+    //
+    std::lock_guard<std::mutex> guard{ U->tracking_cs };
+    if (U->tracking_first && U->tracking_first != TRACKING_END)
+    {
+        Lane* lane{ U->tracking_first };
+        int index = 0;
+        lua_newtable(L);                                       // {}
+        while (lane != TRACKING_END)
+        {
+            // insert a { name, status } tuple, so that several lanes with the same name can't clobber each other
+            lua_newtable(L);                                   // {} {}
+            lua_pushstring(L, lane->debug_name);               // {} {} "name"
+            lua_setfield(L, -2, "name");                       // {} {}
+            push_thread_status(L, lane);                       // {} {} "status"
+            lua_setfield(L, -2, "status");                     // {} {}
+            lua_rawseti(L, -2, ++index);                       // {}
+            lane = lane->tracking_next;
+        }
+    }
+    return lua_gettop(L) - top;                                // 0 or 1
+}
+#endif // HAVE_LANE_TRACKING()
+
+/*
+ * ###############################################################################################
+ * ######################################## Timer support ########################################
+ * ###############################################################################################
+ */
+
+/*
+* secs = now_secs()
+*
+* Returns the current time, as seconds. Resolution depends on std::system_clock implementation
+* Can't use std::chrono::steady_clock because we need the same baseline as std::mktime
+*/
+LUAG_FUNC(now_secs)
+{
+    auto const now{ std::chrono::system_clock::now() };
+    lua_Duration duration { now.time_since_epoch() };
+
+    lua_pushnumber(L, duration.count());
+    return 1;
+}
+
+// #################################################################################################
+
+/*
+* wakeup_at_secs= wakeup_conv(date_tbl)
+*/
+LUAG_FUNC(wakeup_conv)
+{
+    // date_tbl
+    // .year (four digits)
+    // .month (1..12)
+    // .day (1..31)
+    // .hour (0..23)
+    // .min (0..59)
+    // .sec (0..61)
+    // .yday (day of the year)
+    // .isdst (daylight saving on/off)
+
+    STACK_CHECK_START_REL(L, 0);
+    auto readInteger = [L](char const* name_)
+    {
+        lua_getfield(L, 1, name_);
+        lua_Integer const val{ lua_tointeger(L, -1) };
+        lua_pop(L, 1);
+        return static_cast<int>(val);
+    };
+    int const year{ readInteger("year") };
+    int const month{ readInteger("month") };
+    int const day{ readInteger("day") };
+    int const hour{ readInteger("hour") };
+    int const min{ readInteger("min") };
+    int const sec{ readInteger("sec") };
+    STACK_CHECK(L, 0);
+
+    // If Lua table has '.isdst' we trust that. If it does not, we'll let
+    // 'mktime' decide on whether the time is within DST or not (value -1).
+    //
+    lua_getfield(L, 1, "isdst" );
+    int const isdst{ lua_isboolean(L, -1) ? lua_toboolean(L, -1) : -1 };
+    lua_pop(L,1);
+    STACK_CHECK(L, 0);
+
+    std::tm t{};
+    t.tm_year = year - 1900;
+    t.tm_mon= month-1;     // 0..11
+    t.tm_mday= day;        // 1..31
+    t.tm_hour= hour;       // 0..23
+    t.tm_min= min;         // 0..59
+    t.tm_sec= sec;         // 0..60
+    t.tm_isdst= isdst;     // 0/1/negative
+
+    lua_pushnumber(L, static_cast<lua_Number>(std::mktime(&t))); // resolution: 1 second
+    return 1;
+}
+
+/*
+ * ###############################################################################################
+ * ######################################## Module linkage #######################################
+ * ###############################################################################################
+ */
+
+extern int LG_linda(lua_State* L);
+static struct luaL_Reg const lanes_functions[] =
+{
+    { "linda", LG_linda },
+    { "now_secs", LG_now_secs },
+    { "wakeup_conv", LG_wakeup_conv },
+    { "set_thread_priority", LG_set_thread_priority },
+    { "set_thread_affinity", LG_set_thread_affinity },
+    { "nameof", luaG_nameof },
+    { "register", LG_register },
+    { "set_singlethreaded", LG_set_singlethreaded },
+    { nullptr, nullptr }
+};
+
+// #################################################################################################
+
+// upvalue 1: module name
+// upvalue 2: module table
+// param 1: settings table
+LUAG_FUNC(configure)
+{
+    // start with one-time initializations.
+    {
+        // C++ guarantees that the static variable initialization is threadsafe.
+        static auto _ = std::invoke(
+            []()
+            {
+#if (defined PLATFORM_OSX) && (defined _UTILBINDTHREADTOCPU)
+                chudInitialize();
+#endif
+                return false;
+            }
+        );
+    }
+
+    Universe* U = universe_get(L);
+    bool const from_master_state{ U == nullptr };
+    char const* name = luaL_checkstring(L, lua_upvalueindex(1));
+    ASSERT_L(lua_type(L, 1) == LUA_TTABLE);
+
+    STACK_GROW(L, 4);
+    STACK_CHECK_START_ABS(L, 1);                                                          // settings
+
+    DEBUGSPEW_CODE(fprintf( stderr, INDENT_BEGIN "%p: lanes.configure() BEGIN\n" INDENT_END, L));
+    DEBUGSPEW_CODE(if (U) U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
+
+    if (U == nullptr)
+    {
+        U = universe_create(L);                                                           // settings universe
+        DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
+        lua_newtable( L);                                                                 // settings universe mt
+        lua_getfield(L, 1, "shutdown_timeout");                                           // settings universe mt shutdown_timeout
+        lua_getfield(L, 1, "shutdown_mode");                                              // settings universe mt shutdown_timeout shutdown_mode
+        lua_pushcclosure(L, universe_gc, 2);                                              // settings universe mt universe_gc
+        lua_setfield(L, -2, "__gc");                                                      // settings universe mt
+        lua_setmetatable(L, -2);                                                          // settings universe
+        lua_pop(L, 1);                                                                    // settings
+        lua_getfield(L, 1, "verbose_errors");                                             // settings verbose_errors
+        U->verboseErrors = lua_toboolean(L, -1) ? true : false;
+        lua_pop(L, 1);                                                                    // settings
+        lua_getfield(L, 1, "demote_full_userdata");                                       // settings demote_full_userdata
+        U->demoteFullUserdata = lua_toboolean(L, -1) ? true : false;
+        lua_pop(L, 1);                                                                    // settings
+#if HAVE_LANE_TRACKING()
+        lua_getfield(L, 1, "track_lanes");                                                // settings track_lanes
+        U->tracking_first = lua_toboolean(L, -1) ? TRACKING_END : nullptr;
+        lua_pop(L, 1);                                                                    // settings
+#endif // HAVE_LANE_TRACKING()
+        // Linked chains handling
+        U->selfdestruct_first = SELFDESTRUCT_END;
+        initialize_allocator_function( U, L);
+        initialize_on_state_create( U, L);
+        init_keepers( U, L);
+        STACK_CHECK(L, 1);
+
+        // Initialize 'timer_deep'; a common Linda object shared by all states
+        lua_pushcfunction(L, LG_linda);                                                   // settings lanes.linda
+        lua_pushliteral(L, "lanes-timer");                                                // settings lanes.linda "lanes-timer"
+        lua_call(L, 1, 1);                                                                // settings linda
+        STACK_CHECK(L, 2);
+
+        // Proxy userdata contents is only a 'DeepPrelude*' pointer
+        U->timer_deep = *lua_tofulluserdata<DeepPrelude*>(L, -1);
+        // increment refcount so that this linda remains alive as long as the universe exists.
+        U->timer_deep->m_refcount.fetch_add(1, std::memory_order_relaxed);
+        lua_pop(L, 1);                                                                    // settings
+    }
+    STACK_CHECK(L, 1);
+
+    // Serialize calls to 'require' from now on, also in the primary state
+    serialize_require( DEBUGSPEW_PARAM_COMMA( U) L);
+
+    // Retrieve main module interface table
+    lua_pushvalue(L, lua_upvalueindex( 2));                                               // settings M
+    // remove configure() (this function) from the module interface
+    lua_pushnil( L);                                                                      // settings M nil
+    lua_setfield(L, -2, "configure");                                                     // settings M
+    // add functions to the module's table
+    luaG_registerlibfuncs(L, lanes_functions);
+#if HAVE_LANE_TRACKING()
+    // register core.threads() only if settings say it should be available
+    if (U->tracking_first != nullptr)
+    {
+        lua_pushcfunction(L, LG_threads);                                                 // settings M LG_threads()
+        lua_setfield(L, -2, "threads");                                                   // settings M
+    }
+#endif // HAVE_LANE_TRACKING()
+    STACK_CHECK(L, 2);
+
+    {
+        char const* errmsg{ push_deep_proxy(Dest{ L }, U->timer_deep, 0, LookupMode::LaneBody) }; // settings M timer_deep
+        if (errmsg != nullptr)
+        {
+            return luaL_error(L, errmsg);
+        }
+        lua_setfield(L, -2, "timer_gateway");                                             // settings M
+    }
+    STACK_CHECK(L, 2);
+
+    // prepare the metatable for threads
+    // contains keys: { __gc, __index, cached_error, cached_tostring, cancel, join, get_debug_threadname }
+    //
+    if (luaL_newmetatable(L, "Lane"))                                                     // settings M mt
+    {
+        lua_pushcfunction(L, lane_gc);                                                    // settings M mt lane_gc
+        lua_setfield(L, -2, "__gc");                                                      // settings M mt
+        lua_pushcfunction(L, LG_thread_index);                                            // settings M mt LG_thread_index
+        lua_setfield(L, -2, "__index");                                                   // settings M mt
+        lua_getglobal(L, "error");                                                        // settings M mt error
+        ASSERT_L( lua_isfunction(L, -1));
+        lua_setfield(L, -2, "cached_error");                                              // settings M mt
+        lua_getglobal(L, "tostring");                                                     // settings M mt tostring
+        ASSERT_L( lua_isfunction(L, -1));
+        lua_setfield(L, -2, "cached_tostring");                                           // settings M mt
+        lua_pushcfunction(L, LG_thread_join);                                             // settings M mt LG_thread_join
+        lua_setfield(L, -2, "join");                                                      // settings M mt
+        lua_pushcfunction(L, LG_get_debug_threadname);                                    // settings M mt LG_get_debug_threadname
+        lua_setfield(L, -2, "get_debug_threadname");                                      // settings M mt
+        lua_pushcfunction(L, LG_thread_cancel);                                           // settings M mt LG_thread_cancel
+        lua_setfield(L, -2, "cancel");                                                    // settings M mt
+        lua_pushliteral(L, "Lane");                                                       // settings M mt "Lane"
+        lua_setfield(L, -2, "__metatable");                                               // settings M mt
+    }
+
+    lua_pushcclosure(L, LG_lane_new, 1);                                                  // settings M lane_new
+    lua_setfield(L, -2, "lane_new");                                                      // settings M
+
+    // we can't register 'lanes.require' normally because we want to create an upvalued closure
+    lua_getglobal(L, "require");                                                          // settings M require
+    lua_pushcclosure(L, LG_require, 1);                                                   // settings M lanes.require
+    lua_setfield(L, -2, "require");                                                       // settings M
+
+    lua_pushfstring(
+        L, "%d.%d.%d"
+        , LANES_VERSION_MAJOR, LANES_VERSION_MINOR, LANES_VERSION_PATCH
+    );                                                                                    // settings M VERSION
+    lua_setfield(L, -2, "version");                                                       // settings M
+
+    lua_pushinteger(L, THREAD_PRIO_MAX);                                                  // settings M THREAD_PRIO_MAX
+    lua_setfield(L, -2, "max_prio");                                                      // settings M
+
+    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.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
+    // we process it before _G because we don't want to find the module when scanning _G (this would generate longer names)
+    // for example in package.loaded["lanes.core"].*
+    populate_func_lookup_table(L, -1, name);
+    STACK_CHECK(L, 2);
+
+    // record all existing C/JIT-fast functions
+    // Lua 5.2 no longer has LUA_GLOBALSINDEX: we must push globals table on the stack
+    if (from_master_state)
+    {
+        // don't do this when called during the initialization of a new lane,
+        // because we will do it after on_state_create() is called,
+        // and we don't want to skip _G because of caching in case globals are created then
+        lua_pushglobaltable( L);                                                          // settings M _G
+        populate_func_lookup_table(L, -1, nullptr);
+        lua_pop(L, 1);                                                                    // settings M
+    }
+    lua_pop(L, 1);                                                                        // settings
+
+    // set _R[CONFIG_REGKEY] = settings
+    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.fetch_sub(1, std::memory_order_relaxed));
+    // Return the settings table
+    return 1;
+}
+
+// #################################################################################################
+
+#if defined PLATFORM_WIN32 && !defined NDEBUG
+#include <signal.h>
+#include <conio.h>
+
+void signal_handler(int signal)
+{
+    if (signal == SIGABRT)
+    {
+        _cprintf("caught abnormal termination!");
+        abort();
+    }
+}
+
+// helper to have correct callstacks when crashing a Win32 running on 64 bits Windows
+// don't forget to toggle Debug/Exceptions/Win32 in visual Studio too!
+static volatile long s_ecoc_initCount = 0;
+static volatile int s_ecoc_go_ahead = 0;
+static void EnableCrashingOnCrashes(void)
+{
+    if (InterlockedCompareExchange(&s_ecoc_initCount, 1, 0) == 0)
+    {
+        typedef BOOL(WINAPI * tGetPolicy)(LPDWORD lpFlags);
+        typedef BOOL(WINAPI * tSetPolicy)(DWORD dwFlags);
+        const DWORD EXCEPTION_SWALLOWING = 0x1;
+
+        HMODULE kernel32 = LoadLibraryA("kernel32.dll");
+        if (kernel32)
+        {
+            tGetPolicy pGetPolicy = (tGetPolicy) GetProcAddress(kernel32, "GetProcessUserModeExceptionPolicy");
+            tSetPolicy pSetPolicy = (tSetPolicy) GetProcAddress(kernel32, "SetProcessUserModeExceptionPolicy");
+            if (pGetPolicy && pSetPolicy)
+            {
+                DWORD dwFlags;
+                if (pGetPolicy(&dwFlags))
+                {
+                    // Turn off the filter
+                    pSetPolicy(dwFlags & ~EXCEPTION_SWALLOWING);
+                }
+            }
+            FreeLibrary(kernel32);
+        }
+        // typedef void (* SignalHandlerPointer)( int);
+        /*SignalHandlerPointer previousHandler =*/signal(SIGABRT, signal_handler);
+
+        s_ecoc_go_ahead = 1; // let others pass
+    }
+    else
+    {
+        while (!s_ecoc_go_ahead)
+        {
+            Sleep(1);
+        } // changes threads
+    }
+}
+#endif // PLATFORM_WIN32 && !defined NDEBUG
+
+LANES_API int luaopen_lanes_core( lua_State* L)
+{
+#if defined PLATFORM_WIN32 && !defined NDEBUG
+    EnableCrashingOnCrashes();
+#endif // defined PLATFORM_WIN32 && !defined NDEBUG
+
+    STACK_GROW(L, 4);
+    STACK_CHECK_START_REL(L, 0);
+
+    // Prevent PUC-Lua/LuaJIT mismatch. Hopefully this works for MoonJIT too
+    lua_getglobal(L, "jit");                           // {jit?}
+#if LUAJIT_FLAVOR() == 0
+    if (!lua_isnil(L, -1))
+        return luaL_error(L, "Lanes is built for PUC-Lua, don't run from LuaJIT");
+#else
+    if (lua_isnil(L, -1))
+        return luaL_error(L, "Lanes is built for LuaJIT, don't run from PUC-Lua");
+#endif
+    lua_pop(L, 1);                                     //
+    STACK_CHECK(L, 0);
+
+    // Create main module interface table
+    // we only have 1 closure, which must be called to configure Lanes
+    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.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
+        lua_setfield(L, -4, "settings");               // M LG_configure() settings
+        lua_call(L, 1, 0);                             // M
+    }
+    else
+    {
+        // will do nothing on first invocation, as we haven't stored settings in the registry yet
+        lua_setfield(L, -3, "settings");               // M LG_configure()
+        lua_setfield(L, -2, "configure");              // M
+    }
+
+    STACK_CHECK(L, 1);
+    return 1;
+}
+
+[[nodiscard]] static int default_luaopen_lanes(lua_State* L)
+{
+    int const rc{ luaL_loadfile(L, "lanes.lua") || lua_pcall(L, 0, 1, 0) };
+    if (rc != LUA_OK)
+    {
+        return luaL_error(L, "failed to initialize embedded Lanes");
+    }
+    return 1;
+}
+
+// call this instead of luaopen_lanes_core() when embedding Lua and Lanes in a custom application
+LANES_API void luaopen_lanes_embedded( lua_State* L, lua_CFunction _luaopen_lanes)
+{
+    STACK_CHECK_START_REL(L, 0);
+    // pre-require lanes.core so that when lanes.lua calls require "lanes.core" it finds it is already loaded
+    luaL_requiref(L, "lanes.core", luaopen_lanes_core, 0);                                       // ... lanes.core
+    lua_pop(L, 1);                                                                               // ...
+    STACK_CHECK(L, 0);
+    // call user-provided function that runs the chunk "lanes.lua" from wherever they stored it
+    luaL_requiref(L, "lanes", _luaopen_lanes ? _luaopen_lanes : default_luaopen_lanes, 0);       // ... lanes
+    STACK_CHECK(L, 1);
+}
diff --git a/src/lanes.h b/src/lanes.h
index 62b9ea9..bc8de55 100644
--- a/src/lanes.h
+++ b/src/lanes.h
@@ -1,17 +1,17 @@
-#if !defined( __lanes_h__)
-#define __lanes_h__ 1
+#pragma once
 
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
 #include "lua.h"
-#include "platform.h"
+#ifdef __cplusplus
+}
+#endif // __cplusplus
 
-#if (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC)
-#define LANES_API __declspec(dllexport)
-#else
-#define LANES_API
-#endif // (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC)
+#include "lanesconf.h"
 
-#define LANES_VERSION_MAJOR 3
-#define LANES_VERSION_MINOR 17
+#define LANES_VERSION_MAJOR 4
+#define LANES_VERSION_MINOR 0
 #define LANES_VERSION_PATCH 0
 
 #define LANES_MIN_VERSION_REQUIRED(MAJOR, MINOR, PATCH)     ((LANES_VERSION_MAJOR>MAJOR) || (LANES_VERSION_MAJOR==MAJOR && (LANES_VERSION_MINOR>MINOR || (LANES_VERSION_MINOR==MINOR && LANES_VERSION_PATCH>=PATCH))))
@@ -20,9 +20,7 @@
 #define LANES_VERSION_GREATER_THAN(MAJOR, MINOR, PATCH)     ((LANES_VERSION_MAJOR>MAJOR) || (LANES_VERSION_MAJOR==MAJOR && (LANES_VERSION_MINOR>MINOR || (LANES_VERSION_MINOR==MINOR && LANES_VERSION_PATCH>PATCH))))
 #define LANES_VERSION_GREATER_OR_EQUAL(MAJOR, MINOR, PATCH) ((LANES_VERSION_MAJOR>MAJOR) || (LANES_VERSION_MAJOR==MAJOR && (LANES_VERSION_MINOR>MINOR || (LANES_VERSION_MINOR==MINOR && LANES_VERSION_PATCH>=PATCH))))
 
-extern int LANES_API luaopen_lanes_core( lua_State* L);
+LANES_API [[nodiscard]] int luaopen_lanes_core(lua_State* L);
 
 // Call this to work with embedded Lanes instead of calling luaopen_lanes_core()
-extern void LANES_API luaopen_lanes_embedded( lua_State* L, lua_CFunction _luaopen_lanes);
-
-#endif // __lanes_h__
\ No newline at end of file
+LANES_API void luaopen_lanes_embedded(lua_State* L, lua_CFunction _luaopen_lanes);
diff --git a/src/lanes.lua b/src/lanes.lua
index 49900f9..fd3d22b 100644
--- a/src/lanes.lua
+++ b/src/lanes.lua
@@ -73,6 +73,7 @@ lanes.configure = function( settings_)
         keepers_gc_threshold = -1,
         on_state_create = nil,
         shutdown_timeout = 0.25,
+        shutdown_mode = "hard",
         with_timers = true,
         track_lanes = false,
         demote_full_userdata = nil,
@@ -113,6 +114,11 @@ lanes.configure = function( settings_)
             -- shutdown_timeout should be a number >= 0
             return type( val_) == "number" and val_ >= 0
         end,
+        shutdown_mode = function( val_)
+            local valid_hooks = { soft = true, hard = true, call = true, ret = true, line = true, count = true }
+            -- shutdown_mode should be a known hook mask
+            return valid_hooks[val_]
+        end,
         track_lanes = boolean_param_checker,
         demote_full_userdata = boolean_param_checker,
         verbose_errors = boolean_param_checker
@@ -367,7 +373,6 @@ lanes.configure = function( settings_)
 
 
     if settings.with_timers ~= false then
-
         --
         -- On first 'require "lanes"', a timer lane is spawned that will maintain
         -- timer tables and sleep in between the timer events. All interaction with
diff --git a/src/lanes_private.h b/src/lanes_private.h
index 8143216..18e55fd 100644
--- a/src/lanes_private.h
+++ b/src/lanes_private.h
@@ -1,102 +1,106 @@
-#if !defined __lanes_private_h__
-#define __lanes_private_h__ 1
+#pragma once
 
-#include "uniquekey.h"
 #include "cancel.h"
+#include "uniquekey.h"
 #include "universe.h"
 
+#include <chrono>
+#include <condition_variable>
+#include <latch>
+#include <stop_token>
+#include <thread>
+
 // NOTE: values to be changed by either thread, during execution, without
 //       locking, are marked "volatile"
 //
-struct s_Lane
+class Lane
 {
-    THREAD_T thread;
+    public:
+
+    /*
+      Pending: The Lua VM hasn't done anything yet.
+      Running, Waiting: Thread is inside the Lua VM. If the thread is forcefully stopped, we can't lua_close() the Lua State.
+      Done, Error, Cancelled: Thread execution is outside the Lua VM. It can be lua_close()d.
+    */
+    enum class Status
+    {
+        Pending,
+        Running,
+        Waiting,
+        Done,
+        Error,
+        Cancelled
+    };
+    using enum Status;
+
+    // the thread
+    std::jthread m_thread;
+    // a latch to wait for the lua_State to be ready
+    std::latch m_ready{ 1 };
+    // to wait for stop requests through m_thread's stop_source
+    std::mutex m_done_mutex;
+    std::condition_variable m_done_signal; // use condition_variable_any if waiting for a stop_token
     //
     // M: sub-thread OS thread
     // S: not used
 
-    char const* debug_name;
+    char const* debug_name{ "<unnamed>" };
 
+    Universe* const U;
     lua_State* L;
-    Universe* U;
     //
     // M: prepares the state, and reads results
     // S: while S is running, M must keep out of modifying the state
 
-    volatile enum e_status status;
+    Status volatile m_status{ Pending };
     // 
-    // M: sets to PENDING (before launching)
-    // S: updates -> RUNNING/WAITING -> DONE/ERROR_ST/CANCELLED
+    // M: sets to Pending (before launching)
+    // S: updates -> Running/Waiting -> Done/Error/Cancelled
 
-    SIGNAL_T* volatile waiting_on;
+    std::condition_variable* volatile m_waiting_on{ nullptr };
     //
-    // When status is WAITING, points on the linda's signal the thread waits on, else NULL
+    // When status is Waiting, points on the linda's signal the thread waits on, else nullptr
 
-    volatile enum e_cancel_request cancel_request;
+    CancelRequest volatile cancel_request{ CancelRequest::None };
     //
-    // M: sets to FALSE, flags TRUE for cancel request
+    // M: sets to false, flags true for cancel request
     // S: reads to see if cancel is requested
 
-#if THREADWAIT_METHOD == THREADWAIT_CONDVAR
-    SIGNAL_T done_signal;
-    //
-    // M: Waited upon at lane ending  (if Posix with no PTHREAD_TIMEDJOIN)
-    // S: sets the signal once cancellation is noticed (avoids a kill)
-
-    MUTEX_T done_lock;
-    // 
-    // Lock required by 'done_signal' condition variable, protecting
-    // lane status changes to DONE/ERROR_ST/CANCELLED.
-#endif // THREADWAIT_METHOD == THREADWAIT_CONDVAR
-
-    volatile enum
-    {
-        NORMAL,         // normal master side state
-        KILLED          // issued an OS kill
-    } mstatus;
-    //
-    // M: sets to NORMAL, if issued a kill changes to KILLED
-    // S: not used
-
-    struct s_Lane* volatile selfdestruct_next;
+    Lane* volatile selfdestruct_next{ nullptr };
     //
-    // M: sets to non-NULL if facing lane handle '__gc' cycle but the lane
+    // M: sets to non-nullptr if facing lane handle '__gc' cycle but the lane
     //    is still running
-    // S: cleans up after itself if non-NULL at lane exit
+    // S: cleans up after itself if non-nullptr at lane exit
 
 #if HAVE_LANE_TRACKING()
-    struct s_Lane* volatile tracking_next;
+    Lane* volatile tracking_next{ nullptr };
 #endif // HAVE_LANE_TRACKING()
     //
     // For tracking only
+
+    [[nodiscard]] static void* operator new(size_t size_, Universe* U_) noexcept { return U_->internal_allocator.alloc(size_); }
+    // can't actually delete the operator because the compiler generates stack unwinding code that could call it in case of exception
+    static void operator delete(void* p_, Universe* U_) { U_->internal_allocator.free(p_, sizeof(Lane)); }
+    // this one is for us, to make sure memory is freed by the correct allocator
+    static void operator delete(void* p_) { static_cast<Lane*>(p_)->U->internal_allocator.free(p_, sizeof(Lane)); }
+
+    Lane(Universe* U_, lua_State* L_);
+    ~Lane();
+
+    [[nodiscard]] bool waitForCompletion(lua_Duration duration_);
+    void startThread(int priority_);
 };
-typedef struct s_Lane Lane;
 
 // xxh64 of string "LANE_POINTER_REGKEY" generated at https://www.pelock.com/products/hash-calculator
-static DECLARE_CONST_UNIQUE_KEY( LANE_POINTER_REGKEY, 0xB3022205633743BC); // used as registry key
+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.
 //
-inline Lane* lua_toLane(lua_State* L, int i_)
+[[nodiscard]] inline Lane* lua_toLane(lua_State* L, int i_)
 {
-    return *(Lane**)(luaL_checkudata(L, i_, "Lane"));
+    return *(static_cast<Lane**>(luaL_checkudata(L, i_, "Lane")));
 }
 
-static inline Lane* get_lane_from_registry( lua_State* L)
-{
-    Lane* s;
-    STACK_GROW( L, 1);
-    STACK_CHECK( L, 0);
-    REGISTRY_GET( L, LANE_POINTER_REGKEY);
-    s = lua_touserdata( L, -1);     // lightuserdata (true 's_lane' pointer) / nil
-    lua_pop( L, 1);
-    STACK_END( L, 0);
-    return s;
-}
-
-int push_thread_status( lua_State* L, Lane* s);
-
-
-#endif // __lanes_private_h__
\ No newline at end of file
+void push_thread_status(lua_State* L, Lane* lane_);
diff --git a/src/lanesconf.h b/src/lanesconf.h
new file mode 100644
index 0000000..fb4a601
--- /dev/null
+++ b/src/lanesconf.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include "platform.h"
+
+#if (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC)
+#ifdef __cplusplus
+#define LANES_API extern "C" __declspec(dllexport)
+#else
+#define LANES_API extern __declspec(dllexport)
+#endif // __cplusplus
+#else
+#ifdef __cplusplus
+#define LANES_API extern "C"
+#else
+#define LANES_API extern
+#endif // __cplusplus
+#endif // (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC)
diff --git a/src/linda.c b/src/linda.c
deleted file mode 100644
index 2128520..0000000
--- a/src/linda.c
+++ /dev/null
@@ -1,948 +0,0 @@
-/*
- * LINDA.C                          Copyright (c) 2018, Benoit Germain
- *
- * Linda deep userdata.
-*/
-
-/*
-===============================================================================
-
-Copyright (C) 2018 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
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
-===============================================================================
-*/
-
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-
-#include "threading.h"
-#include "compat.h"
-#include "tools.h"
-#include "universe.h"
-#include "keeper.h"
-#include "deep.h"
-#include "lanes_private.h"
-
-/*
-* Actual data is kept within a keeper state, which is hashed by the 's_Linda'
-* pointer (which is same to all userdatas pointing to it).
-*/
-struct s_Linda
-{
-    DeepPrelude prelude; // Deep userdata MUST start with this header
-    SIGNAL_T read_happened;
-    SIGNAL_T write_happened;
-    Universe* U; // the universe this linda belongs to
-    uintptr_t group; // a group to control keeper allocation between lindas
-    enum e_cancel_request simulate_cancel;
-    char name[1];
-};
-#define LINDA_KEEPER_HASHSEED( linda) (linda->group ? linda->group : (uintptr_t)linda)
-
-static void* linda_id( lua_State*, DeepOp);
-
-static inline struct s_Linda* lua_toLinda( lua_State* L, int idx_)
-{
-    struct s_Linda* linda = (struct s_Linda*) luaG_todeep( L, linda_id, idx_);
-    luaL_argcheck( L, linda != NULL, idx_, "expecting a linda object");
-    return linda;
-}
-
-static void check_key_types( lua_State* L, int start_, int end_)
-{
-    int i;
-    for( i = start_; i <= end_; ++ i)
-    {
-        int t = lua_type( L, i);
-        if( t == LUA_TBOOLEAN || t == LUA_TNUMBER || t == LUA_TSTRING || t == LUA_TLIGHTUSERDATA)
-        {
-            continue;
-        }
-        (void) luaL_error( L, "argument #%d: invalid key type (not a boolean, string, number or light userdata)", i);
-    }
-}
-
-LUAG_FUNC( linda_protected_call)
-{
-    int rc = LUA_OK;
-    struct s_Linda* linda = lua_toLinda( L, 1);
-
-    // acquire the keeper
-    Keeper* K = keeper_acquire( linda->U->keepers, LINDA_KEEPER_HASHSEED(linda));
-    lua_State* KL = K ? K->L : NULL; // need to do this for 'STACK_CHECK'
-    if( KL == NULL) return 0;
-
-    // retrieve the actual function to be called and move it before the arguments
-    lua_pushvalue( L, lua_upvalueindex( 1));
-    lua_insert( L, 1);
-    // do a protected call
-    rc = lua_pcall( L, lua_gettop( L) - 1, LUA_MULTRET, 0);
-
-    // release the keeper
-    keeper_release( K);
-
-    // if there was an error, forward it
-    if( rc != LUA_OK)
-    {
-        return lua_error( L);
-    }
-    // return whatever the actual operation provided
-    return lua_gettop( L);
-}
-
-/*
-* bool= linda_send( linda_ud, [timeout_secs=-1,] [linda.null,] key_num|str|bool|lightuserdata, ... )
-*
-* Send one or more values to a Linda. If there is a limit, all values must fit.
-*
-* Returns:  'true' if the value was queued
-*           'false' for timeout (only happens when the queue size is limited)
-*           nil, CANCEL_ERROR if cancelled
-*/
-LUAG_FUNC( linda_send)
-{
-    struct s_Linda* linda = lua_toLinda( L, 1);
-    bool_t ret = FALSE;
-    enum e_cancel_request cancel = CANCEL_NONE;
-    int pushed;
-    time_d timeout = -1.0;
-    int key_i = 2; // index of first key, if timeout not there
-    bool_t as_nil_sentinel; // if not NULL, send() will silently send a single nil if nothing is provided
-
-    if( lua_type( L, 2) == LUA_TNUMBER) // we don't want to use lua_isnumber() because of autocoercion
-    {
-        timeout = SIGNAL_TIMEOUT_PREPARE( lua_tonumber( L, 2));
-        ++ key_i;
-    }
-    else if( lua_isnil( L, 2)) // alternate explicit "no timeout" by passing nil before the key
-    {
-        ++ key_i;
-    }
-
-    as_nil_sentinel = equal_unique_key( L, key_i, NIL_SENTINEL);
-    if( as_nil_sentinel)
-    {
-        // the real key to send data to is after the NIL_SENTINEL marker
-        ++ key_i;
-    }
-
-    // make sure the key is of a valid type
-    check_key_types( L, key_i, key_i);
-
-    STACK_GROW( L, 1);
-
-    // make sure there is something to send
-    if( lua_gettop( L) == key_i)
-    {
-        if( as_nil_sentinel)
-        {
-            // send a single nil if nothing is provided
-            push_unique_key( L, NIL_SENTINEL);
-        }
-        else
-        {
-            return luaL_error( L, "no data to send");
-        }
-    }
-
-    // convert nils to some special non-nil sentinel in sent values
-    keeper_toggle_nil_sentinels( L, key_i + 1, eLM_ToKeeper);
-
-    {
-        bool_t try_again = TRUE;
-        Lane* const s = get_lane_from_registry( L);
-        Keeper* K = which_keeper( linda->U->keepers, LINDA_KEEPER_HASHSEED( linda));
-        lua_State* KL = K ? K->L : NULL; // need to do this for 'STACK_CHECK'
-        if( KL == NULL) return 0;
-        STACK_CHECK( KL, 0);
-        for( ;;)
-        {
-            if( s != NULL)
-            {
-                cancel = s->cancel_request;
-            }
-            cancel = (cancel != CANCEL_NONE) ? cancel : linda->simulate_cancel;
-            // if user wants to cancel, or looped because of a timeout, the call returns without sending anything
-            if( !try_again || cancel != CANCEL_NONE)
-            {
-                pushed = 0;
-                break;
-            }
-
-            STACK_MID( KL, 0);
-            pushed = keeper_call( linda->U, KL, KEEPER_API( send), L, linda, key_i);
-            if( pushed < 0)
-            {
-                break;
-            }
-            ASSERT_L( pushed == 1);
-
-            ret = lua_toboolean( L, -1);
-            lua_pop( L, 1);
-
-            if( ret)
-            {
-                // Wake up ALL waiting threads
-                SIGNAL_ALL( &linda->write_happened);
-                break;
-            }
-
-            // instant timout to bypass the wait syscall
-            if( timeout == 0.0)
-            {
-                break;  /* no wait; instant timeout */
-            }
-
-            // storage limit hit, wait until timeout or signalled that we should try again
-            {
-                enum e_status prev_status = ERROR_ST; // prevent 'might be used uninitialized' warnings
-                if( s != NULL)
-                {
-                    // change status of lane to "waiting"
-                    prev_status = s->status; // RUNNING, most likely
-                    ASSERT_L( prev_status == RUNNING); // but check, just in case
-                    s->status = WAITING;
-                    ASSERT_L( s->waiting_on == NULL);
-                    s->waiting_on = &linda->read_happened;
-                }
-                // could not send because no room: wait until some data was read before trying again, or until timeout is reached
-                try_again = SIGNAL_WAIT( &linda->read_happened, &K->keeper_cs, timeout);
-                if( s != NULL)
-                {
-                    s->waiting_on = NULL;
-                    s->status = prev_status;
-                }
-            }
-        }
-        STACK_END( KL, 0);
-    }
-
-    if( pushed < 0)
-    {
-        return luaL_error( L, "tried to copy unsupported types");
-    }
-
-    switch( cancel)
-    {
-        case CANCEL_SOFT:
-        // if user wants to soft-cancel, the call returns lanes.cancel_error
-        push_unique_key( L, CANCEL_ERROR);
-        return 1;
-
-        case CANCEL_HARD:
-        // raise an error interrupting execution only in case of hard cancel
-        return cancel_error( L); // raises an error and doesn't return
-
-        default:
-        lua_pushboolean( L, ret); // true (success) or false (timeout)
-        return 1;
-    }
-}
-
-
-/*
- * 2 modes of operation
- * [val, key]= linda_receive( linda_ud, [timeout_secs_num=-1], key_num|str|bool|lightuserdata [, ...] )
- * Consumes a single value from the Linda, in any key.
- * Returns: received value (which is consumed from the slot), and the key which had it
-
- * [val1, ... valCOUNT]= linda_receive( linda_ud, [timeout_secs_num=-1], linda.batched, key_num|str|bool|lightuserdata, min_COUNT[, max_COUNT])
- * Consumes between min_COUNT and max_COUNT values from the linda, from a single key.
- * returns the actual consumed values, or nil if there weren't enough values to consume
- *
- */
- // xxh64 of string "BATCH_SENTINEL" generated at https://www.pelock.com/products/hash-calculator
-DECLARE_CONST_UNIQUE_KEY(BATCH_SENTINEL, 0x2DDFEE0968C62AA7);
-LUAG_FUNC( linda_receive)
-{
-    struct s_Linda* linda = lua_toLinda( L, 1);
-    int pushed, expected_pushed_min, expected_pushed_max;
-    enum e_cancel_request cancel = CANCEL_NONE;
-    keeper_api_t selected_keeper_receive;
-    
-    time_d timeout = -1.0;
-    int key_i = 2;
-
-    if( lua_type( L, 2) == LUA_TNUMBER) // we don't want to use lua_isnumber() because of autocoercion
-    {
-        timeout = SIGNAL_TIMEOUT_PREPARE( lua_tonumber( L, 2));
-        ++ key_i;
-    }
-    else if( lua_isnil( L, 2)) // alternate explicit "no timeout" by passing nil before the key
-    {
-        ++ key_i;
-    }
-
-    // are we in batched mode?
-    {
-        int is_batched;
-        push_unique_key( L, BATCH_SENTINEL);
-        is_batched = lua501_equal( L, key_i, -1);
-        lua_pop( L, 1);
-        if( is_batched)
-        {
-            // no need to pass linda.batched in the keeper state
-            ++ key_i;
-            // make sure the keys are of a valid type
-            check_key_types( L, key_i, key_i);
-            // receive multiple values from a single slot
-            selected_keeper_receive = KEEPER_API( receive_batched);
-            // we expect a user-defined amount of return value
-            expected_pushed_min = (int)luaL_checkinteger( L, key_i + 1);
-            expected_pushed_max = (int)luaL_optinteger( L, key_i + 2, expected_pushed_min);
-            // don't forget to count the key in addition to the values
-            ++ expected_pushed_min;
-            ++ expected_pushed_max;
-            if( expected_pushed_min > expected_pushed_max)
-            {
-                return luaL_error( L, "batched min/max error");
-            }
-        }
-        else
-        {
-            // make sure the keys are of a valid type
-            check_key_types( L, key_i, lua_gettop( L));
-            // receive a single value, checking multiple slots
-            selected_keeper_receive = KEEPER_API( receive);
-            // we expect a single (value, key) pair of returned values
-            expected_pushed_min = expected_pushed_max = 2;
-        }
-    }
-
-    {
-        bool_t try_again = TRUE;
-        Lane* const s = get_lane_from_registry( L);
-        Keeper* K = which_keeper( linda->U->keepers, LINDA_KEEPER_HASHSEED( linda));
-        if( K == NULL) return 0;
-        for( ;;)
-        {
-            if( s != NULL)
-            {
-                cancel = s->cancel_request;
-            }
-            cancel = (cancel != CANCEL_NONE) ? cancel : linda->simulate_cancel;
-            // if user wants to cancel, or looped because of a timeout, the call returns without sending anything
-            if( !try_again || cancel != CANCEL_NONE)
-            {
-                pushed = 0;
-                break;
-            }
-
-            // all arguments of receive() but the first are passed to the keeper's receive function
-            pushed = keeper_call( linda->U, K->L, selected_keeper_receive, L, linda, key_i);
-            if( pushed < 0)
-            {
-                break;
-            }
-            if( pushed > 0)
-            {
-                ASSERT_L( pushed >= expected_pushed_min && pushed <= expected_pushed_max);
-                // replace sentinels with real nils
-                keeper_toggle_nil_sentinels( L, lua_gettop( L) - pushed, eLM_FromKeeper);
-                // To be done from within the 'K' locking area
-                //
-                SIGNAL_ALL( &linda->read_happened);
-                break;
-            }
-
-            if( timeout == 0.0)
-            {
-                break;  /* instant timeout */
-            }
-
-            // nothing received, wait until timeout or signalled that we should try again
-            {
-                enum e_status prev_status = ERROR_ST; // prevent 'might be used uninitialized' warnings
-                if( s != NULL)
-                {
-                    // change status of lane to "waiting"
-                    prev_status = s->status; // RUNNING, most likely
-                    ASSERT_L( prev_status == RUNNING); // but check, just in case
-                    s->status = WAITING;
-                    ASSERT_L( s->waiting_on == NULL);
-                    s->waiting_on = &linda->write_happened;
-                }
-                // not enough data to read: wakeup when data was sent, or when timeout is reached
-                try_again = SIGNAL_WAIT( &linda->write_happened, &K->keeper_cs, timeout);
-                if( s != NULL)
-                {
-                    s->waiting_on = NULL;
-                    s->status = prev_status;
-                }
-            }
-        }
-    }
-
-    if( pushed < 0)
-    {
-        return luaL_error( L, "tried to copy unsupported types");
-    }
-
-    switch( cancel)
-    {
-        case CANCEL_SOFT:
-        // if user wants to soft-cancel, the call returns CANCEL_ERROR
-        push_unique_key( L, CANCEL_ERROR);
-        return 1;
-
-        case CANCEL_HARD:
-        // raise an error interrupting execution only in case of hard cancel
-        return cancel_error( L); // raises an error and doesn't return
-
-        default:
-        return pushed;
-    }
-}
-
-
-/*
-* [true|lanes.cancel_error] = linda_set( linda_ud, key_num|str|bool|lightuserdata [, value [, ...]])
-*
-* Set one or more value to Linda.
-* TODO: what do we do if we set to non-nil and limit is 0?
-*
-* Existing slot value is replaced, and possible queued entries removed.
-*/
-LUAG_FUNC( linda_set)
-{
-    struct s_Linda* const linda = lua_toLinda( L, 1);
-    int pushed;
-    bool_t has_value = lua_gettop( L) > 2;
-
-    // make sure the key is of a valid type (throws an error if not the case)
-    check_key_types( L, 2, 2);
-
-    {
-        Keeper* K = which_keeper( linda->U->keepers, LINDA_KEEPER_HASHSEED( linda));
-
-        if( linda->simulate_cancel == CANCEL_NONE)
-        {
-            if( has_value)
-            {
-                // convert nils to some special non-nil sentinel in sent values
-                keeper_toggle_nil_sentinels( L, 3, eLM_ToKeeper);
-            }
-            pushed = keeper_call( linda->U, K->L, KEEPER_API( set), L, linda, 2);
-            if( pushed >= 0) // no error?
-            {
-                ASSERT_L( pushed == 0 || pushed == 1);
-
-                if( has_value)
-                {
-                    // we put some data in the slot, tell readers that they should wake
-                    SIGNAL_ALL( &linda->write_happened); // To be done from within the 'K' locking area
-                }
-                if( pushed == 1)
-                {
-                    // the key was full, but it is no longer the case, tell writers they should wake
-                    ASSERT_L( lua_type( L, -1) == LUA_TBOOLEAN && lua_toboolean( L, -1) == 1);
-                    SIGNAL_ALL( &linda->read_happened); // To be done from within the 'K' locking area
-                }
-            }
-        }
-        else // linda is cancelled
-        {
-            // do nothing and return lanes.cancel_error
-            push_unique_key( L, CANCEL_ERROR);
-            pushed = 1;
-        }
-    }
-
-    // must trigger any error after keeper state has been released
-    return (pushed < 0) ? luaL_error( L, "tried to copy unsupported types") : pushed;
-}
-
-
-/*
- * [val] = linda_count( linda_ud, [key [, ...]])
- *
- * Get a count of the pending elements in the specified keys
- */
-LUAG_FUNC( linda_count)
-{
-    struct s_Linda* linda = lua_toLinda( L, 1);
-    int pushed;
-
-    // make sure the keys are of a valid type
-    check_key_types( L, 2, lua_gettop( L));
-
-    {
-        Keeper* K = which_keeper( linda->U->keepers, LINDA_KEEPER_HASHSEED( linda));
-        pushed = keeper_call( linda->U, K->L, KEEPER_API( count), L, linda, 2);
-        if( pushed < 0)
-        {
-            return luaL_error( L, "tried to count an invalid key");
-        }
-    }
-    return pushed;
-}
-
-
-/*
-* [val [, ...]] = linda_get( linda_ud, key_num|str|bool|lightuserdata [, count = 1])
-*
-* Get one or more values from Linda.
-*/
-LUAG_FUNC( linda_get)
-{
-    struct s_Linda* const linda = lua_toLinda( L, 1);
-    int pushed;
-    lua_Integer count = luaL_optinteger( L, 3, 1);
-    luaL_argcheck( L, count >= 1, 3, "count should be >= 1");
-    luaL_argcheck( L, lua_gettop( L) <= 3, 4, "too many arguments");
-
-    // make sure the key is of a valid type (throws an error if not the case)
-    check_key_types( L, 2, 2);
-
-    if( linda->simulate_cancel == CANCEL_NONE)
-    {
-        Keeper* const K = which_keeper(linda->U->keepers, LINDA_KEEPER_HASHSEED(linda));
-        pushed = keeper_call( linda->U, K->L, KEEPER_API( get), L, linda, 2);
-        if( pushed > 0)
-        {
-            keeper_toggle_nil_sentinels( L, lua_gettop( L) - pushed, eLM_FromKeeper);
-        }
-    }
-    else // linda is cancelled
-    {
-        // do nothing and return lanes.cancel_error
-        push_unique_key( L, CANCEL_ERROR);
-        pushed = 1;
-    }
-    // an error can be raised if we attempt to read an unregistered function
-    if( pushed < 0)
-    {
-        return luaL_error( L, "tried to copy unsupported types");
-    }
-
-    return pushed;
-}
-
-
-/*
-* [true] = linda_limit( linda_ud, key_num|str|bool|lightuserdata, int)
-*
-* Set limit to 1 Linda keys.
-* Optionally wake threads waiting to write on the linda, in case the limit enables them to do so
-*/
-LUAG_FUNC( linda_limit)
-{
-    struct s_Linda* linda = lua_toLinda( L, 1);
-    int pushed;
-
-    // make sure we got 3 arguments: the linda, a key and a limit
-    luaL_argcheck( L, lua_gettop( L) == 3, 2, "wrong number of arguments");
-    // make sure we got a numeric limit
-    luaL_checknumber( L, 3);
-    // make sure the key is of a valid type
-    check_key_types( L, 2, 2);
-
-    if( linda->simulate_cancel == CANCEL_NONE)
-    {
-        Keeper* const K = which_keeper(linda->U->keepers, LINDA_KEEPER_HASHSEED(linda));
-        pushed = keeper_call( linda->U, K->L, KEEPER_API( limit), L, linda, 2);
-        ASSERT_L( pushed == 0 || pushed == 1); // no error, optional boolean value saying if we should wake blocked writer threads
-        if( pushed == 1)
-        {
-            ASSERT_L( lua_type( L, -1) == LUA_TBOOLEAN && lua_toboolean( L, -1) == 1);
-            SIGNAL_ALL( &linda->read_happened); // To be done from within the 'K' locking area
-        }
-    }
-    else // linda is cancelled
-    {
-        // do nothing and return lanes.cancel_error
-        push_unique_key( L, CANCEL_ERROR);
-        pushed = 1;
-    }
-    // propagate pushed boolean if any
-    return pushed;
-}
-
-
-/*
-* (void) = linda_cancel( linda_ud, "read"|"write"|"both"|"none")
-*
-* Signal linda so that waiting threads wake up as if their own lane was cancelled
-*/
-LUAG_FUNC( linda_cancel)
-{
-    struct s_Linda* linda = lua_toLinda( L, 1);
-    char const* who = luaL_optstring( L, 2, "both");
-
-    // make sure we got 3 arguments: the linda, a key and a limit
-    luaL_argcheck( L, lua_gettop( L) <= 2, 2, "wrong number of arguments");
-
-    linda->simulate_cancel = CANCEL_SOFT;
-    if( strcmp( who, "both") == 0) // tell everyone writers to wake up
-    {
-        SIGNAL_ALL( &linda->write_happened);
-        SIGNAL_ALL( &linda->read_happened);
-    }
-    else if( strcmp( who, "none") == 0) // reset flag
-    {
-        linda->simulate_cancel = CANCEL_NONE;
-    }
-    else if( strcmp( who, "read") == 0) // tell blocked readers to wake up
-    {
-        SIGNAL_ALL( &linda->write_happened);
-    }
-    else if( strcmp( who, "write") == 0) // tell blocked writers to wake up
-    {
-        SIGNAL_ALL( &linda->read_happened);
-    }
-    else
-    {
-        return luaL_error( L, "unknown wake hint '%s'", who);
-    }
-    return 0;
-}
-
-
-/*
-* lightuserdata= linda_deep( linda_ud )
-*
-* Return the 'deep' userdata pointer, identifying the Linda.
-*
-* This is needed for using Lindas as key indices (timer system needs it);
-* separately created proxies of the same underlying deep object will have
-* different userdata and won't be known to be essentially the same deep one
-* without this.
-*/
-LUAG_FUNC( linda_deep)
-{
-    struct s_Linda* linda= lua_toLinda( L, 1);
-    lua_pushlightuserdata( L, linda); // just the address
-    return 1;
-}
-
-
-/*
-* string = linda:__tostring( linda_ud)
-*
-* Return the stringification of a linda
-*
-* Useful for concatenation or debugging purposes
-*/
-
-static int linda_tostring( lua_State* L, int idx_, bool_t opt_)
-{
-    struct s_Linda* linda = (struct s_Linda*) luaG_todeep( L, linda_id, idx_);
-    if( !opt_)
-    {
-        luaL_argcheck( L, linda, idx_, "expecting a linda object");
-    }
-    if( linda != NULL)
-    {
-        char text[128];
-        int len;
-        if( linda->name[0])
-            len = sprintf( text, "Linda: %.*s", (int)sizeof(text) - 8, linda->name);
-        else
-            len = sprintf( text, "Linda: %p", linda);
-        lua_pushlstring( L, text, len);
-        return 1;
-    }
-    return 0;
-}
-
-LUAG_FUNC( linda_tostring)
-{
-    return linda_tostring( L, 1, FALSE);
-}
-
-
-/*
-* string = linda:__concat( a, b)
-*
-* Return the concatenation of a pair of items, one of them being a linda
-*
-* Useful for concatenation or debugging purposes
-*/
-LUAG_FUNC( linda_concat)
-{                                   // linda1? linda2?
-    bool_t atLeastOneLinda = FALSE;
-    // Lua semantics enforce that one of the 2 arguments is a Linda, but not necessarily both.
-    if( linda_tostring( L, 1, TRUE))
-    {
-        atLeastOneLinda = TRUE;
-        lua_replace( L, 1);
-    }
-    if( linda_tostring( L, 2, TRUE))
-    {
-        atLeastOneLinda = TRUE;
-        lua_replace( L, 2);
-    }
-    if( !atLeastOneLinda) // should not be possible
-    {
-        return luaL_error( L, "internal error: linda_concat called on non-Linda");
-    }
-    lua_concat( L, 2);
-    return 1;
-}
-
-/*
- * table = linda:dump()
- * return a table listing all pending data inside the linda
- */
-LUAG_FUNC( linda_dump)
-{
-    struct s_Linda* linda = lua_toLinda( L, 1);
-    ASSERT_L( linda->U == universe_get( L));
-    return keeper_push_linda_storage( linda->U, L, linda, LINDA_KEEPER_HASHSEED( linda));
-}
-
-/*
- * table = linda:dump()
- * return a table listing all pending data inside the linda
- */
-LUAG_FUNC( linda_towatch)
-{
-    struct s_Linda* linda = lua_toLinda( L, 1);
-    int pushed;
-    ASSERT_L( linda->U == universe_get( L));
-    pushed = keeper_push_linda_storage( linda->U, L, linda, LINDA_KEEPER_HASHSEED( linda));
-    if( pushed == 0)
-    {
-        // if the linda is empty, don't return nil
-        pushed = linda_tostring( L, 1, FALSE);
-    }
-    return pushed;
-}
-
-/*
-* Identity function of a shared userdata object.
-* 
-*   lightuserdata= linda_id( "new" [, ...] )
-*   = linda_id( "delete", lightuserdata )
-*
-* Creation and cleanup of actual 'deep' objects. 'luaG_...' will wrap them into
-* regular userdata proxies, per each state using the deep data.
-*
-*   tbl= linda_id( "metatable" )
-*
-* Returns a metatable for the proxy objects ('__gc' method not needed; will
-* be added by 'luaG_...')
-*
-*   string= linda_id( "module")
-*
-* Returns the name of the module that a state should require
-* in order to keep a handle on the shared library that exported the idfunc
-*
-*   = linda_id( str, ... )
-*
-* For any other strings, the ID function must not react at all. This allows
-* future extensions of the system. 
-*/
-static void* linda_id( lua_State* L, DeepOp op_)
-{
-    switch( op_)
-    {
-        case eDO_new:
-        {
-            Universe* const U = universe_get(L);
-            struct s_Linda* s;
-            size_t name_len = 0;
-            char const* linda_name = NULL;
-            unsigned long linda_group = 0;
-            // should have a string and/or a number of the stack as parameters (name and group)
-            switch( lua_gettop( L))
-            {
-                default: // 0
-                break;
-
-                case 1: // 1 parameter, either a name or a group
-                if( lua_type( L, -1) == LUA_TSTRING)
-                {
-                    linda_name = lua_tolstring( L, -1, &name_len);
-                }
-                else
-                {
-                    linda_group = (unsigned long) lua_tointeger( L, -1);
-                }
-                break;
-
-                case 2: // 2 parameters, a name and group, in that order
-                linda_name = lua_tolstring( L, -2, &name_len);
-                linda_group = (unsigned long) lua_tointeger( L, -1);
-                break;
-            }
-
-            /* The deep data is allocated separately of Lua stack; we might no
-            * longer be around when last reference to it is being released.
-            * One can use any memory allocation scheme.
-            * just don't use L's allocF because we don't know which state will get the honor of GCing the linda
-            */
-            {
-                AllocatorDefinition* const allocD = &U->internal_allocator;
-                s = (struct s_Linda*) allocD->allocF(allocD->allocUD, NULL, 0, sizeof(struct s_Linda) + name_len); // terminating 0 is already included
-            }
-            if( s)
-            {
-                s->prelude.magic.value = DEEP_VERSION.value;
-                SIGNAL_INIT( &s->read_happened);
-                SIGNAL_INIT( &s->write_happened);
-                s->U = U;
-                s->simulate_cancel = CANCEL_NONE;
-                s->group = linda_group << KEEPER_MAGIC_SHIFT;
-                s->name[0] = 0;
-                memcpy( s->name, linda_name, name_len ? name_len + 1 : 0);
-            }
-            return s;
-        }
-
-        case eDO_delete:
-        {
-            Keeper* myK;
-            struct s_Linda* linda = lua_touserdata( L, 1);
-            ASSERT_L( linda);
-
-            // Clean associated structures in the keeper state.
-            myK = which_keeper( linda->U->keepers, LINDA_KEEPER_HASHSEED( linda));
-            if (myK)
-            {
-                // if collected from my own keeper, we can't acquire/release it
-                // because we are already inside a protected area, and trying to do so would deadlock!
-                bool_t const need_acquire_release = (myK->L != L);
-                // Clean associated structures in the keeper state.
-                Keeper* const K = need_acquire_release ? keeper_acquire(linda->U->keepers, LINDA_KEEPER_HASHSEED(linda)) : myK;
-                // hopefully this won't ever raise an error as we would jump to the closest pcall site while forgetting to release the keeper mutex...
-                keeper_call(linda->U, K->L, KEEPER_API(clear), L, linda, 0);
-                if(need_acquire_release)
-                {
-                    keeper_release(K);
-                }
-            }
-
-            // There aren't any lanes waiting on these lindas, since all proxies have been gc'ed. Right?
-            SIGNAL_FREE( &linda->read_happened);
-            SIGNAL_FREE( &linda->write_happened);
-            {
-                AllocatorDefinition* const allocD = &linda->U->internal_allocator;
-                (void) allocD->allocF(allocD->allocUD, linda, sizeof(struct s_Linda) + strlen(linda->name), 0);
-            }
-            return NULL;
-        }
-
-        case eDO_metatable:
-        {
-
-            STACK_CHECK( L, 0);
-            lua_newtable( L);
-            // metatable is its own index
-            lua_pushvalue( L, -1);
-            lua_setfield( L, -2, "__index");
-
-            // protect metatable from external access
-            lua_pushliteral( L, "Linda");
-            lua_setfield( L, -2, "__metatable");
-
-            lua_pushcfunction( L, LG_linda_tostring);
-            lua_setfield( L, -2, "__tostring");
-
-            // Decoda __towatch support
-            lua_pushcfunction( L, LG_linda_towatch);
-            lua_setfield( L, -2, "__towatch");
-
-            lua_pushcfunction( L, LG_linda_concat);
-            lua_setfield( L, -2, "__concat");
-
-            // protected calls, to ensure associated keeper is always released even in case of error
-            // all function are the protected call wrapper, where the actual operation is provided as upvalue
-            // note that this kind of thing can break function lookup as we use the function pointer here and there
-
-            lua_pushcfunction( L, LG_linda_send);
-            lua_pushcclosure( L, LG_linda_protected_call, 1);
-            lua_setfield( L, -2, "send");
-
-            lua_pushcfunction( L, LG_linda_receive);
-            lua_pushcclosure( L, LG_linda_protected_call, 1);
-            lua_setfield( L, -2, "receive");
-
-            lua_pushcfunction( L, LG_linda_limit);
-            lua_pushcclosure( L, LG_linda_protected_call, 1);
-            lua_setfield( L, -2, "limit");
-
-            lua_pushcfunction( L, LG_linda_set);
-            lua_pushcclosure( L, LG_linda_protected_call, 1);
-            lua_setfield( L, -2, "set");
-
-            lua_pushcfunction( L, LG_linda_count);
-            lua_pushcclosure( L, LG_linda_protected_call, 1);
-            lua_setfield( L, -2, "count");
-
-            lua_pushcfunction( L, LG_linda_get);
-            lua_pushcclosure( L, LG_linda_protected_call, 1);
-            lua_setfield( L, -2, "get");
-
-            lua_pushcfunction( L, LG_linda_cancel);
-            lua_setfield( L, -2, "cancel");
-
-            lua_pushcfunction( L, LG_linda_deep);
-            lua_setfield( L, -2, "deep");
-
-            lua_pushcfunction( L, LG_linda_dump);
-            lua_pushcclosure( L, LG_linda_protected_call, 1);
-            lua_setfield( L, -2, "dump");
-
-            // some constants
-            push_unique_key( L, BATCH_SENTINEL);
-            lua_setfield( L, -2, "batched");
-
-            push_unique_key( L, NIL_SENTINEL);
-            lua_setfield( L, -2, "null");
-
-            STACK_END( L, 1);
-            return NULL;
-        }
-
-        case eDO_module:
-        // linda is a special case because we know lanes must be loaded from the main lua state
-        // to be able to ever get here, so we know it will remain loaded as long a the main state is around
-        // in other words, forever.
-        default:
-        {
-            return NULL;
-        }
-    }
-}
-
-/*
- * ud = lanes.linda( [name[,group]])
- *
- * returns a linda object, or raises an error if creation failed
- */
-LUAG_FUNC( linda)
-{
-    int const top = lua_gettop( L);
-    luaL_argcheck( L, top <= 2, top, "too many arguments");
-    if( top == 1)
-    {
-        int const t = lua_type( L, 1);
-        luaL_argcheck( L, t == LUA_TSTRING || t == LUA_TNUMBER, 1, "wrong parameter (should be a string or a number)");
-    }
-    else if( top == 2)
-    {
-        luaL_checktype( L, 1, LUA_TSTRING);
-        luaL_checktype( L, 2, LUA_TNUMBER);
-    }
-    return luaG_newdeepuserdata( L, linda_id, 0);
-}
diff --git a/src/linda.cpp b/src/linda.cpp
new file mode 100644
index 0000000..e749f52
--- /dev/null
+++ b/src/linda.cpp
@@ -0,0 +1,1025 @@
+/*
+ * LINDA.CPP                        Copyright (c) 2018-2024, Benoit Germain
+ *
+ * Linda deep userdata.
+*/
+
+/*
+===============================================================================
+
+Copyright (C) 2018 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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+===============================================================================
+*/
+
+#include "compat.h"
+#include "deep.h"
+#include "keeper.h"
+#include "lanes_private.h"
+#include "threading.h"
+#include "tools.h"
+#include "universe.h"
+
+#include <array>
+#include <variant>
+
+/*
+* Actual data is kept within a keeper state, which is hashed by the 'Linda'
+* pointer (which is same to all userdatas pointing to it).
+*/
+class Linda : public DeepPrelude // Deep userdata MUST start with this header
+{
+    private:
+
+    static constexpr size_t kEmbeddedNameLength = 24;
+    using EmbeddedName = std::array<char, kEmbeddedNameLength>;
+    struct AllocatedName
+    {
+        size_t len{ 0 };
+        char* name{ nullptr };
+    };
+    // depending on the name length, it is either embedded inside the Linda, or allocated separately
+    std::variant<AllocatedName, EmbeddedName> m_name;
+
+    public:
+
+    std::condition_variable m_read_happened;
+    std::condition_variable m_write_happened;
+    Universe* const U; // the universe this linda belongs to
+    uintptr_t const group; // a group to control keeper allocation between lindas
+    CancelRequest simulate_cancel{ CancelRequest::None };
+
+    public:
+
+    // a fifo full userdata has one uservalue, the table that holds the actual fifo contents
+    [[nodiscard]] static void* operator new(size_t size_, Universe* U_) noexcept { return U_->internal_allocator.alloc(size_); }
+    // always embedded somewhere else or "in-place constructed" as a full userdata
+    // can't actually delete the operator because the compiler generates stack unwinding code that could call it in case of exception
+    static void operator delete(void* p_, Universe* U_) { U_->internal_allocator.free(p_, sizeof(Linda)); }
+    // this one is for us, to make sure memory is freed by the correct allocator
+    static void operator delete(void* p_) { static_cast<Linda*>(p_)->U->internal_allocator.free(p_, sizeof(Linda)); }
+
+    Linda(Universe* U_, uintptr_t group_, char const* name_, size_t len_)
+    : U{ U_ }
+    , group{ group_ << KEEPER_MAGIC_SHIFT }
+    {
+        setName(name_, len_);
+    }
+
+    ~Linda()
+    {
+        if (std::holds_alternative<AllocatedName>(m_name))
+        {
+            AllocatedName& name = std::get<AllocatedName>(m_name);
+            U->internal_allocator.free(name.name, name.len);
+        }
+    }
+
+    private:
+
+    void setName(char const* name_, size_t len_)
+    {
+        // keep default
+        if (!name_ || len_ == 0)
+        {
+            return;
+        }
+        ++len_; // don't forget terminating 0
+        if (len_ < kEmbeddedNameLength)
+        {
+            m_name.emplace<EmbeddedName>();
+            char* const name{ std::get<EmbeddedName>(m_name).data() };
+            memcpy(name, name_, len_);
+        }
+        else
+        {
+            AllocatedName& name = std::get<AllocatedName>(m_name);
+            name.name = static_cast<char*>(U->internal_allocator.alloc(len_));
+            name.len = len_;
+            memcpy(name.name, name_, len_);
+        }
+    }
+
+    public:
+
+    uintptr_t hashSeed() const { return group ? group : std::bit_cast<uintptr_t>(this); }
+
+    char const* getName() const
+    {
+        if (std::holds_alternative<AllocatedName>(m_name))
+        {
+            AllocatedName const& name = std::get<AllocatedName>(m_name);
+            return name.name;
+        }
+        if (std::holds_alternative<EmbeddedName>(m_name))
+        {
+            char const* const name{ std::get<EmbeddedName>(m_name).data() };
+            return name;
+        }
+        return nullptr;
+    }
+};
+[[nodiscard]] static void* linda_id(lua_State*, DeepOp);
+
+template<bool OPT>
+[[nodiscard]] static inline Linda* lua_toLinda(lua_State* L, int idx_)
+{
+    Linda* const linda{ static_cast<Linda*>(luaG_todeep(L, linda_id, idx_)) };
+    if (!OPT)
+    {
+        luaL_argcheck(L, linda != nullptr, idx_, "expecting a linda object");
+    }
+    ASSERT_L(linda->U == universe_get(L));
+    return linda;
+}
+
+// #################################################################################################
+
+static void check_key_types(lua_State* L, int start_, int end_)
+{
+    for (int i{ start_ }; i <= end_; ++i)
+    {
+        int const t{ lua_type(L, i) };
+        if (t == LUA_TBOOLEAN || t == LUA_TNUMBER || t == LUA_TSTRING || t == LUA_TLIGHTUSERDATA)
+        {
+            continue;
+        }
+        luaL_error(L, "argument #%d: invalid key type (not a boolean, string, number or light userdata)", i); // doesn't return
+    }
+}
+
+// #################################################################################################
+
+LUAG_FUNC(linda_protected_call)
+{
+    Linda* const linda{ lua_toLinda<false>(L, 1) };
+
+    // acquire the keeper
+    Keeper* const K{ keeper_acquire(linda->U->keepers, linda->hashSeed()) };
+    lua_State* const KL{ K ? K->L : nullptr };
+    if (KL == nullptr)
+        return 0;
+
+    // retrieve the actual function to be called and move it before the arguments
+    lua_pushvalue(L, lua_upvalueindex(1));
+    lua_insert(L, 1);
+    // do a protected call
+    int const rc{ lua_pcall(L, lua_gettop(L) - 1, LUA_MULTRET, 0) };
+
+    // release the keeper
+    keeper_release(K);
+
+    // if there was an error, forward it
+    if (rc != LUA_OK)
+    {
+        raise_lua_error(L);
+    }
+    // return whatever the actual operation provided
+    return lua_gettop(L);
+}
+
+// #################################################################################################
+
+/*
+* bool= linda_send( linda_ud, [timeout_secs=-1,] [linda.null,] key_num|str|bool|lightuserdata, ... )
+*
+* Send one or more values to a Linda. If there is a limit, all values must fit.
+*
+* Returns:  'true' if the value was queued
+*           'false' for timeout (only happens when the queue size is limited)
+*           nil, CANCEL_ERROR if cancelled
+*/
+LUAG_FUNC(linda_send)
+{
+    Linda* const linda{ lua_toLinda<false>(L, 1) };
+    std::chrono::time_point<std::chrono::steady_clock> until{ std::chrono::time_point<std::chrono::steady_clock>::max() };
+    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
+    {
+        lua_Duration const duration{ lua_tonumber(L, 2) };
+        if (duration.count() >= 0.0)
+        {
+            until = std::chrono::steady_clock::now() + std::chrono::duration_cast<std::chrono::steady_clock::duration>(duration);
+        }
+        ++key_i;
+    }
+    else if (lua_isnil(L, 2)) // alternate explicit "infinite timeout" by passing nil before the key
+    {
+        ++key_i;
+    }
+
+    bool const as_nil_sentinel{ NIL_SENTINEL.equals(L, key_i) }; // if not nullptr, send() will silently send a single nil if nothing is provided
+    if (as_nil_sentinel)
+    {
+        // the real key to send data to is after the NIL_SENTINEL marker
+        ++key_i;
+    }
+
+    // make sure the key is of a valid type
+    check_key_types(L, key_i, key_i);
+
+    STACK_GROW(L, 1);
+
+    // make sure there is something to send
+    if (lua_gettop(L) == key_i)
+    {
+        if (as_nil_sentinel)
+        {
+            // send a single nil if nothing is provided
+            NIL_SENTINEL.pushKey(L);
+        }
+        else
+        {
+            return luaL_error(L, "no data to send");
+        }
+    }
+
+    // convert nils to some special non-nil sentinel in sent values
+    keeper_toggle_nil_sentinels(L, key_i + 1, LookupMode::ToKeeper);
+    bool ret{ false };
+    CancelRequest cancel{ CancelRequest::None };
+    int pushed{ 0 };
+    {
+        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)
+            return 0;
+
+        STACK_CHECK_START_REL(KL, 0);
+        for (bool try_again{ true };;)
+        {
+            if (lane != nullptr)
+            {
+                cancel = lane->cancel_request;
+            }
+            cancel = (cancel != CancelRequest::None) ? cancel : linda->simulate_cancel;
+            // if user wants to cancel, or looped because of a timeout, the call returns without sending anything
+            if (!try_again || cancel != CancelRequest::None)
+            {
+                pushed = 0;
+                break;
+            }
+
+            STACK_CHECK(KL, 0);
+            pushed = keeper_call(linda->U, KL, KEEPER_API(send), L, linda, key_i);
+            if (pushed < 0)
+            {
+                break;
+            }
+            ASSERT_L(pushed == 1);
+
+            ret = lua_toboolean(L, -1) ? true : false;
+            lua_pop(L, 1);
+
+            if (ret)
+            {
+                // Wake up ALL waiting threads
+                linda->m_write_happened.notify_all();
+                break;
+            }
+
+            // instant timout to bypass the wait syscall
+            if (std::chrono::steady_clock::now() >= until)
+            {
+                break; /* no wait; instant timeout */
+            }
+
+            // storage limit hit, wait until timeout or signalled that we should try again
+            {
+                Lane::Status prev_status{ Lane::Error }; // prevent 'might be used uninitialized' warnings
+                if (lane != nullptr)
+                {
+                    // change status of lane to "waiting"
+                    prev_status = lane->m_status; // Running, most likely
+                    ASSERT_L(prev_status == Lane::Running); // but check, just in case
+                    lane->m_status = Lane::Waiting;
+                    ASSERT_L(lane->m_waiting_on == nullptr);
+                    lane->m_waiting_on = &linda->m_read_happened;
+                }
+                // could not send because no room: wait until some data was read before trying again, or until timeout is reached
+                std::unique_lock<std::mutex> keeper_lock{ K->m_mutex, std::adopt_lock };
+                std::cv_status const status{ linda->m_read_happened.wait_until(keeper_lock, until) };
+                keeper_lock.release(); // we don't want to release the lock!
+                try_again = (status == std::cv_status::no_timeout); // detect spurious wakeups
+                if (lane != nullptr)
+                {
+                    lane->m_waiting_on = nullptr;
+                    lane->m_status = prev_status;
+                }
+            }
+        }
+        STACK_CHECK(KL, 0);
+    }
+
+    if (pushed < 0)
+    {
+        return luaL_error(L, "tried to copy unsupported types");
+    }
+
+    switch (cancel)
+    {
+        case CancelRequest::Soft:
+        // if user wants to soft-cancel, the call returns lanes.cancel_error
+        CANCEL_ERROR.pushKey(L);
+        return 1;
+
+        case CancelRequest::Hard:
+        // raise an error interrupting execution only in case of hard cancel
+        raise_cancel_error(L); // raises an error and doesn't return
+
+        default:
+        lua_pushboolean(L, ret); // true (success) or false (timeout)
+        return 1;
+    }
+}
+
+// #################################################################################################
+
+/*
+ * 2 modes of operation
+ * [val, key]= linda_receive( linda_ud, [timeout_secs_num=-1], key_num|str|bool|lightuserdata [, ...] )
+ * Consumes a single value from the Linda, in any key.
+ * Returns: received value (which is consumed from the slot), and the key which had it
+
+ * [val1, ... valCOUNT]= linda_receive( linda_ud, [timeout_secs_num=-1], linda.batched, key_num|str|bool|lightuserdata, min_COUNT[, max_COUNT])
+ * Consumes between min_COUNT and max_COUNT values from the linda, from a single key.
+ * returns the actual consumed values, or nil if there weren't enough values to consume
+ *
+ */
+// xxh64 of string "CANCEL_ERROR" generated at https://www.pelock.com/products/hash-calculator
+static constexpr UniqueKey BATCH_SENTINEL{ 0x2DDFEE0968C62AA7ull };
+LUAG_FUNC(linda_receive)
+{
+    Linda* const linda{ lua_toLinda<false>(L, 1) };
+    std::chrono::time_point<std::chrono::steady_clock> until{ std::chrono::time_point<std::chrono::steady_clock>::max() };
+    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
+    {
+        lua_Duration const duration{ lua_tonumber(L, 2) };
+        if (duration.count() >= 0.0)
+        {
+            until = std::chrono::steady_clock::now() + std::chrono::duration_cast<std::chrono::steady_clock::duration>(duration);
+        }
+        ++key_i;
+    }
+    else if (lua_isnil(L, 2)) // alternate explicit "infinite timeout" by passing nil before the key
+    {
+        ++key_i;
+    }
+
+    keeper_api_t selected_keeper_receive{ nullptr };
+    int expected_pushed_min{ 0 }, expected_pushed_max{ 0 };
+    // are we in batched mode?
+    BATCH_SENTINEL.pushKey(L);
+    int const is_batched{ lua501_equal(L, key_i, -1) };
+    lua_pop(L, 1);
+    if (is_batched)
+    {
+        // no need to pass linda.batched in the keeper state
+        ++key_i;
+        // make sure the keys are of a valid type
+        check_key_types(L, key_i, key_i);
+        // receive multiple values from a single slot
+        selected_keeper_receive = KEEPER_API(receive_batched);
+        // we expect a user-defined amount of return value
+        expected_pushed_min = (int) luaL_checkinteger(L, key_i + 1);
+        expected_pushed_max = (int) luaL_optinteger(L, key_i + 2, expected_pushed_min);
+        // don't forget to count the key in addition to the values
+        ++expected_pushed_min;
+        ++expected_pushed_max;
+        if (expected_pushed_min > expected_pushed_max)
+        {
+            return luaL_error(L, "batched min/max error");
+        }
+    }
+    else
+    {
+        // make sure the keys are of a valid type
+        check_key_types(L, key_i, lua_gettop(L));
+        // receive a single value, checking multiple slots
+        selected_keeper_receive = KEEPER_API(receive);
+        // we expect a single (value, key) pair of returned values
+        expected_pushed_min = expected_pushed_max = 2;
+    }
+
+    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)
+        return 0;
+
+    CancelRequest cancel{ CancelRequest::None };
+    int pushed{ 0 };
+    STACK_CHECK_START_REL(KL, 0);
+    for (bool try_again{ true };;)
+    {
+        if (lane != nullptr)
+        {
+            cancel = lane->cancel_request;
+        }
+        cancel = (cancel != CancelRequest::None) ? cancel : linda->simulate_cancel;
+        // if user wants to cancel, or looped because of a timeout, the call returns without sending anything
+        if (!try_again || cancel != CancelRequest::None)
+        {
+            pushed = 0;
+            break;
+        }
+
+        // all arguments of receive() but the first are passed to the keeper's receive function
+        pushed = keeper_call(linda->U, KL, selected_keeper_receive, L, linda, key_i);
+        if (pushed < 0)
+        {
+            break;
+        }
+        if (pushed > 0)
+        {
+            ASSERT_L(pushed >= expected_pushed_min && pushed <= expected_pushed_max);
+            // replace sentinels with real nils
+            keeper_toggle_nil_sentinels(L, lua_gettop(L) - pushed, LookupMode::FromKeeper);
+            // To be done from within the 'K' locking area
+            //
+            linda->m_read_happened.notify_all();
+            break;
+        }
+
+        if (std::chrono::steady_clock::now() >= until)
+        {
+            break; /* instant timeout */
+        }
+
+        // nothing received, wait until timeout or signalled that we should try again
+        {
+            Lane::Status prev_status{ Lane::Error }; // prevent 'might be used uninitialized' warnings
+            if (lane != nullptr)
+            {
+                // change status of lane to "waiting"
+                prev_status = lane->m_status; // Running, most likely
+                ASSERT_L(prev_status == Lane::Running); // but check, just in case
+                lane->m_status = Lane::Waiting;
+                ASSERT_L(lane->m_waiting_on == nullptr);
+                lane->m_waiting_on = &linda->m_write_happened;
+            }
+            // not enough data to read: wakeup when data was sent, or when timeout is reached
+            std::unique_lock<std::mutex> keeper_lock{ K->m_mutex, std::adopt_lock };
+            std::cv_status const status{ linda->m_write_happened.wait_until(keeper_lock, until) };
+            keeper_lock.release(); // we don't want to release the lock!
+            try_again = (status == std::cv_status::no_timeout); // detect spurious wakeups
+            if (lane != nullptr)
+            {
+                lane->m_waiting_on = nullptr;
+                lane->m_status = prev_status;
+            }
+        }
+    }
+    STACK_CHECK(KL, 0);
+
+    if (pushed < 0)
+    {
+        return luaL_error(L, "tried to copy unsupported types");
+    }
+
+    switch (cancel)
+    {
+        case CancelRequest::Soft:
+        // if user wants to soft-cancel, the call returns CANCEL_ERROR
+        CANCEL_ERROR.pushKey(L);
+        return 1;
+
+        case CancelRequest::Hard:
+        // raise an error interrupting execution only in case of hard cancel
+        raise_cancel_error(L); // raises an error and doesn't return
+
+        default:
+        return pushed;
+    }
+}
+
+// #################################################################################################
+
+/*
+* [true|lanes.cancel_error] = linda_set( linda_ud, key_num|str|bool|lightuserdata [, value [, ...]])
+*
+* Set one or more value to Linda.
+* TODO: what do we do if we set to non-nil and limit is 0?
+*
+* Existing slot value is replaced, and possible queued entries removed.
+*/
+LUAG_FUNC(linda_set)
+{
+    Linda* const linda{ lua_toLinda<false>(L, 1) };
+    bool const has_value{ lua_gettop(L) > 2 };
+    // make sure the key is of a valid type (throws an error if not the case)
+    check_key_types(L, 2, 2);
+
+    Keeper* const K{ which_keeper(linda->U->keepers, linda->hashSeed()) };
+    int pushed{ 0 };
+    if (linda->simulate_cancel == CancelRequest::None)
+    {
+        if (has_value)
+        {
+            // convert nils to some special non-nil sentinel in sent values
+            keeper_toggle_nil_sentinels(L, 3, LookupMode::ToKeeper);
+        }
+        pushed = keeper_call(linda->U, K->L, KEEPER_API(set), L, linda, 2);
+        if (pushed >= 0) // no error?
+        {
+            ASSERT_L(pushed == 0 || pushed == 1);
+
+            if (has_value)
+            {
+                // we put some data in the slot, tell readers that they should wake
+                linda->m_write_happened.notify_all(); // To be done from within the 'K' locking area
+            }
+            if (pushed == 1)
+            {
+                // the key was full, but it is no longer the case, tell writers they should wake
+                ASSERT_L(lua_type(L, -1) == LUA_TBOOLEAN && lua_toboolean(L, -1) == 1);
+                linda->m_read_happened.notify_all(); // To be done from within the 'K' locking area
+            }
+        }
+    }
+    else // linda is cancelled
+    {
+        // do nothing and return lanes.cancel_error
+        CANCEL_ERROR.pushKey(L);
+        pushed = 1;
+    }
+
+    // must trigger any error after keeper state has been released
+    return (pushed < 0) ? luaL_error(L, "tried to copy unsupported types") : pushed;
+}
+
+// #################################################################################################
+
+/*
+ * [val] = linda_count( linda_ud, [key [, ...]])
+ *
+ * Get a count of the pending elements in the specified keys
+ */
+LUAG_FUNC(linda_count)
+{
+    Linda* const linda{ lua_toLinda<false>(L, 1) };
+    // make sure the keys are of a valid type
+    check_key_types(L, 2, lua_gettop(L));
+
+    Keeper* const K{ which_keeper(linda->U->keepers, linda->hashSeed()) };
+    int const pushed{ keeper_call(linda->U, K->L, KEEPER_API(count), L, linda, 2) };
+    if (pushed < 0)
+    {
+        return luaL_error(L, "tried to count an invalid key");
+    }
+    return pushed;
+}
+
+// #################################################################################################
+
+/*
+* [val [, ...]] = linda_get( linda_ud, key_num|str|bool|lightuserdata [, count = 1])
+*
+* Get one or more values from Linda.
+*/
+LUAG_FUNC(linda_get)
+{
+    Linda* const linda{ lua_toLinda<false>(L, 1) };
+    lua_Integer const count{ luaL_optinteger(L, 3, 1) };
+    luaL_argcheck(L, count >= 1, 3, "count should be >= 1");
+    luaL_argcheck(L, lua_gettop(L) <= 3, 4, "too many arguments");
+    // make sure the key is of a valid type (throws an error if not the case)
+    check_key_types(L, 2, 2);
+
+    int pushed{ 0 };
+    if (linda->simulate_cancel == CancelRequest::None)
+    {
+        Keeper* const K{ which_keeper(linda->U->keepers, linda->hashSeed()) };
+        pushed = keeper_call(linda->U, K->L, KEEPER_API(get), L, linda, 2);
+        if (pushed > 0)
+        {
+            keeper_toggle_nil_sentinels(L, lua_gettop(L) - pushed, LookupMode::FromKeeper);
+        }
+    }
+    else // linda is cancelled
+    {
+        // do nothing and return lanes.cancel_error
+        CANCEL_ERROR.pushKey(L);
+        pushed = 1;
+    }
+    // an error can be raised if we attempt to read an unregistered function
+    if (pushed < 0)
+    {
+        return luaL_error(L, "tried to copy unsupported types");
+    }
+
+    return pushed;
+}
+
+// #################################################################################################
+
+/*
+* [true] = linda_limit( linda_ud, key_num|str|bool|lightuserdata, int)
+*
+* Set limit to 1 Linda keys.
+* Optionally wake threads waiting to write on the linda, in case the limit enables them to do so
+*/
+LUAG_FUNC( linda_limit)
+{
+    Linda* const linda{ lua_toLinda<false>(L, 1) };
+    // make sure we got 3 arguments: the linda, a key and a limit
+    luaL_argcheck( L, lua_gettop( L) == 3, 2, "wrong number of arguments");
+    // make sure we got a numeric limit
+    luaL_checknumber( L, 3);
+    // make sure the key is of a valid type
+    check_key_types( L, 2, 2);
+
+    int pushed{ 0 };
+    if (linda->simulate_cancel == CancelRequest::None)
+    {
+        Keeper* const K{ which_keeper(linda->U->keepers, linda->hashSeed()) };
+        pushed = keeper_call(linda->U, K->L, KEEPER_API(limit), L, linda, 2);
+        ASSERT_L( pushed == 0 || pushed == 1); // no error, optional boolean value saying if we should wake blocked writer threads
+        if( pushed == 1)
+        {
+            ASSERT_L( lua_type( L, -1) == LUA_TBOOLEAN && lua_toboolean( L, -1) == 1);
+            linda->m_read_happened.notify_all(); // To be done from within the 'K' locking area
+        }
+    }
+    else // linda is cancelled
+    {
+        // do nothing and return lanes.cancel_error
+        CANCEL_ERROR.pushKey(L);
+        pushed = 1;
+    }
+    // propagate pushed boolean if any
+    return pushed;
+}
+
+// #################################################################################################
+
+/*
+* (void) = linda_cancel( linda_ud, "read"|"write"|"both"|"none")
+*
+* Signal linda so that waiting threads wake up as if their own lane was cancelled
+*/
+LUAG_FUNC(linda_cancel)
+{
+    Linda* const linda{ lua_toLinda<false>(L, 1) };
+    char const* who = luaL_optstring(L, 2, "both");
+    // make sure we got 3 arguments: the linda, a key and a limit
+    luaL_argcheck(L, lua_gettop(L) <= 2, 2, "wrong number of arguments");
+
+    linda->simulate_cancel = CancelRequest::Soft;
+    if (strcmp(who, "both") == 0) // tell everyone writers to wake up
+    {
+        linda->m_write_happened.notify_all();
+        linda->m_read_happened.notify_all();
+    }
+    else if (strcmp(who, "none") == 0) // reset flag
+    {
+        linda->simulate_cancel = CancelRequest::None;
+    }
+    else if (strcmp(who, "read") == 0) // tell blocked readers to wake up
+    {
+        linda->m_write_happened.notify_all();
+    }
+    else if (strcmp(who, "write") == 0) // tell blocked writers to wake up
+    {
+        linda->m_read_happened.notify_all();
+    }
+    else
+    {
+        return luaL_error(L, "unknown wake hint '%s'", who);
+    }
+    return 0;
+}
+
+// #################################################################################################
+
+/*
+* lightuserdata= linda_deep( linda_ud )
+*
+* Return the 'deep' userdata pointer, identifying the Linda.
+*
+* This is needed for using Lindas as key indices (timer system needs it);
+* separately created proxies of the same underlying deep object will have
+* different userdata and won't be known to be essentially the same deep one
+* without this.
+*/
+LUAG_FUNC(linda_deep)
+{
+    Linda* const linda{ lua_toLinda<false>(L, 1) };
+    lua_pushlightuserdata(L, linda); // just the address
+    return 1;
+}
+
+// #################################################################################################
+
+/*
+* string = linda:__tostring( linda_ud)
+*
+* Return the stringification of a linda
+*
+* Useful for concatenation or debugging purposes
+*/
+
+template <bool OPT>
+[[nodiscard]] static int linda_tostring(lua_State* L, int idx_)
+{
+    Linda* const linda{ lua_toLinda<OPT>(L, idx_) };
+    if (linda != nullptr)
+    {
+        char text[128];
+        int len;
+        if (linda->getName())
+            len = sprintf(text, "Linda: %.*s", (int) sizeof(text) - 8, linda->getName());
+        else
+            len = sprintf(text, "Linda: %p", linda);
+        lua_pushlstring(L, text, len);
+        return 1;
+    }
+    return 0;
+}
+
+LUAG_FUNC(linda_tostring)
+{
+    return linda_tostring<false>(L, 1);
+}
+
+// #################################################################################################
+
+/*
+* string = linda:__concat( a, b)
+*
+* Return the concatenation of a pair of items, one of them being a linda
+*
+* Useful for concatenation or debugging purposes
+*/
+LUAG_FUNC(linda_concat)
+{ // linda1? linda2?
+    bool atLeastOneLinda{ false };
+    // Lua semantics enforce that one of the 2 arguments is a Linda, but not necessarily both.
+    if (linda_tostring<true>(L, 1))
+    {
+        atLeastOneLinda = true;
+        lua_replace(L, 1);
+    }
+    if (linda_tostring<true>(L, 2))
+    {
+        atLeastOneLinda = true;
+        lua_replace(L, 2);
+    }
+    if (!atLeastOneLinda) // should not be possible
+    {
+        return luaL_error(L, "internal error: linda_concat called on non-Linda");
+    }
+    lua_concat(L, 2);
+    return 1;
+}
+
+// #################################################################################################
+
+/*
+ * table = linda:dump()
+ * return a table listing all pending data inside the linda
+ */
+LUAG_FUNC(linda_dump)
+{
+    Linda* const linda{ lua_toLinda<false>(L, 1) };
+    return keeper_push_linda_storage(linda->U, Dest{ L }, linda, linda->hashSeed());
+}
+
+// #################################################################################################
+
+/*
+ * table = linda:dump()
+ * return a table listing all pending data inside the linda
+ */
+LUAG_FUNC(linda_towatch)
+{
+    Linda* const linda{ lua_toLinda<false>(L, 1) };
+    int pushed{ keeper_push_linda_storage(linda->U, Dest{ L }, linda, linda->hashSeed()) };
+    if (pushed == 0)
+    {
+        // if the linda is empty, don't return nil
+        pushed = linda_tostring<false>(L, 1);
+    }
+    return pushed;
+}
+
+// #################################################################################################
+
+/*
+* Identity function of a shared userdata object.
+* 
+*   lightuserdata= linda_id( "new" [, ...] )
+*   = linda_id( "delete", lightuserdata )
+*
+* Creation and cleanup of actual 'deep' objects. 'luaG_...' will wrap them into
+* regular userdata proxies, per each state using the deep data.
+*
+*   tbl= linda_id( "metatable" )
+*
+* Returns a metatable for the proxy objects ('__gc' method not needed; will
+* be added by 'luaG_...')
+*
+*   string= linda_id( "module")
+*
+* Returns the name of the module that a state should require
+* in order to keep a handle on the shared library that exported the idfunc
+*
+*   = linda_id( str, ... )
+*
+* For any other strings, the ID function must not react at all. This allows
+* future extensions of the system. 
+*/
+[[nodiscard]] static void* linda_id(lua_State* L, DeepOp op_)
+{
+    switch( op_)
+    {
+        case DeepOp::New:
+        {
+            size_t name_len = 0;
+            char const* linda_name = nullptr;
+            unsigned long linda_group = 0;
+            // should have a string and/or a number of the stack as parameters (name and group)
+            switch (lua_gettop(L))
+            {
+                default: // 0
+                break;
+
+                case 1: // 1 parameter, either a name or a group
+                if (lua_type(L, -1) == LUA_TSTRING)
+                {
+                    linda_name = lua_tolstring(L, -1, &name_len);
+                }
+                else
+                {
+                    linda_group = (unsigned long) lua_tointeger(L, -1);
+                }
+                break;
+
+                case 2: // 2 parameters, a name and group, in that order
+                linda_name = lua_tolstring(L, -2, &name_len);
+                linda_group = (unsigned long) lua_tointeger(L, -1);
+                break;
+            }
+
+            /* The deep data is allocated separately of Lua stack; we might no
+             * longer be around when last reference to it is being released.
+             * One can use any memory allocation scheme.
+             * just don't use L's allocF because we don't know which state will get the honor of GCing the linda
+             */
+            Universe* const U{ universe_get(L) };
+            Linda* linda{ new (U) Linda{ U, linda_group, linda_name, name_len } };
+            return linda;
+        }
+
+        case DeepOp::Delete:
+        {
+            Linda* const linda{ lua_tolightuserdata<Linda>(L, 1) };
+            ASSERT_L(linda);
+            Keeper* const myK{ which_keeper(linda->U->keepers, linda->hashSeed()) };
+            // if collected after the universe, keepers are already destroyed, and there is nothing to clear
+            if (myK)
+            {
+                // if collected from my own keeper, we can't acquire/release it
+                // because we are already inside a protected area, and trying to do so would deadlock!
+                bool const need_acquire_release{ myK->L != L };
+                // Clean associated structures in the keeper state.
+                Keeper* const K{ need_acquire_release ? keeper_acquire(linda->U->keepers, linda->hashSeed()) : myK };
+                // hopefully this won't ever raise an error as we would jump to the closest pcall site while forgetting to release the keeper mutex...
+                std::ignore = keeper_call(linda->U, K->L, KEEPER_API(clear), L, linda, 0);
+                if (need_acquire_release)
+                {
+                    keeper_release(K);
+                }
+            }
+
+            delete linda; // operator delete overload ensures things go as expected
+            return nullptr;
+        }
+
+        case DeepOp::Metatable:
+        {
+            STACK_CHECK_START_REL(L, 0);
+            lua_newtable(L);
+            // metatable is its own index
+            lua_pushvalue(L, -1);
+            lua_setfield(L, -2, "__index");
+
+            // protect metatable from external access
+            lua_pushliteral(L, "Linda");
+            lua_setfield(L, -2, "__metatable");
+
+            lua_pushcfunction(L, LG_linda_tostring);
+            lua_setfield(L, -2, "__tostring");
+
+            // Decoda __towatch support
+            lua_pushcfunction(L, LG_linda_towatch);
+            lua_setfield(L, -2, "__towatch");
+
+            lua_pushcfunction(L, LG_linda_concat);
+            lua_setfield(L, -2, "__concat");
+
+            // protected calls, to ensure associated keeper is always released even in case of error
+            // all function are the protected call wrapper, where the actual operation is provided as upvalue
+            // note that this kind of thing can break function lookup as we use the function pointer here and there
+
+            lua_pushcfunction(L, LG_linda_send);
+            lua_pushcclosure(L, LG_linda_protected_call, 1);
+            lua_setfield(L, -2, "send");
+
+            lua_pushcfunction(L, LG_linda_receive);
+            lua_pushcclosure(L, LG_linda_protected_call, 1);
+            lua_setfield(L, -2, "receive");
+
+            lua_pushcfunction(L, LG_linda_limit);
+            lua_pushcclosure(L, LG_linda_protected_call, 1);
+            lua_setfield(L, -2, "limit");
+
+            lua_pushcfunction(L, LG_linda_set);
+            lua_pushcclosure(L, LG_linda_protected_call, 1);
+            lua_setfield(L, -2, "set");
+
+            lua_pushcfunction(L, LG_linda_count);
+            lua_pushcclosure(L, LG_linda_protected_call, 1);
+            lua_setfield(L, -2, "count");
+
+            lua_pushcfunction(L, LG_linda_get);
+            lua_pushcclosure(L, LG_linda_protected_call, 1);
+            lua_setfield(L, -2, "get");
+
+            lua_pushcfunction(L, LG_linda_cancel);
+            lua_setfield(L, -2, "cancel");
+
+            lua_pushcfunction(L, LG_linda_deep);
+            lua_setfield(L, -2, "deep");
+
+            lua_pushcfunction(L, LG_linda_dump);
+            lua_pushcclosure(L, LG_linda_protected_call, 1);
+            lua_setfield(L, -2, "dump");
+
+            // some constants
+            BATCH_SENTINEL.pushKey(L);
+            lua_setfield(L, -2, "batched");
+
+            NIL_SENTINEL.pushKey(L);
+            lua_setfield(L, -2, "null");
+
+            STACK_CHECK(L, 1);
+            return nullptr;
+        }
+
+        case DeepOp::Module:
+        // linda is a special case because we know lanes must be loaded from the main lua state
+        // to be able to ever get here, so we know it will remain loaded as long a the main state is around
+        // in other words, forever.
+        default:
+        {
+            return nullptr;
+        }
+    }
+}
+
+// #################################################################################################
+
+/*
+ * ud = lanes.linda( [name[,group]])
+ *
+ * returns a linda object, or raises an error if creation failed
+ */
+LUAG_FUNC(linda)
+{
+    int const top{ lua_gettop(L) };
+    luaL_argcheck(L, top <= 2, top, "too many arguments");
+    if (top == 1)
+    {
+        int const t{ lua_type(L, 1) };
+        luaL_argcheck(L, t == LUA_TSTRING || t == LUA_TNUMBER, 1, "wrong parameter (should be a string or a number)");
+    }
+    else if (top == 2)
+    {
+        luaL_checktype(L, 1, LUA_TSTRING);
+        luaL_checktype(L, 2, LUA_TNUMBER);
+    }
+    return luaG_newdeepuserdata(Dest{ L }, linda_id, 0);
+}
diff --git a/src/macros_and_utils.h b/src/macros_and_utils.h
index e184476..e8d5ab5 100644
--- a/src/macros_and_utils.h
+++ b/src/macros_and_utils.h
@@ -1,107 +1,193 @@
-/*
- * MACROS_AND_UTILS.H
- */
-#ifndef MACROS_AND_UTILS_H
-#define MACROS_AND_UTILS_H
+#pragma once
 
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
 #include "lua.h"
 #include "lualib.h"
 #include "lauxlib.h"
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#include <cassert>
+#include <chrono>
+#include <tuple>
+#include <type_traits>
 
- // M$ compiler doesn't support 'inline' keyword in C files...
-#if defined( _MSC_VER)
-#define inline __inline
-#endif
+using namespace std::chrono_literals;
 
 #define USE_DEBUG_SPEW() 0
 #if USE_DEBUG_SPEW()
 extern char const* debugspew_indent;
 #define INDENT_BEGIN "%.*s "
-#define INDENT_END , (U ? U->debugspew_indent_depth : 0), debugspew_indent
+#define INDENT_END , (U ? U->debugspew_indent_depth.load(std::memory_order_relaxed) : 0), debugspew_indent
 #define DEBUGSPEW_CODE(_code) _code
-#define DEBUGSPEW_PARAM_COMMA( param_) param_,
+#define DEBUGSPEW_OR_NOT(a_, b_) a_
+#define DEBUGSPEW_PARAM_COMMA(param_) param_,
 #define DEBUGSPEW_COMMA_PARAM( param_) , param_
 #else // USE_DEBUG_SPEW()
 #define DEBUGSPEW_CODE(_code)
-#define DEBUGSPEW_PARAM_COMMA( param_)
+#define DEBUGSPEW_OR_NOT(a_, b_) b_
+#define DEBUGSPEW_PARAM_COMMA(param_)
 #define DEBUGSPEW_COMMA_PARAM( param_)
 #endif // USE_DEBUG_SPEW()
 
 #ifdef NDEBUG
 
 #define _ASSERT_L(lua,c)     //nothing
-#define STACK_CHECK(L,o)     //nothing
-#define STACK_CHECK_ABS(L,o) //nothing
-#define STACK_MID(L,c)       //nothing
-#define STACK_END(L,c)       //nothing
 #define STACK_DUMP(L)        //nothing
 
+#define STACK_CHECK_START_REL(L, offset_)
+#define STACK_CHECK_START_ABS(L, offset_)
+#define STACK_CHECK_RESET_REL(L, offset_)
+#define STACK_CHECK_RESET_ABS(L, offset_)
+#define STACK_CHECK(L, offset_)
+
 #else // NDEBUG
 
-#define _ASSERT_L( L, cond_) if( (cond_) == 0) { (void) luaL_error( L, "ASSERT failed: %s:%d '%s'", __FILE__, __LINE__, #cond_);}
-
-#define STACK_CHECK( L, offset_) \
-    { \
-        int const L##_delta = offset_; \
-        if( (L##_delta < 0) || (lua_gettop( L) < L##_delta)) \
-        { \
-            assert( FALSE); \
-            (void) luaL_error( L, "STACK INIT ASSERT failed (%d not %d): %s:%d", lua_gettop( L), L##_delta, __FILE__, __LINE__); \
-        } \
-        int const L##_oldtop = lua_gettop( L) - L##_delta
-
-#define STACK_CHECK_ABS( L, offset_) \
-    { \
-        int const L##_pos = offset_; \
-        if( lua_gettop( L) < L##_pos) \
-        { \
-            assert( FALSE); \
-            (void) luaL_error( L, "STACK INIT ASSERT failed (%d not %d): %s:%d", lua_gettop( L), L##_pos, __FILE__, __LINE__); \
-        } \
-        int const L##_oldtop = 0
-
-#define STACK_MID( L, change) \
-        do if( change != LUA_MULTRET) \
-        { \
-            int stack_check_a = lua_gettop( L) - L##_oldtop; \
-            int stack_check_b = (change); \
-            if( stack_check_a != stack_check_b) \
-            { \
-                assert( FALSE); \
-                luaL_error( L, "STACK ASSERT failed (%d not %d): %s:%d", stack_check_a, stack_check_b, __FILE__, __LINE__); \
-            } \
-        } while( 0)
-
-#define STACK_END( L, change) \
-        STACK_MID( L, change); \
+#define _ASSERT_L(L, cond_) if( (cond_) == 0) { (void) luaL_error(L, "ASSERT failed: %s:%d '%s'", __FILE__, __LINE__, #cond_);}
+#define STACK_DUMP(L)    luaG_dump(L)
+
+class StackChecker
+{
+    private:
+    lua_State* const m_L;
+    int m_oldtop;
+
+    public:
+    struct Relative
+    {
+        int const m_offset;
+
+        operator int() const { return m_offset; }
+    };
+
+    struct Absolute
+    {
+        int const m_offset;
+
+        operator int() const { return m_offset; }
+    };
+
+    StackChecker(lua_State* const L_, Relative offset_, char const* file_, size_t const line_)
+    : m_L{ L_ }
+    , m_oldtop{ lua_gettop(L_) - offset_ }
+    {
+        if ((offset_ < 0) || (m_oldtop < 0))
+        {
+            assert(false);
+            luaL_error(m_L, "STACK INIT ASSERT failed (%d not %d): %s:%d", lua_gettop(m_L), offset_, file_, line_); // doesn't return
+        }
+    }
+
+    StackChecker(lua_State* const L_, Absolute pos_, char const* file_, size_t const line_)
+    : m_L{ L_ }
+    , m_oldtop{ 0 }
+    {
+        if (lua_gettop(m_L) != pos_)
+        {
+            assert(false);
+            luaL_error(m_L, "STACK INIT ASSERT failed (%d not %d): %s:%d", lua_gettop(m_L), pos_, file_, line_); // doesn't return
+        }
     }
 
-#define STACK_DUMP( L)    luaG_dump( L)
+    StackChecker& operator=(StackChecker const& rhs_)
+    {
+        assert(m_L == rhs_.m_L);
+        m_oldtop = rhs_.m_oldtop;
+        return *this;
+    }
+
+    // verify if the distance between the current top and the initial one is what we expect
+    void check(int expected_, char const* file_, size_t const line_)
+    {
+        if (expected_ != LUA_MULTRET)
+        {
+            int const actual{ lua_gettop(m_L) - m_oldtop };
+            if (actual != expected_)
+            {
+                assert(false);
+                luaL_error(m_L, "STACK ASSERT failed (%d not %d): %s:%d", actual, expected_, file_, line_); // doesn't return
+            }
+        }
+    }
+};
+
+#define STACK_CHECK_START_REL(L, offset_) StackChecker stackChecker_##L(L, StackChecker::Relative{ offset_ }, __FILE__, __LINE__)
+#define STACK_CHECK_START_ABS(L, offset_) StackChecker stackChecker_##L(L, StackChecker::Absolute{ offset_ }, __FILE__, __LINE__)
+#define STACK_CHECK_RESET_REL(L, offset_) stackChecker_##L = StackChecker{L, StackChecker::Relative{ offset_ }, __FILE__, __LINE__}
+#define STACK_CHECK_RESET_ABS(L, offset_) stackChecker_##L = StackChecker{L, StackChecker::Absolute{ offset_ }, __FILE__, __LINE__}
+#define STACK_CHECK(L, offset_) stackChecker_##L.check(offset_, __FILE__, __LINE__)
 
 #endif // NDEBUG
 
 #define ASSERT_L(c) _ASSERT_L(L,c)
 
-inline void STACK_GROW(lua_State * L, int n_)
+inline void STACK_GROW(lua_State* L, int n_)
 {
     if (!lua_checkstack(L, n_))
-        luaL_error(L, "Cannot grow stack!");
+    {
+        luaL_error(L, "Cannot grow stack!"); // doesn't return
+    }
 }
 
-// non-string keyed registry access
-#define REGISTRY_SET( L, key_, value_) \
-{ \
-    push_unique_key( L, key_); \
-    value_; \
-    lua_rawset( L, LUA_REGISTRYINDEX); \
+#define LUAG_FUNC(func_name) [[nodiscard]] int LG_##func_name(lua_State* L)
+
+// #################################################################################################
+
+// a small helper to extract a full userdata pointer from the stack in a safe way
+template<typename T>
+[[nodiscard]] T* lua_tofulluserdata(lua_State* L, int index_)
+{
+    ASSERT_L(lua_isnil(L, index_) || lua_type(L, index_) == LUA_TUSERDATA);
+    return static_cast<T*>(lua_touserdata(L, index_));
 }
 
-#define REGISTRY_GET( L, key_) \
-{ \
-    push_unique_key( L, key_); \
-    lua_rawget( L, LUA_REGISTRYINDEX); \
+template<typename T>
+[[nodiscard]] auto lua_tolightuserdata(lua_State* L, int index_)
+{
+    ASSERT_L(lua_isnil(L, index_) || lua_islightuserdata(L, index_));
+    if constexpr (std::is_pointer_v<T>)
+    {
+        return static_cast<T>(lua_touserdata(L, index_));
+    }
+    else
+    {
+        return static_cast<T*>(lua_touserdata(L, index_));
+    }
+}
+
+template <typename T>
+[[nodiscard]] T* lua_newuserdatauv(lua_State* L, int nuvalue_)
+{
+    return static_cast<T*>(lua_newuserdatauv(L, sizeof(T), nuvalue_));
+}
+
+// #################################################################################################
+
+// use this instead of Lua's lua_error if possible
+[[noreturn]] static inline void raise_lua_error(lua_State* L)
+{
+    std::ignore = lua_error(L); // doesn't return
+    assert(false); // we should never get here, but i'm paranoid
 }
 
-#define LUAG_FUNC( func_name) int LG_##func_name( lua_State* L)
+using lua_Duration = std::chrono::template duration<lua_Number>;
+
+// #################################################################################################
+
+// A unique type generator
+template <typename T, auto = []{}>
+struct Unique
+{
+    T m_val;
+    constexpr Unique() = default;
+    constexpr operator T() const { return m_val; }
+    constexpr explicit Unique(T b_) : m_val{ b_ } {}
+};
+
+// #################################################################################################
 
-#endif // MACROS_AND_UTILS_H
+using Source = Unique<lua_State*>;
+using Dest = Unique<lua_State*>;
\ No newline at end of file
diff --git a/src/platform.h b/src/platform.h
index 2f71c07..b10f0ad 100644
--- a/src/platform.h
+++ b/src/platform.h
@@ -1,5 +1,4 @@
-#ifndef __LANES_PLATFORM_H__
-#define __LANES_PLATFORM_H__ 1
+#pragma once
 
 #ifdef _WIN32_WCE
   #define PLATFORM_POCKETPC
@@ -21,5 +20,3 @@
 #else
   #error "Unknown platform!"
 #endif
-
-#endif // __LANES_PLATFORM_H__
diff --git a/src/state.c b/src/state.cpp
index 32e5b47..4a5f995 100644
--- a/src/state.c
+++ b/src/state.cpp
@@ -1,5 +1,5 @@
 /*
-* STATE.C
+* STATE.CPP
 *
 * Lua tools to support Lanes.
 */
@@ -8,7 +8,7 @@
 ===============================================================================
 
 Copyright (C) 2002-10 Asko Kauppi <akauppi@gmail.com>
-2011-21 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
@@ -31,20 +31,11 @@ THE SOFTWARE.
 ===============================================================================
 */
 
-#include <stdio.h>
-#include <assert.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdlib.h>
-#if !defined(__APPLE__)
-#include <malloc.h>
-#endif // __APPLE__
-
-#include "compat.h"
-#include "macros_and_utils.h"
-#include "universe.h"
-#include "tools.h"
+#include "state.h"
+
 #include "lanes.h"
+#include "tools.h"
+#include "universe.h"
 
 // ################################################################################################
 
@@ -58,7 +49,7 @@ THE SOFTWARE.
 //
 // Upvalues: [1]: original 'require' function
 //
-static int luaG_new_require( lua_State* L)
+[[nodiscard]] static int luaG_new_require(lua_State* L)
 {
     int rc;
     int const args = lua_gettop( L);                                    // args
@@ -72,62 +63,65 @@ static int luaG_new_require( lua_State* L)
 
     // Using 'lua_pcall()' to catch errors; otherwise a failing 'require' would
     // leave us locked, blocking any future 'require' calls from other lanes.
-    
-    MUTEX_LOCK( &U->require_cs);
+
+    U->require_cs.lock();
     // starting with Lua 5.4, require may return a second optional value, so we need LUA_MULTRET
     rc = lua_pcall( L, args, LUA_MULTRET, 0 /*errfunc*/ ); // err|result(s)
-    MUTEX_UNLOCK( &U->require_cs);
+    U->require_cs.unlock();
 
     // the required module (or an error message) is left on the stack as returned value by original require function
 
     if( rc != LUA_OK) // LUA_ERRRUN / LUA_ERRMEM ?
     {
-        return lua_error( L);
+        raise_lua_error(L);
     }
     // should be 1 for Lua <= 5.3, 1 or 2 starting with Lua 5.4
     return lua_gettop(L);                                           // result(s)
 }
 
+// #################################################################################################
+
 /*
 * Serialize calls to 'require', if it exists
 */
-void serialize_require( DEBUGSPEW_PARAM_COMMA( Universe* U) lua_State* L)
+void serialize_require(DEBUGSPEW_PARAM_COMMA( Universe* U) lua_State* L)
 {
-    STACK_GROW( L, 1);
-    STACK_CHECK( L, 0);
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "serializing require()\n" INDENT_END));
+    STACK_GROW(L, 1);
+    STACK_CHECK_START_REL(L, 0);
+    DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "serializing require()\n" INDENT_END));
 
     // Check 'require' is there and not already wrapped; if not, do nothing
     //
-    lua_getglobal( L, "require");
-    if( lua_isfunction( L, -1) && lua_tocfunction( L, -1) != luaG_new_require)
+    lua_getglobal(L, "require");
+    if (lua_isfunction(L, -1) && lua_tocfunction(L, -1) != luaG_new_require)
     {
         // [-1]: original 'require' function
-        lua_pushcclosure( L, luaG_new_require, 1 /*upvalues*/);
-        lua_setglobal( L, "require");
+        lua_pushcclosure(L, luaG_new_require, 1 /*upvalues*/);
+        lua_setglobal(L, "require");
     }
     else
     {
         // [-1]: nil
-        lua_pop( L, 1);
+        lua_pop(L, 1);
     }
 
-    STACK_END( L, 0);
+    STACK_CHECK(L, 0);
 }
 
 // ################################################################################################
 
 /*---=== luaG_newstate ===---*/
 
-static int require_lanes_core( lua_State* L)
+[[nodiscard]] static int require_lanes_core(lua_State* L)
 {
     // leaves a copy of 'lanes.core' module table on the stack
     luaL_requiref( L, "lanes.core", luaopen_lanes_core, 0);
     return 1;
 }
 
+// #################################################################################################
 
-static const luaL_Reg libs[] =
+static luaL_Reg const libs[] =
 {
     { LUA_LOADLIBNAME, luaopen_package},
     { LUA_TABLIBNAME, luaopen_table},
@@ -146,7 +140,7 @@ static const luaL_Reg libs[] =
 #endif
     { LUA_COLIBNAME, luaopen_coroutine}, // Lua 5.2: coroutine is no longer a part of base!
 #else // LUA_VERSION_NUM
-    { LUA_COLIBNAME, NULL},              // Lua 5.1: part of base package
+    { LUA_COLIBNAME, nullptr }, // Lua 5.1: part of base package
 #endif // LUA_VERSION_NUM
     { LUA_DBLIBNAME, luaopen_debug},
 #if LUAJIT_FLAVOR() != 0 // building against LuaJIT headers, add some LuaJIT-specific libs
@@ -156,14 +150,16 @@ static const luaL_Reg libs[] =
     { LUA_FFILIBNAME, luaopen_ffi},
 #endif // LUAJIT_FLAVOR()
 
-{ LUA_DBLIBNAME, luaopen_debug},
-{ "lanes.core", require_lanes_core}, // So that we can open it like any base library (possible since we have access to the init function)
+    { LUA_DBLIBNAME, luaopen_debug},
+    { "lanes.core", require_lanes_core}, // So that we can open it like any base library (possible since we have access to the init function)
                                                                          //
-{ "base", NULL},                     // ignore "base" (already acquired it)
-{ NULL, NULL }
+    { "base", nullptr }, // ignore "base" (already acquired it)
+    { nullptr, nullptr }
 };
 
-static void open1lib( DEBUGSPEW_PARAM_COMMA( Universe* U) lua_State* L, char const* name_, size_t len_)
+// #################################################################################################
+
+static void open1lib(DEBUGSPEW_PARAM_COMMA(Universe* U) lua_State* L, char const* name_, size_t len_)
 {
     int i;
     for( i = 0; libs[i].name; ++ i)
@@ -172,70 +168,73 @@ static void open1lib( DEBUGSPEW_PARAM_COMMA( Universe* U) lua_State* L, char con
         {
             lua_CFunction libfunc = libs[i].func;
             name_ = libs[i].name; // note that the provided name_ doesn't necessarily ends with '\0', hence len_
-            if( libfunc != NULL)
+            if (libfunc != nullptr)
             {
-                bool_t const isLanesCore = (libfunc == require_lanes_core) ? TRUE : FALSE; // don't want to create a global for "lanes.core"
+                bool const isLanesCore{ libfunc == require_lanes_core }; // don't want to create a global for "lanes.core"
                 DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "opening %.*s library\n" INDENT_END, (int) len_, name_));
-                STACK_CHECK( L, 0);
+                STACK_CHECK_START_REL(L, 0);
                 // open the library as if through require(), and create a global as well if necessary (the library table is left on the stack)
                 luaL_requiref( L, name_, libfunc, !isLanesCore);
                 // lanes.core doesn't declare a global, so scan it here and now
-                if( isLanesCore == TRUE)
+                if( isLanesCore == true)
                 {
                     populate_func_lookup_table( L, -1, name_);
                 }
                 lua_pop( L, 1);
-                STACK_END( L, 0);
+                STACK_CHECK( L, 0);
             }
             break;
         }
     }
 }
 
+// #################################################################################################
 
 // just like lua_xmove, args are (from, to)
-static void copy_one_time_settings( Universe* U, lua_State* L, lua_State* L2)
+static void copy_one_time_settings(Universe* U, Source L, Dest L2)
 {
-    STACK_GROW( L, 2);
-    STACK_CHECK( L, 0);
-    STACK_CHECK( L2, 0);
+    STACK_GROW(L, 2);
+    STACK_CHECK_START_REL(L, 0);
+    STACK_CHECK_START_REL(L2, 0);
 
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "copy_one_time_settings()\n" INDENT_END));
-    DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
+    DEBUGSPEW_CODE(fprintf( stderr, INDENT_BEGIN "copy_one_time_settings()\n" INDENT_END));
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
 
-    REGISTRY_GET( L, CONFIG_REGKEY);                                               // config
-                                                                                                                                                                 // copy settings from from source to destination registry
-    if( luaG_inter_move( U, L, L2, 1, eLM_LaneBody) != eICR_Success)               //                           // config
+    CONFIG_REGKEY.pushValue(L);                                                         // config
+    // copy settings from from source to destination registry
+    if (luaG_inter_move(U, L, L2, 1, LookupMode::LaneBody) != InterCopyResult::Success) //                           // config
     {
-        (void) luaL_error( L, "failed to copy settings when loading lanes.core");
+        luaL_error( L, "failed to copy settings when loading lanes.core"); // doesn't return
     }
     // set L2:_R[CONFIG_REGKEY] = settings
-    REGISTRY_SET( L2, CONFIG_REGKEY, lua_insert( L2, -2));                                                      //
-    STACK_END( L2, 0);
-    STACK_END( L, 0);
-    DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
+    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.fetch_sub(1, std::memory_order_relaxed));
 }
 
+// #################################################################################################
+
 void initialize_on_state_create( Universe* U, lua_State* L)
 {
-    STACK_CHECK( L, 0);
-    lua_getfield( L, -1, "on_state_create");              // settings on_state_create|nil
-    if( !lua_isnil( L, -1))
+    STACK_CHECK_START_REL(L, 1);                             // settings
+    lua_getfield(L, -1, "on_state_create");                  // settings on_state_create|nil
+    if( !lua_isnil(L, -1))
     {
         // store C function pointer in an internal variable
-        U->on_state_create_func = lua_tocfunction( L, -1);  // settings on_state_create
-        if( U->on_state_create_func != NULL)
+        U->on_state_create_func = lua_tocfunction(L, -1);    // settings on_state_create
+        if (U->on_state_create_func != nullptr)
         {
             // make sure the function doesn't have upvalues
-            char const* upname = lua_getupvalue( L, -1, 1);   // settings on_state_create upval?
-            if( upname != NULL) // should be "" for C functions with upvalues if any
+            char const* upname = lua_getupvalue(L, -1, 1);   // settings on_state_create upval?
+            if (upname != nullptr) // should be "" for C functions with upvalues if any
             {
-                (void) luaL_error( L, "on_state_create shouldn't have upvalues");
+                (void) luaL_error(L, "on_state_create shouldn't have upvalues");
             }
             // remove this C function from the config table so that it doesn't cause problems
             // when we transfer the config table in newly created Lua states
-            lua_pushnil( L);                                  // settings on_state_create nil
-            lua_setfield( L, -3, "on_state_create");          // settings on_state_create
+            lua_pushnil(L);                                  // settings on_state_create nil
+            lua_setfield(L, -3, "on_state_create");          // settings on_state_create
         }
         else
         {
@@ -243,113 +242,120 @@ void initialize_on_state_create( Universe* U, lua_State* L)
             U->on_state_create_func = (lua_CFunction) initialize_on_state_create;
         }
     }
-    lua_pop( L, 1);                                       // settings
-    STACK_END( L, 0);
+    lua_pop(L, 1);                                           // settings
+    STACK_CHECK(L, 1);
 }
 
-lua_State* create_state( Universe* U, lua_State* from_)
+// #################################################################################################
+
+lua_State* create_state(Universe* U, lua_State* from_)
 {
     lua_State* L;
 #if LUAJIT_FLAVOR() == 64
     // for some reason, LuaJIT 64 bits does not support creating a state with lua_newstate...
     L = luaL_newstate();
 #else // LUAJIT_FLAVOR() == 64
-    if( U->provide_allocator != NULL) // we have a function we can call to obtain an allocator
+    if (U->provide_allocator != nullptr) // we have a function we can call to obtain an allocator
     {
         lua_pushcclosure( from_, U->provide_allocator, 0);
         lua_call( from_, 0, 1);
         {
-            AllocatorDefinition* const def = lua_touserdata( from_, -1);
-            L = lua_newstate( def->allocF, def->allocUD);
+            AllocatorDefinition* const def{ lua_tofulluserdata<AllocatorDefinition>(from_, -1) };
+            L = lua_newstate( def->m_allocF, def->m_allocUD);
         }
         lua_pop( from_, 1);
     }
     else
     {
         // reuse the allocator provided when the master state was created
-        L = lua_newstate( U->protected_allocator.definition.allocF, U->protected_allocator.definition.allocUD);
+        L = lua_newstate(U->protected_allocator.m_allocF, U->protected_allocator.m_allocUD);
     }
 #endif // LUAJIT_FLAVOR() == 64
 
-    if( L == NULL)
+    if (L == nullptr)
     {
-        (void) luaL_error( from_, "luaG_newstate() failed while creating state; out of memory");
+        luaL_error(from_, "luaG_newstate() failed while creating state; out of memory"); // doesn't return
     }
     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 != NULL)
+    if (U->on_state_create_func != nullptr)
     {
-        STACK_CHECK( 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)
+        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)
         {
             // 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_ != LookupMode::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;
             }
-            REGISTRY_GET( L, CONFIG_REGKEY);                                            // {}
-            STACK_MID( 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_MID( 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_END( L, 0);
+        STACK_CHECK(L, 0);
     }
 }
 
+// #################################################################################################
+
 /*
 * Like 'luaL_openlibs()' but allows the set of libraries be selected
 *
-*   NULL    no libraries, not even base
+*   nullptr    no libraries, not even base
 *   ""      base library only
 *   "io,string"     named libraries
 *   "*"     all libraries
 *
-* Base ("unpack", "print" etc.) is always added, unless 'libs' is NULL.
+* Base ("unpack", "print" etc.) is always added, unless 'libs' is nullptr.
 *
 * *NOT* called for keeper states!
 *
 */
-lua_State* luaG_newstate( Universe* U, lua_State* from_, char const* libs_)
+lua_State* luaG_newstate(Universe* U, Source from_, char const* libs_)
 {
-    lua_State* L = create_state( U, from_);
+    Dest const L{ create_state(U, from_) };
 
-    STACK_GROW( L, 2);
-    STACK_CHECK_ABS( L, 0);
+    STACK_GROW(L, 2);
+    STACK_CHECK_START_ABS(L, 0);
 
     // copy the universe as a light userdata (only the master state holds the full userdata)
     // that way, if Lanes is required in this new state, we'll know we are part of this universe
     universe_store( L, U);
-    STACK_MID( L, 0);
+    STACK_CHECK(L, 0);
 
     // we'll need this every time we transfer some C function from/to this state
-    REGISTRY_SET( L, LOOKUP_REGKEY, lua_newtable( L));
-    STACK_MID( L, 0);
+    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
-    if( libs_ == NULL && U->on_state_create_func == NULL)
+    if (libs_ == nullptr && U->on_state_create_func == nullptr)
     {
-        DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "luaG_newstate(NULL)\n" INDENT_END));
+        DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "luaG_newstate(nullptr)\n" INDENT_END));
         return L;
     }
 
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "luaG_newstate()\n" INDENT_END));
-    DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
+    DEBUGSPEW_CODE(fprintf( stderr, INDENT_BEGIN "luaG_newstate()\n" INDENT_END));
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
 
     // copy settings (for example because it may contain a Lua on_state_create function)
     copy_one_time_settings( U, from_, L);
@@ -360,7 +366,7 @@ lua_State* luaG_newstate( Universe* U, lua_State* from_, char const* libs_)
 
     // Anything causes 'base' to be taken in
     //
-    if( libs_ != NULL)
+    if (libs_ != nullptr)
     {
         // special "*" case (mainly to help with LuaJIT compatibility)
         // as we are called from luaopen_lanes_core() already, and that would deadlock
@@ -370,7 +376,7 @@ lua_State* luaG_newstate( Universe* U, lua_State* from_, char const* libs_)
             luaL_openlibs( L);
             // don't forget lanes.core for regular lane states
             open1lib( DEBUGSPEW_PARAM_COMMA( U) L, "lanes.core", 10);
-            libs_ = NULL; // done with libs
+            libs_ = nullptr; // done with libs
         }
         else
         {
@@ -386,7 +392,7 @@ lua_State* luaG_newstate( Universe* U, lua_State* from_, char const* libs_)
 #endif // LUA_VERSION_NUM
         }
     }
-    STACK_END( L, 0);
+    STACK_CHECK(L, 0);
 
     // scan all libraries, open them one by one
     if( libs_)
@@ -412,31 +418,32 @@ lua_State* luaG_newstate( Universe* U, lua_State* from_, char const* libs_)
 
     // call this after the base libraries are loaded and GC is restarted
     // will raise an error in from_ in case of problem
-    call_on_state_create( U, L, from_, eLM_LaneBody);
+    call_on_state_create(U, L, from_, LookupMode::LaneBody);
 
-    STACK_CHECK( L, 0);
+    STACK_CHECK(L, 0);
     // after all this, register everything we find in our name<->function database
     lua_pushglobaltable( L); // Lua 5.2 no longer has LUA_GLOBALSINDEX: we must push globals table on the stack
-    populate_func_lookup_table( L, -1, NULL);
+    STACK_CHECK(L, 1);
+    populate_func_lookup_table(L, -1, nullptr);
 
 #if 0 && USE_DEBUG_SPEW()
     // dump the lookup database contents
-    lua_getfield( L, LUA_REGISTRYINDEX, LOOKUP_REGKEY);                       // {}
-    lua_pushnil( L);                                                          // {} nil
-    while( lua_next( L, -2))                                                  // {} k v
+    lua_getfield(L, LUA_REGISTRYINDEX, LOOKUP_REGKEY);                                                    // {}
+    lua_pushnil(L);                                                                                       // {} nil
+    while (lua_next(L, -2))                                                                               // {} k v
     {
-        lua_getglobal( L, "print");                                             // {} k v print
-        lua_pushlstring( L, debugspew_indent, U->debugspew_indent_depth);       // {} k v print " "
-        lua_pushvalue( L, -4);                                                  // {} k v print " " k
-        lua_pushvalue( L, -4);                                                  // {} k v print " " k v
-        lua_call( L, 3, 0);                                                     // {} k v
-        lua_pop( L, 1);                                                         // {} k
+        lua_getglobal(L, "print");                                                                        // {} k v print
+        lua_pushlstring(L, debugspew_indent, U->debugspew_indent_depth.load(std::memory_order_relaxed));  // {} k v print " "
+        lua_pushvalue(L, -4);                                                                             // {} k v print " " k
+        lua_pushvalue(L, -4);                                                                             // {} k v print " " k v
+        lua_call(L, 3, 0);                                                                                // {} k v
+        lua_pop(L, 1);                                                                                    // {} k
     }
-    lua_pop( L, 1);                                                           // {}
+    lua_pop(L, 1);                                                                                        // {}
 #endif // USE_DEBUG_SPEW()
 
-    lua_pop( L, 1);
-    STACK_END( L, 0);
-    DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
+    lua_pop(L, 1);
+    STACK_CHECK(L, 0);
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
     return L;
 }
diff --git a/src/state.h b/src/state.h
index e844405..e1c311a 100644
--- a/src/state.h
+++ b/src/state.h
@@ -1,22 +1,19 @@
-#ifndef __LANES_STATE_H__
-#define __LANES_STATE_H__
-
-//#include "lauxlib.h"
-#include "threading.h"
-#include "deep.h"
+#pragma once
 
 #include "macros_and_utils.h"
 
-void serialize_require( DEBUGSPEW_PARAM_COMMA( Universe* U) lua_State *L);
+// forwards
+enum class LookupMode;
+class Universe;
+
+void serialize_require(DEBUGSPEW_PARAM_COMMA(Universe* U) lua_State* L);
 
 // ################################################################################################
 
-lua_State* create_state( Universe* U, lua_State* from_);
-lua_State* luaG_newstate( Universe* U, lua_State* _from, char const* libs);
+[[nodiscard]] lua_State* create_state(Universe* U, lua_State* from_);
+[[nodiscard]] lua_State* luaG_newstate(Universe* U, Source _from, char const* libs);
 
 // ################################################################################################
 
-void initialize_on_state_create( Universe* U, lua_State* L);
-void call_on_state_create( Universe* U, lua_State* L, lua_State* from_, LookupMode mode_);
-
-#endif // __LANES_STATE_H__
+void initialize_on_state_create(Universe* U, lua_State* L);
+void call_on_state_create(Universe* U, lua_State* L, lua_State* from_, LookupMode mode_);
diff --git a/src/threading.c b/src/threading.c
deleted file mode 100644
index 2464d03..0000000
--- a/src/threading.c
+++ /dev/null
@@ -1,1041 +0,0 @@
-/*
- * THREADING.C                        Copyright (c) 2007-08, Asko Kauppi
- *                                    Copyright (C) 2009-19, Benoit Germain
- *
- * Lua Lanes OS threading specific code.
- *
- * References:
- *      <http://www.cse.wustl.edu/~schmidt/win32-cv-1.html>
-*/
-
-/*
-===============================================================================
-
-Copyright (C) 2007-10 Asko Kauppi <akauppi@gmail.com>
-Copyright (C) 2009-14, 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
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
-===============================================================================
-*/
-#if defined(__linux__)
-
-# ifndef _GNU_SOURCE // definition by the makefile can cause a redefinition error
-# define _GNU_SOURCE // must be defined before any include
-# endif // _GNU_SOURCE
-
-# ifdef __ANDROID__
-#  include <android/log.h>
-#  define LOG_TAG "LuaLanes"
-# endif // __ANDROID__
-
-#endif // __linux__
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <assert.h>
-#include <errno.h>
-#include <math.h>
-
-#include "threading.h"
-
-#if !defined( PLATFORM_XBOX) && !defined( PLATFORM_WIN32) && !defined( PLATFORM_POCKETPC)
-# include <sys/time.h>
-#endif // non-WIN32 timing
-
-
-#if defined(PLATFORM_LINUX) || defined(PLATFORM_CYGWIN)
-# include <sys/types.h>
-# include <unistd.h>
-#endif
-
-/* Linux needs to check, whether it's been run as root
-*/
-#ifdef PLATFORM_LINUX
-  volatile bool_t sudo;
-#endif
-
-#ifdef PLATFORM_OSX
-# include "threading_osx.h"
-#endif
-
-/* Linux with older glibc (such as Debian) don't have pthread_setname_np, but have prctl
-*/
-#if defined PLATFORM_LINUX
-#if defined __GNU_LIBRARY__ && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 12
-#define LINUX_USE_PTHREAD_SETNAME_NP 1
-#else // glibc without pthread_setname_np
-#include <sys/prctl.h>
-#define LINUX_USE_PTHREAD_SETNAME_NP 0
-#endif // glibc without pthread_setname_np
-#endif // PLATFORM_LINUX
-
-#ifdef _MSC_VER
-// ".. selected for automatic inline expansion" (/O2 option)
-# pragma warning( disable : 4711 )
-// ".. type cast from function pointer ... to data pointer"
-# pragma warning( disable : 4054 )
-#endif
-
-//#define THREAD_CREATE_RETRIES_MAX 20
-    // loops (maybe retry forever?)
-
-/* 
-* FAIL is for unexpected API return values - essentially programming 
-* error in _this_ code. 
-*/
-#if defined( PLATFORM_XBOX) || defined( PLATFORM_WIN32) || defined( PLATFORM_POCKETPC)
-static void FAIL( char const* funcname, int rc)
-{
-#if defined( PLATFORM_XBOX)
-    fprintf( stderr, "%s() failed! (%d)\n", funcname, rc );
-#else // PLATFORM_XBOX
-    char buf[256];
-    FormatMessageA( FORMAT_MESSAGE_FROM_SYSTEM, NULL, rc, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, 256, NULL);
-    fprintf( stderr, "%s() failed! [GetLastError() -> %d] '%s'", funcname, rc, buf);
-#endif // PLATFORM_XBOX
-#ifdef _MSC_VER
-    __debugbreak(); // give a chance to the debugger!
-#endif // _MSC_VER
-    abort();
-}
-#endif // win32 build
-
-
-/*
-* Returns millisecond timing (in seconds) for the current time.
-*
-* Note: This function should be called once in single-threaded mode in Win32,
-*       to get it initialized.
-*/
-time_d now_secs(void) {
-
-#if defined( PLATFORM_XBOX) || defined( PLATFORM_WIN32) || defined( PLATFORM_POCKETPC)
-    /*
-    * Windows FILETIME values are "100-nanosecond intervals since 
-    * January 1, 1601 (UTC)" (MSDN). Well, we'd want Unix Epoch as
-    * the offset and it seems, so would they:
-    *
-    * <http://msdn.microsoft.com/en-us/library/ms724928(VS.85).aspx>
-    */
-    SYSTEMTIME st;
-    FILETIME ft;
-    ULARGE_INTEGER uli;
-    static ULARGE_INTEGER uli_epoch;   // Jan 1st 1970 0:0:0
-
-    if (uli_epoch.HighPart==0) {
-        st.wYear= 1970;
-        st.wMonth= 1;   // Jan
-        st.wDay= 1;
-        st.wHour= st.wMinute= st.wSecond= st.wMilliseconds= 0;
-
-        if (!SystemTimeToFileTime( &st, &ft ))
-            FAIL( "SystemTimeToFileTime", GetLastError() );
-
-        uli_epoch.LowPart= ft.dwLowDateTime;
-        uli_epoch.HighPart= ft.dwHighDateTime;
-    }
-
-    GetSystemTime( &st );       // current system date/time in UTC
-    if (!SystemTimeToFileTime( &st, &ft ))
-        FAIL( "SystemTimeToFileTime", GetLastError() );
-
-    uli.LowPart= ft.dwLowDateTime;
-    uli.HighPart= ft.dwHighDateTime;
-
-    /* 'double' has less accuracy than 64-bit int, but if it were to degrade,
-     * it would do so gracefully. In practice, the integer accuracy is not
-     * of the 100ns class but just 1ms (Windows XP).
-     */
-# if 1
-    // >= 2.0.3 code
-    return (double) ((uli.QuadPart - uli_epoch.QuadPart)/10000) / 1000.0;
-# elif 0
-    // fix from Kriss Daniels, see: 
-    // <http://luaforge.net/forum/forum.php?thread_id=22704&forum_id=1781>
-    //
-    // "seem to be getting negative numbers from the old version, probably number
-    // conversion clipping, this fixes it and maintains ms resolution"
-    //
-    // This was a bad fix, and caused timer test 5 sec timers to disappear.
-    // --AKa 25-Jan-2009
-    //
-    return ((double)((signed)((uli.QuadPart/10000) - (uli_epoch.QuadPart/10000)))) / 1000.0;
-# else
-    // <= 2.0.2 code
-    return (double)(uli.QuadPart - uli_epoch.QuadPart) / 10000000.0;
-# endif
-#else // !(defined( PLATFORM_WIN32) || defined( PLATFORM_POCKETPC))
-    struct timeval tv;
-        // {
-        //   time_t       tv_sec;   /* seconds since Jan. 1, 1970 */
-        //   suseconds_t  tv_usec;  /* and microseconds */
-        // };
-
-    int rc= gettimeofday( &tv, NULL /*time zone not used any more (in Linux)*/ );
-    assert( rc==0 );
-
-    return ((double)tv.tv_sec) + ((tv.tv_usec)/1000) / 1000.0;
-#endif // !(defined( PLATFORM_WIN32) || defined( PLATFORM_POCKETPC))
-}
-
-
-/*
-*/
-time_d SIGNAL_TIMEOUT_PREPARE( double secs ) {
-    if (secs<=0.0) return secs;
-    else return now_secs() + secs;
-}
-
-
-#if THREADAPI == THREADAPI_PTHREAD
-/*
-* Prepare 'abs_secs' kind of timeout to 'timespec' format
-*/
-static void prepare_timeout( struct timespec *ts, time_d abs_secs ) {
-    assert(ts);
-    assert( abs_secs >= 0.0 );
-
-    if (abs_secs==0.0)
-        abs_secs= now_secs();
-
-    ts->tv_sec= (time_t) floor( abs_secs );
-    ts->tv_nsec= ((long)((abs_secs - ts->tv_sec) * 1000.0 +0.5)) * 1000000UL;   // 1ms = 1000000ns
-    if (ts->tv_nsec == 1000000000UL)
-    {
-        ts->tv_nsec = 0;
-        ts->tv_sec = ts->tv_sec + 1;
-    }
-}
-#endif // THREADAPI == THREADAPI_PTHREAD
-
-
-/*---=== Threading ===---*/
-
-//---
-// It may be meaningful to explicitly limit the new threads' C stack size.
-// We should know how much Lua needs in the C stack, all Lua side allocations
-// are done in heap so they don't count.
-//
-// Consequence of _not_ limiting the stack is running out of virtual memory
-// with 1000-5000 threads on 32-bit systems.
-//
-// Note: using external C modules may be affected by the stack size check.
-//       if having problems, set back to '0' (default stack size of the system).
-// 
-// Win32:       64K (?)
-// Win64:       xxx
-//
-// Linux x86:   2MB     Ubuntu 7.04 via 'pthread_getstacksize()'
-// Linux x64:   xxx
-// Linux ARM:   xxx
-//
-// OS X 10.4.9: 512K    <http://developer.apple.com/qa/qa2005/qa1419.html>
-//                      valid values N * 4KB
-//
-#ifndef _THREAD_STACK_SIZE
-# if defined( PLATFORM_XBOX) || defined( PLATFORM_WIN32) || defined( PLATFORM_POCKETPC) || defined( PLATFORM_CYGWIN)
-#  define _THREAD_STACK_SIZE 0
-      // Win32: does it work with less?
-# elif (defined PLATFORM_OSX)
-#  define _THREAD_STACK_SIZE (524288/2)   // 262144
-      // OS X: "make test" works on 65536 and even below
-      //       "make perftest" works on >= 4*65536 == 262144 (not 3*65536)
-# elif (defined PLATFORM_LINUX) && (defined __i386)
-#  define _THREAD_STACK_SIZE (2097152/16)  // 131072
-      // Linux x86 (Ubuntu 7.04): "make perftest" works on /16 (not on /32)
-# elif (defined PLATFORM_BSD) && (defined __i386)
-#  define _THREAD_STACK_SIZE (1048576/8)  // 131072
-      // FreeBSD 6.2 SMP i386: ("gmake perftest" works on /8 (not on /16)
-# endif
-#endif
-
-#if THREADAPI == THREADAPI_WINDOWS
-
-#if _WIN32_WINNT < 0x0600 // CONDITION_VARIABLE aren't available
-  //
-  void MUTEX_INIT( MUTEX_T *ref ) {
-     *ref= CreateMutex( NULL /*security attr*/, FALSE /*not locked*/, NULL );
-     if (!ref) FAIL( "CreateMutex", GetLastError() );
-  }
-  void MUTEX_FREE( MUTEX_T *ref ) {
-     if (!CloseHandle(*ref)) FAIL( "CloseHandle (mutex)", GetLastError() );
-     *ref= NULL;
-  }
-    void MUTEX_LOCK( MUTEX_T *ref )
-    {
-        DWORD rc = WaitForSingleObject( *ref, INFINITE);
-        // ERROR_WAIT_NO_CHILDREN means a thread was killed (lane terminated because of error raised during a linda transfer for example) while having grabbed this mutex
-        // this is not a big problem as we will grab it just the same, so ignore this particular error
-        if( rc != 0 && rc != ERROR_WAIT_NO_CHILDREN)
-            FAIL( "WaitForSingleObject", (rc == WAIT_FAILED) ? GetLastError() : rc);
-    }
-  void MUTEX_UNLOCK( MUTEX_T *ref ) {
-    if (!ReleaseMutex(*ref))
-        FAIL( "ReleaseMutex", GetLastError() );
-  }
-#endif // CONDITION_VARIABLE aren't available
-
-static int const gs_prio_remap[] =
-{
-    THREAD_PRIORITY_IDLE,
-    THREAD_PRIORITY_LOWEST,
-    THREAD_PRIORITY_BELOW_NORMAL,
-    THREAD_PRIORITY_NORMAL,
-    THREAD_PRIORITY_ABOVE_NORMAL,
-    THREAD_PRIORITY_HIGHEST,
-    THREAD_PRIORITY_TIME_CRITICAL
-};
-
-/* MSDN: "If you would like to use the CRT in ThreadProc, use the
-_beginthreadex function instead (of CreateThread)."
-MSDN: "you can create at most 2028 threads"
-*/
-// Note: Visual C++ requires '__stdcall' where it is
-void THREAD_CREATE( THREAD_T* ref, THREAD_RETURN_T (__stdcall *func)( void*), void* data, int prio /* -3..+3 */)
-{
-    HANDLE h = (HANDLE) _beginthreadex( NULL, // security
-        _THREAD_STACK_SIZE,
-        func,
-        data,
-        0,    // flags (0/CREATE_SUSPENDED)
-        NULL  // thread id (not used)
-    );
-
-    if( h == NULL) // _beginthreadex returns 0L on failure instead of -1L (like _beginthread)
-    {
-        FAIL( "CreateThread", GetLastError());
-    }
-
-    if (prio != THREAD_PRIO_DEFAULT)
-    {
-        if (!SetThreadPriority( h, gs_prio_remap[prio + 3]))
-        {
-            FAIL( "SetThreadPriority", GetLastError());
-        }
-    }
-
-    *ref = h;
-}
-
-
-void THREAD_SET_PRIORITY( int prio)
-{
-    // prio range [-3,+3] was checked by the caller
-    if (!SetThreadPriority( GetCurrentThread(), gs_prio_remap[prio + 3]))
-    {
-        FAIL( "THREAD_SET_PRIORITY", GetLastError());
-    }
-}
-
-void THREAD_SET_AFFINITY( unsigned int aff)
-{
-    if( !SetThreadAffinityMask( GetCurrentThread(), aff))
-    {
-        FAIL( "THREAD_SET_AFFINITY", GetLastError());
-    }
-}
-
-bool_t THREAD_WAIT_IMPL( THREAD_T *ref, double secs)
-{
-    DWORD ms = (secs<0.0) ? INFINITE : (DWORD)((secs*1000.0)+0.5);
-
-    DWORD rc= WaitForSingleObject( *ref, ms /*timeout*/ );
-        //
-        // (WAIT_ABANDONED)
-        // WAIT_OBJECT_0    success (0)
-        // WAIT_TIMEOUT
-        // WAIT_FAILED      more info via GetLastError()
-
-    if (rc == WAIT_TIMEOUT) return FALSE;
-    if( rc !=0) FAIL( "WaitForSingleObject", rc==WAIT_FAILED ? GetLastError() : rc);
-    *ref= NULL;     // thread no longer usable
-    return TRUE;
-  }
-  //
-    void THREAD_KILL( THREAD_T *ref )
-    {
-        // nonexistent on Xbox360, simply disable until a better solution is found
-        #if !defined( PLATFORM_XBOX)
-        // in theory no-one should call this as it is very dangerous (memory and mutex leaks, no notification of DLLs, etc.)
-        if (!TerminateThread( *ref, 0 )) FAIL("TerminateThread", GetLastError());
-        #endif // PLATFORM_XBOX
-        *ref= NULL;
-    }
-
-    void THREAD_MAKE_ASYNCH_CANCELLABLE() {} // nothing to do for windows threads, we can cancel them anytime we want
-
-#if !defined __GNUC__
-    //see http://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx
-    #define MS_VC_EXCEPTION 0x406D1388
-    #pragma pack(push,8)
-        typedef struct tagTHREADNAME_INFO
-        {
-            DWORD dwType; // Must be 0x1000.
-            LPCSTR szName; // Pointer to name (in user addr space).
-            DWORD dwThreadID; // Thread ID (-1=caller thread).
-            DWORD dwFlags; // Reserved for future use, must be zero.
-        } THREADNAME_INFO;
-    #pragma pack(pop)
-#endif // !__GNUC__
-
-    void THREAD_SETNAME( char const* _name)
-    {
-#if !defined __GNUC__
-        THREADNAME_INFO info;
-        info.dwType = 0x1000;
-        info.szName = _name;
-        info.dwThreadID = GetCurrentThreadId();
-        info.dwFlags = 0;
-
-        __try
-        {
-            RaiseException( MS_VC_EXCEPTION, 0, sizeof(info)/sizeof(ULONG_PTR), (ULONG_PTR*)&info );
-        }
-        __except(EXCEPTION_EXECUTE_HANDLER)
-        {
-        }
-#endif // !__GNUC__
-    }
-
-#if _WIN32_WINNT < 0x0600 // CONDITION_VARIABLE aren't available
-
-    void SIGNAL_INIT( SIGNAL_T* ref)
-    {
-        InitializeCriticalSection( &ref->signalCS);
-        InitializeCriticalSection( &ref->countCS);
-        if( 0 == (ref->waitEvent = CreateEvent( 0, TRUE, FALSE, 0)))     // manual-reset
-            FAIL( "CreateEvent", GetLastError());
-        if( 0 == (ref->waitDoneEvent = CreateEvent( 0, FALSE, FALSE, 0)))    // auto-reset
-            FAIL( "CreateEvent", GetLastError());
-        ref->waitersCount = 0;
-    }
-
-    void SIGNAL_FREE( SIGNAL_T* ref)
-    {
-        CloseHandle( ref->waitDoneEvent);
-        CloseHandle( ref->waitEvent);
-        DeleteCriticalSection( &ref->countCS);
-        DeleteCriticalSection( &ref->signalCS);
-    }
-
-    bool_t SIGNAL_WAIT( SIGNAL_T* ref, MUTEX_T* mu_ref, time_d abs_secs)
-    {
-        DWORD errc;
-        DWORD ms;
-
-        if( abs_secs < 0.0)
-            ms = INFINITE;
-        else if( abs_secs == 0.0)
-            ms = 0;
-        else 
-        {
-            time_d msd = (abs_secs - now_secs()) * 1000.0 + 0.5;
-            // If the time already passed, still try once (ms==0). A short timeout
-            // may have turned negative or 0 because of the two time samples done.
-            ms = msd <= 0.0 ? 0 : (DWORD)msd;
-        }
-
-        EnterCriticalSection( &ref->signalCS);
-        EnterCriticalSection( &ref->countCS);
-        ++ ref->waitersCount;
-        LeaveCriticalSection( &ref->countCS);
-        LeaveCriticalSection( &ref->signalCS);
-
-        errc = SignalObjectAndWait( *mu_ref, ref->waitEvent, ms, FALSE);
-
-        EnterCriticalSection( &ref->countCS);
-        if( 0 == -- ref->waitersCount)
-        {
-            // we're the last one leaving...
-            ResetEvent( ref->waitEvent);
-            SetEvent( ref->waitDoneEvent);
-        }
-        LeaveCriticalSection( &ref->countCS);
-        MUTEX_LOCK( mu_ref);
-
-        switch( errc)
-        {
-            case WAIT_TIMEOUT:
-            return FALSE;
-            case WAIT_OBJECT_0:
-            return TRUE;
-        }
-
-        FAIL( "SignalObjectAndWait", GetLastError());
-        return FALSE;
-    }
-
-    void SIGNAL_ALL( SIGNAL_T* ref)
-    {
-        DWORD errc = WAIT_OBJECT_0;
-
-        EnterCriticalSection( &ref->signalCS);
-        EnterCriticalSection( &ref->countCS);
-
-        if( ref->waitersCount > 0)
-        {
-            ResetEvent( ref->waitDoneEvent);
-            SetEvent( ref->waitEvent);
-            LeaveCriticalSection( &ref->countCS);
-            errc = WaitForSingleObject( ref->waitDoneEvent, INFINITE);
-        }
-        else
-        {
-            LeaveCriticalSection( &ref->countCS);
-        }
-
-        LeaveCriticalSection( &ref->signalCS);
-
-        if( WAIT_OBJECT_0 != errc)
-            FAIL( "WaitForSingleObject", GetLastError());
-    }
-
-#else // CONDITION_VARIABLE are available, use them
-
-    //
-    void SIGNAL_INIT( SIGNAL_T *ref )
-    {
-        InitializeConditionVariable( ref);
-    }
-
-    void SIGNAL_FREE( SIGNAL_T *ref )
-    {
-        // nothing to do
-        (void)ref;
-    }
-
-    bool_t SIGNAL_WAIT( SIGNAL_T *ref, MUTEX_T *mu_ref, time_d abs_secs)
-    {
-        long ms;
-
-        if( abs_secs < 0.0)
-            ms = INFINITE;
-        else if( abs_secs == 0.0)
-            ms = 0;
-        else
-        {
-            ms = (long) ((abs_secs - now_secs())*1000.0 + 0.5);
-
-            // If the time already passed, still try once (ms==0). A short timeout
-            // may have turned negative or 0 because of the two time samples done.
-            //
-            if( ms < 0)
-                ms = 0;
-        }
-
-        if( !SleepConditionVariableCS( ref, mu_ref, ms))
-        {
-            if( GetLastError() == ERROR_TIMEOUT)
-            {
-                return FALSE;
-            }
-            else
-            {
-                FAIL( "SleepConditionVariableCS", GetLastError());
-            }
-        }
-        return TRUE;
-    }
-
-    void SIGNAL_ONE( SIGNAL_T *ref )
-    {
-        WakeConditionVariable( ref);
-    }
-
-    void SIGNAL_ALL( SIGNAL_T *ref )
-    {
-        WakeAllConditionVariable( ref);
-    }
-
-#endif // CONDITION_VARIABLE are available
-
-#else // THREADAPI == THREADAPI_PTHREAD
-  // PThread (Linux, OS X, ...)
-  //
-  // On OS X, user processes seem to be able to change priorities.
-  // On Linux, SCHED_RR and su privileges are required..  !-(
-  //
-  #include <errno.h>
-  #include <sched.h>
-
-#       if (defined(__MINGW32__) || defined(__MINGW64__)) && defined pthread_attr_setschedpolicy
-#       if pthread_attr_setschedpolicy( A, S) == ENOTSUP
-    // from the mingw-w64 team:
-    // Well, we support pthread_setschedparam by which you can specify
-    // threading-policy. Nevertheless, yes we lack this function. In
-    // general its implementation is pretty much trivial, as on Win32 target
-    // just SCHED_OTHER can be supported.
-    #undef pthread_attr_setschedpolicy
-    static int pthread_attr_setschedpolicy( pthread_attr_t* attr, int policy)
-    {
-        if( policy != SCHED_OTHER)
-        {
-            return ENOTSUP;
-        }
-        return 0;
-    }
-#       endif // pthread_attr_setschedpolicy()
-#       endif // defined(__MINGW32__) || defined(__MINGW64__)
-
-  static void _PT_FAIL( int rc, const char *name, const char *file, uint_t line ) {
-    const char *why= (rc==EINVAL) ? "EINVAL" : 
-                     (rc==EBUSY) ? "EBUSY" : 
-                     (rc==EPERM) ? "EPERM" :
-                     (rc==ENOMEM) ? "ENOMEM" :
-                     (rc==ESRCH) ? "ESRCH" :
-                     (rc==ENOTSUP) ? "ENOTSUP":
-                     //...
-                     "<UNKNOWN>";
-    fprintf( stderr, "%s %d: %s failed, %d %s\n", file, line, name, rc, why );
-    abort();
-  }
-  #define PT_CALL( call ) { int rc= call; if (rc!=0) _PT_FAIL( rc, #call, __FILE__, __LINE__ ); }
-  //
-  void SIGNAL_INIT( SIGNAL_T *ref ) {
-    PT_CALL( pthread_cond_init(ref,NULL /*attr*/) );
-    }
-  void SIGNAL_FREE( SIGNAL_T *ref ) {
-    PT_CALL( pthread_cond_destroy(ref) );
-  }
-  //
-  /*
-  * Timeout is given as absolute since we may have fake wakeups during
-  * a timed out sleep. A Linda with some other key read, or just because
-  * PThread cond vars can wake up unwantedly.
-  */
-  bool_t SIGNAL_WAIT( SIGNAL_T *ref, pthread_mutex_t *mu, time_d abs_secs ) {
-    if (abs_secs<0.0) {
-        PT_CALL( pthread_cond_wait( ref, mu ) );  // infinite
-    } else {
-        int rc;
-        struct timespec ts;
-
-        assert( abs_secs != 0.0 );
-        prepare_timeout( &ts, abs_secs );
-
-        rc= pthread_cond_timedwait( ref, mu, &ts );
-
-        if (rc==ETIMEDOUT) return FALSE;
-        if (rc) { _PT_FAIL( rc, "pthread_cond_timedwait()", __FILE__, __LINE__ ); }
-    }
-    return TRUE;
-  }
-  //
-  void SIGNAL_ONE( SIGNAL_T *ref ) {
-    PT_CALL( pthread_cond_signal(ref) );     // wake up ONE (or no) waiting thread
-  }
-  //
-  void SIGNAL_ALL( SIGNAL_T *ref ) {
-    PT_CALL( pthread_cond_broadcast(ref) );     // wake up ALL waiting threads
-  }
-
-// array of 7 thread priority values, hand-tuned by platform so that we offer a uniform [-3,+3] public priority range
-static int const gs_prio_remap[] =
-{
-    // NB: PThreads priority handling is about as twisty as one can get it
-    //     (and then some). DON*T TRUST ANYTHING YOU READ ON THE NET!!!
-
-    //---
-    // "Select the scheduling policy for the thread: one of SCHED_OTHER 
-    // (regular, non-real-time scheduling), SCHED_RR (real-time, 
-    // round-robin) or SCHED_FIFO (real-time, first-in first-out)."
-    //
-    // "Using the RR policy ensures that all threads having the same
-    // priority level will be scheduled equally, regardless of their activity."
-    //
-    // "For SCHED_FIFO and SCHED_RR, the only required member of the
-    // sched_param structure is the priority sched_priority. For SCHED_OTHER,
-    // the affected scheduling parameters are implementation-defined."
-    //
-    // "The priority of a thread is specified as a delta which is added to 
-    // the priority of the process."
-    //
-    // ".. priority is an integer value, in the range from 1 to 127. 
-    //  1 is the least-favored priority, 127 is the most-favored."
-    //
-    // "Priority level 0 cannot be used: it is reserved for the system."
-    //
-    // "When you use specify a priority of -99 in a call to 
-    // pthread_setschedparam(), the priority of the target thread is 
-    // lowered to the lowest possible value."
-    //
-    // ...
-
-    // ** CONCLUSION **
-    //
-    // PThread priorities are _hugely_ system specific, and we need at
-    // least OS specific settings. Hopefully, Linuxes and OS X versions
-    // are uniform enough, among each other...
-    //
-#   if defined PLATFORM_OSX
-        // AK 10-Apr-07 (OS X PowerPC 10.4.9):
-        //
-        // With SCHED_RR, 26 seems to be the "normal" priority, where setting
-        // it does not seem to affect the order of threads processed.
-        //
-        // With SCHED_OTHER, the range 25..32 is normal (maybe the same 26,
-        // but the difference is not so clear with OTHER).
-        //
-        // 'sched_get_priority_min()' and '..max()' give 15, 47 as the 
-        // priority limits. This could imply, user mode applications won't
-        // be able to use values outside of that range.
-        //
-#       define _PRIO_MODE SCHED_OTHER
-
-        // OS X 10.4.9 (PowerPC) gives ENOTSUP for process scope
-        //#define _PRIO_SCOPE PTHREAD_SCOPE_PROCESS
-
-#       define _PRIO_HI  32    // seems to work (_carefully_ picked!)
-#       define _PRIO_0   26    // detected
-#       define _PRIO_LO   1    // seems to work (tested)
-
-#   elif defined PLATFORM_LINUX
-        // (based on Ubuntu Linux 2.6.15 kernel)
-        //
-        // SCHED_OTHER is the default policy, but does not allow for priorities.
-        // SCHED_RR allows priorities, all of which (1..99) are higher than
-        // a thread with SCHED_OTHER policy.
-        //
-        // <http://kerneltrap.org/node/6080>
-        // <http://en.wikipedia.org/wiki/Native_POSIX_Thread_Library>
-        // <http://www.net.in.tum.de/~gregor/docs/pthread-scheduling.html>
-        //
-        // Manuals suggest checking #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING,
-        // but even Ubuntu does not seem to define it.
-        //
-#       define _PRIO_MODE SCHED_RR
-
-        // NTLP 2.5: only system scope allowed (being the basic reason why
-        //           root privileges are required..)
-        //#define _PRIO_SCOPE PTHREAD_SCOPE_PROCESS
-
-#       define _PRIO_HI 99
-#       define _PRIO_0  50
-#       define _PRIO_LO 1
-
-#   elif defined(PLATFORM_BSD)
-        //
-        // <http://www.net.in.tum.de/~gregor/docs/pthread-scheduling.html>
-        //
-        // "When control over the thread scheduling is desired, then FreeBSD
-        //  with the libpthread implementation is by far the best choice .."
-        //
-#       define _PRIO_MODE SCHED_OTHER
-#       define _PRIO_SCOPE PTHREAD_SCOPE_PROCESS
-#       define _PRIO_HI 31
-#       define _PRIO_0  15
-#       define _PRIO_LO 1
-
-#   elif defined(PLATFORM_CYGWIN)
-        //
-        // TBD: Find right values for Cygwin
-        //
-#   elif defined( PLATFORM_WIN32) || defined( PLATFORM_POCKETPC)
-        // any other value not supported by win32-pthread as of version 2.9.1
-#           define _PRIO_MODE SCHED_OTHER
-
-        // PTHREAD_SCOPE_PROCESS not supported by win32-pthread as of version 2.9.1
-        //#define _PRIO_SCOPE PTHREAD_SCOPE_SYSTEM // but do we need this at all to start with?
-        THREAD_PRIORITY_IDLE, THREAD_PRIORITY_LOWEST, THREAD_PRIORITY_BELOW_NORMAL, THREAD_PRIORITY_NORMAL, THREAD_PRIORITY_ABOVE_NORMAL, THREAD_PRIORITY_HIGHEST, THREAD_PRIORITY_TIME_CRITICAL
-
-#   else
-#       error "Unknown OS: not implemented!"
-#   endif
-
-#if defined _PRIO_0
-#   define _PRIO_AN (_PRIO_0 + ((_PRIO_HI-_PRIO_0)/2))
-#   define _PRIO_BN (_PRIO_LO + ((_PRIO_0-_PRIO_LO)/2))
-
-    _PRIO_LO, _PRIO_LO, _PRIO_BN, _PRIO_0, _PRIO_AN, _PRIO_HI, _PRIO_HI
-#endif // _PRIO_0
-};
-
-static int select_prio(int prio /* -3..+3 */)
-{
-    if (prio == THREAD_PRIO_DEFAULT)
-        prio = 0;
-    // prio range [-3,+3] was checked by the caller
-    return gs_prio_remap[prio + 3];
-}
-
-void THREAD_CREATE( THREAD_T* ref, THREAD_RETURN_T (*func)( void*), void* data, int prio /* -3..+3 */)
-{
-    pthread_attr_t a;
-    bool_t const change_priority =
-#ifdef PLATFORM_LINUX
-    sudo && // only root-privileged process can change priorities
-#endif
-    (prio != THREAD_PRIO_DEFAULT);
-
-    PT_CALL( pthread_attr_init( &a));
-
-#ifndef PTHREAD_TIMEDJOIN
-    // We create a NON-JOINABLE thread. This is mainly due to the lack of
-    // 'pthread_timedjoin()', but does offer other benefits (s.a. earlier 
-    // freeing of the thread's resources).
-    //
-    PT_CALL( pthread_attr_setdetachstate( &a, PTHREAD_CREATE_DETACHED));
-#endif // PTHREAD_TIMEDJOIN
-
-    // Use this to find a system's default stack size (DEBUG)
-#if 0
-    {
-        size_t n;
-        pthread_attr_getstacksize( &a, &n);
-        fprintf( stderr, "Getstack: %u\n", (unsigned int)n);
-    }
-    //  524288 on OS X
-    // 2097152 on Linux x86 (Ubuntu 7.04)
-    // 1048576 on FreeBSD 6.2 SMP i386
-#endif // 0
-
-#if defined _THREAD_STACK_SIZE && _THREAD_STACK_SIZE > 0
-    PT_CALL( pthread_attr_setstacksize( &a, _THREAD_STACK_SIZE));
-#endif
-
-    if (change_priority)
-    {
-        struct sched_param sp;
-        // "The specified scheduling parameters are only used if the scheduling
-        //  parameter inheritance attribute is PTHREAD_EXPLICIT_SCHED."
-        //
-#if !defined __ANDROID__ || ( defined __ANDROID__ && __ANDROID_API__ >= 28 )
-        PT_CALL( pthread_attr_setinheritsched( &a, PTHREAD_EXPLICIT_SCHED));
-#endif
-
-#ifdef _PRIO_SCOPE
-        PT_CALL( pthread_attr_setscope( &a, _PRIO_SCOPE));
-#endif // _PRIO_SCOPE
-
-        PT_CALL( pthread_attr_setschedpolicy( &a, _PRIO_MODE));
-
-        sp.sched_priority = select_prio(prio);
-        PT_CALL( pthread_attr_setschedparam( &a, &sp));
-    }
-
-    //---
-    // Seems on OS X, _POSIX_THREAD_THREADS_MAX is some kind of system
-    // thread limit (not userland thread). Actual limit for us is way higher.
-    // PTHREAD_THREADS_MAX is not defined (even though man page refers to it!)
-    //
-# ifndef THREAD_CREATE_RETRIES_MAX
-    // Don't bother with retries; a failure is a failure
-    //
-    { 
-        int rc = pthread_create( ref, &a, func, data);
-        if( rc) _PT_FAIL( rc, "pthread_create()", __FILE__, __LINE__ - 1);
-    }
-# else
-#               error "This code deprecated"
-        /*
-        // Wait slightly if thread creation has exchausted the system
-        //
-        { uint_t retries;
-        for( retries=0; retries<THREAD_CREATE_RETRIES_MAX; retries++ ) {
-
-        int rc= pthread_create( ref, &a, func, data );
-        //
-        // OS X / Linux:
-        //    EAGAIN: ".. lacked the necessary resources to create
-        //             another thread, or the system-imposed limit on the
-        //             total number of threads in a process 
-        //             [PTHREAD_THREADS_MAX] would be exceeded."
-        //    EINVAL: attr is invalid
-        // Linux:
-        //    EPERM: no rights for given parameters or scheduling (no sudo)
-        //    ENOMEM: (known to fail with this code, too - not listed in man)
-
-        if (rc==0) break;   // ok!
-
-        // In practise, exhaustion seems to be coming from memory, not a
-        // maximum number of threads. Keep tuning... ;)
-        //
-        if (rc==EAGAIN) {
-        //fprintf( stderr, "Looping (retries=%d) ", retries );    // DEBUG
-
-        // Try again, later.
-
-        Yield();
-        } else {
-        _PT_FAIL( rc, "pthread_create()", __FILE__, __LINE__ );
-        }
-        }
-        }
-        */
-# endif
-
-    PT_CALL( pthread_attr_destroy( &a));
-}
-
-
-void THREAD_SET_PRIORITY( int prio)
-{
-#ifdef PLATFORM_LINUX
-    if( sudo) // only root-privileged process can change priorities
-#endif // PLATFORM_LINUX
-    {
-        struct sched_param sp;
-        // prio range [-3,+3] was checked by the caller
-        sp.sched_priority = gs_prio_remap[ prio + 3];
-        PT_CALL( pthread_setschedparam( pthread_self(), _PRIO_MODE, &sp));
-    }
-}
-
-void THREAD_SET_AFFINITY( unsigned int aff)
-{
-    int bit = 0;
-#ifdef __NetBSD__
-    cpuset_t *cpuset = cpuset_create();
-    if( cpuset == NULL)
-        _PT_FAIL( errno, "cpuset_create", __FILE__, __LINE__-2 );
-#define CPU_SET(b, s) cpuset_set(b, *(s))
-#else
-    cpu_set_t cpuset;
-    CPU_ZERO( &cpuset);
-#endif
-    while( aff != 0)
-    {
-        if( aff & 1)
-        {
-            CPU_SET( bit, &cpuset);
-        }
-        ++ bit;
-        aff >>= 1;
-    }
-#ifdef __ANDROID__
-    PT_CALL( sched_setaffinity( pthread_self(), sizeof(cpu_set_t), &cpuset));
-#elif defined(__NetBSD__)
-    PT_CALL( pthread_setaffinity_np( pthread_self(), cpuset_size(cpuset), cpuset));
-    cpuset_destroy( cpuset);
-#else
-    PT_CALL( pthread_setaffinity_np( pthread_self(), sizeof(cpu_set_t), &cpuset));
-#endif
-}
-
- /*
-  * Wait for a thread to finish.
-  *
-  * 'mu_ref' is a lock we should use for the waiting; initially unlocked.
-  * Same lock as passed to THREAD_EXIT.
-  *
-  * Returns TRUE for successful wait, FALSE for timed out
-  */
-bool_t THREAD_WAIT( THREAD_T *ref, double secs , SIGNAL_T *signal_ref, MUTEX_T *mu_ref, volatile enum e_status *st_ref)
-{
-    struct timespec ts_store;
-    const struct timespec *timeout= NULL;
-    bool_t done;
-
-    // Do timeout counting before the locks
-    //
-#if THREADWAIT_METHOD == THREADWAIT_TIMEOUT
-    if (secs>=0.0)
-#else // THREADWAIT_METHOD == THREADWAIT_CONDVAR
-    if (secs>0.0)
-#endif // THREADWAIT_METHOD == THREADWAIT_CONDVAR
-    {
-        prepare_timeout( &ts_store, now_secs()+secs );
-        timeout= &ts_store;
-    }
-
-#if THREADWAIT_METHOD == THREADWAIT_TIMEOUT
-    /* Thread is joinable
-    */
-    if (!timeout) {
-        PT_CALL( pthread_join( *ref, NULL /*ignore exit value*/ ));
-        done= TRUE;
-    } else {
-        int rc= PTHREAD_TIMEDJOIN( *ref, NULL, timeout );
-        if ((rc!=0) && (rc!=ETIMEDOUT)) {
-            _PT_FAIL( rc, "PTHREAD_TIMEDJOIN", __FILE__, __LINE__-2 );
-        }
-        done= rc==0;
-    }
-#else // THREADWAIT_METHOD == THREADWAIT_CONDVAR
-    /* Since we've set the thread up as PTHREAD_CREATE_DETACHED, we cannot
-     * join with it. Use the cond.var.
-    */
-    (void) ref; // unused
-    MUTEX_LOCK( mu_ref );
-    
-        // 'secs'==0.0 does not need to wait, just take the current status
-        // within the 'mu_ref' locks
-        //
-        if (secs != 0.0) {
-            while( *st_ref < DONE ) {
-                if (!timeout) {
-                    PT_CALL( pthread_cond_wait( signal_ref, mu_ref ));
-                } else {
-                    int rc= pthread_cond_timedwait( signal_ref, mu_ref, timeout );
-                    if (rc==ETIMEDOUT) break;
-                    if (rc!=0) _PT_FAIL( rc, "pthread_cond_timedwait", __FILE__, __LINE__-2 );
-                }
-            }
-        }
-        done= *st_ref >= DONE;  // DONE|ERROR_ST|CANCELLED
-
-    MUTEX_UNLOCK( mu_ref );
-#endif // THREADWAIT_METHOD == THREADWAIT_CONDVAR
-    return done;
-  }
-    //
-  void THREAD_KILL( THREAD_T *ref ) {
-#ifdef __ANDROID__
-      __android_log_print(ANDROID_LOG_WARN, LOG_TAG, "Cannot kill thread!");
-#else
-    pthread_cancel( *ref );
-#endif
-  }
-
-    void THREAD_MAKE_ASYNCH_CANCELLABLE()
-    {
-#ifdef __ANDROID__
-    __android_log_print(ANDROID_LOG_WARN, LOG_TAG, "Cannot make thread async cancellable!");
-#else
-        // that's the default, but just in case...
-        pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
-        // we want cancellation to take effect immediately if possible, instead of waiting for a cancellation point (which is the default)
-        pthread_setcanceltype( PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
-#endif
-    }
-
-    void THREAD_SETNAME( char const* _name)
-    {
-        // exact API to set the thread name is platform-dependant
-        // if you need to fix the build, or if you know how to fill a hole, tell me (bnt.germain@gmail.com) so that I can submit the fix in github.
-#if defined PLATFORM_BSD && !defined __NetBSD__
-        pthread_set_name_np( pthread_self(), _name);
-#elif defined PLATFORM_BSD && defined __NetBSD__
-        pthread_setname_np( pthread_self(), "%s", (void *)_name);
-#elif defined PLATFORM_LINUX
-    #if LINUX_USE_PTHREAD_SETNAME_NP
-        pthread_setname_np( pthread_self(), _name);
-    #else // LINUX_USE_PTHREAD_SETNAME_NP
-         prctl(PR_SET_NAME, _name, 0, 0, 0);
-    #endif // LINUX_USE_PTHREAD_SETNAME_NP
-#elif defined PLATFORM_QNX || defined PLATFORM_CYGWIN
-        pthread_setname_np( pthread_self(), _name);
-#elif defined PLATFORM_OSX
-        pthread_setname_np(_name);
-#elif defined PLATFORM_WIN32 || defined PLATFORM_POCKETPC
-        PT_CALL( pthread_setname_np( pthread_self(), _name));
-#endif
-    }
-#endif // THREADAPI == THREADAPI_PTHREAD
diff --git a/src/threading.cpp b/src/threading.cpp
new file mode 100644
index 0000000..259693a
--- /dev/null
+++ b/src/threading.cpp
@@ -0,0 +1,448 @@
+/*
+ * THREADING.CPP                      Copyright (c) 2007-08, Asko Kauppi
+ *                                    Copyright (C) 2009-24, Benoit Germain
+ *
+ * Lua Lanes OS threading specific code.
+ *
+ * References:
+ *      <http://www.cse.wustl.edu/~schmidt/win32-cv-1.html>
+*/
+
+/*
+===============================================================================
+
+Copyright (C) 2007-10 Asko Kauppi <akauppi@gmail.com>
+Copyright (C) 2009-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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+===============================================================================
+*/
+#if defined(__linux__)
+
+# ifndef _GNU_SOURCE // definition by the makefile can cause a redefinition error
+# define _GNU_SOURCE // must be defined before any include
+# endif // _GNU_SOURCE
+
+# ifdef __ANDROID__
+#  include <android/log.h>
+#  define LOG_TAG "LuaLanes"
+# endif // __ANDROID__
+
+#endif // __linux__
+
+#include "threading.h"
+
+#if !defined( PLATFORM_XBOX) && !defined( PLATFORM_WIN32) && !defined( PLATFORM_POCKETPC)
+# include <sys/time.h>
+#endif // non-WIN32 timing
+
+
+#if defined(PLATFORM_LINUX) || defined(PLATFORM_CYGWIN)
+# include <sys/types.h>
+# include <unistd.h>
+#endif
+
+#ifdef PLATFORM_OSX
+# include "threading_osx.h"
+#endif
+
+/* Linux with older glibc (such as Debian) don't have pthread_setname_np, but have prctl
+*/
+#if defined PLATFORM_LINUX
+#if defined __GNU_LIBRARY__ && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 12
+#define LINUX_USE_PTHREAD_SETNAME_NP 1
+#else // glibc without pthread_setname_np
+#include <sys/prctl.h>
+#define LINUX_USE_PTHREAD_SETNAME_NP 0
+#endif // glibc without pthread_setname_np
+#endif // PLATFORM_LINUX
+
+#ifdef _MSC_VER
+// ".. selected for automatic inline expansion" (/O2 option)
+# pragma warning( disable : 4711 )
+// ".. type cast from function pointer ... to data pointer"
+# pragma warning( disable : 4054 )
+#endif
+
+/* 
+* FAIL is for unexpected API return values - essentially programming 
+* error in _this_ code. 
+*/
+#if defined(PLATFORM_XBOX) || defined(PLATFORM_WIN32) || defined(PLATFORM_POCKETPC)
+  static void FAIL(char const* funcname, int rc)
+  {
+#if defined(PLATFORM_XBOX)
+      fprintf(stderr, "%s() failed! (%d)\n", funcname, rc);
+#else // PLATFORM_XBOX
+      char buf[256];
+      FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, nullptr, rc, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, 256, nullptr);
+      fprintf(stderr, "%s() failed! [GetLastError() -> %d] '%s'", funcname, rc, buf);
+#endif // PLATFORM_XBOX
+#ifdef _MSC_VER
+      __debugbreak(); // give a chance to the debugger!
+#endif // _MSC_VER
+      abort();
+  }
+#endif // win32 build
+
+
+/*---=== Threading ===---*/
+
+// ##################################################################################################
+// ##################################################################################################
+#if THREADAPI == THREADAPI_WINDOWS
+
+static int const gs_prio_remap[] =
+{
+    THREAD_PRIORITY_IDLE,
+    THREAD_PRIORITY_LOWEST,
+    THREAD_PRIORITY_BELOW_NORMAL,
+    THREAD_PRIORITY_NORMAL,
+    THREAD_PRIORITY_ABOVE_NORMAL,
+    THREAD_PRIORITY_HIGHEST,
+    THREAD_PRIORITY_TIME_CRITICAL
+};
+
+// ###############################################################################################
+
+void THREAD_SET_PRIORITY(int prio_, [[maybe_unused]] bool sudo_)
+{
+    // prio range [-3,+3] was checked by the caller
+    if (!SetThreadPriority(GetCurrentThread(), gs_prio_remap[prio_ + 3]))
+    {
+        FAIL("THREAD_SET_PRIORITY", GetLastError());
+    }
+}
+
+// ###############################################################################################
+
+void JTHREAD_SET_PRIORITY(std::jthread& thread_, int prio_, [[maybe_unused]] bool sudo_)
+{
+    // prio range [-3,+3] was checked by the caller
+    if (!SetThreadPriority(thread_.native_handle(), gs_prio_remap[prio_ + 3]))
+    {
+        FAIL("JTHREAD_SET_PRIORITY", GetLastError());
+    }
+}
+
+// ###############################################################################################
+
+void THREAD_SET_AFFINITY(unsigned int aff)
+{
+    if (!SetThreadAffinityMask(GetCurrentThread(), aff))
+    {
+        FAIL("THREAD_SET_AFFINITY", GetLastError());
+    }
+}
+
+// ###############################################################################################
+
+#if !defined __GNUC__
+//see http://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx
+#define MS_VC_EXCEPTION 0x406D1388
+#pragma pack(push,8)
+typedef struct tagTHREADNAME_INFO
+{
+    DWORD dwType; // Must be 0x1000.
+    LPCSTR szName; // Pointer to name (in user addr space).
+    DWORD dwThreadID; // Thread ID (-1=caller thread).
+    DWORD dwFlags; // Reserved for future use, must be zero.
+} THREADNAME_INFO;
+#pragma pack(pop)
+#endif // !__GNUC__
+
+void THREAD_SETNAME(char const* _name)
+{
+#if !defined __GNUC__
+    THREADNAME_INFO info;
+    info.dwType = 0x1000;
+    info.szName = _name;
+    info.dwThreadID = GetCurrentThreadId();
+    info.dwFlags = 0;
+
+    __try
+    {
+        RaiseException( MS_VC_EXCEPTION, 0, sizeof(info)/sizeof(ULONG_PTR), (ULONG_PTR*)&info );
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+    }
+#endif // !__GNUC__
+}
+
+// ##################################################################################################
+// ##################################################################################################
+#else // THREADAPI == THREADAPI_PTHREAD
+// ##################################################################################################
+// ##################################################################################################
+
+//  PThread (Linux, OS X, ...)
+//
+// On OS X, user processes seem to be able to change priorities.
+// On Linux, SCHED_RR and su privileges are required..  !-(
+//
+#include <errno.h>
+#include <sched.h>
+
+#if (defined(__MINGW32__) || defined(__MINGW64__)) && defined pthread_attr_setschedpolicy
+#if pthread_attr_setschedpolicy(A, S) == ENOTSUP
+// from the mingw-w64 team:
+// Well, we support pthread_setschedparam by which you can specify
+// threading-policy. Nevertheless, yes we lack this function. In
+// general its implementation is pretty much trivial, as on Win32 target
+// just SCHED_OTHER can be supported.
+#undef pthread_attr_setschedpolicy
+[[nodiscard]] static int pthread_attr_setschedpolicy(pthread_attr_t* attr, int policy)
+{
+    if (policy != SCHED_OTHER)
+    {
+        return ENOTSUP;
+    }
+    return 0;
+}
+#endif // pthread_attr_setschedpolicy()
+#endif // defined(__MINGW32__) || defined(__MINGW64__)
+
+static void _PT_FAIL( int rc, const char *name, const char *file, int line )
+{
+    const char *why= (rc==EINVAL) ? "EINVAL" : 
+                (rc==EBUSY) ? "EBUSY" : 
+                (rc==EPERM) ? "EPERM" :
+                (rc==ENOMEM) ? "ENOMEM" :
+                (rc==ESRCH) ? "ESRCH" :
+                (rc==ENOTSUP) ? "ENOTSUP":
+                //...
+                "<UNKNOWN>";
+    fprintf( stderr, "%s %d: %s failed, %d %s\n", file, line, name, rc, why );
+    abort();
+}
+#define PT_CALL( call ) { int rc= call; if (rc!=0) _PT_FAIL( rc, #call, __FILE__, __LINE__ ); }
+
+// array of 7 thread priority values, hand-tuned by platform so that we offer a uniform [-3,+3] public priority range
+static int const gs_prio_remap[] =
+{
+    // NB: PThreads priority handling is about as twisty as one can get it
+    //     (and then some). DON*T TRUST ANYTHING YOU READ ON THE NET!!!
+
+    //---
+    // "Select the scheduling policy for the thread: one of SCHED_OTHER 
+    // (regular, non-real-time scheduling), SCHED_RR (real-time, 
+    // round-robin) or SCHED_FIFO (real-time, first-in first-out)."
+    //
+    // "Using the RR policy ensures that all threads having the same
+    // priority level will be scheduled equally, regardless of their activity."
+    //
+    // "For SCHED_FIFO and SCHED_RR, the only required member of the
+    // sched_param structure is the priority sched_priority. For SCHED_OTHER,
+    // the affected scheduling parameters are implementation-defined."
+    //
+    // "The priority of a thread is specified as a delta which is added to 
+    // the priority of the process."
+    //
+    // ".. priority is an integer value, in the range from 1 to 127. 
+    //  1 is the least-favored priority, 127 is the most-favored."
+    //
+    // "Priority level 0 cannot be used: it is reserved for the system."
+    //
+    // "When you use specify a priority of -99 in a call to 
+    // pthread_setschedparam(), the priority of the target thread is 
+    // lowered to the lowest possible value."
+    //
+    // ...
+
+    // ** CONCLUSION **
+    //
+    // PThread priorities are _hugely_ system specific, and we need at
+    // least OS specific settings. Hopefully, Linuxes and OS X versions
+    // are uniform enough, among each other...
+    //
+#   if defined PLATFORM_OSX
+        // AK 10-Apr-07 (OS X PowerPC 10.4.9):
+        //
+        // With SCHED_RR, 26 seems to be the "normal" priority, where setting
+        // it does not seem to affect the order of threads processed.
+        //
+        // With SCHED_OTHER, the range 25..32 is normal (maybe the same 26,
+        // but the difference is not so clear with OTHER).
+        //
+        // 'sched_get_priority_min()' and '..max()' give 15, 47 as the 
+        // priority limits. This could imply, user mode applications won't
+        // be able to use values outside of that range.
+        //
+#       define _PRIO_MODE SCHED_OTHER
+
+        // OS X 10.4.9 (PowerPC) gives ENOTSUP for process scope
+        //#define _PRIO_SCOPE PTHREAD_SCOPE_PROCESS
+
+#       define _PRIO_HI  32    // seems to work (_carefully_ picked!)
+#       define _PRIO_0   26    // detected
+#       define _PRIO_LO   1    // seems to work (tested)
+
+#   elif defined PLATFORM_LINUX
+        // (based on Ubuntu Linux 2.6.15 kernel)
+        //
+        // SCHED_OTHER is the default policy, but does not allow for priorities.
+        // SCHED_RR allows priorities, all of which (1..99) are higher than
+        // a thread with SCHED_OTHER policy.
+        //
+        // <http://kerneltrap.org/node/6080>
+        // <http://en.wikipedia.org/wiki/Native_POSIX_Thread_Library>
+        // <http://www.net.in.tum.de/~gregor/docs/pthread-scheduling.html>
+        //
+        // Manuals suggest checking #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING,
+        // but even Ubuntu does not seem to define it.
+        //
+#       define _PRIO_MODE SCHED_RR
+
+        // NTLP 2.5: only system scope allowed (being the basic reason why
+        //           root privileges are required..)
+        //#define _PRIO_SCOPE PTHREAD_SCOPE_PROCESS
+
+#       define _PRIO_HI 99
+#       define _PRIO_0  50
+#       define _PRIO_LO 1
+
+#   elif defined(PLATFORM_BSD)
+        //
+        // <http://www.net.in.tum.de/~gregor/docs/pthread-scheduling.html>
+        //
+        // "When control over the thread scheduling is desired, then FreeBSD
+        //  with the libpthread implementation is by far the best choice .."
+        //
+#       define _PRIO_MODE SCHED_OTHER
+#       define _PRIO_SCOPE PTHREAD_SCOPE_PROCESS
+#       define _PRIO_HI 31
+#       define _PRIO_0  15
+#       define _PRIO_LO 1
+
+#   elif defined(PLATFORM_CYGWIN)
+        //
+        // TBD: Find right values for Cygwin
+        //
+#   else
+#       error "Unknown OS: not implemented!"
+#   endif
+
+#if defined _PRIO_0
+#   define _PRIO_AN (_PRIO_0 + ((_PRIO_HI-_PRIO_0)/2))
+#   define _PRIO_BN (_PRIO_LO + ((_PRIO_0-_PRIO_LO)/2))
+
+    _PRIO_LO, _PRIO_LO, _PRIO_BN, _PRIO_0, _PRIO_AN, _PRIO_HI, _PRIO_HI
+#endif // _PRIO_0
+};
+
+[[nodiscard]] static int select_prio(int prio /* -3..+3 */)
+{
+    if (prio == THREAD_PRIO_DEFAULT)
+        prio = 0;
+    // prio range [-3,+3] was checked by the caller
+    return gs_prio_remap[prio + 3];
+}
+
+void THREAD_SET_PRIORITY(int prio_, [[maybe_unused]] bool sudo_)
+{
+#ifdef PLATFORM_LINUX
+    if (!sudo_) // only root-privileged process can change priorities
+        return;
+#endif // PLATFORM_LINUX
+
+    struct sched_param sp;
+    // prio range [-3,+3] was checked by the caller
+    sp.sched_priority = gs_prio_remap[prio_ + 3];
+    PT_CALL(pthread_setschedparam(pthread_self(), _PRIO_MODE, &sp));
+}
+
+// #################################################################################################
+
+void JTHREAD_SET_PRIORITY(std::jthread& thread_, int prio_, [[maybe_unused]] bool sudo_)
+{
+#ifdef PLATFORM_LINUX
+    if (!sudo_) // only root-privileged process can change priorities
+        return;
+#endif // PLATFORM_LINUX
+
+    struct sched_param sp;
+    // prio range [-3,+3] was checked by the caller
+    sp.sched_priority = gs_prio_remap[prio_ + 3];
+    PT_CALL(pthread_setschedparam(static_cast<pthread_t>(thread_.native_handle()), _PRIO_MODE, &sp));
+}
+
+// #################################################################################################
+
+void THREAD_SET_AFFINITY(unsigned int aff)
+{
+    int bit = 0;
+#ifdef __NetBSD__
+    cpuset_t* cpuset = cpuset_create();
+    if (cpuset == nullptr)
+        _PT_FAIL(errno, "cpuset_create", __FILE__, __LINE__ - 2);
+#define CPU_SET(b, s) cpuset_set(b, *(s))
+#else
+    cpu_set_t cpuset;
+    CPU_ZERO(&cpuset);
+#endif
+    while (aff != 0)
+    {
+        if (aff & 1)
+        {
+            CPU_SET(bit, &cpuset);
+        }
+        ++bit;
+        aff >>= 1;
+    }
+#ifdef __ANDROID__
+    PT_CALL(sched_setaffinity(pthread_self(), sizeof(cpu_set_t), &cpuset));
+#elif defined(__NetBSD__)
+    PT_CALL(pthread_setaffinity_np(pthread_self(), cpuset_size(cpuset), cpuset));
+    cpuset_destroy(cpuset);
+#else
+    PT_CALL(pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset));
+#endif
+}
+
+// #################################################################################################
+
+void THREAD_SETNAME(char const* _name)
+{
+    // exact API to set the thread name is platform-dependant
+    // if you need to fix the build, or if you know how to fill a hole, tell me (bnt.germain@gmail.com) so that I can submit the fix in github.
+#if defined PLATFORM_BSD && !defined __NetBSD__
+    pthread_set_name_np(pthread_self(), _name);
+#elif defined PLATFORM_BSD && defined __NetBSD__
+    pthread_setname_np(pthread_self(), "%s", (void*) _name);
+#elif defined PLATFORM_LINUX
+#if LINUX_USE_PTHREAD_SETNAME_NP
+    pthread_setname_np(pthread_self(), _name);
+#else // LINUX_USE_PTHREAD_SETNAME_NP
+    prctl(PR_SET_NAME, _name, 0, 0, 0);
+#endif // LINUX_USE_PTHREAD_SETNAME_NP
+#elif defined PLATFORM_QNX || defined PLATFORM_CYGWIN
+    pthread_setname_np(pthread_self(), _name);
+#elif defined PLATFORM_OSX
+    pthread_setname_np(_name);
+#else
+    fprintf(stderr, "THREAD_SETNAME: unsupported platform\n");
+    abort();
+#endif
+}
+
+#endif // THREADAPI == THREADAPI_PTHREAD
+// #################################################################################################
+// #################################################################################################
diff --git a/src/threading.h b/src/threading.h
index b1706ac..fc35730 100644
--- a/src/threading.h
+++ b/src/threading.h
@@ -1,37 +1,13 @@
-/*
-* THREADING.H
-*/
-#ifndef __threading_h__
-#define __threading_h__ 1
+#pragma once
 
-/*
- * win32-pthread:
- * define HAVE_WIN32_PTHREAD and PTW32_INCLUDE_WINDOWS_H in your project configuration when building for win32-pthread.
- * link against pthreadVC2.lib, and of course have pthreadVC2.dll somewhere in your path.
- */
 #include "platform.h"
 
-typedef int bool_t;
-#ifndef FALSE
-# define FALSE 0
-# define TRUE 1
-#endif
-
-typedef unsigned int uint_t;
-
-#include <time.h>
-
-/* Note: ERROR is a defined entity on Win32
-  PENDING: The Lua VM hasn't done anything yet.
-  RUNNING, WAITING: Thread is inside the Lua VM. If the thread is forcefully stopped, we can't lua_close() the Lua State.
-  DONE, ERROR_ST, CANCELLED: Thread execution is outside the Lua VM. It can be lua_close()d.
-*/
-enum e_status { PENDING, RUNNING, WAITING, DONE, ERROR_ST, CANCELLED };
+#include <thread>
 
 #define THREADAPI_WINDOWS 1
 #define THREADAPI_PTHREAD 2
 
-#if( defined( PLATFORM_XBOX) || defined( PLATFORM_WIN32) || defined( PLATFORM_POCKETPC)) && !defined( HAVE_WIN32_PTHREAD)
+#if( defined( PLATFORM_XBOX) || defined( PLATFORM_WIN32) || defined( PLATFORM_POCKETPC))
 //#pragma message ( "THREADAPI_WINDOWS" )
 #define THREADAPI THREADAPI_WINDOWS
 #else // (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC)
@@ -39,22 +15,24 @@ enum e_status { PENDING, RUNNING, WAITING, DONE, ERROR_ST, CANCELLED };
 #define THREADAPI THREADAPI_PTHREAD
 #endif // (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC)
 
-/*---=== Locks & Signals ===---
-*/
+static constexpr int THREAD_PRIO_DEFAULT{ -999 };
 
+// ##################################################################################################
+// ##################################################################################################
 #if THREADAPI == THREADAPI_WINDOWS
-  #if defined( PLATFORM_XBOX)
-    #include <xtl.h>
-  #else // !PLATFORM_XBOX
-    #define WIN32_LEAN_AND_MEAN
-    // CONDITION_VARIABLE needs version 0x0600+
-    // _WIN32_WINNT value is already defined by MinGW, but not by MSVC
-    #ifndef _WIN32_WINNT
-    #define _WIN32_WINNT 0x0600
-    #endif // _WIN32_WINNT
-    #include <windows.h>
-  #endif // !PLATFORM_XBOX
-  #include <process.h>
+
+#if defined(PLATFORM_XBOX)
+#include <xtl.h>
+#else // !PLATFORM_XBOX
+#define WIN32_LEAN_AND_MEAN
+// CONDITION_VARIABLE needs version 0x0600+
+// _WIN32_WINNT value is already defined by MinGW, but not by MSVC
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT 0x0600
+#endif // _WIN32_WINNT
+#include <windows.h>
+#endif // !PLATFORM_XBOX
+#include <process.h>
 
 /*
 #define XSTR(x) STR(x)
@@ -62,204 +40,36 @@ enum e_status { PENDING, RUNNING, WAITING, DONE, ERROR_ST, CANCELLED };
 #pragma message( "The value of _WIN32_WINNT: " XSTR(_WIN32_WINNT))
 */
 
-  // MSDN: http://msdn2.microsoft.com/en-us/library/ms684254.aspx
-  //
-  // CRITICAL_SECTION can be used for simple code protection. Mutexes are
-  // needed for use with the SIGNAL system.
-  //
-
-    #if _WIN32_WINNT < 0x0600 // CONDITION_VARIABLE aren't available, use a signal
-
-    typedef struct
-    {
-        CRITICAL_SECTION    signalCS;
-        CRITICAL_SECTION    countCS;
-        HANDLE      waitEvent;
-        HANDLE      waitDoneEvent;
-        LONG        waitersCount;
-    } SIGNAL_T;
-
-
-    #define MUTEX_T HANDLE
-    void MUTEX_INIT( MUTEX_T* ref);
-    void MUTEX_FREE( MUTEX_T* ref);
-    void MUTEX_LOCK( MUTEX_T* ref);
-    void MUTEX_UNLOCK( MUTEX_T* ref);
-
-    #else // CONDITION_VARIABLE are available, use them
-
-    #define SIGNAL_T CONDITION_VARIABLE
-    #define MUTEX_T CRITICAL_SECTION
-    #define MUTEX_INIT( ref) InitializeCriticalSection( ref)
-    #define MUTEX_FREE( ref) DeleteCriticalSection( ref)
-    #define MUTEX_LOCK( ref) EnterCriticalSection( ref)
-    #define MUTEX_UNLOCK( ref) LeaveCriticalSection( ref)
-
-    #endif // CONDITION_VARIABLE are available
-
-  #define MUTEX_RECURSIVE_INIT(ref)  MUTEX_INIT(ref)  /* always recursive in Win32 */
-
-  typedef unsigned int THREAD_RETURN_T;
-
-  #define YIELD() Sleep(0)
-    #define THREAD_CALLCONV __stdcall
-#else // THREADAPI == THREADAPI_PTHREAD
-  // PThread (Linux, OS X, ...)
-
-  // looks like some MinGW installations don't support PTW32_INCLUDE_WINDOWS_H, so let's include it ourselves, just in case
-  #if defined(PLATFORM_WIN32)
-  #include <windows.h>
-  #endif // PLATFORM_WIN32
-  #include <pthread.h>
-
-  #ifdef PLATFORM_LINUX
-    #if defined(__GLIBC__)
-      # define _MUTEX_RECURSIVE PTHREAD_MUTEX_RECURSIVE_NP
-    #else
-      # define _MUTEX_RECURSIVE PTHREAD_MUTEX_RECURSIVE
-    #endif
-  #else
-    /* OS X, ... */
-  # define _MUTEX_RECURSIVE PTHREAD_MUTEX_RECURSIVE
-  #endif
-
-  #define MUTEX_T            pthread_mutex_t
-  #define MUTEX_INIT(ref)    pthread_mutex_init(ref,NULL)
-  #define MUTEX_RECURSIVE_INIT(ref) \
-      { pthread_mutexattr_t a; pthread_mutexattr_init( &a ); \
-        pthread_mutexattr_settype( &a, _MUTEX_RECURSIVE ); \
-        pthread_mutex_init(ref,&a); pthread_mutexattr_destroy( &a ); \
-      }
-  #define MUTEX_FREE(ref)    pthread_mutex_destroy(ref)
-  #define MUTEX_LOCK(ref)    pthread_mutex_lock(ref)
-  #define MUTEX_UNLOCK(ref)  pthread_mutex_unlock(ref)
-
-  typedef void * THREAD_RETURN_T;
-
-  typedef pthread_cond_t SIGNAL_T;
-
-  void SIGNAL_ONE( SIGNAL_T *ref );
-
-  // Yield is non-portable:
-  //
-  //    OS X 10.4.8/9 has pthread_yield_np()
-  //    Linux 2.4   has pthread_yield() if _GNU_SOURCE is #defined
-  //    FreeBSD 6.2 has pthread_yield()
-  //    ...
-  //
-  #if defined( PLATFORM_OSX)
-    #define YIELD() pthread_yield_np()
-  #else
-    #define YIELD() sched_yield()
-  #endif
-    #define THREAD_CALLCONV
-#endif //THREADAPI == THREADAPI_PTHREAD
-
-void SIGNAL_INIT( SIGNAL_T *ref );
-void SIGNAL_FREE( SIGNAL_T *ref );
-void SIGNAL_ALL( SIGNAL_T *ref );
-
-/*
-* 'time_d': <0.0 for no timeout
-*           0.0 for instant check
-*           >0.0 absolute timeout in secs + ms
-*/
-typedef double time_d;
-time_d now_secs(void);
-
-time_d SIGNAL_TIMEOUT_PREPARE( double rel_secs );
-
-bool_t SIGNAL_WAIT( SIGNAL_T *ref, MUTEX_T *mu, time_d timeout );
-
-
-/*---=== Threading ===---
-*/
-
-#define THREAD_PRIO_DEFAULT (-999)
-
-#if THREADAPI == THREADAPI_WINDOWS
-
-    typedef HANDLE THREAD_T;
-#       define THREAD_ISNULL( _h) (_h == 0)
-    void THREAD_CREATE( THREAD_T* ref, THREAD_RETURN_T (__stdcall *func)( void*), void* data, int prio /* -3..+3 */);
-
-#       define THREAD_PRIO_MIN (-3)
-#       define THREAD_PRIO_MAX (+3)
-
-#       define THREAD_CLEANUP_PUSH( cb_, val_)
-#       define THREAD_CLEANUP_POP( execute_)
+static constexpr int THREAD_PRIO_MIN{ -3 };
+static constexpr int THREAD_PRIO_MAX{ +3 };
 
+// ##################################################################################################
+// ##################################################################################################
 #else // THREADAPI == THREADAPI_PTHREAD
+// ##################################################################################################
+// ##################################################################################################
 
-    /* Platforms that have a timed 'pthread_join()' can get away with a simpler
-     * implementation. Others will use a condition variable.
-     */
-#       if defined __WINPTHREADS_VERSION
-//#             define USE_PTHREAD_TIMEDJOIN
-#       endif // __WINPTHREADS_VERSION
-
-# ifdef USE_PTHREAD_TIMEDJOIN
-#  ifdef PLATFORM_OSX
-#   error "No 'pthread_timedjoin()' on this system"
-#  else
-    /* Linux, ... */
-#   define PTHREAD_TIMEDJOIN pthread_timedjoin_np
-#  endif
-# endif
-
-    typedef pthread_t THREAD_T;
-#       define THREAD_ISNULL( _h) 0 // pthread_t may be a structure: never 'null' by itself
-
-    void THREAD_CREATE( THREAD_T* ref, THREAD_RETURN_T (*func)( void*), void* data, int prio /* -3..+3 */);
+// PThread (Linux, OS X, ...)
 
-#       if defined(PLATFORM_LINUX)
-        extern volatile bool_t sudo;
-#               ifdef LINUX_SCHED_RR
-#                       define THREAD_PRIO_MIN (sudo ? -3 : 0)
-#               else
-#                       define THREAD_PRIO_MIN (0)
-#               endif
-#               define THREAD_PRIO_MAX (sudo ? +3 : 0)
-#       else
-#               define THREAD_PRIO_MIN (-3)
-#               define THREAD_PRIO_MAX (+3)
-#       endif
-
-#       if THREADWAIT_METHOD == THREADWAIT_CONDVAR
-#               define THREAD_CLEANUP_PUSH( cb_, val_) pthread_cleanup_push( cb_, val_)
-#               define THREAD_CLEANUP_POP( execute_) pthread_cleanup_pop( execute_)
-#       else
-#               define THREAD_CLEANUP_PUSH( cb_, val_) {
-#               define THREAD_CLEANUP_POP( execute_) }
-#       endif // THREADWAIT_METHOD == THREADWAIT_CONDVAR
-#endif // THREADAPI == THREADAPI_WINDOWS
-
-/*
-* Win32 and PTHREAD_TIMEDJOIN allow waiting for a thread with a timeout.
-* Posix without PTHREAD_TIMEDJOIN needs to use a condition variable approach.
-*/
-#define THREADWAIT_TIMEOUT 1
-#define THREADWAIT_CONDVAR 2
-
-#if THREADAPI == THREADAPI_WINDOWS || (defined PTHREAD_TIMEDJOIN)
-#define THREADWAIT_METHOD THREADWAIT_TIMEOUT
-#else // THREADAPI == THREADAPI_WINDOWS || (defined PTHREAD_TIMEDJOIN)
-#define THREADWAIT_METHOD THREADWAIT_CONDVAR
-#endif // THREADAPI == THREADAPI_WINDOWS || (defined PTHREAD_TIMEDJOIN)
+// looks like some MinGW installations don't support PTW32_INCLUDE_WINDOWS_H, so let's include it ourselves, just in case
+#if defined(PLATFORM_WIN32)
+#include <windows.h>
+#endif // PLATFORM_WIN32
+#include <pthread.h>
 
+#if defined(PLATFORM_LINUX) && !defined(LINUX_SCHED_RR)
+static constexpr int THREAD_PRIO_MIN{ 0 };
+#else
+static constexpr int THREAD_PRIO_MIN{ -3 };
+#endif
+static constexpr int THREAD_PRIO_MAX{ +3 };
 
-#if THREADWAIT_METHOD == THREADWAIT_TIMEOUT
-bool_t THREAD_WAIT_IMPL( THREAD_T *ref, double secs);
-#define THREAD_WAIT( a, b, c, d, e) THREAD_WAIT_IMPL( a, b)
-#else // THREADWAIT_METHOD == THREADWAIT_CONDVAR
-bool_t THREAD_WAIT_IMPL( THREAD_T *ref, double secs, SIGNAL_T *signal_ref, MUTEX_T *mu_ref, volatile enum e_status *st_ref);
-#define THREAD_WAIT THREAD_WAIT_IMPL
-#endif // // THREADWAIT_METHOD == THREADWAIT_CONDVAR
+#endif // THREADAPI == THREADAPI_PTHREAD
+// ##################################################################################################
+// ##################################################################################################
 
-void THREAD_KILL( THREAD_T* ref);
-void THREAD_SETNAME( char const* _name);
-void THREAD_MAKE_ASYNCH_CANCELLABLE();
-void THREAD_SET_PRIORITY( int prio);
-void THREAD_SET_AFFINITY( unsigned int aff);
+void THREAD_SETNAME(char const* _name);
+void THREAD_SET_PRIORITY(int prio_, bool sudo_);
+void THREAD_SET_AFFINITY(unsigned int aff);
 
-#endif // __threading_h__
+void JTHREAD_SET_PRIORITY(std::jthread& thread_, int prio_, bool sudo_);
diff --git a/src/threading_osx.h b/src/threading_osx.h
index 93da8c3..f4d41e0 100644
--- a/src/threading_osx.h
+++ b/src/threading_osx.h
@@ -2,8 +2,7 @@
  * THREADING_OSX.H
  * http://yyshen.github.io/2015/01/18/binding_threads_to_cores_osx.html
  */
-#ifndef __threading_osx_h__
-#define __threading_osx_h__ 1
+#pragma once
 
 #include <mach/mach_types.h>
 #include <mach/thread_act.h>
@@ -11,15 +10,16 @@
 
 #define SYSCTL_CORE_COUNT "machdep.cpu.core_count"
 
-typedef struct cpu_set {
+struct cpu_set_t
+{
         uint32_t count;
-} cpu_set_t;
+} ;
 
 static inline void CPU_ZERO(cpu_set_t *cs) { cs->count = 0; }
 static inline void CPU_SET(int num, cpu_set_t *cs) { cs->count |= (1 << num); }
-static inline int CPU_ISSET(int num, cpu_set_t *cs) { return (cs->count & (1 << num)); }
+[[nodiscard]] static inline int CPU_ISSET(int num, cpu_set_t *cs) { return (cs->count & (1 << num)); }
 
-int sched_getaffinity(pid_t pid, size_t cpu_size, cpu_set_t *cpu_set)
+[[nodiscard]] int sched_getaffinity(pid_t pid, size_t cpu_size, cpu_set_t *cpu_set)
 {
         int32_t core_count = 0;
         size_t  len = sizeof(core_count);
@@ -38,7 +38,7 @@ int sched_getaffinity(pid_t pid, size_t cpu_size, cpu_set_t *cpu_set)
         return 0;
 }
 
-int pthread_setaffinity_np(pthread_t thread, size_t cpu_size, cpu_set_t *cpu_set)
+[[nodiscard]] int pthread_setaffinity_np(pthread_t thread, size_t cpu_size, cpu_set_t *cpu_set)
 {
         thread_port_t mach_thread;
         int core = 0;
@@ -56,4 +56,3 @@ int pthread_setaffinity_np(pthread_t thread, size_t cpu_size, cpu_set_t *cpu_set
         return 0;
 }
 
-#endif
diff --git a/src/tools.c b/src/tools.cpp
index c43d8a2..a0a3018 100644
--- a/src/tools.c
+++ b/src/tools.cpp
@@ -31,24 +31,12 @@ THE SOFTWARE.
 ===============================================================================
 */
 
-#include <stdio.h>
-#include <assert.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdlib.h>
-#if !defined(__APPLE__)
-#include <malloc.h>
-#endif // __APPLE__
-
 #include "tools.h"
-#include "compat.h"
+
 #include "universe.h"
-#include "keeper.h"
-#include "lanes.h"
-#include "uniquekey.h"
 
 // functions implemented in deep.c
-extern bool_t copydeep( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State* L, uint_t i, LookupMode mode_, char const* upName_);
+extern bool copydeep(Universe* U, Dest L2, int L2_cache_i, Source L, int i, LookupMode mode_, char const* upName_);
 extern void push_registry_subtable( lua_State* L, UniqueKey key_);
 
 DEBUGSPEW_CODE( char const* debugspew_indent = "----+----!----+----!----+----!----+----!----+----!----+----!----+----!----+");
@@ -61,32 +49,32 @@ DEBUGSPEW_CODE( char const* debugspew_indent = "----+----!----+----!----+----!--
  */
 void push_registry_subtable_mode( lua_State* L, UniqueKey key_, const char* mode_)
 {
-  STACK_GROW( L, 3);
-  STACK_CHECK( L, 0);
-
-  REGISTRY_GET( L, key_);                               // {}|nil
-  STACK_MID( L, 1);
-
-  if( lua_isnil( L, -1))
-  {
-    lua_pop( L, 1);                                     //
-    lua_newtable( L);                                   // {}
-    // _R[key_] = {}
-    REGISTRY_SET( L, key_, lua_pushvalue( L, -2));      // {}
-    STACK_MID( L, 1);
-
-    // Set its metatable if requested
-    if( mode_)
-    {
-      lua_newtable( L);                                 // {} mt
-      lua_pushliteral( L, "__mode");                    // {} mt "__mode"
-      lua_pushstring( L, mode_);                        // {} mt "__mode" mode
-      lua_rawset( L, -3);                               // {} mt
-      lua_setmetatable( L, -2);                         // {}
-    }
-  }
-  STACK_END( L, 1);
-  ASSERT_L( lua_istable( L, -1));
+    STACK_GROW(L, 3);
+    STACK_CHECK_START_REL(L, 0);
+
+    key_.pushValue(L);                                                    // {}|nil
+    STACK_CHECK(L, 1);
+
+    if (lua_isnil(L, -1))
+    {
+        lua_pop(L, 1);                                                    //
+        lua_newtable(L);                                                  // {}
+        // _R[key_] = {}
+        key_.setValue(L, [](lua_State* L) { lua_pushvalue(L, -2); });     // {}
+        STACK_CHECK(L, 1);
+
+        // Set its metatable if requested
+        if (mode_)
+        {
+            lua_newtable(L);                                              // {} mt
+            lua_pushliteral(L, "__mode");                                 // {} mt "__mode"
+            lua_pushstring(L, mode_);                                     // {} mt "__mode" mode
+            lua_rawset(L, -3);                                            // {} mt
+            lua_setmetatable(L, -2);                                      // {}
+        }
+    }
+    STACK_CHECK(L, 1);
+    ASSERT_L(lua_istable(L, -1));
 }
 
 // ################################################################################################
@@ -97,7 +85,7 @@ void push_registry_subtable_mode( lua_State* L, UniqueKey key_, const char* mode
  */
 void push_registry_subtable( lua_State* L, UniqueKey key_)
 {
-  push_registry_subtable_mode( L, key_, NULL);
+  push_registry_subtable_mode(L, key_, nullptr);
 }
 
 // ################################################################################################
@@ -116,7 +104,7 @@ void luaG_dump( lua_State* L)
 
     for( i = 1; i <= top; ++ i)
     {
-        int type = lua_type( L, i);
+        LuaType type{ lua_type_as_enum(L, i) };
 
         fprintf( stderr, "\t[%d]= (%s) ", i, lua_typename( L, type));
 
@@ -125,7 +113,7 @@ void luaG_dump( lua_State* L)
         // Note: this requires 'tostring()' to be defined. If it is NOT,
         //       enable it for more debugging.
         //
-        STACK_CHECK( L, 0);
+        STACK_CHECK_START_REL(L, 0);
         STACK_GROW( L, 2);
 
         lua_getglobal( L, "tostring");
@@ -146,7 +134,7 @@ void luaG_dump( lua_State* L)
             fprintf( stderr, "%s", lua_tostring( L, -1));
         }
         lua_pop( L, 1);
-        STACK_END( L, 0);
+        STACK_CHECK( L, 0);
         fprintf( stderr, "\n");
     }
     fprintf( stderr, "\n");
@@ -156,122 +144,97 @@ void luaG_dump( lua_State* L)
 // ################################################################################################
 
 // same as PUC-Lua l_alloc
-static void* libc_lua_Alloc(void* ud, void* ptr, size_t osize, size_t nsize)
+extern "C" [[nodiscard]] static void* libc_lua_Alloc([[maybe_unused]] void* ud, [[maybe_unused]] void* ptr_, [[maybe_unused]] size_t osize_, size_t nsize_)
 {
-    (void)ud; (void)osize;  /* not used */
-    if (nsize == 0)
+    if (nsize_ == 0)
     {
-        free(ptr);
-        return NULL;
+        free(ptr_);
+        return nullptr;
     }
     else
     {
-        return realloc(ptr, nsize);
+        return realloc(ptr_, nsize_);
     }
 }
 
-static void* protected_lua_Alloc( void *ud, void *ptr, size_t osize, size_t nsize)
-{
-    void* p;
-    ProtectedAllocator* s = (ProtectedAllocator*) ud;
-    MUTEX_LOCK( &s->lock);
-    p = s->definition.allocF( s->definition.allocUD, ptr, osize, nsize);
-    MUTEX_UNLOCK( &s->lock);
-    return p;
-}
+// #################################################################################################
 
-static int luaG_provide_protected_allocator( lua_State* L)
+[[nodiscard]] static int luaG_provide_protected_allocator(lua_State* L)
 {
-    Universe* U = universe_get( L);
-    AllocatorDefinition* const def = lua_newuserdatauv( L, sizeof(AllocatorDefinition), 0);
-    def->allocF = protected_lua_Alloc;
-    def->allocUD = &U->protected_allocator;
+    Universe* const U{ universe_get(L) };
+    // push a new full userdata on the stack, giving access to the universe's protected allocator
+    [[maybe_unused]] AllocatorDefinition* const def{ new (L) AllocatorDefinition{ U->protected_allocator.makeDefinition() } };
     return 1;
 }
 
+// #################################################################################################
+
 // called once at the creation of the universe (therefore L is the master Lua state everything originates from)
 // Do I need to disable this when compiling for LuaJIT to prevent issues?
-void initialize_allocator_function( Universe* U, lua_State* L)
+void initialize_allocator_function(Universe* U, lua_State* L)
 {
-    STACK_CHECK( L, 0);
-    lua_getfield( L, -1, "allocator");                      // settings allocator|nil|"protected"
-    if( !lua_isnil( L, -1))
+    STACK_CHECK_START_REL(L, 1);                            // settings
+    lua_getfield(L, -1, "allocator");                       // settings allocator|nil|"protected"
+    if (!lua_isnil(L, -1))
     {
         // store C function pointer in an internal variable
-        U->provide_allocator = lua_tocfunction( L, -1);     // settings allocator
-        if( U->provide_allocator != NULL)
+        U->provide_allocator = lua_tocfunction(L, -1);      // settings allocator
+        if (U->provide_allocator != nullptr)
         {
             // make sure the function doesn't have upvalues
-            char const* upname = lua_getupvalue( L, -1, 1); // settings allocator upval?
-            if( upname != NULL) // should be "" for C functions with upvalues if any
+            char const* upname = lua_getupvalue(L, -1, 1);  // settings allocator upval?
+            if (upname != nullptr) // should be "" for C functions with upvalues if any
             {
-                (void) luaL_error( L, "config.allocator() shouldn't have upvalues");
+                (void) luaL_error(L, "config.allocator() shouldn't have upvalues");
             }
             // remove this C function from the config table so that it doesn't cause problems
             // when we transfer the config table in newly created Lua states
-            lua_pushnil( L);                                // settings allocator nil
-            lua_setfield( L, -3, "allocator");              // settings allocator
+            lua_pushnil(L);                                 // settings allocator nil
+            lua_setfield(L, -3, "allocator");               // settings allocator
         }
-        else if( lua_type( L, -1) == LUA_TSTRING) // should be "protected"
+        else if (lua_type(L, -1) == LUA_TSTRING) // should be "protected"
         {
-            // initialize all we need for the protected allocator
-            MUTEX_INIT( &U->protected_allocator.lock); // the mutex
-            // and the original allocator to call from inside protection by the mutex
-            U->protected_allocator.definition.allocF = lua_getallocf( L, &U->protected_allocator.definition.allocUD);
+            ASSERT_L(strcmp(lua_tostring(L, -1), "protected") == 0);
+            // set the original allocator to call from inside protection by the mutex
+            U->protected_allocator.initFrom(L);
+            U->protected_allocator.installIn(L);
             // before a state is created, this function will be called to obtain the allocator
             U->provide_allocator = luaG_provide_protected_allocator;
-
-            lua_setallocf( L, protected_lua_Alloc, &U->protected_allocator);
         }
     }
     else
     {
-        // initialize the mutex even if we are not going to use it, because cleanup_allocator_function will deinitialize it
-        MUTEX_INIT( &U->protected_allocator.lock);
         // just grab whatever allocator was provided to lua_newstate
-        U->protected_allocator.definition.allocF = lua_getallocf( L, &U->protected_allocator.definition.allocUD);
+        U->protected_allocator.initFrom(L);
     }
-    lua_pop( L, 1);                                         // settings
-    STACK_MID(L, 0);
+    lua_pop(L, 1);                                          // settings
+    STACK_CHECK(L, 1);
 
-    lua_getfield( L, -1, "internal_allocator");             // settings "libc"|"allocator"
+    lua_getfield(L, -1, "internal_allocator");              // settings "libc"|"allocator"
     {
-        char const* allocator = lua_tostring( L, -1);
+        char const* allocator = lua_tostring(L, -1);
         if (strcmp(allocator, "libc") == 0)
         {
-            U->internal_allocator.allocF = libc_lua_Alloc;
-            U->internal_allocator.allocUD = NULL;
+            U->internal_allocator = AllocatorDefinition{ libc_lua_Alloc, nullptr };
         }
         else if (U->provide_allocator == luaG_provide_protected_allocator)
         {
             // user wants mutex protection on the state's allocator. Use protection for our own allocations too, just in case.
-            U->internal_allocator.allocF = lua_getallocf(L, &U->internal_allocator.allocUD);
+            U->internal_allocator = U->protected_allocator.makeDefinition();
         }
         else
         {
             // no protection required, just use whatever we have as-is.
-            U->internal_allocator = U->protected_allocator.definition;
+            U->internal_allocator = U->protected_allocator;
         }
     }
-    lua_pop( L, 1);                                         // settings
-    STACK_END( L, 0);
-}
-
-void cleanup_allocator_function( Universe* U, lua_State* L)
-{
-    // remove the protected allocator, if any
-    if( U->protected_allocator.definition.allocF != NULL)
-    {
-        // install the non-protected allocator
-        lua_setallocf( L, U->protected_allocator.definition.allocF, U->protected_allocator.definition.allocUD);
-        // release the mutex
-        MUTEX_FREE( &U->protected_allocator.lock);
-    }
+    lua_pop(L, 1);                                          // settings
+    STACK_CHECK(L, 1);
 }
 
 // ################################################################################################
 
-static int dummy_writer( lua_State* L, void const* p, size_t sz, void* ud)
+[[nodiscard]] static int dummy_writer(lua_State* L, void const* p, size_t sz, void* ud)
 {
     (void)L; (void)p; (void)sz; (void) ud; // unused
     return 666;
@@ -287,18 +250,18 @@ static int dummy_writer( lua_State* L, void const* p, size_t sz, void* ud)
  * +-----------------+----------+------------+----------+
  * | lua_topointer   |          |            |          |
  * +-----------------+----------+------------+----------+
- * | lua_tocfunction |  NULL    |            |  NULL    |
+ * | lua_tocfunction |  nullptr |            |  nullptr |
  * +-----------------+----------+------------+----------+
  * | lua_dump        |  666     |  1         |  1       |
  * +-----------------+----------+------------+----------+
  */
 
-typedef enum
+enum FuncSubType
 {
     FST_Bytecode,
     FST_Native,
     FST_FastJIT
-} FuncSubType;
+} ;
 
 FuncSubType luaG_getfuncsubtype( lua_State *L, int _i)
 {
@@ -316,7 +279,7 @@ FuncSubType luaG_getfuncsubtype( lua_State *L, int _i)
         // the provided writer fails with code 666
         // therefore, anytime we get 666, this means that lua_dump() attempted a dump
         // all other cases mean this is either a C or LuaJIT-fast function
-        dumpres = lua504_dump( L, dummy_writer, NULL, 0);
+        dumpres = lua504_dump(L, dummy_writer, nullptr, 0);
         lua_pop( L, mustpush);
         if( dumpres == 666)
         {
@@ -326,7 +289,9 @@ FuncSubType luaG_getfuncsubtype( lua_State *L, int _i)
     return FST_FastJIT;
 }
 
-static lua_CFunction luaG_tocfunction( lua_State *L, int _i, FuncSubType *_out)
+// #################################################################################################
+
+[[nodiscard]] static lua_CFunction luaG_tocfunction(lua_State* L, int _i, FuncSubType* _out)
 {
     lua_CFunction p = lua_tocfunction( L, _i);
     *_out = luaG_getfuncsubtype( L, _i);
@@ -334,14 +299,16 @@ static lua_CFunction luaG_tocfunction( lua_State *L, int _i, FuncSubType *_out)
 }
 
 // crc64/we of string "LOOKUPCACHE_REGKEY" generated at http://www.nitrxgen.net/hashgen/
-static DECLARE_CONST_UNIQUE_KEY( LOOKUPCACHE_REGKEY, 0x837a68dfc6fcb716);
+static constexpr UniqueKey LOOKUPCACHE_REGKEY{ 0x837a68dfc6fcb716ull };
+
+// #################################################################################################
 
 // inspired from tconcat() in ltablib.c
-static char const* luaG_pushFQN( lua_State* L, int t, int last, size_t* length)
+[[nodiscard]] static char const* luaG_pushFQN(lua_State* L, int t, int last, size_t* length)
 {
     int i = 1;
     luaL_Buffer b;
-    STACK_CHECK( L, 0);
+    STACK_CHECK_START_REL(L, 0);
     // Lua 5.4 pushes &b as light userdata on the stack. be aware of it...
     luaL_buffinit( L, &b);                            // ... {} ... &b?
     for( ; i < last; ++ i)
@@ -357,10 +324,12 @@ static char const* luaG_pushFQN( lua_State* L, int t, int last, size_t* length)
     }
     // &b is popped at that point (-> replaced by the result)
     luaL_pushresult( &b);                             // ... {} ... "<result>"
-    STACK_END( L, 1);
+    STACK_CHECK( L, 1);
     return lua_tolstring( L, -1, length);
 }
 
+// #################################################################################################
+
 /*
  * receives 2 arguments: a name k and an object o
  * add two entries ["fully.qualified.name"] = o
@@ -369,7 +338,7 @@ static char const* luaG_pushFQN( lua_State* L, int t, int last, size_t* length)
  * if we already had an entry of type [o] = ..., replace the name if the new one is shorter
  * pops the processed object from the stack
  */
-static void update_lookup_entry( DEBUGSPEW_PARAM_COMMA( Universe* U) lua_State* L, int _ctx_base, int _depth)
+static void update_lookup_entry(DEBUGSPEW_PARAM_COMMA( Universe* U) lua_State* L, int _ctx_base, int _depth)
 {
     // slot 1 in the stack contains the table that receives everything we found
     int const dest = _ctx_base;
@@ -378,22 +347,22 @@ static void update_lookup_entry( DEBUGSPEW_PARAM_COMMA( Universe* U) lua_State*
 
     size_t prevNameLength, newNameLength;
     char const* prevName;
-    DEBUGSPEW_CODE( char const *newName);
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "update_lookup_entry()\n" INDENT_END));
-    DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
+    DEBUGSPEW_CODE(char const *newName);
+    DEBUGSPEW_CODE(fprintf( stderr, INDENT_BEGIN "update_lookup_entry()\n" INDENT_END));
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
 
-    STACK_CHECK( L, 0);
+    STACK_CHECK_START_REL(L, 0);
     // first, raise an error if the function is already known
     lua_pushvalue( L, -1);                                                                // ... {bfc} k o o
     lua_rawget( L, dest);                                                                 // ... {bfc} k o name?
-    prevName = lua_tolstring( L, -1, &prevNameLength); // NULL if we got nil (first encounter of this object)
+    prevName = lua_tolstring( L, -1, &prevNameLength); // nullptr if we got nil (first encounter of this object)
     // push name in fqn stack (note that concatenation will crash if name is a not string or a number)
     lua_pushvalue( L, -3);                                                                // ... {bfc} k o name? k
     ASSERT_L( lua_type( L, -1) == LUA_TNUMBER || lua_type( L, -1) == LUA_TSTRING);
     ++ _depth;
     lua_rawseti( L, fqn, _depth);                                                         // ... {bfc} k o name?
     // generate name
-    DEBUGSPEW_CODE( newName =) luaG_pushFQN( L, fqn, _depth, &newNameLength);             // ... {bfc} k o name? "f.q.n"
+    DEBUGSPEW_OR_NOT(newName, std::ignore) = luaG_pushFQN(L, fqn, _depth, &newNameLength);// ... {bfc} k o name? "f.q.n"
     // Lua 5.2 introduced a hash randomizer seed which causes table iteration to yield a different key order
     // on different VMs even when the tables are populated the exact same way.
     // When Lua is built with compatibility options (such as LUA_COMPAT_ALL),
@@ -403,7 +372,7 @@ static void update_lookup_entry( DEBUGSPEW_PARAM_COMMA( Universe* U) lua_State*
     // Also, nothing prevents any external module from exposing a given object under several names, so...
     // Therefore, when we encounter an object for which a name was previously registered, we need to select the names
     // based on some sorting order so that we end up with the same name in all databases whatever order the table walk yielded
-    if( prevName != NULL && (prevNameLength < newNameLength || lua_lessthan( L, -2, -1)))
+    if (prevName != nullptr && (prevNameLength < newNameLength || lua_lessthan(L, -2, -1)))
     {
         DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "%s '%s' remained named '%s'\n" INDENT_END, lua_typename( L, lua_type( L, -3)), newName, prevName));
         // the previous name is 'smaller' than the one we just generated: keep it!
@@ -439,11 +408,13 @@ static void update_lookup_entry( DEBUGSPEW_PARAM_COMMA( Universe* U) lua_State*
         lua_rawseti( L, fqn, _depth);                                                       // ... {bfc} k
     }
     -- _depth;
-    STACK_END( L, -1);
-    DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
+    STACK_CHECK(L, -1);
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
 }
 
-static void populate_func_lookup_table_recur( DEBUGSPEW_PARAM_COMMA( Universe* U) lua_State* L, int _ctx_base, int _i, int _depth)
+// #################################################################################################
+
+static void populate_func_lookup_table_recur(DEBUGSPEW_PARAM_COMMA(Universe* U) lua_State* L, int _ctx_base, int _i, int _depth)
 {
     lua_Integer visit_count;
     // slot 2 contains a table that, when concatenated, produces the fully qualified name of scanned elements in the table provided at slot _i
@@ -452,18 +423,18 @@ static void populate_func_lookup_table_recur( DEBUGSPEW_PARAM_COMMA( Universe* U
     int const cache = _ctx_base + 2;
     // we need to remember subtables to process them after functions encountered at the current depth (breadth-first search)
     int const breadth_first_cache = lua_gettop( L) + 1;
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "populate_func_lookup_table_recur()\n" INDENT_END));
-    DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
+    DEBUGSPEW_CODE(fprintf( stderr, INDENT_BEGIN "populate_func_lookup_table_recur()\n" INDENT_END));
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
 
     STACK_GROW( L, 6);
     // slot _i contains a table where we search for functions (or a full userdata with a metatable)
-    STACK_CHECK( L, 0);                                                                       // ... {_i}
+    STACK_CHECK_START_REL(L, 0);                                                              // ... {_i}
 
     // if object is a userdata, replace it by its metatable
     if( lua_type( L, _i) == LUA_TUSERDATA)
     {
-        lua_getmetatable( L, _i);                                                               // ... {_i} mt
-        lua_replace( L, _i);                                                                    // ... {_i}
+        lua_getmetatable( L, _i);                                                             // ... {_i} mt
+        lua_replace( L, _i);                                                                  // ... {_i}
     }
 
     // if table is already visited, we are done
@@ -471,11 +442,11 @@ static void populate_func_lookup_table_recur( DEBUGSPEW_PARAM_COMMA( Universe* U
     lua_rawget( L, cache);                                                                    // ... {_i} nil|n
     visit_count = lua_tointeger( L, -1); // 0 if nil, else n
     lua_pop( L, 1);                                                                           // ... {_i}
-    STACK_MID( L, 0);
+    STACK_CHECK( L, 0);
     if( visit_count > 0)
     {
-        DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "already visited\n" INDENT_END));
-        DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
+        DEBUGSPEW_CODE(fprintf( stderr, INDENT_BEGIN "already visited\n" INDENT_END));
+        DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
         return;
     }
 
@@ -483,7 +454,7 @@ static void populate_func_lookup_table_recur( DEBUGSPEW_PARAM_COMMA( Universe* U
     lua_pushvalue( L, _i);                                                                    // ... {_i} {}
     lua_pushinteger( L, visit_count + 1);                                                     // ... {_i} {} 1
     lua_rawset( L, cache);                                                                    // ... {_i}
-    STACK_MID( L, 0);
+    STACK_CHECK( L, 0);
 
     // this table is at breadth_first_cache index
     lua_newtable( L);                                                                         // ... {_i} {bfc}
@@ -521,7 +492,7 @@ static void populate_func_lookup_table_recur( DEBUGSPEW_PARAM_COMMA( Universe* U
         {
             lua_pop( L, 1);                                                                       // ... {_i} {bfc} k
         }
-        STACK_MID( L, 2);
+        STACK_CHECK( L, 2);
     }
     // now process the tables we encountered at that depth
     ++ _depth;
@@ -530,7 +501,7 @@ static void populate_func_lookup_table_recur( DEBUGSPEW_PARAM_COMMA( Universe* U
     {
         DEBUGSPEW_CODE( char const* key = (lua_type( L, -2) == LUA_TSTRING) ? lua_tostring( L, -2) : "not a string");
         DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "table '%s'\n" INDENT_END, key));
-        DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
+        DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
         // un-visit this table in case we do need to process it
         lua_pushvalue( L, -1);                                                                  // ... {_i} {bfc} k {} {}
         lua_rawget( L, cache);                                                                  // ... {_i} {bfc} k {} n
@@ -552,8 +523,8 @@ static void populate_func_lookup_table_recur( DEBUGSPEW_PARAM_COMMA( Universe* U
         lua_rawseti( L, fqn, _depth);                                                           // ... {_i} {bfc} k {}
         populate_func_lookup_table_recur( DEBUGSPEW_PARAM_COMMA( U) L, _ctx_base, lua_gettop( L), _depth);
         lua_pop( L, 1);                                                                         // ... {_i} {bfc} k
-        STACK_MID( L, 2);
-        DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
+        STACK_CHECK( L, 2);
+        DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
     }
     // remove table name from fqn stack
     lua_pushnil( L);                                                                          // ... {_i} {bfc} nil
@@ -561,30 +532,32 @@ static void populate_func_lookup_table_recur( DEBUGSPEW_PARAM_COMMA( Universe* U
     -- _depth;
     // we are done with our cache
     lua_pop( L, 1);                                                                           // ... {_i}
-    STACK_END( L, 0);
+    STACK_CHECK( L, 0);
     // we are done                                                                            // ... {_i} {bfc}
-    DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
 }
 
+// #################################################################################################
+
 /*
  * create a "fully.qualified.name" <-> function equivalence database
  */
-void populate_func_lookup_table( lua_State* L, int _i, char const* name_)
+void populate_func_lookup_table(lua_State* L, int i_, char const* name_)
 {
-    int const ctx_base = lua_gettop( L) + 1;
-    int const in_base = lua_absindex( L, _i);
+    int const ctx_base = lua_gettop(L) + 1;
+    int const in_base = lua_absindex(L, i_);
     int start_depth = 0;
     DEBUGSPEW_CODE( Universe* U = universe_get( L));
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "%p: populate_func_lookup_table('%s')\n" INDENT_END, L, name_ ? name_ : "NULL"));
-    DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
+    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "%p: populate_func_lookup_table('%s')\n" INDENT_END, L, name_ ? name_ : "nullptr"));
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
     STACK_GROW( L, 3);
-    STACK_CHECK( L, 0);
-    REGISTRY_GET( L, LOOKUP_REGKEY);                                               // {}
-    STACK_MID( L, 1);
+    STACK_CHECK_START_REL(L, 0);
+    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
     {
-        name_ = name_ ? name_ : "NULL";
+        name_ = name_ ? name_ : "nullptr";
         lua_pushvalue( L, in_base);                                                  // {} f
         lua_pushstring( L, name_);                                                   // {} f _name
         lua_rawset( L, -3);                                                          // {}
@@ -595,10 +568,10 @@ 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_MID( L, 2);
+            STACK_CHECK( L, 2);
             lua_pushstring( L, name_);                                                 // {} {fqn} "name"
             // generate a name, and if we already had one name, keep whichever is the shorter
             lua_pushvalue( L, in_base);                                           // {} {fqn} "name" t
@@ -606,16 +579,16 @@ void populate_func_lookup_table( lua_State* L, int _i, char const* name_)
             // don't forget to store the name at the bottom of the fqn stack
             ++ start_depth;
             lua_rawseti( L, -2, start_depth);                                          // {} {fqn}
-            STACK_MID( L, 2);
+            STACK_CHECK( L, 2);
         }
         // retrieve the cache, create it if we haven't done it yet
-        REGISTRY_GET( L, LOOKUPCACHE_REGKEY);                                        // {} {fqn} {cache}?
+        LOOKUPCACHE_REGKEY.pushValue(L);                                               // {} {fqn} {cache}?
         if( lua_isnil( L, -1))
         {
             lua_pop( L, 1);                                                            // {} {fqn}
             lua_newtable( L);                                                          // {} {fqn} {cache}
-            REGISTRY_SET( L, LOOKUPCACHE_REGKEY, lua_pushvalue( L, -2));
-            STACK_MID( L, 3);
+            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
         populate_func_lookup_table_recur( DEBUGSPEW_PARAM_COMMA( U) L, ctx_base, in_base, start_depth);
@@ -626,19 +599,21 @@ void populate_func_lookup_table( lua_State* L, int _i, char const* name_)
         lua_pop( L, 1);                                                         //
         (void) luaL_error( L, "unsupported module type %s", lua_typename( L, lua_type( L, in_base)));
     }
-    STACK_END( L, 0);
-    DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
+    STACK_CHECK( L, 0);
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
 }
 
+// #################################################################################################
+
 /*---=== Inter-state copying ===---*/
 
 // crc64/we of string "REG_MTID" generated at http://www.nitrxgen.net/hashgen/
-static DECLARE_CONST_UNIQUE_KEY( REG_MTID, 0x2e68f9b4751584dc);
+static constexpr UniqueKey REG_MTID{ 0x2e68f9b4751584dcull };
 
 /*
 * Get a unique ID for metatable at [i].
 */
-static lua_Integer get_mt_id( Universe* U, lua_State* L, int i)
+[[nodiscard]] static lua_Integer get_mt_id(Universe* U, lua_State* L, int i)
 {
     lua_Integer id;
 
@@ -646,20 +621,18 @@ static lua_Integer get_mt_id( Universe* U, lua_State* L, int i)
 
     STACK_GROW( L, 3);
 
-    STACK_CHECK( L, 0);
+    STACK_CHECK_START_REL(L, 0);
     push_registry_subtable( L, REG_MTID);        // ... _R[REG_MTID]
     lua_pushvalue( L, i);                        // ... _R[REG_MTID] {mt}
     lua_rawget( L, -2);                          // ... _R[REG_MTID] mtk?
 
-    id = lua_tointeger( L, -1);    // 0 for nil
+    id = lua_tointeger( L, -1); // 0 for nil
     lua_pop( L, 1);                              // ... _R[REG_MTID]
-    STACK_MID( L, 1);
+    STACK_CHECK( L, 1);
 
     if( id == 0)
     {
-        MUTEX_LOCK( &U->mtid_lock);
-        id = ++ U->last_mt_id;
-        MUTEX_UNLOCK( &U->mtid_lock);
+        id = U->next_mt_id.fetch_add(1, std::memory_order_relaxed);
 
         /* Create two-way references: id_uint <-> table
         */
@@ -673,41 +646,48 @@ static lua_Integer get_mt_id( Universe* U, lua_State* L, int i)
     }
     lua_pop( L, 1);                              // ...
 
-    STACK_END( L, 0);
+    STACK_CHECK( L, 0);
 
     return id;
 }
 
+// #################################################################################################
+
 // function sentinel used to transfer native functions from/to keeper states
-static int func_lookup_sentinel( lua_State* L)
+[[nodiscard]] static int func_lookup_sentinel(lua_State* L)
 {
-    return luaL_error( L, "function lookup sentinel for %s, should never be called", lua_tostring( L, lua_upvalueindex( 1)));
+    return luaL_error(L, "function lookup sentinel for %s, should never be called", lua_tostring(L, lua_upvalueindex(1)));
 }
 
+// #################################################################################################
 
 // function sentinel used to transfer native table from/to keeper states
-static int table_lookup_sentinel( lua_State* L)
+[[nodiscard]] static int table_lookup_sentinel(lua_State* L)
 {
-    return luaL_error( L, "table lookup sentinel for %s, should never be called", lua_tostring( L, lua_upvalueindex( 1)));
+    return luaL_error(L, "table lookup sentinel for %s, should never be called", lua_tostring(L, lua_upvalueindex(1)));
 }
 
+// #################################################################################################
+
 // function sentinel used to transfer cloned full userdata from/to keeper states
-static int userdata_clone_sentinel( lua_State* L)
+[[nodiscard]] static int userdata_clone_sentinel(lua_State* L)
 {
-    return luaL_error( L, "userdata clone sentinel for %s, should never be called", lua_tostring( L, lua_upvalueindex( 1)));
+    return luaL_error(L, "userdata clone sentinel for %s, should never be called", lua_tostring(L, lua_upvalueindex(1)));
 }
 
+// #################################################################################################
+
 /*
  * retrieve the name of a function/table in the lookup database
  */
-static char const* find_lookup_name( lua_State* L, uint_t i, LookupMode mode_, char const* upName_, size_t* len_)
+[[nodiscard]] static char const* find_lookup_name(lua_State* L, int i, LookupMode mode_, char const* upName_, size_t* len_)
 {
     DEBUGSPEW_CODE( Universe* const U = universe_get( L));
     char const* fqn;
     ASSERT_L( lua_isfunction( L, i) || lua_istable( L, i));  // ... v ...
-    STACK_CHECK( L, 0);
+    STACK_CHECK_START_REL(L, 0);
     STACK_GROW( L, 3); // up to 3 slots are necessary on error
-    if( mode_ == eLM_FromKeeper)
+    if (mode_ == LookupMode::FromKeeper)
     {
         lua_CFunction f = lua_tocfunction( L, i); // should *always* be func_lookup_sentinel or table_lookup_sentinel!
         if( f == func_lookup_sentinel || f == table_lookup_sentinel || f == userdata_clone_sentinel)
@@ -717,16 +697,16 @@ static char const* find_lookup_name( lua_State* L, uint_t i, LookupMode mode_, c
         else
         {
             // if this is not a sentinel, this is some user-created table we wanted to lookup
-            ASSERT_L( NULL == f && lua_istable( L, i));
-            // push anything that will convert to NULL string
+            ASSERT_L(nullptr == f && lua_istable(L, i));
+            // push anything that will convert to nullptr string
             lua_pushnil( L);                                     // ... v ... nil
         }
     }
     else
     {
         // fetch the name from the source state's lookup table
-        REGISTRY_GET( L, LOOKUP_REGKEY);                       // ... v ... {}
-        STACK_MID( L, 1);
+        LOOKUP_REGKEY.pushValue(L);                            // ... v ... {}
+        STACK_CHECK( L, 1);
         ASSERT_L( lua_istable( L, -1));
         lua_pushvalue( L, i);                                  // ... v ... {} v
         lua_rawget( L, -2);                                    // ... v ... {} "f.q.n"
@@ -734,9 +714,9 @@ static char const* find_lookup_name( lua_State* L, uint_t i, LookupMode mode_, c
     fqn = lua_tolstring( L, -1, len_);
     DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "function [C] %s \n" INDENT_END, fqn));
     // popping doesn't invalidate the pointer since this is an interned string gotten from the lookup database
-    lua_pop( L, (mode_ == eLM_FromKeeper) ? 1 : 2);          // ... v ...
-    STACK_MID( L, 0);
-    if( NULL == fqn && !lua_istable( L, i)) // raise an error if we try to send an unknown function (but not for tables)
+    lua_pop( L, (mode_ == LookupMode::FromKeeper) ? 1 : 2);    // ... v ...
+    STACK_CHECK( L, 0);
+    if (nullptr == fqn && !lua_istable(L, i)) // raise an error if we try to send an unknown function (but not for tables)
     {
         char const *from, *typewhat, *what, *gotchaA, *gotchaB;
         // try to discover the name of the function we want to send
@@ -762,81 +742,83 @@ static char const* find_lookup_name( lua_State* L, uint_t i, LookupMode mode_, c
         }
         (void) luaL_error( L, "%s%s '%s' not found in %s origin transfer database.%s", typewhat, gotchaA, what, from ? from : "main", gotchaB);
         *len_ = 0;
-        return NULL;
+        return nullptr;
     }
-    STACK_END( L, 0);
+    STACK_CHECK( L, 0);
     return fqn;
 }
 
+// #################################################################################################
 
 /*
  * Push a looked-up table, or nothing if we found nothing
  */
-static bool_t lookup_table( lua_State* L2, lua_State* L, uint_t i, LookupMode mode_, char const* upName_)
+[[nodiscard]] static bool lookup_table(Dest L2, Source L, int i, LookupMode mode_, char const* upName_)
 {
     // get the name of the table we want to send
     size_t len;
     char const* fqn = find_lookup_name( L, i, mode_, upName_, &len);
-    if( NULL == fqn) // name not found, it is some user-created table
+    if (nullptr == fqn) // name not found, it is some user-created table
     {
-        return FALSE;
+        return false;
     }
     // push the equivalent table in the destination's stack, retrieved from the lookup table
-    STACK_CHECK( L2, 0);                                     // L                          // L2
+    STACK_CHECK_START_REL(L2, 0);                                // L                       // L2
     STACK_GROW( L2, 3); // up to 3 slots are necessary on error
     switch( mode_)
     {
         default: // shouldn't happen, in theory...
         (void) luaL_error( L, "internal error: unknown lookup mode");
-        return FALSE;
+        return false;
 
-        case eLM_ToKeeper:
+        case LookupMode::ToKeeper:
         // push a sentinel closure that holds the lookup name as upvalue
-        lua_pushlstring( L2, fqn, len);                                                      // "f.q.n"
-        lua_pushcclosure( L2, table_lookup_sentinel, 1);                                     // f
+        lua_pushlstring(L2, fqn, len);                                                      // "f.q.n"
+        lua_pushcclosure(L2, table_lookup_sentinel, 1);                                     // f
         break;
 
-        case eLM_LaneBody:
-        case eLM_FromKeeper:
-        REGISTRY_GET( L2, LOOKUP_REGKEY);                                                    // {}
-        STACK_MID( L2, 1);
-        ASSERT_L( lua_istable( L2, -1));
-        lua_pushlstring( L2, fqn, len);                                                      // {} "f.q.n"
-        lua_rawget( L2, -2);                                                                 // {} t
+        case LookupMode::LaneBody:
+        case LookupMode::FromKeeper:
+        LOOKUP_REGKEY.pushValue(L2);                                                        // {}
+        STACK_CHECK(L2, 1);
+        ASSERT_L(lua_istable(L2, -1));
+        lua_pushlstring(L2, fqn, len);                                                      // {} "f.q.n"
+        lua_rawget(L2, -2);                                                                 // {} t
         // we accept destination lookup failures in the case of transfering the Lanes body function (this will result in the source table being cloned instead)
         // but not when we extract something out of a keeper, as there is nothing to clone!
-        if( lua_isnil( L2, -1) && mode_ == eLM_LaneBody)
+        if (lua_isnil(L2, -1) && mode_ == LookupMode::LaneBody)
         {
-            lua_pop( L2, 2);                                                                   //
-            STACK_MID( L2, 0);
-            return FALSE;
+            lua_pop(L2, 2);                                                                 //
+            STACK_CHECK(L2, 0);
+            return false;
         }
-        else if( !lua_istable( L2, -1))
+        else if( !lua_istable(L2, -1))
         {
             char const* from, *to;
-            lua_getglobal( L, "decoda_name");                    // ... t ... decoda_name
-            from = lua_tostring( L, -1);
-            lua_pop( L, 1);                                      // ... t ...
-            lua_getglobal( L2, "decoda_name");                                                 // {} t decoda_name
+            lua_getglobal(L, "decoda_name");                     // ... t ... decoda_name
+            from = lua_tostring(L, -1);
+            lua_pop(L, 1);                                       // ... t ...
+            lua_getglobal(L2, "decoda_name");                                               // {} t decoda_name
             to = lua_tostring( L2, -1);
-            lua_pop( L2, 1);                                                                   // {} t
-            // when mode_ == eLM_FromKeeper, L is a keeper state and L2 is not, therefore L2 is the state where we want to raise the error
+            lua_pop(L2, 1);                                                                 // {} t
+            // when mode_ == LookupMode::FromKeeper, L is a keeper state and L2 is not, therefore L2 is the state where we want to raise the error
             (void) luaL_error(
-                (mode_ == eLM_FromKeeper) ? L2 : L
+                (mode_ == LookupMode::FromKeeper) ? L2 : L
                 , "INTERNAL ERROR IN %s: table '%s' not found in %s destination transfer database."
                 , from ? from : "main"
                 , fqn
                 , to ? to : "main"
             );
-            return FALSE;
+            return false;
         }
-        lua_remove( L2, -2);                                                                 // t
+        lua_remove(L2, -2);                                                                 // t
         break;
     }
-    STACK_END( L2, 1);
-    return TRUE;
+    STACK_CHECK( L2, 1);
+    return true;
 }
 
+// #################################################################################################
 
 /* 
  * Check if we've already copied the same table from 'L', and
@@ -845,121 +827,121 @@ static bool_t lookup_table( lua_State* L2, lua_State* L, uint_t i, LookupMode mo
  *
  * Always pushes a table to 'L2'.
  *
- * Returns TRUE if the table was cached (no need to fill it!); FALSE if
+ * Returns true if the table was cached (no need to fill it!); false if
  * it's a virgin.
  */
-static bool_t push_cached_table( lua_State* L2, uint_t L2_cache_i, lua_State* L, uint_t i)
+[[nodiscard]] static bool push_cached_table(Dest L2, int L2_cache_i, Source L, int i)
 {
-    bool_t not_found_in_cache;                                                                       // L2
-    void const* p = lua_topointer( L, i);
+    void const* p{ lua_topointer(L, i) };
 
     ASSERT_L( L2_cache_i != 0);
-    STACK_GROW( L2, 3);
-    STACK_CHECK( L2, 0);
+    STACK_GROW( L2, 3);                                                                              // L2
+    STACK_CHECK_START_REL(L2, 0);
 
     // We don't need to use the from state ('L') in ID since the life span
     // is only for the duration of a copy (both states are locked).
     // push a light userdata uniquely representing the table
-    lua_pushlightuserdata( L2, (void*) p);                                                           // ... p
+    lua_pushlightuserdata(L2, const_cast<void*>(p));                                                 // ... p
 
     //fprintf( stderr, "<< ID: %s >>\n", lua_tostring( L2, -1));
 
     lua_rawget( L2, L2_cache_i);                                                                     // ... {cached|nil}
-    not_found_in_cache = lua_isnil( L2, -1);
+    bool const not_found_in_cache{ lua_isnil(L2, -1) };
     if( not_found_in_cache)
     {
         lua_pop( L2, 1);                                                                             // ...
         lua_newtable( L2);                                                                           // ... {}
-        lua_pushlightuserdata( L2, (void*) p);                                                       // ... {} p
+        lua_pushlightuserdata(L2, const_cast<void*>(p));                                             // ... {} p
         lua_pushvalue( L2, -2);                                                                      // ... {} p {}
         lua_rawset( L2, L2_cache_i);                                                                 // ... {}
     }
-    STACK_END( L2, 1);
+    STACK_CHECK( L2, 1);
     ASSERT_L( lua_istable( L2, -1));
     return !not_found_in_cache;
 }
 
+// #################################################################################################
 
 /*
  * Return some name helping to identify an object
  */
-static int discover_object_name_recur( lua_State* L, int shortest_, int depth_)
+[[nodiscard]] static int discover_object_name_recur(lua_State* L, int shortest_, int depth_)
 {
     int const what = 1;                                     // o "r" {c} {fqn} ... {?}
     int const result = 2;
     int const cache = 3;
     int const fqn = 4;
     // no need to scan this table if the name we will discover is longer than one we already know
-    if( shortest_ <= depth_ + 1)
+    if (shortest_ <= depth_ + 1)
     {
         return shortest_;
     }
-    STACK_GROW( L, 3);
-    STACK_CHECK( L, 0);
+    STACK_GROW(L, 3);
+    STACK_CHECK_START_REL(L, 0);
     // stack top contains the table to search in
-    lua_pushvalue( L, -1);                                  // o "r" {c} {fqn} ... {?} {?}
-    lua_rawget( L, cache);                                  // o "r" {c} {fqn} ... {?} nil/1
+    lua_pushvalue(L, -1);                                  // o "r" {c} {fqn} ... {?} {?}
+    lua_rawget(L, cache);                                  // o "r" {c} {fqn} ... {?} nil/1
     // if table is already visited, we are done
-    if( !lua_isnil( L, -1))
+    if( !lua_isnil(L, -1))
     {
-        lua_pop( L, 1);                                       // o "r" {c} {fqn} ... {?}
+        lua_pop(L, 1);                                       // o "r" {c} {fqn} ... {?}
         return shortest_;
     }
     // examined table is not in the cache, add it now
-    lua_pop( L, 1);                                         // o "r" {c} {fqn} ... {?}
-    lua_pushvalue( L, -1);                                  // o "r" {c} {fqn} ... {?} {?}
-    lua_pushinteger( L, 1);                                 // o "r" {c} {fqn} ... {?} {?} 1
-    lua_rawset( L, cache);                                  // o "r" {c} {fqn} ... {?}
+    lua_pop(L, 1);                                         // o "r" {c} {fqn} ... {?}
+    lua_pushvalue(L, -1);                                  // o "r" {c} {fqn} ... {?} {?}
+    lua_pushinteger(L, 1);                                 // o "r" {c} {fqn} ... {?} {?} 1
+    lua_rawset(L, cache);                                  // o "r" {c} {fqn} ... {?}
     // scan table contents
-    lua_pushnil( L);                                        // o "r" {c} {fqn} ... {?} nil
-    while( lua_next( L, -2))                                // o "r" {c} {fqn} ... {?} k v
+    lua_pushnil(L);                                        // o "r" {c} {fqn} ... {?} nil
+    while (lua_next(L, -2))                                // o "r" {c} {fqn} ... {?} k v
     {
-        //char const *const strKey = (lua_type( L, -2) == LUA_TSTRING) ? lua_tostring( L, -2) : NULL; // only for debugging
-        //lua_Number const numKey = (lua_type( L, -2) == LUA_TNUMBER) ? lua_tonumber( L, -2) : -6666; // only for debugging
-        STACK_MID( L, 2);
+        //char const *const strKey = (lua_type(L, -2) == LUA_TSTRING) ? lua_tostring(L, -2) : nullptr; // only for debugging
+        //lua_Number const numKey = (lua_type(L, -2) == LUA_TNUMBER) ? lua_tonumber(L, -2) : -6666; // only for debugging
+        STACK_CHECK(L, 2);
         // append key name to fqn stack
         ++ depth_;
-        lua_pushvalue( L, -2);                                // o "r" {c} {fqn} ... {?} k v k
-        lua_rawseti( L, fqn, depth_);                         // o "r" {c} {fqn} ... {?} k v
-        if( lua_rawequal( L, -1, what)) // is it what we are looking for?
+        lua_pushvalue(L, -2);                                // o "r" {c} {fqn} ... {?} k v k
+        lua_rawseti(L, fqn, depth_);                         // o "r" {c} {fqn} ... {?} k v
+        if (lua_rawequal(L, -1, what)) // is it what we are looking for?
         {
-            STACK_MID( L, 2);
+            STACK_CHECK(L, 2);
             // update shortest name
             if( depth_ < shortest_)
             {
                 shortest_ = depth_;
-                luaG_pushFQN( L, fqn, depth_, NULL);              // o "r" {c} {fqn} ... {?} k v "fqn"
-                lua_replace( L, result);                          // o "r" {c} {fqn} ... {?} k v
+                std::ignore = luaG_pushFQN(L, fqn, depth_, nullptr); // o "r" {c} {fqn} ... {?} k v "fqn"
+                lua_replace(L, result);                          // o "r" {c} {fqn} ... {?} k v
             }
             // no need to search further at this level
-            lua_pop( L, 2);                                     // o "r" {c} {fqn} ... {?}
-            STACK_MID( L, 0);
+            lua_pop(L, 2);                                     // o "r" {c} {fqn} ... {?}
+            STACK_CHECK(L, 0);
             break;
         }
-        switch( lua_type( L, -1))                             // o "r" {c} {fqn} ... {?} k v
+        switch (lua_type(L, -1))                             // o "r" {c} {fqn} ... {?} k v
         {
             default: // nil, boolean, light userdata, number and string aren't identifiable
             break;
 
             case LUA_TTABLE:                                    // o "r" {c} {fqn} ... {?} k {}
-            STACK_MID( L, 2);
-            shortest_ = discover_object_name_recur( L, shortest_, depth_);
+            STACK_CHECK(L, 2);
+            shortest_ = discover_object_name_recur(L, shortest_, depth_);
             // search in the table's metatable too
-            if( lua_getmetatable( L, -1))                       // o "r" {c} {fqn} ... {?} k {} {mt}
+            if (lua_getmetatable(L, -1))                       // o "r" {c} {fqn} ... {?} k {} {mt}
             {
-                if( lua_istable( L, -1))
+                if( lua_istable(L, -1))
                 {
                     ++ depth_;
-                    lua_pushliteral( L, "__metatable");             // o "r" {c} {fqn} ... {?} k {} {mt} "__metatable"
-                    lua_rawseti( L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k {} {mt}
-                    shortest_ = discover_object_name_recur( L, shortest_, depth_);
-                    lua_pushnil( L);                                // o "r" {c} {fqn} ... {?} k {} {mt} nil
-                    lua_rawseti( L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k {} {mt}
+                    lua_pushliteral(L, "__metatable");             // o "r" {c} {fqn} ... {?} k {} {mt} "__metatable"
+                    lua_rawseti(L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k {} {mt}
+                    shortest_ = discover_object_name_recur(L, shortest_, depth_);
+                    lua_pushnil(L);                                // o "r" {c} {fqn} ... {?} k {} {mt} nil
+                    lua_rawseti(L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k {} {mt}
                     -- depth_;
                 }
-                lua_pop( L, 1);                                   // o "r" {c} {fqn} ... {?} k {}
+                lua_pop(L, 1);                                   // o "r" {c} {fqn} ... {?} k {}
             }
-            STACK_MID( L, 2);
+            STACK_CHECK(L, 2);
             break;
 
             case LUA_TTHREAD:                                   // o "r" {c} {fqn} ... {?} k T
@@ -967,64 +949,65 @@ static int discover_object_name_recur( lua_State* L, int shortest_, int depth_)
             break;
 
             case LUA_TUSERDATA:                                 // o "r" {c} {fqn} ... {?} k U
-            STACK_MID( L, 2);
+            STACK_CHECK(L, 2);
             // search in the object's metatable (some modules are built that way)
-            if( lua_getmetatable( L, -1))                       // o "r" {c} {fqn} ... {?} k U {mt}
+            if (lua_getmetatable(L, -1))                       // o "r" {c} {fqn} ... {?} k U {mt}
             {
-                if( lua_istable( L, -1))
+                if (lua_istable(L, -1))
                 {
                     ++ depth_;
-                    lua_pushliteral( L, "__metatable");             // o "r" {c} {fqn} ... {?} k U {mt} "__metatable"
-                    lua_rawseti( L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k U {mt}
-                    shortest_ = discover_object_name_recur( L, shortest_, depth_);
-                    lua_pushnil( L);                                // o "r" {c} {fqn} ... {?} k U {mt} nil
-                    lua_rawseti( L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k U {mt}
+                    lua_pushliteral(L, "__metatable");             // o "r" {c} {fqn} ... {?} k U {mt} "__metatable"
+                    lua_rawseti(L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k U {mt}
+                    shortest_ = discover_object_name_recur(L, shortest_, depth_);
+                    lua_pushnil(L);                                // o "r" {c} {fqn} ... {?} k U {mt} nil
+                    lua_rawseti(L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k U {mt}
                     -- depth_;
                 }
-                lua_pop( L, 1);                                   // o "r" {c} {fqn} ... {?} k U
+                lua_pop(L, 1);                                   // o "r" {c} {fqn} ... {?} k U
             }
-            STACK_MID( L, 2);
+            STACK_CHECK(L, 2);
             // search in the object's uservalues
             {
                 int uvi = 1;
-                while( lua_getiuservalue( L, -1, uvi) != LUA_TNONE) // o "r" {c} {fqn} ... {?} k U {u}
+                while (lua_getiuservalue(L, -1, uvi) != LUA_TNONE) // o "r" {c} {fqn} ... {?} k U {u}
                 {
-                    if( lua_istable( L, -1)) // if it is a table, look inside
+                    if( lua_istable(L, -1)) // if it is a table, look inside
                     {
                         ++ depth_;
-                        lua_pushliteral( L, "uservalue");               // o "r" {c} {fqn} ... {?} k v {u} "uservalue"
-                        lua_rawseti( L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k v {u}
-                        shortest_ = discover_object_name_recur( L, shortest_, depth_);
-                        lua_pushnil( L);                                // o "r" {c} {fqn} ... {?} k v {u} nil
-                        lua_rawseti( L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k v {u}
+                        lua_pushliteral(L, "uservalue");               // o "r" {c} {fqn} ... {?} k v {u} "uservalue"
+                        lua_rawseti(L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k v {u}
+                        shortest_ = discover_object_name_recur(L, shortest_, depth_);
+                        lua_pushnil(L);                                // o "r" {c} {fqn} ... {?} k v {u} nil
+                        lua_rawseti(L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k v {u}
                         -- depth_;
                     }
-                    lua_pop( L, 1);                                   // o "r" {c} {fqn} ... {?} k U
+                    lua_pop(L, 1);                                   // o "r" {c} {fqn} ... {?} k U
                     ++ uvi;
                 }
                 // when lua_getiuservalue() returned LUA_TNONE, it pushed a nil. pop it now
-                lua_pop( L, 1);                                     // o "r" {c} {fqn} ... {?} k U
+                lua_pop(L, 1);                                     // o "r" {c} {fqn} ... {?} k U
             }
-            STACK_MID( L, 2);
+            STACK_CHECK(L, 2);
             break;
         }
         // make ready for next iteration
-        lua_pop( L, 1);                                       // o "r" {c} {fqn} ... {?} k
+        lua_pop(L, 1);                                       // o "r" {c} {fqn} ... {?} k
         // remove name from fqn stack
-        lua_pushnil( L);                                      // o "r" {c} {fqn} ... {?} k nil
-        lua_rawseti( L, fqn, depth_);                         // o "r" {c} {fqn} ... {?} k
-        STACK_MID( L, 1);
+        lua_pushnil(L);                                      // o "r" {c} {fqn} ... {?} k nil
+        lua_rawseti(L, fqn, depth_);                         // o "r" {c} {fqn} ... {?} k
+        STACK_CHECK(L, 1);
         -- depth_;
     }                                                       // o "r" {c} {fqn} ... {?}
-    STACK_MID( L, 0);
+    STACK_CHECK(L, 0);
     // remove the visited table from the cache, in case a shorter path to the searched object exists
-    lua_pushvalue( L, -1);                                  // o "r" {c} {fqn} ... {?} {?}
-    lua_pushnil( L);                                        // o "r" {c} {fqn} ... {?} {?} nil
-    lua_rawset( L, cache);                                  // o "r" {c} {fqn} ... {?}
-    STACK_END( L, 0);
+    lua_pushvalue(L, -1);                                  // o "r" {c} {fqn} ... {?} {?}
+    lua_pushnil(L);                                        // o "r" {c} {fqn} ... {?} {?} nil
+    lua_rawset(L, cache);                                  // o "r" {c} {fqn} ... {?}
+    STACK_CHECK(L, 0);
     return shortest_;
 }
 
+// #################################################################################################
 
 /*
  * "type", "name" = lanes.nameof( o)
@@ -1046,7 +1029,7 @@ int luaG_nameof( lua_State* L)
     }
 
     STACK_GROW( L, 4);
-    STACK_CHECK( L, 0);
+    STACK_CHECK_START_REL(L, 0);
     // this slot will contain the shortest name we found when we are done
     lua_pushnil( L);                                        // o nil
     // push a cache that will contain all already visited tables
@@ -1067,23 +1050,24 @@ int luaG_nameof( lua_State* L)
         (void) discover_object_name_recur( L, 6666, 1);
     }
     lua_pop( L, 3);                                         // o "result"
-    STACK_END( L, 1);
+    STACK_CHECK( L, 1);
     lua_pushstring( L, luaL_typename( L, 1));               // o "result" "type"
     lua_replace( L, -3);                                    // "type" "result"
     return 2;
 }
 
+// #################################################################################################
 
 /*
  * Push a looked-up native/LuaJIT function.
  */
-static void lookup_native_func( lua_State* L2, lua_State* L, uint_t i, LookupMode mode_, char const* upName_)
+static void lookup_native_func(lua_State* L2, lua_State* L, int i, LookupMode mode_, char const* upName_)
 {
     // get the name of the function we want to send
     size_t len;
     char const* fqn = find_lookup_name( L, i, mode_, upName_, &len);
     // push the equivalent function in the destination's stack, retrieved from the lookup table
-    STACK_CHECK( L2, 0);                                     // L                          // L2
+    STACK_CHECK_START_REL(L2, 0);                                // L                        // L2
     STACK_GROW( L2, 3); // up to 3 slots are necessary on error
     switch( mode_)
     {
@@ -1091,16 +1075,16 @@ static void lookup_native_func( lua_State* L2, lua_State* L, uint_t i, LookupMod
         (void) luaL_error( L, "internal error: unknown lookup mode");
         return;
 
-        case eLM_ToKeeper:
+        case LookupMode::ToKeeper:
         // push a sentinel closure that holds the lookup name as upvalue
         lua_pushlstring( L2, fqn, len);                                                      // "f.q.n"
         lua_pushcclosure( L2, func_lookup_sentinel, 1);                                      // f
         break;
 
-        case eLM_LaneBody:
-        case eLM_FromKeeper:
-        REGISTRY_GET( L2, LOOKUP_REGKEY);                                                    // {}
-        STACK_MID( L2, 1);
+        case LookupMode::LaneBody:
+        case LookupMode::FromKeeper:
+        LOOKUP_REGKEY.pushValue(L2);                                                         // {}
+        STACK_CHECK( L2, 1);
         ASSERT_L( lua_istable( L2, -1));
         lua_pushlstring( L2, fqn, len);                                                      // {} "f.q.n"
         lua_rawget( L2, -2);                                                                 // {} f
@@ -1115,9 +1099,9 @@ static void lookup_native_func( lua_State* L2, lua_State* L, uint_t i, LookupMod
             lua_getglobal( L2, "decoda_name");                                                 // {} f decoda_name
             to = lua_tostring( L2, -1);
             lua_pop( L2, 1);                                                                   // {} f
-            // when mode_ == eLM_FromKeeper, L is a keeper state and L2 is not, therefore L2 is the state where we want to raise the error
+            // when mode_ == LookupMode::FromKeeper, L is a keeper state and L2 is not, therefore L2 is the state where we want to raise the error
             (void) luaL_error(
-                (mode_ == eLM_FromKeeper) ? L2 : L
+                (mode_ == LookupMode::FromKeeper) ? L2 : L
                 , "%s%s: function '%s' not found in %s destination transfer database."
                 , lua_isnil( L2, -1) ? "" : "INTERNAL ERROR IN "
                 , from ? from : "main"
@@ -1130,13 +1114,13 @@ static void lookup_native_func( lua_State* L2, lua_State* L, uint_t i, LookupMod
         break;
 
         /* keep it in case I need it someday, who knows...
-        case eLM_RawFunctions:
+        case LookupMode::RawFunctions:
         {
             int n;
             char const* upname;
             lua_CFunction f = lua_tocfunction( L, i);
             // copy upvalues
-            for( n = 0; (upname = lua_getupvalue( L, i, 1 + n)) != NULL; ++ n)
+            for( n = 0; (upname = lua_getupvalue( L, i, 1 + n)) != nullptr; ++ n)
             {
                 luaG_inter_move( U, L, L2, 1, mode_);                                            // [up[,up ...]]
             }
@@ -1145,9 +1129,10 @@ static void lookup_native_func( lua_State* L2, lua_State* L, uint_t i, LookupMod
         break;
         */
     }
-    STACK_END( L2, 1);
+    STACK_CHECK( L2, 1);
 }
 
+// #################################################################################################
 
 /*
  * Copy a function over, which has not been found in the cache.
@@ -1171,17 +1156,19 @@ static char const* lua_type_names[] =
 };
 static char const* vt_names[] =
 {
-    "VT_NORMAL"
-    , "VT_KEY"
-    , "VT_METATABLE"
+    "VT::NORMAL"
+    , "VT::KEY"
+    , "VT::METATABLE"
 };
 #endif // USE_DEBUG_SPEW()
 
+// #################################################################################################
+
 // Lua 5.4.3 style of dumping (see lstrlib.c)
 // we have to do it that way because we can't unbalance the stack between buffer operations
 // namely, this means we can't push a function on top of the stack *after* we initialize the buffer!
 // luckily, this also works with earlier Lua versions
-static int buf_writer( lua_State* L, void const* b, size_t size, void* ud)
+[[nodiscard]] static int buf_writer(lua_State* L, void const* b, size_t size, void* ud)
 {
     luaL_Buffer* B = (luaL_Buffer*) ud;
     if( !B->L)
@@ -1192,20 +1179,22 @@ static int buf_writer( lua_State* L, void const* b, size_t size, void* ud)
     return 0;
 }
 
-static void copy_func( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State* L, uint_t i, LookupMode mode_, char const* upName_)
+// #################################################################################################
+
+static void copy_func(Universe* U, Dest L2, int L2_cache_i, Source L, int i, LookupMode mode_, char const* upName_)
 {
     int n, needToPush;
     luaL_Buffer B;
-    B.L = NULL;
+    B.L = nullptr;
 
     ASSERT_L( L2_cache_i != 0);                                                       // ... {cache} ... p
     STACK_GROW( L, 2);
-    STACK_CHECK( L, 0);
+    STACK_CHECK_START_REL(L, 0);
 
 
     // 'lua_dump()' needs the function at top of stack
     // if already on top of the stack, no need to push again
-    needToPush = (i != (uint_t)lua_gettop( L));
+    needToPush = (i != lua_gettop( L));
     if( needToPush)
     {
         lua_pushvalue( L, i);                                // ... f
@@ -1232,7 +1221,7 @@ static void copy_func( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State*
 
     // transfer the bytecode, then the upvalues, to create a similar closure
     {
-        char const* name = NULL;
+        char const* name = nullptr;
 
         #if LOG_FUNC_INFO
         // "To get information about a function you push it onto the 
@@ -1244,7 +1233,7 @@ static void copy_func( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State*
             // fills 'name' 'namewhat' and 'linedefined', pops function
             lua_getinfo( L, ">nS", &ar);                       // ... b
             name = ar.namewhat;
-            fprintf( stderr, INDENT_BEGIN "FNAME: %s @ %d\n", i, s_indent, ar.short_src, ar.linedefined);  // just gives NULL
+            fprintf( stderr, INDENT_BEGIN "FNAME: %s @ %d\n", i, s_indent, ar.short_src, ar.linedefined);  // just gives nullptr
         }
         #endif // LOG_FUNC_INFO
         {
@@ -1276,7 +1265,7 @@ static void copy_func( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State*
             // cache[p] = function
             lua_rawset( L2, L2_cache_i);                                                               // ... {cache} ... function
         }
-        STACK_MID( L, 0);
+        STACK_CHECK( L, 0);
 
         /* push over any upvalues; references to this function will come from
         * cache so we don't end up in eternal loop.
@@ -1291,7 +1280,7 @@ static void copy_func( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State*
             // -> if we encounter an upvalue equal to the global table in the source, bind it to the destination's global table
             lua_pushglobaltable( L);                           // ... _G
 #endif // LUA_VERSION_NUM
-            for( n = 0; (upname = lua_getupvalue( L, i, 1 + n)) != NULL; ++ n)
+            for (n = 0; (upname = lua_getupvalue(L, i, 1 + n)) != nullptr; ++n)
             {                                                  // ... _G up[n]
                 DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "UPNAME[%d]: %s -> " INDENT_END, n, upname));
 #if LUA_VERSION_NUM >= 502
@@ -1304,7 +1293,7 @@ static void copy_func( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State*
 #endif // LUA_VERSION_NUM
                 {
                     DEBUGSPEW_CODE( fprintf( stderr, "copying value\n"));
-                    if( !inter_copy_one( U, L2, L2_cache_i, L, lua_gettop( L), VT_NORMAL, mode_, upname))  // ... {cache} ... function <upvalues>
+                    if( !inter_copy_one( U, L2, L2_cache_i, L, lua_gettop( L), VT::NORMAL, mode_, upname)) // ... {cache} ... function <upvalues>
                     {
                         luaL_error( L, "Cannot copy upvalue type '%s'", luaL_typename( L, -1));
                     }
@@ -1317,7 +1306,7 @@ static void copy_func( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State*
         }
         // L2: function + 'n' upvalues (>=0)
 
-        STACK_MID( L, 0);
+        STACK_CHECK( L, 0);
 
         // Set upvalues (originally set to 'nil' by 'lua_load')
         {
@@ -1335,19 +1324,21 @@ static void copy_func( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State*
             // with the function at the top of the stack                                               // ... {cache} ... function
         }
     }
-    STACK_END( L, 0);
+    STACK_CHECK( L, 0);
 }
 
+// #################################################################################################
+
 /* 
  * Check if we've already copied the same function from 'L', and reuse the old
  * copy.
  *
  * Always pushes a function to 'L2'.
  */
-static void copy_cached_func( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State* L, uint_t i, LookupMode mode_, char const* upName_)
+static void copy_cached_func(Universe* U, Dest L2, int L2_cache_i, Source L, int i, LookupMode mode_, char const* upName_)
 {
     FuncSubType funcSubType;
-    /*lua_CFunction cfunc =*/ luaG_tocfunction( L, i, &funcSubType); // NULL for LuaJIT-fast && bytecode functions
+    std::ignore = luaG_tocfunction(L, i, &funcSubType); // nullptr for LuaJIT-fast && bytecode functions
     if( funcSubType == FST_Bytecode)
     {
         void* const aspointer = (void*)lua_topointer( L, i);
@@ -1358,7 +1349,7 @@ static void copy_cached_func( Universe* U, lua_State* L2, uint_t L2_cache_i, lua
 
         // L2_cache[id_str]= function
         //
-        STACK_CHECK( L2, 0);
+        STACK_CHECK_START_REL(L2, 0);
 
         // We don't need to use the from state ('L') in ID since the life span
         // is only for the duration of a copy (both states are locked).
@@ -1386,7 +1377,7 @@ static void copy_cached_func( Universe* U, lua_State* L2, uint_t L2_cache_i, lua
         {
             lua_remove( L2, -2);                                      // ... {cache} ... function
         }
-        STACK_END( L2, 1);
+        STACK_CHECK( L2, 1);
         ASSERT_L( lua_isfunction( L2, -1));
     }
     else // function is native/LuaJIT: no need to cache
@@ -1397,62 +1388,65 @@ static void copy_cached_func( Universe* U, lua_State* L2, uint_t L2_cache_i, lua
     }
 }
 
-static bool_t push_cached_metatable( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State* L, uint_t i, enum eLookupMode mode_, char const* upName_)
+// #################################################################################################
+
+[[nodiscard]] static bool push_cached_metatable(Universe* U, Dest L2, int L2_cache_i, Source L, int i, LookupMode mode_, char const* upName_)
 {
-    STACK_CHECK( L, 0);
-    if( lua_getmetatable( L, i))                                                 // ... mt
+    STACK_CHECK_START_REL(L, 0);
+    if (!lua_getmetatable(L, i))                                                // ... mt
     {
-        lua_Integer const mt_id = get_mt_id( U, L, -1);    // Unique id for the metatable
+        STACK_CHECK( L, 0);
+        return false;
+    }
+    STACK_CHECK(L, 1);
 
-        STACK_CHECK( L2, 0);
-        STACK_GROW( L2, 4);
-        // do we already know this metatable?
-        push_registry_subtable( L2, REG_MTID);                                                                   // _R[REG_MTID]
-        lua_pushinteger( L2, mt_id);                                                                             // _R[REG_MTID] id
-        lua_rawget( L2, -2);                                                                                     // _R[REG_MTID] mt?
+    lua_Integer const mt_id{ get_mt_id(U, L, -1) }; // Unique id for the metatable
 
-        STACK_MID( L2, 2);
+    STACK_CHECK_START_REL(L2, 0);
+    STACK_GROW(L2, 4);
+    // do we already know this metatable?
+    push_registry_subtable(L2, REG_MTID);                                                               // _R[REG_MTID]
+    lua_pushinteger(L2, mt_id);                                                                         // _R[REG_MTID] id
+    lua_rawget(L2, -2);                                                                                 // _R[REG_MTID] mt|nil
+    STACK_CHECK(L2, 2);
 
-        if( lua_isnil( L2, -1))
-        {   // L2 did not know the metatable
-            lua_pop( L2, 1);                                                                                       // _R[REG_MTID]
-            if( inter_copy_one( U, L2, L2_cache_i, L, lua_gettop( L), VT_METATABLE, mode_, upName_))               // _R[REG_MTID] mt
-            {
-                STACK_MID( L2, 2);
-                // mt_id -> metatable
-                lua_pushinteger( L2, mt_id);                                                                         // _R[REG_MTID] mt id
-                lua_pushvalue( L2, -2);                                                                              // _R[REG_MTID] mt id mt
-                lua_rawset( L2, -4);                                                                                 // _R[REG_MTID] mt
-
-                // metatable -> mt_id
-                lua_pushvalue( L2, -1);                                                                              // _R[REG_MTID] mt mt
-                lua_pushinteger( L2, mt_id);                                                                         // _R[REG_MTID] mt mt id
-                lua_rawset( L2, -4);                                                                                 // _R[REG_MTID] mt
-            }
-            else
-            {
-                (void) luaL_error( L, "Error copying a metatable");
-            }
-            STACK_MID( L2, 2);
+    if (lua_isnil(L2, -1))
+    {   // L2 did not know the metatable
+        lua_pop(L2, 1);                                                                                 // _R[REG_MTID]
+        if (!inter_copy_one(U, L2, L2_cache_i, L, lua_gettop(L), VT::METATABLE, mode_, upName_))        // _R[REG_MTID] mt?
+        {
+            luaL_error(L, "Error copying a metatable"); // doesn't return
         }
-        lua_remove( L2, -2);                                                                                     // mt
 
-        lua_pop( L, 1);                                                            // ...
-        STACK_END( L2, 1);
-        STACK_MID( L, 0);
-        return TRUE;
+        STACK_CHECK(L2, 2);                                                                             // _R[REG_MTID] mt
+        // mt_id -> metatable
+        lua_pushinteger(L2, mt_id);                                                                     // _R[REG_MTID] mt id
+        lua_pushvalue(L2, -2);                                                                          // _R[REG_MTID] mt id mt
+        lua_rawset(L2, -4);                                                                             // _R[REG_MTID] mt
+
+        // metatable -> mt_id
+        lua_pushvalue(L2, -1);                                                                          // _R[REG_MTID] mt mt
+        lua_pushinteger(L2, mt_id);                                                                     // _R[REG_MTID] mt mt id
+        lua_rawset(L2, -4);                                                                             // _R[REG_MTID] mt
+        STACK_CHECK(L2, 2);
     }
-    STACK_END( L, 0);
-    return FALSE;
+    lua_remove(L2, -2);                                                                                 // mt
+
+    lua_pop(L, 1);                                                          // ...
+    STACK_CHECK(L2, 1);
+    STACK_CHECK(L, 0);
+    return true;
 }
 
-static void inter_copy_keyvaluepair( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State* L, enum e_vt vt, LookupMode mode_, char const* upName_)
+// #################################################################################################
+
+[[nodiscard]] static void inter_copy_keyvaluepair(Universe* U, Dest L2, int L2_cache_i, Source L, VT vt_, LookupMode mode_, char const* upName_)
 {
-    uint_t val_i = lua_gettop( L);
-    uint_t key_i = val_i - 1;
+    int val_i = lua_gettop(L);
+    int key_i = val_i - 1;
 
     // Only basic key types are copied over; others ignored
-    if( inter_copy_one( U, L2, L2_cache_i, L, key_i, VT_KEY, mode_, upName_))
+    if (inter_copy_one(U, L2, L2_cache_i, L, key_i, VT::KEY, mode_, upName_))
     {
         char* valPath = (char*) upName_;
         if( U->verboseErrors)
@@ -1465,7 +1459,7 @@ static void inter_copy_keyvaluepair( Universe* U, lua_State* L2, uint_t L2_cache
                 size_t const bufLen = strlen( upName_) + keyRawLen + 2;
                 valPath = (char*) alloca( bufLen);
                 sprintf( valPath, "%s.%*s", upName_, (int) keyRawLen, key);
-                key = NULL;
+                key = nullptr;
             }
 #if defined LUA_LNUM || LUA_VERSION_NUM >= 503
             else if( lua_isinteger( L, key_i))
@@ -1498,51 +1492,53 @@ static void inter_copy_keyvaluepair( Universe* U, lua_State* L2, uint_t L2_cache
         * Contents of metatables are copied with cache checking;
         * important to detect loops.
         */
-        if( inter_copy_one( U, L2, L2_cache_i, L, val_i, VT_NORMAL, mode_, valPath))
+        if (inter_copy_one(U, L2, L2_cache_i, L, val_i, VT::NORMAL, mode_, valPath))
         {
             ASSERT_L( lua_istable( L2, -3));
             lua_rawset( L2, -3);    // add to table (pops key & val)
         }
         else
         {
-            luaL_error( L, "Unable to copy %s entry '%s' because of value is of type '%s'", (vt == VT_NORMAL) ? "table" : "metatable", valPath, luaL_typename( L, val_i));
+            luaL_error(L, "Unable to copy %s entry '%s' because of value is of type '%s'", (vt_ == VT::NORMAL) ? "table" : "metatable", valPath, luaL_typename(L, val_i));
         }
     }
 }
 
+// #################################################################################################
+
 /*
 * The clone cache is a weak valued table listing all clones, indexed by their userdatapointer
 * fnv164 of string "CLONABLES_CACHE_KEY" generated at https://www.pelock.com/products/hash-calculator
 */
-static DECLARE_CONST_UNIQUE_KEY( CLONABLES_CACHE_KEY, 0xD04EE018B3DEE8F5);
+static constexpr UniqueKey CLONABLES_CACHE_KEY{ 0xD04EE018B3DEE8F5ull };
 
-static bool_t copyclone( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State* L, uint_t source_i_, LookupMode mode_, char const* upName_)
+[[nodiscard]] static bool copyclone(Universe* U, Dest L2, int L2_cache_i, Source L, int source_i_, LookupMode mode_, char const* upName_)
 {
     void* const source = lua_touserdata( L, source_i_);
     source_i_ = lua_absindex( L, source_i_);
 
-    STACK_CHECK( L, 0);                                                          // L (source)               // L2 (destination)
-    STACK_CHECK( L2, 0);
+    STACK_CHECK_START_REL(L, 0);                                                 // L (source)               // L2 (destination)
+    STACK_CHECK_START_REL(L2, 0);
 
     // Check if the source was already cloned during this copy
     lua_pushlightuserdata( L2, source);                                                                      // ... source
     lua_rawget( L2, L2_cache_i);                                                                             // ... clone?
     if ( !lua_isnil( L2, -1))
     {
-        STACK_MID( L2, 1);
-        return TRUE;
+        STACK_CHECK( L2, 1);
+        return true;
     }
     else
     {
         lua_pop( L2, 1);                                                                                     // ...
     }
-    STACK_MID( L2, 0);
+    STACK_CHECK( L2, 0);
 
     // no metatable? -> not clonable
     if( !lua_getmetatable( L, source_i_))                                        // ... mt?
     {
-        STACK_MID( L, 0);
-        return FALSE;
+        STACK_CHECK( L, 0);
+        return false;
     }
 
     // no __lanesclone? -> not clonable
@@ -1550,15 +1546,15 @@ static bool_t copyclone( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_Stat
     if( lua_isnil( L, -1))
     {
         lua_pop( L, 2);                                                          // ...
-        STACK_MID( L, 0);
-        return FALSE;
+        STACK_CHECK( L, 0);
+        return false;
     }
 
     // we need to copy over the uservalues of the userdata as well
     {
         int const mt = lua_absindex( L, -2);                                     // ... mt __lanesclone
         size_t const userdata_size = (size_t) lua_rawlen( L, source_i_);
-        void* clone = NULL;
+        void* clone = nullptr;
         // extract all the uservalues, but don't transfer them yet
         int uvi = 0;
         while( lua_getiuservalue( L, source_i_, ++ uvi) != LUA_TNONE) {}         // ... mt __lanesclone [uv]+ nil
@@ -1568,9 +1564,9 @@ static bool_t copyclone( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_Stat
         // create the clone userdata with the required number of uservalue slots
         clone = lua_newuserdatauv( L2, userdata_size, uvi);                                                  // ... u
         // copy the metatable in the target state, and give it to the clone we put there
-        if( inter_copy_one( U, L2, L2_cache_i, L, mt, VT_NORMAL, mode_, upName_))                            // ... u mt|sentinel
+        if (inter_copy_one(U, L2, L2_cache_i, L, mt, VT::NORMAL, mode_, upName_))                            // ... u mt|sentinel
         {
-            if( eLM_ToKeeper == mode_)                                                                       // ... u sentinel
+            if( LookupMode::ToKeeper == mode_)                                                               // ... u sentinel
             {
                 ASSERT_L( lua_tocfunction( L2, -1) == table_lookup_sentinel);
                 // we want to create a new closure with a 'clone sentinel' function, where the upvalues are the userdata and the metatable fqn
@@ -1584,7 +1580,7 @@ static bool_t copyclone( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_Stat
                 ASSERT_L( lua_istable( L2, -1));
                 lua_setmetatable( L2, -2);                                                                   // ... u
             }
-            STACK_MID( L2, 1);
+            STACK_CHECK( L2, 1);
         }
         else
         {
@@ -1595,206 +1591,210 @@ static bool_t copyclone( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_Stat
         lua_pushvalue( L2, -2);                                                                              // ... u source u
         lua_rawset( L2, L2_cache_i);                                                                         // ... u
         // make sure we have the userdata now
-        if( eLM_ToKeeper == mode_)                                                                           // ... userdata_clone_sentinel
+        if( LookupMode::ToKeeper == mode_)                                                                   // ... userdata_clone_sentinel
         {
             lua_getupvalue( L2, -1, 2);                                                                      // ... userdata_clone_sentinel u
         }
         // assign uservalues
         while( uvi > 0)
         {
-            if(!inter_copy_one( U, L2, L2_cache_i, L, lua_absindex( L, -1), VT_NORMAL, mode_, upName_))      // ... u uv
+            if (!inter_copy_one(U, L2, L2_cache_i, L, lua_absindex(L, -1), VT::NORMAL, mode_, upName_))      // ... u uv
             {
-                (void) luaL_error(L, "Cannot copy upvalue type '%s'", luaL_typename(L, -1));
+                luaL_error(L, "Cannot copy upvalue type '%s'", luaL_typename(L, -1)); // doesn't return
             }
-            lua_pop( L, 1);                                                  // ... mt __lanesclone [uv]*
+            lua_pop( L, 1);                                                      // ... mt __lanesclone [uv]*
             // this pops the value from the stack
             lua_setiuservalue( L2, -2, uvi);                                                                 // ... u
             -- uvi;
         }
         // when we are done, all uservalues are popped from the source stack, and we want only the single transferred value in the destination
-        if( eLM_ToKeeper == mode_)                                                                           // ... userdata_clone_sentinel u
+        if( LookupMode::ToKeeper == mode_)                                                                   // ... userdata_clone_sentinel u
         {
             lua_pop( L2, 1);                                                                                 // ... userdata_clone_sentinel
         }
-        STACK_MID( L2, 1);
-        STACK_MID( L, 2);
+        STACK_CHECK( L2, 1);
+        STACK_CHECK( L, 2);
         // call cloning function in source state to perform the actual memory cloning
         lua_pushlightuserdata( L, clone);                                        // ... mt __lanesclone clone
         lua_pushlightuserdata( L, source);                                       // ... mt __lanesclone clone source
         lua_pushinteger( L, userdata_size);                                      // ... mt __lanesclone clone source size
         lua_call( L, 3, 0);                                                      // ... mt
-        STACK_MID( L, 1);
+        STACK_CHECK( L, 1);
     }
 
-    STACK_END( L2, 1);
+    STACK_CHECK( L2, 1);
     lua_pop( L, 1);                                                              // ...
-    STACK_END( L, 0);
-    return TRUE;
+    STACK_CHECK( L, 0);
+    return true;
 }
 
-static bool_t inter_copy_userdata( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State* L, uint_t i, enum e_vt vt, LookupMode mode_, char const* upName_)
+// #################################################################################################
+
+[[nodiscard]] static bool inter_copy_userdata(Universe* U, Dest L2, int L2_cache_i, Source L, int i, VT vt_, LookupMode mode_, char const* upName_)
 {
-    STACK_CHECK( L, 0);
-    STACK_CHECK( L2, 0);
-    if( vt == VT_KEY)
+    STACK_CHECK_START_REL(L, 0);
+    STACK_CHECK_START_REL(L2, 0);
+    if (vt_ == VT::KEY)
     {
-        return FALSE;
+        return false;
     }
 
     // try clonable userdata first
     if( copyclone( U, L2, L2_cache_i, L, i, mode_, upName_))
     {
-        STACK_MID( L, 0);
-        STACK_MID( L2, 1);
-        return TRUE;
+        STACK_CHECK(L, 0);
+        STACK_CHECK(L2, 1);
+        return true;
     }
 
-    STACK_MID( L, 0);
-    STACK_MID( L2, 0);
+    STACK_CHECK(L, 0);
+    STACK_CHECK(L2, 0);
 
     // Allow only deep userdata entities to be copied across
-    DEBUGSPEW_CODE( fprintf( stderr, "USERDATA\n"));
-    if( copydeep( U, L2, L2_cache_i, L, i, mode_, upName_))
+    DEBUGSPEW_CODE(fprintf(stderr, "USERDATA\n"));
+    if (copydeep(U, L2, L2_cache_i, L, i, mode_, upName_))
     {
-        STACK_MID( L, 0);
-        STACK_MID( L2, 1);
-        return TRUE;
+        STACK_CHECK(L, 0);
+        STACK_CHECK(L2, 1);
+        return true;
     }
 
-    STACK_MID( L, 0);
-    STACK_MID( L2, 0);
+    STACK_CHECK(L, 0);
+    STACK_CHECK(L2, 0);
 
     // Not a deep or clonable full userdata
-    if( U->demoteFullUserdata) // attempt demotion to light userdata
+    if (U->demoteFullUserdata) // attempt demotion to light userdata
     {
-        void* lud = lua_touserdata( L, i);
-        lua_pushlightuserdata( L2, lud);
+        void* lud = lua_touserdata(L, i);
+        lua_pushlightuserdata(L2, lud);
     }
     else // raise an error
     {
-        (void) luaL_error( L, "can't copy non-deep full userdata across lanes");
+        luaL_error(L, "can't copy non-deep full userdata across lanes"); // doesn't return
     }
 
-    STACK_END( L2, 1);
-    STACK_END( L, 0);
-    return TRUE;
+    STACK_CHECK(L2, 1);
+    STACK_CHECK(L, 0);
+    return true;
 }
 
-static bool_t inter_copy_function( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State* L, uint_t source_i_, enum e_vt vt, LookupMode mode_, char const* upName_)
+// #################################################################################################
+
+[[nodiscard]] static bool inter_copy_function(Universe* U, Dest L2, int L2_cache_i, Source L, int source_i_, VT vt_, LookupMode mode_, char const* upName_)
 {
-    if( vt == VT_KEY)
+    if (vt_ == VT::KEY)
     {
-        return FALSE;
+        return false;
     }
 
-    STACK_CHECK( L, 0);                                                            // L (source)                 // L2 (destination)
-    STACK_CHECK( L2, 0);
-    DEBUGSPEW_CODE( fprintf( stderr, "FUNCTION %s\n", upName_));
+    STACK_CHECK_START_REL(L, 0);                                                  // L (source)                 // L2 (destination)
+    STACK_CHECK_START_REL(L2, 0);
+    DEBUGSPEW_CODE(fprintf(stderr, "FUNCTION %s\n", upName_));
 
-    if( lua_tocfunction( L, source_i_) == userdata_clone_sentinel) // we are actually copying a clonable full userdata from a keeper
+    if (lua_tocfunction(L, source_i_) == userdata_clone_sentinel) // we are actually copying a clonable full userdata from a keeper
     {
         // clone the full userdata again
-        size_t userdata_size = 0;
-        void* source;
-        void* clone;
 
         // let's see if we already restored this userdata
-        lua_getupvalue( L, source_i_, 2);                                          // ... u
-        source = lua_touserdata( L, -1);
-        lua_pushlightuserdata( L2, source);                                                                      // ... source
-        lua_rawget( L2, L2_cache_i);                                                                             // ... u?
-        if( !lua_isnil( L2, -1))
+        lua_getupvalue(L, source_i_, 2);                                          // ... u
+        void* source = lua_touserdata(L, -1);
+        lua_pushlightuserdata(L2, source);                                                                      // ... source
+        lua_rawget(L2, L2_cache_i);                                                                             // ... u?
+        if (!lua_isnil(L2, -1))
         {
-            lua_pop( L, 1);                                                        // ...
-            STACK_MID( L, 0);
-            STACK_MID( L2, 1);
-            return TRUE;
+            lua_pop(L, 1);                                                        // ...
+            STACK_CHECK(L, 0);
+            STACK_CHECK(L2, 1);
+            return true;
         }
-        lua_pop( L2, 1);                                                                                         // ...
+        lua_pop(L2, 1);                                                                                         // ...
 
         // this function has 2 upvalues: the fqn of its metatable, and the userdata itself
-        lookup_table( L2, L, source_i_, mode_, upName_);                                                         // ... mt
+        std::ignore = lookup_table(L2, L, source_i_, mode_, upName_);                                           // ... mt
         // originally 'source_i_' slot was the proxy closure, but from now on it indexes the actual userdata we extracted from it
-        source_i_ = lua_gettop( L);
-        source = lua_touserdata( L, -1);
+        source_i_ = lua_gettop(L);
+        source = lua_touserdata(L, -1);
+        void* clone{ nullptr };
         // get the number of bytes to allocate for the clone
-        userdata_size = (size_t) lua_rawlen( L, -1);
+        size_t const userdata_size{ lua_rawlen(L, -1) };
         {
             // extract uservalues (don't transfer them yet)
             int uvi = 0;
-            while( lua_getiuservalue( L, source_i_, ++ uvi) != LUA_TNONE) {}       // ... u uv
+            while (lua_getiuservalue(L, source_i_, ++uvi) != LUA_TNONE) {}        // ... u uv
             // when lua_getiuservalue() returned LUA_TNONE, it pushed a nil. pop it now
-            lua_pop( L, 1);                                                        // ... u [uv]*
-            -- uvi;
-            STACK_MID( L, uvi + 1);
+            lua_pop(L, 1);                                                        // ... u [uv]*
+            --uvi;
+            STACK_CHECK(L, uvi + 1);
             // create the clone userdata with the required number of uservalue slots
-            clone = lua_newuserdatauv( L2, userdata_size, uvi);                                                  // ... mt u
+            clone = lua_newuserdatauv(L2, userdata_size, uvi);                                                  // ... mt u
             // add it in the cache
-            lua_pushlightuserdata( L2, source);                                                                  // ... mt u source
-            lua_pushvalue( L2, -2);                                                                              // ... mt u source u
-            lua_rawset( L2, L2_cache_i);                                                                         // ... mt u
+            lua_pushlightuserdata(L2, source);                                                                  // ... mt u source
+            lua_pushvalue(L2, -2);                                                                              // ... mt u source u
+            lua_rawset(L2, L2_cache_i);                                                                         // ... mt u
             // set metatable
-            lua_pushvalue( L2, -2);                                                                              // ... mt u mt
-            lua_setmetatable( L2, -2);                                                                           // ... mt u
+            lua_pushvalue(L2, -2);                                                                              // ... mt u mt
+            lua_setmetatable(L2, -2);                                                                           // ... mt u
             // transfer and assign uservalues
-            while( uvi > 0)
+            while (uvi > 0)
             {
-                if(!inter_copy_one( U, L2, L2_cache_i, L, lua_absindex( L, -1), vt, mode_, upName_))             // ... mt u uv
+                if (!inter_copy_one(U, L2, L2_cache_i, L, lua_absindex(L, -1), vt_, mode_, upName_))            // ... mt u uv
                 {
-                    (void) luaL_error(L, "Cannot copy upvalue type '%s'", luaL_typename(L, -1));
+                    luaL_error(L, "Cannot copy upvalue type '%s'", luaL_typename(L, -1)); // doesn't return
                 }
-                lua_pop( L, 1);                                                    // ... u [uv]*
+                lua_pop(L, 1);                                                    // ... u [uv]*
                 // this pops the value from the stack
-                lua_setiuservalue( L2, -2, uvi);                                                                 // ... mt u
+                lua_setiuservalue(L2, -2, uvi);                                                                 // ... mt u
                 -- uvi;
             }
             // when we are done, all uservalues are popped from the stack, we can pop the source as well
-            lua_pop( L, 1);                                                        // ...
-            STACK_MID( L, 0);
-            STACK_MID( L2, 2);                                                                                   // ... mt u
+            lua_pop(L, 1);                                                        // ...
+            STACK_CHECK(L, 0);
+            STACK_CHECK(L2, 2);                                                                                 // ... mt u
         }
         // perform the custom cloning part
-        lua_insert( L2, -2);                                                                                     // ... u mt
+        lua_insert(L2, -2);                                                                                     // ... u mt
         // __lanesclone should always exist because we wouldn't be restoring data from a userdata_clone_sentinel closure to begin with
-        lua_getfield(L2, -1, "__lanesclone");                                                                    // ... u mt __lanesclone
-        lua_remove( L2, -2);                                                                                     // ... u __lanesclone
-        lua_pushlightuserdata( L2, clone);                                                                       // ... u __lanesclone clone
-        lua_pushlightuserdata( L2, source);                                                                      // ... u __lanesclone clone source
-        lua_pushinteger( L2, userdata_size);                                                                     // ... u __lanesclone clone source size
+        lua_getfield(L2, -1, "__lanesclone");                                                                   // ... u mt __lanesclone
+        lua_remove(L2, -2);                                                                                     // ... u __lanesclone
+        lua_pushlightuserdata(L2, clone);                                                                       // ... u __lanesclone clone
+        lua_pushlightuserdata(L2, source);                                                                      // ... u __lanesclone clone source
+        lua_pushinteger(L2, userdata_size);                                                                     // ... u __lanesclone clone source size
         // clone:__lanesclone(dest, source, size)
-        lua_call( L2, 3, 0);                                                                                     // ... u
+        lua_call(L2, 3, 0);                                                                                     // ... u
     }
     else // regular function
     {
-        DEBUGSPEW_CODE( fprintf( stderr, "FUNCTION %s\n", upName_));
-        DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
-        copy_cached_func( U, L2, L2_cache_i, L, source_i_, mode_, upName_);                                      // ... f
-        DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
+        DEBUGSPEW_CODE(fprintf( stderr, "FUNCTION %s\n", upName_));
+        DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
+        copy_cached_func(U, L2, L2_cache_i, L, source_i_, mode_, upName_);                                      // ... f
+        DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
     }
-    STACK_END( L2, 1);
-    STACK_END( L, 0);
-    return TRUE;
+    STACK_CHECK(L2, 1);
+    STACK_CHECK(L, 0);
+    return true;
 }
 
-static bool_t inter_copy_table( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State* L, uint_t i, enum e_vt vt, LookupMode mode_, char const* upName_)
+// #################################################################################################
+
+[[nodiscard]] static bool inter_copy_table(Universe* U, Dest L2, int L2_cache_i, Source L, int i, VT vt_, LookupMode mode_, char const* upName_)
 {
-    if( vt == VT_KEY)
+    if (vt_ == VT::KEY)
     {
-        return FALSE;
+        return false;
     }
 
-    STACK_CHECK( L, 0);
-    STACK_CHECK( L2, 0);
-    DEBUGSPEW_CODE( fprintf( stderr, "TABLE %s\n", upName_));
+    STACK_CHECK_START_REL(L, 0);
+    STACK_CHECK_START_REL(L2, 0);
+    DEBUGSPEW_CODE(fprintf(stderr, "TABLE %s\n", upName_));
 
     /*
-        * First, let's try to see if this table is special (aka is it some table that we registered in our lookup databases during module registration?)
-        * Note that this table CAN be a module table, but we just didn't register it, in which case we'll send it through the table cloning mechanism
-        */
-    if( lookup_table( L2, L, i, mode_, upName_))
+     * First, let's try to see if this table is special (aka is it some table that we registered in our lookup databases during module registration?)
+     * Note that this table CAN be a module table, but we just didn't register it, in which case we'll send it through the table cloning mechanism
+     */
+    if (lookup_table(L2, L, i, mode_, upName_))
     {
-        ASSERT_L( lua_istable( L2, -1) || (lua_tocfunction( L2, -1) == table_lookup_sentinel));    // from lookup datables // can also be table_lookup_sentinel if this is a table we know
-        return TRUE;
+        ASSERT_L(lua_istable(L2, -1) || (lua_tocfunction(L2, -1) == table_lookup_sentinel));  // from lookup data. can also be table_lookup_sentinel if this is a table we know
+        return true;
     }
 
     /* Check if we've already copied the same table from 'L' (during this transmission), and
@@ -1806,36 +1806,38 @@ static bool_t inter_copy_table( Universe* U, lua_State* L2, uint_t L2_cache_i, l
     * Note: Even metatables need to go through this test; to detect
     *       loops such as those in required module tables (getmetatable(lanes).lanes == lanes)
     */
-    if( push_cached_table( L2, L2_cache_i, L, i))
+    if (push_cached_table(L2, L2_cache_i, L, i))
     {
-        ASSERT_L( lua_istable( L2, -1));    // from cache
-        return TRUE;
+        ASSERT_L(lua_istable(L2, -1));    // from cache
+        return true;
     }
-    ASSERT_L( lua_istable( L2, -1));
+    ASSERT_L(lua_istable(L2, -1));
 
-    STACK_GROW( L, 2);
-    STACK_GROW( L2, 2);
+    STACK_GROW(L, 2);
+    STACK_GROW(L2, 2);
 
-    lua_pushnil( L);    // start iteration
-    while( lua_next( L, i))
+    lua_pushnil(L); // start iteration
+    while (lua_next(L, i))
     {
         // need a function to prevent overflowing the stack with verboseErrors-induced alloca()
-        inter_copy_keyvaluepair( U, L2, L2_cache_i, L, vt, mode_, upName_);
-        lua_pop( L, 1);    // pop value (next round)
+        inter_copy_keyvaluepair(U, L2, L2_cache_i, L, vt_, mode_, upName_);
+        lua_pop(L, 1);    // pop value (next round)
     }
-    STACK_MID( L, 0);
-    STACK_MID( L2, 1);
+    STACK_CHECK(L, 0);
+    STACK_CHECK(L2, 1);
 
     // Metatables are expected to be immutable, and copied only once.
-    if( push_cached_metatable( U, L2, L2_cache_i, L, i, mode_, upName_))                                   // ... t mt?
+    if (push_cached_metatable(U, L2, L2_cache_i, L, i, mode_, upName_))                                   // ... t mt?
     {
-        lua_setmetatable( L2, -2);                                                                           // ... t
+        lua_setmetatable(L2, -2);                                                                         // ... t
     }
-    STACK_END( L2, 1);
-    STACK_END( L, 0);
-    return TRUE;
+    STACK_CHECK(L2, 1);
+    STACK_CHECK(L, 0);
+    return true;
 }
 
+// #################################################################################################
+
 /*
 * Copies a value from 'L' state (at index 'i') to 'L2' state. Does not remove
 * the original value.
@@ -1844,23 +1846,23 @@ static bool_t inter_copy_table( Universe* U, lua_State* L2, uint_t L2_cache_i, l
 *
 * 'i' is an absolute index (no -1, ...)
 *
-* Returns TRUE if value was pushed, FALSE if its type is non-supported.
+* Returns true if value was pushed, false if its type is non-supported.
 */
-bool_t inter_copy_one( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State* L, uint_t i, enum e_vt vt, LookupMode mode_, char const* upName_)
+[[nodiscard]] bool inter_copy_one(Universe* U, Dest L2, int L2_cache_i, Source L, int i, VT vt_, LookupMode mode_, char const* upName_)
 {
-    bool_t ret = TRUE;
-    int val_type = lua_type( L, i);
-    static int const pod_mask = (1 << LUA_TNIL) | (1 << LUA_TBOOLEAN) | (1 << LUA_TLIGHTUSERDATA) | (1 << LUA_TNUMBER) | (1 << LUA_TSTRING);
+    bool ret{ true };
+    LuaType val_type{ lua_type_as_enum(L, i) };
+    static constexpr int pod_mask = (1 << LUA_TNIL) | (1 << LUA_TBOOLEAN) | (1 << LUA_TLIGHTUSERDATA) | (1 << LUA_TNUMBER) | (1 << LUA_TSTRING);
     STACK_GROW( L2, 1);
-    STACK_CHECK( L, 0);                                                          // L                          // L2
-    STACK_CHECK( L2, 0);                                                         // L                          // L2
+    STACK_CHECK_START_REL(L, 0);                                                       // L                          // L2
+    STACK_CHECK_START_REL(L2, 0);                                                      // L                          // L2
 
     DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "inter_copy_one()\n" INDENT_END));
-    DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "%s %s: " INDENT_END, lua_type_names[val_type], vt_names[vt]));
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
+    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "%s %s: " INDENT_END, lua_type_names[val_type], vt_names[static_cast<int>(vt_)]));
 
     // Non-POD can be skipped if its metatable contains { __lanesignore = true }
-    if( ((1 << val_type) & pod_mask) == 0)
+    if( ((1 << static_cast<int>(val_type)) & pod_mask) == 0)
     {
         if( lua_getmetatable( L, i))                                               // ... mt
         {
@@ -1868,27 +1870,27 @@ bool_t inter_copy_one( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State*
             if( lua_isboolean( L, -1) && lua_toboolean( L, -1))
             {
                 DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "__lanesignore -> LUA_TNIL\n" INDENT_END));
-                val_type = LUA_TNIL;
+                val_type = LuaType::NIL;
             }
             lua_pop( L, 2);                                                          // ...
         }
     }
-    STACK_MID( L, 0);
+    STACK_CHECK( L, 0);
 
     /* Lets push nil to L2 if the object should be ignored */
     switch( val_type)
     {
         /* Basic types allowed both as values, and as table keys */
 
-        case LUA_TBOOLEAN:
+        case LuaType::BOOLEAN:
         {
-            bool_t v = lua_toboolean( L, i);
+            int const v{ lua_toboolean(L, i) };
             DEBUGSPEW_CODE( fprintf( stderr, "%s\n", v ? "true" : "false"));
             lua_pushboolean( L2, v);
         }
         break;
 
-        case LUA_TNUMBER:
+        case LuaType::NUMBER:
         /* LNUM patch support (keeping integer accuracy) */
 #if defined LUA_LNUM || LUA_VERSION_NUM >= 503
         if( lua_isinteger( L, i))
@@ -1907,7 +1909,7 @@ bool_t inter_copy_one( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State*
         }
         break;
 
-        case LUA_TSTRING:
+        case LuaType::STRING:
         {
             size_t len;
             char const* s = lua_tolstring( L, i, &len);
@@ -1916,7 +1918,7 @@ bool_t inter_copy_one( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State*
         }
         break;
 
-        case LUA_TLIGHTUSERDATA:
+        case LuaType::LIGHTUSERDATA:
         {
             void* p = lua_touserdata( L, i);
             DEBUGSPEW_CODE( fprintf( stderr, "%p\n", p));
@@ -1926,42 +1928,44 @@ bool_t inter_copy_one( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State*
 
         /* The following types are not allowed as table keys */
 
-        case LUA_TUSERDATA:
-        ret = inter_copy_userdata( U, L2, L2_cache_i, L, i, vt, mode_, upName_);
+        case LuaType::USERDATA:
+        ret = inter_copy_userdata(U, L2, L2_cache_i, L, i, vt_, mode_, upName_);
         break;
 
-        case LUA_TNIL:
-        if( vt == VT_KEY)
+        case LuaType::NIL:
+        if (vt_ == VT::KEY)
         {
-            ret = FALSE;
+            ret = false;
             break;
         }
         lua_pushnil( L2);
         break;
 
-        case LUA_TFUNCTION:
-        ret = inter_copy_function( U, L2, L2_cache_i, L, i, vt, mode_, upName_);
+        case LuaType::FUNCTION:
+        ret = inter_copy_function(U, L2, L2_cache_i, L, i, vt_, mode_, upName_);
         break;
 
-        case LUA_TTABLE:
-        ret = inter_copy_table( U, L2, L2_cache_i, L, i, vt, mode_, upName_);
+        case LuaType::TABLE:
+        ret = inter_copy_table(U, L2, L2_cache_i, L, i, vt_, mode_, upName_);
         break;
 
         /* The following types cannot be copied */
 
-        case 10: // LuaJIT CDATA
-        case LUA_TTHREAD:
-        ret = FALSE;
+        case LuaType::CDATA:
+        case LuaType::THREAD:
+        ret = false;
         break;
     }
 
-    DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
 
-    STACK_END( L2, ret ? 1 : 0);
-    STACK_END( L, 0);
+    STACK_CHECK( L2, ret ? 1 : 0);
+    STACK_CHECK( L, 0);
     return ret;
 }
 
+// #################################################################################################
+
 /*
 * Akin to 'lua_xmove' but copies values between _any_ Lua states.
 *
@@ -1969,128 +1973,137 @@ bool_t inter_copy_one( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State*
 *
 * Note: Parameters are in this order ('L' = from first) to be same as 'lua_xmove'.
 */
-InterCopyResult luaG_inter_copy( Universe* U, lua_State* L, lua_State* L2, uint_t n, LookupMode mode_)
+[[nodiscard]] InterCopyResult luaG_inter_copy(Universe* U, Source L, Dest L2, int n, LookupMode mode_)
 {
-    uint_t top_L = lua_gettop( L);                                    // ... {}n
-    uint_t top_L2 = lua_gettop( L2);                                                               // ...
-    uint_t i, j;
+    int const top_L{ lua_gettop(L) };                             // ... {}n
+    int const top_L2{ lua_gettop(L2) };                                                             // ...
     char tmpBuf[16];
-    char const* pBuf = U->verboseErrors ? tmpBuf : "?";
-    bool_t copyok = TRUE;
+    char const* pBuf{ U->verboseErrors ? tmpBuf : "?" };
 
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "luaG_inter_copy()\n" INDENT_END));
-    DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
+    DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "luaG_inter_copy()\n" INDENT_END));
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
 
-    if( n > top_L)
+    if (n > top_L)
     {
         // requesting to copy more than is available?
-        DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "nothing to copy()\n" INDENT_END));
-        DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
-        return eICR_NotEnoughValues;
+        DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "nothing to copy()\n" INDENT_END));
+        DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
+        return InterCopyResult::NotEnoughValues;
     }
 
-    STACK_CHECK( L2, 0);
-    STACK_GROW( L2, n + 1);
+    STACK_CHECK_START_REL(L2, 0);
+    STACK_GROW(L2, n + 1);
 
     /*
     * Make a cache table for the duration of this copy. Collects tables and
     * function entries, avoiding the same entries to be passed on as multiple
     * copies. ESSENTIAL i.e. for handling upvalue tables in the right manner!
     */
-    lua_newtable( L2);                                                                              // ... cache
+    lua_newtable(L2);                                                                               // ... cache
 
-    STACK_CHECK( L, 0);
-    for( i = top_L - n + 1, j = 1; i <= top_L; ++ i, ++ j)
+    STACK_CHECK_START_REL(L, 0);
+    bool copyok{ true };
+    for (int i = top_L - n + 1, j = 1; i <= top_L; ++i, ++j)
     {
-        if( U->verboseErrors)
+        if (U->verboseErrors)
         {
-            sprintf( tmpBuf, "arg_%d", j);
+            sprintf(tmpBuf, "arg_%d", j);
         }
-        copyok = inter_copy_one( U, L2, top_L2 + 1, L, i, VT_NORMAL, mode_, pBuf);                    // ... cache {}n
-        if( !copyok)
+        copyok = inter_copy_one(U, L2, top_L2 + 1, L, i, VT::NORMAL, mode_, pBuf);                  // ... cache {}n
+        if (!copyok)
         {
             break;
         }
     }
-    STACK_END( L, 0);
+    STACK_CHECK(L, 0);
 
-    DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
 
-    if( copyok)
+    if (copyok)
     {
-        STACK_MID( L2, n + 1);
+        STACK_CHECK(L2, n + 1);
         // Remove the cache table. Persistent caching would cause i.e. multiple
         // messages passed in the same table to use the same table also in receiving end.
-        lua_remove( L2, top_L2 + 1);
-        return eICR_Success;
+        lua_remove(L2, top_L2 + 1);
+        return InterCopyResult::Success;
     }
 
     // error -> pop everything from the target state stack
-    lua_settop( L2, top_L2);
-    STACK_END( L2, 0);
-    return eICR_Error;
+    lua_settop(L2, top_L2);
+    STACK_CHECK(L2, 0);
+    return InterCopyResult::Error;
 }
 
+// #################################################################################################
 
-InterCopyResult luaG_inter_move( Universe* U, lua_State* L, lua_State* L2, uint_t n, LookupMode mode_)
+[[nodiscard]] InterCopyResult luaG_inter_move(Universe* U, Source L, Dest L2, int n_, LookupMode mode_)
 {
-    InterCopyResult ret = luaG_inter_copy( U, L, L2, n, mode_);
-    lua_pop( L, (int) n);
+    InterCopyResult const ret{ luaG_inter_copy(U, L, L2, n_, mode_) };
+    lua_pop( L, n_);
     return ret;
 }
 
-InterCopyResult luaG_inter_copy_package( Universe* U, lua_State* L, lua_State* L2, int package_idx_, LookupMode mode_)
+// #################################################################################################
+
+// transfers stuff from L->_G["package"] to L2->_G["package"]
+// returns InterCopyResult::Success if everything is fine
+// returns InterCopyResult::Error if pushed an error message in L
+// else raise an error in L
+[[nodiscard]] InterCopyResult luaG_inter_copy_package(Universe* U, Source L, Dest L2, int package_idx_, LookupMode mode_)
 {
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "luaG_inter_copy_package()\n" INDENT_END));
-    DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
+    DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "luaG_inter_copy_package()\n" INDENT_END));
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
     // package
-    STACK_CHECK( L, 0);
-    STACK_CHECK( L2, 0);
-    package_idx_ = lua_absindex( L, package_idx_);
-    if( lua_type( L, package_idx_) != LUA_TTABLE)
+    STACK_CHECK_START_REL(L, 0);
+    STACK_CHECK_START_REL(L2, 0);
+    package_idx_ = lua_absindex(L, package_idx_);
+    if (lua_type(L, package_idx_) != LUA_TTABLE)
     {
-        lua_pushfstring( L, "expected package as table, got %s", luaL_typename( L, package_idx_));
-        STACK_MID( L, 1);
+        lua_pushfstring(L, "expected package as table, got %s", luaL_typename(L, package_idx_));
+        STACK_CHECK(L, 1);
         // raise the error when copying from lane to lane, else just leave it on the stack to be raised later
-        if (mode_ == eLM_LaneBody)
+        if (mode_ == LookupMode::LaneBody)
         {
             lua_error(L); // doesn't return
         }
-        return eICR_Error;
+        return InterCopyResult::Error;
     }
-    lua_getglobal( L2, "package");
-    if( !lua_isnil( L2, -1)) // package library not loaded: do nothing
+    lua_getglobal(L2, "package");
+    if (!lua_isnil(L2, -1)) // package library not loaded: do nothing
     {
-        int i;
         // package.loaders is renamed package.searchers in Lua 5.2
         // but don't copy it anyway, as the function names change depending on the slot index!
         // users should provide an on_state_create function to setup custom loaders instead
         // don't copy package.preload in keeper states (they don't know how to translate functions)
-        char const* entries[] = { "path", "cpath", (mode_ == eLM_LaneBody) ? "preload" : NULL/*, (LUA_VERSION_NUM == 501) ? "loaders" : "searchers"*/, NULL};
-        for( i = 0; entries[i]; ++ i)
+        char const* entries[] = { "path", "cpath", (mode_ == LookupMode::LaneBody) ? "preload" : nullptr /*, (LUA_VERSION_NUM == 501) ? "loaders" : "searchers"*/, nullptr };
+        for (char const* const entry : entries)
         {
-            DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "package.%s\n" INDENT_END, entries[i]));
-            lua_getfield( L, package_idx_, entries[i]);
-            if( lua_isnil( L, -1))
+            if (!entry)
+            {
+                continue;
+            }
+            DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "package.%s\n" INDENT_END, entry));
+            lua_getfield(L, package_idx_, entry);
+            if (lua_isnil(L, -1))
             {
-                lua_pop( L, 1);
+                lua_pop(L, 1);
             }
             else
             {
-                DEBUGSPEW_CODE( ++ U->debugspew_indent_depth);
-                luaG_inter_move( U, L, L2, 1, mode_); // moves the entry to L2
-                DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
-                lua_setfield( L2, -2, entries[i]); // set package[entries[i]]
+                DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
+                std::ignore = luaG_inter_move(U, L, L2, 1, mode_); // moves the entry to L2
+                DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
+                lua_setfield(L2, -2, entry); // set package[entry]
             }
         }
     }
     else
     {
-        DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "'package' not loaded, nothing to do\n" INDENT_END));
+        DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "'package' not loaded, nothing to do\n" INDENT_END));
     }
-    lua_pop( L2, 1);
-    STACK_END( L2, 0);
-    STACK_END( L, 0);
-    DEBUGSPEW_CODE( -- U->debugspew_indent_depth);
-    return eICR_Success;
+    lua_pop(L2, 1);
+    STACK_CHECK(L2, 0);
+    STACK_CHECK(L, 0);
+    DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
+    return InterCopyResult::Success;
 }
diff --git a/src/tools.h b/src/tools.h
index 6c08734..dce7378 100644
--- a/src/tools.h
+++ b/src/tools.h
@@ -1,65 +1,53 @@
-#ifndef __LANES_TOOLS_H__
-#define __LANES_TOOLS_H__
+#pragma once
 
-//#include "lauxlib.h"
-#include "threading.h"
 #include "deep.h"
-
 #include "macros_and_utils.h"
 
 // forwards
-struct s_Universe;
-typedef struct s_Universe Universe;
+class Universe;
 
 // ################################################################################################
 
-#define luaG_optunsigned(L,i,d) ((uint_t) luaL_optinteger(L,i,d))
-#define luaG_tounsigned(L,i) ((uint_t) lua_tointeger(L,i))
-
 #ifdef _DEBUG
-void luaG_dump( lua_State* L);
+void luaG_dump(lua_State* L);
 #endif // _DEBUG
 
 // ################################################################################################
 
-void push_registry_subtable_mode( lua_State* L, UniqueKey key_, const char* mode_);
-void push_registry_subtable( lua_State* L, UniqueKey key_);
+void push_registry_subtable_mode(lua_State* L, UniqueKey key_, const char* mode_);
+void push_registry_subtable(lua_State* L, UniqueKey key_);
 
-enum e_vt
+enum class VT
 {
-    VT_NORMAL,
-    VT_KEY,
-    VT_METATABLE
+    NORMAL,
+    KEY,
+    METATABLE
 };
 
-enum eInterCopyResult
+enum class InterCopyResult
 {
-    eICR_Success,
-    eICR_NotEnoughValues,
-    eICR_Error
+    Success,
+    NotEnoughValues,
+    Error
 };
-typedef enum eInterCopyResult InterCopyResult;
 
-bool_t inter_copy_one( Universe* U, lua_State* L2, uint_t L2_cache_i, lua_State* L, uint_t i, enum e_vt vt, LookupMode mode_, char const* upName_);
+[[nodiscard]] bool inter_copy_one(Universe* U, Dest L2, int L2_cache_i, Source L, int i, VT vt_, LookupMode mode_, char const* upName_);
 
 // ################################################################################################
 
-InterCopyResult luaG_inter_copy_package( Universe* U, lua_State* L, lua_State* L2, int package_idx_, LookupMode mode_);
-InterCopyResult luaG_inter_copy( Universe* U, lua_State* L, lua_State* L2, uint_t n, LookupMode mode_);
-InterCopyResult luaG_inter_move( Universe* U, lua_State* L, lua_State* L2, uint_t n, LookupMode mode_);
+[[nodiscard]] InterCopyResult luaG_inter_copy_package(Universe* U, Source L, Dest L2, int package_idx_, LookupMode mode_);
+[[nodiscard]] InterCopyResult luaG_inter_copy(Universe* U, Source L, Dest L2, int n, LookupMode mode_);
+[[nodiscard]] InterCopyResult luaG_inter_move(Universe* U, Source L, Dest L2, int n, LookupMode mode_);
 
-int luaG_nameof( lua_State* L);
+[[nodiscard]] int luaG_nameof(lua_State* L);
 
-void populate_func_lookup_table( lua_State* L, int _i, char const* _name);
-void initialize_allocator_function( Universe* U, lua_State* L);
-void cleanup_allocator_function( Universe* U, lua_State* L);
+void populate_func_lookup_table(lua_State* L, int _i, char const* _name);
+void initialize_allocator_function(Universe* U, lua_State* L);
 
 // ################################################################################################
 
 // crc64/we of string "CONFIG_REGKEY" generated at http://www.nitrxgen.net/hashgen/
-static DECLARE_CONST_UNIQUE_KEY( CONFIG_REGKEY, 0x31cd24894eae8624); // 'cancel_error' sentinel
+static constexpr UniqueKey CONFIG_REGKEY{ 0x31cd24894eae8624ull }; // registry key to access the configuration
 
 // crc64/we of string "LOOKUP_REGKEY" generated at http://www.nitrxgen.net/hashgen/
-static DECLARE_CONST_UNIQUE_KEY( LOOKUP_REGKEY, 0x5051ed67ee7b51a1); // 'cancel_error' sentinel
-
-#endif // __LANES_TOOLS_H__
+static constexpr UniqueKey LOOKUP_REGKEY{ 0x5051ed67ee7b51a1ull }; // registry key to access the lookup database
diff --git a/src/uniquekey.h b/src/uniquekey.h
index 7162753..a89ecd3 100644
--- a/src/uniquekey.h
+++ b/src/uniquekey.h
@@ -1,25 +1,76 @@
-#if !defined __LANES_UNIQUEKEY_H__
-#define __LANES_UNIQUEKEY_H__ 1
+#pragma once
 
 #include "compat.h"
+#include "macros_and_utils.h"
 
-// Lua light userdata can hold a pointer.
-struct s_UniqueKey
+#include <bit>
+
+class UniqueKey
 {
-    void* value;
-};
-typedef struct s_UniqueKey UniqueKey;
+    private:
+
+    uintptr_t m_storage;
+
+    public:
 
+    constexpr explicit UniqueKey(uint64_t val_)
 #if LUAJIT_FLAVOR() == 64 // building against LuaJIT headers for 64 bits, light userdata is restricted to 47 significant bits, because LuaJIT uses the other bits for internal optimizations
-#define MAKE_UNIQUE_KEY( p_) ((void*)((uintptr_t)(p_) & 0x7fffffffffffull))
+    : m_storage{ static_cast<uintptr_t>(val_ & 0x7fffffffffffull) }
 #else // LUAJIT_FLAVOR()
-#define MAKE_UNIQUE_KEY( p_) ((void*)(uintptr_t)(p_))
+    : m_storage{ static_cast<uintptr_t>(val_) }
 #endif // LUAJIT_FLAVOR()
+    {
+    }
+    constexpr UniqueKey(UniqueKey const& rhs_) = default;
+    constexpr bool operator!=(UniqueKey const& rhs_) const
+    {
+        return m_storage != rhs_.m_storage;
+    }
+    constexpr bool operator==(UniqueKey const& rhs_) const
+    {
+        return m_storage == rhs_.m_storage;
+    }
 
-#define DECLARE_UNIQUE_KEY( name_) UniqueKey name_
-#define DECLARE_CONST_UNIQUE_KEY( name_, p_) UniqueKey const name_ = { MAKE_UNIQUE_KEY( p_)}
-
-#define push_unique_key( L, key_) lua_pushlightuserdata( L, key_.value)
-#define equal_unique_key( L, i, key_) (lua_touserdata( L, i) == key_.value)
-
-#endif // __LANES_UNIQUEKEY_H__
+    void pushKey(lua_State* const L) const
+    {
+        lua_pushlightuserdata(L, std::bit_cast<void*>(m_storage));
+    }
+    bool equals(lua_State* const L, int i) const
+    {
+        return lua_touserdata(L, i) == std::bit_cast<void*>(m_storage);
+    }
+    void pushValue(lua_State* const L) const
+    {
+        pushKey(L);
+        lua_rawget(L, LUA_REGISTRYINDEX);
+    }
+    template <typename OP>
+    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)
+        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.c b/src/universe.c
deleted file mode 100644
index 9f84baf..0000000
--- a/src/universe.c
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * UNIVERSE.C                  Copyright (c) 2017, Benoit Germain
- */
-
-/*
-===============================================================================
-
-Copyright (C) 2017 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
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
-===============================================================================
-*/
-
-#include <string.h>
-#include <assert.h>
-
-#include "universe.h"
-#include "compat.h"
-#include "macros_and_utils.h"
-#include "uniquekey.h"
-
-// crc64/we of string "UNIVERSE_REGKEY" generated at http://www.nitrxgen.net/hashgen/
-static DECLARE_CONST_UNIQUE_KEY( UNIVERSE_REGKEY, 0x9f877b2cf078f17f);
-
-// ################################################################################################
-
-Universe* universe_create( lua_State* L)
-{
-    Universe* U = (Universe*) lua_newuserdatauv( L, sizeof(Universe), 0);                          // universe
-    memset( U, 0, sizeof( Universe));
-    STACK_CHECK( L, 1);
-    REGISTRY_SET( L, UNIVERSE_REGKEY, lua_pushvalue(L, -2));                                       // universe
-    STACK_END( L, 1);
-    return U;
-}
-
-// ################################################################################################
-
-void universe_store( lua_State* L, Universe* U)
-{
-    STACK_CHECK( L, 0);
-    REGISTRY_SET( L, UNIVERSE_REGKEY, (NULL != U) ? lua_pushlightuserdata( L, U) : lua_pushnil( L));
-    STACK_END( L, 0);
-}
-
-// ################################################################################################
-
-Universe* universe_get( lua_State* L)
-{
-    Universe* universe;
-    STACK_GROW( L, 2);
-    STACK_CHECK( L, 0);
-    REGISTRY_GET( L, UNIVERSE_REGKEY);
-    universe = lua_touserdata( L, -1); // NULL if nil
-    lua_pop( L, 1);
-    STACK_END( L, 0);
-    return universe;
-}
diff --git a/src/universe.cpp b/src/universe.cpp
new file mode 100644
index 0000000..4c53987
--- /dev/null
+++ b/src/universe.cpp
@@ -0,0 +1,106 @@
+/*
+ * UNIVERSE.C                  Copyright (c) 2017, Benoit Germain
+ */
+
+/*
+===============================================================================
+
+Copyright (C) 2017 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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+===============================================================================
+*/
+
+#include <string.h>
+#include <assert.h>
+
+#include "universe.h"
+#include "compat.h"
+#include "macros_and_utils.h"
+#include "uniquekey.h"
+
+// xxh64 of string "UNIVERSE_FULL_REGKEY" generated at http://www.nitrxgen.net/hashgen/
+static constexpr UniqueKey UNIVERSE_FULL_REGKEY{ 0x99CA130C09EDC074ull };
+// xxh64 of string "UNIVERSE_LIGHT_REGKEY" generated at http://www.nitrxgen.net/hashgen/
+static constexpr UniqueKey UNIVERSE_LIGHT_REGKEY{ 0x3663C07C742CEB81ull };
+
+// ################################################################################################
+
+Universe::Universe()
+{
+    //---
+    // Linux needs SCHED_RR to change thread priorities, and that is only
+    // allowed for sudo'ers. SCHED_OTHER (default) has no priorities.
+    // SCHED_OTHER threads are always lower priority than SCHED_RR.
+    //
+    // ^-- those apply to 2.6 kernel.  IF **wishful thinking** these
+    //     constraints will change in the future, non-sudo priorities can
+    //     be enabled also for Linux.
+    //
+#ifdef PLATFORM_LINUX
+    // If lower priorities (-2..-1) are wanted, we need to lift the main
+    // thread to SCHED_RR and 50 (medium) level. Otherwise, we're always below
+    // the launched threads (even -2).
+    //
+#ifdef LINUX_SCHED_RR
+    if (m_sudo)
+    {
+        struct sched_param sp;
+        sp.sched_priority = _PRIO_0;
+        PT_CALL(pthread_setschedparam(pthread_self(), SCHED_RR, &sp));
+    }
+#endif // LINUX_SCHED_RR
+#endif // PLATFORM_LINUX
+}
+
+// ################################################################################################
+
+// only called from the master state
+Universe* universe_create(lua_State* L)
+{
+    ASSERT_L(universe_get(L) == nullptr);
+    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.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;
+}
+
+// ################################################################################################
+
+void universe_store(lua_State* L, Universe* U)
+{
+    ASSERT_L(!U || universe_get(L) == nullptr);
+    STACK_CHECK_START_REL(L, 0);
+    UNIVERSE_LIGHT_REGKEY.setValue(L, [U](lua_State* L) { U ? lua_pushlightuserdata(L, U) : lua_pushnil(L); });
+    STACK_CHECK(L, 0);
+}
+
+// ################################################################################################
+
+Universe* universe_get(lua_State* L)
+{
+    STACK_CHECK_START_REL(L, 0);
+    Universe* const universe{ UNIVERSE_LIGHT_REGKEY.readLightUserDataValue<Universe>(L) };
+    STACK_CHECK(L, 0);
+    return universe;
+}
diff --git a/src/universe.h b/src/universe.h
index 03c78cf..113ed21 100644
--- a/src/universe.h
+++ b/src/universe.h
@@ -1,23 +1,25 @@
-/*
-* UNIVERSE.H
-*/
-#ifndef UNIVERSE_H
-#define UNIVERSE_H
+#pragma once
 
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
 #include "lua.h"
-#include "threading.h"
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#include "compat.h"
 #include "macros_and_utils.h"
 
-// forwards
-struct s_DeepPrelude;
-typedef struct s_DeepPrelude DeepPrelude;
-struct s_Keepers;
-typedef struct s_Keepers Keepers;
-struct s_Lane;
-typedef struct s_Lane Lane;
+#include <mutex>
 
 // ################################################################################################
 
+// forwards
+struct DeepPrelude;
+struct Keepers;
+class Lane;
+
 /*
 * Do we want to activate full lane tracking feature? (EXPERIMENTAL)
 */
@@ -26,38 +28,118 @@ typedef struct s_Lane Lane;
 // ################################################################################################
 
 // everything we need to provide to lua_newstate()
-struct AllocatorDefinition_s
+class AllocatorDefinition
 {
-    lua_Alloc allocF;
-    void* allocUD;
+    public:
+
+    lua_Alloc m_allocF{ nullptr };
+    void* m_allocUD{ nullptr };
+
+    [[nodiscard]] static void* operator new(size_t size_, lua_State* L) noexcept { return lua_newuserdatauv(L, size_, 0); }
+    // always embedded somewhere else or "in-place constructed" as a full userdata
+    // can't actually delete the operator because the compiler generates stack unwinding code that could call it in case of exception
+    static void operator delete([[maybe_unused]] void* p_, lua_State* L) { ASSERT_L(!"should never be called") };
+
+    AllocatorDefinition(lua_Alloc allocF_, void* allocUD_) noexcept
+    : m_allocF{ allocF_ }
+    , m_allocUD{ allocUD_ }
+    {
+    }
+    AllocatorDefinition() = default;
+    AllocatorDefinition(AllocatorDefinition const& rhs_) = default;
+    AllocatorDefinition(AllocatorDefinition&& rhs_) = default;
+    AllocatorDefinition& operator=(AllocatorDefinition const& rhs_) = default;
+    AllocatorDefinition& operator=(AllocatorDefinition&& rhs_) = default;
+
+    void initFrom(lua_State* L)
+    {
+        m_allocF = lua_getallocf(L, &m_allocUD);
+    }
+
+    void* lua_alloc(void* ptr_, size_t osize_, size_t nsize_)
+    {
+        m_allocF(m_allocUD, ptr_, osize_, nsize_);
+    }
+
+    void* alloc(size_t nsize_)
+    {
+        return m_allocF(m_allocUD, nullptr, 0, nsize_);
+    }
+
+    void free(void* ptr_, size_t osize_)
+    {
+        std::ignore = m_allocF(m_allocUD, ptr_, osize_, 0);
+    }
 };
-typedef struct AllocatorDefinition_s AllocatorDefinition;
+
+// ################################################################################################
 
 // mutex-protected allocator for use with Lua states that share a non-threadsafe allocator
-struct ProtectedAllocator_s
+class ProtectedAllocator : public AllocatorDefinition
 {
-    AllocatorDefinition definition;
-    MUTEX_T lock;
+    private:
+
+    std::mutex m_lock;
+
+    [[nodiscard]] static void* protected_lua_Alloc(void* ud_, void* ptr_, size_t osize_, size_t nsize_)
+    {
+        ProtectedAllocator* const allocator{ static_cast<ProtectedAllocator*>(ud_) };
+        std::lock_guard<std::mutex> guard{ allocator->m_lock };
+        return allocator->m_allocF(allocator->m_allocUD, ptr_, osize_, nsize_);
+    }
+
+    public:
+
+    // we are not like our base class: we can't be created inside a full userdata (or we would have to install a metatable and __gc handler to destroy ourselves properly)
+    [[nodiscard]] static void* operator new(size_t size_, lua_State* L) noexcept = delete;
+    static void operator delete(void* p_, lua_State* L) = delete;
+
+    AllocatorDefinition makeDefinition()
+    {
+        return AllocatorDefinition{ protected_lua_Alloc, this};
+    }
+
+    void installIn(lua_State* L)
+    {
+        lua_setallocf(L, protected_lua_Alloc, this);
+    }
+
+    void removeFrom(lua_State* L)
+    {
+        // remove the protected allocator, if any
+        if (m_allocF != nullptr)
+        {
+            // install the non-protected allocator
+            lua_setallocf(L, m_allocF, m_allocUD);
+        }
+    }
 };
-typedef struct ProtectedAllocator_s ProtectedAllocator;
 
 // ################################################################################################
 
 // everything regarding the Lanes universe is stored in that global structure
 // held as a full userdata in the master Lua state that required it for the first time
-// don't forget to initialize all members in LG_configure()
-struct s_Universe
+class Universe
 {
+    public:
+
+#ifdef PLATFORM_LINUX
+    // Linux needs to check, whether it's been run as root
+    bool const m_sudo{ geteuid() == 0 };
+#else
+    bool const m_sudo{ false };
+#endif // PLATFORM_LINUX
+
     // for verbose errors
-    bool_t verboseErrors;
+    bool verboseErrors{ false };
 
-    bool_t demoteFullUserdata;
+    bool demoteFullUserdata{ false };
 
     // before a state is created, this function will be called to obtain the allocator
-    lua_CFunction provide_allocator;
+    lua_CFunction provide_allocator{ nullptr };
 
     // after a state is created, this function will be called right after the bases libraries are loaded
-    lua_CFunction on_state_create_func;
+    lua_CFunction on_state_create_func{ nullptr };
 
     // if allocator="protected" is found in the configuration settings, a wrapper allocator will protect all allocator calls with a mutex
     // contains a mutex and the original allocator definition
@@ -65,41 +147,44 @@ struct s_Universe
 
     AllocatorDefinition internal_allocator;
 
-    Keepers* keepers;
+    Keepers* keepers{ nullptr };
 
     // Initialized by 'init_once_LOCKED()': the deep userdata Linda object
     // used for timers (each lane will get a proxy to this)
-    volatile DeepPrelude* timer_deep;  // = NULL
+    DeepPrelude* timer_deep{ nullptr };
 
 #if HAVE_LANE_TRACKING()
-    MUTEX_T tracking_cs;
-    Lane* volatile tracking_first; // will change to TRACKING_END if we want to activate tracking
+    std::mutex tracking_cs;
+    Lane* volatile tracking_first{ nullptr }; // will change to TRACKING_END if we want to activate tracking
 #endif // HAVE_LANE_TRACKING()
 
-    MUTEX_T selfdestruct_cs;
+    std::mutex selfdestruct_cs;
 
     // require() serialization
-    MUTEX_T require_cs;
-
-    // Lock for reference counter inc/dec locks (to be initialized by outside code) TODO: get rid of this and use atomics instead!
-    MUTEX_T deep_lock;
-    MUTEX_T mtid_lock;
+    std::recursive_mutex require_cs;
 
-    lua_Integer last_mt_id;
+    // metatable unique identifiers
+    std::atomic<lua_Integer> next_mt_id{ 1 };
 
 #if USE_DEBUG_SPEW()
-    int debugspew_indent_depth;
+    std::atomic<int> debugspew_indent_depth{ 0 };
 #endif // USE_DEBUG_SPEW()
 
-    Lane* volatile selfdestruct_first;
+    Lane* volatile selfdestruct_first{ nullptr };
     // After a lane has removed itself from the chain, it still performs some processing.
     // The terminal desinit sequence should wait for all such processing to terminate before force-killing threads
-    int volatile selfdestructing_count;
+    std::atomic<int> selfdestructing_count{ 0 };
+
+    Universe();
+    ~Universe() = default;
+    Universe(Universe const&) = delete;
+    Universe(Universe&&) = delete;
+    Universe& operator=(Universe const&) = delete;
+    Universe& operator=(Universe&&) = delete;
 };
-typedef struct s_Universe Universe;
 
-Universe* universe_get( lua_State* L);
-Universe* universe_create( lua_State* L);
-void universe_store( lua_State* L, Universe* U);
+// ################################################################################################
 
-#endif // UNIVERSE_H
+[[nodiscard]] Universe* universe_get(lua_State* L);
+[[nodiscard]] Universe* universe_create(lua_State* L);
+void universe_store(lua_State* L, Universe* U);
diff --git a/tests/cancel.lua b/tests/cancel.lua
index 4e57184..c22103f 100644
--- a/tests/cancel.lua
+++ b/tests/cancel.lua
@@ -220,25 +220,10 @@ if not next(which_tests) or which_tests.hard_unprotected then
         waitCancellation( h, "cancelled")
 end
 
-if not next(which_tests) or which_tests.kill then
-        remaining_tests.kill = nil
-        print "\n\n####################################################################\nbegin kill cancel test\n"
-        h = lanes.gen( "*", laneBody)( "busy", 50000000) -- start a pure Lua busy loop lane
-
-        -- wait 1/3s before cancelling the lane, before the busy loop can finish
-        print "wait 0.3s"
-        linda:receive( 0.3, "yeah")
-
-        -- hard cancel with kill: the lane thread will be forcefully terminated. kill timeout is pthread-specific
-        print "cancelling"
-        h:cancel( true, 1.0)
-
-        -- wait until cancellation is effective. the lane will be stopped by the linda operation throwing an error
-        waitCancellation( h, "killed")
-end
 --####################################################################
 
 local unknown_test, val = next(remaining_tests)
 assert(not unknown_test, tostring(unknown_test) .. " test is unknown")
 
 print "\nTHE END"
+
diff --git a/tests/keeper.lua b/tests/keeper.lua
index 3333938..6dbbd15 100644
--- a/tests/keeper.lua
+++ b/tests/keeper.lua
@@ -97,4 +97,4 @@ assert( A.some==2 )
 PRINT("C.some = " .. C.some )
 assert( C.some==3 )
 lindaC:set("some")
-assert( C.some==nil )
\ No newline at end of file
+assert( C.some==nil )
diff --git a/tests/perftest.lua b/tests/perftest.lua
index 6ffc064..35f522c 100644
--- a/tests/perftest.lua
+++ b/tests/perftest.lua
@@ -83,46 +83,53 @@ PRIO_EVEN= PRIO_EVEN or 0
 --
 -- AKa 20-Jul-2008: Now the wrapping to one function is no longer needed;
 --     Lanes 2008 can take the used functions as upvalues.
---
+
+-- It looks like this implementation uses a lot of C stack, possibly resulting in stack overflow with Lua54
+-- this is reproducible with the original sieve.lua implementation found at https://www.lua.org/extras/
+-- for example: 
+-- Lua54 exe built with 1Mb of C stack crashes for M above 230, C stack at 500 calls
+-- Lua53 exe built with 1Mb of C stack crashes for M above 491, C stack at 740 calls
+-- Lua52 exe built with 1Mb of C stack crashes for M above 672, C stack at 1000 calls
+-- Lua51 exe built with 1Mb of C stack crashes for M above 718, C stack at 900 calls
 local function sieve_lane(N,id)
 
- if MSYS then
-   io.stderr:setvbuf "no"
- end
+    if MSYS then
+        io.stderr:setvbuf "no"
+    end
+
+    -- generate all the numbers from 2 to n
+    local function gen (n)
+        return coroutine.wrap(function ()
+            for i=2,n do coroutine.yield(i) end
+        end)
+    end
 
- -- generate all the numbers from 2 to n
- local function gen (n)
-  return coroutine.wrap(function ()
-    for i=2,n do coroutine.yield(i) end
-  end)
- end
+    -- filter the numbers generated by `g', removing multiples of `p'
+    local function filter (p, g)
+        return coroutine.wrap(function ()
+            while 1 do
+                local n = g()
+                if n == nil then return end
+                if math.fmod(n, p) ~= 0 then coroutine.yield(n) end
+            end
+        end)
+    end
 
- -- filter the numbers generated by `g', removing multiples of `p'
- local function filter (p, g)
-  return coroutine.wrap(function ()
+    local ret= {}      -- returned values: { 2, 3, 5, 7, 11, ... }
+    N=N or 1000     -- from caller
+    local x = gen(N)   -- generate primes up to N
     while 1 do
-      local n = g()
-      if n == nil then return end
-      if math.fmod(n, p) ~= 0 then coroutine.yield(n) end
+        local n = x()           -- pick a number until done
+        if n == nil then break end
+        --print(n)              -- must be a prime number
+        table.insert( ret, n )
+
+        x = filter(n, x)        -- now remove its multiples
     end
-  end)
- end
-
- local ret= {}      -- returned values: { 2, 3, 5, 7, 11, ... }
- N=N or 1000        -- from caller
- local x = gen(N)   -- generate primes up to N
- while 1 do
-  local n = x()         -- pick a number until done
-  if n == nil then break end
-  --print(n)            -- must be a prime number
-  table.insert( ret, n )
-
-  x = filter(n, x)      -- now remove its multiples
- end
  
- io.stderr:write(id..(MSYS and "\n" or "\t"))   -- mark we're ready
+    io.stderr:write(id..(MSYS and "\n" or "\t"))   -- mark we're ready
 
- return ret     
+    return ret
 end
 -- ** END OF LANE ** --
 
@@ -169,6 +176,7 @@ else
     --
     for i=1,N do
         local tmp= t[i]:join()
+        -- this assert will trigger if you change M to values below 1000 in order to solve C stack overflow
         assert( type(tmp)=="table" and tmp[1]==2 and tmp[168]==997 )
     end
 end
@@ -180,5 +188,7 @@ if TIME then
     io.stderr:write( "*** TIMING: "..t.." seconds ***\n" )
 end
 
+io.stderr:write "done\n"
+
 --
 -- end