cuda-cccl 0.3.2__cp313-cp313-manylinux_2_24_aarch64.whl → 0.3.4__cp313-cp313-manylinux_2_24_aarch64.whl

cuda/cccl/headers/include/cuda/std/{detail/libcxx/include/iosfwd → __fwd/ios.h}

@@ -1,14 +1,14 @@
-//===----------------------------------------------------------------------===//
+//===---------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 // SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES.
 //
-//===----------------------------------------------------------------------===//
+//===---------------------------------------------------------------------===//
 
-#ifndef _LIBCUDACXX_IOSFWD
-#define _LIBCUDACXX_IOSFWD
+#ifndef _CUDA_STD___FWD_IOS_H
+#define _CUDA_STD___FWD_IOS_H
 
 #include <cuda/std/detail/__config>
 
@@ -22,7 +22,6 @@
 
 #include <cuda/std/__fwd/allocator.h>
 #include <cuda/std/__fwd/char_traits.h>
-#include <cuda/std/version>
 
 #include <cuda/std/__cccl/prologue.h>
 
@@ -117,12 +116,8 @@ using streamoff = long int; // for char_traits in <string>
 using streamoff = long long; // for char_traits in <string>
 #endif
 
-// Include other forward declarations here
-template <class _Tp, class _Alloc = allocator<_Tp>>
-class _CCCL_TYPE_VISIBILITY_DEFAULT vector;
-
 _CCCL_END_NAMESPACE_CUDA_STD
 
 #include <cuda/std/__cccl/epilogue.h>
 
-#endif // _LIBCUDACXX_IOSFWD
+#endif // _CUDA_STD___FWD_IOS_H

cuda/cccl/headers/include/cuda/std/__fwd/mdspan.h

@@ -28,6 +28,7 @@
 #  pragma system_header
 #endif // no system header
 
+#include <cuda/std/__cstddef/types.h>
 #include <cuda/std/__type_traits/void_t.h>
 
 #include <cuda/std/__cccl/prologue.h>
@@ -78,33 +79,41 @@ template <class _ElementType,
 class mdspan;
 
 template <class _Tp>
-inline constexpr bool __is_std_mdspan_v = false;
+inline constexpr bool __is_cuda_std_mdspan_v = false;
 
 template <class _ElementType, class _Extents, class _LayoutPolicy, class _AccessorPolicy>
-inline constexpr bool __is_std_mdspan_v<mdspan<_ElementType, _Extents, _LayoutPolicy, _AccessorPolicy>> = true;
+inline constexpr bool __is_cuda_std_mdspan_v<mdspan<_ElementType, _Extents, _LayoutPolicy, _AccessorPolicy>> = true;
 
 template <typename _Layout>
-inline constexpr bool __is_any_mdspan_layout_mapping_left_v = false;
+inline constexpr bool __is_cuda_std_layout_left_mapping_v = false;
 
 template <typename _Extents>
-inline constexpr bool __is_any_mdspan_layout_mapping_left_v<layout_left::mapping<_Extents>> = true;
+inline constexpr bool __is_cuda_std_layout_left_mapping_v<layout_left::mapping<_Extents>> = true;
 
 template <typename _Layout>
-inline constexpr bool __is_any_mdspan_layout_mapping_right_v = false;
+inline constexpr bool __is_cuda_std_layout_right_mapping_v = false;
 
 template <typename _Extents>
-inline constexpr bool __is_any_mdspan_layout_mapping_right_v<layout_right::mapping<_Extents>> = true;
+inline constexpr bool __is_cuda_std_layout_right_mapping_v<layout_right::mapping<_Extents>> = true;
 
 template <typename _Layout>
-inline constexpr bool __is_any_mdspan_layout_mapping_left_or_right_v =
-  __is_any_mdspan_layout_mapping_left_v<_Layout> || __is_any_mdspan_layout_mapping_right_v<_Layout>;
+inline constexpr bool __is_cuda_std_layout_left_or_right_mapping_v =
+  __is_cuda_std_layout_left_mapping_v<_Layout> || __is_cuda_std_layout_right_mapping_v<_Layout>;
 
 // TODO (fbusato): Add support for layout_right_padded and layout_left_padded
 // template<>
