diff --git a/libcxx/test/libcxx/ranges/range.utility.helpers/simple_view.compile.pass.cpp b/libcxx/test/libcxx/ranges/range.utility.helpers/simple_view.compile.pass.cpp
--- a/libcxx/test/libcxx/ranges/range.utility.helpers/simple_view.compile.pass.cpp
+++ b/libcxx/test/libcxx/ranges/range.utility.helpers/simple_view.compile.pass.cpp
@@ -36,7 +36,7 @@
 
 struct DifferentSentinel : std::ranges::view_base {
   int *begin() const;
-  sentinel_wrapper<int*> end() const;
+  sentinel<int*> end() const;
 };
 
 static_assert( std::ranges::__simple_view<SimpleView>);
diff --git a/libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_count_sentinel.pass.cpp b/libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_count_sentinel.pass.cpp
--- a/libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_count_sentinel.pass.cpp
+++ b/libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_count_sentinel.pass.cpp
@@ -83,7 +83,7 @@
 constexpr void check_forward(std::ptrdiff_t n, expected_t expected, range_t& range) {
   using Difference = std::iter_difference_t<It>;
   auto current = stride_counting_iterator(It(range.begin()));
-  Difference const result = std::ranges::advance(current, n, sentinel_wrapper(It(range.end())));
+  Difference const result = std::ranges::advance(current, n, sentinel(It(range.end())));
   assert(current.base().base() == expected.coordinate);
   assert(result == expected.result);
   assert(current.stride_count() == n - result);
diff --git a/libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_sentinel.pass.cpp b/libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_sentinel.pass.cpp
--- a/libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_sentinel.pass.cpp
+++ b/libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_sentinel.pass.cpp
@@ -74,7 +74,7 @@
   auto range = range_t{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
   auto first = stride_counting_iterator(It(range.begin()));
   auto const last = It(range.begin() + n);
-  std::ranges::advance(first, sentinel_wrapper(last));
+  std::ranges::advance(first, sentinel(last));
   assert(first.base() == last);
   assert(first.stride_count() == n);
 }
diff --git a/libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.next/iterator_sentinel.pass.cpp b/libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.next/iterator_sentinel.pass.cpp
--- a/libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.next/iterator_sentinel.pass.cpp
+++ b/libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.next/iterator_sentinel.pass.cpp
@@ -94,7 +94,7 @@
   auto n = (last.base() - it.base());
 
   {
-    auto sent = sentinel_wrapper(last);
+    auto sent = sentinel(last);
     It result = std::ranges::next(std::move(it), sent);
     assert(&*result == expected);
   }
@@ -102,7 +102,7 @@
   // Count operations
   {
     auto strided_it = stride_counting_iterator(it);
-    auto sent = sentinel_wrapper(stride_counting_iterator(last));
+    auto sent = sentinel(stride_counting_iterator(last));
     stride_counting_iterator result = std::ranges::next(std::move(strided_it), sent);
     assert(&*result == expected);
     assert(result.stride_count() == n); // must have used ++ until it hit the sentinel
diff --git a/libcxx/test/std/ranges/range.access/range.prim/empty.pass.cpp b/libcxx/test/std/ranges/range.access/range.prim/empty.pass.cpp
--- a/libcxx/test/std/ranges/range.access/range.prim/empty.pass.cpp
+++ b/libcxx/test/std/ranges/range.access/range.prim/empty.pass.cpp
@@ -46,7 +46,7 @@
 struct BadReturnType {
   BadReturnType empty() { return {}; }
 };
-static_assert(!std::is_invocable_v<RangeEmptyT, BadReturnType>);
+static_assert(!std::is_invocable_v<RangeEmptyT, BadReturnType&>);
 
 struct BoolConvertible {
   constexpr operator bool() noexcept(false) { return true; }
@@ -54,7 +54,6 @@
 struct BoolConvertibleReturnType {
   constexpr BoolConvertible empty() noexcept { return {}; }
 };
-
 static_assert(!noexcept(std::ranges::empty(BoolConvertibleReturnType())));
 
 constexpr bool testEmptyMember() {
@@ -91,79 +90,40 @@
   return true;
 }
 
-struct other_forward_iterator : forward_iterator<int*> { };
-
-struct sentinel {
-  constexpr bool operator==(std::input_or_output_iterator auto) const { return true; }
-};
-
 struct BeginEndNotSizedSentinel {
-  friend constexpr forward_iterator<int*> begin(BeginEndNotSizedSentinel) { return {}; }
-  friend constexpr sentinel end(BeginEndNotSizedSentinel) { return {}; }
-};
-static_assert(!std::is_invocable_v<RangeSizeT, BeginEndNotSizedSentinel&>);
-
-struct InvalidMinusBeginEnd {
-  friend constexpr random_access_iterator<int*> begin(InvalidMinusBeginEnd) { return {}; }
-  friend constexpr sentinel end(InvalidMinusBeginEnd) { return {}; }
-};
-
-// Int is integer-like, but it is not other_forward_iterator's difference_type.
-constexpr short operator-(sentinel, random_access_iterator<int*>) { return 2; }
-constexpr short operator-(random_access_iterator<int*>, sentinel) { return 2; }
-static_assert(!std::is_invocable_v<RangeSizeT, InvalidMinusBeginEnd&>);
-
-// This type will use ranges::size.
-struct IntPtrBeginAndEnd {
-  int buff[8];
-  constexpr int* begin() { return buff; }
-  constexpr int* end() { return buff + 8; }
+  constexpr int *begin() const { return nullptr; }
+  constexpr auto end() const { return sentinel<int*>(nullptr); }
 };
-static_assert(std::is_invocable_v<RangeSizeT, IntPtrBeginAndEnd&>);
+static_assert( std::ranges::forward_range<BeginEndNotSizedSentinel>);
+static_assert(!std::ranges::sized_range<BeginEndNotSizedSentinel>);
 
-// size is disabled here, and it isn't sized_sentinel_for, so we have to compare begin
-// and end again.
+// size is disabled here, so we have to compare begin and end.
 struct DisabledSizeRangeWithBeginEnd {
-  friend constexpr forward_iterator<int*> begin(DisabledSizeRangeWithBeginEnd) { return {}; }
-  friend constexpr sentinel end(DisabledSizeRangeWithBeginEnd) { return {}; }
-  constexpr size_t size() const { return 1; }
+  constexpr int *begin() const { return {}; }
+  constexpr sentinel<int*> end() const { return {}; }
+  size_t size() const;
 };
-
-template <>
+template<>
 inline constexpr bool std::ranges::disable_sized_range<DisabledSizeRangeWithBeginEnd> = true;
-static_assert(!std::is_invocable_v<RangeSizeT, DisabledSizeRangeWithBeginEnd&>);
+static_assert(std::ranges::contiguous_range<DisabledSizeRangeWithBeginEnd>);
+static_assert(!std::ranges::sized_range<DisabledSizeRangeWithBeginEnd>);
 
 struct BeginEndAndEmpty {
-  int* begin();
-  int* end();
-  constexpr bool empty() { return true; }
-};
-
-struct BeginEndAndConstEmpty {
-  int* begin();
-  int* end();
-  constexpr bool empty() const { return true; }
+  constexpr int *begin() const { return nullptr; }
+  constexpr int *end() const { return nullptr; }
+  constexpr bool empty() { return false; }
 };
 
 constexpr bool testBeginEqualsEnd() {
   BeginEndNotSizedSentinel a;
   assert(std::ranges::empty(a) == true);
 
-  InvalidMinusBeginEnd b;
-  assert(std::ranges::empty(b) == true);
-
-  IntPtrBeginAndEnd c;
-  assert(std::ranges::empty(c) == false);
-
   DisabledSizeRangeWithBeginEnd d;
   assert(std::ranges::empty(d) == true);
 
   BeginEndAndEmpty e;
-  assert(std::ranges::empty(e) == true);
-
-  BeginEndAndConstEmpty f;
-  assert(std::ranges::empty(f) == true);
-  assert(std::ranges::empty(std::as_const(f)) == true);
+  assert(std::ranges::empty(e) == false);  // using begin()==end()
+  assert(std::ranges::empty(std::as_const(e)) == true);  // using empty()
 
   return true;
 }
diff --git a/libcxx/test/std/ranges/range.access/range.prim/ssize.pass.cpp b/libcxx/test/std/ranges/range.access/range.prim/ssize.pass.cpp
--- a/libcxx/test/std/ranges/range.access/range.prim/ssize.pass.cpp
+++ b/libcxx/test/std/ranges/range.access/range.prim/ssize.pass.cpp
@@ -30,8 +30,7 @@
 struct SizeMember {
   constexpr size_t size() { return 42; }
 };
-
-static_assert(!std::is_invocable_v<RangeSSizeT, const SizeMember>);
+static_assert(!std::is_invocable_v<decltype(std::ranges::ssize), const SizeMember&>);
 
 struct SizeFunction {
   friend constexpr size_t size(SizeFunction) { return 42; }
@@ -41,18 +40,12 @@
   friend constexpr std::ptrdiff_t size(SizeFunctionSigned) { return 42; }
 };
 
-struct sentinel {
-  bool operator==(std::input_or_output_iterator auto) const { return true; }
-};
-
-struct RandomAccesslRange {
-  constexpr random_access_iterator<int*> begin() { return {}; }
-  constexpr sentinel end() { return {}; }
+int globalBuff[2];
+struct SizedSentinelRange {
+  constexpr int *begin() { return globalBuff; }
+  constexpr auto end() { return sized_sentinel<int*>(globalBuff + 2); }
 };
 
-constexpr std::ptrdiff_t operator-(const sentinel, const random_access_iterator<int*>) { return 2; }
-constexpr std::ptrdiff_t operator-(const random_access_iterator<int*>, const sentinel) { return 2; }
-
 struct ShortUnsignedReturnType {
   constexpr unsigned short size() { return 42; }
 };
@@ -75,7 +68,7 @@
   assert(std::ranges::ssize(SizeFunctionSigned()) == 42);
   ASSERT_SAME_TYPE(decltype(std::ranges::ssize(SizeFunctionSigned())), std::ptrdiff_t);
 
-  RandomAccesslRange b;
+  SizedSentinelRange b;
   assert(std::ranges::ssize(b) == 2);
   ASSERT_SAME_TYPE(decltype(std::ranges::ssize(b)), std::ptrdiff_t);
 
diff --git a/libcxx/test/std/ranges/range.adaptors/range.all/all_t.compile.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.all/all_t.compile.pass.cpp
--- a/libcxx/test/std/ranges/range.adaptors/range.all/all_t.compile.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.all/all_t.compile.pass.cpp
@@ -37,5 +37,5 @@
 ASSERT_SAME_TYPE(std::views::all_t<BorrowableRange const&>, std::ranges::ref_view<BorrowableRange const>);
 
 // Otherwise, returns subrange<iterator_t<T>, sentinel_t<R>>
-ASSERT_SAME_TYPE(std::views::all_t<BorrowableRange>, std::ranges::subrange<forward_iterator<int*>, sentinel>);
-ASSERT_SAME_TYPE(std::views::all_t<BorrowableRange const>, std::ranges::subrange<forward_iterator<int const*>, sentinel>);
+ASSERT_SAME_TYPE(std::views::all_t<BorrowableRange>, std::ranges::subrange<forward_iterator<int*>, sentinel<forward_iterator<int*>>>);
+ASSERT_SAME_TYPE(std::views::all_t<BorrowableRange const>, std::ranges::subrange<forward_iterator<const int*>, sentinel<forward_iterator<const int*>>>);
diff --git a/libcxx/test/std/ranges/range.adaptors/range.common.view/begin.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.common.view/begin.pass.cpp
--- a/libcxx/test/std/ranges/range.adaptors/range.common.view/begin.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.common.view/begin.pass.cpp
@@ -24,7 +24,7 @@
 
 struct MutableView : std::ranges::view_base {
   int* begin();
-  sentinel_wrapper<int*> end();
+  sentinel<int*> end();
 };
 
 template<class View>
@@ -66,22 +66,17 @@
   {
     SizedForwardView view{buf, buf + 8};
     std::ranges::common_view<SizedForwardView> common(view);
-    using CommonIter = std::common_iterator<ForwardIter, sentinel_wrapper<ForwardIter>>;
-    std::same_as<CommonIter> auto begin = common.begin();
-    assert(begin == std::ranges::begin(view));
-  }
-  {
-    SizedForwardView view{buf, buf + 8};
-    std::ranges::common_view<SizedForwardView> const common(view);
-    using CommonIter = std::common_iterator<ForwardIter, sentinel_wrapper<ForwardIter>>;
+    using CommonIter = std::common_iterator<ForwardIter, sized_sentinel<ForwardIter>>;
     std::same_as<CommonIter> auto begin = common.begin();
     assert(begin == std::ranges::begin(view));
+    std::same_as<CommonIter> auto cbegin = std::as_const(common).begin();
+    assert(cbegin == std::ranges::begin(view));
   }
 
   {
     MoveOnlyView view{buf, buf + 8};
     std::ranges::common_view<MoveOnlyView> common(std::move(view));
-    using CommonIter = std::common_iterator<int*, sentinel_wrapper<int*>>;
+    using CommonIter = std::common_iterator<int*, sentinel<int*>>;
     std::same_as<CommonIter> auto begin = common.begin();
     assert(begin == std::ranges::begin(view));
   }
@@ -89,7 +84,7 @@
   {
     CopyableView view{buf, buf + 8};
     std::ranges::common_view<CopyableView> const common(view);
-    using CommonIter = std::common_iterator<int*, sentinel_wrapper<int*>>;
+    using CommonIter = std::common_iterator<int*, sentinel<int*>>;
     std::same_as<CommonIter> auto begin = common.begin();
     assert(begin == std::ranges::begin(view));
   }
diff --git a/libcxx/test/std/ranges/range.adaptors/range.common.view/borrowing.compile.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.common.view/borrowing.compile.pass.cpp
--- a/libcxx/test/std/ranges/range.adaptors/range.common.view/borrowing.compile.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.common.view/borrowing.compile.pass.cpp
@@ -20,12 +20,12 @@
 
 struct View : std::ranges::view_base {
   int *begin() const;
-  sentinel_wrapper<int*> end() const;
+  sentinel<int*> end() const;
 };
 
 struct BorrowableView : std::ranges::view_base {
   int *begin() const;
-  sentinel_wrapper<int*> end() const;
+  sentinel<int*> end() const;
 };
 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<BorrowableView> = true;
diff --git a/libcxx/test/std/ranges/range.adaptors/range.common.view/ctad.compile.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.common.view/ctad.compile.pass.cpp
--- a/libcxx/test/std/ranges/range.adaptors/range.common.view/ctad.compile.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.common.view/ctad.compile.pass.cpp
@@ -20,17 +20,17 @@
 
 struct View : std::ranges::view_base {
   int *begin() const;
-  sentinel_wrapper<int*> end() const;
+  sentinel<int*> end() const;
 };
 
 struct Range {
   int *begin() const;
-  sentinel_wrapper<int*> end() const;
+  sentinel<int*> end() const;
 };
 
 struct BorrowedRange {
   int *begin() const;
-  sentinel_wrapper<int*> end() const;
+  sentinel<int*> end() const;
 };
 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<BorrowedRange> = true;
@@ -55,6 +55,6 @@
     static_assert(std::same_as<
         decltype(std::ranges::common_view(std::move(br))),
         std::ranges::common_view<std::ranges::subrange<
-          int *, sentinel_wrapper<int *>, std::ranges::subrange_kind::unsized>>
+          int *, sentinel<int *>, std::ranges::subrange_kind::unsized>>
     >);
 }
diff --git a/libcxx/test/std/ranges/range.adaptors/range.common.view/end.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.common.view/end.pass.cpp
--- a/libcxx/test/std/ranges/range.adaptors/range.common.view/end.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.common.view/end.pass.cpp
@@ -51,8 +51,8 @@
   {
     int buf[8] = {1, 2, 3, 4, 5, 6, 7, 8};
 
-    using CommonForwardIter = std::common_iterator<ForwardIter, sentinel_wrapper<ForwardIter>>;
-    using CommonIntIter = std::common_iterator<int*, sentinel_wrapper<int*>>;
+    using CommonForwardIter = std::common_iterator<ForwardIter, sized_sentinel<ForwardIter>>;
+    using CommonIntIter = std::common_iterator<int*, sentinel<int*>>;
 
     {
       SizedForwardView view{buf, buf + 8};
diff --git a/libcxx/test/std/ranges/range.adaptors/range.common.view/types.h b/libcxx/test/std/ranges/range.adaptors/range.common.view/types.h
--- a/libcxx/test/std/ranges/range.adaptors/range.common.view/types.h
+++ b/libcxx/test/std/ranges/range.adaptors/range.common.view/types.h
@@ -18,7 +18,7 @@
   int* end_ = nullptr;
   explicit DefaultConstructibleView() = default;
   constexpr int *begin() const { return begin_; }
-  constexpr auto end() const { return sentinel_wrapper<int*>(end_); }
+  constexpr auto end() const { return sentinel<int*>(end_); }
 };
 static_assert(std::ranges::view<DefaultConstructibleView>);
 static_assert(std::default_initializable<DefaultConstructibleView>);
@@ -30,7 +30,7 @@
   constexpr MoveOnlyView(MoveOnlyView&&) = default;
   constexpr MoveOnlyView& operator=(MoveOnlyView&&) = default;
   constexpr int *begin() const { return begin_; }
-  constexpr auto end() const { return sentinel_wrapper<int*>(end_); }
+  constexpr auto end() const { return sentinel<int*>(end_); }
 };
 static_assert( std::ranges::view<MoveOnlyView>);
 static_assert( std::ranges::contiguous_range<MoveOnlyView>);
@@ -41,7 +41,7 @@
   int* end_;
   constexpr explicit CopyableView(int* b, int* e) : begin_(b), end_(e) { }
   constexpr int *begin() const { return begin_; }
-  constexpr auto end() const { return sentinel_wrapper<int*>(end_); }
+  constexpr auto end() const { return sentinel<int*>(end_); }
 };
 static_assert(std::ranges::view<CopyableView>);
 static_assert(std::copyable<CopyableView>);
@@ -52,15 +52,8 @@
   int* end_;
   constexpr explicit SizedForwardView(int* b, int* e) : begin_(b), end_(e) { }
   constexpr auto begin() const { return forward_iterator<int*>(begin_); }
-  constexpr auto end() const { return sentinel_wrapper<forward_iterator<int*>>(forward_iterator<int*>(end_)); }
+  constexpr auto end() const { return sized_sentinel<forward_iterator<int*>>(forward_iterator<int*>(end_)); }
 };
-// Required to make SizedForwardView a sized view.
-constexpr auto operator-(sentinel_wrapper<ForwardIter> sent, ForwardIter iter) {
-  return sent.base().base() - iter.base();
-}
-constexpr auto operator-(ForwardIter iter, sentinel_wrapper<ForwardIter> sent) {
-  return iter.base() - sent.base().base();
-}
 static_assert(std::ranges::view<SizedForwardView>);
 static_assert(std::ranges::forward_range<SizedForwardView>);
 static_assert(std::ranges::sized_range<SizedForwardView>);
@@ -71,15 +64,8 @@
   int* end_;
   constexpr explicit SizedRandomAccessView(int* b, int* e) : begin_(b), end_(e) { }
   constexpr auto begin() const { return random_access_iterator<int*>(begin_); }
-  constexpr auto end() const { return sentinel_wrapper<random_access_iterator<int*>>(random_access_iterator<int*>(end_)); }
+  constexpr auto end() const { return sized_sentinel<random_access_iterator<int*>>(random_access_iterator<int*>(end_)); }
 };
