diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7377db2c..a2ec4c63 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,6 +1,6 @@
 # -----------------------------------------------------------------------------------------
 # SPDX-License-Identifier: MIT
-# SPDX-FileCopyrightText: Copyright (C) 2024 Fix8 Market Technologies Pty Ltd
+# SPDX-FileCopyrightText: Copyright (C) 2024-25 Fix8 Market Technologies Pty Ltd
 # SPDX-FileType: SOURCE
 #
 # conjure_enum (header only)
@@ -28,79 +28,50 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 # ----------------------------------------------------------------------------------------
-cmake_minimum_required (VERSION 3.20)
+cmake_minimum_required (VERSION 3.21+)
+message(STATUS "CMake version ${CMAKE_VERSION}")
+include(cmake/buildutils.cmake)
 project (conjure_enum
    LANGUAGES CXX
-	HOMEPAGE_URL https://github.com/fix8mt/conjure_enum
+	HOMEPAGE_URL https://github.com/fix8mt/${PROJECT_NAME}
    DESCRIPTION "Lightweight C++20 enum and typename reflection"
-   VERSION 1.1.0)
+   VERSION 1.2.0)
 
-message("${CMAKE_PROJECT_NAME} version ${CMAKE_PROJECT_VERSION}")
-
-# to disable strip:
-# cmake -DBUILD_STRIP_EXE=false ..
-option(BUILD_STRIP_EXE "enable stripping of non-unittest executables" true)
-message("-- Build: strip exes ${BUILD_STRIP_EXE}")
-
-# to disable warnings:
-# cmake -DBUILD_ALL_WARNINGS=false ..
-option(BUILD_ALL_WARNINGS "enable building with all warnings" true)
-message("-- Build: with all warnings ${BUILD_ALL_WARNINGS}")
-
-# to disable building unit tests:
-# cmake -DBUILD_UNITTESTS=false ..
-option(BUILD_UNITTESTS "enable building unit tests" true)
-message("-- Build: unit tests ${BUILD_UNITTESTS}")
-
-# to enable clang build profiler:
-# cmake -DBUILD_CLANG_PROFILER=true ..
-# see examples/cbenchmark.sh
-option(BUILD_CLANG_PROFILER "enable clang build profiler" false)
-message("-- Build: clang profiler ${BUILD_CLANG_PROFILER}")
-if(BUILD_CLANG_PROFILER)
-	if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-		add_compile_options(-ftime-trace)
-	else()
-		message(WARNING "BUILD_CLANG_PROFILER only available with Clang")
-	endif()
+if(NOT MSVC)
+	fix8_setbuildtype(CONJURE_ENUM Release)
 endif()
+fix8_addoption("BUILD_UNITTESTS|enable building unit tests|true")
+fix8_addoption("BUILD_STRIP_EXE|enable stripping of non-unittest executables|true")
+fix8_addoption("BUILD_ALL_WARNINGS|enable building with all warnings|true")
+fix8_addoption("BUILD_CLANG_PROFILER|enable clang build profiler|false")
 
-function(build loc x)
-	add_executable(${x} ${loc}/${x}.cpp)
-	if(NOT ${x} STREQUAL srcloctest)
-		add_dependencies(${x} srcloctest) # srcloctest should be built even if errors with conjure_enum
-	endif()
-	set_target_properties(${x} PROPERTIES CXX_STANDARD 20 CXX_STANDARD_REQUIRED true)
-	target_include_directories(${x} PRIVATE include)
-	if(BUILD_ALL_WARNINGS)
-		target_compile_options(${x} PRIVATE
-			$<$<CXX_COMPILER_ID:MSVC>:/W4>
-			$<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-Wall -Wextra -Wpedantic>)
-	endif()
-	get_target_property(cppstd ${x} CXX_STANDARD)
-	message("-- adding ${x}.cpp CXX_STANDARD: C++${cppstd} (${CMAKE_CXX_COMPILER_ID})")
-endfunction()
-
-foreach(x srcloctest example statictest cbenchmark)
-	build(examples ${x})
+fix8_build(examples srcloctest 20)
+foreach(x example statictest cbenchmark)
+	fix8_build(examples ${x} 20)
+	add_dependencies(${x} srcloctest) # srcloctest should be built even if errors with conjure_enum
 	if(BUILD_STRIP_EXE)
 		add_custom_command(TARGET ${x} POST_BUILD COMMAND ${CMAKE_STRIP} ${x})
 	endif()
 endforeach()
 