-// inline constexpr bool __is_any_mdspan_layout_mapping_right_v<layout_right_padded> = true;
+// inline constexpr bool __is_cuda_std_layout_right_mapping_v<layout_right_padded> = true;
 
 // template<>
-// inline constexpr bool __is_any_mdspan_layout_mapping_right_v<layout_left_padded> = true;
+// inline constexpr bool __is_cuda_std_layout_left_mapping_v<layout_left_padded> = true;
+
+template <class _IndexType, size_t... _Extents>
+class extents;
+
+template <class _Tp>
+inline constexpr bool __is_cuda_std_extents_v = false;
+template <class _IndexType, size_t... _Extents>
+inline constexpr bool __is_cuda_std_extents_v<extents<_IndexType, _Extents...>> = true;
 
 _CCCL_END_NAMESPACE_CUDA_STD
 

cuda/cccl/headers/include/cuda/std/__fwd/optional.h

@@ -28,9 +28,9 @@ template <class _Tp>
 class _CCCL_TYPE_VISIBILITY_DEFAULT optional;
 
 template <class _Tp>
-inline constexpr bool __is_std_optional_v = false;
+inline constexpr bool __is_cuda_std_optional_v = false;
 template <class _Tp>
-inline constexpr bool __is_std_optional_v<optional<_Tp>> = true;
+inline constexpr bool __is_cuda_std_optional_v<optional<_Tp>> = true;
 
 _CCCL_END_NAMESPACE_CUDA_STD
 

cuda/cccl/headers/include/cuda/std/__fwd/reference_wrapper.h

@@ -27,6 +27,11 @@ _CCCL_BEGIN_NAMESPACE_CUDA_STD
 template <class _Tp>
 class _CCCL_TYPE_VISIBILITY_DEFAULT reference_wrapper;
 
+template <class _Tp>
+inline constexpr bool __is_cuda_std_reference_wrapper_v = false;
+template <class _Tp>
+inline constexpr bool __is_cuda_std_reference_wrapper_v<reference_wrapper<_Tp>> = true;
+
 _CCCL_END_NAMESPACE_CUDA_STD
 
 #include <cuda/std/__cccl/epilogue.h>

cuda/cccl/headers/include/cuda/std/__fwd/span.h

@@ -33,10 +33,10 @@ template <typename _Tp, size_t _Extent = dynamic_extent>
 class span;
 
 template <class _Tp>
-inline constexpr bool __is_std_span_v = false;
+inline constexpr bool __is_cuda_std_span_v = false;
 
 template <class _Tp, size_t _Extent>
-inline constexpr bool __is_std_span_v<span<_Tp, _Extent>> = true;
+inline constexpr bool __is_cuda_std_span_v<span<_Tp, _Extent>> = true;
 
 _CCCL_END_NAMESPACE_CUDA_STD
 

cuda/cccl/headers/include/cuda/std/__fwd/string.h

@@ -98,6 +98,13 @@ class _CCCL_PREFERRED_NAME(string)
 // clang-format on
 #endif // 0
 
+template <class _Tp>
+inline constexpr bool __is_std_basic_string_v = false;
+#if _CCCL_HAS_HOST_STD_LIB()
+template <class _CharT, class _Traits, class _Alloc>
+inline constexpr bool __is_std_basic_string_v<::std::basic_string<_CharT, _Traits, _Alloc>> = true;
+#endif // _CCCL_HAS_HOST_STD_LIB()
+
 _CCCL_END_NAMESPACE_CUDA_STD
 
 #include <cuda/std/__cccl/epilogue.h>

cuda/cccl/headers/include/cuda/std/__fwd/string_view.h

@@ -66,6 +66,24 @@ _CCCL_PREFERRED_NAME(wstring_view)
       basic_string_view;
 // clang-format on
 