-// Required to make SizedRandomAccessView a sized view.
-constexpr auto operator-(sentinel_wrapper<RandomAccessIter> sent, RandomAccessIter iter) {
-  return sent.base().base() - iter.base();
-}
-constexpr auto operator-(RandomAccessIter iter, sentinel_wrapper<RandomAccessIter> sent) {
-  return iter.base() - sent.base().base();
-}
 static_assert(std::ranges::view<SizedRandomAccessView>);
 static_assert(std::ranges::random_access_range<SizedRandomAccessView>);
 static_assert(std::ranges::sized_range<SizedRandomAccessView>);
@@ -99,7 +85,7 @@
   int* end_;
   constexpr explicit NonCommonView(int* b, int* e) : begin_(b), end_(e) { }
   constexpr int *begin() const { return begin_; }
-  constexpr auto end() const { return sentinel_wrapper<int*>(end_); }
+  constexpr auto end() const { return sentinel<int*>(end_); }
 };
 static_assert( std::ranges::view<NonCommonView>);
 static_assert(!std::ranges::common_range<NonCommonView>);
diff --git a/libcxx/test/std/ranges/range.adaptors/range.drop/end.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.drop/end.pass.cpp
--- a/libcxx/test/std/ranges/range.adaptors/range.drop/end.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.drop/end.pass.cpp
@@ -27,7 +27,7 @@
 
   // !simple-view<V>
   std::ranges::drop_view dropView2(InputView(), 4);
