diff --git a/stl/debugger/STL.natvis b/stl/debugger/STL.natvis
index b9f0787bff6..eee583f922f 100644
--- a/stl/debugger/STL.natvis
+++ b/stl/debugger/STL.natvis
@@ -1404,6 +1404,14 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   </Type>
 
 
+  <Type Name="std::basic_const_iterator&lt;*&gt;">
+      <DisplayString>basic_const_iterator {_Current}</DisplayString>
+      <Expand>
+        <Item Name="current">_Current</Item>
+      </Expand>
+  </Type>
+
+
   <Type Name="std::complex&lt;*&gt;">
       <DisplayString Condition="(_Val[1] &lt; 0) &amp;&amp; (_Val[0] == 0)">-i*{-_Val[1]}</DisplayString>
       <DisplayString Condition="(_Val[1] &lt; 0) &amp;&amp; (_Val[0] != 0)">{_Val[0]}-i*{-_Val[1]}</DisplayString>
diff --git a/stl/inc/xutility b/stl/inc/xutility
index ba8ed1e070b..59150ecce96 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -1691,6 +1691,345 @@ _NODISCARD constexpr const _Elem* data(initializer_list<_Elem> _Ilist) noexcept
 template <class _Ty1, class _Ty2>
 concept _Not_same_as = (!same_as<remove_cvref_t<_Ty1>, remove_cvref_t<_Ty2>>);
 