+template <class _Tp>
+inline constexpr bool __is_std_basic_string_view_v = false;
+#if _CCCL_HAS_HOST_STD_LIB() && __cpp_lib_string_view >= 201606L
+template <class _CharT, class _Traits>
+inline constexpr bool __is_std_basic_string_view_v<::std::basic_string_view<_CharT, _Traits>> = true;
+#endif // _CCCL_HAS_HOST_STD_LIB() && __cpp_lib_string_view >= 201606L
+
+template <class _Tp>
+inline constexpr bool __is_cuda_std_basic_string_view_v = false;
+template <class _Tp>
+inline constexpr bool __is_cuda_std_basic_string_view_v<const _Tp> = __is_cuda_std_basic_string_view_v<_Tp>;
+template <class _Tp>
+inline constexpr bool __is_cuda_std_basic_string_view_v<volatile _Tp> = __is_cuda_std_basic_string_view_v<_Tp>;
+template <class _Tp>
+inline constexpr bool __is_cuda_std_basic_string_view_v<const volatile _Tp> = __is_cuda_std_basic_string_view_v<_Tp>;
+template <class _CharT, class _Traits>
+inline constexpr bool __is_cuda_std_basic_string_view_v<basic_string_view<_CharT, _Traits>> = true;
+
 _CCCL_END_NAMESPACE_CUDA_STD
 
 #include <cuda/std/__cccl/epilogue.h>

cuda/cccl/headers/include/cuda/std/__fwd/tuple.h

@@ -27,6 +27,9 @@ _CCCL_BEGIN_NAMESPACE_CUDA_STD
 template <class...>
 class _CCCL_TYPE_VISIBILITY_DEFAULT tuple;
 
+template <class>
+inline constexpr bool __is_tuple_of_iterator_references_v = false;
+
 _CCCL_END_NAMESPACE_CUDA_STD
 
 #include <cuda/std/__cccl/epilogue.h>

cuda/cccl/headers/include/cuda/std/__fwd/unexpected.h

@@ -0,0 +1,40 @@
+//===---------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _CUDA_STD___FWD_UNEXPECTED_H
+#define _CUDA_STD___FWD_UNEXPECTED_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA_STD
+
+template <class _Err>
+class _CCCL_TYPE_VISIBILITY_DEFAULT unexpected;
+
+template <class _Tp>
+inline constexpr bool __is_cuda_std_unexpected = false;
+
+template <class _Err>
+inline constexpr bool __is_cuda_std_unexpected<unexpected<_Err>> = true;
+
+_CCCL_END_NAMESPACE_CUDA_STD
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA_STD___FWD_UNEXPECTED_H

cuda/cccl/headers/include/cuda/std/{__type_traits/is_reference_wrapper.h → __fwd/variant.h}

@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef _CUDA_STD___TYPE_TRAITS_IS_REFERENCE_WRAPPER_H
-#define _CUDA_STD___TYPE_TRAITS_IS_REFERENCE_WRAPPER_H
+#ifndef _CUDA_STD___FWD_VARIANT_H
+#define _CUDA_STD___FWD_VARIANT_H
 
 #include <cuda/std/detail/__config>
 
@@ -20,31 +20,32 @@
 #  pragma system_header
 #endif // no system header
 
-#include <cuda/std/__fwd/reference_wrapper.h>
-#include <cuda/std/__type_traits/integral_constant.h>
-#include <cuda/std/__type_traits/remove_cv.h>
-
 #include <cuda/std/__cccl/prologue.h>
 
 _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
-template <class _Tp>
-inline constexpr bool __cccl_is_reference_wrapper_v = false;
+template <class... _Types>
+class _CCCL_TYPE_VISIBILITY_DEFAULT variant;
 
 template <class _Tp>
-inline constexpr bool __cccl_is_reference_wrapper_v<reference_wrapper<_Tp>> = true;
+struct _CCCL_TYPE_VISIBILITY_DEFAULT variant_size;
 
 template <class _Tp>
-inline constexpr bool __cccl_is_reference_wrapper_v<const reference_wrapper<_Tp>> = true;
+inline constexpr size_t variant_size_v = variant_size<_Tp>::value;
 
-template <class _Tp>
-inline constexpr bool __cccl_is_reference_wrapper_v<volatile reference_wrapper<_Tp>> = true;
+template <size_t _Ip, class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT variant_alternative;
 
-template <class _Tp>
-inline constexpr bool __cccl_is_reference_wrapper_v<const volatile reference_wrapper<_Tp>> = true;
+template <size_t _Ip, class _Tp>
+using variant_alternative_t = typename variant_alternative<_Ip, _Tp>::type;
+
+inline constexpr size_t variant_npos = static_cast<size_t>(-1);
+
+template <class _IndexType>
+inline constexpr _IndexType __variant_npos = static_cast<_IndexType>(-1);
 
 _CCCL_END_NAMESPACE_CUDA_STD
 
 #include <cuda/std/__cccl/epilogue.h>
 
