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

6 files changed, 306 insertions, 265 deletions

diff --git a/src/keeper.c b/src/keeper.c
index 7485110..3511b56 100644
--- a/src/keeper.c
+++ b/src/keeper.c
@@ -557,7 +557,7 @@ void close_keepers( void)
 *       unclosed, because it does not really matter. In production code, this
 *       function never fails.
 */
-char const* init_keepers( lua_State* L, int const _nbKeepers, lua_CFunction _on_state_create)
+char const* init_keepers( lua_State* L, int _on_state_create, int const _nbKeepers)
 {
         int i;
         assert( _nbKeepers >= 1);
@@ -572,7 +572,7 @@ char const* init_keepers( lua_State* L, int const _nbKeepers, lua_CFunction _on_
                 // 
                 // 'io' for debugging messages, 'package' because we need to require modules exporting idfuncs
                 // the others because they export functions that we may store in a keeper for transfer between lanes
-                K = luaG_newstate( L, "*", _on_state_create);
+                K = luaG_newstate( L, _on_state_create, "*");
 
                 STACK_CHECK( K);
 
@@ -635,8 +635,8 @@ void populate_keepers( lua_State* L)
         char const* name = luaL_checklstring( L, -1, &name_len);
         int i;
 
-        STACK_CHECK( L);
-        STACK_GROW( L, 3);
+        DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "populate_keepers %s BEGIN\n" INDENT_END, name));
+        DEBUGSPEW_CODE( ++ debugspew_indent_depth);
 
         for( i = 0; i < GNbKeepers; ++ i)
         {
@@ -647,16 +647,19 @@ void populate_keepers( lua_State* L)
                 STACK_GROW( K, 2);
                 lua_getglobal( K, "require");
                 lua_pushlstring( K, name, name_len);
-                res = lua_pcall( K, 1, 0, 0);
+                res = lua_pcall( K, 1, 1, 0);
                 if( res != LUA_OK)
                 {
                         char const* err = luaL_checkstring( K, -1);
                         luaL_error( L, "error requiring '%s' in keeper state: %s", name, err);
                 }
+                // after requiring the module, register the functions it exported in our name<->function database
+                populate_func_lookup_table( K, -1, name);
+                lua_pop( K, 1);
                 STACK_END( K, 0);
                 MUTEX_UNLOCK( &GKeepers[i].lock_);
         }
-        STACK_END( L, 0);
+        DEBUGSPEW_CODE( -- debugspew_indent_depth);
 }
 
 struct s_Keeper* keeper_acquire( void const* ptr)
diff --git a/src/keeper.h b/src/keeper.h
index 15a5a41..29a19a9 100644
--- a/src/keeper.h
+++ b/src/keeper.h
@@ -13,7 +13,7 @@ struct s_Keeper
 // problem: maybe on some platforms (linux) atexit() is called after DLL/so are unloaded...
 #define HAVE_KEEPER_ATEXIT_DESINIT 0
 
-char const* init_keepers( lua_State* L, int const _nbKeepers, lua_CFunction _on_state_create);
+char const* init_keepers( lua_State* L, int _on_state_create, int const _nbKeepers);
 #if !HAVE_KEEPER_ATEXIT_DESINIT
 void close_keepers( void);
 #endif // HAVE_KEEPER_ATEXIT_DESINIT
diff --git a/src/lanes.c b/src/lanes.c
index 80f5b15..2b3d8ac 100644
--- a/src/lanes.c
+++ b/src/lanes.c
@@ -52,7 +52,7 @@
  *      ...
  */
 
-char const* VERSION = "3.4.4";
+char const* VERSION = "3.5.0";
 
 /*
 ===============================================================================
@@ -1529,7 +1529,6 @@ LUAG_FUNC( set_singlethreaded)
 # define STACK_TRACE_KEY ((void*)lane_error)     // used as registry key
 # define EXTENDED_STACK_TRACE_KEY ((void*)LG_set_error_reporting)     // used as registry key
 
-#ifdef ERROR_FULL_STACK
 LUAG_FUNC( set_error_reporting)
 {
         bool_t equal;
@@ -1554,7 +1553,6 @@ done:
         lua_rawset( L, LUA_REGISTRYINDEX);
         return 0;
 }
-#endif // ERROR_FULL_STACK
 
 static int lane_error( lua_State* L)
 {
@@ -1735,8 +1733,8 @@ static THREAD_RETURN_T THREAD_CALLCONV lane_main( void *vs)
     // [3..top]: parameters
     //
     rc= lua_pcall( L, lua_gettop(L)-2, LUA_MULTRET, 1 /*error handler*/ );
-        // 0: no error
-        // LUA_ERRRUN: a runtime error (error pushed on stack)
+        // 0: no error, body return values are on the stack
+        // LUA_ERRRUN: cancellation or a runtime error (error pushed on stack)
         // LUA_ERRMEM: memory allocation error
         // LUA_ERRERR: error while running the error handler (if any)
 
@@ -1744,14 +1742,12 @@ static THREAD_RETURN_T THREAD_CALLCONV lane_main( void *vs)
 
     lua_remove(L,1);    // remove error handler
 
