10 files changed, 327 insertions, 95 deletions

diff --git a/CHANGES b/CHANGES
index db44b2c..86da9e8 100644
--- a/CHANGES
+++ b/CHANGES
@@ -45,6 +45,7 @@ CHANGE 2: BGe 27-Nov-24
             - linda:deep() result no longer contains the raw C pointer of the Linda object.
             - linda :receive(), :send(), :get(), :set(), :limit() return nil, error in case of problem. Returned values in case of success change too.
             - linda:limit() can be used to read the value if no new limit is provided.
+            - linda:restrict() can restrain the use of send/receive or set/get on any key.
             - New __close metamethod that calls any suitable handler that was provided at Linda creation.
             - linda:dump() outputs <key>.limit as 'unlimited' instead of -1 for unlimited keys.
             - linda:wake() can wake up threads waiting for a Linda without doing any I/O on it.
diff --git a/docs/index.html b/docs/index.html
index 7432c53..6757981 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1218,7 +1218,7 @@
         lane_h = lanes.gen("", loop)(10000)
 
         while true do
-                local key, val = linda:receive(3.0, "x")    -- timeout in seconds
+                local slot, val = linda:receive(3.0, "x")    -- timeout in seconds
                 if val == nil then
                         print("timed out")
                         break
@@ -1233,7 +1233,7 @@
         Characteristics of the Lanes implementation of lindas are:
 
         <ul>
-                <li>Keys can be of boolean, number, string, light userdata, and deep userdata type. Tables, functions and non-deep userdata can't be keys because their identity isn't preserved when transfered from one Lua state to another.</li>
+                <li>Slots can be of boolean, number, string, light userdata, and deep userdata type. Tables, functions and non-deep userdata can't be slots because their identity isn't preserved when transfered from one Lua state to another.</li>
                 <li>Values can be any type supported by inter-state copying (same <a href="#limitations">limits</a> as for function arguments and upvalues).</li>
                 <li>
                         Registered functions and userdata transiting into a Keeper state are converted to a special dummy closure that holds its actual identity. On transit out, the identity is used to find the real function or userdata in the destination.
@@ -1242,10 +1242,11 @@
                 <li>Consuming method is <tt>:receive</tt> (not in).</li>
                 <li>Non-consuming method is <tt>:get</tt> (not rd).</li>
                 <li>Two producer-side methods: <tt>:send</tt> and <tt>:set</tt> (not out).</li>
-                <li><tt>send</tt> allows for sending multiple values -atomically- to a given key.</li>
-                <li><tt>receive</tt> can wait for multiple keys at once.</li>
-                <li><tt>receive</tt> has a batched mode to consume more than one value from a single key, as in <tt>linda:receive(1.0, linda.batched, "key", 3, 6).</tt></li>
-                <li>Individual keys' queue length can be limited, balancing speed differences in a producer/consumer scenario (making <tt>:send</tt> wait).</li>
+                <li><tt>send</tt> allows for sending multiple values -atomically- to a given slot.</li>
+                <li><tt>receive</tt> can wait for multiple slots at once.</li>
+                <li><tt>receive</tt> has a batched mode to consume more than one value from a single slot, as in <tt>linda:receive(1.0, linda.batched, "slot", 3, 6).</tt></li>
+                <li><tt>restrict</tt> can restrain a particular slot to function either with <tt>send/receive</tt> or <tt>set/get</tt>.</li>
+                <li>Individual slots' queue length can be limited, balancing speed differences in a producer/consumer scenario (making <tt>:send</tt> wait).</li>
                 <li><tt>tostring(linda)</tt> returns a string of the form <tt>"Linda: &lt;opt_name&gt;"</tt></li>
                 <li>
                         Several linda objects may share the same <a href="#keepers">Keeper state</a>. In case there is more than one user <a href="#keepers">Keeper state</a>, assignation must be controlled with the linda's group (an integer in <tt>[0,nb_user_keepers]</tt>).
@@ -1272,65 +1273,84 @@
 </p>
 
 <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
-        bool,string|(nil,[lanes.cancel_error|"timeout"]) = h:limit(key, &lt;limit&gt;)
-        (number|string),string = h:limit(key)
+        bool,string|(nil,[lanes.cancel_error|"timeout"]) = h:limit(slot, &lt;limit&gt;)
+        (number|string),string = h:limit(slot)
 </pre></td></tr></table>
 
 <p>
         By default, queue sizes are unlimited but limits can be enforced using the <tt>limit()</tt> method. This can be useful to balance execution speeds in a producer/consumer scenario.<br />
         A limit of 0 is allowed to block everything. <tt>"unlimited"</tt> removes the limit.<br />
-        If the key was full but the limit change added some room, <tt>limit()</tt> first return value is <tt>true</tt> and the linda is signalled so that <tt>send()</tt>-blocked threads are awakened, else the return value is <tt>false</tt>.
-        If no limit is provided, <tt>limit()</tt> first return value is the current limit for the specified key.<br />
-        The second returned value is a string representing the fill status relatively to the key's current limit (one of <tt>"over"</tt>, <tt>"under"</tt>, <tt>"exact"</tt>).
+        If the slot was full but the limit change added some room, <tt>limit()</tt> first return value is <tt>true</tt> and the linda is signalled so that <tt>send()</tt>-blocked threads are awakened, else the return value is <tt>false</tt>.
+        If no limit is provided, <tt>limit()</tt> first return value is the current limit for the specified slot.<br />
+        The second returned value is a string representing the fill status relatively to the slot's current limit (one of <tt>"over"</tt>, <tt>"under"</tt>, <tt>"exact"</tt>).
         Whether reading or writing, if the linda is cancelled, <tt>limit()</tt> returns <tt>nil, lanes.cancel_error</tt>.
 </p>
 
 <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
-        true|lanes.cancel_error = h:send([timeout_secs,] key, ...)
+        string|(nil,[lanes.cancel_error|"timeout"]) = h:restrict(slot [, "&lt;mode&gt;"])
+        string = h:restrict(slot)
 </pre></td></tr></table>
 
 <p>
-        Timeouts are given in seconds (&gt= 0, millisecond accuracy) or <tt>nil</tt>. Timeout can be omitted only if the first key is not a number (then it is equivalent to an infinite duration).<br />
-        Each key acts as a FIFO queue. There is no limit to the number of keys a linda may contain. Different lindas can have identical keys, which are totally unrelated.
+        It is possible to restrict a particular slot in a Linda to either <tt>send/receive</tt> or <tt>set/get</tt> operations.<br />
+        Possible modes are <tt>"none"</tt>, <tt>"set/get"</tt> or <tt>"send/receive"</tt>.<br />
+        If a new mode is specified, <tt>restrict()</tt> updates the mode and returns the previous one.<br />
+        If no mode is specified, <tt>restrict()</tt> does nothing and returns the current mode.<br />
+        If the linda is cancelled, <tt>restrict()</tt> returns <tt>nil, lanes.cancel_error</tt>.<br />
+        If an unknown mode is specified, <tt>restrict()</tt> raises an error.
+</p>
+
+<table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
+        true|lanes.cancel_error = h:send([timeout_secs,] slot, ...)
+</pre></td></tr></table>
+
+<p>
+        Timeouts are given in seconds (&gt= 0, millisecond accuracy) or <tt>nil</tt>. Timeout can be omitted only if the first slot is not a number (then it is equivalent to an infinite duration).<br />
+        Each slot acts as a FIFO queue. There is no limit to the number of slots a linda may contain. Different lindas can have identical slots, which are totally unrelated.
 </p>
 
 <p>