-#endif // _CUDA_STD___TYPE_TRAITS_ENABLE_IF_H
+#endif // _CUDA_STD___FWD_VARIANT_H

cuda/cccl/headers/include/cuda/std/__internal/features.h

@@ -69,4 +69,18 @@
 #  define _LIBCUDACXX_HAS_NVBF16() 0
 #endif // _CCCL_HAS_NVBF16() && _CCCL_CTK_AT_LEAST(12, 2)
 
+// Clang provides 128b atomics as a builtin
+#if defined(CCCL_ENABLE_EXPERIMENTAL_HOST_ATOMICS_128B)
+#  define _CCCL_HOST_128_ATOMICS_ENABLED() 1
+#  define _CCCL_HOST_128_ATOMICS_MAYBE()   0
+// GCC does not provide 128b atomics, but they may be available as a library, this requires opt-in usage.
+// See: https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html "-mcx16" for more
+#elif _CCCL_COMPILER(CLANG) || _CCCL_COMPILER(GCC)
+#  define _CCCL_HOST_128_ATOMICS_ENABLED() 0
+#  define _CCCL_HOST_128_ATOMICS_MAYBE()   1
+#else
+#  define _CCCL_HOST_128_ATOMICS_ENABLED() 0
+#  define _CCCL_HOST_128_ATOMICS_MAYBE()   0
+#endif
+
 #endif // _CUDA_STD___INTERNAL_FEATURES_H

cuda/cccl/headers/include/cuda/std/__iterator/istream_iterator.h

@@ -22,12 +22,12 @@
 #endif // no system header
 
 #include <cuda/std/__fwd/char_traits.h>
+#include <cuda/std/__fwd/ios.h>
 #include <cuda/std/__iterator/default_sentinel.h>
 #include <cuda/std/__iterator/iterator.h>
 #include <cuda/std/__iterator/iterator_traits.h>
 #include <cuda/std/__memory/addressof.h>
 #include <cuda/std/cstddef>
-#include <cuda/std/detail/libcxx/include/iosfwd>
 
 #include <cuda/std/__cccl/prologue.h>
 

cuda/cccl/headers/include/cuda/std/__iterator/istreambuf_iterator.h

@@ -21,10 +21,10 @@
 #  pragma system_header
 #endif // no system header
 
+#include <cuda/std/__fwd/ios.h>
 #include <cuda/std/__iterator/default_sentinel.h>
 #include <cuda/std/__iterator/iterator.h>
 #include <cuda/std/__iterator/iterator_traits.h>
-#include <cuda/std/detail/libcxx/include/iosfwd>
 
 #include <cuda/std/__cccl/prologue.h>
 

cuda/cccl/headers/include/cuda/std/__iterator/iter_swap.h

@@ -26,6 +26,7 @@
 #include <cuda/std/__iterator/iter_move.h>
 #include <cuda/std/__iterator/iterator_traits.h>
 #include <cuda/std/__iterator/readable_traits.h>
+#include <cuda/std/__type_traits/add_lvalue_reference.h>
 #include <cuda/std/__type_traits/remove_cvref.h>
 #include <cuda/std/__utility/forward.h>
 #include <cuda/std/__utility/move.h>
@@ -33,82 +34,99 @@
 #include <cuda/std/__cccl/prologue.h>
 
 // [iter.cust.swap]
-
 _CCCL_BEGIN_NAMESPACE_RANGES
 _CCCL_BEGIN_NAMESPACE_CPO(__iter_swap)
 template <class _I1, class _I2>
 void iter_swap(_I1, _I2) = delete;
 
-#if _CCCL_HAS_CONCEPTS()
 template <class _T1, class _T2>
-concept __unqualified_iter_swap =
-  (__class_or_enum<remove_cvref_t<_T1>> || __class_or_enum<remove_cvref_t<_T2>>)
-  && requires(_T1&& __x, _T2&& __y) { iter_swap(::cuda::std::forward<_T1>(__x), ::cuda::std::forward<_T2>(__y)); };
+_CCCL_CONCEPT __unqualified_iter_swap = _CCCL_REQUIRES_EXPR((_T1, _T2), _T1&& __x, _T2&& __y)(
+  requires(__class_or_enum<remove_cvref_t<_T1>> || __class_or_enum<remove_cvref_t<_T2>>),
+  ((void) iter_swap(::cuda::std::forward<_T1>(__x), ::cuda::std::forward<_T2>(__y))));
 