+# make include visible to inheriting projects
+add_library(${PROJECT_NAME} INTERFACE)
+file(GLOB HEADER_FILES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/include/fix8/*.hpp")
+target_sources(${PROJECT_NAME} INTERFACE FILE_SET HEADERS FILES ${HEADER_FILES})
+install(TARGETS ${PROJECT_NAME} FILE_SET HEADERS DESTINATION .)
+target_include_directories(${PROJECT_NAME} INTERFACE
+	$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+	$<INSTALL_INTERFACE:include>)
+
 if(BUILD_UNITTESTS)
-	include(FetchContent)
-	FetchContent_Declare(Catch2
-		GIT_REPOSITORY https://github.com/catchorg/Catch2.git
-		GIT_SHALLOW ON
-		GIT_TAG devel)
-	FetchContent_MakeAvailable(Catch2)
+	fix8_fetch(Catch2 catchorg/Catch2 devel)
+	target_compile_features(Catch2 PRIVATE cxx_std_17)
+	add_dependencies(Catch2 srcloctest) # srcloctest should be built before building Catch2
 	list(APPEND CMAKE_MODULE_PATH ${catch2_SOURCE_DIR}/extras)
-	target_compile_features(Catch2 PRIVATE cxx_std_20)
 	include(Catch)
 	enable_testing()
 	foreach(x unittests edgetests)
-		build(utests ${x})
+		fix8_build(utests ${x} 20)
 		target_link_libraries(${x} PRIVATE Catch2::Catch2WithMain)
 		catch_discover_tests(${x})
 	endforeach()
diff --git a/README.md b/README.md
index 3c32ebec..48fee33f 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 <!-----------------------------------------------------------------------------------------
 // SPDX-License-Identifier: MIT
-// SPDX-FileCopyrightText: Copyright (C) 2024 Fix8 Market Technologies Pty Ltd
+// SPDX-FileCopyrightText: Copyright (C) 2024-25 Fix8 Market Technologies Pty Ltd
 // SPDX-FileType: DOCUMENTATION
 //
 // conjure_enum (header only)
@@ -65,7 +65,7 @@
 # 2. Introduction
 ## a) Supercharge Your C++ Enums with This Lightweight Reflection Library!
 
-Based on the awesome work in [`magic_enum`](https://github.com/Neargye/magic_enum)[^2] and [`boost::describe`](https://github.com/boostorg/describe),
+Based on some of the awesome work in [`magic_enum`](https://github.com/Neargye/magic_enum)[^2] and [`boost::describe`](https://github.com/boostorg/describe),
 this library offers a streamlined and powerful way to add reflection capabilities to your C++ enums and other types. We've optimized the core functionality,
 focusing on the main features developers usually want. We've also added general purpose typename reflection for any type.
 
@@ -126,7 +126,7 @@ template<T e>
 static constexpr std::string_view enum_to_string();
 ```
 Returns a `std::string_view` or empty if not found. Optionally passing `true` will remove scope in result if present.
-`noscope` option ![](assets/notminimalred.svg).
+![](assets/notminimalred.svg).
 ```c++
 auto name { conjure_enum<component>::enum_to_string(component::path) };
 auto name_trim { conjure_enum<component>::enum_to_string(component::path, true) }; // optionally remove scope in result
@@ -143,6 +143,11 @@ component::path
 path
 numbers::two
 ```
+
+> [!TIP]
+> For scoped enums, this method will return the fully qualified enum name (with the class prefix). If you want
+> to return the unscoped enum specify `true`
+
 ### Aliases
 Because all methods in `conjure_enum` are defined _within_ a `class` instead of individual template functions in a `namespace`, you can reduce your
 typing with standard aliases:
@@ -472,7 +477,7 @@ requires std::invocable<Fn&&, T, Args...>
 
 template<typename Fn, typename C, typename... Args> // specialisation for member function with object
 requires std::invocable<Fn&&, C, T, Args...>
-[[maybe_unused]] static constexpr auto for_each(Fn&& func, C *obj, Args&&... args);
+[[maybe_unused]] static constexpr auto for_each(Fn&& func, C&& obj, Args&&... args);
 
 template<typename Fn, typename... Args>
 requires std::invocable<Fn&&, T, Args...>
@@ -480,12 +485,12 @@ requires std::invocable<Fn&&, T, Args...>
 
 template<typename Fn, typename C, typename... Args> // specialisation for member function with object
 requires std::invocable<Fn&&, C, T, Args...>
-[[maybe_unused]] static constexpr auto for_each_n(int n, Fn&& func, C *obj, Args&&... args);
+[[maybe_unused]] static constexpr auto for_each_n(int n, Fn&& func, C&& obj, Args&&... args);
 ```
 Call supplied invocable for _each_ enum value. Similar to `std::for_each` except the first parameter of your invocable must accept an enum value (passed by `for_each`).
 Optionally provide any additional parameters. You can limit the number of calls to your invocable by using the `for_each_n` version with the first parameter
 being the maximum number to call. The second version of `for_each` and `for_each_n` is intended to be used
-when using a member function - the _second_ parameter passed by your call must be the `this` pointer of the object.
+when using a member function - the _second_ parameter passed by your call must be a pointer or reference to the object.
 If you wish to pass a `reference` parameter, you must wrap it in `std::ref`.
 
 Works with lambdas, member functions, functions etc, compatible with `std::invoke`.
@@ -586,7 +591,7 @@ requires std::invocable<Fn&&, T, Args...>
 
 template<std::size_t I, typename R, typename Fn, typename C, typename... Args> // specialisation for member function with not found value(nval) for return
 requires std::invocable<Fn&&, C, T, Args...>
-[[maybe_unused]] static constexpr R dispatch(T ev, R nval, const std::array<std::tuple<T, Fn>, I>& disp, C *obj, Args&&... args);
+[[maybe_unused]] static constexpr R dispatch(T ev, R nval, const std::array<std::tuple<T, Fn>, I>& disp, C&& obj, Args&&... args);
 
 template<std::size_t I, typename Fn, typename... Args> // void func with not found call to last element
 requires (std::invocable<Fn&&, T, Args...> && I > 0)
@@ -594,10 +599,10 @@ static constexpr void dispatch(T ev, const std::array<std::tuple<T, Fn>, I>& dis
 
 template<std::size_t I, typename Fn, typename C, typename... Args> // specialisation for void member function with not found call to last element
 requires (std::invocable<Fn&&, C, T, Args...> && I > 0)
-static constexpr void dispatch(T ev, const std::array<std::tuple<T, Fn>, I>& disp, C *obj, Args&&... args);
+static constexpr void dispatch(T ev, const std::array<std::tuple<T, Fn>, I>& disp, C&& obj, Args&&... args);
 ```
-With a given enum, search and call user supplied invocable. A typical use case would be where you want to demux a complex event, allowing you to easily declare predefined invocable actions
-for different enum values.
+With a given enum, search and call user supplied invocable. So for example, if you want to demux a complex event predicated on an enum, you can easily declare predefined invocable actions
+for different enum values and then use `dispatch` to test and execute those actions.
 
 - Where invocable returns a value, return this value or a user supplied "not found" value.
 - Where invocable is void, call user supplied invocable or "not found" invocable (last in supplied array).
@@ -611,7 +616,7 @@ There are two versions of `dispatch` - the first takes an enum value, a 'not fou
 The second version takes an enum value, and a `std::array` of `std::tuple` of enum and invocable. The last element of the array is called if the enum is not found.
 This version is intended for use with `void` return invocables.
 
-The second version of each of the above is intended to be used when using a member function - the _first_ parameter passed after your array must be the `this` pointer of the object.
+The second version of each of the above is intended to be used when using a member function - the _first_ parameter passed after your array must be a pointer or reference to the object.
 You can also use `std::bind` to bind the this pointer and any parameter placeholders when declaring your array.
 If you wish to pass a `reference` parameter, you must wrap it in `std::ref`.
 
@@ -620,7 +625,7 @@ If you wish to pass a `reference` parameter, you must wrap it in `std::ref`.
 
 > [!IMPORTANT]
 > Your `std::array` of `std::tuple` should be sorted by enum.
-> The `dispatch` method performs a binary search on the array. Complexity for a sorted array is at most&ensp; $2log_2(N)+O(1)$ &ensp;comparisons.
+> The `dispatch` method performs a [binary search](https://en.cppreference.com/w/cpp/algorithm/binary_search) on the array. Complexity for a sorted array is at most&ensp; $2log_2(N)+O(1)$ &ensp;comparisons.
 > If the array is _not_ sorted, complexity is linear.
 
 The following example uses a `static constexpr` array of pointers to functions. For brevity they all point to the same function except the last which is
@@ -985,16 +990,16 @@ _output_
 ```CSV
 0000001111
 ```
-You can use the underlying type as well:
+You can use the underlying type in an initialiser_list as well:
 ```c++
-enum_bitset<numbers> b(0,1,2,3);
+enum_bitset<numbers> b({0,1,2,3});
 std::cout << b << '\n';
 ```
 _output_
 ```CSV
 0000001111
 ```
-You can use an `int` initialiser too:
+You can use an `unsigned integer` initialiser too (interpreted as an underlying type):
 ```c++
 enum_bitset<numbers> b(15);
 std::cout << b << '\n';
@@ -1220,7 +1225,7 @@ requires std::invocable<Fn&&, T, Args...>
 
 template<typename C, typename Fn, typename... Args> // specialisation for member function with object
 requires std::invocable<Fn&&, C, T, Args...>
-[[maybe_unused]] constexpr auto for_each(Fn&& func, C *obj, Args&&... args);
+[[maybe_unused]] constexpr auto for_each(Fn&& func, C&& obj, Args&&... args);
 
 template<typename Fn, typename... Args>
 requires std::invocable<Fn&&, T, Args...>
@@ -1228,12 +1233,12 @@ requires std::invocable<Fn&&, T, Args...>
 
 template<typename C, typename Fn, typename... Args> // specialisation for member function with object
 requires std::invocable<Fn&&, C, T, Args...>
-[[maybe_unused]] constexpr auto for_each_n(int n, Fn&& func, C *obj, Args&&... args);
+[[maybe_unused]] constexpr auto for_each_n(int n, Fn&& func, C&& obj, Args&&... args);
 ```
 Call supplied invocable for _every bit that is on_. Similar to `std::for_each` except first parameter of your invocable must accept an enum value (passed by `for_each`).
 Optionally provide any additional parameters. Works with lambdas, member functions, functions etc. You can limit the number of calls to your
 invocable by using the `for_each_n` version with the first parameter being the maximum number to call. The second version of `for_each` and `for_each_n` is intended to be used
-when using a member function - the _second_ parameter passed by your call must be the `this` pointer of the object.
+when using a member function - the _second_ parameter passed by your call must be a pointer or reference to the object.
 If you wish to pass a `reference` parameter, you must wrap it in `std::ref`.
 
 Returns `std::bind(std::forward<Fn>(func), std::placeholders::_1, std::forward<Args>(args)...)` or
@@ -1426,8 +1431,8 @@ static consteval const char* FIX8::conjure_type<T>::tpeek() [with T = test]
 
 ---
 # 6. `fixed_string`
-`fixed_string` is a specialisation of `std::array` that provides statics storage for an ASCII zero (asciiz) string. The purpose of this class is to allow the
-creation of `constexpr` strings with specfic storage, adding a trailing `0`. It is used by `conjure_enum` to store all strings. API is described below.
+`fixed_string` is a specialisation of `std::array` that provides static storage for an ASCII zero (asciiz) string. The purpose of this class is to allow the
+creation of `constexpr` strings with specfic storage whilst adding a trailing `0`. It is used by `conjure_enum` to store all strings. API is described below.
 
 ## a) Creating a `fixed_string`
 ```c++
@@ -1505,22 +1510,34 @@ by default.
 
 The package is also available on [vckpg](https://vcpkg.io/en/package/conjure-enum).
 
-### ii. Default compiler warnings
+### ii. Installing
+To install the headers in your target environment, you can either specify the installation prefix when you first run cmake or set the
+environment variable `CMAKE_INSTALL_PREFIX`. Omitting the prefix will install to the default target directory for your platform.
+```bash
+$ cmake -DCMAKE_INSTALL_PREFIX=<target directory> ..
+```
+
+Alternatively you can install after building using cmake:
+```bash
+$ cmake --install . --prefix <target directory>
+```
+
+### iii. Default compiler warnings
 By default all warnings are enabled. To prevent this, pass the following to cmake:
 ```bash
 $ cmake -DBUILD_ALL_WARNINGS=false ..
 ```
-### iii. Default unit tests
+### iv. Default unit tests
 By default the unit tests are built (which will download Catch2). To prevent this, pass the following to cmake:
 ```bash
 $ cmake -DBUILD_UNITTESTS=false ..
 ```
-### iv. Default executable stripping
+### v. Default executable stripping
 To disable stripping of the executables:
 ```bash
 $ cmake -DBUILD_STRIP_EXE=false ..
 ```
-### v. Clang compilation profiling
+### vi. Clang compilation profiling
 To enable clang compilation profiling:
 ```bash
 $ cmake -DBUILD_CLANG_PROFILER=true ..
@@ -1553,7 +1570,7 @@ message(STATUS "Downloading conjure_enum...")
 include(FetchContent)
 FetchContent_Declare(conjure_enum GIT_REPOSITORY https://github.com/fix8mt/conjure_enum.git)
 FetchContent_MakeAvailable(conjure_enum)
-target_include_directories(myproj PRIVATE ${conjure_enum_SOURCE_DIR}/include)
+target_link_libraries(myproj PRIVATE conjure_enum)
 ```
 
 ## d) Reporting issues
@@ -1650,12 +1667,14 @@ The following are the default settings:
 These definitions set the minimum and maximum enum values that are supported. You can adjust them to suit your requirements but for most use cases the defaults are sufficient.
 > [!TIP]
 > You can reduce compile times in some circumstances by narrowing the range of `FIX8_CONJURE_ENUM_MIN_VALUE` and `FIX8_CONJURE_ENUM_MAX_VALUE`. For example
-> if your enums are only within the range of say `0-16` you can set `FIX8_CONJURE_ENUM_MIN_VALUE` and `FIX8_CONJURE_ENUM_MAX_VALUE` to `0` and `16` respectively. If the range is _too_ narrow
-> `conjure_enum` will **ignore enum values outside your range**.
+> if your enums are only within the range of say `0-16` you can set `FIX8_CONJURE_ENUM_MIN_VALUE` and `FIX8_CONJURE_ENUM_MAX_VALUE` to `0` and `16` respectively.
 
 > [!TIP]
 > If you wish to set ranges on a per enum basis, use `enum_range` (see below).
 
+> [!WARNING]
+> If the range is _too_ narrow `conjure_enum` will **ignore enum values outside your specified range**.
+
 ### ii. using `enum_range`
 You can specialise this class to override the defaults and set your own range on a per enum basis.
 ```c++
@@ -2047,16 +2066,18 @@ From a compilation performance perspective, `conjure_enum` roughly matches the p
 | Compiler | Version(s) | Notes | Unsupported |
 | :--- | :--- | :--- | ---: |
 | [gcc](https://gcc.gnu.org/projects/cxx-status.html) | `11`, `12`, `13`, `14`| `std::format` not complete in `11`, `12` | `<= 10` |
-| [clang](https://clang.llvm.org/cxx_status.html) | `15`, `16`, `17`, `18`| Catch2 needs `cxx_std_20` in `15` | `<= 14` |
-| [msvc](https://learn.microsoft.com/en-us/cpp/overview/visual-cpp-language-conformance) | `16`, `17` | Visual Studio 2019,2022, latest `17.11.3`| `<= 16.9`|
-| [xcode](https://developer.apple.com/support/xcode/) | `15` | Apple Xcode Clang 15.0.0 (LLVM 16), some issues with `constexpr`, workarounds| `<= 14`|
+| [clang](https://clang.llvm.org/cxx_status.html) | `15`, `16`, `17`, `18`, `19`, `20`| Catch2 needs `cxx_std_20` in `15` | `<= 14` |
+| [msvc](https://learn.microsoft.com/en-us/cpp/overview/visual-cpp-language-conformance) | `16`, `17` | Visual Studio 2019,2022, latest `17.14.3`| `<= 16.9`|
+| [xcode](https://developer.apple.com/support/xcode/) | `15`, `16` | Apple Xcode Clang `15.0.0`, `16.3.0` (LLVM `16`, `17`), some issues with `constexpr`, workarounds| `<= 14`|
 
 # 11. Compiler issues
 | Compiler | Version(s) | Issues | Workaround |
 | :--- | :--- | :--- | ---: |
 | clang | `16`, `17`, `18`| Compiler reports integers outside valid range [x,y]| specify underlying type when declaring enum eg. `enum class foo : int` |
+| xcode clang | `17` | Compiler reports `constexpr evaluation hit maximum step limit; possible infinite loop?` error with large enum ranges | use compiler option `-fconstexpr-steps=4194304`|
+| gcc | `12`, `13`, `14`| Compiler reports warnings with catch2 with `CATCH2_INTERNAL_TEST_*` `is partly outside array bounds of ‘CATCH2_INTERNAL_TEST` warnings | can be ignored |
 
-[^1]: &copy; 2024 Fix8 Market Technologies Pty Ltd, David L. Dight.
+[^1]: &copy; 2024-25 Fix8 Market Technologies Pty Ltd, David L. Dight.
   Logo by [Adrian An](mailto:adrian.an[at]mac.com).
 [^2]: &copy; 2019 - 2024 Daniil Goncharov
 
diff --git a/SECURITY.md b/SECURITY.md
index c0816e9f..81e16705 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -1,6 +1,6 @@
 <!-----------------------------------------------------------------------------------------
 // SPDX-License-Identifier: MIT
-// SPDX-FileCopyrightText: Copyright (C) 2024 Fix8 Market Technologies Pty Ltd
+// SPDX-FileCopyrightText: Copyright (C) 2024-25 Fix8 Market Technologies Pty Ltd
 // SPDX-FileType: DOCUMENTATION
 //
 // conjure_enum (header only)
diff --git a/cmake/buildutils.cmake b/cmake/buildutils.cmake
new file mode 100644
index 00000000..a267c964
--- /dev/null
+++ b/cmake/buildutils.cmake
@@ -0,0 +1,87 @@
+# ----------------------------------------------------------------------------------------
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (C) 2024-25 Fix8 Market Technologies Pty Ltd
+# SPDX-FileType: SOURCE
+#
+# cmake utils
+#   by David L. Dight
+# see https://github.com/fix8mt/conjure_enum
+#
+# Lightweight header-only C++20 enum and typename reflection
+#
+# Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is furnished
+# to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice (including the next paragraph)
+# shall be included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+# PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+# ----------------------------------------------------------------------------------------
+# cmake build utils
+# ----------------------------------------------------------------------------------------
+function(fix8_setbuildtype define_prefix default_type)
+	if(NOT ${CMAKE_BUILD_TYPE} STREQUAL "")
+		if (${CMAKE_BUILD_TYPE} STREQUAL "Debug")
+			add_compile_definitions(${define_prefix}_DEBUG_BUILD)
+		elseif(${CMAKE_BUILD_TYPE} STREQUAL "RelWithDebInfo")
+			add_compile_definitions(${define_prefix}_RELWITHDEBINFO_BUILD)
+		elseif(${CMAKE_BUILD_TYPE} STREQUAL "MinSizeRel")
+			add_compile_definitions(${define_prefix}_MINSIZEREL_BUILD)
+		elseif(${default_type} STREQUAL "Release")
+			add_compile_definitions(${define_prefix}_RELEASE_BUILD)
+		else()
+			message(FATAL_ERROR "Unsupported build type ${default_type}")
+		endif()
+		message("-- ${CMAKE_PROJECT_NAME} version ${CMAKE_PROJECT_VERSION}, build type ${CMAKE_BUILD_TYPE}")
+	else()
+		set_property(CACHE CMAKE_BUILD_TYPE PROPERTY VALUE ${default_type})
+		fix8_setbuildtype(${define_prefix} ${default_type})
+	endif()
+endfunction()
+
+# ----------------------------------------------------------------------------------------
+function(fix8_build loc x std)
+	add_executable(${x} ${loc}/${x}.cpp)
+	target_include_directories(${x} PRIVATE include)
+	target_compile_definitions(${x} PUBLIC $<UPPER_CASE:${PROJECT_NAME}>_VERSION="${PROJECT_VERSION}")
+	target_compile_features(${x} PRIVATE cxx_std_${std})
+	get_target_property(cppstd ${x} CXX_STANDARD)
+	message("-- Adding src '${x}.cpp' CXX_STANDARD: C++${cppstd} (${CMAKE_CXX_COMPILER_ID})")
+	if(BUILD_ALL_WARNINGS)
+		target_compile_options(${x} PRIVATE
+			$<$<CXX_COMPILER_ID:MSVC>:/W4>
+			$<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-Wall -Wextra -Wpedantic>)
+	endif()
+endfunction()
+
+# ----------------------------------------------------------------------------------------
+macro(fix8_addoption option_string)
+	string(REPLACE "|" ";" part ${option_string})
+	list(GET part 0 opt_name)
+	list(GET part 1 opt_description)
+	list(GET part 2 opt_default)
+	if(NOT DEFINED ${opt_name})
+		set(${opt_name} ${opt_default})
+	endif()
+	option(${opt_name} "${opt_description}" ${${opt_name}})
+	message("-- Build: ${opt_description}: ${${opt_name}}")
+endmacro()
+
+# ----------------------------------------------------------------------------------------
+macro(fix8_fetch modname parturl tag)
+	include(FetchContent)
+	message(STATUS "Downloading ${modname} (${tag})...")
+	FetchContent_Declare(${modname} GIT_REPOSITORY https://github.com/${parturl}.git GIT_SHALLOW ON GIT_TAG ${tag})
+	FetchContent_MakeAvailable(${modname})
+endmacro()
diff --git a/examples/cbenchmark.cpp b/examples/cbenchmark.cpp
index d396bcf8..4f82795e 100644
--- a/examples/cbenchmark.cpp
+++ b/examples/cbenchmark.cpp
@@ -1,6 +1,6 @@
 //-----------------------------------------------------------------------------------------
 // SPDX-License-Identifier: MIT
-// SPDX-FileCopyrightText: Copyright (C) 2024 Fix8 Market Technologies Pty Ltd
+// SPDX-FileCopyrightText: Copyright (C) 2024-25 Fix8 Market Technologies Pty Ltd
 // SPDX-FileType: SOURCE
 //
 // conjure_enum (header only)
diff --git a/examples/example.cpp b/examples/example.cpp
index 9f36e7d8..77ce3a9f 100644
--- a/examples/example.cpp
+++ b/examples/example.cpp
@@ -1,6 +1,6 @@
 //-----------------------------------------------------------------------------------------
 // SPDX-License-Identifier: MIT
-// SPDX-FileCopyrightText: Copyright (C) 2024 Fix8 Market Technologies Pty Ltd
+// SPDX-FileCopyrightText: Copyright (C) 2024-25 Fix8 Market Technologies Pty Ltd
 // SPDX-FileType: SOURCE
 //
 // conjure_enum (header only)
@@ -264,5 +264,11 @@ int main(void)
 	std::cout << ee.get_underlying_bit_size()  << '\n';
 	std::cout << ee.get_bit_mask() << '\n';
 	std::cout << ee.get_unused_bit_mask() << '\n';
+
+	std::cout << enum_bitset<numbers>(3) << '\n';
+	std::cout << enum_bitset<numbers>({0,1}) << '\n';
+	std::cout << enum_bitset<numbers>(0,1,2,3) << '\n';
+	std::cout << enum_bitset<numbers>({0,1,2,3}) << '\n';
+	std::cout << enum_bitset<numbers>(42) << '\n';
 	return 0;
 }
diff --git a/examples/srcloctest.cpp b/examples/srcloctest.cpp
index efee3dd0..964af81b 100644
--- a/examples/srcloctest.cpp
+++ b/examples/srcloctest.cpp
@@ -1,6 +1,6 @@
 //-----------------------------------------------------------------------------------------
 // SPDX-License-Identifier: MIT
-// SPDX-FileCopyrightText: Copyright (C) 2024 Fix8 Market Technologies Pty Ltd
+// SPDX-FileCopyrightText: Copyright (C) 2024-25 Fix8 Market Technologies Pty Ltd
 // SPDX-FileType: SOURCE
 
 // conjure_enum (header only)
@@ -151,15 +151,22 @@ int main(int argc, char **argv)
 			conjure_type<TEST::TEST1::NineEnums1>::tpeek()
    };
 
-	bool mkd{}, cpl{true}, hlp{};
-	const std::map<std::string_view, bool&> opts { {"-m",mkd},{"-c",cpl},{"-h",hlp} };
+	bool mkd{}, cpl{true}, hlp{}, cplonly{}, vers{};
+	const std::map<std::string_view, bool&> opts { {"-m",mkd},{"-c",cpl},{"-h",hlp},{"-C",cplonly},{"-v",vers}};
 	for (const std::vector<std::string_view> args{argv + 1, argv + argc}; const auto pp : args)
+	{
 		if (auto result{opts.find(pp)}; result != opts.cend())
 			result->second ^= true;
+		else
+		{
+			std::cerr << "Unknown option: " << pp << '\n';
+			return 1;
+		}
+	}
 	if (hlp)
 	{
-		std::cout << R"(
-This program shows the output generated by your compiler. There are nine different
+		std::cout <<
+R"(This program shows the output generated by your compiler. There are nine different
 sets of tests - conjure_enum and conjure_type use this information to inform the
 parsing algorithm to extract enum and type info. For most compilers, there will be
 few if any differences between compiler versions - certainly few that impact
@@ -167,21 +174,30 @@ conjure_enum - however there have been a couple of changes with earlier releases
 Since the output of std::source_location is entirely implementation dependent, future
 changes may occur.
 
-Usage: )" << argv[0] << " [-cmh]" << R"(
+See <https://github.com/fix8mt/conjure_enum>
+
+Usage: )" << argv[0] << " [-cCmvh]" << R"(
   -c show compiler (default true)
-  -m output using markdown
+  -C show compiler version only
+  -m format output with markdown
+  -v conjure_enum version
   -h help
 )";
 		return 0;
 	}
+	if (vers)
+	{
+		std::cout << "conjure_enum version " CONJURE_ENUM_VERSION "\n";
+		return 0;
+	}
 
 	if (cpl)
 	{
 #if defined _MSC_VER
-#define STRINGIZE(x) #x
-#define STRINGIZE_VALUE(x) STRINGIZE(x)
+# define STRINGIZE(x) #x
+# define STRINGIZE_VALUE(x) STRINGIZE(x)
 #endif
-		if (mkd)
+		if (mkd && !cplonly)
 			std::cout << "---\n# ";
 		std::cout << "Compiler: "
 #if defined __clang__
@@ -196,21 +212,24 @@ Usage: )" << argv[0] << " [-cmh]" << R"(
 			"\n";
 	}
 
-	for (const auto *pp : srclocstrs)
+	if (!cplonly)
 	{
-		if (mkd && std::isdigit(pp[0]))
+		for (const auto *pp : srclocstrs)
 		{
-			if (pp != srclocstrs[0])
-				std::cout << "```\n";
-			std::cout << "## ";
+			if (mkd && std::isdigit(pp[0]))
+			{
+				if (pp != srclocstrs[0])
+					std::cout << "```\n";
+				std::cout << "## ";
+			}
+			if (!mkd || pp[0])
+				std::cout << pp << '\n';
+			if (mkd && std::isdigit(pp[0]))
+				std::cout << "```c++\n";
 		}
-		if (!mkd || pp[0])
-			std::cout << pp << '\n';
-		if (mkd && std::isdigit(pp[0]))
-			std::cout << "```c++\n";
+		if (mkd)
+			std::cout << "```\n";
 	}
-	if (mkd)
-		std::cout << "```\n";
 
 	return 0;
 }
diff --git a/examples/statictest.cpp b/examples/statictest.cpp
index 7956a1f0..6e2132ef 100644
--- a/examples/statictest.cpp
+++ b/examples/statictest.cpp
@@ -1,6 +1,6 @@
 //-----------------------------------------------------------------------------------------
 // SPDX-License-Identifier: MIT
-// SPDX-FileCopyrightText: Copyright (C) 2024 Fix8 Market Technologies Pty Ltd
+// SPDX-FileCopyrightText: Copyright (C) 2024-25 Fix8 Market Technologies Pty Ltd
 // SPDX-FileType: SOURCE
 
 // conjure_enum (header only)
diff --git a/include/fix8/conjure_enum.hpp b/include/fix8/conjure_enum.hpp
index 264c24b4..605715a4 100644
--- a/include/fix8/conjure_enum.hpp
+++ b/include/fix8/conjure_enum.hpp
@@ -1,6 +1,6 @@
 //-----------------------------------------------------------------------------------------
 // SPDX-License-Identifier: MIT
-// SPDX-FileCopyrightText: Copyright (C) 2024 Fix8 Market Technologies Pty Ltd
+// SPDX-FileCopyrightText: Copyright (C) 2024-25 Fix8 Market Technologies Pty Ltd
 // SPDX-FileType: SOURCE
 //
 // conjure_enum (header only)
@@ -63,6 +63,7 @@
 #include <array>
 #if not defined FIX8_CONJURE_ENUM_MINIMAL
 # include <functional>
+# include <ostream>
 #endif
 
 //-----------------------------------------------------------------------------------------
@@ -147,12 +148,6 @@ class cs final : public static_only
 using stype = cs::stype;
 using sval = cs::sval;
 
-#if defined _MSC_VER
-#define CHKMSSTR(e, x) \
-	if constexpr (constexpr auto ep##x { e.find(cs::get_spec<sval::anon_str,stype::x>()) }; ep##x != std::string_view::npos) \
-		return e.substr(ep##x + cs::get_spec<sval::anon_str,stype::x>().size(), e.size() - (ep##x + cs::get_spec<sval::anon_str,stype::x>().size()))
-#endif
-
 //-----------------------------------------------------------------------------------------
 template<typename T>
 concept valid_enum = requires(T)
@@ -323,6 +318,7 @@ class conjure_enum : public static_only
 	static constexpr auto count() noexcept { return values.size(); }
 	static constexpr bool is_continuous() noexcept { return (static_cast<size_t>(max_v) - static_cast<size_t>(min_v) + 1) == count(); }
 	static constexpr bool in_range(T value) noexcept { return std::clamp(value, min_v, max_v) == value; }
+	static constexpr bool starts_from_zero() noexcept { return static_cast<size_t>(min_v) == 0; }
 
 	// scope ops
 	static constexpr bool has_scope(std::string_view what) noexcept
@@ -389,7 +385,7 @@ class conjure_enum : public static_only
 
 	static constexpr std::string_view enum_to_string(T value, [[maybe_unused]] bool noscope=false) noexcept
 	{
-		if constexpr (is_continuous())
+		if constexpr (is_continuous() and starts_from_zero())
 		{
 			if (in_range(value))
 			{
diff --git a/include/fix8/conjure_enum_bitset.hpp b/include/fix8/conjure_enum_bitset.hpp
index 75c4d24c..73199acd 100644
--- a/include/fix8/conjure_enum_bitset.hpp
+++ b/include/fix8/conjure_enum_bitset.hpp
@@ -1,6 +1,6 @@
 //-----------------------------------------------------------------------------------------
 // SPDX-License-Identifier: MIT
-// SPDX-FileCopyrightText: Copyright (C) 2024 Fix8 Market Technologies Pty Ltd
+// SPDX-FileCopyrightText: Copyright (C) 2024-25 Fix8 Market Technologies Pty Ltd
 // SPDX-FileType: SOURCE
 //
 // conjure_enum (header only)
@@ -110,14 +110,28 @@ class enum_bitset
 
 	static constexpr int correct_count(int val) noexcept { return val ? val - unused_bits : 0; }
 
+	template<std::size_t... I>
+	constexpr enum_bitset(std::initializer_list<U> bits, std::index_sequence<I...>) noexcept
+		: _present((0u | ... | (1 << *(bits.begin() + I)))) {}
+
 public:
 	using enum_bitset_underlying_type = U;
 	using reference = _reference<enum_bitset>;
 	using const_reference = _reference<const enum_bitset>;
 
-	explicit constexpr enum_bitset(U bits) noexcept : _present(bits) {}
-	explicit constexpr enum_bitset(std::bitset<countof> from) : _present(U(from.to_ullong())) {}
-	constexpr enum_bitset(std::string_view from, bool anyscope=false, char sep='|', bool ignore_errors=true)
+	template<std::size_t N>
+	requires (N > 0 and N < conjure_enum<T>::count())
+	explicit constexpr enum_bitset(std::initializer_list<U> bits) noexcept : enum_bitset(bits, std::make_index_sequence<N>{}) {}
+
+	template<typename V>
+	requires std::same_as<std::remove_cvref_t<V>, std::bitset<countof>>
+	explicit constexpr enum_bitset(V&& from) : _present(U(from.to_ullong())) {}
+
+	explicit constexpr enum_bitset(U bits) : _present(bits) {}
+
+	template<typename V>
+	requires std::convertible_to<V, std::string_view>
+	constexpr enum_bitset(V&& from, bool anyscope=false, char sep='|', bool ignore_errors=true)
 		: _present(factory(from, anyscope, sep, ignore_errors)) {}
 
 	template<valid_bitset_enum... E>
@@ -288,7 +302,7 @@ class enum_bitset
 
 	template<typename C, typename Fn, typename... Args> // specialisation for member function with object
 	requires std::invocable<Fn&&, C, T, Args...>
-	[[maybe_unused]] constexpr auto for_each(Fn&& func, C *obj, Args&&... args) noexcept
+	[[maybe_unused]] constexpr auto for_each(Fn&& func, C&& obj, Args&&... args) noexcept
 	{
 		return for_each(std::bind(std::forward<Fn>(func), obj, std::placeholders::_1, std::forward<Args>(args)...));
 	}
@@ -305,7 +319,7 @@ class enum_bitset
 
 	template<typename C, typename Fn, typename... Args> // specialisation for member function with object
 	requires std::invocable<Fn&&, C, T, Args...>
-	[[maybe_unused]] constexpr auto for_each_n(int n, Fn&& func, C *obj, Args&&... args) noexcept
+	[[maybe_unused]] constexpr auto for_each_n(int n, Fn&& func, C&& obj, Args&&... args) noexcept
 	{
 		return for_each_n(n, std::bind(std::forward<Fn>(func), obj, std::placeholders::_1, std::forward<Args>(args)...));
 	}
diff --git a/include/fix8/conjure_enum_ext.hpp b/include/fix8/conjure_enum_ext.hpp
index 154052a5..0a26b416 100644
--- a/include/fix8/conjure_enum_ext.hpp
+++ b/include/fix8/conjure_enum_ext.hpp
@@ -1,6 +1,6 @@
 //-----------------------------------------------------------------------------------------
 // SPDX-License-Identifier: MIT
-// SPDX-FileCopyrightText: Copyright (C) 2024 Fix8 Market Technologies Pty Ltd
+// SPDX-FileCopyrightText: Copyright (C) 2024-25 Fix8 Market Technologies Pty Ltd
 // SPDX-FileType: SOURCE
 //
 // conjure_enum (header only)
@@ -123,6 +123,10 @@
 	{
 		constexpr std::string_view from{tpeek()};
 #if defined _MSC_VER
+#define CHKMSSTR(e, x) \
+	if constexpr (constexpr auto ep##x { e.find(cs::get_spec<sval::anon_str,stype::x>()) }; ep##x != std::string_view::npos) \
+		return e.substr(ep##x + cs::get_spec<sval::anon_str,stype::x>().size(), e.size() - (ep##x + cs::get_spec<sval::anon_str,stype::x>().size()))
+
 		constexpr auto ep { from.rfind(cs::get_spec<sval::start,stype::type_t>()) };
 		if constexpr (ep == std::string_view::npos)
 			return {};
@@ -156,7 +160,7 @@
 
 	template<typename Fn, typename C, typename... Args> // specialisation for member function with object
 	requires std::invocable<Fn&&, C, T, Args...>
-	[[maybe_unused]] static constexpr auto for_each(Fn&& func, C *obj, Args&&... args) noexcept
+	[[maybe_unused]] static constexpr auto for_each(Fn&& func, C&& obj, Args&&... args) noexcept
 	{
 		return for_each(std::bind(std::forward<Fn>(func), obj, std::placeholders::_1, std::forward<Args>(args)...));
 	}
@@ -176,7 +180,7 @@
 
 	template<typename Fn, typename C, typename... Args> // specialisation for member function with object
 	requires std::invocable<Fn&&, C, T, Args...>
-	[[maybe_unused]] static constexpr auto for_each_n(int n, Fn&& func, C *obj, Args&&... args) noexcept
+	[[maybe_unused]] static constexpr auto for_each_n(int n, Fn&& func, C&& obj, Args&&... args) noexcept
 	{
 		return for_each_n(n, std::bind(std::forward<Fn>(func), obj, std::placeholders::_1, std::forward<Args>(args)...));
 	}
@@ -198,7 +202,7 @@
 
 	template<std::size_t I, typename R, typename Fn, typename C, typename... Args> // specialisation for member function with not found value(nval) for return
 	requires std::invocable<Fn&&, C, T, Args...>
-	[[maybe_unused]] static constexpr R dispatch(T ev, R nval, const std::array<std::tuple<T, Fn>, I>& disp, C *obj, Args&&... args) noexcept
+	[[maybe_unused]] static constexpr R dispatch(T ev, R nval, const std::array<std::tuple<T, Fn>, I>& disp, C&& obj, Args&&... args) noexcept
 	{
 		const auto [begin,end] { std::equal_range(disp.cbegin(), disp.cend(), std::make_tuple(ev, Fn()), tuple_comp<Fn>) };
 		return begin != end ? std::invoke(std::get<Fn>(*begin), obj, ev, std::forward<Args>(args)...) : nval;
@@ -214,7 +218,7 @@
 
 	template<std::size_t I, typename Fn, typename C, typename... Args> // specialisation for void member function with not found call to last element
 	requires (std::invocable<Fn&&, C, T, Args...> && I > 0)
-	static constexpr void dispatch(T ev, const std::array<std::tuple<T, Fn>, I>& disp, C *obj, Args&&... args) noexcept
+	static constexpr void dispatch(T ev, const std::array<std::tuple<T, Fn>, I>& disp, C&& obj, Args&&... args) noexcept
 	{
 		const auto [begin,end] { std::equal_range(disp.cbegin(), std::prev(disp.cend()), std::make_tuple(ev, Fn()), tuple_comp<Fn>) };
 		return std::invoke(std::get<Fn>(begin != end ? *begin : *std::prev(disp.cend())), obj, ev, std::forward<Args>(args)...);
@@ -237,9 +241,6 @@ struct iterator_adaptor
 	constexpr auto end() noexcept { return conjure_enum<T>::entries.cend(); }
 };
 
-//-----------------------------------------------------------------------------------------
-#include <ostream>
-
 //-----------------------------------------------------------------------------------------
 // ostream& operator<< for any enum; add the following before using:
 // using ostream_enum_operator::operator<<;
diff --git a/include/fix8/conjure_type.hpp b/include/fix8/conjure_type.hpp
index d78a6737..e7963088 100644
--- a/include/fix8/conjure_type.hpp
+++ b/include/fix8/conjure_type.hpp
@@ -1,6 +1,6 @@
 //-----------------------------------------------------------------------------------------
 // SPDX-License-Identifier: MIT
-// SPDX-FileCopyrightText: Copyright (C) 2024 Fix8 Market Technologies Pty Ltd
+// SPDX-FileCopyrightText: Copyright (C) 2024-25 Fix8 Market Technologies Pty Ltd
 // SPDX-FileType: SOURCE
 //
 // conjure_enum (header only)
diff --git a/reference/source_location.md b/reference/source_location.md
index 371a68ae..8f22b854 100644
--- a/reference/source_location.md
+++ b/reference/source_location.md
@@ -1,6 +1,6 @@
 <!-----------------------------------------------------------------------------------------
 // SPDX-License-Identifier: MIT
-// SPDX-FileCopyrightText: Copyright (C) 2024 Fix8 Market Technologies Pty Ltd
+// SPDX-FileCopyrightText: Copyright (C) 2024-25 Fix8 Market Technologies Pty Ltd
 // SPDX-FileType: DOCUMENTATION
 //
 // conjure_enum (header only)
@@ -140,7 +140,7 @@ static const char *conjure_type<TEST::TEST1::NineEnums1>::tpeek() [T = TEST::TES
 ```
 
 ---
-# Compiler: GCC: 14.0.1 20240412 (experimental) [master r14-9935-g67e1433a94f]
+# Compiler: GCC: 14.2.0
 ## 1. scoped enum
 ```c++
 static consteval const char* conjure_type<T>::tpeek() [with T = Namespace_Enum_Type]
@@ -201,6 +201,67 @@ static consteval const char* conjure_type<T>::tpeek() [with T = TEST::TEST1::Nin
 static consteval const char* conjure_type<T>::tpeek() [with T = TEST::TEST1::NineEnums1]
 ```
 
+---
+# Compiler: MSVC: 1943
+## 1. scoped enum
+```c++
+const char *__cdecl conjure_type<enum Namespace_Enum_Type>::tpeek(void) noexcept
+const char *__cdecl conjure_enum<enum Namespace_Enum_Type>::epeek<Namespace_Enum_Type::Value>(void) noexcept
+const char *__cdecl conjure_enum<enum Namespace_Enum_Type>::epeek<(enum Namespace_Enum_Type)0x64>(void) noexcept
+```
+## 2. unscoped enum
+```c++
+const char *__cdecl conjure_type<enum Namespace_Enum_Type1>::tpeek(void) noexcept
+const char *__cdecl conjure_enum<enum Namespace_Enum_Type1>::epeek<Value>(void) noexcept
+const char *__cdecl conjure_enum<enum Namespace_Enum_Type1>::epeek<(enum Namespace_Enum_Type1)0x64>(void) noexcept
+```
+## 3. scoped enum in anonymous namespace
+```c++
+const char *__cdecl conjure_type<enum `anonymous namespace'::Anon_Enum_Type>::tpeek(void) noexcept
+const char *__cdecl conjure_enum<enum `anonymous namespace'::Anon_Enum_Type>::epeek<`anonymous-namespace'::Anon_Enum_Type::Value>(void) noexcept
+const char *__cdecl conjure_enum<enum `anonymous namespace'::Anon_Enum_Type>::epeek<(enum `anonymous-namespace'::Anon_Enum_Type)0x64>(void) noexcept
+```
+## 4. unscoped enum in anonymous namespace
+```c++
+const char *__cdecl conjure_type<enum `anonymous namespace'::Anon_Enum_Type1>::tpeek(void) noexcept
+const char *__cdecl conjure_enum<enum `anonymous namespace'::Anon_Enum_Type1>::epeek<`anonymous-namespace'::Value>(void) noexcept
+const char *__cdecl conjure_enum<enum `anonymous namespace'::Anon_Enum_Type1>::epeek<(enum `anonymous-namespace'::Anon_Enum_Type1)0x64>(void) noexcept
+```
+## 5. scoped enum in namespace
+```c++
+const char *__cdecl conjure_type<enum Namespace::Namespace_Enum_Type>::tpeek(void) noexcept
+const char *__cdecl conjure_enum<enum Namespace::Namespace_Enum_Type>::epeek<Namespace::Namespace_Enum_Type::Value>(void) noexcept
+const char *__cdecl conjure_enum<enum Namespace::Namespace_Enum_Type>::epeek<(enum Namespace::Namespace_Enum_Type)0x64>(void) noexcept
+```
+## 6. unscoped enum in namespace
+```c++
+const char *__cdecl conjure_type<enum Namespace::Namespace_Enum_Type1>::tpeek(void) noexcept
+const char *__cdecl conjure_enum<enum Namespace::Namespace_Enum_Type1>::epeek<Namespace::Value>(void) noexcept
+const char *__cdecl conjure_enum<enum Namespace::Namespace_Enum_Type1>::epeek<(enum Namespace::Namespace_Enum_Type1)0x64>(void) noexcept
+```
+## 7. types in named and anonymous namespaces
+```c++
+const char *__cdecl conjure_type<struct Foo>::tpeek(void) noexcept
+const char *__cdecl conjure_type<class Namespace::Namespace_Foo>::tpeek(void) noexcept
+const char *__cdecl conjure_type<class `anonymous namespace'::Anon_Foo>::tpeek(void) noexcept
+```
+## 8. other types
+```c++
+const char *__cdecl conjure_type<int>::tpeek(void) noexcept
+const char *__cdecl conjure_type<class std::basic_string_view<char,struct std::char_traits<char> > >::tpeek(void) noexcept
+const char *__cdecl conjure_type<class std::vector<class std::tuple<int,char,class std::basic_string_view<char,struct std::char_traits<char> > >,class std::allocator<class std::tuple<int,char,class std::basic_string_view<char,struct std::char_traits<char> > > > > >::tpeek(void) noexcept
+```
+## 9. edge enum types
+```c++
+const char *__cdecl conjure_type<enum `anonymous namespace'::NineEnums>::tpeek(void) noexcept
+const char *__cdecl conjure_type<enum `anonymous namespace'::NineEnums1>::tpeek(void) noexcept
+const char *__cdecl conjure_type<enum TEST::NineEnums>::tpeek(void) noexcept
+const char *__cdecl conjure_type<enum TEST::NineEnums1>::tpeek(void) noexcept
+const char *__cdecl conjure_type<enum `anonymous namespace'::TEST1::NineEnums>::tpeek(void) noexcept
+const char *__cdecl conjure_type<enum `anonymous namespace'::TEST1::NineEnums1>::tpeek(void) noexcept
+const char *__cdecl conjure_type<enum TEST::TEST1::NineEnums>::tpeek(void) noexcept
+const char *__cdecl conjure_type<enum TEST::TEST1::NineEnums1>::tpeek(void) noexcept
+```
 ---
 # Compiler: MSVC: 1940
 ## 1. scoped enum
@@ -332,6 +393,67 @@ const char *__cdecl conjure_type<enum TEST::TEST1::NineEnums>::tpeek(void) noexc
 const char *__cdecl conjure_type<enum TEST::TEST1::NineEnums1>::tpeek(void) noexcept
 ```
 
+---
+# Compiler: Clang: Apple LLVM 17.0.0 (clang-1700.0.13.3)
+## 1. scoped enum
+```c++
+static const char *conjure_type<Namespace_Enum_Type>::tpeek() [T = Namespace_Enum_Type]
+static const char *conjure_enum<Namespace_Enum_Type>::epeek() [T = Namespace_Enum_Type, e = Namespace_Enum_Type::Value]
+static const char *conjure_enum<Namespace_Enum_Type>::epeek() [T = Namespace_Enum_Type, e = (Namespace_Enum_Type)100]
+```
+## 2. unscoped enum
+```c++
+static const char *conjure_type<Namespace_Enum_Type1>::tpeek() [T = Namespace_Enum_Type1]
+static const char *conjure_enum<Namespace_Enum_Type1>::epeek() [T = Namespace_Enum_Type1, e = Value]
+static const char *conjure_enum<Namespace_Enum_Type1>::epeek() [T = Namespace_Enum_Type1, e = (Namespace_Enum_Type1)100]
+```
+## 3. scoped enum in anonymous namespace
+```c++
+static const char *conjure_type<(anonymous namespace)::Anon_Enum_Type>::tpeek() [T = (anonymous namespace)::Anon_Enum_Type]
+static const char *conjure_enum<(anonymous namespace)::Anon_Enum_Type>::epeek() [T = (anonymous namespace)::Anon_Enum_Type, e = (anonymous namespace)::Anon_Enum_Type::Value]
+static const char *conjure_enum<(anonymous namespace)::Anon_Enum_Type>::epeek() [T = (anonymous namespace)::Anon_Enum_Type, e = ((anonymous namespace)::Anon_Enum_Type)100]
+```
+## 4. unscoped enum in anonymous namespace
+```c++
+static const char *conjure_type<(anonymous namespace)::Anon_Enum_Type1>::tpeek() [T = (anonymous namespace)::Anon_Enum_Type1]
+static const char *conjure_enum<(anonymous namespace)::Anon_Enum_Type1>::epeek() [T = (anonymous namespace)::Anon_Enum_Type1, e = (anonymous namespace)::Value]
+static const char *conjure_enum<(anonymous namespace)::Anon_Enum_Type1>::epeek() [T = (anonymous namespace)::Anon_Enum_Type1, e = ((anonymous namespace)::Anon_Enum_Type1)100]
+```
+## 5. scoped enum in namespace
+```c++
+static const char *conjure_type<Namespace::Namespace_Enum_Type>::tpeek() [T = Namespace::Namespace_Enum_Type]
+static const char *conjure_enum<Namespace::Namespace_Enum_Type>::epeek() [T = Namespace::Namespace_Enum_Type, e = Namespace::Namespace_Enum_Type::Value]
+static const char *conjure_enum<Namespace::Namespace_Enum_Type>::epeek() [T = Namespace::Namespace_Enum_Type, e = (Namespace::Namespace_Enum_Type)100]
+```
+## 6. unscoped enum in namespace
+```c++
+static const char *conjure_type<Namespace::Namespace_Enum_Type1>::tpeek() [T = Namespace::Namespace_Enum_Type1]
+static const char *conjure_enum<Namespace::Namespace_Enum_Type1>::epeek() [T = Namespace::Namespace_Enum_Type1, e = Namespace::Value]
+static const char *conjure_enum<Namespace::Namespace_Enum_Type1>::epeek() [T = Namespace::Namespace_Enum_Type1, e = (Namespace::Namespace_Enum_Type1)100]
+```
+## 7. types in named and anonymous namespaces
+```c++
+static const char *conjure_type<Foo>::tpeek() [T = Foo]
+static const char *conjure_type<Namespace::Namespace_Foo>::tpeek() [T = Namespace::Namespace_Foo]
+static const char *conjure_type<(anonymous namespace)::Anon_Foo>::tpeek() [T = (anonymous namespace)::Anon_Foo]
+```
+## 8. other types
+```c++
+static const char *conjure_type<int>::tpeek() [T = int]
+static const char *conjure_type<std::string_view>::tpeek() [T = std::string_view]
+static const char *conjure_type<std::vector<std::tuple<int, char, std::string_view>>>::tpeek() [T = std::vector<std::tuple<int, char, std::string_view>>]
+```
+## 9. edge enum types
+```c++
+static const char *conjure_type<(anonymous namespace)::NineEnums>::tpeek() [T = (anonymous namespace)::NineEnums]
+static const char *conjure_type<(anonymous namespace)::NineEnums1>::tpeek() [T = (anonymous namespace)::NineEnums1]
+static const char *conjure_type<TEST::NineEnums>::tpeek() [T = TEST::NineEnums]
+static const char *conjure_type<TEST::NineEnums1>::tpeek() [T = TEST::NineEnums1]
+static const char *conjure_type<(anonymous namespace)::TEST1::NineEnums>::tpeek() [T = (anonymous namespace)::TEST1::NineEnums]
+static const char *conjure_type<(anonymous namespace)::TEST1::NineEnums1>::tpeek() [T = (anonymous namespace)::TEST1::NineEnums1]
+static const char *conjure_type<TEST::TEST1::NineEnums>::tpeek() [T = TEST::TEST1::NineEnums]
+static const char *conjure_type<TEST::TEST1::NineEnums1>::tpeek() [T = TEST::TEST1::NineEnums1]
+```
 ---
 # Compiler: Clang: Apple LLVM 15.0.0 (clang-1500.3.9.4)
 ## 1. scoped enum
@@ -456,6 +578,67 @@ static consteval const char* conjure_type<T>::tpeek() [with T = TEST::TEST1::Nin
 static consteval const char* conjure_type<T>::tpeek() [with T = TEST::TEST1::NineEnums1]
 ```
 
+---
+# Compiler: Clang: Ubuntu Clang 20.1.2 (0ubuntu1)
+## 1. scoped enum
+```c++
+static const char *conjure_type<Namespace_Enum_Type>::tpeek() [T = Namespace_Enum_Type]
+static const char *conjure_enum<Namespace_Enum_Type>::epeek() [T = Namespace_Enum_Type, e = Namespace_Enum_Type::Value]
+static const char *conjure_enum<Namespace_Enum_Type>::epeek() [T = Namespace_Enum_Type, e = (Namespace_Enum_Type)100]
+```
+## 2. unscoped enum
+```c++
+static const char *conjure_type<Namespace_Enum_Type1>::tpeek() [T = Namespace_Enum_Type1]
+static const char *conjure_enum<Namespace_Enum_Type1>::epeek() [T = Namespace_Enum_Type1, e = Value]
+static const char *conjure_enum<Namespace_Enum_Type1>::epeek() [T = Namespace_Enum_Type1, e = (Namespace_Enum_Type1)100]
+```
+## 3. scoped enum in anonymous namespace
+```c++
+static const char *conjure_type<(anonymous namespace)::Anon_Enum_Type>::tpeek() [T = (anonymous namespace)::Anon_Enum_Type]
+static const char *conjure_enum<(anonymous namespace)::Anon_Enum_Type>::epeek() [T = (anonymous namespace)::Anon_Enum_Type, e = (anonymous namespace)::Anon_Enum_Type::Value]
+static const char *conjure_enum<(anonymous namespace)::Anon_Enum_Type>::epeek() [T = (anonymous namespace)::Anon_Enum_Type, e = ((anonymous namespace)::Anon_Enum_Type)100]
+```
+## 4. unscoped enum in anonymous namespace
+```c++
+static const char *conjure_type<(anonymous namespace)::Anon_Enum_Type1>::tpeek() [T = (anonymous namespace)::Anon_Enum_Type1]
+static const char *conjure_enum<(anonymous namespace)::Anon_Enum_Type1>::epeek() [T = (anonymous namespace)::Anon_Enum_Type1, e = (anonymous namespace)::Value]
+static const char *conjure_enum<(anonymous namespace)::Anon_Enum_Type1>::epeek() [T = (anonymous namespace)::Anon_Enum_Type1, e = ((anonymous namespace)::Anon_Enum_Type1)100]
+```
+## 5. scoped enum in namespace
+```c++
+static const char *conjure_type<Namespace::Namespace_Enum_Type>::tpeek() [T = Namespace::Namespace_Enum_Type]
+static const char *conjure_enum<Namespace::Namespace_Enum_Type>::epeek() [T = Namespace::Namespace_Enum_Type, e = Namespace::Namespace_Enum_Type::Value]
+static const char *conjure_enum<Namespace::Namespace_Enum_Type>::epeek() [T = Namespace::Namespace_Enum_Type, e = (Namespace::Namespace_Enum_Type)100]
+```
+## 6. unscoped enum in namespace
+```c++
+static const char *conjure_type<Namespace::Namespace_Enum_Type1>::tpeek() [T = Namespace::Namespace_Enum_Type1]
+static const char *conjure_enum<Namespace::Namespace_Enum_Type1>::epeek() [T = Namespace::Namespace_Enum_Type1, e = Namespace::Value]
+static const char *conjure_enum<Namespace::Namespace_Enum_Type1>::epeek() [T = Namespace::Namespace_Enum_Type1, e = (Namespace::Namespace_Enum_Type1)100]
+```
+## 7. types in named and anonymous namespaces
+```c++
+static const char *conjure_type<Foo>::tpeek() [T = Foo]
+static const char *conjure_type<Namespace::Namespace_Foo>::tpeek() [T = Namespace::Namespace_Foo]
+static const char *conjure_type<(anonymous namespace)::Anon_Foo>::tpeek() [T = (anonymous namespace)::Anon_Foo]
+```
+## 8. other types
+```c++
+static const char *conjure_type<int>::tpeek() [T = int]
+static const char *conjure_type<std::basic_string_view<char>>::tpeek() [T = std::basic_string_view<char>]
+static const char *conjure_type<std::vector<std::tuple<int, char, std::basic_string_view<char>>>>::tpeek() [T = std::vector<std::tuple<int, char, std::basic_string_view<char>>>]
+```
+## 9. edge enum types
+```c++
+static const char *conjure_type<(anonymous namespace)::NineEnums>::tpeek() [T = (anonymous namespace)::NineEnums]
+static const char *conjure_type<(anonymous namespace)::NineEnums1>::tpeek() [T = (anonymous namespace)::NineEnums1]
+static const char *conjure_type<TEST::NineEnums>::tpeek() [T = TEST::NineEnums]
+static const char *conjure_type<TEST::NineEnums1>::tpeek() [T = TEST::NineEnums1]
+static const char *conjure_type<(anonymous namespace)::TEST1::NineEnums>::tpeek() [T = (anonymous namespace)::TEST1::NineEnums]
+static const char *conjure_type<(anonymous namespace)::TEST1::NineEnums1>::tpeek() [T = (anonymous namespace)::TEST1::NineEnums1]
+static const char *conjure_type<TEST::TEST1::NineEnums>::tpeek() [T = TEST::TEST1::NineEnums]
+static const char *conjure_type<TEST::TEST1::NineEnums1>::tpeek() [T = TEST::TEST1::NineEnums1]
+```
 ---
 # Compiler: Clang: Ubuntu Clang 18.1.3 (1ubuntu1)
 ## 1. scoped enum
@@ -580,6 +763,7 @@ static consteval const char* conjure_type<T>::tpeek() [with T = TEST::TEST1::Nin
 static consteval const char* conjure_type<T>::tpeek() [with T = TEST::TEST1::NineEnums1]
 ```
 
+---
 # Compiler: GCC: 13.2.0
 ## 1. scoped enum
 ```c++
@@ -641,6 +825,7 @@ static consteval const char* conjure_type<T>::tpeek() [with T = TEST::TEST1::Nin
 static consteval const char* conjure_type<T>::tpeek() [with T = TEST::TEST1::NineEnums1]
 ```
 
+---
 # Compiler: Clang: Ubuntu Clang 17.0.6 (9ubuntu1)
 ## 1. scoped enum
 ```c++
diff --git a/utests/edgetests.cpp b/utests/edgetests.cpp
index 0e7f1abe..056f8704 100644
--- a/utests/edgetests.cpp
+++ b/utests/edgetests.cpp
@@ -1,6 +1,6 @@
 //-----------------------------------------------------------------------------------------
 // SPDX-License-Identifier: MIT
-// SPDX-FileCopyrightText: Copyright (C) 2024 Fix8 Market Technologies Pty Ltd
+// SPDX-FileCopyrightText: Copyright (C) 2024-25 Fix8 Market Technologies Pty Ltd
 // SPDX-FileType: SOURCE
 //
 // conjure_enum (header only)
@@ -80,6 +80,92 @@ namespace test::util
 	[[nodiscard]] constexpr size_t countOf() { return FIX8::conjure_enum<E>::count(); }
 }
 
+enum class numbers
+{
+   blah_0, blah_1, blah_2, blah_3, blah_4,
+   blah_5, blah_6, blah_7, blah_8, blah_9,
+   blah_10, blah_11, blah_12, blah_13, blah_14,
+   blah_15, blah_16, blah_17, blah_18, blah_19,
+   blah_20, blah_21, blah_22, blah_23, blah_24,
+   blah_25, blah_26, blah_27, blah_28, blah_29,
+   blah_30, blah_31, blah_32, blah_33, blah_34,
+   blah_35, blah_36, blah_37, blah_38, blah_39,
+   blah_40, blah_41, blah_42, blah_43, blah_44,
+   blah_45, blah_46, blah_47, blah_48, blah_49,
+   blah_50, blah_51, blah_52, blah_53, blah_54,
+   blah_55, blah_56, blah_57, blah_58, blah_59,
+   blah_60, blah_61, blah_62, blah_63, blah_64,
+   blah_65, blah_66, blah_67, blah_68, blah_69,
+   blah_70, blah_71, blah_72, blah_73, blah_74,
+   blah_75, blah_76, blah_77, blah_78, blah_79,
+   blah_80, blah_81, blah_82, blah_83, blah_84,
+   blah_85, blah_86, blah_87, blah_88, blah_89,
+   blah_90, blah_91, blah_92, blah_93, blah_94,
+   blah_95, blah_96, blah_97, blah_98, blah_99,
+   blah_100, blah_101, blah_102, blah_103, blah_104,
+   blah_105, blah_106, blah_107, blah_108, blah_109,
+   blah_110, blah_111, blah_112, blah_113, blah_114,
+   blah_115, blah_116, blah_117, blah_118, blah_119,
+   blah_120, blah_121, blah_122, blah_123, blah_124,
+   blah_125, blah_126, blah_127, blah_128, blah_129,
+   blah_130, blah_131, blah_132, blah_133, blah_134,
+   blah_135, blah_136, blah_137, blah_138, blah_139,
+   blah_140, blah_141, blah_142, blah_143, blah_144,
+   blah_145, blah_146, blah_147, blah_148, blah_149,
+   blah_150, blah_151, blah_152, blah_153, blah_154,
+   blah_155, blah_156, blah_157, blah_158, blah_159,
+   blah_160, blah_161, blah_162, blah_163, blah_164,
+   blah_165, blah_166, blah_167, blah_168, blah_169,
+   blah_170, blah_171, blah_172, blah_173, blah_174,
+   blah_175, blah_176, blah_177, blah_178, blah_179,
+   blah_180, blah_181, blah_182, blah_183, blah_184,
+   blah_185, blah_186, blah_187, blah_188, blah_189,
+   blah_190, blah_191, blah_192, blah_193, blah_194,
+   blah_195, blah_196, blah_197, blah_198, blah_199,
+   blah_200, blah_201, blah_202, blah_203, blah_204,
+   blah_205, blah_206, blah_207, blah_208, blah_209,
+   blah_210, blah_211, blah_212, blah_213, blah_214,
+   blah_215, blah_216, blah_217, blah_218, blah_219,
+   blah_220, blah_221, blah_222, blah_223, blah_224,
+   blah_225, blah_226, blah_227, blah_228, blah_229,
+   blah_230, blah_231, blah_232, blah_233, blah_234,
+   blah_235, blah_236, blah_237, blah_238, blah_239,
+   blah_240, blah_241, blah_242, blah_243, blah_244,
+   blah_245, blah_246, blah_247, blah_248, blah_249,
+   blah_250, blah_251, blah_252, blah_253, blah_254,
+   blah_255, blah_256, blah_257, blah_258, blah_259,
+   blah_260, blah_261, blah_262, blah_263, blah_264,
+   blah_265, blah_266, blah_267, blah_268, blah_269,
+   blah_270, blah_271, blah_272, blah_273, blah_274,
+   blah_275, blah_276, blah_277, blah_278, blah_279,
+   blah_280, blah_281, blah_282, blah_283, blah_284,
+   blah_285, blah_286, blah_287, blah_288, blah_289,
+   blah_290, blah_291, blah_292, blah_293, blah_294,
+   blah_295, blah_296, blah_297, blah_298, blah_299,
+   blah_300, blah_301, blah_302, blah_303, blah_304,
+   blah_305, blah_306, blah_307, blah_308, blah_309,
+   blah_310, blah_311, blah_312, blah_313, blah_314,
+   blah_315, blah_316, blah_317, blah_318, blah_319,
+   blah_320, blah_321, blah_322, blah_323, blah_324,
+   blah_325, blah_326, blah_327, blah_328, blah_329,
+   blah_330, blah_331, blah_332, blah_333, blah_334,
+   blah_335, blah_336, blah_337, blah_338, blah_339,
+   blah_340, blah_341, blah_342, blah_343, blah_344,
+   blah_345, blah_346, blah_347, blah_348, blah_349,
+   blah_350, blah_351, blah_352, blah_353, blah_354,
+	blah_355, blah_356, blah_357, blah_358, blah_359,
+	blah_360, blah_361, blah_362, blah_363, blah_364,
+	blah_365, blah_366, blah_367, blah_368, blah_369,
+	blah_370, blah_371, blah_372, blah_373, blah_374,
+	blah_375, blah_376, blah_377, blah_378, blah_379,
+	blah_380, blah_381, blah_382, blah_383, blah_384,
+	blah_385, blah_386, blah_387, blah_388, blah_389,
+	blah_390, blah_391, blah_392, blah_393, blah_394,
+	blah_395, blah_396, blah_397, blah_398, blah_399,
+	blah_400,
+	ce_first=blah_0,ce_last=blah_400
+};
+
 //-----------------------------------------------------------------------------------------
 using namespace FIX8;
 
@@ -271,3 +357,12 @@ TEST_CASE("nested type")
 	REQUIRE(conjure_type<TEST::TEST1::foo>::as_string_view() == "TEST::TEST1::foo");
 }
 
+//-----------------------------------------------------------------------------------------
+TEST_CASE("enum limits")
+{
+	REQUIRE(conjure_enum<numbers>::get_enum_min_value() == conjure_enum<numbers>::get_actual_enum_min_value());
+	REQUIRE(conjure_enum<numbers>::get_enum_max_value() == conjure_enum<numbers>::get_actual_enum_max_value());
+	REQUIRE(conjure_enum<numbers>::get_enum_min_value() == 0);
+	REQUIRE(conjure_enum<numbers>::get_enum_max_value() == 400);
+}
+
diff --git a/utests/unittests.cpp b/utests/unittests.cpp
index 815af1e4..a6377224 100644
--- a/utests/unittests.cpp
+++ b/utests/unittests.cpp
@@ -1,6 +1,6 @@
 //-----------------------------------------------------------------------------------------
 // SPDX-License-Identifier: MIT
-// SPDX-FileCopyrightText: Copyright (C) 2024 Fix8 Market Technologies Pty Ltd
+// SPDX-FileCopyrightText: Copyright (C) 2024-25 Fix8 Market Technologies Pty Ltd
 // SPDX-FileType: SOURCE
 //
 // conjure_enum (header only)
@@ -69,6 +69,10 @@ enum class numbers64
 	sixty, sixty_one, sixty_two, sixty_three
 };
 enum class reverse_range_test { first=7, second=6, third=5, fourth=4, fifth=3, sixth=2, seventh=1, eighth=0 };
+enum class neg_one_plus_continuous { neg_one=-1, zero=0, one=1, two=2, three=3 };
+enum class neg_one_plus_noncontinuous { neg_one=-1, zero=0, one=1, three=3 };
+enum class one_plus_continuous { one=1, two=2, three=3 };
+enum class one_plus_noncontinuous { one=1, three=3 };
 
 //-----------------------------------------------------------------------------------------
 // run as: ctest --output-on-failure
@@ -154,6 +158,10 @@ TEST_CASE("is_continuous")
 	REQUIRE(!conjure_enum<component>::is_continuous());
 	REQUIRE(conjure_enum<numbers>::is_continuous());
 	REQUIRE(conjure_enum<reverse_range_test>::is_continuous());
+	REQUIRE(conjure_enum<neg_one_plus_continuous>::is_continuous());
+	REQUIRE(!conjure_enum<neg_one_plus_noncontinuous>::is_continuous());
+	REQUIRE(conjure_enum<one_plus_continuous>::is_continuous());
+	REQUIRE(!conjure_enum<one_plus_noncontinuous>::is_continuous());
 }
 
 //-----------------------------------------------------------------------------------------
@@ -278,6 +286,10 @@ TEST_CASE("contains")
 	REQUIRE(conjure_enum<component1>::contains<path>());
 	REQUIRE(conjure_enum<numbers>::contains(numbers::five));
 	REQUIRE(!conjure_enum<numbers>::contains(static_cast<numbers>(100)));
+	REQUIRE(conjure_enum<one_plus_continuous>::contains(static_cast<one_plus_continuous>(2)));
+	REQUIRE(!conjure_enum<one_plus_noncontinuous>::contains(static_cast<one_plus_noncontinuous>(2)));
+	REQUIRE(conjure_enum<neg_one_plus_continuous>::contains(static_cast<neg_one_plus_continuous>(2)));
+	REQUIRE(!conjure_enum<neg_one_plus_noncontinuous>::contains(static_cast<neg_one_plus_noncontinuous>(2)));
 }
 
 //-----------------------------------------------------------------------------------------
@@ -291,6 +303,14 @@ TEST_CASE("enum_to_string")
 	REQUIRE(conjure_enum<component1>::enum_to_string<component1::fragment>() == "fragment");
 	using enum numbers;
 	REQUIRE(conjure_enum<numbers>::enum_to_string<two>() == "numbers::two");
+	REQUIRE(conjure_enum<neg_one_plus_continuous>::enum_to_string<neg_one_plus_continuous::neg_one>() == "neg_one_plus_continuous::neg_one");
+	REQUIRE(conjure_enum<neg_one_plus_noncontinuous>::enum_to_string<neg_one_plus_noncontinuous::neg_one>() == "neg_one_plus_noncontinuous::neg_one");
+	REQUIRE(conjure_enum<one_plus_continuous>::enum_to_string<one_plus_continuous::one>() == "one_plus_continuous::one");
+	REQUIRE(conjure_enum<one_plus_noncontinuous>::enum_to_string<one_plus_noncontinuous::one>() == "one_plus_noncontinuous::one");
+	REQUIRE(conjure_enum<neg_one_plus_continuous>::enum_to_string(neg_one_plus_continuous::neg_one) == "neg_one_plus_continuous::neg_one");
+	REQUIRE(conjure_enum<neg_one_plus_noncontinuous>::enum_to_string(neg_one_plus_noncontinuous::neg_one) == "neg_one_plus_noncontinuous::neg_one");
+	REQUIRE(conjure_enum<one_plus_continuous>::enum_to_string(one_plus_continuous::one) == "one_plus_continuous::one");
+	REQUIRE(conjure_enum<one_plus_noncontinuous>::enum_to_string(one_plus_noncontinuous::one) == "one_plus_noncontinuous::one");
 }
 
 //-----------------------------------------------------------------------------------------
@@ -392,6 +412,10 @@ TEST_CASE("index")
 	REQUIRE(conjure_enum<component>::index<component(100)>().value_or(100) == 100);
 	REQUIRE(conjure_enum<numbers>::index<numbers::five>().value() == 5);
 	REQUIRE(conjure_enum<numbers>::index<numbers(100)>().value_or(100) == 100);
+	REQUIRE(conjure_enum<neg_one_plus_continuous>::index<neg_one_plus_continuous::zero>().value() == 1);
+	REQUIRE(conjure_enum<neg_one_plus_noncontinuous>::index<neg_one_plus_noncontinuous::zero>().value() == 1);
+	REQUIRE(conjure_enum<one_plus_continuous>::index<one_plus_continuous::two>().value() == 1);
+	REQUIRE(conjure_enum<one_plus_noncontinuous>::index<one_plus_noncontinuous::three>().value() == 1);
 }
 
 //-----------------------------------------------------------------------------------------
@@ -453,8 +477,13 @@ TEST_CASE("for_each")
 	};
 	foo bar;
 	total = 0;
+	// test pointer to object
 	conjure_enum<component>::for_each(&foo::process, &bar, 10, std::ref(total));
 	REQUIRE(total == 160);
+	total = 0;
+	// test reference to object
+	conjure_enum<component>::for_each(&foo::process, bar, 10, std::ref(total));
+	REQUIRE(total == 160);
 }
 
 //-----------------------------------------------------------------------------------------
@@ -683,6 +712,16 @@ TEST_CASE("enum_bitset")
 	REQUIRE(ec.countr_zero() == 1);
 	REQUIRE(ec.countr_one() == 0);
 	REQUIRE(ec.countl_zero() == 6);
+
+	enum_bitset<numbers> ed({1, 3, 6});
+	REQUIRE(ed.to_ulong() == (1 << 1 | 1 << 3 | 1 << 6));
+	REQUIRE(ed.to_string() == "0001001010"s);
+	REQUIRE(ed.to_ulong() == 0b0001001010);
+
+	enum_bitset<numbers> ee(74);
+	REQUIRE(ee.to_ulong() == 0b0001001010);
+	enum_bitset<numbers> ef(1);
+	REQUIRE(ef.to_ulong() == 0b01);
 }
 
 //-----------------------------------------------------------------------------------------
@@ -861,6 +900,12 @@ TEST_CASE("enum_bitset using conjure_enum::dispatch")
 		ptr->total += conjure_enum<numbers>::dispatch(val, -1, arr, ptr, extr);
 	}, tarr, &bar, 1000);
 	REQUIRE(bar.total == 3998);
+	bar.total = 0;
+	enc.for_each([](numbers val, const auto& arr, foo& ptr, int extr)
+	{
+		ptr.total += conjure_enum<numbers>::dispatch(val, -1, arr, ptr, extr);
+	}, tarr, bar, 1000);
+	REQUIRE(bar.total == 3998);
 
 	const auto dd2
 	{