-        Multiple values can be sent to a given key at once, atomically (the send will fail unless all the values fit within the queue limit). This can be useful for multiple producer scenarios, if the protocols used are giving data in streams of multiple units.
+        Multiple values can be sent to a given slot at once, atomically (the send will fail unless all the values fit within the queue limit). This can be useful for multiple producer scenarios, if the protocols used are giving data in streams of multiple units.
         Atomicity avoids the producers from garbling each others messages, which could happen if the units were sent individually.
 </p>
 
 <p>
-        If no data is provided after the key, <tt>send()</tt> raises an error.<br />
-        Also, if <tt>linda.null</tt> or <tt>lanes.null</tt> is sent as data in a linda, it will be read as a <tt>nil</tt>.<br />
+        If <tt>linda.null</tt> or <tt>lanes.null</tt> is sent as data in a linda, it will be read as a <tt>nil</tt>.<br />
+</p>
+
+<p>
+        <tt>send()</tt> raises an error if no data is provided after the slot.<br />
+        <tt>send()</tt> raises an error if called when a restriction forbids its use on the provided slot.<br />
+        <tt>send()</tt> raises <tt>lanes.cancel_error</tt> if interrupted by a hard cancel request.<br />
         <tt>send()</tt> return values can be:
         <ul>
                 <li><tt>true</tt> on success.</li>
                 <li><tt>nil, "timeout"</tt> if the queue limit was met, and the queue did not empty enough during the given duration.</li>
                 <li><tt>nil, lanes.cancel_error</tt> if interrupted by a soft cancel request.</li>
-                <li>Raises <tt>lanes.cancel_error</tt> if interrupted by a hard cancel request.</li>
         </ul>
 </p>
 
 <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
-        key, val = h:receive([timeout_secs,] key [, key...])
+        slot, val = h:receive([timeout_secs,] slot [, slot...])
 
-        key, val [, val...] = h:receive([timeout,] h.batched, key, n_uint_min[, n_uint_max])
+        slot, val [, val...] = h:receive([timeout,] h.batched, slot, n_uint_min[, n_uint_max])
 </pre></td></tr></table>
 
 <p>
+        <tt>receive()</tt> raises an error if called when a restriction forbids its use on any provided slot.<br />
+        In batched mode, <tt>receive()</tt> will raise an error if <tt>min_count < 1</tt> or <tt>max_count < min_count</tt>.
+</p>
+
+<p>
         Unbatched <tt>receive()</tt> return values can be:
         <ul>
                 <li><tt>nil, lanes.cancel_error</tt> if interrupted by a hard cancel request.</li>
                 <li><tt>nil, "timeout"</tt> if nothing was available.</li>
-                <li>A key and the value extracted from it. Note that <tt>nil</tt> can be sent and received; the <tt>key</tt> value will tell it apart from a timeout.</li>
+                <li>A slot and the value extracted from it. Note that <tt>nil</tt> can be sent and received; the first returned value <tt>slot</tt> will tell it apart from a timeout.</li>
         </ul>
 </p>
 
 <p>
-        In batched mode, <tt>linda:receive()</tt> will raise an error if <tt>min_count < 1</tt> or <tt>max_count < min_count</tt>.
-</p>
-
-<p>
         Note that any number of lanes can be reading or writing a linda. There can be many producers, and many consumers. It is up to you.
 </p>
 
@@ -1339,19 +1359,20 @@
 </p>
 
 <p>
-        When receiving from multiple slots, the keys are checked in order, which can    be used for making priority queues.
+        When receiving from multiple slots, the slots are checked in order, which can be used for making priority queues.
 </p>
 
 <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
-        (bool,string)|(nil,lanes.cancel_error) = linda_h:set(key [, val [, ...]])
+        (bool,string)|(nil,lanes.cancel_error) = linda_h:set(slot [, val [, ...]])
 
-        (number,[val [, ...]])|(nil,lanes.cancel_error) = linda_h:get(key [, count = 1])
+        (number,[val [, ...]])|(nil,lanes.cancel_error) = linda_h:get(slot [, count = 1])
 </pre></td></tr></table>
 
 <p>
-        <tt>get()</tt>/<tt>set()</tt> and <tt>send()</tt>/<tt>receive()</tt> can be used together; reading a slot essentially peeks the next outcoming value of a queue.<br />
-        <tt>get()</tt>/<tt>set()</tt> are for accessing a key without queuing or consuming. They can be used for making shared tables of storage among the lanes.<br />
-        Writing to a key never blocks because it ignores the limit. It overwrites existing values and clears any possible queued entries.<br />
+        <tt>set()</tt> and <tt>get()</tt> raise an error if used when a restriction forbids their use on the provided slot.<br />
+        Unless a particular slot is constrained with <tt>restrict()</tt>, <tt>get()</tt>/<tt>set()</tt> and <tt>send()</tt>/<tt>receive()</tt> can be used together; reading a slot essentially peeks the next outcoming value of a queue.<br />
+        <tt>get()</tt>/<tt>set()</tt> are for accessing a slot without queuing or consuming. They can be used for making shared tables of storage among the lanes.<br />
+        <tt>set()</tt> never blocks because it ignores the limit. It overwrites existing values and clears any possible queued entries.<br />
 </p>
 <p>
         <tt>get()</tt> can read several values at once, and does not block. Return values ares:
@@ -1361,12 +1382,12 @@
         </ul>
 </p>
 <p>
-        <tt>set()</tt> can write several values at the specified key. Writing <tt>nil</tt> values is possible, and clearing the contents at the specified key is done by not providing any value.<br />
+        <tt>set()</tt> can write several values at the specified slot. Writing <tt>nil</tt> values is possible, and clearing the contents at the specified slot is done by not providing any value.<br />
         If <tt>set()</tt> actually stores data, the linda is signalled for write, so that <tt>receive()</tt>-blocked Lanes are awakened.<br />
-        Clearing the contents of a non-existent key does not create it!<br />
-        If the key was full but the new data count of the key after <tt>set()</tt> is below its limit, <tt>set()</tt> first return value is <tt>true</tt> and the linda is also signaled for read, so that <tt>send()</tt>-blocked Lanes are awakened.<br />
-        If the key was not already full, nothing additional happens, and <tt>set()</tt> first return value is <tt>false</tt>.<br />
-        The second return value is a string representing the fill status relatively to the key's current limit (one of <tt>"over"</tt>, <tt>"under"</tt>, <tt>"exact"</tt>).
+        Clearing the contents of a non-existent slot does not create it!<br />
+        If the slot was full but the new data count of the slot after <tt>set()</tt> is below its limit, <tt>set()</tt> first return value is <tt>true</tt> and the linda is also signaled for read, so that <tt>send()</tt>-blocked Lanes are awakened.<br />
+        If the slot was not already full, nothing additional happens, and <tt>set()</tt> first return value is <tt>false</tt>.<br />
+        The second return value is a string representing the fill status relatively to the slot's current limit (one of <tt>"over"</tt>, <tt>"under"</tt>, <tt>"exact"</tt>).
 </p>
 
 <p>
@@ -1374,25 +1395,26 @@
 </p>
 
 <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
