diff --git a/.gitignore b/.gitignore
index 86d062a..9648517 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,5 +3,4 @@ compile_commands.json
 # LSP keeps state here
 .cache
 # typical build directories
-build
-ccov
+.build*
diff --git a/CMakeLists.txt b/CMakeLists.txt
index bcb080d..e9176ee 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -6,8 +6,7 @@ project(refcnt VERSION 0.1)
 enable_language(CXX)
 
 # common XO cmake macros (see proj/xo-cmake)
-include(xo_macros/xo_cxx)
-include(xo_macros/code-coverage)
+include(cmake/xo-bootstrap-macros.cmake)
 
 # ----------------------------------------------------------------
 # unit test setup
diff --git a/cmake/xo-bootstrap-macros.cmake b/cmake/xo-bootstrap-macros.cmake
new file mode 100644
index 0000000..1664443
--- /dev/null
+++ b/cmake/xo-bootstrap-macros.cmake
@@ -0,0 +1,12 @@
+if (("${CMAKE_MODULE_PATH}" STREQUAL "") OR ("${CMAKE_MODULE_PATH}" STREQUAL "prefix"))
+    # default to typical install location for xo-project-macros
+    set(CMAKE_MODULE_PATH ${CMAKE_INSTALL_PREFIX}/share/cmake)
+endif()
+
+message("-- CMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}")
+message("-- CMAKE_MODULE_PATH=${CMAKE_MODULE_PATH}")
+
+# needs to have been installed somewhere on CMAKE_MODULE_PATH,
+# (e.g. from xo-cmake with the same value for CMAKE_INSTALL_PREFIX)
+#
+include(xo_macros/xo-project-macros)
diff --git a/utest/intrusive_ptr.test.cpp b/utest/intrusive_ptr.test.cpp
index bc45d38..890832b 100644
--- a/utest/intrusive_ptr.test.cpp
+++ b/utest/intrusive_ptr.test.cpp
@@ -7,295 +7,295 @@
 #include <type_traits>
 
 namespace xo {
-  using xo::ref::Refcount;
-  using xo::ref::Borrow;
-  using xo::ref::rp;
-  using xo::ref::brw;
-  using xo::ref::intrusive_ptr_refcount;
-  using xo::ref::intrusive_ptr_add_ref;
-  using xo::ref::intrusive_ptr_release;
+    using xo::ref::Refcount;
+    using xo::ref::Borrow;
+    using xo::ref::rp;
+    using xo::ref::brw;
+    using xo::ref::intrusive_ptr_refcount;
+    using xo::ref::intrusive_ptr_add_ref;
+    using xo::ref::intrusive_ptr_release;
 
-  namespace ut {
-    namespace {
-      static uint32_t ctor_count = 0;
-      static uint32_t dtor_count = 0;
+    namespace ut {
+        namespace {
+            static uint32_t ctor_count = 0;
+            static uint32_t dtor_count = 0;
 
-      /* empty object,  except for refcount */
-      class JustRefcount : public ref::Refcount {
-      public:
-    JustRefcount() { ++ctor_count; }
-    ~JustRefcount() { ++dtor_count; }
-      }; /*JustRefcount*/
+            /* empty object,  except for refcount */
+            class JustRefcount : public ref::Refcount {
+            public:
+                JustRefcount() { ++ctor_count; }
+                ~JustRefcount() { ++dtor_count; }
+            }; /*JustRefcount*/
 
-      inline std::ostream & operator<<(std::ostream & os, JustRefcount & x) {
-    os << "JustRefcount";
-    return os;
-      } /*operator<<*/
-    } /*namespace*/
+            inline std::ostream & operator<<(std::ostream & os, JustRefcount & x) {
+                os << "JustRefcount";
+                return os;
+            } /*operator<<*/
+        } /*namespace*/
 
-    TEST_CASE("refcount", "[refcnt][trivial]") {
-      REQUIRE(std::is_default_constructible<ref::Refcount>() == true);
-      REQUIRE(std::has_virtual_destructor<ref::Refcount>() == true);
+        TEST_CASE("refcount", "[refcnt][trivial]") {
+            REQUIRE(std::is_default_constructible<ref::Refcount>() == true);
+            REQUIRE(std::has_virtual_destructor<ref::Refcount>() == true);
 
-      /* refcount object self-initializes to 0 */
-      Refcount x;
-      REQUIRE(x.reference_counter() == 0);
-    } /*TEST_CASE(refcount)*/
+            /* refcount object self-initializes to 0 */
+            Refcount x;
+            REQUIRE(x.reference_counter() == 0);
+        } /*TEST_CASE(refcount)*/
 
-    TEST_CASE("null-intrusive-ptr", "[refcnt][trivial]") {
-      //constexpr std::string_view c_self = "TEST_CASE:null-intrusive-ptr";
+        TEST_CASE("null-intrusive-ptr", "[refcnt][trivial]") {
+            //constexpr std::string_view c_self = "TEST_CASE:null-intrusive-ptr";
 
-      REQUIRE(std::has_virtual_destructor<JustRefcount>() == true);
+            REQUIRE(std::has_virtual_destructor<JustRefcount>() == true);
 
-      rp<JustRefcount> p1;
-      rp<JustRefcount> p2;
+            rp<JustRefcount> p1;
+            rp<JustRefcount> p2;
 
-      REQUIRE(sizeof(p1) == sizeof(JustRefcount*));
+            REQUIRE(sizeof(p1) == sizeof(JustRefcount*));
 
-      REQUIRE(p1.get() == nullptr);
-      REQUIRE(p1.operator->() == nullptr);
+            REQUIRE(p1.get() == nullptr);
+            REQUIRE(p1.operator->() == nullptr);
 
-      REQUIRE(p2.get() == nullptr);
-      REQUIRE(p2.operator->() == nullptr);
+            REQUIRE(p2.get() == nullptr);
+            REQUIRE(p2.operator->() == nullptr);
 
-      /* can assign a nullptr */
-      rp<JustRefcount> p3;
+            /* can assign a nullptr */
+            rp<JustRefcount> p3;
 
-      REQUIRE(p3.get() == nullptr);
-      p3 = p1;
-      REQUIRE(p3.get() == nullptr);
+            REQUIRE(p3.get() == nullptr);
+            p3 = p1;
+            REQUIRE(p3.get() == nullptr);
 
-      /* can use aux functions on null pointers */
-      REQUIRE(intrusive_ptr_refcount(p1.get()) == 0);
+            /* can use aux functions on null pointers */
+            REQUIRE(intrusive_ptr_refcount(p1.get()) == 0);
 
-      intrusive_ptr_add_ref(nullptr);
-      intrusive_ptr_release(nullptr);
+            intrusive_ptr_add_ref(nullptr);
+            intrusive_ptr_release(nullptr);
 
-      /* can borrow a null intrusive_ptr */
-      brw<JustRefcount> p1_brw = p1.borrow();
-      brw<JustRefcount> p2_brw = p2.borrow();
+            /* can borrow a null intrusive_ptr */
+            brw<JustRefcount> p1_brw = p1.borrow();
+            brw<JustRefcount> p2_brw = p2.borrow();
 
-      REQUIRE(p1_brw.get() == nullptr);
-      REQUIRE(p1_brw.operator->() == nullptr);
-      /* null borrow is false-y */
-      REQUIRE(p1_brw == false);
+            REQUIRE(p1_brw.get() == nullptr);
+            REQUIRE(p1_brw.operator->() == nullptr);
+            /* null borrow is false-y */
+            REQUIRE(p1_brw == false);
 
-      /* can promote a borrowed pointer */
-      rp<JustRefcount> pp = p1_brw.promote();
+            /* can promote a borrowed pointer */
+            rp<JustRefcount> pp = p1_brw.promote();
 
-      REQUIRE(p1.get() == pp.get());
+            REQUIRE(p1.get() == pp.get());
 
-      /* comparisons */
-      REQUIRE(Borrow<JustRefcount>::compare(p1_brw, p2_brw) == 0);
-      REQUIRE(p1_brw == p2_brw);
-      REQUIRE((p1_brw != p2_brw) == false);
-      REQUIRE(p1 == p1_brw);
-      REQUIRE((p1 != p1_brw) == false);
-      REQUIRE(p1_brw == p1);
-      REQUIRE((p1_brw != p1) == false);
-    } /*TEST_CASE(null-intrusive_ptr)*/
+            /* comparisons */
+            REQUIRE(Borrow<JustRefcount>::compare(p1_brw, p2_brw) == 0);
+            REQUIRE(p1_brw == p2_brw);
+            REQUIRE((p1_brw != p2_brw) == false);
+            REQUIRE(p1 == p1_brw);
+            REQUIRE((p1 != p1_brw) == false);
+            REQUIRE(p1_brw == p1);
+            REQUIRE((p1_brw != p1) == false);
+        } /*TEST_CASE(null-intrusive_ptr)*/
 
-    TEST_CASE("intrusive-ptr-identity", "[refcnt][identity]")
-    {
-      uint32_t cc = ctor_count;
-      uint32_t dc = dtor_count;
+        TEST_CASE("intrusive-ptr-identity", "[refcnt][identity]")
+        {
+            uint32_t cc = ctor_count;
+            uint32_t dc = dtor_count;
 
-      rp<JustRefcount> p1(new JustRefcount());
+            rp<JustRefcount> p1(new JustRefcount());
 
-      REQUIRE(ctor_count == cc + 1);
-      REQUIRE(dtor_count == dc);
-      REQUIRE(p1.get() != nullptr);
-      REQUIRE(p1.get() == p1.operator->());
-      REQUIRE(intrusive_ptr_refcount(p1.get()) == 1);
-      REQUIRE(p1->reference_counter() == 1);
+            REQUIRE(ctor_count == cc + 1);
+            REQUIRE(dtor_count == dc);
+            REQUIRE(p1.get() != nullptr);
+            REQUIRE(p1.get() == p1.operator->());
+            REQUIRE(intrusive_ptr_refcount(p1.get()) == 1);
+            REQUIRE(p1->reference_counter() == 1);
 
-      intrusive_ptr_add_ref(p1.get());
+            intrusive_ptr_add_ref(p1.get());
 
-      REQUIRE(intrusive_ptr_refcount(p1.get()) == 2);
+            REQUIRE(intrusive_ptr_refcount(p1.get()) == 2);
 
-      intrusive_ptr_release(p1.get());
+            intrusive_ptr_release(p1.get());
 
-      REQUIRE(intrusive_ptr_refcount(p1.get()) == 1);
+            REQUIRE(intrusive_ptr_refcount(p1.get()) == 1);
 
-      REQUIRE(ctor_count == cc + 1);
-      REQUIRE(dtor_count == dc);
+            REQUIRE(ctor_count == cc + 1);
+            REQUIRE(dtor_count == dc);
 
-      rp<JustRefcount> p2(new JustRefcount());
+            rp<JustRefcount> p2(new JustRefcount());
 
-      REQUIRE(ctor_count == cc + 2);
-      REQUIRE(dtor_count == dc);
+            REQUIRE(ctor_count == cc + 2);
+            REQUIRE(dtor_count == dc);
 
-      REQUIRE(p2.get() != nullptr);
-      REQUIRE(p2.get() != p1.get());
-      REQUIRE(p2.get() == p2.operator->());
-      REQUIRE(p2->reference_counter() == 1);
+            REQUIRE(p2.get() != nullptr);
+            REQUIRE(p2.get() != p1.get());
+            REQUIRE(p2.get() == p2.operator->());
+            REQUIRE(p2->reference_counter() == 1);
 
-      /* can borrow a non-null intrusive-ptr */
-      brw<JustRefcount> p1_brw = p1.borrow();
+            /* can borrow a non-null intrusive-ptr */
+            brw<JustRefcount> p1_brw = p1.borrow();
 
-      REQUIRE(p1_brw.get() == p1.get());
+            REQUIRE(p1_brw.get() == p1.get());
 
-      /* borrowing does not change refcount,  borrow not tracked */
-      REQUIRE(ctor_count == cc + 2);
-      REQUIRE(dtor_count == dc);
-      REQUIRE(p1.get()->reference_counter() == 1);
+            /* borrowing does not change refcount,  borrow not tracked */
+            REQUIRE(ctor_count == cc + 2);
+            REQUIRE(dtor_count == dc);
+            REQUIRE(p1.get()->reference_counter() == 1);
 
-      /* copying borrowed pointer does not touch refcount */
-      brw<JustRefcount> p1_brw2 = p1_brw;
+            /* copying borrowed pointer does not touch refcount */
+            brw<JustRefcount> p1_brw2 = p1_brw;
 
-      REQUIRE(ctor_count == cc + 2);
-      REQUIRE(dtor_count == dc);
-      REQUIRE(p1_brw2.get() == p1.get());
+            REQUIRE(ctor_count == cc + 2);
+            REQUIRE(dtor_count == dc);
+            REQUIRE(p1_brw2.get() == p1.get());
 
-      REQUIRE(p1.get()->reference_counter() == 1);
-    } /*TEST_CASE(identity-intrusive-ptr)*/
+            REQUIRE(p1.get()->reference_counter() == 1);
+        } /*TEST_CASE(identity-intrusive-ptr)*/
 
-    TEST_CASE("intrusive-ptr-release", "[refcnt][release]")
-    {
-      uint32_t cc = ctor_count;
-      uint32_t dc = dtor_count;
+        TEST_CASE("intrusive-ptr-release", "[refcnt][release]")
+        {
+            uint32_t cc = ctor_count;
+            uint32_t dc = dtor_count;
 
-      rp<JustRefcount> p1(new JustRefcount());
+            rp<JustRefcount> p1(new JustRefcount());
 
-      REQUIRE(ctor_count == cc + 1);
-      REQUIRE(dtor_count == dc);
-      REQUIRE(p1.get() != nullptr);
-      REQUIRE(p1->reference_counter() == 1);
+            REQUIRE(ctor_count == cc + 1);
+            REQUIRE(dtor_count == dc);
+            REQUIRE(p1.get() != nullptr);
+            REQUIRE(p1->reference_counter() == 1);
 
-      /* reference count going to 0 -> delete object */
-      p1 = nullptr;
+            /* reference count going to 0 -> delete object */
+            p1 = nullptr;
 
-      REQUIRE(p1.get() == nullptr);
-      REQUIRE(ctor_count == cc + 1);
-      REQUIRE(dtor_count == dc + 1);
-    } /*TEST_CASE(intrusive-ptr-release)*/
+            REQUIRE(p1.get() == nullptr);
+            REQUIRE(ctor_count == cc + 1);
+            REQUIRE(dtor_count == dc + 1);
+        } /*TEST_CASE(intrusive-ptr-release)*/
 
-    TEST_CASE("intrusive-ptr-copy", "[refcnt][copy]")
-    {
-      uint32_t cc = ctor_count;
-      uint32_t dc = dtor_count;
+        TEST_CASE("intrusive-ptr-copy", "[refcnt][copy]")
+        {
+            uint32_t cc = ctor_count;
+            uint32_t dc = dtor_count;
 
-      rp<JustRefcount> p1(new JustRefcount());
-      JustRefcount * p1_native = p1.get();
+            rp<JustRefcount> p1(new JustRefcount());
+            JustRefcount * p1_native = p1.get();
 
-      REQUIRE(ctor_count == cc + 1);
-      REQUIRE(dtor_count == dc);
-      REQUIRE(p1.get() != nullptr);
-      REQUIRE(p1->reference_counter() == 1);
+            REQUIRE(ctor_count == cc + 1);
+            REQUIRE(dtor_count == dc);
+            REQUIRE(p1.get() != nullptr);
+            REQUIRE(p1->reference_counter() == 1);
 
-      /* copy ctor ran to make copy of p1,  did not allocate */
-      rp<JustRefcount> p2(p1);
+            /* copy ctor ran to make copy of p1,  did not allocate */
+            rp<JustRefcount> p2(p1);
 
-      REQUIRE(p1->reference_counter() == 2);
-      REQUIRE(ctor_count == cc + 1);
-      REQUIRE(dtor_count == dc);
+            REQUIRE(p1->reference_counter() == 2);
+            REQUIRE(ctor_count == cc + 1);
+            REQUIRE(dtor_count == dc);
 
-    } /*TEST_CASE(intrusive-ptr-copy)*/
+        } /*TEST_CASE(intrusive-ptr-copy)*/
 
-    TEST_CASE("intrusive-ptr-move", "[refcnt][move]")
-    {
-      uint32_t cc = ctor_count;
-      uint32_t dc = dtor_count;
+        TEST_CASE("intrusive-ptr-move", "[refcnt][move]")
+        {
+            uint32_t cc = ctor_count;
+            uint32_t dc = dtor_count;
 
-      rp<JustRefcount> p1(new JustRefcount());
-      JustRefcount * p1_native = p1.get();
+            rp<JustRefcount> p1(new JustRefcount());
+            JustRefcount * p1_native = p1.get();
 
-      REQUIRE(ctor_count == cc + 1);
-      REQUIRE(dtor_count == dc);
-      REQUIRE(p1.get() != nullptr);
-      REQUIRE(p1->reference_counter() == 1);
+            REQUIRE(ctor_count == cc + 1);
+            REQUIRE(dtor_count == dc);
+            REQUIRE(p1.get() != nullptr);
+            REQUIRE(p1->reference_counter() == 1);
 
-      rp<JustRefcount> p2{std::move(p1)};
+            rp<JustRefcount> p2{std::move(p1)};
 
-      REQUIRE(p2->reference_counter() == 1);
-      REQUIRE(ctor_count == cc + 1);
-      REQUIRE(dtor_count == dc);
+            REQUIRE(p2->reference_counter() == 1);
+            REQUIRE(ctor_count == cc + 1);
+            REQUIRE(dtor_count == dc);
 
-      p2 = nullptr;
+            p2 = nullptr;
 
-      REQUIRE(ctor_count == cc + 1);
-      REQUIRE(dtor_count == dc + 1);
-    } /*TEST_CASE(intrusive-ptr-move)*/
+            REQUIRE(ctor_count == cc + 1);
+            REQUIRE(dtor_count == dc + 1);
+        } /*TEST_CASE(intrusive-ptr-move)*/
 
-    TEST_CASE("instrusive-ptr-assign", "[refcnt][assign]")
-    {
-      uint32_t cc = ctor_count;
-      uint32_t dc = dtor_count;
+        TEST_CASE("instrusive-ptr-assign", "[refcnt][assign]")
+        {
+            uint32_t cc = ctor_count;
+            uint32_t dc = dtor_count;
 
-      rp<JustRefcount> p1(new JustRefcount());
-      JustRefcount * p1_native = p1.get();
+            rp<JustRefcount> p1(new JustRefcount());
+            JustRefcount * p1_native = p1.get();
 
-      REQUIRE(ctor_count == cc + 1);
-      REQUIRE(dtor_count == dc);
-      REQUIRE(p1.get() != nullptr);
-      REQUIRE(p1->reference_counter() == 1);
+            REQUIRE(ctor_count == cc + 1);
+            REQUIRE(dtor_count == dc);
+            REQUIRE(p1.get() != nullptr);
+            REQUIRE(p1->reference_counter() == 1);
 
-      rp<JustRefcount> p2;
+            rp<JustRefcount> p2;
 
-      REQUIRE(p2.get() == nullptr);
-      REQUIRE(ctor_count == cc + 1);
-      REQUIRE(dtor_count == dc);
+            REQUIRE(p2.get() == nullptr);
+            REQUIRE(ctor_count == cc + 1);
+            REQUIRE(dtor_count == dc);
 
-      p2 = p1;
+            p2 = p1;
 
-      REQUIRE(p2.get() == p1.get());
-      REQUIRE(p2->reference_counter() == 2);
+            REQUIRE(p2.get() == p1.get());
+            REQUIRE(p2->reference_counter() == 2);
 
-      REQUIRE(ctor_count == cc + 1);
-      REQUIRE(dtor_count == dc);
+            REQUIRE(ctor_count == cc + 1);
+            REQUIRE(dtor_count == dc);
 
-      p1 = nullptr;
+            p1 = nullptr;
 
-      REQUIRE(p2->reference_counter() == 1);
-      REQUIRE(ctor_count == cc + 1);
-      REQUIRE(dtor_count == dc);
+            REQUIRE(p2->reference_counter() == 1);
+            REQUIRE(ctor_count == cc + 1);
+            REQUIRE(dtor_count == dc);
 
-      p2 = nullptr;
+            p2 = nullptr;
 
-      REQUIRE(ctor_count == cc + 1);
-      REQUIRE(dtor_count == dc + 1);
-    } /*TEST_CASE(intrusive-ptr-assign)*/
+            REQUIRE(ctor_count == cc + 1);
+            REQUIRE(dtor_count == dc + 1);
+        } /*TEST_CASE(intrusive-ptr-assign)*/
 
-    TEST_CASE("intrusive-ptr-move-assign", "[refcnt][move-assign]")
-    {
-      uint32_t cc = ctor_count;
-      uint32_t dc = dtor_count;
+        TEST_CASE("intrusive-ptr-move-assign", "[refcnt][move-assign]")
+        {
+            uint32_t cc = ctor_count;
+            uint32_t dc = dtor_count;
 
-      rp<JustRefcount> p1(new JustRefcount());
-      JustRefcount * p1_native = p1.get();
+            rp<JustRefcount> p1(new JustRefcount());
+            JustRefcount * p1_native = p1.get();
 
-      REQUIRE(ctor_count == cc + 1);
-      REQUIRE(dtor_count == dc);
-      REQUIRE(p1.get() != nullptr);
-      REQUIRE(p1->reference_counter() == 1);
+            REQUIRE(ctor_count == cc + 1);
+            REQUIRE(dtor_count == dc);
+            REQUIRE(p1.get() != nullptr);
+            REQUIRE(p1->reference_counter() == 1);
 
-      rp<JustRefcount> p2;
+            rp<JustRefcount> p2;
 
-      REQUIRE(p2.get() == nullptr);
-      REQUIRE(ctor_count == cc + 1);
-      REQUIRE(dtor_count == dc);
+            REQUIRE(p2.get() == nullptr);
+            REQUIRE(ctor_count == cc + 1);
+            REQUIRE(dtor_count == dc);
 
-      p2 = std::move(p1);
+            p2 = std::move(p1);
 
-      REQUIRE(p1.get() == nullptr);
-      REQUIRE(p2.get() == p1_native);
-      REQUIRE(p2->reference_counter() == 1);
+            REQUIRE(p1.get() == nullptr);
+            REQUIRE(p2.get() == p1_native);
+            REQUIRE(p2->reference_counter() == 1);
 
-      REQUIRE(ctor_count == cc + 1);
-      REQUIRE(dtor_count == dc);
+            REQUIRE(ctor_count == cc + 1);
+            REQUIRE(dtor_count == dc);
 
-      p1 = nullptr; /*no-op*/
+            p1 = nullptr; /*no-op*/
 
-      REQUIRE(p2->reference_counter() == 1);
-      REQUIRE(ctor_count == cc + 1);
-      REQUIRE(dtor_count == dc);
+            REQUIRE(p2->reference_counter() == 1);
+            REQUIRE(ctor_count == cc + 1);
+            REQUIRE(dtor_count == dc);
 
-      p2 = nullptr;
+            p2 = nullptr;
 
-      REQUIRE(ctor_count == cc + 1);
-      REQUIRE(dtor_count == dc + 1);
-    } /*TEST_CASE(intrusive-ptr-move-assign)*/
-  } /*namespace ut*/
+            REQUIRE(ctor_count == cc + 1);
+            REQUIRE(dtor_count == dc + 1);
+        } /*TEST_CASE(intrusive-ptr-move-assign)*/
+    } /*namespace ut*/
 } /*namespace xo*/
 
 /* end intrusive_ptr.test.cpp */