-    // Lua 5.1 error handler is limited to one return value; taking stack trace
-    // via registry
-    //
-    if( rc != 0)
+    // Lua 5.1 error handler is limited to one return value; taking stack trace via registry
+    if( rc != LUA_OK)
     {
         STACK_GROW(L,1);
         lua_pushlightuserdata( L, STACK_TRACE_KEY );
-        lua_gettable(L, LUA_REGISTRYINDEX);
+        lua_gettable(L, LUA_REGISTRYINDEX); // yields nil if no stack was generated (in case of cancellation for example)
 
         // For cancellation, a stack trace isn't placed
         //
@@ -1773,7 +1769,7 @@ static THREAD_RETURN_T THREAD_CALLCONV lane_main( void *vs)
         // LUA_ERRMEM(4): memory allocation error
 #endif
 
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "Lane %p body: %s\n" INDENT_END, L, get_errcode_name( rc)));
+    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "Lane %p body: %s (%s)\n" INDENT_END, L, get_errcode_name( rc), (lua_touserdata(L,1)==CANCEL_ERROR) ? "cancelled" : lua_typename( L, lua_type( L, 1))));
     //STACK_DUMP(L);
     // Call finalizers, if the script has set them up.
     //
@@ -1831,6 +1827,26 @@ static THREAD_RETURN_T THREAD_CALLCONV lane_main( void *vs)
     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 lookup databases in source and keeper states
+// module = lanes.require( "modname")
+// upvalue[1]: _G.require
+LUAG_FUNC( require)
+{
+        char const* name = lua_tostring( L, 1);
+        DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lanes.require %s BEGIN\n" INDENT_END, name));
+        DEBUGSPEW_CODE( ++ debugspew_indent_depth);
+        lua_pushvalue( L, lua_upvalueindex(1));   // "name" require
+        lua_pushvalue( L, 1);                     // "name" require "name"
+        lua_call( L, 1, 1);                       // "name" module
+        populate_func_lookup_table( L, -1, name);
+        lua_insert( L, -2);                       // module "name"
+        populate_keepers( L);
+        lua_pop( L, 1);                           // module
+        DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "lanes.require %s END\n" INDENT_END, name));
+        DEBUGSPEW_CODE( -- debugspew_indent_depth);
+        return 1;
+}
 
 //---
 // lane_ud= thread_new( function, [libs_str], 
@@ -1844,32 +1860,6 @@ static THREAD_RETURN_T THREAD_CALLCONV lane_main( void *vs)
 // Upvalues: metatable to use for 'lane_ud'
 //
 
-// helper function to require a module in the keeper states and in the target state
-// source state contains module name at the top of the stack
-static void require_one_module( lua_State* L, lua_State* L2, bool_t _fatal)
-{
-        size_t len;
-        char const* name = lua_tolstring( L, -1, &len);
-        // require the module in the target lane
-        STACK_GROW( L2, 2);
-        lua_getglobal( L2, "require");
-        if( lua_isnil( L2, -1))
-        {
-                lua_pop( L2, 1);
-                if( _fatal)
-                {
-                        luaL_error( L, "cannot pre-require modules without loading 'package' library first");
-                }
-        }
-        else
-        {
-                lua_pushlstring( L2, name, len);
-                lua_pcall( L2, 1, 0, 0);
-                // we need to require this module in the keeper states as well
-                populate_keepers( L);
-        }
-}
-
 LUAG_FUNC( thread_new)
 {
         lua_State* L2;
@@ -1877,17 +1867,17 @@ LUAG_FUNC( thread_new)
         struct s_lane** ud;
 
         char const* libs = lua_tostring( L, 2);
-        lua_CFunction on_state_create = lua_iscfunction( L, 3) ? lua_tocfunction( L, 3) : NULL;
+        int const on_state_create = lua_isfunction( L, 3) ? 3 : 0;
         uint_t cs = luaG_optunsigned( L, 4, 0);
         int prio = (int) luaL_optinteger( L, 5, 0);
-        uint_t glob = luaG_isany( L, 6) ? 6 : 0;
-        uint_t package = luaG_isany( L,7) ? 7 : 0;
-        uint_t required = luaG_isany( L, 8) ? 8 : 0;
+        uint_t glob = lua_isnoneornil( L, 6) ? 0 : 6;
+        uint_t package = lua_isnoneornil( L,7) ? 0 : 7;
+        uint_t required = lua_isnoneornil( L, 8) ? 0 : 8;
 
 #define FIXED_ARGS 8
         uint_t args= lua_gettop(L) - FIXED_ARGS;
 
-        if (prio < THREAD_PRIO_MIN || prio > THREAD_PRIO_MAX)
+        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);
         }
@@ -1898,7 +1888,7 @@ LUAG_FUNC( thread_new)
 
         // populate with selected libraries at  the same time
         //
-        L2 = luaG_newstate( L, libs, on_state_create);
+        L2 = luaG_newstate( L, on_state_create, libs);
 
         STACK_GROW( L, 2);
         STACK_GROW( L2, 3);
@@ -1918,17 +1908,6 @@ LUAG_FUNC( thread_new)
 
         // modules to require in the target lane *before* the function is transfered!
 