-  assert(dropView2.end() == globalBuff + 8);
+  assert(base(base(dropView2.end())) == globalBuff + 8);
 
   // range<const V>
   const std::ranges::drop_view dropView3(MoveOnlyView(), 0);
@@ -35,7 +35,7 @@
 
   // !simple-view<V>
   const std::ranges::drop_view dropView4(InputView(), 2);
-  assert(dropView4.end() == globalBuff + 8);
+  assert(base(base(dropView4.end())) == globalBuff + 8);
 
   // range<const V>
   std::ranges::drop_view dropView5(MoveOnlyView(), 10);
diff --git a/libcxx/test/std/ranges/range.adaptors/range.drop/types.h b/libcxx/test/std/ranges/range.adaptors/range.drop/types.h
--- a/libcxx/test/std/ranges/range.adaptors/range.drop/types.h
+++ b/libcxx/test/std/ranges/range.adaptors/range.drop/types.h
@@ -76,12 +76,9 @@
 inline constexpr bool std::ranges::enable_borrowed_range<BorrowableView> = true;
 
 struct InputView : std::ranges::view_base {
-  constexpr cpp20_input_iterator<int*> begin() const { return cpp20_input_iterator<int*>(globalBuff); }
-  constexpr int* end() const { return globalBuff + 8; }
+  constexpr auto begin() const { return cpp20_input_iterator<int*>(globalBuff); }
+  constexpr auto end() const { return sentinel<cpp20_input_iterator<int*>>(cpp20_input_iterator<int*>(globalBuff + 8)); }
 };
-// TODO: remove these bogus operators
-constexpr bool operator==(const cpp20_input_iterator<int*> &lhs, int* rhs) { return lhs.base() == rhs; }
-constexpr bool operator==(int* lhs, const cpp20_input_iterator<int*> &rhs) { return rhs.base() == lhs; }
 
 struct Range {
   int *begin() const;
diff --git a/libcxx/test/std/ranges/range.adaptors/range.join.view/ctad.compile.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.join.view/ctad.compile.pass.cpp
--- a/libcxx/test/std/ranges/range.adaptors/range.join.view/ctad.compile.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.join.view/ctad.compile.pass.cpp
@@ -22,24 +22,24 @@
   // All friends here are defined to prevent GCC warnings.
   friend T* begin(View&) { return nullptr; }
   friend T* begin(View const&) { return nullptr; }
-  friend sentinel_wrapper<T*> end(View&) { return sentinel_wrapper<T*>(nullptr); }
-  friend sentinel_wrapper<T*> end(View const&) { return sentinel_wrapper<T*>(nullptr); }
+  friend sentinel<T*> end(View&) { return sentinel<T*>(nullptr); }
+  friend sentinel<T*> end(View const&) { return sentinel<T*>(nullptr); }
 };
 
 template<class T>
 struct Range {
   friend T* begin(Range&) { return nullptr; }
   friend T* begin(Range const&) { return nullptr; }
-  friend sentinel_wrapper<T*> end(Range&) { return sentinel_wrapper<T*>(nullptr); }
-  friend sentinel_wrapper<T*> end(Range const&) { return sentinel_wrapper<T*>(nullptr); }
+  friend sentinel<T*> end(Range&) { return sentinel<T*>(nullptr); }
+  friend sentinel<T*> end(Range const&) { return sentinel<T*>(nullptr); }
 };
 
 template<class T>
 struct BorrowedRange {
   friend T* begin(BorrowedRange&) { return nullptr; }
   friend T* begin(BorrowedRange const&) { return nullptr; }
-  friend sentinel_wrapper<T*> end(BorrowedRange&) { return sentinel_wrapper<T*>(nullptr); }
-  friend sentinel_wrapper<T*> end(BorrowedRange const&) { return sentinel_wrapper<T*>(nullptr); }
+  friend sentinel<T*> end(BorrowedRange&) { return sentinel<T*>(nullptr); }
+  friend sentinel<T*> end(BorrowedRange const&) { return sentinel<T*>(nullptr); }
 };
 
 template<>
@@ -66,7 +66,7 @@
     static_assert(std::same_as<
         decltype(std::ranges::join_view(std::move(br))),
         std::ranges::join_view<std::ranges::subrange<BorrowedRange<int> *,
-                               sentinel_wrapper<BorrowedRange<int> *>,
+                               sentinel<BorrowedRange<int> *>,
                                std::ranges::subrange_kind::unsized>>
     >);
 }