+#if _HAS_CXX23
+_EXPORT_STD template <indirectly_readable _Ty>
+using iter_const_reference_t = common_reference_t<const iter_value_t<_Ty>&&, iter_reference_t<_Ty>>;
+
+template <class _Ty>
+concept _Constant_iterator = input_iterator<_Ty> && same_as<iter_const_reference_t<_Ty>, iter_reference_t<_Ty>>;
+
+_EXPORT_STD template <input_iterator _Iter>
+class basic_const_iterator;
+
+_EXPORT_STD template <input_iterator _Iter>
+using const_iterator = conditional_t<_Constant_iterator<_Iter>, _Iter, basic_const_iterator<_Iter>>;
+
+template <class _Sent>
+struct _Const_sentinel {
+    using type = _Sent;
+};
+
+template <input_iterator _Sent>
+struct _Const_sentinel<_Sent> {
+    using type = const_iterator<_Sent>;
+};
+
+_EXPORT_STD template <semiregular _Sent>
+using const_sentinel = typename _Const_sentinel<_Sent>::type;
+
+// clang-format off
+template <class _Ty>
+concept _Not_a_const_iterator = !_Is_specialization_v<_Ty, basic_const_iterator>;
+// clang-format on
+
+template <class>
+struct _Basic_const_iterator_category {};
+
+template <forward_iterator _Iter>
+struct _Basic_const_iterator_category<_Iter> {
+    using iterator_category = typename iterator_traits<_Iter>::iterator_category;
+};
+
+// TRANSITION, LLVM-55945: These are distinct concepts as a workaround
+template <class _Ty, class _Iter>
+concept _Bci_order =
+    _Not_same_as<_Ty, basic_const_iterator<_Iter>> && random_access_iterator<_Iter> && totally_ordered_with<_Iter, _Ty>;
+
+template <class _Ty, class _Iter>
+concept _Bci_order_3way = _Bci_order<_Ty, _Iter> && three_way_comparable_with<_Iter, _Ty>;
+
+template <class _Ty, class _Iter>
+concept _Not_bci_order =
+    _Not_a_const_iterator<_Ty> && random_access_iterator<_Iter> && totally_ordered_with<_Iter, _Ty>;
+
+_EXPORT_STD template <input_iterator _Iter>
+class basic_const_iterator : public _Basic_const_iterator_category<_Iter> {
+private:
+    /* [[no_unique_address]] */ _Iter _Current{};
+
+    using _Reference = iter_const_reference_t<_Iter>;
+
+    _NODISCARD static _CONSTEVAL auto _Get_iter_concept() noexcept {
+        if constexpr (contiguous_iterator<_Iter>) {
+            return contiguous_iterator_tag{};
+        } else if constexpr (random_access_iterator<_Iter>) {
+            return random_access_iterator_tag{};
+        } else if constexpr (bidirectional_iterator<_Iter>) {
+            return bidirectional_iterator_tag{};
+        } else if constexpr (forward_iterator<_Iter>) {
+            return forward_iterator_tag{};
+        } else {
+            return input_iterator_tag{};
+        }
+    }
+
+public:
+    using iterator_concept = decltype(_Get_iter_concept());
+    using value_type       = iter_value_t<_Iter>;
+    using difference_type  = iter_difference_t<_Iter>;
+
+    // clang-format off
+    basic_const_iterator() requires default_initializable<_Iter> = default;
+    // clang-format on
+
+    constexpr basic_const_iterator(_Iter _Current_) noexcept(is_nothrow_move_constructible_v<_Iter>) // strengthened
+        : _Current(_STD move(_Current_)) {}
+
+    template <convertible_to<_Iter> _Other>
+    constexpr basic_const_iterator(basic_const_iterator<_Other> _Current_) noexcept(
+        is_nothrow_constructible_v<_Iter, _Other>) // strengthened
+        : _Current(_STD move(_Current_._Current)) {}
+
+    template <_Not_same_as<basic_const_iterator> _Other>
+        requires convertible_to<_Other, _Iter>
+    constexpr basic_const_iterator(_Other&& _Current_) noexcept(
+        is_nothrow_constructible_v<_Iter, _Other>) // strengthened
+        : _Current(_STD forward<_Other>(_Current_)) {}
+
+    _NODISCARD constexpr const _Iter& base() const& noexcept {
+        return _Current;
+    }
+
+    _NODISCARD constexpr _Iter base() && noexcept(is_nothrow_move_constructible_v<_Iter>) /* strengthened */ {
+        return _STD move(_Current);
+    }
+
+    _NODISCARD constexpr _Reference operator*() const
+        noexcept(noexcept(static_cast<_Reference>(*_Current))) /* strengthened */ {
+        return static_cast<_Reference>(*_Current);
+    }
+
+    _NODISCARD constexpr const value_type* operator->() const
+        noexcept(contiguous_iterator<_Iter> || noexcept(*_Current)) /* strengthened */
+        requires is_lvalue_reference_v<iter_reference_t<_Iter>>
+              && same_as<remove_cvref_t<iter_reference_t<_Iter>>, value_type>
+    {
+        if constexpr (contiguous_iterator<_Iter>) {
+            return _STD to_address(_Current);
+        } else {
+            return _STD addressof(*_Current);
+        }
+    }
+
+    constexpr basic_const_iterator& operator++() noexcept(noexcept(++_Current)) /* strengthened */ {
+        ++_Current;
+        return *this;
+    }
+
+    constexpr void operator++(int) noexcept(noexcept(++_Current)) /* strengthened */ {
+        ++_Current;
+    }
+
+    constexpr basic_const_iterator operator++(int) noexcept(
+        noexcept(++*this) && is_nothrow_copy_constructible_v<basic_const_iterator>) // strengthened
+        requires forward_iterator<_Iter>
+    {
+        auto _Tmp = *this;
+        ++*this;
+        return _Tmp;
+    }
+
+    constexpr basic_const_iterator& operator--() noexcept(noexcept(--_Current)) // strengthened
+        requires bidirectional_iterator<_Iter>
+    {
+        --_Current;
+        return *this;
+    }
+
+    constexpr basic_const_iterator operator--(int) noexcept(
+        noexcept(--*this) && is_nothrow_copy_constructible_v<basic_const_iterator>) // strengthened
+        requires bidirectional_iterator<_Iter>
+    {
+        auto _Tmp = *this;
+        --*this;
+        return _Tmp;
+    }
+
+    constexpr basic_const_iterator& operator+=(const difference_type _Off) noexcept(
+        noexcept(_Current += _Off)) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        _Current += _Off;
+        return *this;
+    }
+
+    constexpr basic_const_iterator& operator-=(const difference_type _Off) noexcept(
+        noexcept(_Current -= _Off)) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        _Current -= _Off;
+        return *this;
+    }
+
+    _NODISCARD constexpr _Reference operator[](const difference_type _Idx) const
+        noexcept(noexcept(static_cast<_Reference>(_Current[_Idx]))) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        return static_cast<_Reference>(_Current[_Idx]);
+    }
+
+    template <sentinel_for<_Iter> _Sent>
+    _NODISCARD constexpr bool operator==(const _Sent& _Se) const // per LWG-3769
+        noexcept(noexcept(_Fake_copy_init<bool>(_Current == _Se))) /* strengthened */ {
+        return _Current == _Se;
+    }
+
+    _NODISCARD_FRIEND constexpr bool
+        operator<(const basic_const_iterator& _Left, const basic_const_iterator& _Right) noexcept(
+            noexcept(_Fake_copy_init<bool>(_Left._Current < _Right._Current))) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        return _Left._Current < _Right._Current;
+    }
+
+    _NODISCARD_FRIEND constexpr bool
+        operator>(const basic_const_iterator& _Left, const basic_const_iterator& _Right) noexcept(
+            noexcept(_Fake_copy_init<bool>(_Left._Current > _Right._Current))) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        return _Left._Current > _Right._Current;
+    }
+
+    _NODISCARD_FRIEND constexpr bool
+        operator<=(const basic_const_iterator& _Left, const basic_const_iterator& _Right) noexcept(
+            noexcept(_Fake_copy_init<bool>(_Left._Current <= _Right._Current))) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        return _Left._Current <= _Right._Current;
+    }
+
+    _NODISCARD_FRIEND constexpr bool
+        operator>=(const basic_const_iterator& _Left, const basic_const_iterator& _Right) noexcept(
+            noexcept(_Fake_copy_init<bool>(_Left._Current >= _Right._Current))) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        return _Left._Current >= _Right._Current;
+    }
+
+    _NODISCARD_FRIEND constexpr auto operator<=>(const basic_const_iterator& _Left,
+        const basic_const_iterator& _Right) noexcept(noexcept(_Left._Current <=> _Right._Current)) // strengthened
+        requires random_access_iterator<_Iter> && three_way_comparable<_Iter>
+    {
+        return _Left._Current <=> _Right._Current;
+    }
+
+    template <_Bci_order<_Iter> _Other>
+    _NODISCARD_FRIEND constexpr bool operator<(const basic_const_iterator& _Left, const _Other& _Right) noexcept(
+        noexcept(_Fake_copy_init<bool>(_Left._Current < _Right))) /* strengthened */ {
+        return _Left._Current < _Right;
+    }
+
+    template <_Bci_order<_Iter> _Other>
+    _NODISCARD_FRIEND constexpr bool operator>(const basic_const_iterator& _Left, const _Other& _Right) noexcept(
+        noexcept(_Fake_copy_init<bool>(_Left._Current > _Right))) /* strengthened */ {
+        return _Left._Current > _Right;
+    }
+
+    template <_Bci_order<_Iter> _Other>
+    _NODISCARD_FRIEND constexpr bool operator<=(const basic_const_iterator& _Left, const _Other& _Right) noexcept(
+        noexcept(_Fake_copy_init<bool>(_Left._Current <= _Right))) /* strengthened */ {
+        return _Left._Current <= _Right;
+    }
+
+    template <_Bci_order<_Iter> _Other>
+    _NODISCARD_FRIEND constexpr bool operator>=(const basic_const_iterator& _Left, const _Other& _Right) noexcept(
+        noexcept(_Fake_copy_init<bool>(_Left._Current >= _Right))) /* strengthened */ {
+        return _Left._Current >= _Right;
+    }
+
+    template <_Not_bci_order<_Iter> _Other>
+    _NODISCARD_FRIEND constexpr bool operator<(const _Other& _Left, const basic_const_iterator& _Right) noexcept(
+        noexcept(_Fake_copy_init<bool>(_Left < _Right._Current))) /* strengthened */ {
+        return _Left < _Right._Current;
+    }
+
+    template <_Not_bci_order<_Iter> _Other>
+    _NODISCARD_FRIEND constexpr bool operator>(const _Other& _Left, const basic_const_iterator& _Right) noexcept(
+        noexcept(_Fake_copy_init<bool>(_Left > _Right._Current))) /* strengthened */ {
+        return _Left > _Right._Current;
+    }
+
+    template <_Not_bci_order<_Iter> _Other>
+    _NODISCARD_FRIEND constexpr bool operator<=(const _Other& _Left, const basic_const_iterator& _Right) noexcept(
+        noexcept(_Fake_copy_init<bool>(_Left <= _Right._Current))) /* strengthened */ {
+        return _Left <= _Right._Current;
+    }
+
+    template <_Not_bci_order<_Iter> _Other>
+    _NODISCARD_FRIEND constexpr bool operator>=(const _Other& _Left, const basic_const_iterator& _Right) noexcept(
+        noexcept(_Fake_copy_init<bool>(_Left >= _Right._Current))) /* strengthened */ {
+        return _Left >= _Right._Current;
+    }
+
+    template <_Bci_order_3way<_Iter> _Other>
+    _NODISCARD_FRIEND constexpr auto operator<=>(const basic_const_iterator& _Left, const _Other& _Right) noexcept(
+        noexcept(_Left._Current <=> _Right)) /* strengthened */ {
+        return _Left._Current <=> _Right;
+    }
+
+    _NODISCARD_FRIEND constexpr basic_const_iterator operator+(const basic_const_iterator& _It,
+        const difference_type _Off) noexcept(noexcept(basic_const_iterator{_It._Current + _Off})) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        return basic_const_iterator{_It._Current + _Off};
+    }
+
+    _NODISCARD_FRIEND constexpr basic_const_iterator operator+(const difference_type _Off,
+        const basic_const_iterator& _It) noexcept(noexcept(basic_const_iterator{_It._Current + _Off})) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        return basic_const_iterator{_It._Current + _Off};
+    }
+
+    _NODISCARD_FRIEND constexpr basic_const_iterator operator-(const basic_const_iterator& _It,
+        const difference_type _Off) noexcept(noexcept(basic_const_iterator{_It._Current - _Off})) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        return basic_const_iterator{_It._Current - _Off};
+    }
+
+    template <sized_sentinel_for<_Iter> _Sent>
+    _NODISCARD constexpr difference_type operator-(const _Sent& _Se) const // per LWG-3769
+        noexcept(noexcept(_Current - _Se)) /* strengthened */ {
+        return _Current - _Se;
+    }
+
+    template <_Not_a_const_iterator _Sent>
+        requires sized_sentinel_for<_Sent, _Iter>
+    _NODISCARD_FRIEND constexpr difference_type operator-(const _Sent& _Se, const basic_const_iterator& _It) noexcept(
+        noexcept(_Se - _It._Current)) /* strengthened */ { // per LWG-3769
+        return _Se - _It._Current;
+    }
+};
+
+template <class _Ty1, common_with<_Ty1> _Ty2>
+struct common_type<basic_const_iterator<_Ty1>, _Ty2> {
+    using type = basic_const_iterator<common_type_t<_Ty1, _Ty2>>;
+};
+
+template <class _Ty1, common_with<_Ty1> _Ty2>
+struct common_type<_Ty2, basic_const_iterator<_Ty1>> {
+    using type = basic_const_iterator<common_type_t<_Ty1, _Ty2>>;
+};
+
+template <class _Ty1, common_with<_Ty1> _Ty2>
+struct common_type<basic_const_iterator<_Ty1>, basic_const_iterator<_Ty2>> {
+    using type = basic_const_iterator<common_type_t<_Ty1, _Ty2>>;
+};
+
+_EXPORT_STD template <input_iterator _Iter>
+_NODISCARD constexpr const_iterator<_Iter> make_const_iterator(_Iter _It) noexcept(
+    is_nothrow_constructible_v<const_iterator<_Iter>, _Iter&>) /* strengthened */ {
+    return _It;
+}
+
+_EXPORT_STD template <semiregular _Sent>
+_NODISCARD constexpr const_sentinel<_Sent> make_const_sentinel(_Sent _Se) noexcept(
+    is_nothrow_constructible_v<const_sentinel<_Sent>, _Sent&>) /* strengthened */ {
+    return _Se;
+}
+#endif // _HAS_CXX23
+
 namespace ranges {
     template <class>
     inline constexpr bool _Has_complete_elements = false;
diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h
index 7e7c78319ff..cd8749a4571 100644
--- a/stl/inc/yvals_core.h
+++ b/stl/inc/yvals_core.h
@@ -322,6 +322,8 @@
 // P2166R1 Prohibiting basic_string And basic_string_view Construction From nullptr
 // P2186R2 Removing Garbage Collection Support
 // P2273R3 constexpr unique_ptr
+// P2278R4 cbegin Should Always Return A Constant Iterator
+//     ("Iterators" section from the paper only)
 // P2291R3 constexpr Integral <charconv>
 // P2302R4 ranges::contains, ranges::contains_subrange
 // P2321R2 zip
diff --git a/tests/std/include/range_algorithm_support.hpp b/tests/std/include/range_algorithm_support.hpp
index 1f88f13a11d..1c4c0db2ce6 100644
--- a/tests/std/include/range_algorithm_support.hpp
+++ b/tests/std/include/range_algorithm_support.hpp
@@ -361,7 +361,7 @@ namespace test {
     template <class Category, class Element,
         // Model sized_sentinel_for along with sentinel?
         CanDifference Diff = CanDifference{derived_from<Category, random>},
-        // Model sentinel_for with self (and sized_sentinel_for if Diff; implies copyable)?
+        // Model sentinel_for with self (and sized_sentinel_for if Diff implies copyable)?
         CanCompare Eq = CanCompare{derived_from<Category, fwd>},
         // Use a ProxyRef reference type (instead of Element&)?
         ProxyRef Proxy = ProxyRef{!derived_from<Category, contiguous>},
diff --git a/tests/std/test.lst b/tests/std/test.lst
index 24d9ded681f..2501eeab87c 100644
--- a/tests/std/test.lst
+++ b/tests/std/test.lst
@@ -545,6 +545,8 @@ tests\P2136R3_invoke_r
 tests\P2162R2_std_visit_for_derived_classes_from_variant
 tests\P2231R1_complete_constexpr_optional_variant
 tests\P2273R3_constexpr_unique_ptr
+tests\P2278R4_basic_const_iterator
+tests\P2278R4_ranges_const_iterator_machinery
 tests\P2302R4_ranges_alg_contains
 tests\P2302R4_ranges_alg_contains_subrange
 tests\P2321R2_proxy_reference
diff --git a/tests/std/tests/P2278R4_basic_const_iterator/env.lst b/tests/std/tests/P2278R4_basic_const_iterator/env.lst
new file mode 100644
index 00000000000..18e2d7c71ec
--- /dev/null
+++ b/tests/std/tests/P2278R4_basic_const_iterator/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\concepts_latest_matrix.lst
diff --git a/tests/std/tests/P2278R4_basic_const_iterator/test.cpp b/tests/std/tests/P2278R4_basic_const_iterator/test.cpp
new file mode 100644
index 00000000000..b08f706aa6e
--- /dev/null
+++ b/tests/std/tests/P2278R4_basic_const_iterator/test.cpp
@@ -0,0 +1,288 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cassert>
+#include <iterator>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+#include "range_algorithm_support.hpp"
+
+using namespace std;
+
+template <typename T>
+concept Pointer = is_pointer_v<T>;
+
+template <typename It>
+concept HasPeek = requires(const It& iter) {
+                      { iter.peek() } -> Pointer;
+                      requires convertible_to<decltype(iter.peek()), const iter_value_t<It>*>;
+                  };
+
+static_assert(!HasPeek<int*>);
+static_assert(!HasPeek<reverse_iterator<int*>>);
+static_assert(HasPeek<test::iterator<forward_iterator_tag, int>>);
+
+template <input_iterator It>
+constexpr void test_one(It iter) {
+    using ConstIt = basic_const_iterator<It>;
+    using Se      = test::sentinel<const iter_value_t<ConstIt>>;
+
+    // Validate iterator concepts
+    static_assert(input_iterator<ConstIt>);
+    static_assert(forward_iterator<ConstIt> == forward_iterator<It>);
+    static_assert(bidirectional_iterator<ConstIt> == bidirectional_iterator<It>);
+    static_assert(random_access_iterator<ConstIt> == random_access_iterator<It>);
+    static_assert(contiguous_iterator<ConstIt> == contiguous_iterator<It>);
+
+    // Validate nested types
+    static_assert(same_as<typename ConstIt::value_type, iter_value_t<It>>);
+    static_assert(same_as<typename ConstIt::difference_type, iter_difference_t<It>>);
+    if constexpr (forward_iterator<It>) {
+        using Cat = typename iterator_traits<It>::iterator_category;
+        static_assert(same_as<typename ConstIt::iterator_category, Cat>);
+    }
+
+    // Validate default-initializability
+    static_assert(default_initializable<ConstIt> == default_initializable<It>);
+
+    same_as<ConstIt> auto citer = basic_const_iterator{iter};
+    if (!forward_iterator<It>) { // intentionally not if constexpr
+        return;
+    }
+
+    { // Validate basic_const_iterator::operator*()
+        same_as<iter_const_reference_t<It>> decltype(auto) val = *citer;
+        assert(val == *iter);
+        static_assert(noexcept(*citer) == noexcept(static_cast<iter_const_reference_t<It>>(*iter))); // strengthened
+    }
+
+    // Validate basic_const_iterator::operator->()
+    if constexpr (is_lvalue_reference_v<iter_reference_t<It>>
+                  && same_as<remove_cvref_t<iter_reference_t<It>>, iter_value_t<It>>) {
+        const same_as<const iter_value_t<It>*> auto ptr = citer.operator->();
+        assert(ptr == addressof(*citer));
+
+        if constexpr (contiguous_iterator<It>) {
+            static_assert(noexcept(citer.operator->()) == noexcept(to_address(iter))); // strengthened
+        } else {
+            static_assert(noexcept(citer.operator->()) == noexcept(addressof(*iter))); // strengthened
+        }
+    }
+
+    { // Validate basic_const_iterator::operator++()
+        same_as<ConstIt&> decltype(auto) citer2 = ++citer;
+        ++iter;
+        assert(citer2 == iter);
+        assert(*citer2 == *iter);
+        static_assert(noexcept(++citer) == noexcept(++iter)); // strengthened
+    }
+
+    // Validate basic_const_iterator::operator++(int)
+    if constexpr (forward_iterator<It>) {
+        same_as<ConstIt> decltype(auto) citer2 = citer++;
+        assert(citer2 == iter);
+        assert(*citer2 == *iter);
+        static_assert(
+            noexcept(citer++) == (noexcept(iter++) && is_nothrow_copy_constructible_v<ConstIt>) ); // strengthened
+    } else {
+        static_assert(is_void_v<decltype(citer++)>);
+        static_assert(noexcept(citer++) == noexcept(iter++)); // strengthened
+    }
+
+    iter++;
+    assert(citer == iter);
+    assert(*citer == *iter);
+
+
+    if constexpr (bidirectional_iterator<It>) {
+        { // Validate basic_const_iterator::operator--()
+            same_as<ConstIt&> decltype(auto) citer2 = --citer;
+            --iter;
+            assert(citer2 == iter);
+            assert(*citer2 == *iter);
+            static_assert(noexcept(--citer) == noexcept(--iter)); // strengthened
+        }
+
+        { // Validate basic_const_iterator::operator--(int)
+            same_as<ConstIt> decltype(auto) citer2 = citer--;
+            assert(citer2 == iter);
+            assert(*citer2 == *iter);
+            static_assert(
+                noexcept(citer--) == (noexcept(iter--) && is_nothrow_copy_constructible_v<ConstIt>) ); // strengthened
+
+            iter--;
+            assert(citer == iter);
+            assert(*citer == *iter);
+        }
+    }
+
+    if constexpr (random_access_iterator<It>) {
+        { // Validate basic_const_iterator::operator+=()
+            same_as<ConstIt&> decltype(auto) citer2 = (citer += 2);
+            iter += 2;
+            assert(citer2 == iter);
+            assert(*citer2 == *iter);
+            static_assert(noexcept(citer += 2) == noexcept(iter += 2)); // strengthened
+        }
+
+        { // Validate basic_const_iterator::operator-=()
+            same_as<ConstIt&> decltype(auto) citer2 = (citer -= 2);
+            iter -= 2;
+            assert(citer2 == iter);
+            assert(*citer2 == *iter);
+            static_assert(noexcept(citer -= 2) == noexcept(iter -= 2)); // strengthened
+        }
+
+        { // Validate basic_const_iterator::operator[]
+            same_as<iter_const_reference_t<It>> decltype(auto) val = citer[0];
+            assert(val == iter[0]);
+            static_assert(
+                noexcept(citer[0]) == noexcept(static_cast<iter_const_reference_t<It>>(iter[0]))); // strengthened
+        }
+
+        { // Validate operator{<, >, <=, >=, <=>}(const basic_const_iterator&, const basic_const_iterator&)
+            const same_as<ConstIt> auto citer2 = (citer + 1);
+            assert(citer < citer2);
+            assert(citer2 > citer);
+            assert(citer <= citer2);
+            assert(citer2 >= citer);
+            assert(citer2 <=> citer == partial_ordering::greater);
+
+            static_assert(noexcept(citer < citer2) == noexcept(citer.base() < citer2.base())); // strengthened
+            static_assert(noexcept(citer2 > citer) == noexcept(citer2.base() > citer.base())); // strengthened
+            static_assert(noexcept(citer <= citer2) == noexcept(citer.base() <= citer2.base())); // strengthened
+            static_assert(noexcept(citer2 >= citer) == noexcept(citer2.base() >= citer.base())); // strengthened
+            static_assert(noexcept(citer2 <=> citer) == noexcept(citer2.base() <=> citer.base())); // strengthened
+        }
+
+        iter += 2; // advance iter temporarily
+
+        { // Validate operator{<, >, <=, >=, <=>}(const basic_const_iterator&, const "not same as
+          // basic_const_iterator"&)
+            assert(citer < iter);
+            assert(!(citer > iter));
+            assert(citer <= iter);
+            assert(!(citer >= iter));
+            assert(citer <=> iter == partial_ordering::less);
+
+            static_assert(noexcept(citer < iter) == noexcept(citer.base() < iter)); // strengthened
+            static_assert(noexcept(!(citer > iter)) == noexcept(!(citer.base() > iter))); // strengthened
+            static_assert(noexcept(citer <= iter) == noexcept(citer.base() <= iter)); // strengthened
+            static_assert(noexcept(!(citer >= iter)) == noexcept(!(citer.base() >= iter))); // strengthened
+            static_assert(noexcept(citer <=> iter) == noexcept(citer.base() <=> iter)); // strengthened
+        }
+
+        { // Validate operator{<, >, <=, >=}(const "not a const iterator"&, const basic_const_iterator&)
+            assert(!(iter < citer));
+            assert(iter > citer);
+            assert(!(iter <= citer));
+            assert(iter >= citer);
+
+            static_assert(noexcept(!(iter < citer)) == noexcept(!(iter < citer.base()))); // strengthened
+            static_assert(noexcept(iter > citer) == noexcept(iter > citer.base())); // strengthened
+            static_assert(noexcept(!(iter <= citer)) == noexcept(!(iter <= citer.base()))); // strengthened
+            static_assert(noexcept(iter >= citer) == noexcept(iter >= citer.base())); // strengthened
+        }
+
+        { // Validate operator+(const basic_const_iterator&, difference_type)
+            const same_as<ConstIt> auto citer2 = (citer + 2);
+            const same_as<ConstIt> auto citer3 = (2 + citer);
+            assert(citer2 == citer3);
+            assert(*citer2 == *iter);
+
+            static_assert(noexcept(citer + 2) == noexcept(iter + 2)); // strengthened
+            static_assert(noexcept(2 + citer) == noexcept(2 + iter)); // strengthened
+        }
+
+        { // Validate operator-(const basic_const_iterator&, difference_type)
+            citer += 4;
+            const same_as<ConstIt> auto citer2 = (citer - 2);
+            assert(*citer2 == *iter);
+            citer -= 4;
+
+            static_assert(noexcept(citer - 2) == noexcept(iter - 2)); // strengthened
+        }
+
+        { // Validate operator-(const basic_const_iterator&, sized_sentinel)
+            assert(citer - citer == 0);
+            assert(citer - iter == -2);
+            assert(iter - citer == 2);
+            static_assert(noexcept(citer - citer) == noexcept(iter - iter)); // strengthened
+            static_assert(noexcept(citer - iter) == noexcept(iter - iter)); // strengthened
+            static_assert(noexcept(iter - citer) == noexcept(iter - iter)); // strengthened
+
+            if constexpr (HasPeek<It> && sized_sentinel_for<Se, It>) {
+                Se sent{iter.peek()};
+                assert(citer - sent == -2);
+                assert(sent - citer == 2);
+                static_assert(noexcept(citer - sent) == noexcept(iter - sent)); // strengthened
+                static_assert(noexcept(sent - citer) == noexcept(sent - iter)); // strengthened
+            }
+        }
+
+        iter -= 2;
+    }
+
+    // Validate to_address
+    if constexpr (contiguous_iterator<It> && HasPeek<It>) {
+        assert(to_address(citer) == iter.peek());
+    }
+
+    // Validate basic_const_iterator::operator==()
+    assert(citer == iter);
+    assert(iter == citer);
+    static_assert(noexcept(citer == iter) == noexcept(iter == iter));
+    if constexpr (HasPeek<It> && sentinel_for<Se, It>) {
+        Se sent{iter.peek()};
+        assert(citer == sent);
+        static_assert(noexcept(citer == sent) == noexcept(iter == sent)); // strengthened
+    }
+
+    { // Validate basic_const_iterator::base() const&
+        [[maybe_unused]] same_as<const It&> decltype(auto) base = citer.base();
+        static_assert(noexcept(citer.base()));
+    }
+
+    { // Validate basic_const_iterator::base() &&
+        [[maybe_unused]] same_as<It> decltype(auto) base = move(citer).base();
+        static_assert(noexcept(move(citer).base()) == is_nothrow_move_constructible_v<It>); // strengthened
+    }
+}
+
+static constexpr int some_ints[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+
+struct instantiator {
+    template <input_iterator It>
+    static constexpr void call() {
+        It iter{some_ints};
+        test_one(iter);
+    }
+};
+
+template <class Category, test::CanDifference CanDiff>
+using test_iterator = test::iterator<Category, const int, CanDiff, test::CanCompare::yes,
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}>;
+
+constexpr void instantiation_test() {
+    using test::CanDifference;
+
+    // The iterator is sensitive to category and differencing, but oblivious to proxyness
+    instantiator::call<test_iterator<input_iterator_tag, CanDifference::no>>();
+    instantiator::call<test_iterator<forward_iterator_tag, CanDifference::no>>();
+    instantiator::call<test_iterator<bidirectional_iterator_tag, CanDifference::no>>();
+    instantiator::call<test_iterator<random_access_iterator_tag, CanDifference::no>>();
+    instantiator::call<test_iterator<contiguous_iterator_tag, CanDifference::no>>();
+
+    instantiator::call<test_iterator<input_iterator_tag, CanDifference::yes>>();
+    instantiator::call<test_iterator<forward_iterator_tag, CanDifference::yes>>();
+    instantiator::call<test_iterator<bidirectional_iterator_tag, CanDifference::yes>>();
+    instantiator::call<test_iterator<random_access_iterator_tag, CanDifference::yes>>();
+    instantiator::call<test_iterator<contiguous_iterator_tag, CanDifference::yes>>();
+}
+
+int main() {
+    static_assert((instantiation_test(), true));
+    instantiation_test();
+}
diff --git a/tests/std/tests/P2278R4_ranges_const_iterator_machinery/env.lst b/tests/std/tests/P2278R4_ranges_const_iterator_machinery/env.lst
new file mode 100644
index 00000000000..18e2d7c71ec
--- /dev/null
+++ b/tests/std/tests/P2278R4_ranges_const_iterator_machinery/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\concepts_latest_matrix.lst
diff --git a/tests/std/tests/P2278R4_ranges_const_iterator_machinery/test.compile.pass.cpp b/tests/std/tests/P2278R4_ranges_const_iterator_machinery/test.compile.pass.cpp
new file mode 100644
index 00000000000..9a33ffe39d4
--- /dev/null
+++ b/tests/std/tests/P2278R4_ranges_const_iterator_machinery/test.compile.pass.cpp
@@ -0,0 +1,196 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <deque>
+#include <forward_list>
+#include <istream>
+#include <list>
+#include <ranges>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+using namespace std;
+
+template <typename It>
+concept CanIterConstRef = requires { typename iter_const_reference_t<It>; };
+
+template <typename It>
+concept CanConstIterator = requires(It it) {
+                               typename const_iterator<It>;
+                               { make_const_iterator(move(it)) } -> same_as<const_iterator<It>>;
+                           };
+
+template <typename Se>
+concept CanConstSentinel = requires(Se se) {
+                               typename const_sentinel<Se>;
+                               { make_const_sentinel(move(se)) } -> same_as<const_sentinel<Se>>;
+                           };
+
+static_assert(!CanIterConstRef<int>);
+static_assert(!CanIterConstRef<list<int>>);
+static_assert(!CanIterConstRef<deque<int>>);
+
+namespace test_pointer {
+    using Ptr = int*;
+    static_assert(CanIterConstRef<Ptr>);
+    static_assert(CanConstIterator<Ptr>);
+    static_assert(CanConstSentinel<Ptr>);
+    static_assert(same_as<iter_const_reference_t<Ptr>, const int&>);
+    static_assert(same_as<const_iterator<Ptr>, basic_const_iterator<Ptr>>);
+    static_assert(same_as<iter_reference_t<const_iterator<Ptr>>, const int&>);
+    static_assert(same_as<const_sentinel<Ptr>, basic_const_iterator<Ptr>>);
+    static_assert(same_as<iter_reference_t<const_sentinel<Ptr>>, const int&>);
+
+    using ConstPtr = const int*;
+    static_assert(CanIterConstRef<ConstPtr>);
+    static_assert(CanConstIterator<ConstPtr>);
+    static_assert(CanConstSentinel<ConstPtr>);
+    static_assert(same_as<iter_const_reference_t<ConstPtr>, const int&>);
+    static_assert(same_as<const_iterator<ConstPtr>, ConstPtr>);
+    static_assert(same_as<iter_reference_t<const_iterator<ConstPtr>>, const int&>);
+    static_assert(same_as<const_sentinel<ConstPtr>, ConstPtr>);
+
+    // Validate common_type
+    static_assert(same_as<common_type_t<basic_const_iterator<Ptr>, ConstPtr>, basic_const_iterator<ConstPtr>>);
+    static_assert(same_as<common_type_t<ConstPtr, basic_const_iterator<Ptr>>, basic_const_iterator<ConstPtr>>);
+    static_assert(same_as<common_type_t<basic_const_iterator<Ptr>, basic_const_iterator<ConstPtr>>,
+        basic_const_iterator<ConstPtr>>);
+} // namespace test_pointer
+
+namespace test_random_access_iter {
+    using Iter = deque<int>::iterator;
+    static_assert(CanIterConstRef<Iter>);
+    static_assert(CanConstIterator<Iter>);
+    static_assert(CanConstSentinel<Iter>);
+    static_assert(same_as<iter_const_reference_t<Iter>, const int&>);
+    static_assert(same_as<const_iterator<Iter>, basic_const_iterator<Iter>>);
+    static_assert(same_as<iter_reference_t<const_iterator<Iter>>, const int&>);
+    static_assert(same_as<const_sentinel<Iter>, basic_const_iterator<Iter>>);
+    static_assert(same_as<iter_reference_t<const_sentinel<Iter>>, const int&>);
+
+    using ConstIter = deque<int>::const_iterator;
+    static_assert(CanIterConstRef<ConstIter>);
+    static_assert(CanConstIterator<ConstIter>);
+    static_assert(CanConstSentinel<ConstIter>);
+    static_assert(same_as<iter_const_reference_t<ConstIter>, const int&>);
+    static_assert(same_as<const_iterator<ConstIter>, ConstIter>);
+    static_assert(same_as<iter_reference_t<const_iterator<ConstIter>>, const int&>);
+    static_assert(same_as<const_sentinel<ConstIter>, ConstIter>);
+} // namespace test_random_access_iter
+
+namespace test_bidirectional_iter {
+    using Iter = list<int>::iterator;
+    static_assert(CanIterConstRef<Iter>);
+    static_assert(CanConstIterator<Iter>);
+    static_assert(CanConstSentinel<Iter>);
+    static_assert(same_as<iter_const_reference_t<Iter>, const int&>);
+    static_assert(same_as<const_iterator<Iter>, basic_const_iterator<Iter>>);
+    static_assert(same_as<iter_reference_t<const_iterator<Iter>>, const int&>);
+    static_assert(same_as<const_sentinel<Iter>, basic_const_iterator<Iter>>);
+    static_assert(same_as<iter_reference_t<const_sentinel<Iter>>, const int&>);
+
+    using ConstIter = list<int>::const_iterator;
+    static_assert(CanIterConstRef<ConstIter>);
+    static_assert(CanConstIterator<ConstIter>);
+    static_assert(CanConstSentinel<ConstIter>);
+    static_assert(same_as<iter_const_reference_t<ConstIter>, const int&>);
+    static_assert(same_as<const_iterator<ConstIter>, ConstIter>);
+    static_assert(same_as<iter_reference_t<const_iterator<ConstIter>>, const int&>);
+    static_assert(same_as<const_sentinel<ConstIter>, ConstIter>);
+} // namespace test_bidirectional_iter
+
+namespace test_forward_iter {
+    using Iter = forward_list<int>::iterator;
+    static_assert(CanIterConstRef<Iter>);
+    static_assert(CanConstIterator<Iter>);
+    static_assert(CanConstSentinel<Iter>);
+    static_assert(same_as<iter_const_reference_t<Iter>, const int&>);
+    static_assert(same_as<const_iterator<Iter>, basic_const_iterator<Iter>>);
+    static_assert(same_as<iter_reference_t<const_iterator<Iter>>, const int&>);
+    static_assert(same_as<const_sentinel<Iter>, basic_const_iterator<Iter>>);
+    static_assert(same_as<iter_reference_t<const_sentinel<Iter>>, const int&>);
+
+    using ConstIter = forward_list<int>::const_iterator;
+    static_assert(CanIterConstRef<ConstIter>);
+    static_assert(CanConstIterator<ConstIter>);
+    static_assert(CanConstSentinel<ConstIter>);
+    static_assert(same_as<iter_const_reference_t<ConstIter>, const int&>);
+    static_assert(same_as<const_iterator<ConstIter>, ConstIter>);
+    static_assert(same_as<iter_reference_t<const_iterator<ConstIter>>, const int&>);
+    static_assert(same_as<const_sentinel<ConstIter>, ConstIter>);
+} // namespace test_forward_iter
+
+namespace test_input_iter {
+    using Iter = ranges::iterator_t<ranges::istream_view<int>>;
+    static_assert(CanIterConstRef<Iter>);
+    static_assert(CanConstIterator<Iter>);
+    static_assert(!CanConstSentinel<Iter>);
+    static_assert(same_as<iter_const_reference_t<Iter>, const int&>);
+    static_assert(same_as<const_iterator<Iter>, basic_const_iterator<Iter>>);
+    static_assert(same_as<iter_reference_t<const_iterator<Iter>>, const int&>);
+} // namespace test_input_iter
+
+namespace test_prvalue_iter {
+    using TransformView = ranges::transform_view<ranges::ref_view<deque<float>>, int (*)(float)>;
+
+    using Iter = ranges::iterator_t<TransformView>;
+    static_assert(CanIterConstRef<Iter>);
+    static_assert(CanConstIterator<Iter>);
+    static_assert(CanConstSentinel<Iter>);
+    static_assert(same_as<iter_const_reference_t<Iter>, int>);
+    static_assert(same_as<const_iterator<Iter>, Iter>);
+    static_assert(same_as<iter_reference_t<const_iterator<Iter>>, int>);
+    static_assert(same_as<const_sentinel<Iter>, Iter>);
+    static_assert(same_as<iter_reference_t<const_sentinel<Iter>>, int>);
+
+    using ConstIter = ranges::iterator_t<const TransformView>;
+    static_assert(CanIterConstRef<ConstIter>);
+    static_assert(CanConstIterator<ConstIter>);
+    static_assert(CanConstSentinel<ConstIter>);
+    static_assert(same_as<iter_const_reference_t<ConstIter>, int>);
+    static_assert(same_as<const_iterator<ConstIter>, ConstIter>);
+    static_assert(same_as<iter_reference_t<const_iterator<ConstIter>>, int>);
+    static_assert(same_as<const_sentinel<ConstIter>, ConstIter>);
+} // namespace test_prvalue_iter
+
+namespace test_vector_bool_iter {
+    using Iter = vector<bool>::iterator;
+    static_assert(CanIterConstRef<Iter>);
+    static_assert(CanConstIterator<Iter>);
+    static_assert(CanConstSentinel<Iter>);
+    static_assert(same_as<iter_const_reference_t<Iter>, bool>);
+    static_assert(same_as<const_iterator<Iter>, basic_const_iterator<Iter>>);
+    static_assert(same_as<iter_reference_t<const_iterator<Iter>>, bool>);
+    static_assert(same_as<const_sentinel<Iter>, basic_const_iterator<Iter>>);
+    static_assert(same_as<iter_reference_t<const_sentinel<Iter>>, bool>);
+
+    using ConstIter = vector<bool>::const_iterator;
+    static_assert(CanIterConstRef<ConstIter>);
+    static_assert(CanConstIterator<ConstIter>);
+    static_assert(CanConstSentinel<ConstIter>);
+    static_assert(same_as<iter_const_reference_t<ConstIter>, bool>);
+    static_assert(same_as<const_iterator<ConstIter>, ConstIter>);
+    static_assert(same_as<iter_reference_t<const_iterator<ConstIter>>, bool>);
+    static_assert(same_as<const_sentinel<ConstIter>, ConstIter>);
+} // namespace test_vector_bool_iter
+
+// Test standard sentinels
+static_assert(!CanIterConstRef<default_sentinel_t>);
+static_assert(!CanConstIterator<default_sentinel_t>);
+static_assert(CanConstSentinel<default_sentinel_t>);
+static_assert(same_as<const_sentinel<default_sentinel_t>, default_sentinel_t>);
+
+static_assert(!CanIterConstRef<unreachable_sentinel_t>);
+static_assert(!CanConstIterator<unreachable_sentinel_t>);
+static_assert(CanConstSentinel<unreachable_sentinel_t>);
+static_assert(same_as<const_sentinel<unreachable_sentinel_t>, unreachable_sentinel_t>);
+
+struct NotSemiregular {
+    NotSemiregular()                      = default;
+    NotSemiregular(const NotSemiregular&) = delete;
+};
+
+static_assert(!CanConstSentinel<NotSemiregular>);
+
+int main() {} // COMPILE-ONLY