+#if _CCCL_HAS_NOEXCEPT_MANGLING() // older GCC cannot use noexcept inside a requires clause
 template <class _T1, class _T2>
-concept __readable_swappable = !__unqualified_iter_swap<_T1, _T2> && indirectly_readable<_T1>
-                            && indirectly_readable<_T2> && swappable_with<iter_reference_t<_T1>, iter_reference_t<_T2>>;
+_CCCL_CONCEPT __noexcept_unqualified_iter_swap = _CCCL_REQUIRES_EXPR((_T1, _T2), _T1&& __x, _T2&& __y)(
+  requires(__unqualified_iter_swap<_T1, _T2>),
+  noexcept(iter_swap(::cuda::std::forward<_T1>(__x), ::cuda::std::forward<_T2>(__y))));
+#else // ^^^ _CCCL_HAS_NOEXCEPT_MANGLING() ^^^ / vvv !_CCCL_HAS_NOEXCEPT_MANGLING() vvv
+template <class _T1, class _T2, bool = __unqualified_iter_swap<_T1, _T2>>
+inline constexpr bool __noexcept_unqualified_iter_swap = false;
 
 template <class _T1, class _T2>
-concept __moveable_storable = !__unqualified_iter_swap<_T1, _T2> && !__readable_swappable<_T1, _T2>
-                           && indirectly_movable_storable<_T1, _T2> && indirectly_movable_storable<_T2, _T1>;
-#else // ^^^ _CCCL_HAS_CONCEPTS() ^^^ / vvv !_CCCL_HAS_CONCEPTS() vvv
-template <class _T1, class _T2>
-_CCCL_CONCEPT_FRAGMENT(
-  __unqualified_iter_swap_,
-  requires(_T1&& __x, _T2&& __y)(requires(__class_or_enum<remove_cvref_t<_T1>> || __class_or_enum<remove_cvref_t<_T2>>),
-                                 ((void) iter_swap(::cuda::std::forward<_T1>(__x), ::cuda::std::forward<_T2>(__y)))));
+inline constexpr bool __noexcept_unqualified_iter_swap<_T1, _T2, true> =
+  noexcept(iter_swap(::cuda::std::declval<_T1>(), ::cuda::std::declval<_T2>()));
+#endif // !_CCCL_HAS_NOEXCEPT_MANGLING()
 
 template <class _T1, class _T2>
-_CCCL_CONCEPT __unqualified_iter_swap = _CCCL_FRAGMENT(__unqualified_iter_swap_, _T1, _T2);
+_CCCL_CONCEPT __readable_swappable = _CCCL_REQUIRES_EXPR((_T1, _T2))(
+  requires(!__unqualified_iter_swap<_T1, _T2>),
+  requires(indirectly_readable<_T1>),
+  requires(indirectly_readable<_T2>),
+  requires(__can_reference<iter_reference_t<_T1>>),
+  requires(__can_reference<iter_reference_t<_T2>>),
+  requires(swappable_with<iter_reference_t<_T1>, iter_reference_t<_T2>>));
+
+#if _CCCL_HAS_NOEXCEPT_MANGLING() // older GCC cannot use noexcept inside a requires clause
+template <class _T1, class _T2>
+_CCCL_CONCEPT __noexcept_readable_swappable = _CCCL_REQUIRES_EXPR((_T1, _T2), _T1&& __x, _T2&& __y) //
+  (requires(__readable_swappable<_T1, _T2>),
+   noexcept(::cuda::std::ranges::swap(*::cuda::std::forward<_T1>(__x), *::cuda::std::forward<_T2>(__y))));
+#else // ^^^ _CCCL_HAS_NOEXCEPT_MANGLING() ^^^ / vvv !_CCCL_HAS_NOEXCEPT_MANGLING() vvv
+template <class _T1, class _T2, bool = __readable_swappable<_T1, _T2>>
+inline constexpr bool __noexcept_readable_swappable = false;
 
 template <class _T1, class _T2>
