13 files changed, 421 insertions, 278 deletions

diff --git a/CHANGES b/CHANGES
index 66b5c23..3957956 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,5 +1,19 @@
 CHANGES:
 
+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
@@ -210,7 +224,7 @@ CHANGE 19 BGe 2-Dec-2010:
 
 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
+    A bit of code cleanup
 
 CHANGE 17 BGe 21-Sept-2010:
     Fixed stupid compilation errors.
diff --git a/Makefile b/Makefile
index 5406dad..fc44fac 100644
--- a/Makefile
+++ b/Makefile
@@ -88,6 +88,8 @@ test:
         $(MAKE) atexit
         $(MAKE) linda_perf
         $(MAKE) rupval
+        $(MAKE) package
+        $(MAKE) pingpong
 
 basic: tests/basic.lua $(_TARGET_SO)
         $(_PREFIX) $(LUA) $<
@@ -167,6 +169,12 @@ atexit: tests/atexit.lua $(_TARGET_SO)
 rupval: tests/rupval.lua $(_TARGET_SO)
         $(_PREFIX) $(LUA) $<
 
+package: tests/package.lua $(_TARGET_SO)
+        $(_PREFIX) $(LUA) $<
+
+pingpong: tests/pingpong.lua $(_TARGET_SO)
+        $(_PREFIX) $(LUA) $<
+
 #---
 perftest-plain: tests/perftest.lua $(_TARGET_SO)
         $(MAKE) _perftest ARGS="$< $(N) -plain"
diff --git a/docs/index.html b/docs/index.html
index 4f31923..8b21a97 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -69,7 +69,7 @@
                         </p>
 
                         <p>
-                                This document was revised on 26-Jan-13, and applies to version <tt>3.4.4</tt>.
+                                This document was revised on 30-Jan-13, and applies to version <tt>3.5.0</tt>.
                         </p>
                 </font>
         </center>
@@ -249,10 +249,17 @@
                                 <code>.on_state_create</code>
                         </td>
                         <td>
-                                C function/<tt>nil</tt>
+                                function/<tt>nil</tt>
                         </td>
                         <td>
-                                If provided, will be called in every created Lua state (keepers and lanes) right after it is created, and *before* any library is loaded. That way, all C functions it loads in the state can be added to the function lookup database. Default is <tt>nil</tt>.
+                                If provided, will be called in every created Lua state (keepers and lanes) right after initializing the base libraries.
+                                <br>
+                                Typical usage is twofold:
+                                <ul>
+                                        <li>Tweak <tt>package.loaders</tt></li>
+                                        <li>Load some additional C functions in the global space (of course only a C function will be able to do this).</li>
+                                </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>.
                         </td>
                 </tr>
 
@@ -270,6 +277,22 @@
         </table>
 </p>
 
+<p>
+        NEW (version 3.5.0)
+        <br>
+        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.
+</p>
+
+<table border="1" bgcolor="#FFFFE0" cellpadding="10" style="width:50%">
+        <tr>
+                <td>
+                        <pre>   local m = lanes.require "modname"</pre>
+                </td>
+        </tr>
+</table>
+
 <hr/>
 <h2 id="creation">Creation</h2>
 
@@ -468,6 +491,8 @@
                                 These tables are built from the modules listed here. <tt>required</tt> must be a list of strings, each one being the name of a module to be required. Each module is required with <tt>require()</tt> before the lanes function is invoked.
                                 So, from the required module's point of view, requiring it manually from inside the lane body or having it required this way doesn't change anything. From the lane body's point of view, the only difference is that a module not creating a global won't be accessible.
                                 Therefore, a lane body will also have to require a module manually, but this won't do anything more (see Lua's <tt>require</tt> documentation).
+                                <br>
+                                ATTEMPTING TO TRANSFER A FUNCTION REGISTERED BY A MODULE NOT LISTED HERE WILL RAISE AN ERROR.
                         </td>
                 </tr>
                 <tr valign=top>
@@ -567,7 +592,7 @@
                         </td>
                         <td/>
                         <td>
-                                running, not suspended on a Linda call.
+                                running, not suspended on a <a href="#lindas">Linda</a> call.
                         </td>
                 </tr>
                 <tr>
@@ -577,7 +602,7 @@
                         </td>
                         <td/>
                         <td>
-                                waiting at a Linda <tt>:receive()</tt> or <tt>:send()</tt>
+                                waiting at a <a href="#lindas">Linda</a> <tt>:receive()</tt> or <tt>:send()</tt>
                         </td>
                 </tr>
                 <tr>
@@ -711,7 +736,7 @@
 </pre></td></tr></table>
 
 <p>
