1 files changed, 83 insertions, 66 deletions

diff --git a/src/keeper.cpp b/src/keeper.cpp
index cad9207..4af0d86 100644
--- a/src/keeper.cpp
+++ b/src/keeper.cpp
@@ -77,7 +77,7 @@ class KeyUD final
 
     // a fifo full userdata has one uservalue, the table that holds the actual fifo contents
     [[nodiscard]]
-    static void* operator new([[maybe_unused]] size_t size_, KeeperState L_) noexcept { return luaG_newuserdatauv<KeyUD>(L_, UserValueCount{ 1 }); }
+    static void* operator new([[maybe_unused]] size_t size_, KeeperState L_) noexcept { return luaW_newuserdatauv<KeyUD>(L_, UserValueCount{ 1 }); }
     // always embedded somewhere else or "in-place constructed" as a full userdata
     // can't actually delete the operator because the compiler generates stack unwinding code that could call it in case of exception
     static void operator delete([[maybe_unused]] void* p_, [[maybe_unused]] KeeperState L_) { LUA_ASSERT(L_, !"should never be called"); }
@@ -104,6 +104,7 @@ class KeyUD final
 
 // #################################################################################################
 
+[[nodiscard]]
 bool KeyUD::changeLimit(LindaLimit const limit_)
 {
     bool const _newSlackAvailable{
@@ -127,6 +128,7 @@ LindaRestrict KeyUD::changeRestrict(LindaRestrict const restrict_)
 
 // in: nothing
 // out: { first = 1, count = 0, limit = -1}
+[[nodiscard]]
 KeyUD* KeyUD::Create(KeeperState const K_)
 {
     STACK_GROW(K_, 2);
@@ -141,9 +143,10 @@ KeyUD* KeyUD::Create(KeeperState const K_)
 
 // #################################################################################################
 
+[[nodiscard]]
 KeyUD* KeyUD::GetPtr(KeeperState const K_, StackIndex const idx_)
 {
-    return luaG_tofulluserdata<KeyUD>(K_, idx_);
+    return luaW_tofulluserdata<KeyUD>(K_, idx_);
 }
 
 // #################################################################################################
@@ -181,6 +184,7 @@ void KeyUD::peek(KeeperState const K_, int const count_) const
 
 // in: fifo
 // out: remove the fifo table from the stack, push as many items as required on the stack (function assumes they exist in sufficient number)
+[[nodiscard]]
 int KeyUD::pop(KeeperState const K_, int const minCount_, int const maxCount_)
 {
     if (count < minCount_) {
@@ -191,23 +195,33 @@ int KeyUD::pop(KeeperState const K_, int const minCount_, int const maxCount_)
     int const _popCount{ std::min(count, maxCount_) };
     LUA_ASSERT(K_, KeyUD::GetPtr(K_, kIdxTop) == this);                                            // K_: ... this
     prepareAccess(K_, kIdxTop);                                                                    // K_: ... fifo
+
+    STACK_CHECK_START_REL(K_, 0);
     StackIndex const _fifo_idx{ lua_gettop(K_) };
     // each iteration pushes a value on the stack!
     STACK_GROW(K_, _popCount + 2);
-    // skip first item, we will push it last
-    for (int const _i : std::ranges::iota_view{ 1, _popCount }) {
+
+    // remove an element from fifo sequence and push it on the stack
+    auto _extractFifoItem = [K = K_, first = first, fifo_idx = lua_gettop(K_)](int const _i)
+    {
+        STACK_CHECK_START_REL(K, 0);
         int const _at{ first + _i };
         // push item on the stack
-        lua_rawgeti(K_, _fifo_idx, _at);                                                           // K_: ... fifo val
+        lua_rawgeti(K, fifo_idx, _at);                                                             // K_: ... fifo val
         // remove item from the fifo
-        lua_pushnil(K_);                                                                           // K_: ... fifo val nil
-        lua_rawseti(K_, _fifo_idx, _at);                                                           // K_: ... fifo val
+        lua_pushnil(K);                                                                            // K_: ... fifo val nil
+        lua_rawseti(K, fifo_idx, _at);                                                             // K_: ... fifo val
+        STACK_CHECK(K, 1);
+    };
+
+    // skip first item, we will push it last to avoid shifting the whole stack when removing 'fifo'
+    for (int const _i : std::ranges::iota_view{ 1, _popCount }) {
+        _extractFifoItem(_i);                                                                      // K_: ... fifo val1...valN
     }
     // now process first item
-    lua_rawgeti(K_, _fifo_idx, first);                                                             // K_: ... fifo vals val
-    lua_pushnil(K_);                                                                               // K_: ... fifo vals val nil
-    lua_rawseti(K_, _fifo_idx, first);                                                             // K_: ... fifo vals val
-    lua_replace(K_, _fifo_idx);                                                                    // K_: ... vals
+    _extractFifoItem(0);                                                                           // K_: ... fifo val1...valN val0
+    STACK_CHECK(K_, _popCount);
+    lua_replace(K_, _fifo_idx);                                                                    // K_: ... val0...valN
 
     // avoid ever-growing indexes by resetting each time we detect the fifo is empty
     int const _new_count{ count - _popCount };
@@ -222,7 +236,7 @@ int KeyUD::pop(KeeperState const K_, int const minCount_, int const maxCount_)
 // replaces it by its uservalue on the stack (the table holding the fifo values)
 void KeyUD::prepareAccess(KeeperState const K_, StackIndex const idx_) const
 {
-    StackIndex const _idx{ luaG_absindex(K_, idx_) };
+    StackIndex const _idx{ luaW_absindex(K_, idx_) };
     LUA_ASSERT(K_, KeyUD::GetPtr(K_, idx_) == this);
     // we can replace the key userdata in the stack without fear of it being GCed, there are other references around
     lua_getiuservalue(K_, _idx, kContentsTableIndex);
@@ -233,9 +247,10 @@ void KeyUD::prepareAccess(KeeperState const K_, StackIndex const idx_) const
 
 // in: expect this val... on top of the stack
 // out: nothing, removes all pushed values from the stack
+[[nodiscard]]
 bool KeyUD::push(KeeperState const K_, int const count_, bool const enforceLimit_)
 {
-    StackIndex const _fifoIdx{ luaG_absindex(K_, StackIndex{ -1 - count_ }) };
+    StackIndex const _fifoIdx{ luaW_absindex(K_, StackIndex{ -1 - count_ }) };
     LUA_ASSERT(K_, KeyUD::GetPtr(K_, _fifoIdx) == this);                                           // K_: this val...
     if (enforceLimit_ && (limit >= 0) && (count + count_ > limit)) { // not enough room
         return false;
@@ -259,16 +274,16 @@ bool KeyUD::push(KeeperState const K_, int const count_, bool const enforceLimit
 void KeyUD::pushFillStatus(KeeperState const K_) const
 {
     if (limit < 0) {
-        luaG_pushstring(K_, kUnder);
+        luaW_pushstring(K_, kUnder);
         return;
     }
-    int const _delta{limit - count};
+    int const _delta{ limit - count };
     if (_delta < 0) {
-        luaG_pushstring(K_, kOver);
+        luaW_pushstring(K_, kOver);
     } else if (_delta > 0) {
-        luaG_pushstring(K_, kUnder);
+        luaW_pushstring(K_, kUnder);
     } else {
-        luaG_pushstring(K_, kExact);
+        luaW_pushstring(K_, kExact);
     }
 }
 
@@ -279,13 +294,16 @@ void KeyUD::PushFillStatus(KeeperState const K_, KeyUD const* const key_)
     if (key_) {
         key_->pushFillStatus(K_);                                                                  // _K: ... <fill status>
     } else {
-        luaG_pushstring(K_, KeyUD::kUnder);                                                        // _K: ... "under"
+        luaW_pushstring(K_, KeyUD::kUnder);                                                        // _K: ... "under"
     }
 }
 
 // #################################################################################################
 
-// expects 'this' on top of the stack
+// in: expects 'this' on top of the stack
+// out: nothing
+// returns true if the channel was full
+[[nodiscard]]
 bool KeyUD::reset(KeeperState const K_)
 {
     LUA_ASSERT(K_, KeyUD::GetPtr(K_, kIdxTop) == this);
@@ -312,10 +330,10 @@ static void PushKeysDB(KeeperState const K_, StackIndex const idx_)
 {
     STACK_GROW(K_, 5);
     STACK_CHECK_START_REL(K_, 0);
-    StackIndex const _absidx{ luaG_absindex(K_, idx_) };
+    StackIndex const _absidx{ luaW_absindex(K_, idx_) };
     kLindasRegKey.pushValue(K_);                                                                   // K_: ... LindasDB
     lua_pushvalue(K_, _absidx);                                                                    // K_: ... LindasDB linda
-    if (luaG_rawget(K_, StackIndex{ -2 }) == LuaType::NIL) {                                       // K_: ... LindasDB KeysDB
+    if (luaW_rawget(K_, StackIndex{ -2 }) == LuaType::NIL) {                                       // K_: ... LindasDB KeysDB
         lua_pop(K_, 1);                                                                            // K_: ... LindasDB
         // add a new KeysDB table for this linda
         lua_newtable(K_);                                                                          // K_: ... LindasDB KeysDB
@@ -337,6 +355,7 @@ static void PushKeysDB(KeeperState const K_, StackIndex const idx_)
 
 // in: linda
 // out: nothing
+[[nodiscard]]
 int keepercall_collectgarbage(lua_State* const L_)
 {
     lua_gc(L_, LUA_GCCOLLECT, 0);
@@ -346,6 +365,7 @@ int keepercall_collectgarbage(lua_State* const L_)
 // #################################################################################################
 
 // in: linda [, key [, ...]]
+[[nodiscard]]
 int keepercall_count(lua_State* const L_)
 {
     KeeperState const _K{ L_ };
@@ -370,7 +390,7 @@ int keepercall_count(lua_State* const L_)
     case 2:                                                                                        // _K: linda key
         PushKeysDB(_K, StackIndex{ 1 });                                                           // _K: linda key KeysDB
         lua_replace(_K, 1);                                                                        // _K: KeysDB key
-        if (luaG_rawget(_K, StackIndex{ -2 }) == LuaType::NIL) { // the key is unknown             // _K: KeysDB KeyUD|nil
+        if (luaW_rawget(_K, StackIndex{ -2 }) == LuaType::NIL) { // the key is unknown             // _K: KeysDB KeyUD|nil
             lua_remove(_K, -2);                                                                    // _K: nil
         } else { // the key is known                                                               // _K: KeysDB KeyUD
             KeyUD* const _key{ KeyUD::GetPtr(_K, kIdxTop) };
@@ -409,6 +429,7 @@ int keepercall_count(lua_State* const L_)
 
 // in: linda
 // not part of the linda public API, only used for cleanup at linda GC
+[[nodiscard]]
 int keepercall_destruct(lua_State* const L_)
 {
     STACK_GROW(L_, 3);
@@ -427,6 +448,7 @@ int keepercall_destruct(lua_State* const L_)
 
 // in: linda_ud key [count]
 // out: N <N values>|kRestrictedChannel
+[[nodiscard]]
 int keepercall_get(lua_State* const L_)
 {
     KeeperState const _K{ L_ };
@@ -461,6 +483,7 @@ int keepercall_get(lua_State* const L_)
 
 // in: linda key [n|nil]
 // out: boolean, <fill status: string>
+[[nodiscard]]
 int keepercall_limit(lua_State* const L_)
 {
     KeeperState const _K{ L_ };
@@ -480,7 +503,7 @@ int keepercall_limit(lua_State* const L_)
         if (_key && _key->limit >= 0) {
             lua_pushinteger(_K, _key->limit);                                                      // _K: limit
         } else { // if the key doesn't exist, it is unlimited by default
-            luaG_pushstring(_K, "unlimited");                                                      // _K: "unlimited"
+            luaW_pushstring(_K, "unlimited");                                                      // _K: "unlimited"
         }
         // return a single value: the limit of the key
     } else {
@@ -504,6 +527,7 @@ int keepercall_limit(lua_State* const L_)
 
 // in: linda, key [, key]?
 // out: (key, val) or nothing
+[[nodiscard]]
 int keepercall_receive(lua_State* const L_)
 {
     KeeperState const _K{ L_ };
@@ -548,6 +572,7 @@ int keepercall_receive(lua_State* const L_)
 // #################################################################################################
 
 // in: linda key mincount [maxcount]
+[[nodiscard]]
 int keepercall_receive_batched(lua_State* const L_)
 {
     KeeperState const _K{ L_ };
@@ -581,6 +606,7 @@ int keepercall_receive_batched(lua_State* const L_)
 
 // in: linda key [mode]
 // out: mode
+[[nodiscard]]
 int keepercall_restrict(lua_State* const L_)
 {
     KeeperState const _K{ L_ };
@@ -591,7 +617,7 @@ int keepercall_restrict(lua_State* const L_)
         if (_reading) {
             return LindaRestrict::None;
         }
-        std::string_view const _val{ luaG_tostring(_K, StackIndex{ 3 }) };
+        std::string_view const _val{ luaW_tostring(_K, StackIndex{ 3 }) };
         if (_val == "set/get") {
             return LindaRestrict::SetGet;
         }
@@ -623,7 +649,7 @@ int keepercall_restrict(lua_State* const L_)
         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
+        luaW_pushstring(_K, _encodeRestrict(_prevRstrct));                                          // _K: _previous
     } else {
         if (_key == nullptr) {                                                                     // _K: KeysDB key nil
             lua_pop(_K, 1);                                                                        // _K: KeysDB key
@@ -635,7 +661,7 @@ int keepercall_restrict(lua_State* const L_)
         // 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
+        luaW_pushstring(_K, _encodeRestrict(_previous));                                           // _K: _previous
     }
     STACK_CHECK(_K, 1);
     return 1;
@@ -645,6 +671,7 @@ int keepercall_restrict(lua_State* const L_)
 
 // in: linda, key, ...
 // out: true|false|kRestrictedChannel
+[[nodiscard]]
 int keepercall_send(lua_State* const L_)
 {
     KeeperState const _K{ L_ };
@@ -653,7 +680,7 @@ int keepercall_send(lua_State* const L_)
     PushKeysDB(_K, StackIndex{ 1 });                                                               // _K: linda key val... KeysDB
     // get the fifo associated to this key in this linda, create it if it doesn't exist
     lua_pushvalue(_K, 2);                                                                          // _K: linda key val... KeysDB key
-    if (luaG_rawget(_K, StackIndex{ -2 }) == LuaType::NIL) {                                       // _K: linda key val... KeysDB KeyUD|nil
+    if (luaW_rawget(_K, StackIndex{ -2 }) == LuaType::NIL) {                                       // _K: linda key val... KeysDB KeyUD|nil
         lua_pop(_K, 1);                                                                            // _K: linda key val... KeysDB
         std::ignore = KeyUD::Create(KeeperState{ _K });                                            // _K: linda key val... KeysDB KeyUD
         // KeysDB[key] = KeyUD
@@ -684,6 +711,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, or kRestrictedChannel if the key is restricted
+[[nodiscard]]
 int keepercall_set(lua_State* const L_)
 {
     KeeperState const _K{ L_ };
@@ -753,6 +781,7 @@ int keepercall_set(lua_State* const L_)
  *
  * Returns: number of return values (pushed to 'L'), unset in case of error
  */
+[[nodiscard]]
 KeeperCallResult keeper_call(KeeperState const K_, keeper_api_t const func_, lua_State* const L_, Linda* const linda_, StackIndex const starting_index_)
 {
     KeeperCallResult _result;
@@ -811,22 +840,6 @@ KeeperCallResult keeper_call(KeeperState const K_, keeper_api_t const func_, lua
 // #################################################################################################
 // #################################################################################################
 
-void* Keeper::operator new[](size_t size_, Universe* U_) noexcept
-{
-    // size_ is the memory for the element count followed by the elements themselves
-    return U_->internalAllocator.alloc(size_);
-}
-
-// #################################################################################################
-
-// can't actually delete the operator because the compiler generates stack unwinding code that could call it in case of exception
-void Keeper::operator delete[](void* p_, Universe* U_)
-{
-    U_->internalAllocator.free(p_, *static_cast<size_t*>(p_) * sizeof(Keeper) + sizeof(size_t));
-}
-
-// #################################################################################################
-
 // only used by linda:dump() and linda:__towatch() for debugging purposes
 // table is populated as follows:
 // {
@@ -838,6 +851,7 @@ void Keeper::operator delete[](void* p_, Universe* U_)
 //     }
 //     ...
 // }
+[[nodiscard]]
 int Keeper::PushLindaStorage(Linda& linda_, DestState const L_)
 {
     Keeper* const _keeper{ linda_.whichKeeper() };
@@ -849,7 +863,7 @@ int Keeper::PushLindaStorage(Linda& linda_, DestState const L_)
     STACK_CHECK_START_REL(_K, 0);
     kLindasRegKey.pushValue(_K);                                                                   // _K: LindasDB                                       L_:
     lua_pushlightuserdata(_K, &linda_);                                                            // _K: LindasDB linda                                 L_:
-    LuaType const _type{ luaG_rawget(_K, StackIndex{ -2 }) };                                      // _K: LindasDB KeysDB                                L_:
+    LuaType const _type{ luaW_rawget(_K, StackIndex{ -2 }) };                                      // _K: LindasDB KeysDB                                L_:
     lua_remove(_K, -2);                                                                            // _K: KeysDB                                         L_:
     if (_type != LuaType::TABLE) { // possible if we didn't send anything through that linda
         lua_pop(_K, 1);                                                                            // _K:                                                L_:
@@ -886,20 +900,20 @@ int Keeper::PushLindaStorage(Linda& linda_, DestState const L_)
         if (_key->limit >= 0) {
             lua_pushinteger(L_, _key->limit);                                                      // _K: KeysDB key                                     L_: out key keyout fifo limit
         } else {
-            luaG_pushstring(L_, "unlimited");                                                      // _K: KeysDB key                                     L_: out key keyout fifo limit
+            luaW_pushstring(L_, "unlimited");                                                      // _K: KeysDB key                                     L_: out key keyout fifo limit
         }
         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
+            luaW_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
+            luaW_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
+            luaW_pushstring(L_, "send/receive");                                                   // _K: KeysDB key                                     L_: out key keyout fifo restrict
             break;
         }
         STACK_CHECK(L_, 5);
@@ -927,7 +941,7 @@ void Keepers::DeleteKV::operator()(Keeper* const k_) const
     for (auto& _k : std::span<Keeper>(k_, count)) {
         _k.~Keeper();
     }
-    U->internalAllocator.free(k_, count * sizeof(Keeper));
+    U.internalAllocator.free(k_, count * sizeof(Keeper));
 }
 
 // #################################################################################################
@@ -959,24 +973,24 @@ void Keepers::collectGarbage()
         // when keeper N+1 is closed, object is GCed, linda operation is called, which attempts to acquire keeper N, whose Lua state no longer exists
         // in that case, the linda operation should do nothing. which means that these operations must check for keeper acquisition success
         // which is early-outed with a keepers->nbKeepers null-check
-        for (size_t const _i : std::ranges::iota_view{ size_t{ 0 }, _kv.nbKeepers }) {
-            _gcOneKeeper(_kv.keepers[_i]);
+        for (Keeper& _k : std::span<Keeper>{ _kv.keepers.get(), _kv.nbKeepers }) {
+            _gcOneKeeper(_k);
         }
     }
 }
 
 // #################################################################################################
 
-
-void Keepers::close()
+[[nodiscard]]
+bool Keepers::close()
 {
     if (isClosing.test_and_set(std::memory_order_release)) {
-        assert(false); // should never close more than once in practice
-        return;
+        return false; // should never close more than once in practice
     }
 
+    // We may have not initialized the keepers if an error was raised in Universe::Create because of bad settings
     if (std::holds_alternative<std::monostate>(keeper_array)) {
-        return;
+        return true;
     }
 
     auto _closeOneKeeper = [](Keeper& keeper_) {
@@ -996,9 +1010,8 @@ void Keepers::close()
         // when keeper N+1 is closed, object is GCed, linda operation is called, which attempts to acquire keeper N, whose Lua state no longer exists
         // in that case, the linda operation should do nothing. which means that these operations must check for keeper acquisition success
         // which is early-outed with a keepers->nbKeepers null-check
-        size_t const _nbKeepers{ std::exchange(_kv.nbKeepers, size_t{ 0 }) };
-        for (size_t const _i : std::ranges::iota_view{ size_t{ 0 }, _nbKeepers }) {
-            if (!_closeOneKeeper(_kv.keepers[_i])) {
+        for (Keeper& _k : std::span<Keeper>{ _kv.keepers.get(), std::exchange(_kv.nbKeepers, size_t{ 0 }) }) {
+            if (!_closeOneKeeper(_k)) {
                 // detected partial init: destroy only the mutexes that got initialized properly
                 break;
             }
@@ -1006,6 +1019,7 @@ void Keepers::close()
     }
 
     keeper_array.emplace<std::monostate>();
+    return true;
 }
 
 // #################################################################################################
@@ -1076,7 +1090,7 @@ void Keepers::initialize(Universe& U_, lua_State* L_, size_t const nbKeepers_, i
         keeper_.K = _K;
 
         // Give a name to the state
-        luaG_pushstring(_K, "Keeper #%d", i_ + 1);                                                 // L_: settings                                   _K: "Keeper #n"
+        luaW_pushstring(_K, "Keeper #%d", i_ + 1);                                                 // L_: settings                                   _K: "Keeper #n"
         if constexpr (HAVE_DECODA_SUPPORT()) {
             lua_pushvalue(_K, -1);                                                                 //                                                _K: "Keeper #n" Keeper #n"
             lua_setglobal(_K, "decoda_name");                                                      // L_: settings                                   _K: "Keeper #n"
@@ -1098,9 +1112,9 @@ void Keepers::initialize(Universe& U_, lua_State* L_, size_t const nbKeepers_, i
         STACK_CHECK(_K, 0);
 
         // copy package.path and package.cpath from the source state
-        if (luaG_getmodule(L, LUA_LOADLIBNAME) != LuaType::NIL) {                                  // L_: settings package                           _K:
+        if (luaW_getmodule(L, LUA_LOADLIBNAME) != LuaType::NIL) {                                  // L_: settings package                           _K:
             // when copying with mode LookupMode::ToKeeper, error message is pushed at the top of the stack, not raised immediately
-            InterCopyContext _c{ U, DestState{ _K.value() }, SourceState{ L }, {}, SourceIndex{ luaG_absindex(L, kIdxTop).value() }, {}, LookupMode::ToKeeper, {} };
+            InterCopyContext _c{ U, DestState{ _K.value() }, SourceState{ L }, {}, SourceIndex{ luaW_absindex(L, kIdxTop).value() }, {}, LookupMode::ToKeeper, {} };
             if (_c.interCopyPackage() != InterCopyResult::Success) {                               // L_: settings ... error_msg                     _K:
                 // if something went wrong, the error message is at the top of the stack
                 lua_remove(L, -2);                                                                 // L_: settings error_msg
@@ -1137,11 +1151,14 @@ void Keepers::initialize(Universe& U_, lua_State* L_, size_t const nbKeepers_, i
 
     default:
         KV& _kv = keeper_array.emplace<KV>(
-            std::unique_ptr<Keeper[], DeleteKV>{ new(&U_) Keeper[nbKeepers_], DeleteKV{ &U_, nbKeepers_ } },
+            std::unique_ptr<Keeper, DeleteKV>{ static_cast<Keeper*>(U_.internalAllocator.alloc(sizeof(Keeper) * nbKeepers_)), DeleteKV{ U_, nbKeepers_ } },
             nbKeepers_
         );
-        for (size_t const _i : std::ranges::iota_view{ size_t{ 0 }, nbKeepers_ }) {
-            _initOneKeeper(_kv.keepers[_i], static_cast<int>(_i));
+        // fak. std::ranges::views::enumerate is c++23 (would help having item and index iterated over simultaneously)
+        int _i{};
+        for (Keeper& _k : std::span<Keeper>{ _kv.keepers.get(), nbKeepers_ }) {
+            new (&_k) Keeper{};
+            _initOneKeeper(_k, _i++);
         }
     }
 }