-_CCCL_CONCEPT_FRAGMENT(
-  __readable_swappable_,
-  requires()(requires(!__unqualified_iter_swap<_T1, _T2>),
-             requires(indirectly_readable<_T1>),
-             requires(indirectly_readable<_T2>),
-             requires(swappable_with<iter_reference_t<_T1>, iter_reference_t<_T2>>)));
+inline constexpr bool __noexcept_readable_swappable<_T1, _T2, true> =
+  noexcept(::cuda::std::ranges::swap(*::cuda::std::declval<_T1>(), *::cuda::std::declval<_T2>()));
+#endif // !_CCCL_HAS_NOEXCEPT_MANGLING()
 
 template <class _T1, class _T2>
-_CCCL_CONCEPT __readable_swappable = _CCCL_FRAGMENT(__readable_swappable_, _T1, _T2);
+_CCCL_CONCEPT __movable_storable = _CCCL_REQUIRES_EXPR((_T1, _T2))(
+  requires(!__unqualified_iter_swap<_T1, _T2>),
+  requires(!__readable_swappable<_T1, _T2>),
+  requires(indirectly_movable_storable<_T1, _T2>),
+  requires(indirectly_movable_storable<_T2, _T1>));
 
+#if _CCCL_HAS_NOEXCEPT_MANGLING() // older GCC cannot use noexcept inside a requires clause
 template <class _T1, class _T2>
-_CCCL_CONCEPT_FRAGMENT(
-  __moveable_storable_,
-  requires()(requires(!__unqualified_iter_swap<_T1, _T2>),
-             requires(!__readable_swappable<_T1, _T2>),
-             requires(indirectly_movable_storable<_T1, _T2>),
-             requires(indirectly_movable_storable<_T2, _T1>)));
+_CCCL_CONCEPT __noexcept_movable_storable =
+  _CCCL_REQUIRES_EXPR((_T1, _T2), _T1&& __x, _T2&& __y, iter_value_t<_T2> __old)(
+    requires(__movable_storable<_T1, _T2>),
+    noexcept(iter_value_t<_T2>(::cuda::std::ranges::iter_move(__y))),
+    noexcept(*__y = ::cuda::std::ranges::iter_move(__x)),
+    noexcept(*::cuda::std::forward<_T1>(__x) = ::cuda::std::move(__old)));
+#else // ^^^ _CCCL_HAS_NOEXCEPT_MANGLING() ^^^ / vvv !_CCCL_HAS_NOEXCEPT_MANGLING() vvv
+template <class _T1, class _T2, bool = __movable_storable<_T1, _T2>>
+inline constexpr bool __noexcept_movable_storable = false;
 
 template <class _T1, class _T2>