diff --git a/libcxx/test/std/ranges/range.adaptors/range.join.view/ctad.verify.cpp b/libcxx/test/std/ranges/range.adaptors/range.join.view/ctad.verify.cpp
--- a/libcxx/test/std/ranges/range.adaptors/range.join.view/ctad.verify.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.join.view/ctad.verify.cpp
@@ -23,8 +23,8 @@
 struct Range {
   friend T* begin(Range&) { return nullptr; }
   friend T* begin(Range const&) { return nullptr; }
-  friend sentinel_wrapper<T*> end(Range&) { return sentinel_wrapper<T*>(nullptr); }
-  friend sentinel_wrapper<T*> end(Range const&) { return sentinel_wrapper<T*>(nullptr); }
+  friend sentinel<T*> end(Range&) { return sentinel<T*>(nullptr); }
+  friend sentinel<T*> end(Range const&) { return sentinel<T*>(nullptr); }
 };
 
 void testExplicitCTAD() {
diff --git a/libcxx/test/std/ranges/range.adaptors/range.reverse/begin.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.reverse/begin.pass.cpp
--- a/libcxx/test/std/ranges/range.adaptors/range.reverse/begin.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.reverse/begin.pass.cpp
@@ -57,13 +57,13 @@
 
   auto begin() { return CountedIter(begin_); }
   auto begin() const { return CountedIter(begin_); }
-  auto end() { return sentinel_wrapper<CountedIter>(CountedIter(end_)); }
-  auto end() const { return sentinel_wrapper<CountedIter>(CountedIter(end_)); }
+  auto end() { return sentinel<CountedIter>(CountedIter(end_)); }
+  auto end() const { return sentinel<CountedIter>(CountedIter(end_)); }
 };
 
 struct RASentRange : std::ranges::view_base {
-  using sent_t = sentinel_wrapper<random_access_iterator<int*>>;
-  using sent_const_t = sentinel_wrapper<random_access_iterator<const int*>>;
+  using sent_t = sentinel<random_access_iterator<int*>>;
+  using sent_const_t = sentinel<random_access_iterator<const int*>>;
 
   int* begin_;
   int* end_;
diff --git a/libcxx/test/std/ranges/range.adaptors/range.reverse/borrowing.compile.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.reverse/borrowing.compile.pass.cpp
--- a/libcxx/test/std/ranges/range.adaptors/range.reverse/borrowing.compile.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.reverse/borrowing.compile.pass.cpp
@@ -21,15 +21,15 @@
 struct View : std::ranges::view_base {
   friend int* begin(View&);
   friend int* begin(View const&);
-  friend sentinel_wrapper<int*> end(View&);
-  friend sentinel_wrapper<int*> end(View const&);
+  friend sentinel<int*> end(View&);
+  friend sentinel<int*> end(View const&);
 };
 
 struct BorrowableView : std::ranges::view_base {
   friend int* begin(BorrowableView&);
   friend int* begin(BorrowableView const&);
-  friend sentinel_wrapper<int*> end(BorrowableView&);
-  friend sentinel_wrapper<int*> end(BorrowableView const&);
+  friend sentinel<int*> end(BorrowableView&);
+  friend sentinel<int*> end(BorrowableView const&);
 };
 
 template<>
diff --git a/libcxx/test/std/ranges/range.adaptors/range.reverse/ctad.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.reverse/ctad.pass.cpp
--- a/libcxx/test/std/ranges/range.adaptors/range.reverse/ctad.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.reverse/ctad.pass.cpp
@@ -23,22 +23,22 @@
 struct View : std::ranges::view_base {
   friend int* begin(View&) { return nullptr; }
   friend int* begin(View const&) { return nullptr; }
-  friend sentinel_wrapper<int*> end(View&) { return sentinel_wrapper<int*>(nullptr); }
-  friend sentinel_wrapper<int*> end(View const&) { return sentinel_wrapper<int*>(nullptr); }
+  friend sentinel<int*> end(View&) { return sentinel<int*>(nullptr); }
+  friend sentinel<int*> end(View const&) { return sentinel<int*>(nullptr); }
 };
 
 struct Range {
   friend int* begin(Range&) { return nullptr; }
   friend int* begin(Range const&) { return nullptr; }
-  friend sentinel_wrapper<int*> end(Range&) { return sentinel_wrapper<int*>(nullptr); }
-  friend sentinel_wrapper<int*> end(Range const&) { return sentinel_wrapper<int*>(nullptr); }
+  friend sentinel<int*> end(Range&) { return sentinel<int*>(nullptr); }
+  friend sentinel<int*> end(Range const&) { return sentinel<int*>(nullptr); }
 };
 
 struct BorrowedRange {
   friend int* begin(BorrowedRange&) { return nullptr; }
   friend int* begin(BorrowedRange const&) { return nullptr; }
-  friend sentinel_wrapper<int*> end(BorrowedRange&) { return sentinel_wrapper<int*>(nullptr); }
-  friend sentinel_wrapper<int*> end(BorrowedRange const&) { return sentinel_wrapper<int*>(nullptr); }
+  friend sentinel<int*> end(BorrowedRange&) { return sentinel<int*>(nullptr); }
+  friend sentinel<int*> end(BorrowedRange const&) { return sentinel<int*>(nullptr); }
 };
 
 template<>
@@ -63,7 +63,7 @@
     (void)x;
   }
   {
-    using Subrange = std::ranges::subrange<int *, sentinel_wrapper<int *>, std::ranges::subrange_kind::unsized>;
+    using Subrange = std::ranges::subrange<int *, sentinel<int *>, std::ranges::subrange_kind::unsized>;
     std::same_as<std::ranges::reverse_view<Subrange>> auto x = std::ranges::reverse_view(std::move(br));
     (void)x;
   }
diff --git a/libcxx/test/std/ranges/range.adaptors/range.reverse/types.h b/libcxx/test/std/ranges/range.adaptors/range.reverse/types.h
--- a/libcxx/test/std/ranges/range.adaptors/range.reverse/types.h
+++ b/libcxx/test/std/ranges/range.adaptors/range.reverse/types.h
@@ -31,8 +31,8 @@
 enum CopyCategory { MoveOnly, Copyable };
 template<CopyCategory CC>
 struct BidirSentRange : std::ranges::view_base {
-  using sent_t = sentinel_wrapper<bidirectional_iterator<int*>>;
-  using sent_const_t = sentinel_wrapper<bidirectional_iterator<const int*>>;
+  using sent_t = sentinel<bidirectional_iterator<int*>>;
+  using sent_const_t = sentinel<bidirectional_iterator<const int*>>;
 
   int* begin_;
   int* end_;
diff --git a/libcxx/test/std/ranges/range.adaptors/range.take/borrowing.compile.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.take/borrowing.compile.pass.cpp
--- a/libcxx/test/std/ranges/range.adaptors/range.take/borrowing.compile.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.take/borrowing.compile.pass.cpp
@@ -21,15 +21,15 @@
 struct View : std::ranges::view_base {
   friend int* begin(View&);
   friend int* begin(View const&);
-  friend sentinel_wrapper<int*> end(View&);
-  friend sentinel_wrapper<int*> end(View const&);
+  friend sentinel<int*> end(View&);
+  friend sentinel<int*> end(View const&);
 };
 
 struct BorrowableView : std::ranges::view_base {
   friend int* begin(BorrowableView&);
   friend int* begin(BorrowableView const&);
-  friend sentinel_wrapper<int*> end(BorrowableView&);
-  friend sentinel_wrapper<int*> end(BorrowableView const&);
+  friend sentinel<int*> end(BorrowableView&);
+  friend sentinel<int*> end(BorrowableView const&);
 };
 
 template<>
diff --git a/libcxx/test/std/ranges/range.adaptors/range.take/ctad.compile.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.take/ctad.compile.pass.cpp
--- a/libcxx/test/std/ranges/range.adaptors/range.take/ctad.compile.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.take/ctad.compile.pass.cpp
@@ -22,22 +22,22 @@
 struct View : std::ranges::view_base {
   friend int* begin(View&);
   friend int* begin(View const&);
-  friend sentinel_wrapper<int*> end(View&);
-  friend sentinel_wrapper<int*> end(View const&);
+  friend sentinel<int*> end(View&);
+  friend sentinel<int*> end(View const&);
 };
 
 struct Range {
   friend int* begin(Range&);
   friend int* begin(Range const&);
-  friend sentinel_wrapper<int*> end(Range&);
-  friend sentinel_wrapper<int*> end(Range const&);
+  friend sentinel<int*> end(Range&);
+  friend sentinel<int*> end(Range const&);
 };
 
 struct BorrowedRange {
   friend int* begin(BorrowedRange&);
   friend int* begin(BorrowedRange const&);
-  friend sentinel_wrapper<int*> end(BorrowedRange&);
-  friend sentinel_wrapper<int*> end(BorrowedRange const&);
+  friend sentinel<int*> end(BorrowedRange&);
+  friend sentinel<int*> end(BorrowedRange const&);
 };
 
 template<>
@@ -63,6 +63,6 @@
     static_assert(std::same_as<
         decltype(std::ranges::take_view(std::move(br), 0)),
         std::ranges::take_view<std::ranges::subrange<
-          int *, sentinel_wrapper<int *>, std::ranges::subrange_kind::unsized>>
+          int *, sentinel<int *>, std::ranges::subrange_kind::unsized>>
     >);
 }
