isomorfeus-ferret 0.15.0 → 0.16.0

data/ext/isomorfeus_ferret_ext/mdbx.c

@@ -12,7 +12,7 @@
  * <http://www.OpenLDAP.org/license.html>. */
 
 #define xMDBX_ALLOY 1
-#define MDBX_BUILD_SOURCERY e17be563de6f6f85e208ded5aacc1387bc0addf6ce5540c99d0d15db2c3e8edd_v0_12_2_0_g9b062cf0
+#define MDBX_BUILD_SOURCERY 56f8a04f0668bb80d0d3f24fd2c9958d9aeb83004b65badfd5ccfa80647a2218_v0_12_2_18_gb3248442
 #ifdef MDBX_CONFIG_H
 #include MDBX_CONFIG_H
 #endif
@@ -428,14 +428,13 @@ __extern_C key_t ftok(const char *, int);
 /* Byteorder */
 
 #if defined(i386) || defined(__386) || defined(__i386) || defined(__i386__) || \
-    defined(i486) || defined(__i486) || defined(__i486__) ||                   \
-    defined(i586) || defined(__i586) || defined(__i586__) ||                   \
-    defined(i686) || defined(__i686) || defined(__i686__) ||                   \
-    defined(_M_IX86) || defined(_X86_) || defined(__I86__) ||                  \
-    defined(__THW_INTEL__) || defined(__INTEL__) ||                            \
-    defined(__x86_64) || defined(__x86_64__) ||                                \
+    defined(i486) || defined(__i486) || defined(__i486__) || defined(i586) ||  \
+    defined(__i586) || defined(__i586__) || defined(i686) ||                   \
+    defined(__i686) || defined(__i686__) || defined(_M_IX86) ||                \
+    defined(_X86_) || defined(__THW_INTEL__) || defined(__I86__) ||            \
+    defined(__INTEL__) || defined(__x86_64) || defined(__x86_64__) ||          \
     defined(__amd64__) || defined(__amd64) || defined(_M_X64) ||               \
-    defined(_M_AMD64) || defined(__IA32__)
+    defined(_M_AMD64) || defined(__IA32__) || defined(__INTEL__)
 #ifndef __ia32__
 /* LY: define neutral __ia32__ for x86 and x86-64 */
 #define __ia32__ 1
@@ -3138,13 +3137,9 @@ struct MDBX_txn {
   /* Additional flag for sync_locked() */
 #define MDBX_SHRINK_ALLOWED UINT32_C(0x40000000)
 
-#define MDBX_TXN_UPDATE_GC 0x20 /* GC is being updated */
-#define MDBX_TXN_FROZEN_RE 0x40 /* list of reclaimed-pgno must not altered */
-
 #define TXN_FLAGS                                                              \
   (MDBX_TXN_FINISHED | MDBX_TXN_ERROR | MDBX_TXN_DIRTY | MDBX_TXN_SPILLS |     \
-   MDBX_TXN_HAS_CHILD | MDBX_TXN_INVALID | MDBX_TXN_UPDATE_GC |                \
-   MDBX_TXN_FROZEN_RE)
+   MDBX_TXN_HAS_CHILD | MDBX_TXN_INVALID)
 
 #if (TXN_FLAGS & (MDBX_TXN_RW_BEGIN_FLAGS | MDBX_TXN_RO_BEGIN_FLAGS)) ||       \
     ((MDBX_TXN_RW_BEGIN_FLAGS | MDBX_TXN_RO_BEGIN_FLAGS | TXN_FLAGS) &         \
@@ -3226,11 +3221,16 @@ struct MDBX_txn {
       MDBX_page *loose_pages;
       /* Number of loose pages (tw.loose_pages) */
       size_t loose_count;
-      size_t spill_least_removed;
-      /* The sorted list of dirty pages we temporarily wrote to disk
-       * because the dirty list was full. page numbers in here are
-       * shifted left by 1, deleted slots have the LSB set. */
-      MDBX_PNL spill_pages;
+      union {
+        struct {
+          size_t least_removed;
+          /* The sorted list of dirty pages we temporarily wrote to disk
+           * because the dirty list was full. page numbers in here are
+           * shifted left by 1, deleted slots have the LSB set. */
+          MDBX_PNL list;
+        } spilled;
+        size_t writemap_dirty_npages;
+      };
     } tw;
   };
 };
@@ -3280,6 +3280,9 @@ struct MDBX_cursor {
 #define C_SUB 0x04         /* Cursor is a sub-cursor */
 #define C_DEL 0x08         /* last op was a cursor_del */
 #define C_UNTRACK 0x10     /* Un-track cursor when closing */
+#define C_GCU                                                                                  \
+  0x20 /* Происходит подготовка к обновлению GC, поэтому \
+        * можно брать страницы из GC даже для FREE_DBI */
   uint8_t mc_flags;
 
   /* Cursor checking flags. */
@@ -4643,7 +4646,7 @@ __cold static const char *pagetype_caption(const uint8_t type,
   }
 }
 