-_CCCL_CONCEPT __moveable_storable = _CCCL_FRAGMENT(__moveable_storable_, _T1, _T2);
-#endif // ^^^ !_CCCL_HAS_CONCEPTS() ^^^
+inline constexpr bool __noexcept_movable_storable<_T1, _T2, true> =
+  noexcept(iter_value_t<_T2>(::cuda::std::ranges::iter_move(::cuda::std::declval<add_lvalue_reference_t<_T2>>())))
+  && noexcept(*::cuda::std::declval<add_lvalue_reference_t<_T2>>() =
+                ::cuda::std::ranges::iter_move(::cuda::std::declval<add_lvalue_reference_t<_T1>>()))
+  && noexcept(*::cuda::std::declval<_T1>() = ::cuda::std::declval<iter_value_t<_T2>>());
+#endif // !_CCCL_HAS_NOEXCEPT_MANGLING()
 
 struct __fn
 {
   _CCCL_TEMPLATE(class _T1, class _T2)
   _CCCL_REQUIRES(__unqualified_iter_swap<_T1, _T2>)
-  _CCCL_API constexpr void operator()(_T1&& __x, _T2&& __y) const
-    noexcept(noexcept(iter_swap(::cuda::std::forward<_T1>(__x), ::cuda::std::forward<_T2>(__y))))
+  _CCCL_API constexpr void operator()(_T1&& __x, _T2&& __y) const noexcept(__noexcept_unqualified_iter_swap<_T1, _T2>)
   {
     (void) iter_swap(::cuda::std::forward<_T1>(__x), ::cuda::std::forward<_T2>(__y));
   }
 
   _CCCL_TEMPLATE(class _T1, class _T2)
   _CCCL_REQUIRES(__readable_swappable<_T1, _T2>)
-  _CCCL_API constexpr void operator()(_T1&& __x, _T2&& __y) const
-    noexcept(noexcept(::cuda::std::ranges::swap(*::cuda::std::forward<_T1>(__x), *::cuda::std::forward<_T2>(__y))))
+  _CCCL_API constexpr void operator()(_T1&& __x, _T2&& __y) const noexcept(__noexcept_readable_swappable<_T1, _T2>)
   {
     ::cuda::std::ranges::swap(*::cuda::std::forward<_T1>(__x), *::cuda::std::forward<_T2>(__y));
   }
 
   _CCCL_TEMPLATE(class _T1, class _T2)
-  _CCCL_REQUIRES(__moveable_storable<_T2, _T1>)
-  _CCCL_API constexpr void operator()(_T1&& __x, _T2&& __y) const
-    noexcept(noexcept(iter_value_t<_T2>(::cuda::std::ranges::iter_move(__y)))
-             && noexcept(*__y = ::cuda::std::ranges::iter_move(__x))
-             && noexcept(*::cuda::std::forward<_T1>(__x) = declval<iter_value_t<_T2>>()))
+  _CCCL_REQUIRES(__movable_storable<_T2, _T1>)
+  _CCCL_API constexpr void operator()(_T1&& __x, _T2&& __y) const noexcept(__noexcept_movable_storable<_T1, _T2>)
   {
     iter_value_t<_T2> __old(::cuda::std::ranges::iter_move(__y));
     *__y                            = ::cuda::std::ranges::iter_move(__x);

cuda/cccl/headers/include/cuda/std/__iterator/ostream_iterator.h

@@ -22,11 +22,11 @@
 #endif // no system header
 
 #include <cuda/std/__fwd/char_traits.h>
+#include <cuda/std/__fwd/ios.h>
 #include <cuda/std/__iterator/iterator.h>
 #include <cuda/std/__iterator/iterator_traits.h>
 #include <cuda/std/__memory/addressof.h>
 #include <cuda/std/cstddef>
-#include <cuda/std/detail/libcxx/include/iosfwd>
 
 #include <cuda/std/__cccl/prologue.h>
 

cuda/cccl/headers/include/cuda/std/__iterator/ostreambuf_iterator.h

@@ -21,10 +21,10 @@
 #  pragma system_header
 #endif // no system header
 
+#include <cuda/std/__fwd/ios.h>
 #include <cuda/std/__iterator/iterator.h>
 #include <cuda/std/__iterator/iterator_traits.h>
 #include <cuda/std/cstddef>
-#include <cuda/std/detail/libcxx/include/iosfwd>
 
 #include <cuda/std/__cccl/prologue.h>
 

cuda/cccl/headers/include/cuda/std/__iterator/reverse_iterator.h

@@ -38,11 +38,6 @@
 #include <cuda/std/__iterator/prev.h>
 #include <cuda/std/__iterator/readable_traits.h>
 #include <cuda/std/__memory/addressof.h>
-#ifdef _LIBCUDACXX_HAS_RANGES
-#  include <cuda/std/__ranges/access.h>
-#  include <cuda/std/__ranges/concepts.h>
-#  include <cuda/std/__ranges/subrange.h>
-#endif // _LIBCUDACXX_HAS_RANGES
 #include <cuda/std/__type_traits/conditional.h>
 #include <cuda/std/__type_traits/enable_if.h>
 #include <cuda/std/__type_traits/is_assignable.h>

cuda/cccl/headers/include/cuda/std/__limits/numeric_limits.h

@@ -25,6 +25,7 @@
 #include <cuda/std/__type_traits/is_floating_point.h>
 #include <cuda/std/__type_traits/is_integral.h>
 #include <cuda/std/__type_traits/is_same.h>
+#include <cuda/std/__type_traits/make_unsigned.h>
 #include <cuda/std/cfloat>
 #include <cuda/std/climits>
 
@@ -149,22 +150,6 @@ public:
   static constexpr float_round_style round_style = round_toward_zero;
 };
 
-// MSVC warns about overflowing left shift
-_CCCL_DIAG_PUSH
-_CCCL_DIAG_SUPPRESS_MSVC(4309)
-template <class _Tp, int __digits, bool _IsSigned>
-struct __int_min
-{
-  static constexpr _Tp value = static_cast<_Tp>(_Tp(1) << __digits);
-};
-_CCCL_DIAG_POP
-
-template <class _Tp, int __digits>
-struct __int_min<_Tp, __digits, false>
-{
-  static constexpr _Tp value = _Tp(0);
-};
-
 template <class _Tp>
 class __numeric_limits_impl<_Tp, __numeric_limits_type::__integral>
 {
@@ -179,11 +164,12 @@ public:
   static constexpr int max_digits10 = 0;
   _CCCL_API static constexpr type min() noexcept
   {
-    return __int_min<type, digits, is_signed>::value;
+    return static_cast<_Tp>(~max());
   }
   _CCCL_API static constexpr type max() noexcept
   {
-    return is_signed ? type(type(~0) ^ min()) : type(~0);
+    using _Up = make_unsigned_t<_Tp>;
+    return static_cast<_Tp>(static_cast<_Up>(~_Up{0}) >> static_cast<int>(is_signed));
   }
   _CCCL_API static constexpr type lowest() noexcept
   {

cuda/cccl/headers/include/cuda/std/__linalg/conj_if_needed.h

@@ -39,9 +39,9 @@ _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
 namespace linalg
 {
-
 _CCCL_BEGIN_NAMESPACE_CPO(__conj_if_needed)
 
+// Need newline for concept emulation :_(
 template <class _Type>
 _CCCL_CONCEPT _HasConj = _CCCL_REQUIRES_EXPR((_Type), _Type __a)(static_cast<void>(::cuda::std::conj(__a)));
 
@@ -67,7 +67,6 @@ _CCCL_END_NAMESPACE_CPO
 inline namespace __cpo
 {
 _CCCL_GLOBAL_CONSTANT auto conj_if_needed = __conj_if_needed::__conj_if_needed{};
-
 } // namespace __cpo
 } // end namespace linalg
 

cuda/cccl/headers/include/cuda/std/__linalg/conjugate_transposed.h

@@ -38,13 +38,11 @@ _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
 namespace linalg
 {
-
 template <class _ElementType, class _Extents, class _Layout, class _Accessor>
 [[nodiscard]] _CCCL_API constexpr auto conjugate_transposed(mdspan<_ElementType, _Extents, _Layout, _Accessor> __a)
 {
   return conjugated(transposed(__a));
 }
-
 } // end namespace linalg
 
 _CCCL_END_NAMESPACE_CUDA_STD

cuda/cccl/headers/include/cuda/std/__linalg/conjugated.h

@@ -42,7 +42,6 @@ _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
 namespace linalg
 {
-
 template <class _NestedAccessor>
 class conjugated_accessor
 {
@@ -129,7 +128,6 @@ conjugated(mdspan<_ElementType, _Extents, _Layout, conjugated_accessor<_NestedAc
   return mdspan<__return_element_type, _Extents, _Layout, __return_accessor_type>(
     __a.data_handle(), __a.mapping(), __a.accessor().nested_accessor());
 }
-
 } // end namespace linalg
 
 _CCCL_END_NAMESPACE_CUDA_STD

cuda/cccl/headers/include/cuda/std/__linalg/scaled.h

@@ -41,7 +41,6 @@ _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
 namespace linalg
 {
-
 template <class _ScalingFactor, class _NestedAccessor>
 class scaled_accessor
 {
@@ -105,10 +104,8 @@ private:
 
 namespace __detail
 {
-
 template <class _ScalingFactor, class _NestedAccessor>
 using __scaled_element_type = add_const_t<typename scaled_accessor<_ScalingFactor, _NestedAccessor>::element_type>;
-
 } // namespace __detail
 
 template <class _ScalingFactor, class _ElementType, class _Extents, class _Layout, class _Accessor>
@@ -122,7 +119,6 @@ scaled(_ScalingFactor __scaling_factor, mdspan<_ElementType, _Extents, _Layout,
   using __acc_type = scaled_accessor<_ScalingFactor, _Accessor>;
   return {__x.data_handle(), __x.mapping(), __acc_type{__scaling_factor, __x.accessor()}};
 }
-
 } // end namespace linalg
 
 _CCCL_END_NAMESPACE_CUDA_STD