diff --git a/libcxx/test/std/ranges/range.adaptors/range.take/sentinel/base.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.take/sentinel/base.pass.cpp
--- a/libcxx/test/std/ranges/range.adaptors/range.take/sentinel/base.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.take/sentinel/base.pass.cpp
@@ -24,20 +24,13 @@
 
 constexpr bool test() {
   int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
-  auto sw = sentinel_wrapper<int *>(buffer + 8); // Note: not 4, but that's OK.
-
   {
-    const std::ranges::take_view<MoveOnlyView> tv(MoveOnlyView{buffer}, 4);
-    assert(tv.end().base().base() == sw.base());
-    ASSERT_SAME_TYPE(decltype(tv.end().base()), sentinel_wrapper<int *>);
+    std::ranges::take_view<MoveOnlyView> tv(MoveOnlyView(buffer), 4);
+    std::same_as<sentinel<int*>> auto sw1 = tv.end().base();
+    assert(base(sw1) == buffer + 8);
+    std::same_as<sentinel<int*>> auto sw2 = std::as_const(tv).end().base();
+    assert(base(sw2) == buffer + 8);
   }
-
-  {
-    std::ranges::take_view<MoveOnlyView> tv(MoveOnlyView{buffer}, 4);
-    assert(tv.end().base().base() == sw.base());
-    ASSERT_SAME_TYPE(decltype(tv.end().base()), sentinel_wrapper<int *>);
-  }
-
   return true;
 }
 
diff --git a/libcxx/test/std/ranges/range.adaptors/range.take/sentinel/ctor.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.take/sentinel/ctor.pass.cpp
--- a/libcxx/test/std/ranges/range.adaptors/range.take/sentinel/ctor.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.take/sentinel/ctor.pass.cpp
@@ -27,27 +27,39 @@
 
   {
     // Test the default ctor.
-    std::ranges::take_view<MoveOnlyView> tv(MoveOnlyView{buffer}, 4);
-    assert(decltype(tv.end()){} == std::ranges::next(tv.begin(), 4));
+    using TakeView = std::ranges::take_view<MoveOnlyView>;
+    using Sentinel = std::ranges::sentinel_t<TakeView>;
+    Sentinel s;
+    TakeView tv = TakeView(MoveOnlyView(buffer), 4);
+    assert(tv.begin() + 4 == s);
   }
 
   {
-    std::ranges::take_view<MoveOnlyView> nonConst(MoveOnlyView{buffer}, 5);
-    const std::ranges::take_view<MoveOnlyView> tvConst(MoveOnlyView{buffer}, 5);
-    auto sent1 = nonConst.end();
-    // Convert to const. Note, we cannot go the other way.
-    std::remove_cv_t<decltype(tvConst.end())> sent2 = sent1;
-
-    assert(sent1 == std::ranges::next(tvConst.begin(), 5));
-    assert(sent2 == std::ranges::next(tvConst.begin(), 5));
+    // Test the conversion from "sentinel" to "sentinel-to-const".
+    using TakeView = std::ranges::take_view<MoveOnlyView>;
+    using Sentinel = std::ranges::sentinel_t<TakeView>;
+    using ConstSentinel = std::ranges::sentinel_t<const TakeView>;
+    static_assert(std::is_convertible_v<Sentinel, ConstSentinel>);
+    TakeView tv = TakeView(MoveOnlyView(buffer), 4);
+    Sentinel s = tv.end();
+    ConstSentinel cs = s;
+    cs = s;  // test assignment also
+    assert(tv.begin() + 4 == s);
+    assert(tv.begin() + 4 == cs);
+    assert(std::as_const(tv).begin() + 4 == s);
+    assert(std::as_const(tv).begin() + 4 == cs);
   }
 
   {
-    std::ranges::take_view<CopyableView> tv(CopyableView{buffer}, 6);
-    auto sw = sentinel_wrapper<int *>(buffer + 6);
-    using Sent = decltype(tv.end());
-    Sent sent = Sent(sw);
-    assert(sent.base().base() == sw.base());
+    // Test the constructor from "base-sentinel" to "sentinel".
+    using TakeView = std::ranges::take_view<MoveOnlyView>;
+    using Sentinel = std::ranges::sentinel_t<TakeView>;
+    sentinel<int*> sw1 = MoveOnlyView(buffer).end();
+    static_assert( std::is_constructible_v<Sentinel, sentinel<int*>>);
+    static_assert(!std::is_convertible_v<sentinel<int*>, Sentinel>);
+    auto s = Sentinel(sw1);
+    std::same_as<sentinel<int*>> auto sw2 = s.base();
+    assert(base(sw2) == base(sw1));
   }
 
   return true;
diff --git a/libcxx/test/std/ranges/range.adaptors/range.take/types.h b/libcxx/test/std/ranges/range.adaptors/range.take/types.h
--- a/libcxx/test/std/ranges/range.adaptors/range.take/types.h
+++ b/libcxx/test/std/ranges/range.adaptors/range.take/types.h
@@ -15,7 +15,7 @@
   MoveOnlyView& operator=(MoveOnlyView&&) = default;
 
   constexpr int* begin() const {return ptr_;}
-  constexpr sentinel_wrapper<int*> end() const {return sentinel_wrapper<int*>{ptr_ + 8};}
+  constexpr sentinel<int*> end() const {return sentinel<int*>{ptr_ + 8};}
 };
 static_assert( std::ranges::view<MoveOnlyView>);
 static_assert( std::ranges::contiguous_range<MoveOnlyView>);
@@ -26,7 +26,7 @@
   constexpr explicit CopyableView(int* ptr) : ptr_(ptr) {}
 
   constexpr int* begin() const {return ptr_;}
-  constexpr sentinel_wrapper<int*> end() const {return sentinel_wrapper<int*>{ptr_ + 8};}
+  constexpr sentinel<int*> end() const {return sentinel<int*>{ptr_ + 8};}
 };
 static_assert(std::ranges::view<CopyableView>);
 static_assert(std::ranges::contiguous_range<CopyableView>);
@@ -37,15 +37,8 @@
   int *ptr_;
   constexpr explicit SizedForwardView(int* ptr) : ptr_(ptr) {}
   constexpr auto begin() const { return ForwardIter(ptr_); }
-  constexpr auto end() const { return sentinel_wrapper<ForwardIter>(ForwardIter(ptr_ + 8)); }
+  constexpr auto end() const { return sized_sentinel<ForwardIter>(ForwardIter(ptr_ + 8)); }
 };
-// Required to make SizedForwardView a sized view.
-constexpr auto operator-(sentinel_wrapper<ForwardIter> sent, ForwardIter iter) {
-  return sent.base().base() - iter.base();
-}
-constexpr auto operator-(ForwardIter iter, sentinel_wrapper<ForwardIter> sent) {
-  return iter.base() - sent.base().base();
-}
 static_assert(std::ranges::view<SizedForwardView>);
 static_assert(std::ranges::forward_range<SizedForwardView>);
 static_assert(std::ranges::sized_range<SizedForwardView>);
@@ -55,15 +48,8 @@
   int *ptr_;
   constexpr explicit SizedRandomAccessView(int* ptr) : ptr_(ptr) {}
   constexpr auto begin() const { return RandomAccessIter(ptr_); }
-  constexpr auto end() const { return sentinel_wrapper<RandomAccessIter>(RandomAccessIter(ptr_ + 8)); }
+  constexpr auto end() const { return sized_sentinel<RandomAccessIter>(RandomAccessIter(ptr_ + 8)); }
 };
