diff --git a/src/mdbx.c b/src/mdbx.c
index 1351cdb4..56f52dc0 100644
--- a/src/mdbx.c
+++ b/src/mdbx.c
@@ -2127,9 +2127,9 @@ static int mdbx_mapresize(MDBX_env *env, const pgno_t size_pgno,
 bailout:
   if (rc == MDBX_SUCCESS) {
 #if defined(_WIN32) || defined(_WIN64)
-    assert(size_bytes == env->me_dxb_mmap.current);
-    assert(size_bytes <= env->me_dxb_mmap.filesize);
-    assert(limit_bytes == env->me_dxb_mmap.length);
+    mdbx_assert(env, size_bytes == env->me_dxb_mmap.current);
+    mdbx_assert(env, size_bytes <= env->me_dxb_mmap.filesize);
+    mdbx_assert(env, limit_bytes == env->me_dxb_mmap.length);
 #endif
     env->me_dbgeo.now = size_bytes;
     env->me_dbgeo.upper = limit_bytes;
@@ -2232,7 +2232,7 @@ static int mdbx_page_alloc(MDBX_cursor *mc, unsigned num, MDBX_page **mp,
 
   if (likely(flags & MDBX_ALLOC_CACHE)) {
     /* If there are any loose pages, just use them */
-    assert(mp && num);
+    mdbx_assert(env, mp && num);
     if (likely(num == 1 && txn->mt_loose_pages)) {
       np = txn->mt_loose_pages;
       txn->mt_loose_pages = NEXT_LOOSE_PAGE(np);
@@ -2563,7 +2563,7 @@ static int mdbx_page_alloc(MDBX_cursor *mc, unsigned num, MDBX_page **mp,
       *mp = NULL;
       txn->mt_flags |= MDBX_TXN_ERROR;
     }
-    assert(rc);
+    mdbx_assert(env, rc != MDBX_SUCCESS);
     return rc;
   }
 
@@ -2841,7 +2841,7 @@ static int mdbx_env_sync_ex(MDBX_env *env, int force, int nonblock) {
         env->me_sync_pending >
             pgno2bytes(env, 16 /* FIXME: define threshold */) &&
         (flags & MDBX_NOSYNC) == 0) {
-      assert(((flags ^ env->me_flags) & MDBX_WRITEMAP) == 0);
+      mdbx_assert(env, ((flags ^ env->me_flags) & MDBX_WRITEMAP) == 0);
       const size_t usedbytes = pgno_align2os_bytes(env, head->mm_geo.next);
 
       mdbx_txn_unlock(env);
@@ -3057,7 +3057,7 @@ static int mdbx_txn_renew0(MDBX_txn *txn, unsigned flags) {
       mdbx_rdt_unlock(env);
 
       if (likely(env->me_flags & MDBX_ENV_TXKEY)) {
-        assert(env->me_live_reader == env->me_pid);
+        mdbx_assert(env, env->me_live_reader == env->me_pid);
         mdbx_thread_rthc_set(env->me_txkey, r);
       }
     }
@@ -3176,7 +3176,7 @@ static int mdbx_txn_renew0(MDBX_txn *txn, unsigned flags) {
     return MDBX_SUCCESS;
   }
 bailout:
-  assert(rc != MDBX_SUCCESS);
+  mdbx_tassert(txn, rc != MDBX_SUCCESS);
   mdbx_txn_end(txn, MDBX_END_SLOT | MDBX_END_FAIL_BEGIN);
   return rc;
 }
@@ -3386,7 +3386,7 @@ static void mdbx_dbis_update(MDBX_txn *txn, int keep) {
         if (ptr) {
           env->me_dbxs[i].md_name.iov_len = 0;
           mdbx_compiler_barrier();
-          assert(env->me_dbflags[i] == 0);
+          mdbx_assert(env, env->me_dbflags[i] == 0);
           env->me_dbiseqs[i]++;
           env->me_dbxs[i].md_name.iov_base = NULL;
           free(ptr);
@@ -3506,8 +3506,8 @@ int mdbx_txn_reset(MDBX_txn *txn) {
   /* LY: don't close DBI-handles in MDBX mode */
   int rc = mdbx_txn_end(txn, MDBX_END_RESET | MDBX_END_UPDATE);
   if (rc == MDBX_SUCCESS) {
-    assert(txn->mt_signature == MDBX_MT_SIGNATURE);
-    assert(txn->mt_owner == 0);
+    mdbx_tassert(txn, txn->mt_signature == MDBX_MT_SIGNATURE);
+    mdbx_tassert(txn, txn->mt_owner == 0);
   }
   return rc;
 }
@@ -4360,7 +4360,7 @@ static int mdbx_page_flush(MDBX_txn *txn, pgno_t keep) {
         continue;
       }
       pgno = dl[i].pgno;
-      assert(pgno >= MIN_PAGENO);
+      mdbx_tassert(txn, pgno >= MIN_PAGENO);
       /* clear dirty flag */
       dp->mp_flags &= ~P_DIRTY;
       dp->mp_validator = 0 /* TODO */;
@@ -4731,7 +4731,7 @@ fail:
  * before mapping it into memory. */
 static int __cold mdbx_read_header(MDBX_env *env, MDBX_meta *meta,
                                    uint64_t *filesize) {
-  assert(offsetof(MDBX_page, mp_meta) == PAGEHDRSZ);
+  STATIC_ASSERT(offsetof(MDBX_page, mp_meta) == PAGEHDRSZ);
 
   int rc = mdbx_filesize(env->me_fd, filesize);
   if (unlikely(rc != MDBX_SUCCESS))
@@ -5907,7 +5907,7 @@ static int __cold mdbx_setup_dxb(MDBX_env *env, int lck_rc) {
       break;
 
     if (lck_rc == /* lck exclusive */ MDBX_RESULT_TRUE) {
-      assert(META_IS_STEADY(&meta) && !META_IS_STEADY(head));
+      mdbx_assert(env, META_IS_STEADY(&meta) && !META_IS_STEADY(head));
       if (env->me_flags & MDBX_RDONLY) {
         mdbx_error("rollback needed: (from head %" PRIaTXN
                    " to steady %" PRIaTXN "), but unable in read-only mode",
@@ -6041,8 +6041,8 @@ static int __cold mdbx_setup_dxb(MDBX_env *env, int lck_rc) {
 /* Open and/or initialize the lock region for the environment. */
 static int __cold mdbx_setup_lck(MDBX_env *env, char *lck_pathname,
                                  mode_t mode) {
-  assert(env->me_fd != INVALID_HANDLE_VALUE);
-  assert(env->me_lfd == INVALID_HANDLE_VALUE);
+  mdbx_assert(env, env->me_fd != INVALID_HANDLE_VALUE);
+  mdbx_assert(env, env->me_lfd == INVALID_HANDLE_VALUE);
 
   const int open_flags =
       (env->me_flags & MDBX_EXCLUSIVE) ? O_RDWR : O_RDWR | O_CREAT;
@@ -7767,7 +7767,7 @@ int mdbx_cursor_get(MDBX_cursor *mc, MDBX_val *key, MDBX_val *data,
       mc->mc_ki[mc->mc_top] = (uint16_t)nkeys;
       return MDBX_NOTFOUND;
     }
-    assert(nkeys > 0);
+    mdbx_cassert(mc, nkeys > 0);
 
     rc = MDBX_SUCCESS;
     if (IS_LEAF2(mp)) {
@@ -8391,7 +8391,7 @@ int mdbx_cursor_put(MDBX_cursor *mc, MDBX_val *key, MDBX_val *data,
       if ((rc2 = mdbx_ovpage_free(mc, omp)) != MDBX_SUCCESS)
         return rc2;
     } else if (data->iov_len == olddata.iov_len) {
-      assert(EVEN(key->iov_len) == EVEN(leaf->mn_ksize));
+      mdbx_cassert(mc, EVEN(key->iov_len) == EVEN(leaf->mn_ksize));
       /* same size, just replace it. Note that we could
        * also reuse this node if the new data is smaller,
        * but instead we opt to shrink the node in that case. */
@@ -8407,8 +8407,8 @@ int mdbx_cursor_put(MDBX_cursor *mc, MDBX_val *key, MDBX_val *data,
         mdbx_cassert(mc, key->iov_len < UINT16_MAX);
         leaf->mn_ksize = (uint16_t)key->iov_len;
         memcpy(NODEKEY(leaf), key->iov_base, key->iov_len);
-        assert((char *)NODEKEY(leaf) + NODEDSZ(leaf) <
-               (char *)(mc->mc_pg[mc->mc_top]) + env->me_psize);
+        mdbx_cassert(mc, (char *)NODEKEY(leaf) + NODEDSZ(leaf) <
+                             (char *)(mc->mc_pg[mc->mc_top]) + env->me_psize);
         goto fix_parent;
       }
 
@@ -11667,14 +11667,16 @@ static int mdbx_dbi_bind(MDBX_txn *txn, const MDBX_dbi dbi, unsigned user_flags,
   if (!txn->mt_dbxs[dbi].md_cmp || MDBX_DEBUG) {
     if (!keycmp)
       keycmp = mdbx_default_keycmp(user_flags);
-    assert(!txn->mt_dbxs[dbi].md_cmp || txn->mt_dbxs[dbi].md_cmp == keycmp);
+    mdbx_tassert(txn, !txn->mt_dbxs[dbi].md_cmp ||
+                          txn->mt_dbxs[dbi].md_cmp == keycmp);
     txn->mt_dbxs[dbi].md_cmp = keycmp;
   }
 
   if (!txn->mt_dbxs[dbi].md_dcmp || MDBX_DEBUG) {
     if (!datacmp)
       datacmp = mdbx_default_datacmp(user_flags);
-    assert(!txn->mt_dbxs[dbi].md_dcmp || txn->mt_dbxs[dbi].md_dcmp == datacmp);
+    mdbx_tassert(txn, !txn->mt_dbxs[dbi].md_dcmp ||
+                          txn->mt_dbxs[dbi].md_dcmp == datacmp);
     txn->mt_dbxs[dbi].md_dcmp = datacmp;
   }
 
@@ -11789,7 +11791,7 @@ int mdbx_dbi_open_ex(MDBX_txn *txn, const char *table_name, unsigned user_flags,
       if (env->me_dbflags[i] & MDBX_VALID) {
         txn->mt_dbs[i].md_flags = env->me_dbflags[i] & PERSISTENT_FLAGS;
         txn->mt_dbflags[i] = DB_VALID | DB_USRVALID | DB_STALE;
-        assert(txn->mt_dbxs[i].md_cmp != NULL);
+        mdbx_tassert(txn, txn->mt_dbxs[i].md_cmp != NULL);
       }
     }
     txn->mt_numdbs = env->me_numdbs;
@@ -11818,7 +11820,7 @@ int mdbx_dbi_open_ex(MDBX_txn *txn, const char *table_name, unsigned user_flags,
   MDBX_db db_dummy;
   if (unlikely(rc)) {
     /* MDBX_NOTFOUND and MDBX_CREATE: Create new DB */
-    assert(rc == MDBX_NOTFOUND);
+    mdbx_tassert(txn, rc == MDBX_NOTFOUND);
     memset(&db_dummy, 0, sizeof(db_dummy));
     db_dummy.md_root = P_INVALID;
     db_dummy.md_flags = user_flags & PERSISTENT_FLAGS;
@@ -11841,7 +11843,7 @@ int mdbx_dbi_open_ex(MDBX_txn *txn, const char *table_name, unsigned user_flags,
   env->me_dbflags[slot] = 0;
   rc = mdbx_dbi_bind(txn, slot, user_flags, keycmp, datacmp);
   if (unlikely(rc != MDBX_SUCCESS)) {
-    assert((dbflag & DB_CREAT) == 0);
+    mdbx_tassert(txn, (dbflag & DB_CREAT) == 0);
   bailout:
     free(namedup);
   } else {
@@ -12257,7 +12259,7 @@ int __cold mdbx_reader_check(MDBX_env *env, int *dead) {
  *  MDBX_SUCCESS     - done
  *  Otherwise errcode. */
 int __cold mdbx_reader_check0(MDBX_env *env, int rdt_locked, int *dead) {
-  assert(rdt_locked >= 0);
+  mdbx_assert(env, rdt_locked >= 0);
 
   if (unlikely(env->me_pid != mdbx_getpid())) {
     env->me_flags |= MDBX_FATAL_ERROR;
@@ -13173,7 +13175,7 @@ int mdbx_dbi_sequence(MDBX_txn *txn, MDBX_dbi dbi, uint64_t *result,
     if (unlikely(new < increment))
       return MDBX_RESULT_TRUE;
 
-    assert(new > dbs->md_seq);
+    mdbx_tassert(txn, new > dbs->md_seq);
     dbs->md_seq = new;
     txn->mt_flags |= MDBX_TXN_DIRTY;
     txn->mt_dbflags[dbi] |= DB_DIRTY;