-        If you want to wait for multiple lanes to finish (any of a set of lanes), use a <a href="#lindas">Linda</a> object. Give each lane a specific id, and send that id over a Linda once that thread is done (as the last thing you do).
+        If you want to wait for multiple lanes to finish (any of a set of lanes), use a <a href="#lindas">Linda</a> object. Give each lane a specific id, and send that id over a <a href="#lindas">Linda</a> once that thread is done (as the last thing you do).
 </p>
 
 <table border=1 bgcolor="#FFFFE0" cellpadding="10" style="width:50%"><tr><td><pre>
@@ -750,7 +775,7 @@
 <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.
         <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 linda with infinite timeout).
+        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>
         The code should be able to handle this situation appropriately if required (in other words, it should gracefully handle the fact that it didn't receive the expected values).
         <br>
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)
 //
diff --git a/tests/fibonacci.lua b/tests/fibonacci.lua
index 48cd8d7..a5e0b2a 100644
--- a/tests/fibonacci.lua
+++ b/tests/fibonacci.lua
@@ -28,6 +28,7 @@ local KNOWN= { [0]=0, 1,1,2,3,5,8,13,21,34,55,89,144 }
 -- uint= fib( n_uint )
 --
 local function fib( n )
+        --local lanes = require"lanes".configure()
     --
     local sum
     local floor= assert(math.floor)
@@ -39,9 +40,11 @@ local function fib( n )
     else
         -- Splits into two; this task remains waiting for the results
         --
-        -- note that lanes is pulled in as upvalue, so we need package library to require internals properly
-        -- (because lua51-lanes is always required internally if possible, which is necessary in that case)
-        local gen_f= lanes.gen( "*", fib )
+        -- note that lanes is pulled in by upvalue, so we need lanes.core to be available
+                                -- the other solution is to require "lanes" from inside the lane body, as in:
+                                -- local lanes = require"lanes".configure()
+        -- local gen_f= lanes.gen( "*", fib)
+        local gen_f= lanes.gen( "*", {required={"lanes.core"}}, fib)
 
         local n1=floor(n/2) +1
         local n2=floor(n/2) -1 + n%2
diff --git a/tests/package.lua b/tests/package.lua
new file mode 100644
index 0000000..7c72d35
--- /dev/null
+++ b/tests/package.lua
@@ -0,0 +1,20 @@
+assert(nil == package.loaders[5])
+
+local configure_loaders = function()
+        table.insert(package.loaders, 4, function() end)
+        assert(package.loaders[1])
+        assert(package.loaders[2])
+        assert(package.loaders[3])
+        assert(package.loaders[4])
+        assert(package.loaders[5])
+        print "loaders configured!"
+end
+
+configure_loaders()
+
+for k,v in pairs(package.loaders) do
+        print( k, type(v))
+end
+
+lanes = require "lanes"
+lanes.configure{with_timers=false, on_state_create = configure_loaders}
\ No newline at end of file
diff --git a/tests/pingpong.lua b/tests/pingpong.lua
new file mode 100644
index 0000000..30cd360
--- /dev/null
+++ b/tests/pingpong.lua
@@ -0,0 +1,31 @@
+local lanes = require 'lanes'.configure()
+local q = lanes.linda()
+
+local pingpong = function(name, qr, qs, start)
+    print("start " .. name, qr, qs, start)
+    local count = 0
+    if start then
+        print(name .. ": sending " .. qs .. " 0")
+        q:send(qs, 0)
+    end
+    while count < 10 do
+        print(name .. ": receiving " .. qr)
+        local key, val = q:receive(qr)
+        if val == nil then
+            print(name .. ": timeout")
+            break
+        end
+        print(name .. ":" .. val)
+        val = val + 1
+        print(name .. ": sending " .. qs .. " " .. tostring(val + 1))
+        q:send(qs, val)
+        count = count + 1
+    end
+end
+
+-- pingpong("L1", '0', '1', true)
+local t1, err1 = lanes.gen("*", pingpong)("L1", 'a', 'b', true)
+local t2, err2 = lanes.gen("*", pingpong)("L2", 'b', 'a', false)
+
+t1:join()
+t2:join()
\ No newline at end of file
diff --git a/tests/timer.lua b/tests/timer.lua
index 953e4ed..805d85c 100644
--- a/tests/timer.lua
+++ b/tests/timer.lua
@@ -8,8 +8,7 @@
 io.stderr:setvbuf "no"
 
 
-local lanes = require "lanes"
-lanes.configure()
+local lanes = require "lanes".configure()
 
 local linda= lanes.linda()
 
@@ -101,3 +100,5 @@ PRINT "...making sure no ticks are coming..."
 local k,v= linda:receive( 10, T1,T2 )    -- should not get any
 assert(v==nil)
 
+lanes.timer_lane:cancel()
+print (lanes.timer_lane[1], lanes.timer_lane[2])
\ No newline at end of file