-// Required to make SizedRandomAccessView a sized view.
-constexpr auto operator-(sentinel_wrapper<RandomAccessIter> sent, RandomAccessIter iter) {
-  return sent.base().base() - iter.base();
-}
-constexpr auto operator-(RandomAccessIter iter, sentinel_wrapper<RandomAccessIter> sent) {
-  return iter.base() - sent.base().base();
-}
 static_assert(std::ranges::view<SizedRandomAccessView>);
 static_assert(std::ranges::random_access_range<SizedRandomAccessView>);
 static_assert(std::ranges::sized_range<SizedRandomAccessView>);
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/end.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/end.pass.cpp
--- a/libcxx/test/std/ranges/range.adaptors/range.transform/end.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/end.pass.cpp
@@ -32,37 +32,54 @@
 
 constexpr bool test() {
   {
-    std::ranges::transform_view transformView(MoveOnlyView{}, PlusOneMutable{});
-    assert(transformView.end().base() == globalBuff + 8);
+    using TransformView = std::ranges::transform_view<ForwardView, PlusOneMutable>;
+    static_assert(std::ranges::common_range<TransformView>);
+    TransformView tv;
+    auto end = tv.end();
+    ASSERT_SAME_TYPE(decltype(end.base()), std::ranges::sentinel_t<ForwardView>);
+    assert(base(end.base()) == globalBuff + 8);
+    static_assert(!EndInvocable<const TransformView>); // because PlusOneMutable
   }
-
   {
-    std::ranges::transform_view transformView(ForwardView{}, PlusOneMutable{});
-    assert(transformView.end().base().base() == globalBuff + 8);
+    using TransformView = std::ranges::transform_view<InputView, PlusOneMutable>;
+    static_assert(!std::ranges::common_range<TransformView>);
+    TransformView tv;
+    auto end = tv.end();
+    ASSERT_SAME_TYPE(decltype(end.base()), std::ranges::sentinel_t<InputView>);
+    assert(base(base(end.base())) == globalBuff + 8);
+    static_assert(!EndInvocable<const TransformView>); // because PlusOneMutable
   }
-
   {
-    std::ranges::transform_view transformView(InputView{}, PlusOneMutable{});
-    assert(transformView.end().base() == globalBuff + 8);
+    using TransformView = std::ranges::transform_view<InputView, PlusOne>;
+    static_assert(!std::ranges::common_range<TransformView>);
+    TransformView tv;
+    auto end = tv.end();
+    ASSERT_SAME_TYPE(decltype(end.base()), std::ranges::sentinel_t<InputView>);
+    assert(base(base(end.base())) == globalBuff + 8);
+    auto cend = std::as_const(tv).end();
+    ASSERT_SAME_TYPE(decltype(cend.base()), std::ranges::sentinel_t<const InputView>);
+    assert(base(base(cend.base())) == globalBuff + 8);
   }
-
   {
-    const std::ranges::transform_view transformView(MoveOnlyView{}, PlusOne{});
-    assert(transformView.end().base() == globalBuff + 8);
+    using TransformView = std::ranges::transform_view<MoveOnlyView, PlusOneMutable>;
+    static_assert(std::ranges::common_range<TransformView>);
+    TransformView tv;
+    auto end = tv.end();
+    ASSERT_SAME_TYPE(decltype(end.base()), std::ranges::sentinel_t<MoveOnlyView>);
+    assert(end.base() == globalBuff + 8);
+    static_assert(!EndInvocable<const TransformView>); // because PlusOneMutable
+  }
+  {
+    using TransformView = std::ranges::transform_view<MoveOnlyView, PlusOne>;
+    static_assert(std::ranges::common_range<TransformView>);
+    TransformView tv;
+    auto end = tv.end();
+    ASSERT_SAME_TYPE(decltype(end.base()), std::ranges::sentinel_t<MoveOnlyView>);
+    assert(end.base() == globalBuff + 8);
+    auto cend = std::as_const(tv).end();
+    ASSERT_SAME_TYPE(decltype(cend.base()), std::ranges::sentinel_t<const MoveOnlyView>);
+    assert(cend.base() == globalBuff + 8);
   }
-
-  static_assert(!EndInvocable<const std::ranges::transform_view<MoveOnlyView, PlusOneMutable>>);
-  static_assert( EndInvocable<      std::ranges::transform_view<MoveOnlyView, PlusOneMutable>>);
-  static_assert( EndInvocable<const std::ranges::transform_view<MoveOnlyView, PlusOne>>);
-  static_assert(!EndInvocable<const std::ranges::transform_view<InputView, PlusOneMutable>>);
-  static_assert( EndInvocable<      std::ranges::transform_view<InputView, PlusOneMutable>>);
-  static_assert( EndInvocable<const std::ranges::transform_view<InputView, PlusOne>>);
-
-  static_assert(!EndIsIter<const std::ranges::transform_view<InputView, PlusOne>>);
-  static_assert(!EndIsIter<      std::ranges::transform_view<InputView, PlusOneMutable>>);
-  static_assert( EndIsIter<const std::ranges::transform_view<MoveOnlyView, PlusOne>>);
-  static_assert( EndIsIter<      std::ranges::transform_view<MoveOnlyView, PlusOneMutable>>);
-
   return true;
 }
 
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/base.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/base.pass.cpp
--- a/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/base.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/base.pass.cpp
@@ -17,30 +17,29 @@
 #include "test_macros.h"
 #include "../types.h"
 
-template<class V, class F>
-concept BaseInvocable = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
-  iter.base();
+template<class It>
+concept BaseInvocable = requires(It it) {
+  it.base();
 };
 
 constexpr bool test() {
   {
-    std::ranges::transform_view<MoveOnlyView, PlusOneMutable> transformView;
-    auto iter = std::move(transformView).begin();
-    ASSERT_SAME_TYPE(int*, decltype(iter.base()));
-    assert(iter.base() == globalBuff);
-    ASSERT_SAME_TYPE(int*, decltype(std::move(iter).base()));
-    assert(std::move(iter).base() == globalBuff);
+    using TransformView = std::ranges::transform_view<MoveOnlyView, PlusOneMutable>;
+    TransformView tv;
+    auto begin = tv.begin();
+    ASSERT_SAME_TYPE(decltype(begin.base()), int*);
+    assert(begin.base() == globalBuff);
+    ASSERT_SAME_TYPE(decltype(std::move(begin).base()), int*);
+    assert(std::move(begin).base() == globalBuff);
   }
-
   {
-    std::ranges::transform_view<InputView, PlusOneMutable> transformView;
-    auto iter = transformView.begin();
-    assert(std::move(iter).base() == globalBuff);
-    ASSERT_SAME_TYPE(cpp20_input_iterator<int *>, decltype(std::move(iter).base()));
+    using TransformView = std::ranges::transform_view<InputView, PlusOneMutable>;
+    TransformView tv;
+    auto begin = tv.begin();
+    static_assert(!BaseInvocable<decltype(begin)&>);
+    std::same_as<cpp20_input_iterator<int *>> auto it = std::move(begin).base();
+    assert(base(it) == globalBuff);
   }
-
-  static_assert(!BaseInvocable<InputView, PlusOneMutable>);
-
   return true;
 }
 
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/size.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/size.pass.cpp
--- a/libcxx/test/std/ranges/range.adaptors/range.transform/size.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/size.pass.cpp
@@ -34,8 +34,8 @@
 
   static_assert(!SizeInvocable<std::ranges::transform_view<ForwardView, PlusOne>>);
 
-  static_assert(SizeInvocable<std::ranges::transform_view<SizedSentinelNotConstView, PlusOne>>);
-  static_assert(!SizeInvocable<const std::ranges::transform_view<SizedSentinelNotConstView, PlusOne>>);
+  static_assert(SizeInvocable<std::ranges::transform_view<NonConstSizedView, PlusOne>>);
+  static_assert(!SizeInvocable<const std::ranges::transform_view<NonConstSizedView, PlusOne>>);
 
   return true;
 }
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/types.h b/libcxx/test/std/ranges/range.adaptors/range.transform/types.h
--- a/libcxx/test/std/ranges/range.adaptors/range.transform/types.h
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/types.h
@@ -85,33 +85,28 @@
 struct InputView : std::ranges::view_base {
   int *ptr_;
   constexpr explicit InputView(int* ptr = globalBuff) : ptr_(ptr) {}
-  constexpr cpp20_input_iterator<int*> begin() const { return cpp20_input_iterator<int*>(ptr_); }
-  constexpr int *end() const { return ptr_ + 8; }
+  constexpr auto begin() const { return cpp20_input_iterator<int*>(ptr_); }
+  constexpr auto end() const { return sentinel<cpp20_input_iterator<int*>>(cpp20_input_iterator<int*>(ptr_ + 8)); }
 };