-        DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "thread_new: require 'lanes.core'\n" INDENT_END));
-        //start by requiring lanes.core, since it is a bit special
-        // it is not fatal if 'require' isn't loaded, just ignore (may cause function transfer errors later on if the lane pulls the lanes module itself)
-        STACK_CHECK( L);
-        STACK_CHECK( L2);
-        lua_pushliteral( L, "lanes.core");
-        require_one_module( L, L2, FALSE);
-        lua_pop( L, 1);
-        STACK_END( L2, 0);
-        STACK_END (L, 0);
-
         STACK_CHECK( L);
         STACK_CHECK( L2);
         if( required)
@@ -1941,6 +1920,7 @@ LUAG_FUNC( thread_new)
                 {
                         return luaL_error( L, "expected required module list as a table, got %s", luaL_typename( L, required));
                 }
+
                 lua_pushnil( L);
                 while( lua_next( L, required) != 0)
                 {
@@ -1950,7 +1930,32 @@ LUAG_FUNC( thread_new)
                         }
                         else
                         {
-                                require_one_module( L, L2, TRUE);
+                                // 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);
+
+                                // require the module in the target lane
+                                STACK_GROW( L2, 2);
+                                STACK_CHECK( L2);
+                                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
+                                        lua_pcall( L2, 1, 1, 0);                           // ret
+                                        STACK_MID( L2, 1);
+                                        // after requiring the module, register the functions it exported in our name<->function database
+                                        populate_func_lookup_table( L2, -1, name);
+                                        STACK_MID( L2, 1);
+                                        lua_pop( L2, 1);
+                                        // don't require this module in the keeper states as well, use lanes.require() for that!
+                                        //populate_keepers( L);
+                                }
+                                STACK_END( L2, 0);
                         }
                         lua_pop( L, 1);
                         ++ nbRequired;