-        [val] = linda_h:count([key[,...]])
+        [val] = linda_h:count([slot[,...]])
 </pre></td></tr></table>
 
 <p>
         Returns some information about the contents of the linda.<br />
-        If no key is specified, and the linda is empty, returns nothing.<br />
-        If no key is specified, and the linda is not empty, returns a table of key/count pairs that counts the number of items in each of the exiting keys of the linda. This count can be 0 if the key has been used but is empty.<br />
-        If a single key is specified, returns the number of pending items, or nothing if the key is unknown.<br />
-        If more than one key is specified, return a table of key/count pairs for the known keys.
+        If no slot is specified, and the linda is empty, returns nothing.<br />
+        If no slot is specified, and the linda is not empty, returns a table of slot/count pairs that counts the number of items in each of the exiting slots of the linda. This count can be 0 if the slot has been used but is empty.<br />
+        If a single slot is specified, returns the number of pending items, or nothing if the slot is unknown.<br />
+        If more than one slot is specified, return a table of slot/count pairs for the known slots.
 </p>
 
 <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
         linda_h:dump() ->
         {
-                [&lt;key&gt;] =
+                [&lt;slot&gt;] =
                 {
                         first = &lt;n&gt;
                         count = &lt;n&gt;
                         limit = &lt;n&gt;|'unlimited'
+                        restrict = "none"|"set/get"|"send/receive"
                         fifo = { &lt;array of values&gt; }
                 }
                 ...
@@ -1458,7 +1480,7 @@
                 </li>
 
                 <li>
-                        Namespace control. linda keys have a "flat" namespace, so collisions are possible if you try to use the same linda for too many separate uses.
+                        Namespace control. linda slots have a "flat" namespace, so collisions are possible if you try to use the same linda for too many separate uses.
                 </li>
 
                 <li>
@@ -1467,7 +1489,7 @@
                 </li>
         </ul>
 
-        On the other side, you need to use a common linda for waiting for multiple keys. You cannot wait for keys from two separate linda objects at the same time.
+        On the other side, you need to use a common linda for waiting for multiple slots. You cannot wait for slots from two separate linda objects at the same time.
 </p>
 
 <p>
@@ -1480,7 +1502,7 @@
 <h2 id="timers">Timers</h2>
 
 <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
-        void = lanes.timer(linda_h, key, date_tbl|first_secs [,period_secs])
+        void = lanes.timer(linda_h, slot, date_tbl|first_secs [,period_secs])
 </pre></td></tr></table>
 
 <p>
@@ -1492,7 +1514,7 @@
 </p>
 
 <p>
-        Once a timer expires, the <tt>key</tt> is set with the current time (in seconds, same offset as <tt>os.time()</tt> but with millisecond accuracy). The key can be waited upon using the regular <a href="#lindas">linda</a> <tt>:receive()</tt> method.
+        Once a timer expires, the <tt>slot</tt> is set with the current time (in seconds, same offset as <tt>os.time()</tt> but with millisecond accuracy). The slot can be waited upon using the regular <a href="#lindas">linda</a> <tt>:receive()</tt> method.
 </p>
 
 <p>
@@ -1517,13 +1539,13 @@
         lanes.timer(linda, "min", t, 60)   -- reoccur every minute (sharp)
 
         while true do
-                local key, v = linda:receive("sec", "min")
-                print("Timer "..key..": "..v)
+                local slot, v = linda:receive("sec", "min")
+                print("Timer "..slot..": "..v)
         end
 </pre></td></tr></table>
 
 <p>
-        NOTE: Timer keys are set, not queued, so missing a beat is possible especially if the timer cycle is extremely small. The key value can be used to know the actual time passed.
+        NOTE: Timer slots are set, not queued, so missing a beat is possible especially if the timer cycle is extremely small. The slot value can be used to know the actual time passed.
 </p>
 
 <table>
@@ -1533,7 +1555,7 @@
                         <font size="-1">
                                 Having the API as <tt>lanes.timer()</tt> is intentional. Another alternative would be <tt>linda_h:timer()</tt> but timers are not traditionally seen to be part of lindas. Also, it would mean any lane getting a <a href="#lindas">linda</a> handle would be able to modify timers on it.
                                 A third choice could be abstracting the timers out of <a href="#lindas">linda</a> realm altogether (<tt>timer_h= lanes.timer(date|first_secs, period_secs )</tt>) but that would mean separate waiting functions for timers, and lindas.
-                                Even if a <a href="#lindas">linda</a> object and key was returned, that key couldn't be waited upon simultaneously with one's general <a href="#lindas">linda</a> events.
+                                Even if a <a href="#lindas">linda</a> object and slot was returned, that slot couldn't be waited upon simultaneously with one's general <a href="#lindas">linda</a> events.
                                 The current system gives maximum capabilities with minimum API, and any smoothenings can easily be crafted in Lua at the application level.
                         </font>
                 </td>
@@ -1578,7 +1600,7 @@
 </p>
 
 <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
-        lock_func|lanes.cancel_error = lanes.genlock(linda_h, key [,N_uint=1])
+        lock_func|lanes.cancel_error = lanes.genlock(linda_h, slot [,N_uint=1])
 
         bool|lanes.cancel_error = lock_func(M_uint [, "try"] )     -- acquire
         ..
@@ -1604,13 +1626,13 @@
 <p>
 
 <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
-        atomic_func|lanes.cancel_error = lanes.genatomic(linda_h, key [,initial_num=0.0])
+        atomic_func|lanes.cancel_error = lanes.genatomic(linda_h, slot [,initial_num=0.0])
 
         new_num|lanes.cancel_error = atomic_func([diff_num=+1.0])
 </pre></td></tr></table>
 
 <p>
-        Each time called, the generated function will change <tt>linda[key]</tt> atomically, without other lanes being able to interfere. The new value is returned. You can use either <tt>diff 0.0</tt> or <tt>get</tt> to just read the current value.
+        Each time called, the generated function will change <tt>linda[slot]</tt> atomically, without other lanes being able to interfere. The new value is returned. You can use either <tt>diff 0.0</tt> or <tt>get</tt> to just read the current value.
 </p>
 
 <p>
@@ -1632,7 +1654,7 @@
                 <li>Booleans, numbers, strings, light userdata, Lua functions and tables of such can always be passed.</li>
                 <li>
                         Cyclic tables and/or duplicate references are allowed and reproduced appropriately, but only <u>within the same transmission</u>.
-                        Using the same source table in multiple <a href="#lindas">linda</a> messages keeps no ties between the tables (this is the same reason why tables can't be used as keys).
+                        Using the same source table in multiple <a href="#lindas">linda</a> messages keeps no ties between the tables (this is the same reason why tables can't be used as slots).
                 </li>
                 <li>
                         For tables and full userdata: before anything else, the metatable is searched for a <tt>__lanesconvert</tt> field. If found, the source object is converted as follows depending on <tt>__lanesconvert</tt>'s value:
@@ -1914,7 +1936,7 @@ static MyDeepFactory g_MyDeepFactory;
         <ul>
                 <li>Data passing (arguments, upvalues, <a href="#lindas">linda</a> messages) is generally fast, doing two binary state-to-state copies (from source state to hidden state, hidden state to target state). Remember that not only the function you specify but also its upvalues, their upvalues, etc. etc. will get copied.</li>
                 <li>Lane startup is fast (1000's of lanes a second), depending on the number of standard libraries initialized. Initializing all standard libraries is about 3-4 times slower than having no standard libraries at all. If you throw in a lot of lanes per second, make sure you give them minimal necessary set of libraries.</li>
-                <li>Waiting lindas are woken up (and execute some hidden Lua code) each time <u>any</u> key in the <a href="#lindas">lindas</a> they are waiting for are changed. This may give essential slow-down (not measured, just a gut feeling) if a lot of <a href="#lindas">linda</a> keys are used. Using separate <a href="#lindas">lindas</a> for logically separate issues will help (which is good practice anyhow).</li>
+                <li>Waiting lindas are woken up (and execute some hidden Lua code) each time <u>any</u> slot in the <a href="#lindas">lindas</a> they are waiting for are changed. This may give essential slow-down (not measured, just a gut feeling) if a lot of <a href="#lindas">linda</a> slots are used. Using separate <a href="#lindas">lindas</a> for logically separate issues will help (which is good practice anyhow).</li>
                 <li><a href="#lindas">linda</a> objects are light. The memory footprint is two OS-level signalling objects (<tt>HANDLE</tt> or <tt>pthread_cond_t</tt>) for each, plus one C pointer for the proxies per each Lua state using the <a href="#lindas">linda</a>. Barely nothing.</li>
                 <li>Timers are light. You can probably expect timers up to 0.01 second resolution to be useful, but that is very system specific. All timers are merged into one main timer state (see <tt>timer.lua</tt>); no OS side timers are utilized.</li>
                 <li>If you are using a lot of <a href="#lindas">linda</a> objects, it may be useful to try having more of these <a href="#keepers">Keeper states</a>. By default, only one is used (see <a href="#initialization"><tt>lanes.configure()</tt></a>).</li>
diff --git a/src/cancel.cpp b/src/cancel.cpp
index 8fa68d5..31656c4 100644
--- a/src/cancel.cpp
+++ b/src/cancel.cpp
@@ -164,7 +164,7 @@ LUAG_FUNC(lane_cancel)
             raise_luaL_argerror(L_, StackIndex{ 2 }, "duration cannot be < 0");
         }
         lua_remove(L_, 2); // argument is processed, remove it
-    } else if (lua_isnil(L_, 2)) { // alternate explicit "infinite timeout" by passing nil before the key
+    } else if (lua_isnil(L_, 2)) { // alternate explicit "infinite timeout" by passing nil
         lua_remove(L_, 2); // argument is processed, remove it
     }
 
diff --git a/src/compat.hpp b/src/compat.hpp
index f66f703..81f1665 100644
--- a/src/compat.hpp
+++ b/src/compat.hpp
@@ -272,6 +272,16 @@ LuaType luaG_getmodule(lua_State* L_, std::string_view const& name_);
 
 // #################################################################################################
 
+template<typename ENUM>
+requires std::is_enum_v<ENUM>
+[[nodiscard]]
+ENUM luaG_optenum(lua_State* const L_, StackIndex const idx_, ENUM const def_)
+{
+    return static_cast<ENUM>(luaL_optinteger(L_, idx_, static_cast<std::underlying_type_t<ENUM>>(def_)));
+}
+
+// #################################################################################################
+
 inline void luaG_registerlibfuncs(lua_State* L_, luaL_Reg const* funcs_)
 {
     // fake externs to make clang happy...
diff --git a/src/keeper.cpp b/src/keeper.cpp
index 8a99a36..e7b02e6 100644
--- a/src/keeper.cpp
+++ b/src/keeper.cpp
@@ -73,6 +73,7 @@ class KeyUD
     int first{ 1 };
     int count{ 0 };
     LindaLimit limit{ -1 };
+    LindaRestrict restrict { LindaRestrict::None };
 
     // a fifo full userdata has one uservalue, the table that holds the actual fifo contents
     [[nodiscard]]
@@ -84,6 +85,8 @@ class KeyUD
     [[nodiscard]]
     bool changeLimit(LindaLimit limit_);
     [[nodiscard]]
+    LindaRestrict changeRestrict(LindaRestrict restrict_);
+    [[nodiscard]]
     static KeyUD* Create(KeeperState K_);
     [[nodiscard]]
     static KeyUD* GetPtr(KeeperState K_, StackIndex idx_);
@@ -114,6 +117,14 @@ bool KeyUD::changeLimit(LindaLimit const limit_)
 
 // #################################################################################################
 
+[[nodiscard]]
+LindaRestrict KeyUD::changeRestrict(LindaRestrict const restrict_)
+{
+    return std::exchange(restrict, restrict_);
+}
+
+// #################################################################################################
+
 // in: nothing
 // out: { first = 1, count = 0, limit = -1}
 KeyUD* KeyUD::Create(KeeperState const K_)
@@ -280,7 +291,7 @@ bool KeyUD::reset(KeeperState const K_)
     LUA_ASSERT(K_, KeyUD::GetPtr(K_, kIdxTop) == this);
     STACK_CHECK_START_REL(K_, 0);
     bool const _wasFull{ (limit > 0) && (count >= limit) };
-    // empty the KeyUD: replace uservalue with a virgin table, reset counters, but leave limit unchanged!
+    // empty the KeyUD: replace uservalue with a virgin table, reset counters, but leave limit and restrict unchanged!
     // if we have an actual limit, use it to preconfigure the table
     lua_createtable(K_, (limit <= 0) ? 0 : limit.value(), 0);                                      // K_: KeysDB key val... KeyUD {}
     lua_setiuservalue(K_, StackIndex{ -2 }, kContentsTableIndex);                                  // K_: KeysDB key val... KeyUD
@@ -408,7 +419,7 @@ int keepercall_destruct(lua_State* const L_)
 // #################################################################################################
 
 // in: linda_ud key [count]
-// out: bool + at most <count> values
+// out: N <N values>|kRestrictedChannel
 int keepercall_get(lua_State* const L_)
 {
     KeeperState const _K{ L_ };
@@ -423,7 +434,13 @@ int keepercall_get(lua_State* const L_)
     lua_remove(_K, 1);                                                                             // _K: KeyUD
     KeyUD const* const _key{ KeyUD::GetPtr(_K, kIdxTop) };
     if (_key != nullptr) {
-        _key->peek(_K, _count);                                                                    // _K: N val...
+        if (_key->restrict == LindaRestrict::SendReceive) { // can we use set/get?
+            lua_settop(_K, 0);                                                                     // _K:
+            kRestrictedChannel.pushKey(_K);                                                        // _K: kRestrictedChannel
+            return 1;
+        } else {
+            _key->peek(_K, _count);                                                                // _K: N val...
+        }
     } else {
         // no fifo was ever registered for this key, or it is empty
         lua_pop(_K, 1);                                                                            // _K:
@@ -492,6 +509,17 @@ int keepercall_receive(lua_State* const L_)
         lua_rawget(_K, 1);                                                                         // _K: KeysDB keys... KeyUD
         KeyUD* const _key{ KeyUD::GetPtr(_K, kIdxTop) };
         if (_key != nullptr) { // it's fine to attempt a read on a key that wasn't yet written to
+            if (_key->restrict == LindaRestrict::SetGet) { // can we use send/receive?
+                kRestrictedChannel.pushKey(_K);                                                    // _K: KeysDB keys... key[i] kRestrictedChannel
+                lua_replace(_K, 1);                                                                // _K: kRestrictedChannel keys... key[i]
+                lua_settop(_K, _keyIdx);                                                           // _K: kRestrictedChannel keys... key[i]
+                if (_keyIdx != 2) {
+                    lua_replace(_K, 2);                                                            // _K: kRestrictedChannel key[i] keys...
+                    lua_settop(_K, 2);                                                             // _K: kRestrictedChannel key[i]
+                }
+                lua_insert(_K, 1);                                                                 // _K: key kRestrictedChannel
+                return 2;
+            }
             int const _popped{ _key->pop(_K, 1, 1) };                                              // _K: KeysDB keys... val
             if (_popped > 0) {
                 lua_replace(_K, 1);                                                                // _K: val keys...
@@ -527,19 +555,89 @@ int keepercall_receive_batched(lua_State* const L_)
     lua_rawget(_K, 2);                                                                             // _K: key KeysDB KeyUD
     lua_remove(_K, 2);                                                                             // _K: key KeyUD
     KeyUD* const _key{ KeyUD::GetPtr(_K, kIdxTop) };
-    if (_key == nullptr || _key->pop(_K, _min_count, _max_count) == 0) {                           // _K: [key val...]|crap
-        // Lua will adjust the stack for us when we return
-        return 0;
+    if (!_key) {
+        return 0; // Lua will adjust the stack for us when we return
+    }
+    if (_key->restrict == LindaRestrict::SetGet) { // can we use send/receive?
+        lua_settop(_K, 1);                                                                         // _K: key
+        kRestrictedChannel.pushKey(_K);                                                            // _K: key kRestrictedChannel
+        return 2;
+    }
+    if (_key->pop(_K, _min_count, _max_count) == 0) {                                              // _K: [key val...]|crap
+        return 0; // Lua will adjust the stack for us when we return
+    }
+    // return whatever remains on the stack at that point: the key and the values we pulled from the fifo
+    return lua_gettop(_K);
+}
+
+// #################################################################################################
+
+// in: linda key [mode]
+// out: mode
+int keepercall_restrict(lua_State* const L_)
+{
+    KeeperState const _K{ L_ };
+    STACK_CHECK_START_ABS(_K, lua_gettop(_K));
+    // no restriction to set, means we read and return the current restriction instead
+    bool const _reading{ lua_gettop(_K) == 2 };
+    auto _decodeRestrict = [_K, _reading]() {
+        if (_reading) {
+            return LindaRestrict::None;
+        }
+        std::string_view const _val{ luaG_tostring(_K, StackIndex{ 3 }) };
+        if (_val == "set/get") {
+            return LindaRestrict::SetGet;
+        }
+        if (_val == "send/receive") {
+            return LindaRestrict::SendReceive;
+        }
+        return LindaRestrict::None;
+    };
+    auto _encodeRestrict = [](LindaRestrict const val_) {
+        switch (val_) {
+        default:
+        case LindaRestrict::None:
+            return std::string_view{ "none" };
+        case LindaRestrict::SetGet:
+            return std::string_view{ "set/get" };
+        case LindaRestrict::SendReceive:
+            return std::string_view{ "send/receive" };
+        }
+    };
+    LindaRestrict const _rstrct{ _decodeRestrict() }; // if we read nil because the argument is absent
+    lua_settop(_K, 2);                                                                             // _K: linda key
+    PushKeysDB(_K, StackIndex{ 1 });                                                               // _K: linda key KeysDB
+    lua_replace(_K, 1);                                                                            // _K: KeysDB key
+    lua_pushvalue(_K, -1);                                                                         // _K: KeysDB key key
+    lua_rawget(_K, -3);                                                                            // _K: KeysDB key KeyUD|nil
+    KeyUD* _key{ KeyUD::GetPtr(_K, kIdxTop) };
+    if (_reading) {
+        // remove any clutter on the stack
+        lua_settop(_K, 0);                                                                         // _K:
+        auto const _prevRstrct{ _key ? _key->restrict : LindaRestrict::None };
+        // return a single value: the restrict mode of the key
+        luaG_pushstring(_K, _encodeRestrict(_prevRstrct));                                          // _K: _previous
     } else {
-        // return whatever remains on the stack at that point: the key and the values we pulled from the fifo
-        return lua_gettop(_K);
+        if (_key == nullptr) {                                                                     // _K: KeysDB key nil
+            lua_pop(_K, 1);                                                                        // _K: KeysDB key
+            _key = KeyUD::Create(_K);                                                              // _K: KeysDB key KeyUD
+            lua_rawset(_K, -3);                                                                    // _K: KeysDB
+        }
+        // remove any clutter on the stack
+        lua_settop(_K, 0);                                                                         // _K:
+        // return true if we decide that blocked threads waiting to write on that key should be awakened
+        // this is the case if we detect the key was full but it is no longer the case
+        LindaRestrict const _previous{ _key->changeRestrict(_rstrct) };
+        luaG_pushstring(_K, _encodeRestrict(_previous));                                           // _K: _previous
     }
+    STACK_CHECK(_K, 1);
+    return 1;
 }
 
 // #################################################################################################
 
 // in: linda, key, ...
-// out: true|false
+// out: true|false|kRestrictedChannel
 int keepercall_send(lua_State* const L_)
 {
     KeeperState const _K{ L_ };
@@ -561,7 +659,11 @@ int keepercall_send(lua_State* const L_)
     lua_pop(_K, 1);                                                                                // _K: linda KeyUD val...
     STACK_CHECK(_K, 0);
     KeyUD* const _key{ KeyUD::GetPtr(_K, StackIndex{ 2 }) };
-    if (_key && _key->push(_K, _n, true)) { // not enough room?
+    if (_key->restrict == LindaRestrict::SetGet) { // can we use send/receive?
+        lua_settop(_K, 0);                                                                         // _K:
+        kRestrictedChannel.pushKey(_K);                                                            // _K: kRestrictedChannel
+    }
+    else if (_key->push(_K, _n, true)) { // not enough room?
         lua_settop(_K, 0);                                                                         // _K:
         lua_pushboolean(_K, 1);                                                                    // _K: true
     } else {
@@ -575,7 +677,7 @@ int keepercall_send(lua_State* const L_)
 // #################################################################################################
 
 // in: linda key [val...]
-// out: true if the linda was full but it's no longer the case, else false
+// out: true if the linda was full but it's no longer the case, else false, or kRestrictedChannel if the key is restricted
 int keepercall_set(lua_State* const L_)
 {
     KeeperState const _K{ L_ };
@@ -588,11 +690,16 @@ int keepercall_set(lua_State* const L_)
     lua_pushvalue(_K, 2);                                                                          // _K: KeysDB key val... key
     lua_rawget(_K, 1);                                                                             // _K: KeysDB key val KeyUD|nil
     KeyUD* _key{ KeyUD::GetPtr(_K, kIdxTop) };
+    if (_key && _key->restrict == LindaRestrict::SendReceive) { // can we use send/receive?
+        lua_settop(_K, 0);                                                                         // _K:
+        kRestrictedChannel.pushKey(_K);                                                            // _K: kRestrictedChannel
+        return 1;
+    }
 
     if (lua_gettop(_K) == 3) { // no value to set                                                  // _K: KeysDB key KeyUD|nil
         // empty the KeyUD for the specified key: replace uservalue with a virgin table, reset counters, but leave limit unchanged!
         if (_key != nullptr) { // might be nullptr if we set a nonexistent key to nil              // _K: KeysDB key KeyUD
-            if (_key->limit < 0) { // KeyUD limit value is the default (unlimited): we can totally remove it
+            if (_key->limit < 0 && _key->restrict == LindaRestrict::None) { // KeyUD limit value and restrict mode are the default (unlimited/none): we can totally remove it
                 lua_pop(_K, 1);                                                                    // _K: KeysDB key
                 lua_pushnil(_K);                                                                   // _K: KeysDB key nil
                 lua_rawset(_K, -3);                                                                // _K: KeysDB
@@ -777,6 +884,20 @@ int Keeper::PushLindaStorage(Linda& linda_, DestState const L_)
         }
         STACK_CHECK(L_, 5);
         lua_setfield(L_, -3, "limit");                                                             // _K: KeysDB key                                     L_: out key keyout fifo
+        // keyout.restrict
+        switch (_key->restrict) {
+        case LindaRestrict::None:
+            luaG_pushstring(L_, "none");                                                           // _K: KeysDB key                                     L_: out key keyout fifo restrict
+            break;
+        case LindaRestrict::SetGet:
+            luaG_pushstring(L_, "set/get");                                                        // _K: KeysDB key                                     L_: out key keyout fifo restrict
+            break;
+        case LindaRestrict::SendReceive:
+            luaG_pushstring(L_, "send/receive");                                                   // _K: KeysDB key                                     L_: out key keyout fifo restrict
+            break;
+        }
+        STACK_CHECK(L_, 5);
+        lua_setfield(L_, -3, "restrict");                                                          // _K: KeysDB key                                     L_: out key keyout fifo
         // keyout.fifo
         lua_setfield(L_, -2, "fifo");                                                              // _K: KeysDB key                                     L_: out key keyout
         // out[key] = keyout
diff --git a/src/keeper.hpp b/src/keeper.hpp
index b77f1a9..e2ad445 100644
--- a/src/keeper.hpp
+++ b/src/keeper.hpp
@@ -13,6 +13,15 @@ DECLARE_UNIQUE_TYPE(KeeperIndex, int);
 
 // #################################################################################################
 
+enum class LindaRestrict
+{
+    None,
+    SetGet,
+    SendReceive
+};
+
+// #################################################################################################
+
 struct Keeper
 {
     std::mutex mutex;
@@ -79,6 +88,9 @@ DECLARE_UNIQUE_TYPE(KeeperCallResult, std::optional<int>);
 // xxh64 of string "kNilSentinel" generated at https://www.pelock.com/products/hash-calculator
 static constexpr UniqueKey kNilSentinel{ 0xC457D4EDDB05B5E4ull, "lanes.null" };
 
+// xxh64 of string "kRestrictedChannel" generated at https://www.pelock.com/products/hash-calculator
+static constexpr UniqueKey kRestrictedChannel{ 0x4C8B879ECDE110F7ull };
+
 using keeper_api_t = lua_CFunction;
 #define KEEPER_API(_op) keepercall_##_op
 
@@ -96,6 +108,8 @@ int keepercall_receive(lua_State* L_);
 [[nodiscard]]
 int keepercall_receive_batched(lua_State* L_);
 [[nodiscard]]
+int keepercall_restrict(lua_State* L_);
+[[nodiscard]]
 int keepercall_send(lua_State* L_);
 [[nodiscard]]
 int keepercall_set(lua_State* L_);
diff --git a/src/lanes.lua b/src/lanes.lua
index dfa959d..8d8f25d 100644
--- a/src/lanes.lua
+++ b/src/lanes.lua
@@ -448,6 +448,7 @@ local configure_timers = function()
 
     -- Timer lane; initialize only on the first 'require "lanes"' instance (which naturally has 'table' always declared)
     local first_time_key = "first time"
+    timerLinda:restrict(first_time_key, "set/get")
     local _, _first_time_val = timerLinda:get(first_time_key)
     local first_time = (_first_time_val == nil)
     timerLinda:set(first_time_key, true)
diff --git a/src/linda.cpp b/src/linda.cpp
index 43d2a91..6ebbc1f 100644
--- a/src/linda.cpp
+++ b/src/linda.cpp
@@ -57,7 +57,7 @@ namespace {
 
             case LuaType::USERDATA:
                 if (!DeepFactory::IsDeepUserdata(L_, _i)) {
-                    raise_luaL_error(L_, "argument #%d: can't use non-deep userdata as a key", _i);
+                    raise_luaL_error(L_, "argument #%d: can't use non-deep userdata as a slot", _i);
                 }
                 break;
 
@@ -66,7 +66,7 @@ namespace {
                     static constexpr std::array<std::reference_wrapper<UniqueKey const>, 3> kKeysToCheck{ kLindaBatched, kCancelError, kNilSentinel };
                     for (UniqueKey const& _key : kKeysToCheck) {
                         if (_key.equals(L_, _i)) {
-                            raise_luaL_error(L_, "argument #%d: can't use %s as a key", _i, _key.debugName.data());
+                            raise_luaL_error(L_, "argument #%d: can't use %s as a slot", _i, _key.debugName.data());
                             break;
                         }
                     }
@@ -74,7 +74,7 @@ namespace {
                 break;
 
             default:
-                raise_luaL_error(L_, "argument #%d: invalid key type (not a boolean, string, number or light userdata)", _i);
+                raise_luaL_error(L_, "argument #%d: invalid slot type (not a boolean, string, number or light userdata)", _i);
             }
         }
         STACK_CHECK(L_, 0);
@@ -416,7 +416,7 @@ static LUAG_FUNC(linda_index)
 // #################################################################################################
 
 /*
- * [val] = linda_count( linda_ud, [key [, ...]])
+ * [val] = linda_count( linda_ud, [slot [, ...]])
  *
  * Get a count of the pending elements in the specified keys
  */
@@ -430,7 +430,7 @@ LUAG_FUNC(linda_count)
 
             Keeper* const _keeper{ _linda->whichKeeper() };
             KeeperCallResult const _pushed{ keeper_call(_keeper->K, KEEPER_API(count), L_, _linda, StackIndex{ 2 }) };
-            return OptionalValue(_pushed, L_, "tried to count an invalid key");
+            return OptionalValue(_pushed, L_, "Tried to count an invalid slot");
         }
     };
     return Linda::ProtectedCall(L_, _count);
@@ -487,13 +487,16 @@ LUAG_FUNC(linda_get)
             lua_Integer const _count{ luaL_optinteger(L_, 3, 1) };
             luaL_argcheck(L_, _count >= 1, 3, "count should be >= 1");
             luaL_argcheck(L_, lua_gettop(L_) <= 3, 4, "too many arguments");
-            // make sure the key is of a valid type (throws an error if not the case)
+            // make sure the slot is of a valid type (throws an error if not the case)
             CheckKeyTypes(L_, StackIndex{ 2 }, StackIndex{ 2 });
 
             KeeperCallResult _pushed;
             if (_linda->cancelStatus == Linda::Active) {
                 Keeper* const _keeper{ _linda->whichKeeper() };
                 _pushed = keeper_call(_keeper->K, KEEPER_API(get), L_, _linda, StackIndex{ 2 });
+                if (_pushed.has_value() && kRestrictedChannel.equals(L_, kIdxTop)) {
+                    raise_luaL_error(L_, "Key is restricted");
+                }
             } else { // linda is cancelled
                 // do nothing and return nil,lanes.cancel_error
                 lua_pushnil(L_);
@@ -511,7 +514,7 @@ LUAG_FUNC(linda_get)
 
 /*
  * [bool]|nil,cancel_error = linda:limit(key_num|str|bool|lightuserdata, [int])
- * "unlimited"|number = linda:limit(key)
+ * "unlimited"|number = linda:limit(slot)
  *
  * Read or set limit to 1 Linda keys.
  * Optionally wake threads waiting to write on the linda, in case the limit enables them to do so
@@ -522,7 +525,7 @@ LUAG_FUNC(linda_limit)
     static constexpr lua_CFunction _limit{
         +[](lua_State* const L_) {
             Linda* const _linda{ ToLinda<false>(L_, StackIndex{ 1 }) };
-            // make sure we got 2 or 3 arguments: the linda, a key and optionally a limit
+            // make sure we got 2 or 3 arguments: the linda, a slot and optionally a limit
             int const _nargs{ lua_gettop(L_) };
             luaL_argcheck(L_, _nargs == 2 || _nargs == 3, 2, "wrong number of arguments");
             // make sure we got a numeric limit, or "unlimited", (or nothing)
@@ -531,7 +534,7 @@ LUAG_FUNC(linda_limit)
             if (_val < 0) {
                 raise_luaL_argerror(L_, StackIndex{ 3 }, "limit must be >= 0");
             }
-            // make sure the key is of a valid type
+            // make sure the slot is of a valid type
             CheckKeyTypes(L_, StackIndex{ 2 }, StackIndex{ 2 });
 
             KeeperCallResult _pushed;
@@ -539,8 +542,8 @@ LUAG_FUNC(linda_limit)
                 if (_unlimited) {
                     LUA_ASSERT(L_, lua_gettop(L_) == 3 && luaG_tostring(L_, StackIndex{ 3 }) == "unlimited");
                     // inside the Keeper, unlimited is signified with a -1 limit (can't use nil because of nil kNilSentinel conversions!)
-                    lua_pop(L_, 1);                                                                // L_: linda key
-                    lua_pushinteger(L_, -1);                                                       // L_: linda key nil
+                    lua_pop(L_, 1);                                                                // L_: linda slot
+                    lua_pushinteger(L_, -1);                                                       // L_: linda slot nil
                 }
                 Keeper* const _keeper{ _linda->whichKeeper() };
                 _pushed = keeper_call(_keeper->K, KEEPER_API(limit), L_, _linda, StackIndex{ 2 });
@@ -572,12 +575,12 @@ LUAG_FUNC(linda_limit)
 
 /*
  * 2 modes of operation
- * [val, key]= linda:receive([timeout_secs_num=nil], key_num|str|bool|lightuserdata [, ...] )
- * Consumes a single value from the Linda, in any key.
- * Returns: received value (which is consumed from the slot), and the key which had it
+ * [val, slot]= linda:receive([timeout_secs_num=nil], key_num|str|bool|lightuserdata [, ...] )
+ * Consumes a single value from the Linda, in any slot.
+ * Returns: received value (which is consumed from the slot), and the slot which had it
 
  * [val1, ... valCOUNT]= linda_receive( linda_ud, [timeout_secs_num=-1], linda.batched, key_num|str|bool|lightuserdata, min_COUNT[, max_COUNT])
- * Consumes between min_COUNT and max_COUNT values from the linda, from a single key.
+ * Consumes between min_COUNT and max_COUNT values from the linda, from a single slot.
  * returns the actual consumed values, or nil if there weren't enough values to consume
  */
 LUAG_FUNC(linda_receive)
@@ -585,7 +588,7 @@ LUAG_FUNC(linda_receive)
     static constexpr lua_CFunction _receive{
         +[](lua_State* const L_) {
             Linda* const _linda{ ToLinda<false>(L_, StackIndex{ 1 }) };
-            StackIndex _key_i{ 2 }; // index of first key, if timeout not there
+            StackIndex _key_i{ 2 }; // index of first slot, if timeout not there
 
             std::chrono::time_point<std::chrono::steady_clock> _until{ std::chrono::time_point<std::chrono::steady_clock>::max() };
             if (luaG_type(L_, StackIndex{ 2 }) == LuaType::NUMBER) { // we don't want to use lua_isnumber() because of autocoercion
@@ -596,7 +599,7 @@ LUAG_FUNC(linda_receive)
                     raise_luaL_argerror(L_, StackIndex{ 2 }, "duration cannot be < 0");
                 }
                 ++_key_i;
-            } else if (lua_isnil(L_, 2)) { // alternate explicit "infinite timeout" by passing nil before the key
+            } else if (lua_isnil(L_, 2)) { // alternate explicit "infinite timeout" by passing nil before the slot
                 ++_key_i;
             }
 
@@ -616,7 +619,7 @@ LUAG_FUNC(linda_receive)
                     raise_luaL_argerror(L_, StackIndex{ _key_i + 1 }, "bad min count");
                 }
                 _expected_pushed_max = (int) luaL_optinteger(L_, _key_i + 2, _expected_pushed_min);
-                // don't forget to count the key in addition to the values
+                // don't forget to count the slot in addition to the values
                 ++_expected_pushed_min;
                 ++_expected_pushed_max;
                 if (_expected_pushed_min > _expected_pushed_max) {
@@ -627,7 +630,7 @@ LUAG_FUNC(linda_receive)
                 CheckKeyTypes(L_, _key_i, StackIndex{ lua_gettop(L_) });
                 // receive a single value, checking multiple slots
                 _selected_keeper_receive = KEEPER_API(receive);
-                // we expect a single (value, key) pair of returned values
+                // we expect a single (value, slot) pair of returned values
                 _expected_pushed_min = _expected_pushed_max = 2;
             }
 
@@ -660,6 +663,9 @@ LUAG_FUNC(linda_receive)
                 }
                 if (_pushed.value() > 0) {
                     LUA_ASSERT(L_, _pushed.value() >= _expected_pushed_min && _pushed.value() <= _expected_pushed_max);
+                    if (kRestrictedChannel.equals(L_, StackIndex{ kIdxTop })) {
+                        raise_luaL_error(L_, "Key is restricted");
+                    }
                     _linda->readHappened.notify_all();
                     break;
                 }
@@ -730,6 +736,49 @@ LUAG_FUNC(linda_receive)
 // #################################################################################################
 
 /*
+ * "string" = linda:restrict(key_num|str|bool|lightuserdata, [string])
+ * "string" = linda:restrict(slot)
+ *
+ * Read or set restrict mode to 1 Linda slot.
+ */
+LUAG_FUNC(linda_restrict)
+{
+    static constexpr lua_CFunction _rstrct{
+        +[](lua_State* const L_) {
+            Linda* const _linda{ ToLinda<false>(L_, StackIndex{ 1 }) };
+            // make sure we got 2 or 3 arguments: the linda, a slot and optionally a restrict mode
+            int const _nargs{ lua_gettop(L_) };
+            luaL_argcheck(L_, _nargs == 2 || _nargs == 3, 2, "wrong number of arguments");
+            // make sure we got a known restrict mode, (or nothing)
+            std::string_view const _mode{ luaG_tostring(L_, StackIndex{ 3 }) };
+            if (!_mode.empty() && (_mode != "none" && _mode != "set/get" && _mode != "send/receive")) {
+                raise_luaL_argerror(L_, StackIndex{ 3 }, "unknown restrict mode");
+            }
+            // make sure the slot is of a valid type
+            CheckKeyTypes(L_, StackIndex{ 2 }, StackIndex{ 2 });
+
+            KeeperCallResult _pushed;
+            if (_linda->cancelStatus == Linda::Active) {
+                Keeper* const _keeper{ _linda->whichKeeper() };
+                _pushed = keeper_call(_keeper->K, KEEPER_API(restrict), L_, _linda, StackIndex{ 2 });
+                // we should get a single return value: the string describing the previous restrict mode
+                LUA_ASSERT(L_, _pushed.has_value() && (_pushed.value() == 1) && luaG_type(L_, kIdxTop) == LuaType::STRING);
+            } else { // linda is cancelled
+                // do nothing and return nil,lanes.cancel_error
+                lua_pushnil(L_);
+                kCancelError.pushKey(L_);
+                _pushed.emplace(2);
+            }
+            // propagate returned values
+            return _pushed.value();
+        }
+    };
+    return Linda::ProtectedCall(L_, _rstrct);
+}
+
+// #################################################################################################
+
+/*
  * bool= linda:linda_send([timeout_secs=nil,] key_num|str|bool|lightuserdata, ...)
  *
  * Send one or more values to a Linda. If there is a limit, all values must fit.
@@ -743,7 +792,7 @@ LUAG_FUNC(linda_send)
     static constexpr lua_CFunction _send{
         +[](lua_State* const L_) {
             Linda* const _linda{ ToLinda<false>(L_, StackIndex{ 1 }) };
-            StackIndex _key_i{ 2 }; // index of first key, if timeout not there
+            StackIndex _key_i{ 2 }; // index of first slot, if timeout not there
 
             std::chrono::time_point<std::chrono::steady_clock> _until{ std::chrono::time_point<std::chrono::steady_clock>::max() };
             if (luaG_type(L_, StackIndex{ 2 }) == LuaType::NUMBER) { // we don't want to use lua_isnumber() because of autocoercion
@@ -754,11 +803,11 @@ LUAG_FUNC(linda_send)
                     raise_luaL_argerror(L_, StackIndex{ 2 }, "duration cannot be < 0");
                 }
                 ++_key_i;
-            } else if (lua_isnil(L_, 2)) { // alternate explicit "infinite timeout" by passing nil before the key
+            } else if (lua_isnil(L_, 2)) { // alternate explicit "infinite timeout" by passing nil before the slot
                 ++_key_i;
             }
 
-            // make sure the key is of a valid type
+            // make sure the slot is of a valid type
             CheckKeyTypes(L_, _key_i, _key_i);
 
             STACK_GROW(L_, 1);
@@ -799,6 +848,9 @@ LUAG_FUNC(linda_send)
                     }
                     LUA_ASSERT(L_, _pushed.value() == 1);
 
+                    if (kRestrictedChannel.equals(L_, StackIndex{ kIdxTop })) {
+                        raise_luaL_error(L_, "Key is restricted");
+                    }
                     _ret = lua_toboolean(L_, -1) ? true : false;
                     lua_pop(L_, 1);
 
@@ -884,7 +936,7 @@ LUAG_FUNC(linda_set)
         +[](lua_State* const L_) {
             Linda* const _linda{ ToLinda<false>(L_, StackIndex{ 1 }) };
             bool const _has_data{ lua_gettop(L_) > 2 };
-            // make sure the key is of a valid type (throws an error if not the case)
+            // make sure the slot is of a valid type (throws an error if not the case)
             CheckKeyTypes(L_, StackIndex{ 2 }, StackIndex{ 2 });
 
             KeeperCallResult _pushed;
@@ -892,6 +944,9 @@ LUAG_FUNC(linda_set)
                 Keeper* const _keeper{ _linda->whichKeeper() };
                 _pushed = keeper_call(_keeper->K, KEEPER_API(set), L_, _linda, StackIndex{ 2 });
                 if (_pushed.has_value()) { // no error?
+                    if (kRestrictedChannel.equals(L_, kIdxTop)) {
+                        raise_luaL_error(L_, "Key is restricted");
+                    }
                     LUA_ASSERT(L_, _pushed.value() == 2 && luaG_type(L_, kIdxTop) == LuaType::STRING && luaG_type(L_, StackIndex{ -2 }) == LuaType::BOOLEAN);
 
                     if (_has_data) {
@@ -899,7 +954,7 @@ LUAG_FUNC(linda_set)
                         _linda->writeHappened.notify_all(); // To be done from within the 'K' locking area
                     }
                     if (lua_toboolean(L_, -2)) {
-                        // the key was full, but it is no longer the case, tell writers they should wake
+                        // the slot was full, but it is no longer the case, tell writers they should wake
                         _linda->readHappened.notify_all(); // To be done from within the 'K' locking area
                     }
                 }
@@ -992,6 +1047,7 @@ namespace {
             { "get", LG_linda_get },
             { "limit", LG_linda_limit },
             { "receive", LG_linda_receive },
+            { "restrict", LG_linda_restrict },
             { "send", LG_linda_send },
             { "set", LG_linda_set },
             { "wake", LG_linda_wake },
diff --git a/tests/cancel.lua b/tests/cancel.lua
index 1984c85..e65d794 100644
--- a/tests/cancel.lua
+++ b/tests/cancel.lua
@@ -39,10 +39,17 @@ if not next(which_tests) or which_tests.genlock then
         local lock = lanes.genlock( linda, "lock", 1)
         local atomic = lanes.genatomic( linda, "atomic")
 
+        local check_returned_cancel_error = function(_status, _err)
+                assert(_status == nil and _err == lanes.cancel_error)
+        end
         -- check that cancelled lindas give cancel_error as they should
         linda:cancel()
-        local _status, _err = linda:get( "empty")
-        assert(_status == nil and _err == lanes.cancel_error)
+        check_returned_cancel_error(linda:set( "empty", 42))
+        check_returned_cancel_error(linda:get( "empty"))
+        check_returned_cancel_error(linda:send( "empty", 42))
+        check_returned_cancel_error(linda:receive( "empty"))
+        check_returned_cancel_error(linda:limit( "empty", 5))
+        check_returned_cancel_error(linda:restrict( "empty", "set/get"))
         assert( lanes.genlock( linda, "any", 1) == lanes.cancel_error)
         assert( lanes.genatomic( linda, "any") == lanes.cancel_error)
 
diff --git a/tests/fifo.lua b/tests/fifo.lua
index e1bfeae..9efcbd9 100644
--- a/tests/fifo.lua
+++ b/tests/fifo.lua
@@ -60,7 +60,7 @@ for key,count in pairs(fifo_linda:count("unknown key", A.channel, "unknown key",
 end
 print "Dumping linda stats.. [4]" -- count everything
 for key,contents in pairs(fifo_linda:dump()) do
-    print("channel " .. key .. ": limit=".. contents.limit, " first=" .. contents.first, " count=" .. contents.count)
+    print("channel " .. key .. ": limit=".. contents.limit, " first=" .. contents.first, " count=" .. contents.count .. " restrict=" .. contents.restrict)
     for k,v in pairs(contents.fifo) do
         print("[".. k.."] = " .. v)
     end