-// TODO: remove these bogus operators
-constexpr bool operator==(const cpp20_input_iterator<int*> &lhs, int* rhs) { return lhs.base() == rhs; }
-constexpr bool operator==(int* lhs, const cpp20_input_iterator<int*> &rhs) { return rhs.base() == lhs; }
+static_assert( std::ranges::view<InputView>);
+static_assert(!std::ranges::sized_range<InputView>);
 
 struct SizedSentinelView : std::ranges::view_base {
   int count_;
   constexpr explicit SizedSentinelView(int count = 8) : count_(count) {}
-  constexpr auto begin() const { return RandomAccessIter(globalBuff); }
-  constexpr int *end() const { return globalBuff + count_; }
+  constexpr int *begin() const { return globalBuff; }
+  constexpr auto end() const { return sized_sentinel<int*>(globalBuff + count_); }
 };
-// TODO: remove these bogus operators
-constexpr auto operator- (const RandomAccessIter &lhs, int* rhs) { return lhs.base() - rhs; }
-constexpr auto operator- (int* lhs, const RandomAccessIter &rhs) { return lhs - rhs.base(); }
-constexpr bool operator==(const RandomAccessIter &lhs, int* rhs) { return lhs.base() == rhs; }
-constexpr bool operator==(int* lhs, const RandomAccessIter &rhs) { return rhs.base() == lhs; }
 