-__cold static __must_check_result int MDBX_PRINTF_ARGS(2, 3)
+__cold static int MDBX_PRINTF_ARGS(2, 3)
     bad_page(const MDBX_page *mp, const char *fmt, ...) {
   if (LOG_ENABLED(MDBX_LOG_ERROR)) {
     static const MDBX_page *prev;
@@ -5257,7 +5260,7 @@ __cold void thread_dtor(void *rthc) {
     if (atomic_load32(&reader->mr_pid, mo_Relaxed) == self_pid) {
       TRACE("==== thread 0x%" PRIxPTR ", rthc %p, cleanup", osal_thread_self(),
             __Wpedantic_format_voidptr(reader));
-      atomic_cas32(&reader->mr_pid, self_pid, 0);
+      (void)atomic_cas32(&reader->mr_pid, self_pid, 0);
     }
   }
 
@@ -6346,50 +6349,51 @@ __hot static size_t pnl_merge(MDBX_PNL dst, const MDBX_PNL src) {
   return total;
 }
 
-static void spill_remove(MDBX_txn *txn, size_t idx, pgno_t npages) {
-  tASSERT(txn, idx > 0 && idx <= MDBX_PNL_GETSIZE(txn->tw.spill_pages) &&
-                   txn->tw.spill_least_removed > 0);
-  txn->tw.spill_least_removed =
-      (idx < txn->tw.spill_least_removed) ? idx : txn->tw.spill_least_removed;
-  txn->tw.spill_pages[idx] |= 1;
-  MDBX_PNL_SETSIZE(txn->tw.spill_pages,
-                   MDBX_PNL_GETSIZE(txn->tw.spill_pages) -
-                       (idx == MDBX_PNL_GETSIZE(txn->tw.spill_pages)));
+static void spill_remove(MDBX_txn *txn, size_t idx, size_t npages) {
+  tASSERT(txn, idx > 0 && idx <= MDBX_PNL_GETSIZE(txn->tw.spilled.list) &&
+                   txn->tw.spilled.least_removed > 0);
+  txn->tw.spilled.least_removed = (idx < txn->tw.spilled.least_removed)
+                                      ? idx
+                                      : txn->tw.spilled.least_removed;
+  txn->tw.spilled.list[idx] |= 1;
+  MDBX_PNL_SETSIZE(txn->tw.spilled.list,
+                   MDBX_PNL_GETSIZE(txn->tw.spilled.list) -
+                       (idx == MDBX_PNL_GETSIZE(txn->tw.spilled.list)));
 
   while (unlikely(npages > 1)) {
-    const pgno_t pgno = (txn->tw.spill_pages[idx] >> 1) + 1;
+    const pgno_t pgno = (txn->tw.spilled.list[idx] >> 1) + 1;
     if (MDBX_PNL_ASCENDING) {
-      if (++idx > MDBX_PNL_GETSIZE(txn->tw.spill_pages) ||
-          (txn->tw.spill_pages[idx] >> 1) != pgno)
+      if (++idx > MDBX_PNL_GETSIZE(txn->tw.spilled.list) ||
+          (txn->tw.spilled.list[idx] >> 1) != pgno)
         return;
     } else {
-      if (--idx < 1 || (txn->tw.spill_pages[idx] >> 1) != pgno)
+      if (--idx < 1 || (txn->tw.spilled.list[idx] >> 1) != pgno)
         return;
-      txn->tw.spill_least_removed = (idx < txn->tw.spill_least_removed)
-                                        ? idx
-                                        : txn->tw.spill_least_removed;
-    }
-    txn->tw.spill_pages[idx] |= 1;
-    MDBX_PNL_SETSIZE(txn->tw.spill_pages,
-                     MDBX_PNL_GETSIZE(txn->tw.spill_pages) -
-                         (idx == MDBX_PNL_GETSIZE(txn->tw.spill_pages)));
+      txn->tw.spilled.least_removed = (idx < txn->tw.spilled.least_removed)
+                                          ? idx
+                                          : txn->tw.spilled.least_removed;
+    }
+    txn->tw.spilled.list[idx] |= 1;
+    MDBX_PNL_SETSIZE(txn->tw.spilled.list,
+                     MDBX_PNL_GETSIZE(txn->tw.spilled.list) -
+                         (idx == MDBX_PNL_GETSIZE(txn->tw.spilled.list)));
     --npages;
   }
 }
 
 static MDBX_PNL spill_purge(MDBX_txn *txn) {
-  tASSERT(txn, txn->tw.spill_least_removed > 0);
-  const MDBX_PNL sl = txn->tw.spill_pages;
-  if (txn->tw.spill_least_removed != INT_MAX) {
+  tASSERT(txn, txn->tw.spilled.least_removed > 0);
+  const MDBX_PNL sl = txn->tw.spilled.list;
+  if (txn->tw.spilled.least_removed != INT_MAX) {
     size_t len = MDBX_PNL_GETSIZE(sl), r, w;
-    for (w = r = txn->tw.spill_least_removed; r <= len; ++r) {
+    for (w = r = txn->tw.spilled.least_removed; r <= len; ++r) {
       sl[w] = sl[r];
       w += 1 - (sl[r] & 1);
     }
     for (size_t i = 1; i < w; ++i)
       tASSERT(txn, (sl[i] & 1) == 0);
     MDBX_PNL_SETSIZE(sl, w - 1);
-    txn->tw.spill_least_removed = INT_MAX;
+    txn->tw.spilled.least_removed = INT_MAX;
   } else {
     for (size_t i = 1; i <= MDBX_PNL_GETSIZE(sl); ++i)
       tASSERT(txn, (sl[i] & 1) == 0);
@@ -6445,7 +6449,8 @@ static __inline size_t pnl_search(const MDBX_PNL pnl, pgno_t pgno,
 }
 
 static __inline size_t search_spilled(const MDBX_txn *txn, pgno_t pgno) {
-  const MDBX_PNL pnl = txn->tw.spill_pages;
+  tASSERT(txn, (txn->mt_flags & MDBX_WRITEMAP) == 0 || MDBX_AVOID_MSYNC);
+  const MDBX_PNL pnl = txn->tw.spilled.list;
   if (likely(!pnl))
     return 0;
   pgno <<= 1;
@@ -6454,8 +6459,8 @@ static __inline size_t search_spilled(const MDBX_txn *txn, pgno_t pgno) {
 }
 
 static __inline bool intersect_spilled(const MDBX_txn *txn, pgno_t pgno,
-                                       pgno_t npages) {
-  const MDBX_PNL pnl = txn->tw.spill_pages;
+                                       size_t npages) {
+  const MDBX_PNL pnl = txn->tw.spilled.list;
   if (likely(!pnl))
     return false;
   const size_t len = MDBX_PNL_GETSIZE(pnl);
@@ -6467,7 +6472,7 @@ static __inline bool intersect_spilled(const MDBX_txn *txn, pgno_t pgno,
     DEBUG_EXTRA_PRINT("%s\n", "]");
   }
   const pgno_t spilled_range_begin = pgno << 1;
-  const pgno_t spilled_range_last = ((pgno + npages) << 1) - 1;
+  const pgno_t spilled_range_last = ((pgno + (pgno_t)npages) << 1) - 1;
 #if MDBX_PNL_ASCENDING
   const size_t n =
       pnl_search(pnl, spilled_range_begin, (size_t)(MAX_PAGENO + 1) << 1);
@@ -6831,7 +6836,7 @@ dpl_endpgno(const MDBX_dpl *dl, size_t i) {
 }
 
 static __inline bool dpl_intersect(const MDBX_txn *txn, pgno_t pgno,
-                                   pgno_t npages) {
+                                   size_t npages) {
   tASSERT(txn, (txn->mt_flags & MDBX_TXN_RDONLY) == 0);
   tASSERT(txn, (txn->mt_flags & MDBX_WRITEMAP) == 0 || MDBX_AVOID_MSYNC);
 
@@ -6889,7 +6894,7 @@ MDBX_MAYBE_UNUSED static const MDBX_page *debug_dpl_find(const MDBX_txn *txn,
   return nullptr;
 }
 
-static void dpl_remove_ex(const MDBX_txn *txn, size_t i, pgno_t npages) {
+static void dpl_remove_ex(const MDBX_txn *txn, size_t i, size_t npages) {
   tASSERT(txn, (txn->mt_flags & MDBX_TXN_RDONLY) == 0);
   tASSERT(txn, (txn->mt_flags & MDBX_WRITEMAP) == 0 || MDBX_AVOID_MSYNC);
 
@@ -6911,7 +6916,7 @@ static void dpl_remove(const MDBX_txn *txn, size_t i) {
 static __always_inline int __must_check_result dpl_append(MDBX_txn *txn,
                                                           pgno_t pgno,
                                                           MDBX_page *page,
-                                                          pgno_t npages) {
+                                                          size_t npages) {
   tASSERT(txn, (txn->mt_flags & MDBX_TXN_RDONLY) == 0);
   tASSERT(txn, (txn->mt_flags & MDBX_WRITEMAP) == 0 || MDBX_AVOID_MSYNC);
   MDBX_dpl *dl = txn->tw.dirtylist;
@@ -6980,7 +6985,7 @@ static __must_check_result __inline int page_retire(MDBX_cursor *mc,
                                                     MDBX_page *mp);
 
 static int __must_check_result page_dirty(MDBX_txn *txn, MDBX_page *mp,
-                                          pgno_t npages);
+                                          size_t npages);
 typedef struct page_result {
   MDBX_page *page;
   int err;
@@ -6989,7 +6994,7 @@ typedef struct page_result {
 static txnid_t kick_longlived_readers(MDBX_env *env, const txnid_t laggard);
 
 static pgr_t page_new(MDBX_cursor *mc, const unsigned flags);
-static pgr_t page_new_large(MDBX_cursor *mc, const pgno_t npages);
+static pgr_t page_new_large(MDBX_cursor *mc, const size_t npages);
 static int page_touch(MDBX_cursor *mc);
 static int cursor_touch(MDBX_cursor *mc);
 static int touch_dbi(MDBX_cursor *mc);
@@ -7588,7 +7593,7 @@ static MDBX_page *page_malloc(MDBX_txn *txn, size_t num) {
 }
 
 /* Free a shadow dirty page */
-static void dpage_free(MDBX_env *env, MDBX_page *dp, pgno_t npages) {
+static void dpage_free(MDBX_env *env, MDBX_page *dp, size_t npages) {
   VALGRIND_MAKE_MEM_UNDEFINED(dp, pgno2bytes(env, npages));
   MDBX_ASAN_UNPOISON_MEMORY_REGION(dp, pgno2bytes(env, npages));
   if (unlikely(env->me_flags & MDBX_PAGEPERTURB))
@@ -7910,7 +7915,7 @@ static bool txn_refund(MDBX_txn *txn) {
   if (before == txn->mt_next_pgno)
     return false;
 
-  if (txn->tw.spill_pages)
+  if (txn->tw.spilled.list)
     /* Squash deleted pagenums if we refunded any */
     spill_purge(txn);
 
@@ -7925,9 +7930,9 @@ static __inline bool txn_refund(MDBX_txn *txn) {
 #endif /* MDBX_ENABLE_REFUND */
 
 __cold static void kill_page(MDBX_txn *txn, MDBX_page *mp, pgno_t pgno,
-                             pgno_t npages) {
+                             size_t npages) {
   MDBX_env *const env = txn->mt_env;
-  DEBUG("kill %u page(s) %" PRIaPGNO, npages, pgno);
+  DEBUG("kill %zu page(s) %" PRIaPGNO, npages, pgno);
   eASSERT(env, pgno >= NUM_METAS && npages);
   if (!IS_FROZEN(txn, mp)) {
     const size_t bytes = pgno2bytes(env, npages);
@@ -7954,7 +7959,7 @@ __cold static void kill_page(MDBX_txn *txn, MDBX_page *mp, pgno_t pgno,
 
 /* Remove page from dirty list */
 static __inline void page_wash(MDBX_txn *txn, const size_t di,
-                               MDBX_page *const mp, const pgno_t npages) {
+                               MDBX_page *const mp, const size_t npages) {
   tASSERT(txn, (txn->mt_flags & MDBX_TXN_RDONLY) == 0);
   tASSERT(txn, (txn->mt_flags & MDBX_WRITEMAP) == 0 || MDBX_AVOID_MSYNC);
   tASSERT(txn, di && di <= txn->tw.dirtylist->length &&
@@ -8003,7 +8008,7 @@ static int page_retire_ex(MDBX_cursor *mc, const pgno_t pgno,
    *  So for flexibility and avoid extra internal dependencies we just
    *  fallback to reading if dirty list was not allocated yet. */
   size_t di = 0, si = 0;
-  pgno_t npages = 1;
+  size_t npages = 1;
   bool is_frozen = false, is_spilled = false, is_shadowed = false;
   if (unlikely(!mp)) {
     if (ASSERT_ENABLED() && pageflags) {
@@ -8019,7 +8024,7 @@ static int page_retire_ex(MDBX_cursor *mc, const pgno_t pgno,
       is_frozen = true;
       if (ASSERT_ENABLED()) {
         for (MDBX_txn *scan = txn; scan; scan = scan->mt_parent) {
-          tASSERT(txn, !search_spilled(scan, pgno));
+          tASSERT(txn, !txn->tw.spilled.list || !search_spilled(scan, pgno));
           tASSERT(txn, !scan->tw.dirtylist || !debug_dpl_find(scan, pgno));
         }
       }
@@ -8064,7 +8069,7 @@ static int page_retire_ex(MDBX_cursor *mc, const pgno_t pgno,
     is_shadowed = IS_SHADOWED(txn, mp);
     if (is_dirty) {
       tASSERT(txn, !is_spilled);
-      tASSERT(txn, !search_spilled(txn, pgno));
+      tASSERT(txn, !txn->tw.spilled.list || !search_spilled(txn, pgno));
       tASSERT(txn, debug_dpl_find(txn, pgno) == mp || txn->mt_parent ||
                        (txn->mt_flags & MDBX_WRITEMAP));
     } else {
@@ -8098,12 +8103,12 @@ status_done:
   } else {
     npages = mp->mp_pages;
     cASSERT(mc, mc->mc_db->md_overflow_pages >= npages);
-    mc->mc_db->md_overflow_pages -= npages;
+    mc->mc_db->md_overflow_pages -= (pgno_t)npages;
   }
 
   if (is_frozen) {
   retire:
-    DEBUG("retire %u page %" PRIaPGNO, npages, pgno);
+    DEBUG("retire %zu page %" PRIaPGNO, npages, pgno);
     rc = pnl_append_range(false, &txn->tw.retired_pages, pgno, npages);
     tASSERT(txn, dirtylist_check(txn));
     return rc;
@@ -8154,7 +8159,7 @@ status_done:
       }
       tASSERT(txn, is_spilled || is_shadowed || (mp && IS_SHADOWED(txn, mp)));
     }
-    DEBUG("refunded %u %s page %" PRIaPGNO, npages, kind, pgno);
+    DEBUG("refunded %zu %s page %" PRIaPGNO, npages, kind, pgno);
     txn->mt_next_pgno = pgno;
     txn_refund(txn);
     return MDBX_SUCCESS;
@@ -8223,7 +8228,7 @@ status_done:
     page_wash(txn, di, mp, npages);
 
   reclaim:
-    DEBUG("reclaim %u %s page %" PRIaPGNO, npages, "dirty", pgno);
+    DEBUG("reclaim %zu %s page %" PRIaPGNO, npages, "dirty", pgno);
     rc = pnl_insert_range(&txn->tw.relist, pgno, npages);
     tASSERT(txn, pnl_check_allocated(txn->tw.relist,
                                      txn->mt_next_pgno - MDBX_ENABLE_REFUND));
@@ -8330,7 +8335,7 @@ static void iov_callback4dirtypages(iov_ctx_t *ctx, size_t offset, void *data,
     osal_flush_incoherent_mmap(env->me_map + offset, bytes, env->me_os_psize);
     const MDBX_page *const rp = (const MDBX_page *)(env->me_map + offset);
     /* check with timeout as the workaround
-     * for https://web.archive.org/web/https://github.com/erthink/libmdbx/issues/269 */
+     * for https://libmdbx.dqdkfa.ru/dead-github/issues/269 */
     if (unlikely(memcmp(wp, rp, bytes))) {
       ctx->coherency_timestamp = 0;
       WARNING("catch delayed/non-arrived page %" PRIaPGNO " %s", wp->mp_pgno,
@@ -8351,11 +8356,12 @@ static void iov_callback4dirtypages(iov_ctx_t *ctx, size_t offset, void *data,
     do {
       eASSERT(env, wp->mp_pgno == bytes2pgno(env, offset));
       eASSERT(env, (wp->mp_flags & P_ILL_BITS) == 0);
-      unsigned npages = IS_OVERFLOW(wp) ? wp->mp_pages : 1u;
+      size_t npages = IS_OVERFLOW(wp) ? wp->mp_pages : 1u;
       size_t chunk = pgno2bytes(env, npages);
       eASSERT(env, bytes >= chunk);
+      MDBX_page *next = (MDBX_page *)((char *)wp + chunk);
       dpage_free(env, wp, npages);
-      wp = (MDBX_page *)((char *)wp + chunk);
+      wp = next;
       offset += chunk;
       bytes -= chunk;
     } while (bytes);
@@ -8384,7 +8390,7 @@ __must_check_result static int iov_write(iov_ctx_t *ctx) {
 }
 
 __must_check_result static int iov_page(MDBX_txn *txn, iov_ctx_t *ctx,
-                                        MDBX_page *dp, pgno_t npages) {
+                                        MDBX_page *dp, size_t npages) {
   MDBX_env *const env = txn->mt_env;
   tASSERT(txn, ctx->err == MDBX_SUCCESS);
   tASSERT(txn, dp->mp_pgno >= MIN_PAGENO && dp->mp_pgno < txn->mt_next_pgno);
@@ -8428,16 +8434,16 @@ __must_check_result static int iov_page(MDBX_txn *txn, iov_ctx_t *ctx,
 #if MDBX_NEED_WRITTEN_RANGE
   ctx->flush_begin =
       (ctx->flush_begin < dp->mp_pgno) ? ctx->flush_begin : dp->mp_pgno;
-  ctx->flush_end = (ctx->flush_end > dp->mp_pgno + npages)
+  ctx->flush_end = (ctx->flush_end > dp->mp_pgno + (pgno_t)npages)
                        ? ctx->flush_end
-                       : dp->mp_pgno + npages;
+                       : dp->mp_pgno + (pgno_t)npages;
 #endif /* MDBX_NEED_WRITTEN_RANGE */
   env->me_lck->mti_unsynced_pages.weak += npages;
   return MDBX_SUCCESS;
 }
 
 static int spill_page(MDBX_txn *txn, iov_ctx_t *ctx, MDBX_page *dp,
-                      const pgno_t npages) {
+                      const size_t npages) {
   tASSERT(txn, !(txn->mt_flags & MDBX_WRITEMAP) || MDBX_AVOID_MSYNC);
 #if MDBX_ENABLE_PGOP_STAT
   txn->mt_env->me_lck->mti_pgop_stat.spill.weak += npages;
@@ -8446,7 +8452,7 @@ static int spill_page(MDBX_txn *txn, iov_ctx_t *ctx, MDBX_page *dp,
   int err = iov_page(txn, ctx, dp, npages);
   if (likely(err == MDBX_SUCCESS) &&
       (!MDBX_AVOID_MSYNC || !(txn->mt_flags & MDBX_WRITEMAP)))
-    err = pnl_append_range(true, &txn->tw.spill_pages, pgno << 1, npages);
+    err = pnl_append_range(true, &txn->tw.spilled.list, pgno << 1, npages);
   return err;
 }
 
@@ -8496,16 +8502,16 @@ static unsigned spill_prio(const MDBX_txn *txn, const size_t i,
                            const uint32_t reciprocal) {
   MDBX_dpl *const dl = txn->tw.dirtylist;
   const uint32_t age = dpl_age(txn, i);
-  const unsigned npages = dpl_npages(dl, i);
+  const size_t npages = dpl_npages(dl, i);
   const pgno_t pgno = dl->items[i].pgno;
   if (age == 0) {
-    DEBUG("skip %s %u page %" PRIaPGNO, "keep", npages, pgno);
+    DEBUG("skip %s %zu page %" PRIaPGNO, "keep", npages, pgno);
     return 256;
   }
 
   MDBX_page *const dp = dl->items[i].ptr;
   if (dp->mp_flags & (P_LOOSE | P_SPILLED)) {
-    DEBUG("skip %s %u page %" PRIaPGNO,
+    DEBUG("skip %s %zu page %" PRIaPGNO,
           (dp->mp_flags & P_LOOSE)   ? "loose"
           : (dp->mp_flags & P_LOOSE) ? "loose"
                                      : "parent-spilled",
@@ -8519,7 +8525,7 @@ static unsigned spill_prio(const MDBX_txn *txn, const size_t i,
   if (parent && (parent->mt_flags & MDBX_TXN_SPILLS)) {
     do
       if (intersect_spilled(parent, pgno, npages)) {
-        DEBUG("skip-2 parent-spilled %u page %" PRIaPGNO, npages, pgno);
+        DEBUG("skip-2 parent-spilled %zu page %" PRIaPGNO, npages, pgno);
         dp->mp_flags |= P_SPILLED;
         return 256;
       }
@@ -8533,7 +8539,7 @@ static unsigned spill_prio(const MDBX_txn *txn, const size_t i,
     return prio = 256 - prio;
 
   /* make a large/overflow pages be likely to spill */
-  uint32_t factor = npages | npages >> 1;
+  size_t factor = npages | npages >> 1;
   factor |= factor >> 2;
   factor |= factor >> 4;
   factor |= factor >> 8;
@@ -8541,7 +8547,7 @@ static unsigned spill_prio(const MDBX_txn *txn, const size_t i,
   factor = prio * log2n_powerof2(factor + 1) + /* golden ratio */ 157;
   factor = (factor < 256) ? 255 - factor : 0;
   tASSERT(txn, factor < 256 && factor < (256 - prio));
-  return prio = factor;
+  return prio = (unsigned)factor;
 }
 
 /* Spill pages from the dirty list back to disk.
@@ -8645,7 +8651,7 @@ __cold static int txn_spill_slowpath(MDBX_txn *const txn, MDBX_cursor *const m0,
   if (txn->mt_flags & MDBX_WRITEMAP) {
     NOTICE("%s-spilling %zu dirty-entries, %zu dirty-npages", "msync",
            dirty_entries, dirty_npages);
-    tASSERT(txn, txn->tw.spill_pages == nullptr);
+    tASSERT(txn, txn->tw.spilled.list == nullptr);
     const MDBX_env *env = txn->mt_env;
     rc =
         osal_msync(&txn->mt_env->me_dxb_mmap, 0,
@@ -8669,10 +8675,10 @@ __cold static int txn_spill_slowpath(MDBX_txn *const txn, MDBX_cursor *const m0,
   tASSERT(txn, txn->tw.dirtylist->pages_including_loose - txn->tw.loose_count >=
                    need_spill_npages);
   if (!MDBX_AVOID_MSYNC || !(txn->mt_flags & MDBX_WRITEMAP)) {
-    if (!txn->tw.spill_pages) {
-      txn->tw.spill_least_removed = INT_MAX;
-      txn->tw.spill_pages = pnl_alloc(need_spill);
-      if (unlikely(!txn->tw.spill_pages)) {
+    if (!txn->tw.spilled.list) {
+      txn->tw.spilled.least_removed = INT_MAX;
+      txn->tw.spilled.list = pnl_alloc(need_spill);
+      if (unlikely(!txn->tw.spilled.list)) {
         rc = MDBX_ENOMEM;
       bailout:
         txn->mt_flags |= MDBX_TXN_ERROR;
@@ -8681,7 +8687,7 @@ __cold static int txn_spill_slowpath(MDBX_txn *const txn, MDBX_cursor *const m0,
     } else {
       /* purge deleted slots */
       spill_purge(txn);
-      rc = pnl_reserve(&txn->tw.spill_pages, need_spill);
+      rc = pnl_reserve(&txn->tw.spilled.list, need_spill);
       (void)rc /* ignore since the resulting list may be shorter
        and pnl_append() will increase pnl on demand */
           ;
@@ -8865,7 +8871,7 @@ __cold static int txn_spill_slowpath(MDBX_txn *const txn, MDBX_cursor *const m0,
       goto bailout;
 
     if (!MDBX_AVOID_MSYNC || !(txn->mt_flags & MDBX_WRITEMAP)) {
-      pnl_sort(txn->tw.spill_pages, (size_t)txn->mt_next_pgno << 1);
+      pnl_sort(txn->tw.spilled.list, (size_t)txn->mt_next_pgno << 1);
       txn->mt_flags |= MDBX_TXN_SPILLS;
     }
     NOTICE("spilled %u dirty-entries, %u dirty-npages, now have %zu dirty-room",
@@ -9279,6 +9285,7 @@ static txnid_t find_oldest_reader(MDBX_env *const env, const txnid_t steady) {
   MDBX_lockinfo *const lck = env->me_lck_mmap.lck;
   if (unlikely(lck == NULL /* exclusive without-lck mode */)) {
     eASSERT(env, env->me_lck == (void *)&env->x_lckless_stub);
+    env->me_lck->mti_readers_refresh_flag.weak = nothing_changed;
     return env->me_lck->mti_oldest_reader.weak = steady;
   }
 
@@ -9367,10 +9374,13 @@ __cold static pgno_t find_largest_snapshot(const MDBX_env *env,
 
 /* Add a page to the txn's dirty list */
 __hot static int __must_check_result page_dirty(MDBX_txn *txn, MDBX_page *mp,
-                                                pgno_t npages) {
+                                                size_t npages) {
   tASSERT(txn, (txn->mt_flags & MDBX_TXN_RDONLY) == 0);
+  mp->mp_txnid = txn->mt_front;
   if (!txn->tw.dirtylist) {
     tASSERT(txn, (txn->mt_flags & MDBX_WRITEMAP) != 0 && !MDBX_AVOID_MSYNC);
+    txn->tw.writemap_dirty_npages += npages;
+    tASSERT(txn, txn->tw.spilled.list == nullptr);
     return MDBX_SUCCESS;
   }
   tASSERT(txn, (txn->mt_flags & MDBX_WRITEMAP) == 0 || MDBX_AVOID_MSYNC);
@@ -9383,7 +9393,6 @@ __hot static int __must_check_result page_dirty(MDBX_txn *txn, MDBX_page *mp,
 #endif /* xMDBX_DEBUG_SPILLING == 2 */
 
   int rc;
-  mp->mp_txnid = txn->mt_front;
   if (unlikely(txn->tw.dirtyroom == 0)) {
     if (txn->tw.loose_count) {
       MDBX_page *loose = txn->tw.loose_pages;
@@ -10093,6 +10102,8 @@ MDBX_MAYBE_UNUSED static __always_inline size_t __builtin_clzl(size_t value) {
 }
 #endif /* _MSC_VER */
 
+#if !MDBX_PNL_ASCENDING
+
 #if !defined(MDBX_ATTRIBUTE_TARGET) &&                                         \
     (__has_attribute(__target__) || __GNUC_PREREQ(5, 0))
 #define MDBX_ATTRIBUTE_TARGET(target) __attribute__((__target__(target)))
@@ -10406,6 +10417,8 @@ __hot static pgno_t *scan4seq_neon(pgno_t *range, const size_t len,
 /* Choosing of another variants should be added here. */
 #endif /* scan4seq_default */
 
+#endif /* MDBX_PNL_ASCENDING */
+
 #ifndef scan4seq_default
 #define scan4seq_default scan4seq_fallback
 #endif /* scan4seq_default */
@@ -10469,45 +10482,39 @@ static pgno_t *scan4seq_resolver(pgno_t *range, const size_t len,
  *
  * Returns 0 on success, non-zero on failure.*/
 
-#define MDBX_ALLOC_GC 1
-#define MDBX_ALLOC_NEW 2
-#define MDBX_ALLOC_COALESCE 4
-#define MDBX_ALLOC_SLOT 8
-#define MDBX_ALLOC_RESERVE 16
-#define MDBX_ALLOC_BACKLOG 32
-#define MDBX_ALLOC_ALL (MDBX_ALLOC_GC | MDBX_ALLOC_NEW)
-#define MDBX_ALLOC_LIFO 128
+#define MDBX_ALLOC_DEFAULT 0
+#define MDBX_ALLOC_RESERVE 1
+#define MDBX_ALLOC_UNIMPORTANT 2
+#define MDBX_ALLOC_COALESCE 4    /* внутреннее состояние */
+#define MDBX_ALLOC_SHOULD_SCAN 8 /* внутреннее состояние */
+#define MDBX_ALLOC_LIFO 16       /* внутреннее состояние */
 
-static __inline bool is_gc_usable(const MDBX_txn *txn) {
+static __inline bool is_gc_usable(MDBX_txn *txn, const MDBX_cursor *mc,
+                                  const uint8_t flags) {
   /* If txn is updating the GC, then the retired-list cannot play catch-up with
    * itself by growing while trying to save it. */
-  if (txn->mt_flags & (MDBX_TXN_UPDATE_GC | MDBX_TXN_FROZEN_RE))
+  if (mc->mc_dbi == FREE_DBI && !(flags & MDBX_ALLOC_RESERVE) &&
+      !(mc->mc_flags & C_GCU))
     return false;
 
   /* avoid (recursive) search inside empty tree and while tree is
-     updating, https://web.archive.org/web/https://github.com/erthink/libmdbx/issues/31 */
+     updating, https://libmdbx.dqdkfa.ru/dead-github/issues/31 */
   if (txn->mt_dbs[FREE_DBI].md_entries == 0)
     return false;
 
-  /* If our dirty list is already full, we can't touch GC */
-  if (unlikely(txn->tw.dirtyroom < txn->mt_dbs[FREE_DBI].md_depth) &&
-      !(txn->mt_dbistate[FREE_DBI] & DBI_DIRTY))
-    return false;
-
   return true;
 }
 
-static int gc_cursor_init(MDBX_cursor *mc, MDBX_txn *txn) {
-  if (unlikely(txn->mt_dbs[FREE_DBI].md_flags != MDBX_INTEGERKEY)) {
-    ERROR("unexpected/invalid db-flags 0x%u for GC/FreeDB",
-          txn->mt_dbs[FREE_DBI].md_flags);
-    return MDBX_CORRUPTED;
-  }
-  return cursor_init(mc, txn, FREE_DBI);
+__hot static bool is_already_reclaimed(const MDBX_txn *txn, txnid_t id) {
+  const size_t len = MDBX_PNL_GETSIZE(txn->tw.lifo_reclaimed);
+  for (size_t i = 1; i <= len; ++i)
+    if (txn->tw.lifo_reclaimed[i] == id)
+      return true;
+  return false;
 }
 
 static pgr_t page_alloc_slowpath(const MDBX_cursor *mc, const size_t num,
-                                 char flags) {
+                                 uint8_t flags) {
 #if MDBX_ENABLE_PROFGC
   const uint64_t monotime_before = osal_monotime();
   size_t majflt_before;
@@ -10525,21 +10532,13 @@ static pgr_t page_alloc_slowpath(const MDBX_cursor *mc, const size_t num,
   prof->spe_counter += 1;
 #endif /* MDBX_ENABLE_PROFGC */
 
-  eASSERT(env, num == 0 || !(flags & MDBX_ALLOC_SLOT));
-  eASSERT(env, num > 0 || !(flags & MDBX_ALLOC_NEW));
-  eASSERT(env, (flags & (MDBX_ALLOC_SLOT | MDBX_ALLOC_RESERVE |
-                         MDBX_ALLOC_BACKLOG)) == 0 ||
-                   (flags & MDBX_ALLOC_GC));
-  eASSERT(env, (flags & (MDBX_ALLOC_SLOT | MDBX_ALLOC_RESERVE |
-                         MDBX_ALLOC_BACKLOG)) == 0 ||
-                   (flags & MDBX_ALLOC_NEW) == 0);
+  eASSERT(env, num > 0 || (flags & MDBX_ALLOC_RESERVE));
   eASSERT(env, pnl_check_allocated(txn->tw.relist,
                                    txn->mt_next_pgno - MDBX_ENABLE_REFUND));
 
   pgno_t pgno = 0, *range = nullptr;
-  size_t re_len = MDBX_PNL_GETSIZE(txn->tw.relist);
+  size_t newnext, re_len = MDBX_PNL_GETSIZE(txn->tw.relist);
   if (num > 1) {
-    eASSERT(env, !(flags & MDBX_ALLOC_SLOT));
 #if MDBX_ENABLE_PROFGC
     prof->xpages += 1;
 #endif /* MDBX_ENABLE_PROFGC */
@@ -10555,347 +10554,363 @@ static pgr_t page_alloc_slowpath(const MDBX_cursor *mc, const size_t num,
       }
     }
   } else {
-    eASSERT(env, (flags & (MDBX_ALLOC_SLOT | MDBX_ALLOC_RESERVE)) ||
-                     MDBX_PNL_GETSIZE(txn->tw.relist) == 0);
+    eASSERT(env, num == 0 || re_len == 0);
   }
 
   //---------------------------------------------------------------------------
 
-  if (likely(flags & MDBX_ALLOC_GC)) {
-    if (unlikely(!is_gc_usable(txn)))
-      goto no_gc;
+  if (unlikely(!is_gc_usable(txn, mc, flags)))
+    goto no_gc;
 
-    eASSERT(env, (flags & (MDBX_ALLOC_COALESCE | MDBX_ALLOC_LIFO)) == 0);
-    flags += (env->me_flags & MDBX_LIFORECLAIM) ? MDBX_ALLOC_LIFO : 0;
+  eASSERT(env, (flags & (MDBX_ALLOC_COALESCE | MDBX_ALLOC_LIFO |
+                         MDBX_ALLOC_SHOULD_SCAN)) == 0);
+  flags += (env->me_flags & MDBX_LIFORECLAIM) ? MDBX_ALLOC_LIFO : 0;
 
-    const unsigned coalesce_threshold = env->me_maxgc_ov1page >> 2;
+  if (/* Не коагулируем записи при подготовке резерва для обновления GC.
+       * Иначе попытка увеличить резерв может приводить к необходимости ещё
+       * большего резерва из-за увеличения списка переработанных страниц. */
+      (flags & MDBX_ALLOC_RESERVE) == 0) {
     if (txn->mt_dbs[FREE_DBI].md_branch_pages &&
-        MDBX_PNL_GETSIZE(txn->tw.relist) < coalesce_threshold && num)
+        re_len < env->me_maxgc_ov1page / 2)
       flags += MDBX_ALLOC_COALESCE;
+  }
 
-    MDBX_cursor recur;
-    ret.err = gc_cursor_init(&recur, txn);
-    if (unlikely(ret.err != MDBX_SUCCESS))
-      goto fail;
+  MDBX_cursor *const gc =
+      (MDBX_cursor *)((char *)env->me_txn0 + sizeof(MDBX_txn));
+  gc->mc_txn = txn;
+  gc->mc_flags = 0;
 
-  retry_gc_refresh_oldest:;
-    txnid_t oldest = txn_oldest_reader(txn);
-    if (unlikely(!oldest))
-      goto no_gc;
-
-  retry_gc_have_oldest:
-    if (unlikely(oldest >= txn->mt_txnid)) {
-      ERROR("unexpected/invalid oldest-readed txnid %" PRIaTXN
-            " for current-txnid %" PRIaTXN,
-            oldest, txn->mt_txnid);
-      ret.err = MDBX_PROBLEM;
-      goto fail;
-    }
-    const txnid_t detent = oldest + 1;
+retry_gc_refresh_oldest:;
+  txnid_t oldest = txn_oldest_reader(txn);
+retry_gc_have_oldest:
+  if (unlikely(oldest >= txn->mt_txnid)) {
+    ERROR("unexpected/invalid oldest-readed txnid %" PRIaTXN
+          " for current-txnid %" PRIaTXN,
+          oldest, txn->mt_txnid);
+    ret.err = MDBX_PROBLEM;
+    goto fail;
+  }
+  const txnid_t detent = oldest + 1;
 
-    txnid_t last = 0;
-    bool should_scan = false;
-    MDBX_cursor_op op = MDBX_FIRST;
-    if (flags & MDBX_ALLOC_LIFO) {
-      if (!txn->tw.lifo_reclaimed) {
-        txn->tw.lifo_reclaimed = txl_alloc();
-        if (unlikely(!txn->tw.lifo_reclaimed)) {
-          ret.err = MDBX_ENOMEM;
-          goto fail;
-        }
+  txnid_t id = 0;
+  MDBX_cursor_op op = MDBX_FIRST;
+  if (flags & MDBX_ALLOC_LIFO) {
+    if (!txn->tw.lifo_reclaimed) {
+      txn->tw.lifo_reclaimed = txl_alloc();
+      if (unlikely(!txn->tw.lifo_reclaimed)) {
+        ret.err = MDBX_ENOMEM;
+        goto fail;
       }
-      /* Begin lookup backward from oldest reader */
-      last = detent - 1;
-      op = MDBX_SET_RANGE;
-    } else if (txn->tw.last_reclaimed) {
-      /* Continue lookup forward from last-reclaimed */
-      last = txn->tw.last_reclaimed + 1;
-      if (last >= detent)
-        goto no_gc;
-      op = MDBX_SET_RANGE;
     }
+    /* Begin lookup backward from oldest reader */
+    id = detent - 1;
+    op = MDBX_SET_RANGE;
+  } else if (txn->tw.last_reclaimed) {
+    /* Continue lookup forward from last-reclaimed */
+    id = txn->tw.last_reclaimed + 1;
+    if (id >= detent)
+      goto depleted_gc;
+    op = MDBX_SET_RANGE;
+  }
 
-  next_gc:;
-    MDBX_val key;
-    key.iov_base = &last;
-    key.iov_len = sizeof(last);
+next_gc:;
+  MDBX_val key;
+  key.iov_base = &id;
+  key.iov_len = sizeof(id);
 
 #if MDBX_ENABLE_PROFGC
-    prof->rsteps += 1;
+  prof->rsteps += 1;
 #endif /* MDBX_ENABLE_PROFGC */
 
-    /* Seek first/next GC record */
-    ret.err = mdbx_cursor_get(&recur, &key, NULL, op);
-    if (unlikely(ret.err != MDBX_SUCCESS)) {
-      if (unlikely(ret.err != MDBX_NOTFOUND))
-        goto fail;
-      if ((flags & MDBX_ALLOC_LIFO) && op == MDBX_SET_RANGE) {
-        op = MDBX_PREV;
-        goto next_gc;
-      }
-      goto depleted_gc;
-    }
-    if (unlikely(key.iov_len != sizeof(txnid_t))) {
-      ret.err = MDBX_CORRUPTED;
+  /* Seek first/next GC record */
+  ret.err = mdbx_cursor_get(gc, &key, NULL, op);
+  if (unlikely(ret.err != MDBX_SUCCESS)) {
+    if (unlikely(ret.err != MDBX_NOTFOUND))
       goto fail;
-    }
-    last = unaligned_peek_u64(4, key.iov_base);
-    if (flags & MDBX_ALLOC_LIFO) {
+    if ((flags & MDBX_ALLOC_LIFO) && op == MDBX_SET_RANGE) {
       op = MDBX_PREV;
-      if (last >= detent)
-        goto next_gc;
-      /* skip IDs of records that already reclaimed */
-      for (size_t i = MDBX_PNL_GETSIZE(txn->tw.lifo_reclaimed); i > 0; --i)
-        if (txn->tw.lifo_reclaimed[i] == last)
-          goto next_gc;
-    } else {
-      op = MDBX_NEXT;
-      if (unlikely(last >= detent))
-        goto depleted_gc;
+      goto next_gc;
     }
+    goto depleted_gc;
+  }
+  if (unlikely(key.iov_len != sizeof(txnid_t))) {
+    ret.err = MDBX_CORRUPTED;
+    goto fail;
+  }
+  id = unaligned_peek_u64(4, key.iov_base);
+  if (flags & MDBX_ALLOC_LIFO) {
+    op = MDBX_PREV;
+    if (id >= detent || is_already_reclaimed(txn, id))
+      goto next_gc;
+  } else {
+    op = MDBX_NEXT;
+    if (unlikely(id >= detent))
+      goto depleted_gc;
+  }
 
-    /* Reading next GC record */
-    MDBX_val data;
-    MDBX_page *const mp = recur.mc_pg[recur.mc_top];
-    if (unlikely((ret.err = node_read(&recur,
-                                      page_node(mp, recur.mc_ki[recur.mc_top]),
-                                      &data, mp)) != MDBX_SUCCESS))
-      goto fail;
+  /* Reading next GC record */
+  MDBX_val data;
+  MDBX_page *const mp = gc->mc_pg[gc->mc_top];
+  if (unlikely((ret.err = node_read(gc, page_node(mp, gc->mc_ki[gc->mc_top]),
+                                    &data, mp)) != MDBX_SUCCESS))
+    goto fail;
 
-    eASSERT(env, (txn->mt_flags & MDBX_TXN_FROZEN_RE) == 0);
-    pgno_t *gc_pnl = (pgno_t *)data.iov_base;
-    if (unlikely(data.iov_len % sizeof(pgno_t) ||
-                 data.iov_len < MDBX_PNL_SIZEOF(gc_pnl) ||
-                 !pnl_check(gc_pnl, txn->mt_next_pgno))) {
-      ret.err = MDBX_CORRUPTED;
-      goto fail;
+  pgno_t *gc_pnl = (pgno_t *)data.iov_base;
+  if (unlikely(data.iov_len % sizeof(pgno_t) ||
+               data.iov_len < MDBX_PNL_SIZEOF(gc_pnl) ||
+               !pnl_check(gc_pnl, txn->mt_next_pgno))) {
+    ret.err = MDBX_CORRUPTED;
+    goto fail;
+  }
+
+  const size_t gc_len = MDBX_PNL_GETSIZE(gc_pnl);
+  TRACE("gc-read: id #%" PRIaTXN " len %zu, re-list will %zu ", id, gc_len,
+        gc_len + re_len);
+
+  eASSERT(env, re_len == MDBX_PNL_GETSIZE(txn->tw.relist));
+  if (unlikely(gc_len + re_len >= env->me_maxgc_ov1page)) {
+    /* Don't try to coalesce too much. */
+    if (flags & MDBX_ALLOC_SHOULD_SCAN) {
+      eASSERT(env, flags & MDBX_ALLOC_COALESCE);
+      eASSERT(env, num > 0);
+#if MDBX_ENABLE_PROFGC
+      env->me_lck->mti_pgop_stat.gc_prof.coalescences += 1;
+#endif /* MDBX_ENABLE_PROFGC */
+      TRACE("clear %s %s", "MDBX_ALLOC_COALESCE", "since got threshold");
+      if (re_len >= num) {
+        eASSERT(env, MDBX_PNL_LAST(txn->tw.relist) < txn->mt_next_pgno &&
+                         MDBX_PNL_FIRST(txn->tw.relist) < txn->mt_next_pgno);
+        range = txn->tw.relist + (MDBX_PNL_ASCENDING ? 1 : re_len);
+        pgno = *range;
+        if (num == 1)
+          goto done;
+        range = scan4seq(range, re_len, num - 1);
+        eASSERT(env, range == scan4range_checker(txn->tw.relist, num - 1));
+        if (likely(range)) {
+          pgno = *range;
+          goto done;
+        }
+      }
+      flags -= MDBX_ALLOC_COALESCE | MDBX_ALLOC_SHOULD_SCAN;
     }
-    const size_t gc_len = MDBX_PNL_GETSIZE(gc_pnl);
-    if (unlikely(/* list is too long already */ MDBX_PNL_GETSIZE(
-                     txn->tw.relist) >= env->me_options.rp_augment_limit) &&
-        ((/* not a slot-request from gc-update */
-          (flags & MDBX_ALLOC_SLOT) == 0 &&
+    if (unlikely(/* list is too long already */ re_len >=
+                 env->me_options.rp_augment_limit) &&
+        ((/* not a slot-request from gc-update */ num &&
           /* have enough unallocated space */ txn->mt_geo.upper >=
               txn->mt_next_pgno + num) ||
-         gc_len + MDBX_PNL_GETSIZE(txn->tw.relist) >= MDBX_PGL_LIMIT)) {
+         gc_len + re_len >= MDBX_PGL_LIMIT)) {
       /* Stop reclaiming to avoid large/overflow the page list.
        * This is a rare case while search for a continuously multi-page region
        * in a large database.
-       * https://web.archive.org/web/https://github.com/erthink/libmdbx/issues/123 */
+       * https://libmdbx.dqdkfa.ru/dead-github/issues/123
+       */
       NOTICE("stop reclaiming to avoid PNL overflow: %zu (current) + %zu "
              "(chunk) -> %zu",
-             MDBX_PNL_GETSIZE(txn->tw.relist), gc_len,
-             gc_len + MDBX_PNL_GETSIZE(txn->tw.relist));
+             re_len, gc_len, gc_len + re_len);
       goto depleted_gc;
     }
+  }
 
-    /* Remember ID of readed GC record */
-    txn->tw.last_reclaimed = last;
-    if (flags & MDBX_ALLOC_LIFO) {
-      ret.err = txl_append(&txn->tw.lifo_reclaimed, last);
-      if (unlikely(ret.err != MDBX_SUCCESS))
-        goto fail;
-    }
-
-    /* Append PNL from GC record to tw.relist */
-    ret.err = pnl_need(&txn->tw.relist, gc_len);
+  /* Remember ID of readed GC record */
+  txn->tw.last_reclaimed = id;
+  if (flags & MDBX_ALLOC_LIFO) {
+    ret.err = txl_append(&txn->tw.lifo_reclaimed, id);
     if (unlikely(ret.err != MDBX_SUCCESS))
       goto fail;
-    txn->tw.relist = txn->tw.relist;
+  }
 
-    if (LOG_ENABLED(MDBX_LOG_EXTRA)) {
-      DEBUG_EXTRA("readed GC-pnl txn %" PRIaTXN " root %" PRIaPGNO
-                  " len %zu, PNL",
-                  last, txn->mt_dbs[FREE_DBI].md_root, gc_len);
-      for (size_t i = gc_len; i; i--)
-        DEBUG_EXTRA_PRINT(" %" PRIaPGNO, gc_pnl[i]);
-      DEBUG_EXTRA_PRINT(", next_pgno %u\n", txn->mt_next_pgno);
-    }
+  /* Append PNL from GC record to tw.relist */
+  ret.err = pnl_need(&txn->tw.relist, gc_len);
+  if (unlikely(ret.err != MDBX_SUCCESS))
+    goto fail;
 
-    /* Merge in descending sorted order */
-    re_len = pnl_merge(txn->tw.relist, gc_pnl);
-    should_scan = true;
-    if (AUDIT_ENABLED()) {
-      if (unlikely(!pnl_check(txn->tw.relist, txn->mt_next_pgno))) {
-        ret.err = MDBX_CORRUPTED;
-        goto fail;
-      }
-    } else {
-      eASSERT(env, pnl_check_allocated(txn->tw.relist, txn->mt_next_pgno));
+  if (LOG_ENABLED(MDBX_LOG_EXTRA)) {
+    DEBUG_EXTRA("readed GC-pnl txn %" PRIaTXN " root %" PRIaPGNO
+                " len %zu, PNL",
+                id, txn->mt_dbs[FREE_DBI].md_root, gc_len);
+    for (size_t i = gc_len; i; i--)
+      DEBUG_EXTRA_PRINT(" %" PRIaPGNO, gc_pnl[i]);
+    DEBUG_EXTRA_PRINT(", next_pgno %u\n", txn->mt_next_pgno);
+  }
+
+  /* Merge in descending sorted order */
+  re_len = pnl_merge(txn->tw.relist, gc_pnl);
+  flags |= MDBX_ALLOC_SHOULD_SCAN;
+  if (AUDIT_ENABLED()) {
+    if (unlikely(!pnl_check(txn->tw.relist, txn->mt_next_pgno))) {
+      ret.err = MDBX_CORRUPTED;
+      goto fail;
     }
-    eASSERT(env, dirtylist_check(txn));
+  } else {
+    eASSERT(env, pnl_check_allocated(txn->tw.relist, txn->mt_next_pgno));
+  }
+  eASSERT(env, dirtylist_check(txn));
 
-    eASSERT(env,
-            re_len == 0 || MDBX_PNL_MOST(txn->tw.relist) < txn->mt_next_pgno);
-    if (MDBX_ENABLE_REFUND && re_len &&
-        unlikely(MDBX_PNL_MOST(txn->tw.relist) == txn->mt_next_pgno - 1)) {
-      /* Refund suitable pages into "unallocated" space */
-      if (txn_refund(txn))
-        re_len = MDBX_PNL_GETSIZE(txn->tw.relist);
-    }
-    eASSERT(env, re_len == MDBX_PNL_GETSIZE(txn->tw.relist));
-    eASSERT(env, pnl_check_allocated(txn->tw.relist,
-                                     txn->mt_next_pgno - MDBX_ENABLE_REFUND));
+  eASSERT(env,
+          re_len == 0 || MDBX_PNL_MOST(txn->tw.relist) < txn->mt_next_pgno);
+  if (MDBX_ENABLE_REFUND && re_len &&
+      unlikely(MDBX_PNL_MOST(txn->tw.relist) == txn->mt_next_pgno - 1)) {
+    /* Refund suitable pages into "unallocated" space */
+    txn_refund(txn);
+    re_len = MDBX_PNL_GETSIZE(txn->tw.relist);
+  }
+  eASSERT(env, re_len == MDBX_PNL_GETSIZE(txn->tw.relist));
+  eASSERT(env, pnl_check_allocated(txn->tw.relist,
+                                   txn->mt_next_pgno - MDBX_ENABLE_REFUND));
 
-    /* Done for a kick-reclaim mode, actually no page needed */
-    if (unlikely(flags & MDBX_ALLOC_SLOT)) {
-      eASSERT(env, ret.err == MDBX_SUCCESS);
-      goto early_exit;
-    }
+  /* Done for a kick-reclaim mode, actually no page needed */
+  if (unlikely(num == 0)) {
+    eASSERT(env, ret.err == MDBX_SUCCESS);
+    TRACE("%s: last id #%" PRIaTXN ", re-len %zu", "early-exit for slot", id,
+          re_len);
+    goto early_exit;
+  }
 
-    /* TODO: delete reclaimed records */
+  /* TODO: delete reclaimed records */
 
-    /* Don't try to coalesce too much. */
-    eASSERT(env, op == MDBX_PREV || op == MDBX_NEXT);
-    if (flags & MDBX_ALLOC_COALESCE) {
-      if (re_len /* current size */ < coalesce_threshold) {
-#if MDBX_ENABLE_PROFGC
-        env->me_lck->mti_pgop_stat.gc_prof.coalescences += 1;
-#endif /* MDBX_ENABLE_PROFGC */
-        goto next_gc;
-      }
-      TRACE("clear %s %s", "MDBX_ALLOC_COALESCE", "since got threshold");
-      flags &= ~MDBX_ALLOC_COALESCE;
-    }
+  eASSERT(env, op == MDBX_PREV || op == MDBX_NEXT);
+  if (flags & MDBX_ALLOC_COALESCE) {
+    TRACE("%s: last id #%" PRIaTXN ", re-len %zu", "coalesce-continue", id,
+          re_len);
+    goto next_gc;
+  }
 
-  scan:
-    eASSERT(env, should_scan);
-    if (re_len >= num) {
-      eASSERT(env, MDBX_PNL_LAST(txn->tw.relist) < txn->mt_next_pgno &&
-                       MDBX_PNL_FIRST(txn->tw.relist) < txn->mt_next_pgno);
-      range = txn->tw.relist + (MDBX_PNL_ASCENDING ? 1 : re_len);
+scan:
+  eASSERT(env, flags & MDBX_ALLOC_SHOULD_SCAN);
+  eASSERT(env, num > 0);
+  if (re_len >= num) {
+    eASSERT(env, MDBX_PNL_LAST(txn->tw.relist) < txn->mt_next_pgno &&
+                     MDBX_PNL_FIRST(txn->tw.relist) < txn->mt_next_pgno);
+    range = txn->tw.relist + (MDBX_PNL_ASCENDING ? 1 : re_len);
+    pgno = *range;
+    if (num == 1)
+      goto done;
+    range = scan4seq(range, re_len, num - 1);
+    eASSERT(env, range == scan4range_checker(txn->tw.relist, num - 1));
+    if (likely(range)) {
       pgno = *range;
-      if (num == 1)
-        goto done;
-      range = scan4seq(range, re_len, num - 1);
-      eASSERT(env, range == scan4range_checker(txn->tw.relist, num - 1));
-      if (likely(range)) {
-        pgno = *range;
-        goto done;
-      }
+      goto done;
     }
-    should_scan = false;
-    if (ret.err == MDBX_SUCCESS)
-      goto next_gc;
+  }
+  flags -= MDBX_ALLOC_SHOULD_SCAN;
+  if (ret.err == MDBX_SUCCESS) {
+    TRACE("%s: last id #%" PRIaTXN ", re-len %zu", "continue-search", id,
+          re_len);
+    goto next_gc;
+  }
 
-  depleted_gc:
-    ret.err = MDBX_NOTFOUND;
-    if (should_scan)
-      goto scan;
+depleted_gc:
+  ret.err = MDBX_NOTFOUND;
+  if (flags & MDBX_ALLOC_SHOULD_SCAN)
+    goto scan;
 
-    //-------------------------------------------------------------------------
+  //-------------------------------------------------------------------------
+
+  /* There is no suitable pages in the GC and to be able to allocate
+   * we should CHOICE one of:
+   *  - make a new steady checkpoint if reclaiming was stopped by
+   *    the last steady-sync, or wipe it in the MDBX_UTTERLY_NOSYNC mode;
+   *  - kick lagging reader(s) if reclaiming was stopped by ones of it.
+   *  - extend the database file. */
 
-    /* There is no suitable pages in the GC and to be able to allocate
-     * we should CHOICE one of:
-     *  - make a new steady checkpoint if reclaiming was stopped by
-     *    the last steady-sync, or wipe it in the MDBX_UTTERLY_NOSYNC mode;
-     *  - kick lagging reader(s) if reclaiming was stopped by ones of it.
-     *  - extend the database file. */
-
-    /* Will use new pages from the map if nothing is suitable in the GC. */
-    pgno = txn->mt_next_pgno;
-    const size_t newnext = num + pgno;
-
-    const meta_ptr_t recent = meta_recent(env, &txn->tw.troika);
-    const meta_ptr_t prefer_steady = meta_prefer_steady(env, &txn->tw.troika);
-    /* does reclaiming stopped at the last steady point? */
-    if (recent.ptr_c != prefer_steady.ptr_c && prefer_steady.is_steady &&
-        detent == prefer_steady.txnid + 1) {
-      DEBUG("gc-kick-steady: recent %" PRIaTXN "-%s, steady %" PRIaTXN
-            "-%s, detent %" PRIaTXN,
-            recent.txnid, durable_caption(recent.ptr_c), prefer_steady.txnid,
-            durable_caption(prefer_steady.ptr_c), detent);
-      const pgno_t autosync_threshold =
-          atomic_load32(&env->me_lck->mti_autosync_threshold, mo_Relaxed);
-      const uint64_t autosync_period =
-          atomic_load64(&env->me_lck->mti_autosync_period, mo_Relaxed);
-      uint64_t eoos_timestamp;
-      /* wipe the last steady-point if one of:
-       *  - UTTERLY_NOSYNC mode AND auto-sync threshold is NOT specified
-       *  - UTTERLY_NOSYNC mode AND free space at steady-point is exhausted
-       * otherwise, make a new steady-point if one of:
-       *  - auto-sync threshold is specified and reached;
-       *  - upper limit of database size is reached;
-       *  - database is full (with the current file size)
-       *       AND auto-sync threshold it NOT specified */
-      if (F_ISSET(env->me_flags, MDBX_UTTERLY_NOSYNC) &&
-          ((autosync_threshold | autosync_period) == 0 ||
-           newnext >= prefer_steady.ptr_c->mm_geo.now)) {
-        /* wipe steady checkpoint in MDBX_UTTERLY_NOSYNC mode
-         * without any auto-sync threshold(s). */
+  /* Will use new pages from the map if nothing is suitable in the GC. */
+  newnext = (pgno = txn->mt_next_pgno) + num;
+
+  /* Does reclaiming stopped at the last steady point? */
+  const meta_ptr_t recent = meta_recent(env, &txn->tw.troika);
+  const meta_ptr_t prefer_steady = meta_prefer_steady(env, &txn->tw.troika);
+  if (recent.ptr_c != prefer_steady.ptr_c && prefer_steady.is_steady &&
+      detent == prefer_steady.txnid + 1) {
+    DEBUG("gc-kick-steady: recent %" PRIaTXN "-%s, steady %" PRIaTXN
+          "-%s, detent %" PRIaTXN,
+          recent.txnid, durable_caption(recent.ptr_c), prefer_steady.txnid,
+          durable_caption(prefer_steady.ptr_c), detent);
+    const pgno_t autosync_threshold =
+        atomic_load32(&env->me_lck->mti_autosync_threshold, mo_Relaxed);
+    const uint64_t autosync_period =
+        atomic_load64(&env->me_lck->mti_autosync_period, mo_Relaxed);
+    uint64_t eoos_timestamp;
+    /* wipe the last steady-point if one of:
+     *  - UTTERLY_NOSYNC mode AND auto-sync threshold is NOT specified
+     *  - UTTERLY_NOSYNC mode AND free space at steady-point is exhausted
+     * otherwise, make a new steady-point if one of:
+     *  - auto-sync threshold is specified and reached;
+     *  - upper limit of database size is reached;
+     *  - database is full (with the current file size)
+     *       AND auto-sync threshold it NOT specified */
+    if (F_ISSET(env->me_flags, MDBX_UTTERLY_NOSYNC) &&
+        ((autosync_threshold | autosync_period) == 0 ||
+         newnext >= prefer_steady.ptr_c->mm_geo.now)) {
+      /* wipe steady checkpoint in MDBX_UTTERLY_NOSYNC mode
+       * without any auto-sync threshold(s). */
 #if MDBX_ENABLE_PROFGC
-        env->me_lck->mti_pgop_stat.gc_prof.wipes += 1;
+      env->me_lck->mti_pgop_stat.gc_prof.wipes += 1;
 #endif /* MDBX_ENABLE_PROFGC */
-        ret.err = wipe_steady(txn, detent);
-        DEBUG("gc-wipe-steady, rc %d", ret.err);
-        if (unlikely(ret.err != MDBX_SUCCESS))
-          goto fail;
-        eASSERT(env, prefer_steady.ptr_c !=
-                         meta_prefer_steady(env, &txn->tw.troika).ptr_c);
-        goto retry_gc_refresh_oldest;
-      }
-      if ((flags & (MDBX_ALLOC_BACKLOG | MDBX_ALLOC_NEW)) == 0 ||
-          (autosync_threshold &&
-           atomic_load64(&env->me_lck->mti_unsynced_pages, mo_Relaxed) >=
-               autosync_threshold) ||
-          (autosync_period &&
-           (eoos_timestamp =
-                atomic_load64(&env->me_lck->mti_eoos_timestamp, mo_Relaxed)) &&
-           osal_monotime() - eoos_timestamp >= autosync_period) ||
-          newnext >= txn->mt_geo.upper ||
-          (newnext >= txn->mt_end_pgno &&
-           (autosync_threshold | autosync_period) == 0)) {
-        /* make steady checkpoint. */
+      ret.err = wipe_steady(txn, detent);
+      DEBUG("gc-wipe-steady, rc %d", ret.err);
+      if (unlikely(ret.err != MDBX_SUCCESS))
+        goto fail;
+      eASSERT(env, prefer_steady.ptr_c !=
+                       meta_prefer_steady(env, &txn->tw.troika).ptr_c);
+      goto retry_gc_refresh_oldest;
+    }
+    if ((autosync_threshold &&
+         atomic_load64(&env->me_lck->mti_unsynced_pages, mo_Relaxed) >=
+             autosync_threshold) ||
+        (autosync_period &&
+         (eoos_timestamp =
+              atomic_load64(&env->me_lck->mti_eoos_timestamp, mo_Relaxed)) &&
+         osal_monotime() - eoos_timestamp >= autosync_period) ||
+        newnext >= txn->mt_geo.upper ||
+        ((num == 0 || newnext >= txn->mt_end_pgno) &&
+         (autosync_threshold | autosync_period) == 0)) {
+      /* make steady checkpoint. */
 #if MDBX_ENABLE_PROFGC
-        env->me_lck->mti_pgop_stat.gc_prof.flushes += 1;
+      env->me_lck->mti_pgop_stat.gc_prof.flushes += 1;
 #endif /* MDBX_ENABLE_PROFGC */
-        MDBX_meta meta = *recent.ptr_c;
-        ret.err = sync_locked(env, env->me_flags & MDBX_WRITEMAP, &meta,
-                              &txn->tw.troika);
-        DEBUG("gc-make-steady, rc %d", ret.err);
-        eASSERT(env, ret.err != MDBX_RESULT_TRUE);
-        if (unlikely(ret.err != MDBX_SUCCESS))
-          goto fail;
-        eASSERT(env, prefer_steady.ptr_c !=
-                         meta_prefer_steady(env, &txn->tw.troika).ptr_c);
-        goto retry_gc_refresh_oldest;
-      }
+      MDBX_meta meta = *recent.ptr_c;
+      ret.err = sync_locked(env, env->me_flags & MDBX_WRITEMAP, &meta,
+                            &txn->tw.troika);
+      DEBUG("gc-make-steady, rc %d", ret.err);
+      eASSERT(env, ret.err != MDBX_RESULT_TRUE);
+      if (unlikely(ret.err != MDBX_SUCCESS))
+        goto fail;
+      eASSERT(env, prefer_steady.ptr_c !=
+                       meta_prefer_steady(env, &txn->tw.troika).ptr_c);
+      goto retry_gc_refresh_oldest;
     }
+  }
 
-    if (env->me_lck_mmap.lck &&
-        unlikely(true ==
-                 atomic_load32(&env->me_lck_mmap.lck->mti_readers_refresh_flag,
-                               mo_AcquireRelease))) {
-      oldest = txn_oldest_reader(txn);
-      if (oldest >= detent)
-        goto retry_gc_have_oldest;
-    }
+  if (unlikely(true == atomic_load32(&env->me_lck->mti_readers_refresh_flag,
+                                     mo_AcquireRelease))) {
+    oldest = txn_oldest_reader(txn);
+    if (oldest >= detent)
+      goto retry_gc_have_oldest;
+  }
 
-    /* avoid kick lagging reader(s) if is enough unallocated space
-     * at the end of database file. */
-    if ((flags & MDBX_ALLOC_NEW) && newnext <= txn->mt_end_pgno) {
-      eASSERT(env, range == nullptr);
-      goto done;
-    }
+  /* Avoid kick lagging reader(s) if is enough unallocated space
+   * at the end of database file. */
+  if (!(flags & MDBX_ALLOC_RESERVE) && newnext <= txn->mt_end_pgno) {
+    eASSERT(env, range == nullptr);
+    goto done;
+  }
 
-    if (oldest < txn->mt_txnid - xMDBX_TXNID_STEP) {
-      oldest = kick_longlived_readers(env, oldest);
-      if (oldest >= detent)
-        goto retry_gc_have_oldest;
-    }
+  if (oldest < txn->mt_txnid - xMDBX_TXNID_STEP) {
+    oldest = kick_longlived_readers(env, oldest);
+    if (oldest >= detent)
+      goto retry_gc_have_oldest;
   }
 
   //---------------------------------------------------------------------------
 
 no_gc:
-  if ((flags & MDBX_ALLOC_NEW) == 0) {
+  if (flags & MDBX_ALLOC_RESERVE) {
     ret.err = MDBX_NOTFOUND;
     goto fail;
   }
 
   /* Will use new pages from the map if nothing is suitable in the GC. */
-  pgno = txn->mt_next_pgno;
-  const size_t newnext = num + pgno;
+  newnext = (pgno = txn->mt_next_pgno) + num;
   if (newnext <= txn->mt_end_pgno)
     goto done;
 
@@ -10932,12 +10947,12 @@ no_gc:
 
 done:
   ret.err = MDBX_SUCCESS;
-  if (likely((flags & (MDBX_ALLOC_SLOT | MDBX_ALLOC_RESERVE)) == 0)) {
+  if (likely((flags & MDBX_ALLOC_RESERVE) == 0)) {
     ENSURE(env, pgno >= NUM_METAS);
     if (range) {
-      eASSERT(env, (txn->mt_flags & MDBX_TXN_FROZEN_RE) == 0);
       eASSERT(env, pgno == *range);
       eASSERT(env, pgno + num <= txn->mt_next_pgno && pgno >= NUM_METAS);
+      eASSERT(env, re_len == MDBX_PNL_GETSIZE(txn->tw.relist));
       /* Cutoff allocated pages from tw.relist */
 #if MDBX_PNL_ASCENDING
       for (const pgno_t *const end = re_list + re_len - num; range <= end;
@@ -10951,7 +10966,6 @@ done:
       eASSERT(env, pnl_check_allocated(txn->tw.relist,
                                        txn->mt_next_pgno - MDBX_ENABLE_REFUND));
     } else {
-      eASSERT(env, flags & MDBX_ALLOC_NEW);
       pgno = txn->mt_next_pgno;
       txn->mt_next_pgno += (pgno_t)num;
       eASSERT(env, txn->mt_next_pgno <= txn->mt_end_pgno);
@@ -10995,8 +11009,9 @@ done:
       int level;
       const char *what;
       if (flags & MDBX_ALLOC_RESERVE) {
-        level = (flags & MDBX_ALLOC_BACKLOG) ? MDBX_LOG_DEBUG : MDBX_LOG_NOTICE;
-        what = (flags & MDBX_ALLOC_SLOT) ? "gc-slot/backlog" : "backlog-pages";
+        level =
+            (flags & MDBX_ALLOC_UNIMPORTANT) ? MDBX_LOG_DEBUG : MDBX_LOG_NOTICE;
+        what = num ? "reserve-pages" : "fetch-slot";
       } else {
         txn->mt_flags |= MDBX_TXN_ERROR;
         level = MDBX_LOG_ERROR;
@@ -11011,7 +11026,7 @@ done:
   } else {
   early_exit:
     DEBUG("return NULL for %zu pages for ALLOC_%s, rc %d", num,
-          (flags & MDBX_ALLOC_SLOT) ? "SLOT" : "RESERVE", ret.err);
+          num ? "RESERVE" : "SLOT", ret.err);
     ret.page = NULL;
   }
 
@@ -11057,84 +11072,103 @@ __hot static pgr_t page_alloc(const MDBX_cursor *mc) {
     return ret;
   }
 
-  if (likely(!(txn->mt_flags & MDBX_TXN_FROZEN_RE))) {
-    MDBX_PNL pnl = txn->tw.relist;
-    const size_t len = MDBX_PNL_GETSIZE(pnl);
-    if (likely(len > 0)) {
-      MDBX_env *const env = txn->mt_env;
+  MDBX_PNL pnl = txn->tw.relist;
+  const size_t len = MDBX_PNL_GETSIZE(pnl);
+  if (likely(len > 0)) {
+    MDBX_env *const env = txn->mt_env;
 
-      MDBX_PNL_SETSIZE(pnl, len - 1);
+    MDBX_PNL_SETSIZE(pnl, len - 1);
 #if MDBX_PNL_ASCENDING
-      const pgno_t pgno = pnl[1];
-      for (size_t i = 1; i < len; ++i)
-        pnl[i] = pnl[i + 1];
+    const pgno_t pgno = pnl[1];
+    for (size_t i = 1; i < len; ++i)
+      pnl[i] = pnl[i + 1];
 #else
-      const pgno_t pgno = pnl[len];
+    const pgno_t pgno = pnl[len];
 #endif
 
 #if MDBX_ENABLE_PROFGC
-      const uint64_t monotime_before = osal_monotime();
-      size_t majflt_before;
-      const uint64_t cputime_before = osal_cputime(&majflt_before);
-      profgc_stat_t *const prof =
-          (mc->mc_dbi == FREE_DBI) ? &env->me_lck->mti_pgop_stat.gc_prof.self
-                                   : &env->me_lck->mti_pgop_stat.gc_prof.work;
+    const uint64_t monotime_before = osal_monotime();
+    size_t majflt_before;
+    const uint64_t cputime_before = osal_cputime(&majflt_before);
+    profgc_stat_t *const prof = (mc->mc_dbi == FREE_DBI)
+                                    ? &env->me_lck->mti_pgop_stat.gc_prof.self
+                                    : &env->me_lck->mti_pgop_stat.gc_prof.work;
 #endif /* MDBX_ENABLE_PROFGC */
-      pgr_t ret;
-      if (env->me_flags & MDBX_WRITEMAP) {
-        ret.page = pgno2page(env, pgno);
-        MDBX_ASAN_UNPOISON_MEMORY_REGION(ret.page, env->me_psize);
-      } else {
-        ret.page = page_malloc(txn, 1);
-        if (unlikely(!ret.page)) {
-          ret.err = MDBX_ENOMEM;
-          goto bailout;
-        }
+    pgr_t ret;
+    if (env->me_flags & MDBX_WRITEMAP) {
+      ret.page = pgno2page(env, pgno);
+      MDBX_ASAN_UNPOISON_MEMORY_REGION(ret.page, env->me_psize);
+    } else {
+      ret.page = page_malloc(txn, 1);
+      if (unlikely(!ret.page)) {
+        ret.err = MDBX_ENOMEM;
+        goto bailout;
       }
+    }
 
-      VALGRIND_MAKE_MEM_UNDEFINED(ret.page, env->me_psize);
-      ret.page->mp_pgno = pgno;
-      ret.page->mp_leaf2_ksize = 0;
-      ret.page->mp_flags = 0;
-      tASSERT(txn, ret.page->mp_pgno >= NUM_METAS);
+    VALGRIND_MAKE_MEM_UNDEFINED(ret.page, env->me_psize);
+    ret.page->mp_pgno = pgno;
+    ret.page->mp_leaf2_ksize = 0;
+    ret.page->mp_flags = 0;
+    tASSERT(txn, ret.page->mp_pgno >= NUM_METAS);
 
-      ret.err = page_dirty(txn, ret.page, 1);
-    bailout:
-      tASSERT(txn, pnl_check_allocated(txn->tw.relist,
-                                       txn->mt_next_pgno - MDBX_ENABLE_REFUND));
+    ret.err = page_dirty(txn, ret.page, 1);
+  bailout:
+    tASSERT(txn, pnl_check_allocated(txn->tw.relist,
+                                     txn->mt_next_pgno - MDBX_ENABLE_REFUND));
 #if MDBX_ENABLE_PROFGC
-      size_t majflt_after;
-      prof->rtime_cpu += osal_cputime(&majflt_after) - cputime_before;
-      prof->majflt += majflt_after - majflt_before;
-      prof->xtime_monotonic += osal_monotime() - monotime_before;
+    size_t majflt_after;
+    prof->rtime_cpu += osal_cputime(&majflt_after) - cputime_before;
+    prof->majflt += majflt_after - majflt_before;
+    prof->xtime_monotonic += osal_monotime() - monotime_before;
 #endif /* MDBX_ENABLE_PROFGC */
-      return ret;
-    }
+    return ret;
   }
 
-  return page_alloc_slowpath(mc, 1, MDBX_ALLOC_ALL);
+  return page_alloc_slowpath(mc, 1, MDBX_ALLOC_DEFAULT);
 }
 
-/* Copy the used portions of a non-large/overflow page. */
-__hot static void page_copy(MDBX_page *dst, const MDBX_page *src,
-                            size_t psize) {
+/* Copy the used portions of a page. */
+__hot static void page_copy(MDBX_page *const dst, const MDBX_page *const src,
+                            const size_t size) {
   STATIC_ASSERT(UINT16_MAX > MAX_PAGESIZE - PAGEHDRSZ);
   STATIC_ASSERT(MIN_PAGESIZE > PAGEHDRSZ + NODESIZE * 4);
+  char *copy_dst = (void *)dst;
+  const char *copy_src = (const void *)src;
+  size_t copy_len = size;
+  if (src->mp_flags & P_LEAF2) {
+    copy_len = PAGEHDRSZ + src->mp_leaf2_ksize * page_numkeys(src);
+    if (unlikely(copy_len > size))
+      goto bailout;
+  }
   if ((src->mp_flags & (P_LEAF2 | P_OVERFLOW)) == 0) {
-    size_t upper = src->mp_upper, lower = src->mp_lower, unused = upper - lower;
-
+    size_t upper = src->mp_upper, lower = src->mp_lower;
+    intptr_t unused = upper - lower;
     /* If page isn't full, just copy the used portion. Adjust
      * alignment so memcpy may copy words instead of bytes. */
-    if (unused >= MDBX_CACHELINE_SIZE * 2) {
+    if (unused > MDBX_CACHELINE_SIZE * 3) {
       lower = ceil_powerof2(lower + PAGEHDRSZ, sizeof(void *));
       upper = floor_powerof2(upper + PAGEHDRSZ, sizeof(void *));
-      memcpy(dst, src, lower);
-      dst = (void *)((char *)dst + upper);
-      src = (void *)((char *)src + upper);
-      psize -= upper;
+      if (unlikely(upper > copy_len))
+        goto bailout;
+      memcpy(copy_dst, copy_src, lower);
+      copy_dst += upper;
+      copy_src += upper;
+      copy_len -= upper;
     }
   }
-  memcpy(dst, src, psize);
+  memcpy(copy_dst, copy_src, copy_len);
+  return;
+
+bailout:
+  if (src->mp_flags & P_LEAF2)
+    bad_page(src, "%s addr %p, n-keys %zu, ksize %u",
+             "invalid/corrupted source page", __Wpedantic_format_voidptr(src),
+             page_numkeys(src), src->mp_leaf2_ksize);
+  else
+    bad_page(src, "%s addr %p, upper %u", "invalid/corrupted source page",
+             __Wpedantic_format_voidptr(src), src->mp_upper);
+  memset(dst, -1, size);
 }
 
 /* Pull a page off the txn's spill list, if present.
@@ -11541,7 +11575,9 @@ __cold int mdbx_env_sync_poll(MDBX_env *env) {
 
 /* Back up parent txn's cursors, then grab the originals for tracking */
 static int cursor_shadow(MDBX_txn *parent, MDBX_txn *nested) {
-  for (int i = parent->mt_numdbs; --i >= 0;) {
+  tASSERT(parent, parent->mt_cursors[FREE_DBI] == nullptr);
+  nested->mt_cursors[FREE_DBI] = nullptr;
+  for (int i = parent->mt_numdbs; --i > FREE_DBI;) {
     nested->mt_cursors[i] = NULL;
     MDBX_cursor *mc = parent->mt_cursors[i];
     if (mc != NULL) {
@@ -11586,7 +11622,8 @@ static int cursor_shadow(MDBX_txn *parent, MDBX_txn *nested) {
  *
  * Returns 0 on success, non-zero on failure. */
 static void cursors_eot(MDBX_txn *txn, const bool merge) {
-  for (intptr_t i = txn->mt_numdbs; --i >= 0;) {
+  tASSERT(txn, txn->mt_cursors[FREE_DBI] == nullptr);
+  for (intptr_t i = txn->mt_numdbs; --i > FREE_DBI;) {
     MDBX_cursor *next, *mc = txn->mt_cursors[i];
     if (!mc)
       continue;
@@ -11856,7 +11893,7 @@ __cold int mdbx_thread_unregister(const MDBX_env *env) {
   return MDBX_SUCCESS;
 }
 
-/* check against https://web.archive.org/web/https://github.com/erthink/libmdbx/issues/269 */
+/* check against https://libmdbx.dqdkfa.ru/dead-github/issues/269 */
 static bool coherency_check(const MDBX_env *env, const txnid_t txnid,
                             const volatile MDBX_db *dbs,
                             const volatile MDBX_meta *meta, bool report) {
@@ -11957,7 +11994,7 @@ __cold static int coherency_timeout(uint64_t *timestamp, pgno_t pgno) {
 }
 
 /* check with timeout as the workaround
- * for https://web.archive.org/web/https://github.com/erthink/libmdbx/issues/269 */
+ * for https://libmdbx.dqdkfa.ru/dead-github/issues/269 */
 __hot static int coherency_check_readed(const MDBX_env *env,
                                         const txnid_t txnid,
                                         const volatile MDBX_db *dbs,
@@ -12193,8 +12230,7 @@ static int txn_renew(MDBX_txn *txn, const unsigned flags) {
     txn->tw.troika = meta_tap(env);
     const meta_ptr_t head = meta_recent(env, &txn->tw.troika);
     uint64_t timestamp = 0;
-    while (
-        "workaround for https://web.archive.org/web/https://github.com/erthink/libmdbx/issues/269") {
+    while ("workaround for https://libmdbx.dqdkfa.ru/dead-github/issues/269") {
       rc = coherency_check_readed(env, head.txnid, head.ptr_v->mm_dbs,
                                   head.ptr_v, &timestamp);
       if (likely(rc == MDBX_SUCCESS))
@@ -12219,8 +12255,8 @@ static int txn_renew(MDBX_txn *txn, const unsigned flags) {
     txn->tw.loose_refund_wl = 0;
 #endif /* MDBX_ENABLE_REFUND */
     MDBX_PNL_SETSIZE(txn->tw.retired_pages, 0);
-    txn->tw.spill_pages = NULL;
-    txn->tw.spill_least_removed = 0;
+    txn->tw.spilled.list = NULL;
+    txn->tw.spilled.least_removed = 0;
     txn->tw.last_reclaimed = 0;
     if (txn->tw.lifo_reclaimed)
       MDBX_PNL_SETSIZE(txn->tw.lifo_reclaimed, 0);
@@ -12297,6 +12333,19 @@ static int txn_renew(MDBX_txn *txn, const unsigned flags) {
         osal_srwlock_AcquireShared(&env->me_remap_guard);
       }
 #endif /* Windows */
+    } else {
+      if (unlikely(txn->mt_dbs[FREE_DBI].md_flags != MDBX_INTEGERKEY)) {
+        ERROR("unexpected/invalid db-flags 0x%u for GC/FreeDB",
+              txn->mt_dbs[FREE_DBI].md_flags);
+        rc = MDBX_INCOMPATIBLE;
+        goto bailout;
+      }
+
+      tASSERT(txn, txn == env->me_txn0);
+      MDBX_cursor *const gc = (MDBX_cursor *)((char *)txn + sizeof(MDBX_txn));
+      rc = cursor_init(gc, txn, FREE_DBI);
+      if (rc != MDBX_SUCCESS)
+        goto bailout;
     }
 #if defined(MDBX_USE_VALGRIND) || defined(__SANITIZE_ADDRESS__)
     txn_valgrind(env, txn);
@@ -12514,7 +12563,7 @@ int mdbx_txn_begin_ex(MDBX_env *env, MDBX_txn *parent, MDBX_txn_flags_t flags,
     txn->tw.dirtylru = parent->tw.dirtylru;
 
     dpl_sort(parent);
-    if (parent->tw.spill_pages)
+    if (parent->tw.spilled.list)
       spill_purge(parent);
 
     tASSERT(txn, MDBX_PNL_ALLOCLEN(txn->tw.relist) >=
@@ -12591,7 +12640,7 @@ int mdbx_txn_begin_ex(MDBX_env *env, MDBX_txn *parent, MDBX_txn_flags_t flags,
       eASSERT(env, (txn->mt_flags &
                     ~(MDBX_WRITEMAP | MDBX_SHRINK_ALLOWED | MDBX_NOMETASYNC |
                       MDBX_SAFE_NOSYNC | MDBX_TXN_SPILLS)) == 0);
-      assert(!txn->tw.spill_pages && !txn->tw.spill_least_removed);
+      assert(!txn->tw.spilled.list && !txn->tw.spilled.least_removed);
     }
     txn->mt_signature = MDBX_MT_SIGNATURE;
     txn->mt_userctx = context;
@@ -12696,10 +12745,9 @@ int mdbx_txn_info(const MDBX_txn *txn, MDBX_txn_info *info, bool scan_rlt) {
         env, txn->mt_child ? (size_t)txn->tw.retired_pages
                            : MDBX_PNL_GETSIZE(txn->tw.retired_pages));
     info->txn_space_leftover = pgno2bytes(env, txn->tw.dirtyroom);
-    info->txn_space_dirty =
-        txn->tw.dirtylist
-            ? pgno2bytes(env, txn->tw.dirtylist->pages_including_loose)
-            : 0;
+    info->txn_space_dirty = pgno2bytes(
+        env, txn->tw.dirtylist ? txn->tw.dirtylist->pages_including_loose
+                               : txn->tw.writemap_dirty_npages);
     info->txn_reader_lag = INT64_MAX;
     MDBX_lockinfo *const lck = env->me_lck_mmap.lck;
     if (scan_rlt && lck) {
@@ -13015,8 +13063,8 @@ static int txn_end(MDBX_txn *txn, const unsigned mode) {
     txn->mt_flags = MDBX_TXN_FINISHED;
     txn->mt_owner = 0;
     env->me_txn = txn->mt_parent;
-    pnl_free(txn->tw.spill_pages);
-    txn->tw.spill_pages = nullptr;
+    pnl_free(txn->tw.spilled.list);
+    txn->tw.spilled.list = nullptr;
     if (txn == env->me_txn0) {
       eASSERT(env, txn->mt_parent == NULL);
       /* Export or close DBI handles created in this txn */
@@ -13283,7 +13331,7 @@ typedef struct gc_update_context {
 #if MDBX_ENABLE_BIGFOOT
   txnid_t bigfoot;
 #endif /* MDBX_ENABLE_BIGFOOT */
-  MDBX_cursor_couple cursor;
+  MDBX_cursor cursor;
 } gcu_context_t;
 
 static __inline int gcu_context_init(MDBX_txn *txn, gcu_context_t *ctx) {
@@ -13292,7 +13340,7 @@ static __inline int gcu_context_init(MDBX_txn *txn, gcu_context_t *ctx) {
 #if MDBX_ENABLE_BIGFOOT
   ctx->bigfoot = txn->mt_txnid;
 #endif /* MDBX_ENABLE_BIGFOOT */
-  return cursor_init(&ctx->cursor.outer, txn, FREE_DBI);
+  return cursor_init(&ctx->cursor, txn, FREE_DBI);
 }
 
 static __always_inline size_t gcu_backlog_size(MDBX_txn *txn) {
@@ -13311,10 +13359,10 @@ static int gcu_clean_stored_retired(MDBX_txn *txn, gcu_context_t *ctx) {
 #endif /* MDBX_ENABLE_BIGFOOT */
       key.iov_len = sizeof(txnid_t);
       const struct cursor_set_result csr =
-          cursor_set(&ctx->cursor.outer, &key, &val, MDBX_SET);
+          cursor_set(&ctx->cursor, &key, &val, MDBX_SET);
       if (csr.err == MDBX_SUCCESS && csr.exact) {
         ctx->retired_stored = 0;
-        err = mdbx_cursor_del(&ctx->cursor.outer, 0);
+        err = mdbx_cursor_del(&ctx->cursor, 0);
         TRACE("== clear-4linear, backlog %zu, err %d", gcu_backlog_size(txn),
               err);
       }
@@ -13327,6 +13375,13 @@ static int gcu_clean_stored_retired(MDBX_txn *txn, gcu_context_t *ctx) {
   return err;
 }
 
+static int gcu_touch(gcu_context_t *ctx) {
+  ctx->cursor.mc_flags |= C_GCU;
+  int err = cursor_touch(&ctx->cursor);
+  ctx->cursor.mc_flags -= C_GCU;
+  return err;
+}
+
 /* Prepare a backlog of pages to modify GC itself, while reclaiming is
  * prohibited. It should be enough to prevent search in page_alloc_slowpath()
  * during a deleting, when GC tree is unbalanced. */
@@ -13356,14 +13411,12 @@ static int gcu_prepare_backlog(MDBX_txn *txn, gcu_context_t *ctx,
     key.iov_base = val.iov_base = nullptr;
     key.iov_len = sizeof(txnid_t);
     val.iov_len = MDBX_PNL_SIZEOF(txn->tw.retired_pages);
-    err = cursor_spill(&ctx->cursor.outer, &key, &val);
+    err = cursor_spill(&ctx->cursor, &key, &val);
     if (unlikely(err != MDBX_SUCCESS))
       return err;
   }
 
-  tASSERT(txn, txn->mt_flags & MDBX_TXN_UPDATE_GC);
-  txn->mt_flags -= MDBX_TXN_UPDATE_GC;
-  err = cursor_touch(&ctx->cursor.outer);
+  err = gcu_touch(ctx);
   TRACE("== after-touch, backlog %zu, err %d", gcu_backlog_size(txn), err);
 
   if (unlikely(pages4retiredlist > 1) &&
@@ -13373,22 +13426,20 @@ static int gcu_prepare_backlog(MDBX_txn *txn, gcu_context_t *ctx,
     err = gcu_clean_stored_retired(txn, ctx);
     if (unlikely(err != MDBX_SUCCESS))
       return err;
-    err = page_alloc_slowpath(&ctx->cursor.outer, (pgno_t)pages4retiredlist,
-                              MDBX_ALLOC_GC | MDBX_ALLOC_RESERVE)
-              .err;
+    err =
+        page_alloc_slowpath(&ctx->cursor, pages4retiredlist, MDBX_ALLOC_RESERVE)
+            .err;
     TRACE("== after-4linear, backlog %zu, err %d", gcu_backlog_size(txn), err);
-    cASSERT(&ctx->cursor.outer,
+    cASSERT(&ctx->cursor,
             gcu_backlog_size(txn) >= pages4retiredlist || err != MDBX_SUCCESS);
   }
 
   while (gcu_backlog_size(txn) < backlog4cow + pages4retiredlist &&
          err == MDBX_SUCCESS)
-    err = page_alloc_slowpath(&ctx->cursor.outer, 0,
-                              MDBX_ALLOC_GC | MDBX_ALLOC_SLOT |
-                                  MDBX_ALLOC_RESERVE | MDBX_ALLOC_BACKLOG)
+    err = page_alloc_slowpath(&ctx->cursor, 0,
+                              MDBX_ALLOC_RESERVE | MDBX_ALLOC_UNIMPORTANT)
               .err;
 
-  txn->mt_flags += MDBX_TXN_UPDATE_GC;
   TRACE("<< backlog %zu, err %d", gcu_backlog_size(txn), err);
   return (err != MDBX_NOTFOUND) ? err : MDBX_SUCCESS;
 }
@@ -13417,9 +13468,8 @@ static int update_gc(MDBX_txn *txn, gcu_context_t *ctx) {
   MDBX_env *const env = txn->mt_env;
   const char *const dbg_prefix_mode = ctx->lifo ? "    lifo" : "    fifo";
   (void)dbg_prefix_mode;
-  txn->mt_flags += MDBX_TXN_UPDATE_GC;
-  ctx->cursor.outer.mc_next = txn->mt_cursors[FREE_DBI];
-  txn->mt_cursors[FREE_DBI] = &ctx->cursor.outer;
+  ctx->cursor.mc_next = txn->mt_cursors[FREE_DBI];
+  txn->mt_cursors[FREE_DBI] = &ctx->cursor;
 
   /* txn->tw.relist[] can grow and shrink during this call.
    * txn->tw.last_reclaimed and txn->tw.retired_pages[] can only grow.
@@ -13481,7 +13531,7 @@ retry:
                       ctx->cleaned_id <= env->me_lck->mti_oldest_reader.weak);
           key.iov_base = &ctx->cleaned_id;
           key.iov_len = sizeof(ctx->cleaned_id);
-          rc = mdbx_cursor_get(&ctx->cursor.outer, &key, NULL, MDBX_SET);
+          rc = mdbx_cursor_get(&ctx->cursor, &key, NULL, MDBX_SET);
           if (rc == MDBX_NOTFOUND)
             continue;
           if (unlikely(rc != MDBX_SUCCESS))
@@ -13494,18 +13544,17 @@ retry:
           tASSERT(txn, ctx->cleaned_id <= env->me_lck->mti_oldest_reader.weak);
           TRACE("%s: cleanup-reclaimed-id [%zu]%" PRIaTXN, dbg_prefix_mode,
                 ctx->cleaned_slot, ctx->cleaned_id);
-          tASSERT(txn, *txn->mt_cursors == &ctx->cursor.outer);
-          rc = mdbx_cursor_del(&ctx->cursor.outer, 0);
+          tASSERT(txn, *txn->mt_cursors == &ctx->cursor);
+          rc = mdbx_cursor_del(&ctx->cursor, 0);
           if (unlikely(rc != MDBX_SUCCESS))
             goto bailout;
         } while (ctx->cleaned_slot < MDBX_PNL_GETSIZE(txn->tw.lifo_reclaimed));
         txl_sort(txn->tw.lifo_reclaimed);
       }
     } else {
-      /* If using records from GC which we have not yet deleted,
-       * now delete them and any we reserved for tw.relist. */
+      /* Удаляем оставшиеся вынутые из GC записи. */
       while (ctx->cleaned_id <= txn->tw.last_reclaimed) {
-        rc = cursor_first(&ctx->cursor.outer, &key, NULL);
+        rc = cursor_first(&ctx->cursor, &key, NULL);
         if (rc == MDBX_NOTFOUND)
           break;
         if (unlikely(rc != MDBX_SUCCESS))
@@ -13530,8 +13579,8 @@ retry:
         tASSERT(txn, ctx->cleaned_id <= env->me_lck->mti_oldest_reader.weak);
         TRACE("%s: cleanup-reclaimed-id %" PRIaTXN, dbg_prefix_mode,
               ctx->cleaned_id);
-        tASSERT(txn, *txn->mt_cursors == &ctx->cursor.outer);
-        rc = mdbx_cursor_del(&ctx->cursor.outer, 0);
+        tASSERT(txn, *txn->mt_cursors == &ctx->cursor);
+        rc = mdbx_cursor_del(&ctx->cursor, 0);
         if (unlikely(rc != MDBX_SUCCESS))
           goto bailout;
       }
@@ -13566,10 +13615,7 @@ retry:
         if (txn->tw.loose_count > 0) {
           TRACE("%s: try allocate gc-slot for %zu loose-pages", dbg_prefix_mode,
                 txn->tw.loose_count);
-          rc = page_alloc_slowpath(&ctx->cursor.outer, 0,
-                                   MDBX_ALLOC_GC | MDBX_ALLOC_SLOT |
-                                       MDBX_ALLOC_RESERVE)
-                   .err;
+          rc = page_alloc_slowpath(&ctx->cursor, 0, MDBX_ALLOC_RESERVE).err;
           if (rc == MDBX_SUCCESS) {
             TRACE("%s: retry since gc-slot for %zu loose-pages available",
                   dbg_prefix_mode, txn->tw.loose_count);
@@ -13651,10 +13697,9 @@ retry:
     if (ctx->retired_stored < MDBX_PNL_GETSIZE(txn->tw.retired_pages)) {
       if (unlikely(!ctx->retired_stored)) {
         /* Make sure last page of GC is touched and on retired-list */
-        txn->mt_flags -= MDBX_TXN_UPDATE_GC;
-        rc = page_search(&ctx->cursor.outer, NULL,
-                         MDBX_PS_LAST | MDBX_PS_MODIFY);
-        txn->mt_flags += MDBX_TXN_UPDATE_GC;
+        rc = cursor_last(&ctx->cursor, nullptr, nullptr);
+        if (likely(rc != MDBX_SUCCESS))
+          rc = gcu_touch(ctx);
         if (unlikely(rc != MDBX_SUCCESS) && rc != MDBX_NOTFOUND)
           goto bailout;
       }
@@ -13664,6 +13709,8 @@ retry:
       do {
         if (ctx->bigfoot > txn->mt_txnid) {
           rc = gcu_clean_stored_retired(txn, ctx);
+          if (unlikely(rc != MDBX_SUCCESS))
+            goto bailout;
           tASSERT(txn, ctx->bigfoot <= txn->mt_txnid);
         }
 
@@ -13685,7 +13732,7 @@ retry:
                   ? env->me_maxgc_ov1page
                   : left;
           data.iov_len = (chunk + 1) * sizeof(pgno_t);
-          rc = mdbx_cursor_put(&ctx->cursor.outer, &key, &data, MDBX_RESERVE);
+          rc = mdbx_cursor_put(&ctx->cursor, &key, &data, MDBX_RESERVE);
           if (unlikely(rc != MDBX_SUCCESS))
             goto bailout;
 
@@ -13723,7 +13770,7 @@ retry:
       do {
         gcu_prepare_backlog(txn, ctx, true);
         data.iov_len = MDBX_PNL_SIZEOF(txn->tw.retired_pages);
-        rc = mdbx_cursor_put(&ctx->cursor.outer, &key, &data, MDBX_RESERVE);
+        rc = mdbx_cursor_put(&ctx->cursor, &key, &data, MDBX_RESERVE);
         if (unlikely(rc != MDBX_SUCCESS))
           goto bailout;
         /* Retry if tw.retired_pages[] grew during the Put() */
@@ -13790,17 +13837,13 @@ retry:
           left > (MDBX_PNL_GETSIZE(txn->tw.lifo_reclaimed) - ctx->reused_slot) *
                      env->me_maxgc_ov1page &&
           !ctx->dense) {
-        /* LY: need just a txn-id for save page list. */
+        /* Hужен свободный для для сохранения списка страниц. */
         bool need_cleanup = false;
-        txnid_t snap_oldest;
+        txnid_t snap_oldest = 0;
       retry_rid:
-        txn->mt_flags -= MDBX_TXN_UPDATE_GC;
         do {
-          snap_oldest = txn_oldest_reader(txn);
-          rc = page_alloc_slowpath(&ctx->cursor.outer, 0,
-                                   MDBX_ALLOC_GC | MDBX_ALLOC_SLOT |
-                                       MDBX_ALLOC_RESERVE)
-                   .err;
+          rc = page_alloc_slowpath(&ctx->cursor, 0, MDBX_ALLOC_RESERVE).err;
+          snap_oldest = env->me_lck->mti_oldest_reader.weak;
           if (likely(rc == MDBX_SUCCESS)) {
             TRACE("%s: took @%" PRIaTXN " from GC", dbg_prefix_mode,
                   MDBX_PNL_LAST(txn->tw.lifo_reclaimed));
@@ -13812,7 +13855,6 @@ retry:
             left >
                 (MDBX_PNL_GETSIZE(txn->tw.lifo_reclaimed) - ctx->reused_slot) *
                     env->me_maxgc_ov1page);
-        txn->mt_flags += MDBX_TXN_UPDATE_GC;
 
         if (likely(rc == MDBX_SUCCESS)) {
           TRACE("%s: got enough from GC.", dbg_prefix_mode);
@@ -13830,7 +13872,7 @@ retry:
         } else {
           tASSERT(txn, txn->tw.last_reclaimed == 0);
           if (unlikely(txn_oldest_reader(txn) != snap_oldest))
-            /* should retry page_alloc_slowpath(MDBX_ALLOC_GC)
+            /* should retry page_alloc_slowpath()
              * if the oldest reader changes since the last attempt */
             goto retry_rid;
           /* no reclaimable GC entries,
@@ -13840,7 +13882,8 @@ retry:
                 ctx->rid);
         }
 
-        /* LY: GC is empty, will look any free txn-id in high2low order. */
+        /* В GC нет годных к переработке записей,
+         * будем использовать свободные id в обратном порядке. */
         while (MDBX_PNL_GETSIZE(txn->tw.lifo_reclaimed) < prefer_max_scatter &&
                left > (MDBX_PNL_GETSIZE(txn->tw.lifo_reclaimed) -
                        ctx->reused_slot) *
@@ -13858,26 +13901,20 @@ retry:
           }
 
           tASSERT(txn, ctx->rid >= MIN_TXNID && ctx->rid <= MAX_TXNID);
-          --ctx->rid;
+          ctx->rid -= 1;
           key.iov_base = &ctx->rid;
           key.iov_len = sizeof(ctx->rid);
-          rc = mdbx_cursor_get(&ctx->cursor.outer, &key, &data, MDBX_SET_KEY);
+          rc = mdbx_cursor_get(&ctx->cursor, &key, &data, MDBX_SET_KEY);
           if (unlikely(rc == MDBX_SUCCESS)) {
-            DEBUG("%s: GC's id %" PRIaTXN " is used, continue bottom-up search",
+            DEBUG("%s: GC's id %" PRIaTXN " is present, going to first",
                   dbg_prefix_mode, ctx->rid);
-            ++ctx->rid;
-            rc = mdbx_cursor_get(&ctx->cursor.outer, &key, &data, MDBX_FIRST);
-            if (rc == MDBX_NOTFOUND) {
-              DEBUG("%s: GC is empty (going dense-mode)", dbg_prefix_mode);
-              ctx->dense = true;
-              break;
-            }
+            rc = cursor_first(&ctx->cursor, &key, nullptr);
             if (unlikely(rc != MDBX_SUCCESS ||
                          key.iov_len != sizeof(txnid_t))) {
               rc = MDBX_CORRUPTED;
               goto bailout;
             }
-            txnid_t gc_first = unaligned_peek_u64(4, key.iov_base);
+            const txnid_t gc_first = unaligned_peek_u64(4, key.iov_base);
             if (gc_first <= MIN_TXNID) {
               DEBUG("%s: no free GC's id(s) less than %" PRIaTXN
                     " (going dense-mode)",
@@ -13925,13 +13962,13 @@ retry:
       tASSERT(txn, txn->tw.lifo_reclaimed == NULL);
       if (unlikely(ctx->rid == 0)) {
         ctx->rid = txn_oldest_reader(txn);
-        rc = mdbx_cursor_get(&ctx->cursor.outer, &key, NULL, MDBX_FIRST);
-        if (rc == MDBX_SUCCESS) {
+        rc = cursor_first(&ctx->cursor, &key, nullptr);
+        if (likely(rc == MDBX_SUCCESS)) {
           if (unlikely(key.iov_len != sizeof(txnid_t))) {
             rc = MDBX_CORRUPTED;
             goto bailout;
           }
-          txnid_t gc_first = unaligned_peek_u64(4, key.iov_base);
+          const txnid_t gc_first = unaligned_peek_u64(4, key.iov_base);
           if (ctx->rid >= gc_first)
             ctx->rid = gc_first - 1;
           if (unlikely(ctx->rid == 0)) {
@@ -14022,7 +14059,7 @@ retry:
     TRACE("%s: reserve %zu [%zu...%zu) @%" PRIaTXN, dbg_prefix_mode, chunk,
           ctx->settled + 1, ctx->settled + chunk + 1, reservation_gc_id);
     gcu_prepare_backlog(txn, ctx, true);
-    rc = mdbx_cursor_put(&ctx->cursor.outer, &key, &data,
+    rc = mdbx_cursor_put(&ctx->cursor, &key, &data,
                          MDBX_RESERVE | MDBX_NOOVERWRITE);
     tASSERT(txn, pnl_check_allocated(txn->tw.relist,
                                      txn->mt_next_pgno - MDBX_ENABLE_REFUND));
@@ -14070,7 +14107,7 @@ retry:
     size_t left = amount;
     if (txn->tw.lifo_reclaimed == nullptr) {
       tASSERT(txn, ctx->lifo == 0);
-      rc = cursor_first(&ctx->cursor.outer, &key, &data);
+      rc = cursor_first(&ctx->cursor, &key, &data);
       if (unlikely(rc != MDBX_SUCCESS))
         goto bailout;
     } else {
@@ -14104,7 +14141,7 @@ retry:
               dbg_prefix_mode, fill_gc_id, ctx->filled_slot);
         key.iov_base = &fill_gc_id;
         key.iov_len = sizeof(fill_gc_id);
-        rc = mdbx_cursor_get(&ctx->cursor.outer, &key, &data, MDBX_SET_KEY);
+        rc = mdbx_cursor_get(&ctx->cursor, &key, &data, MDBX_SET_KEY);
         if (unlikely(rc != MDBX_SUCCESS))
           goto bailout;
       }
@@ -14118,7 +14155,6 @@ retry:
       key.iov_len = sizeof(fill_gc_id);
 
       tASSERT(txn, data.iov_len >= sizeof(pgno_t) * 2);
-      txn->mt_flags += MDBX_TXN_FROZEN_RE;
       size_t chunk = data.iov_len / sizeof(pgno_t) - 1;
       if (unlikely(chunk > left)) {
         TRACE("%s: chunk %zu > left %zu, @%" PRIaTXN, dbg_prefix_mode, chunk,
@@ -14126,14 +14162,11 @@ retry:
         if ((ctx->loop < 5 && chunk - left > ctx->loop / 2) ||
             chunk - left > env->me_maxgc_ov1page) {
           data.iov_len = (left + 1) * sizeof(pgno_t);
-          if (ctx->loop < 7)
-            txn->mt_flags &= ~MDBX_TXN_FROZEN_RE;
         }
         chunk = left;
       }
-      rc = mdbx_cursor_put(&ctx->cursor.outer, &key, &data,
+      rc = mdbx_cursor_put(&ctx->cursor, &key, &data,
                            MDBX_CURRENT | MDBX_RESERVE);
-      txn->mt_flags &= ~MDBX_TXN_FROZEN_RE;
       if (unlikely(rc != MDBX_SUCCESS))
         goto bailout;
       gcu_clean_reserved(env, data);
@@ -14182,7 +14215,7 @@ retry:
 
       if (txn->tw.lifo_reclaimed == nullptr) {
         tASSERT(txn, ctx->lifo == 0);
-        rc = cursor_next(&ctx->cursor.outer, &key, &data, MDBX_NEXT);
+        rc = cursor_next(&ctx->cursor, &key, &data, MDBX_NEXT);
         if (unlikely(rc != MDBX_SUCCESS))
           goto bailout;
       } else {
@@ -14213,7 +14246,7 @@ retry:
               ctx->cleaned_slot == MDBX_PNL_GETSIZE(txn->tw.lifo_reclaimed));
 
 bailout:
-  txn->mt_cursors[FREE_DBI] = ctx->cursor.outer.mc_next;
+  txn->mt_cursors[FREE_DBI] = ctx->cursor.mc_next;
 
   MDBX_PNL_SETSIZE(txn->tw.relist, 0);
 #if MDBX_ENABLE_PROFGC
@@ -14363,7 +14396,8 @@ static __inline void txn_merge(MDBX_txn *const parent, MDBX_txn *const txn,
   MDBX_PNL_SETSIZE(parent->tw.retired_pages, w);
 
   /* Filter-out parent spill list */
-  if (parent->tw.spill_pages && MDBX_PNL_GETSIZE(parent->tw.spill_pages) > 0) {
+  if (parent->tw.spilled.list &&
+      MDBX_PNL_GETSIZE(parent->tw.spilled.list) > 0) {
     const MDBX_PNL sl = spill_purge(parent);
     size_t len = MDBX_PNL_GETSIZE(sl);
     if (len) {
@@ -14378,7 +14412,7 @@ static __inline void txn_merge(MDBX_txn *const parent, MDBX_txn *const txn,
             DEBUG("refund parent's spilled page %" PRIaPGNO, sl[i] >> 1);
           i -= 1;
         } while (i && sl[i] >= (parent->mt_next_pgno << 1));
-        MDBX_PNL_GETSIZE(sl) = i;
+        MDBX_PNL_SETSIZE(sl, i);
 #else
         assert(MDBX_PNL_MOST(sl) == MDBX_PNL_FIRST(sl));
         size_t i = 0;
@@ -14451,10 +14485,10 @@ static __inline void txn_merge(MDBX_txn *const parent, MDBX_txn *const txn,
   }
 
   /* Remove anything in our spill list from parent's dirty list */
-  if (txn->tw.spill_pages) {
-    tASSERT(txn, pnl_check_allocated(txn->tw.spill_pages,
+  if (txn->tw.spilled.list) {
+    tASSERT(txn, pnl_check_allocated(txn->tw.spilled.list,
                                      (size_t)parent->mt_next_pgno << 1));
-    dpl_sift(parent, txn->tw.spill_pages, true);
+    dpl_sift(parent, txn->tw.spilled.list, true);
     tASSERT(parent,
             parent->tw.dirtyroom + parent->tw.dirtylist->length ==
                 (parent->mt_parent ? parent->mt_parent->tw.dirtyroom
@@ -14606,23 +14640,23 @@ static __inline void txn_merge(MDBX_txn *const parent, MDBX_txn *const txn,
   tASSERT(parent, dirtylist_check(parent));
   dpl_free(txn);
 
-  if (txn->tw.spill_pages) {
-    if (parent->tw.spill_pages) {
+  if (txn->tw.spilled.list) {
+    if (parent->tw.spilled.list) {
       /* Must not fail since space was preserved above. */
-      pnl_merge(parent->tw.spill_pages, txn->tw.spill_pages);
-      pnl_free(txn->tw.spill_pages);
+      pnl_merge(parent->tw.spilled.list, txn->tw.spilled.list);
+      pnl_free(txn->tw.spilled.list);
     } else {
-      parent->tw.spill_pages = txn->tw.spill_pages;
-      parent->tw.spill_least_removed = txn->tw.spill_least_removed;
+      parent->tw.spilled.list = txn->tw.spilled.list;
+      parent->tw.spilled.least_removed = txn->tw.spilled.least_removed;
     }
     tASSERT(parent, dirtylist_check(parent));
   }
 
   parent->mt_flags &= ~MDBX_TXN_HAS_CHILD;
-  if (parent->tw.spill_pages) {
-    assert(pnl_check_allocated(parent->tw.spill_pages,
+  if (parent->tw.spilled.list) {
+    assert(pnl_check_allocated(parent->tw.spilled.list,
                                (size_t)parent->mt_next_pgno << 1));
-    if (MDBX_PNL_GETSIZE(parent->tw.spill_pages))
+    if (MDBX_PNL_GETSIZE(parent->tw.spilled.list))
       parent->mt_flags |= MDBX_TXN_SPILLS;
   }
 }
@@ -14693,8 +14727,8 @@ int mdbx_txn_commit_ex(MDBX_txn *txn, MDBX_commit_latency *latency) {
                           sizeof(parent->mt_geo)) == 0);
       tASSERT(txn, memcmp(&parent->mt_canary, &txn->mt_canary,
                           sizeof(parent->mt_canary)) == 0);
-      tASSERT(txn, !txn->tw.spill_pages ||
-                       MDBX_PNL_GETSIZE(txn->tw.spill_pages) == 0);
+      tASSERT(txn, !txn->tw.spilled.list ||
+                       MDBX_PNL_GETSIZE(txn->tw.spilled.list) == 0);
       tASSERT(txn, txn->tw.loose_count == 0);
 
       /* fast completion of pure nested transaction */
@@ -14714,10 +14748,10 @@ int mdbx_txn_commit_ex(MDBX_txn *txn, MDBX_commit_latency *latency) {
         goto fail;
     }
 
-    if (txn->tw.spill_pages) {
-      if (parent->tw.spill_pages) {
-        rc = pnl_need(&parent->tw.spill_pages,
-                      MDBX_PNL_GETSIZE(txn->tw.spill_pages));
+    if (txn->tw.spilled.list) {
+      if (parent->tw.spilled.list) {
+        rc = pnl_need(&parent->tw.spilled.list,
+                      MDBX_PNL_GETSIZE(txn->tw.spilled.list));
         if (unlikely(rc != MDBX_SUCCESS))
           goto fail;
       }
@@ -15837,7 +15871,7 @@ static int sync_locked(MDBX_env *env, unsigned flags, MDBX_meta *const pending,
   }
 
   uint64_t timestamp = 0;
-  while ("workaround for https://web.archive.org/web/https://github.com/erthink/libmdbx/issues/269") {
+  while ("workaround for https://libmdbx.dqdkfa.ru/dead-github/issues/269") {
     rc =
         coherency_check_written(env, pending->unsafe_txnid, target, &timestamp);
     if (likely(rc == MDBX_SUCCESS))
@@ -16359,7 +16393,7 @@ mdbx_env_set_geometry(MDBX_env *env, intptr_t size_lower, intptr_t size_now,
 
       uint64_t timestamp = 0;
       while ("workaround for "
-             "https://web.archive.org/web/https://github.com/erthink/libmdbx/issues/269") {
+             "https://libmdbx.dqdkfa.ru/dead-github/issues/269") {
         meta = *head.ptr_c;
         rc = coherency_check_readed(env, head.txnid, meta.mm_dbs, &meta,
                                     &timestamp);
@@ -17503,13 +17537,13 @@ __cold static int handle_env_pathname(MDBX_handle_env_pathname *ctx,
   }
 #else
   struct stat st;
-  if (stat(pathname, &st)) {
+  if (stat(pathname, &st) != 0) {
     rc = errno;
     if (rc != MDBX_ENOFILE)
       return rc;
     if (mode == 0 || (*flags & MDBX_RDONLY) != 0)
       /* can't open existing */
-      return rc;
+      return rc /* MDBX_ENOFILE */;
 
     /* auto-create directory if requested */
     const mdbx_mode_t dir_mode =
@@ -17702,7 +17736,7 @@ __cold int mdbx_env_openW(MDBX_env *env, const wchar_t *pathname,
   } else {
 #if MDBX_MMAP_INCOHERENT_FILE_WRITE
     /* Temporary `workaround` for OpenBSD kernel's flaw.
-     * See https://web.archive.org/web/https://github.com/erthink/libmdbx/issues/67 */
+     * See https://libmdbx.dqdkfa.ru/dead-github/issues/67 */
     if ((flags & MDBX_WRITEMAP) == 0) {
       if (flags & MDBX_ACCEDE)
         flags |= MDBX_WRITEMAP;
@@ -18014,7 +18048,7 @@ __cold int mdbx_env_openW(MDBX_env *env, const wchar_t *pathname,
   }
 
   if ((flags & MDBX_RDONLY) == 0) {
-    const size_t tsize = sizeof(MDBX_txn),
+    const size_t tsize = sizeof(MDBX_txn) + sizeof(MDBX_cursor),
                  size = tsize + env->me_maxdbs *
                                     (sizeof(MDBX_db) + sizeof(MDBX_cursor *) +
                                      sizeof(MDBX_atomic_uint32_t) + 1);
@@ -18139,9 +18173,10 @@ __cold static int env_close(MDBX_env *env) {
   }
 
   if (env->me_dbxs) {
-    for (size_t i = env->me_numdbs; --i >= CORE_DBS;)
+    for (size_t i = CORE_DBS; i < env->me_numdbs; ++i)
       osal_free(env->me_dbxs[i].md_name.iov_base);
     osal_free(env->me_dbxs);
+    env->me_numdbs = CORE_DBS;
     env->me_dbxs = nullptr;
   }
   if (env->me_pbuf) {
@@ -18164,7 +18199,7 @@ __cold static int env_close(MDBX_env *env) {
     dpl_free(env->me_txn0);
     txl_free(env->me_txn0->tw.lifo_reclaimed);
     pnl_free(env->me_txn0->tw.retired_pages);
-    pnl_free(env->me_txn0->tw.spill_pages);
+    pnl_free(env->me_txn0->tw.spilled.list);
     pnl_free(env->me_txn0->tw.relist);
     osal_free(env->me_txn0);
     env->me_txn0 = nullptr;
@@ -18907,7 +18942,8 @@ static __noinline int node_read_bigdata(MDBX_cursor *mc, const MDBX_node *node,
   if (!MDBX_DISABLE_VALIDATION) {
     const MDBX_env *env = mc->mc_txn->mt_env;
     const size_t dsize = data->iov_len;
-    if (unlikely(node_size_len(node_ks(node), dsize) <= env->me_leaf_nodemax))
+    if (unlikely(node_size_len(node_ks(node), dsize) <= env->me_leaf_nodemax) &&
+        mc->mc_dbi != FREE_DBI)
       poor_page(mp, "too small data (%zu bytes) for bigdata-node", dsize);
     const unsigned npages = number_of_ovpages(env, dsize);
     if (unlikely(lp.page->mp_pages != npages)) {
@@ -18915,7 +18951,7 @@ static __noinline int node_read_bigdata(MDBX_cursor *mc, const MDBX_node *node,
         return bad_page(lp.page,
                         "too less n-pages %u for bigdata-node (%zu bytes)",
                         lp.page->mp_pages, dsize);
-      else
+      else if (mc->mc_dbi != FREE_DBI)
         poor_page(lp.page, "extra n-pages %u for bigdata-node (%zu bytes)",
                   lp.page->mp_pages, dsize);
     }
@@ -20011,7 +20047,6 @@ static int touch_dbi(MDBX_cursor *mc) {
   *mc->mc_dbistate |= DBI_DIRTY;
   mc->mc_txn->mt_flags |= MDBX_TXN_DIRTY;
   if (mc->mc_dbi >= CORE_DBS) {
-    cASSERT(mc, (mc->mc_txn->mt_flags & MDBX_TXN_UPDATE_GC) == 0);
     /* Touch DB record of named DB */
     MDBX_cursor_couple cx;
     int rc = cursor_init(&cx.outer, mc->mc_txn, MAIN_DBI);
@@ -20424,9 +20459,9 @@ __hot int mdbx_cursor_put(MDBX_cursor *mc, const MDBX_val *key, MDBX_val *data,
 
     /* Large/Overflow page overwrites need special handling */
     if (unlikely(node_flags(node) & F_BIGDATA)) {
-      int dpages = (node_size(key, data) > env->me_leaf_nodemax)
-                       ? number_of_ovpages(env, data->iov_len)
-                       : 0;
+      const size_t dpages = (node_size(key, data) > env->me_leaf_nodemax)
+                                ? number_of_ovpages(env, data->iov_len)
+                                : 0;
 
       const pgno_t pgno = node_largedata_pgno(node);
       pgr_t lp = page_get_large(mc, pgno, mc->mc_pg[mc->mc_top]->mp_txnid);
@@ -20435,13 +20470,13 @@ __hot int mdbx_cursor_put(MDBX_cursor *mc, const MDBX_val *key, MDBX_val *data,
       cASSERT(mc, PAGETYPE_WHOLE(lp.page) == P_OVERFLOW);
 
       /* Is the ov page from this txn (or a parent) and big enough? */
-      int ovpages = lp.page->mp_pages;
-      if (!IS_FROZEN(mc->mc_txn, lp.page) &&
-          (unlikely(mc->mc_txn->mt_flags & MDBX_TXN_FROZEN_RE)
-               ? (ovpages >= dpages)
-               : (ovpages ==
-                  /* LY: add configurable threshold to keep reserve space */
-                  dpages))) {
+      const size_t ovpages = lp.page->mp_pages;
+      const size_t extra_threshold =
+          (mc->mc_dbi == FREE_DBI)
+              ? 1
+              : /* LY: add configurable threshold to keep reserve space */ 0;
+      if (!IS_FROZEN(mc->mc_txn, lp.page) && ovpages >= dpages &&
+          ovpages <= dpages + extra_threshold) {
         /* yes, overwrite it. */
         if (!IS_MODIFIABLE(mc->mc_txn, lp.page)) {
           if (IS_SPILLED(mc->mc_txn, lp.page)) {
@@ -20972,7 +21007,6 @@ static pgr_t page_new(MDBX_cursor *mc, const unsigned flags) {
 
   DEBUG("db %u allocated new page %" PRIaPGNO, mc->mc_dbi, ret.page->mp_pgno);
   ret.page->mp_flags = (uint16_t)flags;
-  ret.page->mp_txnid = mc->mc_txn->mt_front;
   cASSERT(mc, *mc->mc_dbistate & DBI_DIRTY);
   cASSERT(mc, mc->mc_txn->mt_flags & MDBX_TXN_DIRTY);
 #if MDBX_ENABLE_PGOP_STAT
@@ -20994,25 +21028,24 @@ static pgr_t page_new(MDBX_cursor *mc, const unsigned flags) {
   return ret;
 }
 
-static pgr_t page_new_large(MDBX_cursor *mc, const unsigned npages) {
+static pgr_t page_new_large(MDBX_cursor *mc, const size_t npages) {
   pgr_t ret = likely(npages == 1)
                   ? page_alloc(mc)
-                  : page_alloc_slowpath(mc, npages, MDBX_ALLOC_ALL);
+                  : page_alloc_slowpath(mc, npages, MDBX_ALLOC_DEFAULT);
   if (unlikely(ret.err != MDBX_SUCCESS))
     return ret;
 
-  DEBUG("db %u allocated new large-page %" PRIaPGNO ", num %u", mc->mc_dbi,
+  DEBUG("db %u allocated new large-page %" PRIaPGNO ", num %zu", mc->mc_dbi,
         ret.page->mp_pgno, npages);
   ret.page->mp_flags = P_OVERFLOW;
-  ret.page->mp_txnid = mc->mc_txn->mt_front;
   cASSERT(mc, *mc->mc_dbistate & DBI_DIRTY);
   cASSERT(mc, mc->mc_txn->mt_flags & MDBX_TXN_DIRTY);
 #if MDBX_ENABLE_PGOP_STAT
   mc->mc_txn->mt_env->me_lck->mti_pgop_stat.newly.weak += npages;
 #endif /* MDBX_ENABLE_PGOP_STAT */
 
-  mc->mc_db->md_overflow_pages += npages;
-  ret.page->mp_pages = npages;
+  mc->mc_db->md_overflow_pages += (pgno_t)npages;
+  ret.page->mp_pages = (pgno_t)npages;
   cASSERT(mc, !(mc->mc_flags & C_SUB));
   return ret;
 }
@@ -21109,7 +21142,6 @@ __hot static int __must_check_result node_add_leaf(MDBX_cursor *mc, size_t indx,
         key ? key->iov_len : 0, DKEY_DEBUG(key));
   cASSERT(mc, key != NULL && data != NULL);
   cASSERT(mc, PAGETYPE_COMPAT(mp) == P_LEAF);
-  cASSERT(mc, page_room(mp) >= leaf_size(mc->mc_txn->mt_env, key, data));
   MDBX_page *largepage = NULL;
 
   size_t node_bytes;
@@ -21118,6 +21150,7 @@ __hot static int __must_check_result node_add_leaf(MDBX_cursor *mc, size_t indx,
     STATIC_ASSERT(sizeof(pgno_t) % 2 == 0);
     node_bytes =
         node_size_len(key->iov_len, 0) + sizeof(pgno_t) + sizeof(indx_t);
+    cASSERT(mc, page_room(mp) >= node_bytes);
   } else if (unlikely(node_size(key, data) >
                       mc->mc_txn->mt_env->me_leaf_nodemax)) {
     /* Put data on large/overflow page. */
@@ -21131,6 +21164,7 @@ __hot static int __must_check_result node_add_leaf(MDBX_cursor *mc, size_t indx,
             flags);
       return MDBX_PROBLEM;
     }
+    cASSERT(mc, page_room(mp) >= leaf_size(mc->mc_txn->mt_env, key, data));
     const pgno_t ovpages = number_of_ovpages(mc->mc_txn->mt_env, data->iov_len);
     const pgr_t npr = page_new_large(mc, ovpages);
     if (unlikely(npr.err != MDBX_SUCCESS))
@@ -21142,10 +21176,12 @@ __hot static int __must_check_result node_add_leaf(MDBX_cursor *mc, size_t indx,
     flags |= F_BIGDATA;
     node_bytes =
         node_size_len(key->iov_len, 0) + sizeof(pgno_t) + sizeof(indx_t);
+    cASSERT(mc, node_bytes == leaf_size(mc->mc_txn->mt_env, key, data));
   } else {
+    cASSERT(mc, page_room(mp) >= leaf_size(mc->mc_txn->mt_env, key, data));
     node_bytes = node_size(key, data) + sizeof(indx_t);
+    cASSERT(mc, node_bytes == leaf_size(mc->mc_txn->mt_env, key, data));
   }
-  cASSERT(mc, node_bytes == leaf_size(mc->mc_txn->mt_env, key, data));
 
   /* Move higher pointers up one slot. */
   const size_t nkeys = page_numkeys(mp);
@@ -22886,7 +22922,8 @@ __cold static int page_check(MDBX_cursor *const mc, const MDBX_page *const mp) {
               "big-node data size (%zu) <> min/max value-length (%zu/%zu)\n",
               dsize, mc->mc_dbx->md_vlen_min, mc->mc_dbx->md_vlen_max);
         if (unlikely(node_size_len(node_ks(node), dsize) <=
-                     mc->mc_txn->mt_env->me_leaf_nodemax))
+                     mc->mc_txn->mt_env->me_leaf_nodemax) &&
+            mc->mc_dbi != FREE_DBI)
           poor_page(mp, "too small data (%zu bytes) for bigdata-node", dsize);
 
         if ((mc->mc_checking & CC_RETIRING) == 0) {
@@ -22901,7 +22938,7 @@ __cold static int page_check(MDBX_cursor *const mc, const MDBX_page *const mp) {
               rc = bad_page(lp.page,
                             "too less n-pages %u for bigdata-node (%zu bytes)",
                             lp.page->mp_pages, dsize);
-            else
+            else if (mc->mc_dbi != FREE_DBI)
               poor_page(lp.page,
                         "extra n-pages %u for bigdata-node (%zu bytes)",
                         lp.page->mp_pages, dsize);
@@ -23327,7 +23364,7 @@ static int page_split(MDBX_cursor *mc, const MDBX_val *const newkey,
   int rc = MDBX_SUCCESS, foliage = 0;
   size_t i, ptop;
   MDBX_env *const env = mc->mc_txn->mt_env;
-  MDBX_val sepkey, rkey, xdata;
+  MDBX_val rkey, xdata;
   MDBX_page *tmp_ki_copy = NULL;
   DKBUF;
 
@@ -23419,6 +23456,7 @@ static int page_split(MDBX_cursor *mc, const MDBX_val *const newkey,
   eASSERT(env, split_indx >= minkeys && split_indx <= nkeys - minkeys + 1);
 
   cASSERT(mc, !IS_BRANCH(mp) || newindx > 0);
+  MDBX_val sepkey = {nullptr, 0};
   /* It is reasonable and possible to split the page at the begin */
   if (unlikely(newindx < minkeys)) {
     split_indx = minkeys;
@@ -23751,7 +23789,7 @@ static int page_split(MDBX_cursor *mc, const MDBX_val *const newkey,
           break;
         }
     }
-  } else if (!IS_LEAF2(mp)) {
+  } else if (tmp_ki_copy /* !IS_LEAF2(mp) */) {
     /* Move nodes */
     mc->mc_pg[mc->mc_top] = sister;
     i = split_indx;
@@ -25053,7 +25091,7 @@ __cold static int fetch_envinfo_ex(const MDBX_env *env, const MDBX_txn *txn,
   const size_t size_before_pgop_stat = offsetof(MDBX_envinfo, mi_pgop_stat);
 
   /* is the environment open?
-   * (https://web.archive.org/web/https://github.com/erthink/libmdbx/issues/171) */
+   * (https://libmdbx.dqdkfa.ru/dead-github/issues/171) */
   if (unlikely(!env->me_map)) {
     /* environment not yet opened */
 #if 1
@@ -27864,7 +27902,7 @@ __cold int mdbx_env_warmup(const MDBX_env *env, const MDBX_txn *txn,
     if (getrlimit(RLIMIT_RSS, &rss) == 0 && rss.rlim_cur < estimated_rss) {
       rss.rlim_cur = estimated_rss;
       if (rss.rlim_max < estimated_rss)
-        rss.rlim_max = used_range;
+        rss.rlim_max = estimated_rss;
       if (setrlimit(RLIMIT_RSS, &rss)) {
         rc = errno;
         WARNING("setrlimit(%s, {%zu, %zu}) error %d", "RLIMIT_RSS",
@@ -29696,7 +29734,7 @@ MDBX_INTERNAL_FUNC int osal_openfile(const enum osal_openfile_purpose purpose,
   flags |= O_CLOEXEC;
 #endif /* O_CLOEXEC */
 
-  /* Safeguard for https://web.archive.org/web/https://github.com/erthink/libmdbx/issues/144 */
+  /* Safeguard for https://libmdbx.dqdkfa.ru/dead-github/issues/144 */
 #if STDIN_FILENO == 0 && STDOUT_FILENO == 1 && STDERR_FILENO == 2
   int stub_fd0 = -1, stub_fd1 = -1, stub_fd2 = -1;
   static const char dev_null[] = "/dev/null";
@@ -29734,7 +29772,7 @@ MDBX_INTERNAL_FUNC int osal_openfile(const enum osal_openfile_purpose purpose,
       errno = EACCES /* restore errno if file exists */;
   }
 
-  /* Safeguard for https://web.archive.org/web/https://github.com/erthink/libmdbx/issues/144 */
+  /* Safeguard for https://libmdbx.dqdkfa.ru/dead-github/issues/144 */
 #if STDIN_FILENO == 0 && STDOUT_FILENO == 1 && STDERR_FILENO == 2
   if (*fd == STDIN_FILENO) {
     WARNING("Got STD%s_FILENO/%d, avoid using it by dup(fd)", "IN",
@@ -30091,10 +30129,15 @@ MDBX_INTERNAL_FUNC int osal_msync(const osal_mmap_t *map, size_t offset,
     return (int)GetLastError();
 #else
 #if defined(__linux__) || defined(__gnu_linux__)
-  assert(linux_kernel_version > 0x02061300);
   /* Since Linux 2.6.19, MS_ASYNC is in fact a no-op. The kernel properly
-   * tracks dirty pages and flushes them to storage as necessary. */
-  return MDBX_SUCCESS;
+   * tracks dirty pages and flushes ones as necessary. */
+  //
+  // However, this behavior may be changed in custom kernels,
+  // so just leave such optimization to the libc discretion.
+  //
+  // assert(linux_kernel_version > 0x02061300);
+  // if (mode_bits == MDBX_SYNC_NONE)
+  //   return MDBX_SUCCESS;
 #endif /* Linux */
   if (msync(ptr, length, (mode_bits & MDBX_SYNC_DATA) ? MS_SYNC : MS_ASYNC))
     return errno;
@@ -30577,7 +30620,7 @@ MDBX_INTERNAL_FUNC int osal_munmap(osal_mmap_t *map) {
   VALGRIND_MAKE_MEM_NOACCESS(map->address, map->current);
   /* Unpoisoning is required for ASAN to avoid false-positive diagnostic
    * when this memory will re-used by malloc or another mmapping.
-   * See https://web.archive.org/web/https://github.com/erthink/libmdbx/pull/93#issuecomment-613687203
+   * See https://libmdbx.dqdkfa.ru/dead-github/pull/93#issuecomment-613687203
    */
   MDBX_ASAN_UNPOISON_MEMORY_REGION(map->address,
                                    (map->filesize && map->filesize < map->limit)
@@ -30656,7 +30699,7 @@ MDBX_INTERNAL_FUNC int osal_mresize(const int flags, osal_mmap_t *map,
 
   /* Unpoisoning is required for ASAN to avoid false-positive diagnostic
    * when this memory will re-used by malloc or another mmapping.
-   * See https://web.archive.org/web/https://github.com/erthink/libmdbx/pull/93#issuecomment-613687203
+   * See https://libmdbx.dqdkfa.ru/dead-github/pull/93#issuecomment-613687203
    */
   MDBX_ASAN_UNPOISON_MEMORY_REGION(map->address, map->limit);
   status = NtUnmapViewOfSection(GetCurrentProcess(), map->address);
@@ -30937,7 +30980,7 @@ retry_mapview:;
         /* Unpoisoning is required for ASAN to avoid false-positive diagnostic
          * when this memory will re-used by malloc or another mmapping.
          * See
-         * https://web.archive.org/web/https://github.com/erthink/libmdbx/pull/93#issuecomment-613687203
+         * https://libmdbx.dqdkfa.ru/dead-github/pull/93#issuecomment-613687203
          */
         MDBX_ASAN_UNPOISON_MEMORY_REGION(
             map->address,
@@ -30959,7 +31002,7 @@ retry_mapview:;
     /* Unpoisoning is required for ASAN to avoid false-positive diagnostic
      * when this memory will re-used by malloc or another mmapping.
      * See
-     * https://web.archive.org/web/https://github.com/erthink/libmdbx/pull/93#issuecomment-613687203
+     * https://libmdbx.dqdkfa.ru/dead-github/pull/93#issuecomment-613687203
      */
     MDBX_ASAN_UNPOISON_MEMORY_REGION(
         map->address, (map->current < map->limit) ? map->current : map->limit);
@@ -31782,9 +31825,9 @@ __dll_export
         0,
         12,
         2,
-        0,
-        {"2022-11-11T17:35:32+03:00", "cd8aa216aff5c70b45bd3afd46d417a95126dcc3", "9b062cf0c7d41297f756c7f7b897ed981022bdbf",
-         "v0.12.2-0-g9b062cf0"},
+        18,
+        {"2022-11-28T15:45:29+03:00", "9558651eb24ab172a73a7bc6149cadad4c4df990", "b3248442962cfdda728656d6d9085147a7d42b63",
+         "v0.12.2-18-gb3248442"},
         sourcery};
 
 __dll_export