@@ -2578,7 +2583,7 @@ static const struct luaL_Reg lanes_functions [] = {
 /*
 * One-time initializations
 */
-static void init_once_LOCKED( lua_State* L, int const nbKeepers, lua_CFunction _on_state_create, lua_Number _shutdown_timeout, bool_t _track_lanes)
+static void init_once_LOCKED( lua_State* L, int const _on_state_create, int const nbKeepers, lua_Number _shutdown_timeout, bool_t _track_lanes)
 {
     char const* err;
 
@@ -2603,7 +2608,7 @@ static void init_once_LOCKED( lua_State* L, int const nbKeepers, lua_CFunction _
         //
         MUTEX_RECURSIVE_INIT( &require_cs );
 
-        serialize_require( L );
+        serialize_require( L);
 
         // Linked chains handling
         //
@@ -2635,7 +2640,7 @@ static void init_once_LOCKED( lua_State* L, int const nbKeepers, lua_CFunction _
         }
   #endif
 #endif
-    err = init_keepers( L, nbKeepers, _on_state_create);
+    err = init_keepers( L, _on_state_create, nbKeepers);
     if (err)
     {
             (void) luaL_error( L, "Unable to initialize: %s", err );
@@ -2691,7 +2696,7 @@ LUAG_FUNC( configure)
         char const* name = luaL_checkstring( L, lua_upvalueindex( 1));
         // all parameter checks are done lua-side
         int const nbKeepers = (int)lua_tointeger( L, 1);
-        lua_CFunction on_state_create = lua_iscfunction( L, 2) ? lua_tocfunction( L, 2) : NULL;
+        int const on_state_create = lua_isfunction( L, 2) ? 2 : 0;
         lua_Number shutdown_timeout = lua_tonumber( L, 3);
         bool_t track_lanes = lua_toboolean( L, 4);
 
@@ -2732,6 +2737,11 @@ LUAG_FUNC( configure)
         lua_pushcclosure( L, LG_thread_new, 1);                                // ... M LG_thread_new
         lua_setfield(L, -2, "thread_new");                                     // ... M
 
+        // we can't register 'lanes.require' normally because we want to create an upvalued closure
+        lua_getglobal( L, "require");                                          // ... M require
+        lua_pushcclosure( L, LG_require, 1);                                   // ... M lanes.require
+        lua_setfield( L, -2, "require");                                       // ... M
+
         lua_pushstring(L, VERSION);                                            // ... M VERSION
         lua_setfield(L, -2, "version");                                        // ... M
 
@@ -2743,7 +2753,7 @@ LUAG_FUNC( configure)
 
         // 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.*
+        // for example in package.loaded["lanes.core"].*
         populate_func_lookup_table( L, -1, name);
 
         // record all existing C/JIT-fast functions
@@ -2768,7 +2778,7 @@ LUAG_FUNC( configure)
                 static volatile int /*bool*/ go_ahead; // = 0
                 if( InterlockedCompareExchange( &s_initCount, 1, 0) == 0)
                 {
-                        init_once_LOCKED( L, nbKeepers, on_state_create, shutdown_timeout, track_lanes);
+                        init_once_LOCKED( L, on_state_create, nbKeepers, shutdown_timeout, track_lanes);
                         go_ahead = 1;    // let others pass
                 }
                 else
@@ -2786,7 +2796,7 @@ LUAG_FUNC( configure)
                         //
                         if( s_initCount == 0)
                         {
-                                init_once_LOCKED( L, nbKeepers, on_state_create, shutdown_timeout, track_lanes);
+                                init_once_LOCKED( L, on_state_create, nbKeepers, shutdown_timeout, track_lanes);
                                 s_initCount = 1;
                         }
                 }
diff --git a/src/lanes.lua b/src/lanes.lua
index 1d50f97..f4eef81 100644
--- a/src/lanes.lua
+++ b/src/lanes.lua
@@ -123,9 +123,6 @@ lanes.configure = function( _params)
 
         local set_singlethreaded = assert( core.set_singlethreaded)
 
-        local now_secs = assert( core.now_secs)
-        local wakeup_conv = assert( core.wakeup_conv)
-
         local max_prio = assert( core.max_prio)
 
 lanes.ABOUT= 
@@ -311,6 +308,7 @@ local linda = core.linda
 
 -- PUBLIC LANES API
 local timer = function() error "timers are not active" end
+local timer_lane = nil
 local timers = timer
 
 if _params.with_timers ~= false then
@@ -338,158 +336,161 @@ timer_gateway:set(first_time_key,true)
 -- has 'table' always declared)
 --
 if first_time then
-    local table_remove= assert( table.remove )
-    local table_insert= assert( table.insert )
 
-    --
-    -- { [deep_linda_lightuserdata]= { [deep_linda_lightuserdata]=linda_h, 
-    --                                 [key]= { wakeup_secs [,period_secs] } [, ...] },
-    -- }
-    --
-    -- Collection of all running timers, indexed with linda's & key.
-    --
-    -- Note that we need to use the deep lightuserdata identifiers, instead
-    -- of 'linda_h' themselves as table indices. Otherwise, we'd get multiple
-    -- entries for the same timer.
-    --
-    -- The 'hidden' reference to Linda proxy is used in 'check_timers()' but
-    -- also important to keep the Linda alive, even if all outside world threw
-    -- away pointers to it (which would ruin uniqueness of the deep pointer).
-    -- Now we're safe.
-    --
-    local collection= {}
-
-    local function get_timers()
-        local r = {}
-        for deep, t in pairs( collection) do
-            -- WR( tostring( deep))
-            local l = t[deep]
-            for key, timer_data in pairs( t) do
-                if key ~= deep then
-                    table_insert( r, {l, key, timer_data})
-                end
-            end
-        end
-        return r
-    end
-    --
-    -- set_timer( linda_h, key [,wakeup_at_secs [,period_secs]] )
-    --
-    local function set_timer( linda, key, wakeup_at, period )
-        assert( wakeup_at==nil or wakeup_at>0.0 )
-        assert( period==nil or period>0.0 )
+        -----
+        -- Snore loop (run as a lane on the background)
+        --
+        -- High priority, to get trustworthy timings.
+        --
+        -- We let the timer lane be a "free running" thread; no handle to it
+        -- remains.
+        --
+        local timer_body = function()
+                -- require lanes.core inside the timer body to prevent pulling now_secs() through an uvpvalue
+                local core = require "lanes.core"
+
+                --
+                -- { [deep_linda_lightuserdata]= { [deep_linda_lightuserdata]=linda_h, 
+                --                                 [key]= { wakeup_secs [,period_secs] } [, ...] },
+                -- }
+                --
+                -- Collection of all running timers, indexed with linda's & key.
+                --
+                -- Note that we need to use the deep lightuserdata identifiers, instead
+                -- of 'linda_h' themselves as table indices. Otherwise, we'd get multiple
+                -- entries for the same timer.
+                --
+                -- The 'hidden' reference to Linda proxy is used in 'check_timers()' but
+                -- also important to keep the Linda alive, even if all outside world threw
+                -- away pointers to it (which would ruin uniqueness of the deep pointer).
+                -- Now we're safe.
+                --
+                local collection = {}
+                local table_insert = assert( table.insert)
+
+                local get_timers = function()
+                        local r = {}
+                        for deep, t in pairs( collection) do
+                                -- WR( tostring( deep))
+                                local l = t[deep]
+                                for key, timer_data in pairs( t) do
+                                        if key ~= deep then
+                                                table_insert( r, {l, key, timer_data})
+                                        end
+                                end
+                        end
+                        return r
+                end -- get_timers()
 
-        local linda_deep= linda:deep()
-        assert( linda_deep )
+                --
+                -- set_timer( linda_h, key [,wakeup_at_secs [,period_secs]] )
+                --
+                local set_timer = function( linda, key, wakeup_at, period)
+                        assert( wakeup_at == nil or wakeup_at > 0.0)
+                        assert( period == nil or period > 0.0)
 
-        -- Find or make a lookup for this timer
-        --
-        local t1= collection[linda_deep]
-        if not t1 then
-            t1= { [linda_deep]= linda }     -- proxy to use the Linda
-            collection[linda_deep]= t1
-        end
-    
-        if wakeup_at==nil then
-            -- Clear the timer
-            --
-            t1[key]= nil
-
-            -- Remove empty tables from collection; speeds timer checks and
-            -- lets our 'safety reference' proxy be gc:ed as well.
-            --
-            local empty= true
-            for k,_ in pairs(t1) do
-                if k~= linda_deep then
-                    empty= false; break
-                end
-            end
-            if empty then
-                collection[linda_deep]= nil
-            end
-            
-            -- Note: any unread timer value is left at 'linda[key]' intensionally;
-            --       clearing a timer just stops it.
-        else
-            -- New timer or changing the timings
-            --
-            local t2= t1[key]
-            if not t2 then
-                t2= {}; t1[key]= t2
-            end
-    
-            t2[1]= wakeup_at
-            t2[2]= period   -- can be 'nil'
-        end
-    end
+                        local linda_deep = linda:deep()
+                        assert( linda_deep)
+
+                        -- Find or make a lookup for this timer
+                        --
+                        local t1 = collection[linda_deep]
+                        if not t1 then
+                                t1 = { [linda_deep] = linda}     -- proxy to use the Linda
+                                collection[linda_deep] = t1
+                        end
+                
+                        if wakeup_at == nil then
+                                -- Clear the timer
+                                --
+                                t1[key]= nil
+
+                                -- Remove empty tables from collection; speeds timer checks and
+                                -- lets our 'safety reference' proxy be gc:ed as well.
+                                --
+                                local empty = true
+                                for k, _ in pairs( t1) do
+                                        if k ~= linda_deep then
+                                                empty = false
+                                                break
+                                        end
+                                end
+                                if empty then
+                                        collection[linda_deep] = nil
+                                end
+
+                                -- Note: any unread timer value is left at 'linda[key]' intensionally;
+                                --       clearing a timer just stops it.
+                        else
+                                -- New timer or changing the timings
+                                --
+                                local t2 = t1[key]
+                                if not t2 then
+                                        t2= {}
+                                        t1[key]= t2
+                                end
+                
+                                t2[1] = wakeup_at
+                                t2[2] = period   -- can be 'nil'
+                        end
+                end -- set_timer()
+
+                local now_secs = core.now_secs
+                assert( type( now_secs) == "function")
+                -----
+                -- [next_wakeup_at]= check_timers()
+                -- Check timers, and wake up the ones expired (if any)
+                -- Returns the closest upcoming (remaining) wakeup time (or 'nil' if none).
+                local check_timers = function()
+                        local now = now_secs()
+                        local next_wakeup
+
+                        for linda_deep,t1 in pairs(collection) do
+                                for key,t2 in pairs(t1) do
+                                        --
+                                        if key==linda_deep then
+                                                -- no 'continue' in Lua :/
+                                        else
+                                                -- 't2': { wakeup_at_secs [,period_secs] }
+                                                --
+                                                local wakeup_at= t2[1]
+                                                local period= t2[2]     -- may be 'nil'
+
+                                                if wakeup_at <= now then    
+                                                        local linda= t1[linda_deep]
+                                                        assert(linda)
+                
+                                                        linda:set( key, now )
+                                
+                                                        -- 'pairs()' allows the values to be modified (and even
+                                                        -- removed) as far as keys are not touched
+
+                                                        if not period then
+                                                                -- one-time timer; gone
+                                                                --
+                                                                t1[key]= nil
+                                                                wakeup_at= nil   -- no 'continue' in Lua :/
+                                                        else
+                                                                -- repeating timer; find next wakeup (may jump multiple repeats)
+                                                                --
+                                                                repeat
+                                                                                wakeup_at= wakeup_at+period
+                                                                until wakeup_at > now
+
+                                                                t2[1]= wakeup_at
+                                                        end
+                                                end
+                                                                                
+                                                if wakeup_at and ((not next_wakeup) or (wakeup_at < next_wakeup)) then
+                                                        next_wakeup= wakeup_at
+                                                end 
+                                        end
+                                end -- t2 loop
+                        end -- t1 loop
+
+                        return next_wakeup  -- may be 'nil'
+                end -- check_timers()
 
-    -----
-    -- [next_wakeup_at]= check_timers()
-    --
-    -- Check timers, and wake up the ones expired (if any)
-    --
-    -- Returns the closest upcoming (remaining) wakeup time (or 'nil' if none).
-    --
-    local function check_timers()
-
-        local now= now_secs()
-        local next_wakeup
-
-        for linda_deep,t1 in pairs(collection) do
-            for key,t2 in pairs(t1) do
-                --
-                if key==linda_deep then
-                    -- no 'continue' in Lua :/
-                else
-                    -- 't2': { wakeup_at_secs [,period_secs] }
-                    --
-                    local wakeup_at= t2[1]
-                    local period= t2[2]     -- may be 'nil'
-                    
-                    if wakeup_at <= now then    
-                        local linda= t1[linda_deep]
-                        assert(linda)
-    
-                        linda:set( key, now )
-        
-                        -- 'pairs()' allows the values to be modified (and even
-                        -- removed) as far as keys are not touched
-                                                
-                        if not period then
-                            -- one-time timer; gone
-                            --
-                            t1[key]= nil
-                            wakeup_at= nil   -- no 'continue' in Lua :/
-                        else
-                            -- repeating timer; find next wakeup (may jump multiple repeats)
-                            --
-                            repeat
-                                wakeup_at= wakeup_at+period
-                            until wakeup_at > now
-    
-                            t2[1]= wakeup_at
-                        end
-                    end
-                    
-                    if wakeup_at and ((not next_wakeup) or (wakeup_at < next_wakeup)) then
-                        next_wakeup= wakeup_at
-                    end 
-                end
-            end -- t2 loop
-        end -- t1 loop
-        
-        return next_wakeup  -- may be 'nil'
-    end    
-
-    -----
-    -- Snore loop (run as a lane on the background)
-    --
-    -- High priority, to get trustworthy timings.
-    --
-    -- We let the timer lane be a "free running" thread; no handle to it
-    -- remains.
-    --
-        local timer_body = function()
                 local timer_gateway_batched = timer_gateway.batched
                 set_debug_threadname( "LanesTimer")
                 set_finalizer( function( err, stk)
@@ -502,7 +503,7 @@ if first_time then
                         end
                 end)
                 while true do
-                        local next_wakeup= check_timers()
+                        local next_wakeup = check_timers()
 
                         -- Sleep until next timer to wake up, or a set/clear command
                         --
@@ -528,9 +529,9 @@ if first_time then
                         --      WR( "timer lane: no linda, aborted?")
                         end
                 end
-        end
-        gen( "*", { package= {}, priority = max_prio}, timer_body)() -- "*" instead of "io,package" for LuaJIT compatibility...
-end
+        end -- timer_body()
+        timer_lane = gen( "*", { package= {}, priority = max_prio}, timer_body)() -- "*" instead of "io,package" for LuaJIT compatibility...
+end -- first_time
 
 -----
 -- = timer( linda_h, key_val, date_tbl|first_secs [,period_secs] )
@@ -540,13 +541,13 @@ timer = function( linda, key, a, period )
     if getmetatable( linda) ~= "Linda" then
         error "expecting a Linda"
     end
-    if a==0.0 then
+    if a == 0.0 then
         -- Caller expects to get current time stamp in Linda, on return
         -- (like the timer had expired instantly); it would be good to set this
         -- as late as possible (to give most current time) but also we want it
         -- to precede any possible timers that might start striking.
         --
-        linda:set( key, now_secs() )
+        linda:set( key, core.now_secs())
 
         if not period or period==0.0 then
             timer_gateway:send( TGW_KEY, linda, key, nil, nil )   -- clear the timer
@@ -555,8 +556,8 @@ timer = function( linda, key, a, period )
         a= period
     end
 
-    local wakeup_at= type(a)=="table" and wakeup_conv(a)    -- given point of time
-                                       or (a and now_secs()+a or nil)
+    local wakeup_at= type(a)=="table" and core.wakeup_conv(a)    -- given point of time
+                                       or (a and core.now_secs()+a or nil)
     -- queue to timer
     --
     timer_gateway:send( TGW_KEY, linda, key, wakeup_at, period )
@@ -639,15 +640,17 @@ local function genatomic( linda, key, initial_val )
 end
 
         -- activate full interface
+        lanes.require = core.require
         lanes.gen = gen
         lanes.linda = core.linda
         lanes.cancel_error = core.cancel_error
         lanes.nameof = core.nameof
         lanes.threads = (_params.track_lanes and core.threads) and core.threads or function() error "lane tracking is not available" end
         lanes.timer = timer
+        lanes.timer_lane = timer_lane
         lanes.timers = timers
         lanes.genlock = genlock
-        lanes.now_secs = now_secs
+        lanes.now_secs = core.now_secs
         lanes.genatomic = genatomic
         -- from now on, calling configure does nothing but checking that we don't call it with parameters that changed compared to the first invocation
         lanes.configure = function( _params2)
diff --git a/src/tools.c b/src/tools.c
index 552e61e..9961c1a 100644
--- a/src/tools.c
+++ b/src/tools.c
@@ -224,7 +224,7 @@ static char const* luaG_pushFQN(lua_State *L, int t, int last)
         {
                 lua_rawgeti( L, t, i);
                 luaL_addvalue( &b);
-                luaL_addlstring(&b, ".", 1);
+                luaL_addlstring(&b, "/", 1);
         }
         if( i == last)  // add last value (if interval was not empty)
         {
@@ -250,9 +250,16 @@ static void populate_func_lookup_table_recur( lua_State* L, int _ctx_base, int _
         int const breadth_first_cache = lua_gettop( L) + 1;
 
         STACK_GROW( L, 6);
-        // slot _i contains a table where we search for functions
+        // slot _i contains a table where we search for functions (or a full userdata with a metatable)
         STACK_CHECK( L);                                                                          // ... {_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}
+        }
+
         // if table is already visited, we are done
         lua_pushvalue( L, _i);                                                                    // ... {_i} {}
         lua_rawget( L, cache);                                                                    // ... {_i} nil|n
@@ -437,7 +444,7 @@ void populate_func_lookup_table( lua_State* L, int _i, char const* _name)
 *
 */
 
-lua_State* luaG_newstate( lua_State* _from, char const* libs, lua_CFunction _on_state_create)
+lua_State* luaG_newstate( lua_State* _from, int const _on_state_create, char const* libs)
 {
         // reuse alloc function from the originating state
         void* allocUD;
@@ -450,7 +457,7 @@ lua_State* luaG_newstate( lua_State* _from, char const* libs, lua_CFunction _on_
         }
 
         // neither libs (not even 'base') nor special init func: we are done
-        if( !libs && !_on_state_create)
+        if( libs == NULL && _on_state_create <= 0)
         {
                 return L;
         }
@@ -460,13 +467,6 @@ lua_State* luaG_newstate( lua_State* _from, char const* libs, lua_CFunction _on_
 
         STACK_GROW( L, 2);
         STACK_CHECK( L);
-        if( _on_state_create)
-        {
-                DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "calling on_state_create()\n" INDENT_END));
-                lua_pushcfunction( L, _on_state_create);
-                lua_call( L, 0, 0);
-        }
-
         // 'lua.c' stops GC during initialization so perhaps its a good idea. :)
         // but do it after _on_state_create in case it does a lot of stuff...
         lua_gc( L, LUA_GCSTOP, 0);
@@ -520,7 +520,29 @@ lua_State* luaG_newstate( lua_State* _from, char const* libs, lua_CFunction _on_
         lua_gc( L, LUA_GCRESTART, 0);
 
         STACK_CHECK( L);
-        // after opening base, register the functions it exported in our name<->function database
+        // call this after the base libraries are loaded!
+        if( _on_state_create > 0)
+        {
+                DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "calling on_state_create()\n" INDENT_END));
+                if( lua_iscfunction( _from, _on_state_create))
+                {
+                        // C function: recreate a closure in the new state, bypassing the lookup scheme
+                        lua_CFunction osc = lua_tocfunction( _from, _on_state_create);
+                        lua_pushcfunction( L, osc);
+                }
+                else
+                {
+                        STACK_CHECK( _from);
+                        // Lua function: transfer as usual (should work as long as it only uses base libraries)
+                        lua_pushvalue( _from, _on_state_create);
+                        luaG_inter_move( _from, L, 1);
+                        STACK_END( _from, 0);
+                }
+                lua_call( L, 0, 0);
+                STACK_MID( 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);
         lua_pop( L, 1);
@@ -1180,9 +1202,9 @@ static void inter_copy_func( lua_State* L2, uint_t L2_cache_i, lua_State* L, uin
 
 static void push_cached_func( lua_State* L2, uint_t L2_cache_i, lua_State* L, uint_t i)
 {
-        void * const aspointer = (void*)lua_topointer( L, i);
+        void* const aspointer = (void*)lua_topointer( L, i);
         // TBD: Merge this and same code for tables
-        ASSERT_L( L2_cache_i != 0 );
+        ASSERT_L( L2_cache_i != 0);
 
         STACK_GROW( L2, 2);
 
@@ -1199,8 +1221,8 @@ static void push_cached_func( lua_State* L2, uint_t L2_cache_i, lua_State* L, ui
 
         //fprintf( stderr, "<< ID: %s >>\n", lua_tostring(L2,-1) );
 
-        lua_pushvalue( L2, -1 );                                      // ... {cache} ... p p
-        lua_rawget( L2, L2_cache_i );                                 // ... {cache} ... p function|nil|true
+        lua_pushvalue( L2, -1);                                       // ... {cache} ... p p
+        lua_rawget( L2, L2_cache_i);                                  // ... {cache} ... p function|nil|true
 
         if( lua_isnil(L2,-1)) // function is unknown
         {
@@ -1209,7 +1231,7 @@ static void push_cached_func( lua_State* L2, uint_t L2_cache_i, lua_State* L, ui
                 // Set to 'true' for the duration of creation; need to find self-references
                 // via upvalues
                 //
-                // pushes a copy of the func, a stores a reference in the cache
+                // pushes a copy of the func, stores a reference in the cache
                 inter_copy_func( L2, L2_cache_i, L, i);                     // ... {cache} ... function
         }
         else // found function in the cache
@@ -1426,7 +1448,9 @@ static void inter_copy_func( lua_State* L2, uint_t L2_cache_i, lua_State* L, uin
                 // if already on top of the stack, no need to push again
                 int needToPush = (i != (uint_t)lua_gettop( L));
                 if( needToPush)
+                {
                         lua_pushvalue( L, i);                                // ... f
+                }
 
                 luaL_buffinit( L, &b);
                 //
@@ -1568,11 +1592,11 @@ static void inter_copy_func( lua_State* L2, uint_t L2_cache_i, lua_State* L, uin
 *
 * Returns TRUE if value was pushed, FALSE if its type is non-supported.
 */
-static bool_t inter_copy_one_( lua_State *L2, uint_t L2_cache_i, lua_State *L, uint_t i, enum e_vt vt )
+static bool_t inter_copy_one_( lua_State* L2, uint_t L2_cache_i, lua_State* L, uint_t i, enum e_vt vt)
 {
-        bool_t ret= TRUE;
+        bool_t ret = TRUE;
 
-        STACK_GROW( L2, 1 );
+        STACK_GROW( L2, 1);
 
         STACK_CHECK( L2);
 
@@ -1626,6 +1650,7 @@ static bool_t inter_copy_one_( lua_State *L2, uint_t L2_cache_i, lua_State *L, u
                 }
                 /* Allow only deep userdata entities to be copied across
                 */
+                DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "USERDATA\n" INDENT_END));
                 if( !luaG_copydeep( L, L2, i))
                 {
                         // Cannot copy it full; copy as light userdata
@@ -1669,7 +1694,6 @@ static bool_t inter_copy_one_( lua_State *L2, uint_t L2_cache_i, lua_State *L, u
 #endif
                         STACK_CHECK( L2);
                         push_cached_func( L2, L2_cache_i, L, i);
-                        ASSERT_L( lua_isfunction( L2, -1));
                         STACK_END( L2, 1);
                 }
                 break;
@@ -1827,7 +1851,7 @@ static bool_t inter_copy_one_( lua_State *L2, uint_t L2_cache_i, lua_State *L, u
 *
 * Note: Parameters are in this order ('L' = from first) to be same as 'lua_xmove'.
 */
-int luaG_inter_copy( lua_State* L, lua_State *L2, uint_t n)
+int luaG_inter_copy( lua_State* L, lua_State* L2, uint_t n)
 {
         uint_t top_L = lua_gettop( L);
         uint_t top_L2 = lua_gettop( L2);
@@ -1903,7 +1927,9 @@ void luaG_inter_copy_package( lua_State* L, lua_State* L2, int _idx)
         {
                 int i;
                 // package.loaders is renamed package.searchers in Lua 5.2
-                char const* entries[] = { "path", "cpath", "preload", (LUA_VERSION_NUM == 501) ? "loaders" : "searchers", NULL};
+                // 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
+                char const* entries[] = { "path", "cpath", "preload"/*, (LUA_VERSION_NUM == 501) ? "loaders" : "searchers"*/, NULL};
                 for( i = 0; entries[i]; ++ i)
                 {
                         DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "%s\n" INDENT_END, entries[i]));
@@ -1944,7 +1970,7 @@ MUTEX_T require_cs;
 //
 // Upvalues: [1]: original 'require' function
 //
-static int new_require( lua_State *L)
+int luaG_new_require( lua_State* L)
 {
         int rc, i;
         int args = lua_gettop( L);
@@ -1955,24 +1981,24 @@ static int new_require( lua_State *L)
 
         lua_pushvalue( L, lua_upvalueindex(1));
         for( i = 1; i <= args; ++ i)
+        {
                 lua_pushvalue( L, i);
+        }
 
         // Using 'lua_pcall()' to catch errors; otherwise a failing 'require' would
         // leave us locked, blocking any future 'require' calls from other lanes.
         //
         MUTEX_LOCK( &require_cs);
-        {
-                rc = lua_pcall( L, args, 1 /*retvals*/, 0 /*errfunc*/ );
-                //
-                // LUA_ERRRUN / LUA_ERRMEM
-        }
+        rc = lua_pcall( L, args, 1 /*retvals*/, 0 /*errfunc*/ );
         MUTEX_UNLOCK( &require_cs);
 
         // the required module (or an error message) is left on the stack as returned value by original require function
         STACK_END( L, 1);
 
-        if (rc)
-                lua_error(L);   // error message already at [-1]
+        if( rc != LUA_OK) // LUA_ERRRUN / LUA_ERRMEM ?
+        {
+                return lua_error( L);   // error message already at [-1]
+        }
 
         return 1;
 }
@@ -1980,7 +2006,7 @@ static int new_require( lua_State *L)
 /*
 * Serialize calls to 'require', if it exists
 */
-void serialize_require( lua_State *L )
+void serialize_require( lua_State* L)
 {
         STACK_GROW( L, 1);
         STACK_CHECK( L);
@@ -1991,7 +2017,7 @@ void serialize_require( lua_State *L )
         if( lua_isfunction( L, -1))
         {
                 // [-1]: original 'require' function
-                lua_pushcclosure( L, new_require, 1 /*upvalues*/);
+                lua_pushcclosure( L, luaG_new_require, 1 /*upvalues*/);
                 lua_setglobal( L, "require");
         }
         else
diff --git a/src/tools.h b/src/tools.h
index f79d2ad..a06e23f 100644
--- a/src/tools.h
+++ b/src/tools.h
@@ -78,11 +78,9 @@ extern int debugspew_indent_depth;
 #define luaG_optunsigned(L,i,d) ((uint_t) luaL_optinteger(L,i,d))
 #define luaG_tounsigned(L,i) ((uint_t) lua_tointeger(L,i))
 
-#define luaG_isany(L,i)  (!lua_isnil(L,i))
-
 void luaG_dump( lua_State* L );
 
-lua_State* luaG_newstate( lua_State* _from, char const* libs, lua_CFunction _on_state_create);
+lua_State* luaG_newstate( lua_State* _from, int const _on_state_create, char const* libs);
 
 typedef struct {
     volatile int refcount;
@@ -96,6 +94,7 @@ int luaG_inter_copy( lua_State *L, lua_State *L2, uint_t n);
 int luaG_inter_move( lua_State *L, lua_State *L2, uint_t n);
 
 int luaG_nameof( lua_State* L);
+int luaG_new_require( lua_State* L);
 
 // Lock for reference counter inc/dec locks (to be initialized by outside code)
 //