-struct SizedSentinelNotConstView : std::ranges::view_base {
-  ForwardIter begin() const;
-  int *end() const;
+struct NonConstSizedView : std::ranges::view_base {
+  forward_iterator<int*> begin() const;
+  forward_iterator<int*> end() const;
   size_t size();
 };
-// TODO: remove these bogus operators
-bool operator==(const ForwardIter &lhs, int* rhs);
-bool operator==(int* lhs, const ForwardIter &rhs);
+static_assert( std::ranges::view<NonConstSizedView>);
+static_assert( std::ranges::sized_range<NonConstSizedView>);
+static_assert( std::ranges::range<const NonConstSizedView>);
+static_assert(!std::ranges::sized_range<const NonConstSizedView>);
 
 struct Range {
   int *begin() const;
diff --git a/libcxx/test/std/ranges/range.req/range.range/helper_aliases.compile.pass.cpp b/libcxx/test/std/ranges/range.req/range.range/helper_aliases.compile.pass.cpp
--- a/libcxx/test/std/ranges/range.req/range.range/helper_aliases.compile.pass.cpp
+++ b/libcxx/test/std/ranges/range.req/range.range/helper_aliases.compile.pass.cpp
@@ -24,14 +24,11 @@
 
 #include <ranges>
 
-#include <concepts>
-
-#include "test_iterators.h"
-#include "test_range.h"
-
-
-
-static_assert(std::same_as<std::ranges::range_difference_t<test_range<cpp20_input_iterator> >, std::iter_difference_t<int*> >);
-static_assert(std::same_as<std::ranges::range_value_t<test_range<cpp20_input_iterator> >, std::iter_value_t<int*> >);
-static_assert(std::same_as<std::ranges::range_reference_t<test_range<cpp20_input_iterator> >, std::iter_reference_t<int*> >);
-static_assert(std::same_as<std::ranges::range_rvalue_reference_t<test_range<cpp20_input_iterator> >, std::iter_rvalue_reference_t<int*> >);
+struct Range {
+    int *begin();
+    int *end();
+};
+static_assert(std::same_as<std::ranges::range_difference_t<Range>, std::ptrdiff_t>);
+static_assert(std::same_as<std::ranges::range_value_t<Range>, int>);
+static_assert(std::same_as<std::ranges::range_reference_t<Range>, int&>);
+static_assert(std::same_as<std::ranges::range_rvalue_reference_t<Range>, int&&>);
diff --git a/libcxx/test/std/ranges/range.req/range.range/iterator_t.compile.pass.cpp b/libcxx/test/std/ranges/range.req/range.range/iterator_t.compile.pass.cpp
--- a/libcxx/test/std/ranges/range.req/range.range/iterator_t.compile.pass.cpp
+++ b/libcxx/test/std/ranges/range.req/range.range/iterator_t.compile.pass.cpp
@@ -10,23 +10,47 @@
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
-// template<class T>
-// using iterator_t = decltype(ranges::begin(declval<T&>()));
+// template<range _Rp>
+// using iterator_t = decltype(ranges::begin(declval<_Rp&>()));
 
 #include <ranges>
 
-#include <concepts>
-
-#include "test_range.h"
-
-
-
-static_assert(std::same_as<std::ranges::iterator_t<test_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
-static_assert(std::same_as<std::ranges::iterator_t<test_range<cpp17_input_iterator> const>, cpp17_input_iterator<int const*> >);
-
-static_assert(std::same_as<std::ranges::iterator_t<test_non_const_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
-
-static_assert(std::same_as<std::ranges::iterator_t<test_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
-static_assert(std::same_as<std::ranges::iterator_t<test_common_range<cpp17_input_iterator> const>, cpp17_input_iterator<int const*> >);
-
-static_assert(std::same_as<std::ranges::iterator_t<test_non_const_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
+#include "test_iterators.h"
+
+template<class T>
+concept HasIteratorT = requires {
+    typename std::ranges::iterator_t<T>;
+};
+
+static_assert(std::same_as<std::ranges::iterator_t<int[]>, int*>);
+static_assert(std::same_as<std::ranges::iterator_t<int(&)[]>, int*>);
+static_assert(std::same_as<std::ranges::iterator_t<int[10]>, int*>);
+static_assert(std::same_as<std::ranges::iterator_t<int(&)[10]>, int*>);
+
+struct Range {
+    char *begin() &;
+    sentinel<char*> end() &;
+    short *begin() &&;
+    sentinel<short*> end() &&;
+    int *begin() const&;
+    sentinel<int*> end() const&;
+    long *begin() const&&;
+    sentinel<long*> end() const&&;
+};
+static_assert(std::same_as<std::ranges::iterator_t<Range>, char*>);
+static_assert(std::same_as<std::ranges::iterator_t<Range&>, char*>);
+static_assert(std::same_as<std::ranges::iterator_t<Range&&>, char*>);
+static_assert(std::same_as<std::ranges::iterator_t<const Range>, int*>);
+static_assert(std::same_as<std::ranges::iterator_t<const Range&>, int*>);
+static_assert(std::same_as<std::ranges::iterator_t<const Range&&>, int*>);
+
+struct NonConstRange {
+    int *begin();
+    int *end();
+};
+static_assert(std::same_as<std::ranges::iterator_t<NonConstRange>, int*>);
+static_assert(std::same_as<std::ranges::iterator_t<NonConstRange&>, int*>);
+static_assert(std::same_as<std::ranges::iterator_t<NonConstRange&&>, int*>);
+static_assert(!HasIteratorT<const NonConstRange>);
+static_assert(!HasIteratorT<const NonConstRange&>);
+static_assert(!HasIteratorT<const NonConstRange&&>);
diff --git a/libcxx/test/std/ranges/range.req/range.range/sentinel_t.compile.pass.cpp b/libcxx/test/std/ranges/range.req/range.range/sentinel_t.compile.pass.cpp
--- a/libcxx/test/std/ranges/range.req/range.range/sentinel_t.compile.pass.cpp
+++ b/libcxx/test/std/ranges/range.req/range.range/sentinel_t.compile.pass.cpp
@@ -15,16 +15,42 @@
 
 #include <ranges>
 
-#include <concepts>
-
 #include "test_iterators.h"
-#include "test_range.h"
-
-
 
-static_assert(std::same_as<std::ranges::sentinel_t<test_range<cpp20_input_iterator> >, sentinel>);
-static_assert(std::same_as<std::ranges::sentinel_t<test_range<cpp20_input_iterator> const>, sentinel>);
-static_assert(std::same_as<std::ranges::sentinel_t<test_non_const_range<cpp20_input_iterator> >, sentinel>);
-static_assert(std::same_as<std::ranges::sentinel_t<test_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
-static_assert(std::same_as<std::ranges::sentinel_t<test_common_range<cpp17_input_iterator> const>, cpp17_input_iterator<int const*> >);
-static_assert(std::same_as<std::ranges::sentinel_t<test_non_const_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
+template<class T>
+concept HasSentinelT = requires {
+    typename std::ranges::sentinel_t<T>;
+};
+
+static_assert(!HasSentinelT<int[]>);
+static_assert(!HasSentinelT<int(&)[]>);
+static_assert(std::same_as<std::ranges::sentinel_t<int[10]>, int*>);
+static_assert(std::same_as<std::ranges::sentinel_t<int(&)[10]>, int*>);
+
+struct Range {
+    char *begin() &;
+    sentinel<char*> end() &;
+    short *begin() &&;
+    sentinel<short*> end() &&;
+    int *begin() const&;
+    sentinel<int*> end() const&;
+    long *begin() const&&;
+    sentinel<long*> end() const&&;
+};
+static_assert(std::same_as<std::ranges::sentinel_t<Range>, sentinel<char*>>);
+static_assert(std::same_as<std::ranges::sentinel_t<Range&>, sentinel<char*>>);
+static_assert(std::same_as<std::ranges::sentinel_t<Range&&>, sentinel<char*>>);
+static_assert(std::same_as<std::ranges::sentinel_t<const Range>, sentinel<int*>>);
+static_assert(std::same_as<std::ranges::sentinel_t<const Range&>, sentinel<int*>>);
+static_assert(std::same_as<std::ranges::sentinel_t<const Range&&>, sentinel<int*>>);
+
+struct NonConstRange {
+    int *begin();
+    int *end();
+};
+static_assert(std::same_as<std::ranges::sentinel_t<NonConstRange>, int*>);
+static_assert(std::same_as<std::ranges::sentinel_t<NonConstRange&>, int*>);
+static_assert(std::same_as<std::ranges::sentinel_t<NonConstRange&&>, int*>);
+static_assert(!HasSentinelT<const NonConstRange>);
+static_assert(!HasSentinelT<const NonConstRange&>);
+static_assert(!HasSentinelT<const NonConstRange&&>);
diff --git a/libcxx/test/std/ranges/range.req/range.refinements/output_range.compile.pass.cpp b/libcxx/test/std/ranges/range.req/range.refinements/output_range.compile.pass.cpp
--- a/libcxx/test/std/ranges/range.req/range.refinements/output_range.compile.pass.cpp
+++ b/libcxx/test/std/ranges/range.req/range.refinements/output_range.compile.pass.cpp
@@ -14,17 +14,16 @@
 // concept output_range;
 
 #include <ranges>
-
 #include <iterator>
+
 #include "test_iterators.h"
-#include "test_range.h"
 
 struct T { };
 
 // Satisfied when it's a range and has the right iterator
 struct GoodRange {
     output_iterator<T*> begin();
-    sentinel end();
+    sentinel<output_iterator<T*>> end();
 };
 static_assert(std::ranges::range<GoodRange>);
 static_assert(std::output_iterator<std::ranges::iterator_t<GoodRange>, T>);
@@ -40,8 +39,8 @@
 
 // Not satisfied when the iterator is not an output_iterator
 struct RangeWithBadIterator {
-    cpp17_input_iterator<T const*> begin();
-    sentinel end();
+    cpp17_input_iterator<const T*> begin();
+    sentinel<cpp17_input_iterator<const T*>> end();
 };
 static_assert( std::ranges::range<RangeWithBadIterator>);
 static_assert(!std::output_iterator<std::ranges::iterator_t<RangeWithBadIterator>, T>);
diff --git a/libcxx/test/std/ranges/range.utility/range.subrange/enable_borrowed_range.compile.pass.cpp b/libcxx/test/std/ranges/range.utility/range.subrange/enable_borrowed_range.compile.pass.cpp
--- a/libcxx/test/std/ranges/range.utility/range.subrange/enable_borrowed_range.compile.pass.cpp
+++ b/libcxx/test/std/ranges/range.utility/range.subrange/enable_borrowed_range.compile.pass.cpp
@@ -20,4 +20,4 @@
 
 static_assert(ranges::borrowed_range<ranges::subrange<int*>>);
 static_assert(ranges::borrowed_range<ranges::subrange<int*, int const*>>);
-static_assert(ranges::borrowed_range<ranges::subrange<int*, sentinel_wrapper<int*>, ranges::subrange_kind::unsized>>);
+static_assert(ranges::borrowed_range<ranges::subrange<int*, sentinel<int*>, ranges::subrange_kind::unsized>>);
diff --git a/libcxx/test/support/test_iterators.h b/libcxx/test/support/test_iterators.h
--- a/libcxx/test/support/test_iterators.h
+++ b/libcxx/test/support/test_iterators.h
@@ -657,6 +657,8 @@
 
     constexpr I base() && { return std::move(base_); }
 
+    friend constexpr I base(const cpp20_input_iterator& it) { return it.base_; }
+
     template <class T>
     void operator,(T const &) = delete;
 
@@ -862,62 +864,30 @@
     requires std::equality_comparable_with<T, decltype(u.base())>;
 };
 
-template <std::input_or_output_iterator I>
-class sentinel_wrapper {
+template <class It>
+class sentinel {
 public:
-    sentinel_wrapper() = default;
-    constexpr explicit sentinel_wrapper(I base) : base_(std::move(base)) {}
-
-    constexpr bool operator==(const I& other) const requires std::equality_comparable<I> {
-        return base_ == other;
-    }
-
-    constexpr const I& base() const& { return base_; }
-    constexpr I base() && { return std::move(base_); }
-
-    template<std::input_or_output_iterator I2>
-        requires sentinel_for_base<I, I2>
-    constexpr bool operator==(const I2& other) const {
-        return base_ == other.base();
-    }
-
+    sentinel() = default;
+    constexpr explicit sentinel(const It& it) : base_(base(it)) {}
+    constexpr bool operator==(const It& other) const { return base_ == base(other); }
+    friend constexpr auto base(const sentinel& s) { return It(s.base_); }
 private:
-    I base_ = I();
+    decltype(base(std::declval<It>())) base_;
 };
 
-template <std::input_or_output_iterator I>
+template <class It>
 class sized_sentinel {
 public:
-    sized_sentinel() = default;
-    constexpr explicit sized_sentinel(I base) : base_(std::move(base)) {}
-
-    constexpr bool operator==(const I& other) const requires std::equality_comparable<I> {
-        return base_ == other;
-    }
-
-    constexpr const I& base() const& { return base_; }
-    constexpr I base() && { return std::move(base_); }
-
-    template<std::input_or_output_iterator I2>
-        requires sentinel_for_base<I, I2>
-    constexpr bool operator==(const I2& other) const {
-        return base_ == other.base();
-    }
-
+    explicit sized_sentinel() = default;
+    constexpr explicit sized_sentinel(const It& it) : base_(base(it)) {}
+    constexpr bool operator==(const It& other) const { return base_ == base(other); }
+    friend constexpr auto operator-(const sized_sentinel& s, const It& i) { return s.base_ - base(i); }
+    friend constexpr auto operator-(const It& i, const sized_sentinel& s) { return base(i) - s.base_; }
+    friend constexpr auto base(const sized_sentinel& s) { return It(s.base_); }
 private:
-    I base_ = I();
+    decltype(base(std::declval<It>())) base_;
 };
 
-template <std::input_or_output_iterator I>
-constexpr auto operator-(sized_sentinel<I> sent, std::input_or_output_iterator auto iter) {
-  return sent.base() - iter;
-}
-
-template <std::input_or_output_iterator I>
-constexpr auto operator-(std::input_or_output_iterator auto iter, sized_sentinel<I> sent) {
-  return iter - sent.base();
-}
-
 template <class It>
 class three_way_contiguous_iterator
 {
diff --git a/libcxx/test/support/test_range.h b/libcxx/test/support/test_range.h
--- a/libcxx/test/support/test_range.h
+++ b/libcxx/test/support/test_range.h
@@ -17,24 +17,20 @@
 #error "test/support/test_range.h" can only be included in builds supporting ranges
 #endif
 
-struct sentinel {
-  bool operator==(std::input_or_output_iterator auto const&) const;
-};
-
 template <template <class...> class I>
 requires std::input_or_output_iterator<I<int*> >
 struct test_range {
   I<int*> begin();
   I<int const*> begin() const;
-  sentinel end();
-  sentinel end() const;
+  sentinel<I<int*>> end();
+  sentinel<I<const int*>> end() const;
 };
 
 template <template <class...> class I>
 requires std::input_or_output_iterator<I<int*> >
 struct test_non_const_range {
   I<int*> begin();
-  sentinel end();
+  sentinel<I<int*>> end();
 };
 
 template <template <class...> class I>
@@ -58,8 +54,8 @@
 struct test_view : std::ranges::view_base {
   I<int*> begin();
   I<int const*> begin() const;
-  sentinel end();
-  sentinel end() const;
+  sentinel<I<int*>> end();
+  sentinel<I<const int*>> end() const;
 };
 
 #endif // LIBCXX_TEST_SUPPORT_TEST_RANGE_H