Fix SeedSequence SFINAE, SaltedSeedSeq truncation salting, and reseed mixing.

DO_NOT_SUBMIT: Found additional repairs

Custom `SeedSequence` types, `absl::SeedSeq` overloads, and engine seeding
previously had several correctness gaps:
* Passing an lvalue or `const` `absl::SeedSeq` to `absl::BitGen` or
  `absl::InsecureBitGen` copied or re-wrapped it in another `SaltedSeedSeq`,
  double-salting outputs or dropping entropy from stateful zero-size seeders;
  brace-moving `absl::SeedSeq b{std::move(a)}` selected the `initializer_list`
  constructor instead of moving, and `SaltedSeedSeq` permitted rvalue-reference
  template arguments.
* Narrow `SaltedSeedSeq::generate()` requests (`n < min(60, 2 * s)`) mixed salt
  only after `[rand.util.seedseq]` truncation collisions had already occurred;
  expanding to `min(60, 2 * s)` words and folding both the salt and excess words
  into the `n`-word output eliminates collisions up to 1,056 bits (`s <= 33`)
  while keeping `size()` and `param()` unsalted.
* Engine and `SaltedSeedSeq` `SeedSequence` overloads lacked uniform
  `[rand.req.seedseq]` SFINAE constraints (including `result_type` validation
  on `randen_engine` and `pcg_engine` and constraints on
  `randen_engine::reseed()`), and seeding `randen_engine` with a 64-bit
  `SeedSequence::result_type` overflowed its 32-bit seed buffer sizing.
* `RandenPoolSeedSeq::generate()` wrote raw bytes directly into any pointer or
  `std::vector<U>::iterator`, causing trap-representation UB on `bool*` and
  corrupting non-integral targets assignable from `uint32_t`.
* `randen_engine` decoupled `RandenPoolSeedSeq` via `IsDirectEntropySeedSeq`
  (drawing 8 pool words directly into two even 128-bit rate lanes rather than
  inferring pool seeding from `seq.size() == 0`), and `reseed(seq)` now permutes
  and domain-separates capacity before absorbing seed material while keeping all
  constructors and `seed()` streams bit-identical.

PiperOrigin-RevId: 1022538016
diff --git a/absl/random/CMakeLists.txt b/absl/random/CMakeLists.txt
index cef4ab5..7e4b1d1 100644
--- a/absl/random/CMakeLists.txt
+++ b/absl/random/CMakeLists.txt
@@ -688,9 +688,11 @@
   LINKOPTS
     ${ABSL_DEFAULT_LINKOPTS}
   DEPS
+    absl::config
     absl::inlined_vector
     absl::optional
     absl::random_internal_seed_material
+    absl::random_internal_traits
     absl::span
     absl::type_traits
 )
@@ -774,6 +776,7 @@
     absl::random_internal_entropy_pool
     absl::random_internal_salted_seed_seq
     absl::random_internal_seed_material
+    absl::random_internal_traits
     absl::type_traits
 )
 
@@ -788,10 +791,12 @@
   LINKOPTS
     ${ABSL_DEFAULT_LINKOPTS}
   DEPS
+    absl::bits
     absl::config
     absl::int128
     absl::random_internal_fastmath
     absl::random_internal_iostream_state_saver
+    absl::random_internal_traits
     absl::type_traits
 )
 
@@ -806,9 +811,11 @@
   LINKOPTS
     ${ABSL_DEFAULT_LINKOPTS}
   DEPS
+    absl::config
     absl::endian
     absl::random_internal_iostream_state_saver
     absl::random_internal_randen
+    absl::random_internal_traits
     absl::raw_logging_internal
     absl::type_traits
 )
@@ -1073,6 +1080,7 @@
     absl::random_random
     absl::synchronization
     absl::type_traits
+    GTest::gmock
     GTest::gtest_main
 )
 
@@ -1121,6 +1129,7 @@
   LINKOPTS
     ${ABSL_DEFAULT_LINKOPTS}
   DEPS
+    absl::config
     absl::random_internal_explicit_seed_seq
     absl::random_internal_pcg_engine
     absl::time
@@ -1139,6 +1148,7 @@
   LINKOPTS
     ${ABSL_DEFAULT_LINKOPTS}
   DEPS
+    absl::config
     absl::log
     absl::random_internal_explicit_seed_seq
     absl::random_internal_randen_engine
diff --git a/absl/random/internal/BUILD.bazel b/absl/random/internal/BUILD.bazel
index 04f9a27..251a393 100644
--- a/absl/random/internal/BUILD.bazel
+++ b/absl/random/internal/BUILD.bazel
@@ -239,6 +239,7 @@
     linkopts = ABSL_DEFAULT_LINKOPTS,
     deps = [
         ":seed_material",
+        ":traits",
         "//absl/base:config",
         "//absl/container:inlined_vector",
         "//absl/meta:type_traits",
@@ -310,6 +311,7 @@
         ":entropy_pool",
         ":salted_seed_seq",
         ":seed_material",
+        ":traits",
         "//absl/base:config",
         "//absl/container:inlined_vector",
         "//absl/meta:type_traits",
@@ -324,6 +326,7 @@
     deps = [
         ":fastmath",
         ":iostream_state_saver",
+        ":traits",
         "//absl/base:config",
         "//absl/meta:type_traits",
         "//absl/numeric:bits",
@@ -341,6 +344,7 @@
     deps = [
         ":iostream_state_saver",
         ":randen",
+        ":traits",
         "//absl/base:config",
         "//absl/base:endian",
         "//absl/meta:type_traits",
@@ -689,6 +693,7 @@
     deps = [
         ":explicit_seed_seq",
         ":pcg_engine",
+        "//absl/base:config",
         "@googletest//:gtest",
         "@googletest//:gtest_main",
     ],
@@ -705,6 +710,7 @@
     deps = [
         ":explicit_seed_seq",
         ":randen_engine",
+        "//absl/base:config",
         "//absl/log",
         "//absl/time",
         "@googletest//:gtest",
diff --git a/absl/random/internal/nonsecure_base.h b/absl/random/internal/nonsecure_base.h
index d1442f8..ec4604e 100644
--- a/absl/random/internal/nonsecure_base.h
+++ b/absl/random/internal/nonsecure_base.h
@@ -29,11 +29,47 @@
 #include "absl/random/internal/entropy_pool.h"
 #include "absl/random/internal/salted_seed_seq.h"
 #include "absl/random/internal/seed_material.h"
+#include "absl/random/internal/traits.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace random_internal {
 
+// True when `Iterator` is a known contiguous mutable iterator over non-bool
+// integral elements (`U*` or `std::vector<U>::iterator`) whose object
+// representation can be filled directly with random bytes. Excludes `bool`
+// (trap representations), non-integral types (arbitrary object layout),
+// `const`/`volatile` pointees, and proxy references, without instantiating
+// `std::iterator_traits<void*>` (ill-formed in C++17) or `std::vector<U>` for
+// non-qualifying `U`.
+template <typename Iterator, bool IsPointer = std::is_pointer_v<Iterator>,
+          typename = void>
+struct IsRandenPoolContiguousIterator : std::false_type {};
+
+template <typename Iterator>
+struct IsRandenPoolContiguousIterator<Iterator, true, void>
+    : std::bool_constant<
+          std::is_same_v<std::remove_pointer_t<Iterator>,
+                         std::remove_cv_t<std::remove_pointer_t<Iterator>>> &&
+          std::is_integral_v<std::remove_pointer_t<Iterator>> &&
+          !std::is_same_v<std::remove_pointer_t<Iterator>, bool>> {};
+
+template <typename Iterator>
+struct IsRandenPoolContiguousIterator<
+    Iterator, false,
+    std::enable_if_t<
+        std::is_same_v<typename std::iterator_traits<Iterator>::value_type,
+                       absl::remove_cvref_t<typename std::iterator_traits<
+                           Iterator>::value_type>> &&
+        std::is_integral_v<
+            typename std::iterator_traits<Iterator>::value_type> &&
+        !std::is_same_v<typename std::iterator_traits<Iterator>::value_type,
+                        bool> &&
+        std::is_same_v<typename std::iterator_traits<Iterator>::reference,
+                       typename std::iterator_traits<Iterator>::value_type&>>>
+    : std::is_same<Iterator, typename std::vector<typename std::iterator_traits<
+                                 Iterator>::value_type>::iterator> {};
+
 // RandenPoolSeedSeq is a custom seed sequence type where generate() fills the
 // provided buffer via the RandenPool entropy source.
 class RandenPoolSeedSeq {
@@ -54,16 +90,16 @@
   template <typename RandomAccessIterator>
   void generate_impl(BufferTag, RandomAccessIterator begin,
                      RandomAccessIterator end) {
-    const size_t n = std::distance(begin, end);
+    const size_t n = static_cast<size_t>(std::distance(begin, end));
     absl::InlinedVector<uint32_t, 8> data(n, 0);
-    GetEntropyFromRandenPool(data.begin(), sizeof(data[0]) * n);
+    GetEntropyFromRandenPool(data.data(), sizeof(data[0]) * n);
     std::copy(std::begin(data), std::end(data), begin);
   }
 
  public:
   using result_type = uint32_t;
 
-  size_t size() { return 0; }
+  size_t size() const { return 0; }
 
   template <typename OutIterator>
   void param(OutIterator) const {}
@@ -72,16 +108,13 @@
   void generate(RandomAccessIterator begin, RandomAccessIterator end) {
     // RandomAccessIterator must be assignable from uint32_t
     if (begin != end) {
-      using U = typename std::iterator_traits<RandomAccessIterator>::value_type;
-      // ContiguousTag indicates the common case of a known contiguous buffer,
-      // which allows directly filling the buffer. In C++20,
-      // std::contiguous_iterator_tag provides a mechanism for testing this
-      // capability, however until Abseil's support requirements allow us to
-      // assume C++20, limit checks to a few common cases.
+      // ContiguousTag indicates the common case of a known contiguous buffer of
+      // mutable non-bool integral values, which allows directly filling the
+      // buffer. In C++20, std::contiguous_iterator_tag provides a mechanism for
+      // testing this capability, however until Abseil's support requirements
+      // allow us to assume C++20, limit checks to a few common cases.
       using TagType = std::conditional_t<
-          (std::is_pointer_v<RandomAccessIterator> ||
-           std::is_same_v<RandomAccessIterator,
-                          typename std::vector<U>::iterator>),
+          IsRandenPoolContiguousIterator<RandomAccessIterator>::value,
           ContiguousTag, BufferTag>;
 
       generate_impl(TagType{}, begin, end);
@@ -89,6 +122,65 @@
   }
 };
 
+template <>
+struct IsDirectEntropySeedSeq<RandenPoolSeedSeq> : std::true_type {};
+
+// Detects whether `URBG` can be constructed directly from `seq` (if it is
+// already a `SaltedSeedSeq`) or from a stack-scoped non-owning
+// `SaltedSeedSeq<std::remove_reference_t<SSeq>&>`.
+template <typename URBG, typename SSeq, typename = void>
+struct CanDirectlySeedURBG : std::false_type {};
+
+template <typename URBG, typename SSeq>
+struct CanDirectlySeedURBG<URBG, SSeq,
+                           std::enable_if_t<HasSeedSeqGenerate<SSeq>::value>>
+    : std::is_constructible<
+          URBG,
+          std::conditional_t<is_salted_seed_seq<SSeq>::value,
+                             std::remove_reference_t<SSeq>&,
+                             SaltedSeedSeq<std::remove_reference_t<SSeq>&>&>> {
+};
+
+template <typename SSeq, typename ResultType, typename = void>
+struct HasSeedSeqParam : std::false_type {};
+
+template <typename SSeq, typename ResultType>
+struct HasSeedSeqParam<
+    SSeq, ResultType,
+    std::void_t<decltype(std::declval<std::remove_reference_t<SSeq>&>().param(
+        std::back_inserter(
+            std::declval<absl::InlinedVector<ResultType, 8>&>())))>>
+    : std::true_type {};
+
+template <typename URBG, typename SSeq, typename Target, typename ResultType,
+          typename = void>
+struct CanMakeSaltedSeedSeqImpl : std::false_type {};
+
+template <typename URBG, typename SSeq, typename Target, typename ResultType>
+struct CanMakeSaltedSeedSeqImpl<
+    URBG, SSeq, Target, ResultType,
+    std::enable_if_t<std::conjunction_v<
+        std::is_constructible<
+            SaltedSeedSeq<Target>,
+            typename absl::InlinedVector<ResultType, 8>::iterator,
+            typename absl::InlinedVector<ResultType, 8>::iterator>,
+        HasSeedSeqParam<SSeq, ResultType>>>>
+    : std::is_constructible<URBG, SaltedSeedSeq<Target>&> {};
+
+// Detects whether `MakeSaltedSeedSeq(seq)` can construct a mutable owning
+// `SaltedSeedSeq` from `seq` via `seq.param(...)` (e.g. `const std::seed_seq&`
+// or `const absl::SeedSeq&`) that can construct `URBG`.
+template <typename URBG, typename SSeq, typename = void>
+struct CanMakeSaltedSeedSeq : std::false_type {};
+
+template <typename URBG, typename SSeq>
+struct CanMakeSaltedSeedSeq<URBG, SSeq,
+                            std::enable_if_t<HasSeedSeqGenerate<
+                                typename UnwrappedSeedSeq<SSeq>::type>::value>>
+    : CanMakeSaltedSeedSeqImpl<
+          URBG, SSeq, typename UnwrappedSeedSeq<SSeq>::type,
+          typename UnwrappedSeedSeq<SSeq>::type::result_type> {};
+
 // Each instance of NonsecureURBGBase<URBG> will be seeded by variates produced
 // by a thread-unique URBG-instance.
 template <typename URBG, typename Seeder = RandenPoolSeedSeq>
@@ -106,8 +198,14 @@
   NonsecureURBGBase& operator=(NonsecureURBGBase&&) = default;
 
   // Constructor using a seed
-  template <class SSeq, typename = typename std::enable_if_t<
-                            !std::is_same_v<SSeq, NonsecureURBGBase>>>
+  template <
+      class SSeq,
+      typename = std::enable_if_t<
+          !std::is_same_v<absl::remove_cvref_t<SSeq>, NonsecureURBGBase> &&
+          !std::is_base_of_v<NonsecureURBGBase, absl::remove_cvref_t<SSeq>> &&
+          !std::is_convertible_v<SSeq, result_type>>,
+      typename = std::enable_if_t<std::disjunction_v<
+          CanDirectlySeedURBG<URBG, SSeq>, CanMakeSaltedSeedSeq<URBG, SSeq>>>>
   explicit NonsecureURBGBase(SSeq&& seq)
       : urbg_(ConstructURBG(std::forward<SSeq>(seq))) {}
 
@@ -145,9 +243,17 @@
 
   template <typename SSeq>
   static URBG ConstructURBG(SSeq&& seq) {  // NOLINT(runtime/references)
-    auto salted_seq =
-        random_internal::MakeSaltedSeedSeq(std::forward<SSeq>(seq));
-    return URBG(salted_seq);
+    if constexpr (CanDirectlySeedURBG<URBG, SSeq>::value) {
+      if constexpr (is_salted_seed_seq<SSeq>::value) {
+        return URBG(seq);
+      } else {
+        SaltedSeedSeq<std::remove_reference_t<SSeq>&> salted_seq(seq);
+        return URBG(salted_seq);
+      }
+    } else {
+      auto salted_seq = random_internal::MakeSaltedSeedSeq(seq);
+      return URBG(salted_seq);
+    }
   }
 
   URBG urbg_;
diff --git a/absl/random/internal/nonsecure_base_test.cc b/absl/random/internal/nonsecure_base_test.cc
index 61f49cd..be6f28d 100644
--- a/absl/random/internal/nonsecure_base_test.cc
+++ b/absl/random/internal/nonsecure_base_test.cc
@@ -15,8 +15,12 @@
 #include "absl/random/internal/nonsecure_base.h"
 
 #include <algorithm>
+#include <array>
+#include <cmath>
 #include <cstddef>
 #include <cstdint>
+#include <cstring>
+#include <deque>
 #include <iterator>
 #include <random>
 #include <thread>  // NOLINT
@@ -24,6 +28,7 @@
 #include <utility>
 #include <vector>
 
+#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "absl/algorithm/container.h"
 #include "absl/container/flat_hash_set.h"
@@ -76,6 +81,18 @@
 
   static_assert(!std::is_copy_constructible_v<E>,
                 "NonsecureURBGBase should not be copy constructible");
+  static_assert(!std::is_constructible_v<E, E&>,
+                "NonsecureURBGBase should not be constructible from non-const "
+                "lvalue reference");
+  static_assert(!std::is_constructible_v<E, int>,
+                "NonsecureURBGBase should not be constructible from int");
+  static_assert(!std::is_constructible_v<E, T>,
+                "NonsecureURBGBase should not be constructible from "
+                "result_type");
+  static_assert(!std::is_constructible_v<absl::BitGen, int>,
+                "BitGen should not be constructible from int");
+  static_assert(!std::is_constructible_v<absl::BitGen, absl::BitGen&>,
+                "BitGen should not be constructible from BitGen&");
 
   static_assert(!std::is_copy_assignable_v<E>,
                 "NonsecureURBGBase should not be copy assignable");
@@ -265,3 +282,548 @@
   seeder.generate(std::begin(state), std::end(state));
   EXPECT_FALSE(state[0] == 0 && state[1] == 0);
 }
+
+TEST(RandenPoolSeedSeqTest, SizeIsConstAndZero) {
+  const absl::random_internal::RandenPoolSeedSeq const_seeder;
+  EXPECT_EQ(const_seeder.size(), 0u);
+}
+
+namespace {
+struct AssignableSeedSink {
+  static constexpr uint64_t kHeadCanary = 0x1122334455667788ull;
+  static constexpr uint64_t kTailCanary = 0x99aabbccddeeff00ull;
+
+  uint64_t head_canary = kHeadCanary;
+  uint32_t value = 0;
+  int assignments = 0;
+  uint64_t tail_canary = kTailCanary;
+
+  AssignableSeedSink& operator=(uint32_t v) {
+    value = v;
+    ++assignments;
+    return *this;
+  }
+};
+}  // namespace
+
+TEST(RandenPoolSeedSeqTest, ContiguousIteratorTraitGuardsInvalidTypes) {
+  using absl::random_internal::IsRandenPoolContiguousIterator;
+
+  static_assert(IsRandenPoolContiguousIterator<uint8_t*>::value);
+  static_assert(IsRandenPoolContiguousIterator<uint16_t*>::value);
+  static_assert(IsRandenPoolContiguousIterator<uint32_t*>::value);
+  static_assert(IsRandenPoolContiguousIterator<uint64_t*>::value);
+  static_assert(IsRandenPoolContiguousIterator<int32_t*>::value);
+  static_assert(IsRandenPoolContiguousIterator<int64_t*>::value);
+  static_assert(
+      IsRandenPoolContiguousIterator<std::vector<uint32_t>::iterator>::value);
+  static_assert(
+      IsRandenPoolContiguousIterator<std::vector<uint64_t>::iterator>::value);
+  static_assert(
+      IsRandenPoolContiguousIterator<std::vector<int32_t>::iterator>::value);
+
+  // Exclude bool (trap representations), non-integral types (arbitrary object
+  // representations), const/volatile pointees, non-contiguous iterators, and
+  // non-iterators.
+  static_assert(!IsRandenPoolContiguousIterator<bool*>::value);
+  static_assert(!IsRandenPoolContiguousIterator<const bool*>::value);
+  static_assert(
+      !IsRandenPoolContiguousIterator<std::vector<bool>::iterator>::value);
+  static_assert(!IsRandenPoolContiguousIterator<const uint32_t*>::value);
+  static_assert(!IsRandenPoolContiguousIterator<volatile uint32_t*>::value);
+  static_assert(!IsRandenPoolContiguousIterator<
+                std::vector<uint32_t>::const_iterator>::value);
+  static_assert(!IsRandenPoolContiguousIterator<float*>::value);
+  static_assert(!IsRandenPoolContiguousIterator<double*>::value);
+  static_assert(
+      !IsRandenPoolContiguousIterator<std::vector<double>::iterator>::value);
+  static_assert(!IsRandenPoolContiguousIterator<AssignableSeedSink*>::value);
+  static_assert(!IsRandenPoolContiguousIterator<
+                std::vector<AssignableSeedSink>::iterator>::value);
+  static_assert(
+      !IsRandenPoolContiguousIterator<std::deque<uint32_t>::iterator>::value);
+  static_assert(!IsRandenPoolContiguousIterator<void*>::value);
+  static_assert(!IsRandenPoolContiguousIterator<const void*>::value);
+  static_assert(!IsRandenPoolContiguousIterator<void (*)()>::value);
+  static_assert(!IsRandenPoolContiguousIterator<int>::value);
+
+  static_assert(absl::random_internal::IsDirectEntropySeedSeq<
+                absl::random_internal::RandenPoolSeedSeq>::value);
+  static_assert(
+      !absl::random_internal::IsDirectEntropySeedSeq<std::seed_seq>::value);
+}
+
+TEST(RandenPoolSeedSeqTest, SeederAvoidsTrapRepresentationsOnBool) {
+  absl::random_internal::RandenPoolSeedSeq seeder;
+
+  bool bool_array[64] = {};
+  seeder.generate(std::begin(bool_array), std::end(bool_array));
+  int true_count = 0;
+  for (const bool& b : bool_array) {
+    unsigned char raw = 0xff;
+    static_assert(sizeof(bool) == sizeof(unsigned char));
+    std::memcpy(&raw, &b, sizeof(raw));
+    EXPECT_LE(raw, 1u);
+    if (b) ++true_count;
+  }
+  EXPECT_GT(true_count, 0);
+
+  std::vector<bool> bool_vec(16, false);
+  seeder.generate(bool_vec.begin(), bool_vec.end());
+  EXPECT_THAT(bool_vec, testing::Contains(true));
+}
+
+TEST(RandenPoolSeedSeqTest, SeederUsesAssignmentForNonIntegralAndBufferPaths) {
+  absl::random_internal::RandenPoolSeedSeq seeder;
+
+  // Size 12 exceeds InlinedVector<uint32_t, 8>'s inline capacity to exercise
+  // heap-backed BufferTag generation and scrubbing as well.
+  AssignableSeedSink sink_array[12];
+  seeder.generate(std::begin(sink_array), std::end(sink_array));
+  bool any_nonzero = false;
+  for (const auto& s : sink_array) {
+    EXPECT_EQ(s.head_canary, AssignableSeedSink::kHeadCanary);
+    EXPECT_EQ(s.tail_canary, AssignableSeedSink::kTailCanary);
+    EXPECT_EQ(s.assignments, 1);
+    any_nonzero = any_nonzero || (s.value != 0);
+  }
+  EXPECT_TRUE(any_nonzero);
+
+  std::vector<AssignableSeedSink> sink_vec(6);
+  seeder.generate(sink_vec.begin(), sink_vec.end());
+  for (const auto& s : sink_vec) {
+    EXPECT_EQ(s.head_canary, AssignableSeedSink::kHeadCanary);
+    EXPECT_EQ(s.tail_canary, AssignableSeedSink::kTailCanary);
+    EXPECT_EQ(s.assignments, 1);
+  }
+
+  double fp_array[8] = {};
+  seeder.generate(std::begin(fp_array), std::end(fp_array));
+  for (double d : fp_array) {
+    EXPECT_TRUE(std::isfinite(d));
+    EXPECT_GE(d, 0.0);
+    EXPECT_LE(d, static_cast<double>(UINT32_MAX));
+  }
+
+  volatile uint32_t vol_array[4] = {};
+  seeder.generate(std::begin(vol_array), std::end(vol_array));
+  EXPECT_FALSE(vol_array[0] == 0 && vol_array[1] == 0 && vol_array[2] == 0 &&
+               vol_array[3] == 0);
+
+  std::deque<uint32_t> dq(12, 0);
+  seeder.generate(dq.begin(), dq.end());
+  EXPECT_THAT(dq, testing::Contains(testing::Ne(0u)));
+}
+
+TEST(NonsecureURBGBase, LvalueAndRvalueSaltedSeedSeqMatch) {
+  absl::SeedSeq s1{1, 2, 3, 4};
+  absl::SeedSeq s2{1, 2, 3, 4};
+
+  absl::BitGen gen_lvalue(s1);
+  absl::BitGen gen_rvalue(std::move(s2));
+  for (int i = 0; i < 16; ++i) {
+    EXPECT_EQ(gen_lvalue(), gen_rvalue());
+  }
+}
+
+namespace {
+template <typename URBG>
+std::array<typename URBG::result_type, 16> GenerateSequence(URBG& gen) {
+  std::array<typename URBG::result_type, 16> out;
+  for (auto& value : out) {
+    value = gen();
+  }
+  return out;
+}
+
+template <typename ResultT, bool kConstGenerate = true, uint32_t kStart = 1,
+          bool kConstSize = true, bool kHasSize = true>
+struct TestSeedSeq {
+  using result_type = ResultT;
+  size_t count = 4;
+  uint32_t start = kStart;
+
+  explicit TestSeedSeq(size_t n = 4) : count(n) {}
+
+  template <bool H = kHasSize, bool C = kConstSize,
+            std::enable_if_t<H && C, int> = 0>
+  size_t size() const {
+    return count;
+  }
+  template <bool H = kHasSize, bool C = kConstSize,
+            std::enable_if_t<H && !C, int> = 0>
+  size_t size() {
+    return count;
+  }
+
+  template <typename OutIt, bool C = kConstGenerate,
+            std::enable_if_t<C, int> = 0>
+  void generate(OutIt begin, OutIt end) const {
+    uint32_t v = start;
+    for (OutIt it = begin; it != end; ++it) *it = v++;
+  }
+  template <typename OutIt, bool C = kConstGenerate,
+            std::enable_if_t<!C, int> = 0>
+  void generate(OutIt begin, OutIt end) {
+    uint32_t v = start;
+    for (OutIt it = begin; it != end; ++it) *it = v++;
+  }
+};
+
+struct NoResultTypeSeedSeq {
+  size_t size() const { return 2; }
+  template <typename OutIt>
+  void generate(OutIt begin, OutIt end) const {
+    uint32_t v = 1;
+    for (OutIt it = begin; it != end; ++it) *it = v++;
+  }
+};
+
+template <bool kConstGenerate>
+struct ZeroSizeCounterSeedSeq {
+  using result_type = uint32_t;
+  mutable uint32_t counter = 1;
+  size_t size() const { return 0; }
+  template <typename OutIt>
+  void param(OutIt) const {}
+  template <typename OutIt, bool C = kConstGenerate,
+            std::enable_if_t<C, int> = 0>
+  void generate(OutIt begin, OutIt end) const {
+    for (OutIt it = begin; it != end; ++it) *it = counter++;
+  }
+  template <typename OutIt, bool C = kConstGenerate,
+            std::enable_if_t<!C, int> = 0>
+  void generate(OutIt begin, OutIt end) {
+    for (OutIt it = begin; it != end; ++it) *it = counter++;
+  }
+};
+
+template <bool kConstGenerate, bool kHasSize>
+struct TestParamSeedSeq
+    : TestSeedSeq<uint32_t, kConstGenerate, 1, /*kConstSize=*/false, kHasSize> {
+  std::vector<uint32_t> values;
+  TestParamSeedSeq() = default;
+  template <typename It>
+  TestParamSeedSeq(It begin, It end) : values(begin, end) {
+    this->count = values.size();
+    this->start = values.empty() ? 1u : values[0];
+  }
+  template <typename OutIt>
+  void param(OutIt out) const {
+    std::copy(values.begin(), values.end(), out);
+  }
+};
+
+using StatefulZeroSizeSeedSeq = ZeroSizeCounterSeedSeq<false>;
+using ConstGenerateZeroSizeSeedSeq = ZeroSizeCounterSeedSeq<true>;
+using SeedSeq64 = TestSeedSeq<uint64_t, /*kConstGenerate=*/false, 0xdeadbeefu>;
+using SeedSeq32 = TestSeedSeq<uint32_t, /*kConstGenerate=*/false, 0xdeadbeefu>;
+using SignedResultTypeSeedSeq = TestSeedSeq<int32_t>;
+using NarrowResultTypeSeedSeq = TestSeedSeq<uint16_t>;
+using VoidResultTypeSeedSeq = TestSeedSeq<void>;
+using ConstGenerateNonConstSizeSeedSeq =
+    TestSeedSeq<uint32_t, /*kConstGenerate=*/true, 1, /*kConstSize=*/false>;
+using ConstGenerateNoSizeSeedSeq =
+    TestSeedSeq<uint32_t, /*kConstGenerate=*/true, 1, /*kConstSize=*/true,
+                /*kHasSize=*/false>;
+using ConstGenerateNonConstSizeWithParamSeedSeq = TestParamSeedSeq<true, true>;
+using ConstParamNoSizeSeedSeq = TestParamSeedSeq<false, false>;
+}  // namespace
+
+TEST(NonsecureURBGBase, SeedSeqConstructibilityTraits) {
+  static_assert(std::is_constructible_v<absl::BitGen, absl::SeedSeq&>);
+  static_assert(std::is_constructible_v<absl::BitGen, absl::SeedSeq&&>);
+  static_assert(std::is_constructible_v<absl::BitGen, const absl::SeedSeq&>);
+  static_assert(std::is_constructible_v<absl::BitGen, const absl::SeedSeq&&>);
+  static_assert(std::is_constructible_v<absl::BitGen, std::seed_seq&>);
+  static_assert(std::is_constructible_v<absl::BitGen, std::seed_seq&&>);
+  static_assert(std::is_constructible_v<absl::BitGen, const std::seed_seq&>);
+  static_assert(std::is_constructible_v<absl::BitGen, const std::seed_seq&&>);
+  static_assert(
+      std::is_constructible_v<absl::BitGen, StatefulZeroSizeSeedSeq&>);
+  static_assert(
+      !std::is_constructible_v<absl::BitGen, const StatefulZeroSizeSeedSeq&>);
+  static_assert(std::is_constructible_v<absl::BitGen,
+                                        const ConstGenerateZeroSizeSeedSeq&>);
+  static_assert(std::is_constructible_v<absl::BitGen, SeedSeq64&>);
+  static_assert(std::is_constructible_v<absl::BitGen, SeedSeq64&&>);
+  static_assert(!std::is_constructible_v<absl::BitGen, NoResultTypeSeedSeq&>);
+  static_assert(
+      !std::is_constructible_v<absl::BitGen, const NoResultTypeSeedSeq&>);
+  static_assert(
+      !std::is_constructible_v<absl::BitGen, SignedResultTypeSeedSeq&>);
+  static_assert(
+      !std::is_constructible_v<absl::BitGen, NarrowResultTypeSeedSeq&>);
+  static_assert(!std::is_constructible_v<absl::BitGen, VoidResultTypeSeedSeq&>);
+  static_assert(
+      std::is_constructible_v<absl::BitGen, ConstGenerateNonConstSizeSeedSeq&>);
+  static_assert(
+      !std::is_constructible_v<absl::BitGen,
+                               const ConstGenerateNonConstSizeSeedSeq&>);
+  static_assert(
+      !std::is_constructible_v<absl::BitGen, ConstGenerateNoSizeSeedSeq&>);
+  static_assert(!std::is_constructible_v<absl::BitGen,
+                                         const ConstGenerateNoSizeSeedSeq&>);
+  static_assert(
+      std::is_constructible_v<
+          absl::BitGen, const ConstGenerateNonConstSizeWithParamSeedSeq&>);
+  static_assert(
+      !std::is_constructible_v<absl::BitGen, const ConstParamNoSizeSeedSeq&>);
+
+  static_assert(
+      std::is_constructible_v<absl::InsecureBitGen, const absl::SeedSeq&>);
+  static_assert(
+      std::is_constructible_v<absl::InsecureBitGen, const std::seed_seq&>);
+  static_assert(!std::is_constructible_v<absl::InsecureBitGen,
+                                         const StatefulZeroSizeSeedSeq&>);
+  static_assert(std::is_constructible_v<absl::InsecureBitGen,
+                                        const ConstGenerateZeroSizeSeedSeq&>);
+  static_assert(std::is_constructible_v<absl::InsecureBitGen, SeedSeq64&>);
+  static_assert(
+      !std::is_constructible_v<absl::InsecureBitGen, NoResultTypeSeedSeq&>);
+  static_assert(
+      !std::is_constructible_v<absl::InsecureBitGen, SignedResultTypeSeedSeq&>);
+  static_assert(
+      !std::is_constructible_v<absl::InsecureBitGen, NarrowResultTypeSeedSeq&>);
+  static_assert(
+      !std::is_constructible_v<absl::InsecureBitGen, VoidResultTypeSeedSeq&>);
+  static_assert(
+      std::is_constructible_v<absl::InsecureBitGen,
+                              const ConstGenerateNonConstSizeSeedSeq&>);
+  static_assert(std::is_constructible_v<absl::InsecureBitGen,
+                                        const ConstGenerateNoSizeSeedSeq&>);
+  static_assert(std::is_constructible_v<
+                absl::InsecureBitGen,
+                const ConstGenerateNonConstSizeWithParamSeedSeq&>);
+  static_assert(std::is_constructible_v<absl::InsecureBitGen,
+                                        const ConstParamNoSizeSeedSeq&>);
+
+  static_assert(std::is_constructible_v<ExampleNonsecureURBG, SeedSeq64&>);
+  static_assert(
+      !std::is_constructible_v<ExampleNonsecureURBG, NoResultTypeSeedSeq&>);
+  static_assert(
+      !std::is_constructible_v<ExampleNonsecureURBG, SignedResultTypeSeedSeq&>);
+  static_assert(
+      !std::is_constructible_v<ExampleNonsecureURBG, NarrowResultTypeSeedSeq&>);
+  static_assert(
+      !std::is_constructible_v<ExampleNonsecureURBG, VoidResultTypeSeedSeq&>);
+  static_assert(
+      std::is_constructible_v<ExampleNonsecureURBG,
+                              const ConstGenerateNonConstSizeSeedSeq&>);
+  static_assert(std::is_constructible_v<ExampleNonsecureURBG,
+                                        const ConstGenerateNoSizeSeedSeq&>);
+}
+
+TEST(NonsecureURBGBase, ConstSaltedSeedSeqMatchesMutable) {
+  absl::SeedSeq mutable_lvalue{1, 2, 3, 4};
+  absl::SeedSeq mutable_rvalue{1, 2, 3, 4};
+  const absl::SeedSeq const_lvalue{1, 2, 3, 4};
+  const absl::SeedSeq const_rvalue{1, 2, 3, 4};
+
+  absl::BitGen bitgen_mutable_lvalue(mutable_lvalue);
+  absl::BitGen bitgen_mutable_rvalue(std::move(mutable_rvalue));
+  absl::BitGen bitgen_const_lvalue(const_lvalue);
+  absl::BitGen bitgen_const_rvalue(std::move(const_rvalue));
+  const auto expected_bitgen = GenerateSequence(bitgen_mutable_lvalue);
+  EXPECT_THAT(GenerateSequence(bitgen_mutable_rvalue),
+              testing::Eq(expected_bitgen));
+  EXPECT_THAT(GenerateSequence(bitgen_const_lvalue),
+              testing::Eq(expected_bitgen));
+  EXPECT_THAT(GenerateSequence(bitgen_const_rvalue),
+              testing::Eq(expected_bitgen));
+
+  absl::InsecureBitGen insecure_mutable(mutable_lvalue);
+  absl::InsecureBitGen insecure_const(const_lvalue);
+  EXPECT_THAT(GenerateSequence(insecure_const),
+              testing::Eq(GenerateSequence(insecure_mutable)));
+}
+
+TEST(NonsecureURBGBase, ConstStdSeedSeqMatchesMutable) {
+  std::seed_seq mutable_lvalue{1, 2, 3, 4};
+  std::seed_seq mutable_rvalue{1, 2, 3, 4};
+  const std::seed_seq const_lvalue{1, 2, 3, 4};
+  const std::seed_seq const_rvalue{1, 2, 3, 4};
+
+  absl::BitGen bitgen_mutable_lvalue(mutable_lvalue);
+  absl::BitGen bitgen_mutable_rvalue(std::move(mutable_rvalue));
+  absl::BitGen bitgen_const_lvalue(const_lvalue);
+  absl::BitGen bitgen_const_rvalue(std::move(const_rvalue));
+  const auto expected_bitgen = GenerateSequence(bitgen_mutable_lvalue);
+  EXPECT_THAT(GenerateSequence(bitgen_mutable_rvalue),
+              testing::Eq(expected_bitgen));
+  EXPECT_THAT(GenerateSequence(bitgen_const_lvalue),
+              testing::Eq(expected_bitgen));
+  EXPECT_THAT(GenerateSequence(bitgen_const_rvalue),
+              testing::Eq(expected_bitgen));
+
+  absl::InsecureBitGen insecure_mutable(mutable_lvalue);
+  absl::InsecureBitGen insecure_const(const_lvalue);
+  EXPECT_THAT(GenerateSequence(insecure_const),
+              testing::Eq(GenerateSequence(insecure_mutable)));
+}
+
+TEST(NonsecureURBGBase, StatefulZeroSizeSeedSeqPreservesEntropy) {
+  StatefulZeroSizeSeedSeq seeder;
+  absl::BitGen gen1(seeder);
+  absl::BitGen gen2(seeder);
+  EXPECT_THAT(GenerateSequence(gen1), testing::Ne(GenerateSequence(gen2)));
+}
+
+TEST(NonsecureURBGBase, ConstGenerateZeroSizeSeedSeqPreservesEntropy) {
+  const ConstGenerateZeroSizeSeedSeq seeder;
+  absl::BitGen gen1(seeder);
+  absl::BitGen gen2(seeder);
+  EXPECT_THAT(GenerateSequence(gen1), testing::Ne(GenerateSequence(gen2)));
+}
+
+TEST(NonsecureURBGBase, SeedSequenceWith64BitResultTypeMatches32Bit) {
+  SeedSeq64 seq64;
+  SeedSeq32 seq32;
+
+  absl::BitGen bitgen64(seq64);
+  absl::BitGen bitgen32(seq32);
+  EXPECT_THAT(GenerateSequence(bitgen64),
+              testing::Eq(GenerateSequence(bitgen32)));
+
+  absl::InsecureBitGen insecure64(seq64);
+  absl::InsecureBitGen insecure32(seq32);
+  EXPECT_THAT(GenerateSequence(insecure64),
+              testing::Eq(GenerateSequence(insecure32)));
+
+  ExampleNonsecureURBG example64(seq64);
+  ExampleNonsecureURBG example32(seq32);
+  EXPECT_THAT(GenerateSequence(example64),
+              testing::Eq(GenerateSequence(example32)));
+}
+
+TEST(NonsecureURBGBase, ConstFallbackViaParamMatchesDirectSeeding) {
+  std::array<uint32_t, 3> init = {10, 20, 30};
+  ConstGenerateNonConstSizeWithParamSeedSeq mutable_with_param(init.begin(),
+                                                               init.end());
+  const ConstGenerateNonConstSizeWithParamSeedSeq const_with_param(init.begin(),
+                                                                   init.end());
+  absl::BitGen bitgen_from_mutable_param(mutable_with_param);
+  absl::BitGen bitgen_from_const_param(const_with_param);
+  EXPECT_THAT(GenerateSequence(bitgen_from_const_param),
+              testing::Eq(GenerateSequence(bitgen_from_mutable_param)));
+}
+
+TEST(NonsecureURBGBase, NonConstSizeAndNoSizeSeedSeqs) {
+  ConstGenerateNonConstSizeSeedSeq mutable_non_const_size;
+  absl::BitGen bitgen_mutable(mutable_non_const_size);
+  EXPECT_THAT(GenerateSequence(bitgen_mutable),
+              testing::Ne(std::array<absl::BitGen::result_type, 16>{}));
+
+  const ConstGenerateNonConstSizeSeedSeq const_non_const_size;
+  absl::InsecureBitGen insecure_non_const_size(const_non_const_size);
+  ExampleNonsecureURBG example_non_const_size(const_non_const_size);
+  EXPECT_THAT(GenerateSequence(insecure_non_const_size),
+              testing::Ne(std::array<absl::InsecureBitGen::result_type, 16>{}));
+  EXPECT_THAT(GenerateSequence(example_non_const_size),
+              testing::Ne(std::array<ExampleNonsecureURBG::result_type, 16>{}));
+
+  const ConstGenerateNoSizeSeedSeq const_no_size;
+  absl::InsecureBitGen insecure_no_size(const_no_size);
+  ExampleNonsecureURBG example_no_size(const_no_size);
+  EXPECT_THAT(GenerateSequence(insecure_no_size),
+              testing::Ne(std::array<absl::InsecureBitGen::result_type, 16>{}));
+  EXPECT_THAT(GenerateSequence(example_no_size),
+              testing::Ne(std::array<ExampleNonsecureURBG::result_type, 16>{}));
+
+  std::array<uint32_t, 3> init = {10, 20, 30};
+  const ConstParamNoSizeSeedSeq const_param_no_size(init.begin(), init.end());
+  absl::InsecureBitGen insecure_param_no_size(const_param_no_size);
+  EXPECT_THAT(GenerateSequence(insecure_param_no_size),
+              testing::Ne(std::array<absl::InsecureBitGen::result_type, 16>{}));
+}
+
+TEST(NonsecureURBGBase, SaltedSeedingSeparatesStdSeedSeqCollisionTuples) {
+  if (!absl::random_internal::GetSaltMaterial().has_value()) {
+    return;
+  }
+
+  // s = 2 collision pair at n = 2 (affects BitGen(s=2) and pcg32(SeedSeq)).
+  constexpr uint32_t kS2A[2] = {0x00000003u, 0xef243a0au};
+  constexpr uint32_t kS2B[2] = {0x0b8bb54eu, 0xfaafef55u};
+  {
+    absl::SeedSeq salted_a(std::begin(kS2A), std::end(kS2A));
+    absl::SeedSeq salted_b(std::begin(kS2B), std::end(kS2B));
+    absl::random_internal::pcg32_2018_engine pcg_a(salted_a);
+    absl::random_internal::pcg32_2018_engine pcg_b(salted_b);
+    EXPECT_THAT(GenerateSequence(pcg_a), testing::Ne(GenerateSequence(pcg_b)));
+
+    absl::BitGen bitgen_a(salted_a);
+    absl::BitGen bitgen_b(salted_b);
+    EXPECT_THAT(GenerateSequence(bitgen_a),
+                testing::Ne(GenerateSequence(bitgen_b)));
+
+    std::seed_seq std_a(std::begin(kS2A), std::end(kS2A));
+    std::seed_seq std_b(std::begin(kS2B), std::end(kS2B));
+    absl::BitGen bitgen_std_a(std_a);
+    absl::BitGen bitgen_std_b(std_b);
+    EXPECT_THAT(GenerateSequence(bitgen_std_a),
+                testing::Ne(GenerateSequence(bitgen_std_b)));
+  }
+
+  // s = 3 collision pair at n = 3 (affects BitGen(s=3)).
+  constexpr uint32_t kS3A[3] = {0x0000269du, 0x4cc2d2d4u, 0x507fd03cu};
+  constexpr uint32_t kS3B[3] = {0x00033c9bu, 0xa08a4e6cu, 0x5082e63au};
+  {
+    std::seed_seq std_a(std::begin(kS3A), std::end(kS3A));
+    std::seed_seq std_b(std::begin(kS3B), std::end(kS3B));
+    absl::BitGen bitgen_a(std_a);
+    absl::BitGen bitgen_b(std_b);
+    EXPECT_THAT(GenerateSequence(bitgen_a),
+                testing::Ne(GenerateSequence(bitgen_b)));
+  }
+
+  // s = 4 collision pair at n = 4 (affects InsecureBitGen and BitGen(s=4)).
+  constexpr uint32_t kS4A[4] = {0x00010253u, 0x4c1127d0u, 0xc406ad4cu,
+                                0x13a2704du};
+  constexpr uint32_t kS4B[4] = {0x000135d7u, 0xc89ecda0u, 0x24996d88u,
+                                0x13a2a3d1u};
+  {
+    absl::SeedSeq salted_a(std::begin(kS4A), std::end(kS4A));
+    absl::SeedSeq salted_b(std::begin(kS4B), std::end(kS4B));
+    absl::InsecureBitGen insecure_a(salted_a);
+    absl::InsecureBitGen insecure_b(salted_b);
+    EXPECT_THAT(GenerateSequence(insecure_a),
+                testing::Ne(GenerateSequence(insecure_b)));
+
+    absl::BitGen bitgen_a(salted_a);
+    absl::BitGen bitgen_b(salted_b);
+    EXPECT_THAT(GenerateSequence(bitgen_a),
+                testing::Ne(GenerateSequence(bitgen_b)));
+  }
+
+  // s = 8 collision pairs at n = 8 (BitGen) and n = 4 (InsecureBitGen).
+  constexpr uint32_t kS8N8A[8] = {0x7496df94u, 0x2f701878u, 0xf374430bu,
+                                  0x33e4d291u, 0x8e5b51a3u, 0x0f511665u,
+                                  0xd44a6ec8u, 0xbb00fd0au};
+  constexpr uint32_t kS8N8B[8] = {0x64e949bau, 0x47fb3261u, 0xdeaae914u,
+                                  0xfdd32ba0u, 0xa4d1fd8du, 0x357706e1u,
+                                  0xc49cd8eeu, 0xbb01dbdfu};
+  {
+    std::seed_seq std_a(std::begin(kS8N8A), std::end(kS8N8A));
+    std::seed_seq std_b(std::begin(kS8N8B), std::end(kS8N8B));
+    absl::BitGen bitgen_a(std_a);
+    absl::BitGen bitgen_b(std_b);
+    EXPECT_THAT(GenerateSequence(bitgen_a),
+                testing::Ne(GenerateSequence(bitgen_b)));
+  }
+
+  constexpr uint32_t kS8N4A[8] = {0x00000001u, 0x00000002u, 0x00000003u,
+                                  0x00000004u, 0x0000bf91u, 0x67c0a593u,
+                                  0x313389e7u, 0xee5c8e5cu};
+  constexpr uint32_t kS8N4B[8] = {0x00000001u, 0x00000002u, 0x00000003u,
+                                  0x00000004u, 0x00011835u, 0xa5168553u,
+                                  0xcee80a7au, 0xee5ce700u};
+  {
+    absl::SeedSeq salted_a(std::begin(kS8N4A), std::end(kS8N4A));
+    absl::SeedSeq salted_b(std::begin(kS8N4B), std::end(kS8N4B));
+    absl::InsecureBitGen insecure_a(salted_a);
+    absl::InsecureBitGen insecure_b(salted_b);
+    EXPECT_THAT(GenerateSequence(insecure_a),
+                testing::Ne(GenerateSequence(insecure_b)));
+  }
+}
diff --git a/absl/random/internal/pcg_engine.h b/absl/random/internal/pcg_engine.h
index e785392..3616163 100644
--- a/absl/random/internal/pcg_engine.h
+++ b/absl/random/internal/pcg_engine.h
@@ -19,9 +19,11 @@
 #include <cstdint>
 #include <ios>
 #include <istream>
+#include <iterator>
 #include <limits>
 #include <ostream>
 #include <type_traits>
+#include <utility>
 
 #include "absl/base/config.h"
 #include "absl/meta/type_traits.h"
@@ -29,6 +31,7 @@
 #include "absl/numeric/int128.h"
 #include "absl/random/internal/fastmath.h"
 #include "absl/random/internal/iostream_state_saver.h"
+#include "absl/random/internal/traits.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
@@ -58,6 +61,13 @@
   using mix_type = Mix;
   using state_type = typename Mix::state_type;
 
+  template <class SeedSequence>
+  using EnableIfSeedSeq = std::conjunction<
+      std::negation<
+          std::is_base_of<pcg_engine, absl::remove_cvref_t<SeedSequence>>>,
+      std::negation<std::is_convertible<SeedSequence, uint64_t>>,
+      HasSeedSeqGenerate<SeedSequence>>;
+
  public:
   // C++11 URBG interface:
   using result_type = typename Mix::result_type;
@@ -72,8 +82,8 @@
 
   explicit pcg_engine(uint64_t seed_value = 0) { seed(seed_value); }
 
-  template <class SeedSequence, typename = typename std::enable_if_t<
-                                    !std::is_same_v<SeedSequence, pcg_engine>>>
+  template <class SeedSequence,
+            typename = std::enable_if_t<EnableIfSeedSeq<SeedSequence>::value>>
   explicit pcg_engine(SeedSequence&& seq) {
     seed(seq);
   }
@@ -94,10 +104,9 @@
     state_ = lcg(tmp + Params::increment());
   }
 
-  template <class SeedSequence>
-  typename std::enable_if_t<!std::is_convertible_v<SeedSequence, uint64_t>,
-                            void>
-  seed(SeedSequence&& seq) {
+  template <class SeedSequence,
+            typename = std::enable_if_t<EnableIfSeedSeq<SeedSequence>::value>>
+  void seed(SeedSequence&& seq) {
     reseed(seq);
   }
 
@@ -213,15 +222,13 @@
 
   template <class SeedSequence>
   void reseed(SeedSequence& seq) {
-    using sequence_result_type = typename SeedSequence::result_type;
-    constexpr size_t kBufferSize =
-        sizeof(state_type) / sizeof(sequence_result_type);
-    sequence_result_type buffer[kBufferSize];
+    constexpr size_t kBufferSize = sizeof(state_type) / sizeof(uint32_t);
+    uint32_t buffer[kBufferSize];
     seq.generate(std::begin(buffer), std::end(buffer));
     // Convert the seed output to a single state value.
     state_type tmp = buffer[0];
     for (size_t i = 1; i < kBufferSize; i++) {
-      tmp <<= (sizeof(sequence_result_type) * 8);
+      tmp <<= (sizeof(uint32_t) * 8);
       tmp |= buffer[i];
     }
     state_ = lcg(tmp + params_type::increment());
diff --git a/absl/random/internal/pcg_engine_test.cc b/absl/random/internal/pcg_engine_test.cc
index 938dc85..68daaed 100644
--- a/absl/random/internal/pcg_engine_test.cc
+++ b/absl/random/internal/pcg_engine_test.cc
@@ -29,6 +29,7 @@
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
+#include "absl/base/config.h"
 #include "absl/random/internal/explicit_seed_seq.h"
 
 #define UPDATE_GOLDEN 0
@@ -238,6 +239,20 @@
                 "return type of operator== must be bool");
 }
 
+TYPED_TEST(PCGEngineTest, NonConstCopyConstruction) {
+  using E = TypeParam;
+  E v(123);
+  v();
+
+  E copy_paren(v);
+  E copy_brace{v};
+  EXPECT_TRUE(copy_paren == v);
+  EXPECT_TRUE(copy_brace == v);
+  const auto expected = v();
+  EXPECT_EQ(copy_paren(), expected);
+  EXPECT_EQ(copy_brace(), expected);
+}
+
 TYPED_TEST(PCGEngineTest, RandenEngineSFINAETest) {
   using engine_type = TypeParam;
   using result_type = typename engine_type::result_type;
@@ -407,6 +422,163 @@
               FailsLeavingUnchanged());
 }
 
+template <typename Engine, typename Arg, typename = void>
+struct HasSeedMethod : std::false_type {};
+
+template <typename Engine, typename Arg>
+struct HasSeedMethod<
+    Engine, Arg,
+    std::void_t<decltype(std::declval<Engine&>().seed(std::declval<Arg>()))>>
+    : std::true_type {};
+
+template <typename ResultT, bool kConstGenerate = true, uint32_t kStart = 1>
+struct TestSeedSeq {
+  using result_type = ResultT;
+  size_t size() const { return 4; }
+  template <typename OutIt, bool C = kConstGenerate,
+            std::enable_if_t<C, int> = 0>
+  void generate(OutIt begin, OutIt end) const {
+    uint32_t v = kStart;
+    for (OutIt it = begin; it != end; ++it) *it = v++;
+  }
+  template <typename OutIt, bool C = kConstGenerate,
+            std::enable_if_t<!C, int> = 0>
+  void generate(OutIt begin, OutIt end) {
+    uint32_t v = kStart;
+    for (OutIt it = begin; it != end; ++it) *it = v++;
+  }
+};
+
+struct NoResultTypeSeedSeq {
+  size_t size() const { return 4; }
+  template <typename OutIt>
+  void generate(OutIt begin, OutIt end) const {
+    for (OutIt it = begin; it != end; ++it) *it = 1u;
+  }
+};
+
+struct ConvertibleSeedSeq {
+  using result_type = uint32_t;
+  template <typename OutIt>
+  void generate(OutIt begin, OutIt end) const {
+    for (OutIt it = begin; it != end; ++it) *it = 1u;
+  }
+  operator uint64_t() const {
+    return 7u;
+  }  // NOLINT(google-explicit-constructor)
+};
+
+template <typename Engine>
+struct DerivedPCG : Engine {
+  using Engine::Engine;
+  void generate(uint32_t*, uint32_t*) const {}
+};
+
+using NonConstGenerateSeedSeq = TestSeedSeq<uint32_t, /*kConstGenerate=*/false>;
+using ConstGenerateSeedSeq = TestSeedSeq<uint32_t>;
+using SeedSeq64 = TestSeedSeq<uint64_t, /*kConstGenerate=*/false, 0xdeadbeefu>;
+using SeedSeq32 = TestSeedSeq<uint32_t, /*kConstGenerate=*/false, 0xdeadbeefu>;
+using SignedResultSeedSeq = TestSeedSeq<int32_t>;
+using NarrowResultSeedSeq = TestSeedSeq<uint16_t>;
+using BoolResultSeedSeq = TestSeedSeq<bool>;
+using ConstResultSeedSeq = TestSeedSeq<const uint32_t>;
+using RefResultSeedSeq = TestSeedSeq<uint32_t&>;
+using VoidResultSeedSeq = TestSeedSeq<void>;
+
+#ifdef ABSL_HAVE_EXCEPTIONS
+struct ThrowingPCGSeedSeq {
+  using result_type = uint32_t;
+  void generate(uint32_t* begin, uint32_t*) {
+    *begin = 0xdeadbeefu;
+    throw 9;
+  }
+};
+#endif
+
+TYPED_TEST(PCGEngineTest, SeedSequenceConstraintsAndConstSeeding) {
+  using engine_type = TypeParam;
+
+  const ConstGenerateSeedSeq const_seq;
+  engine_type engine(const_seq);
+  engine_type reseeded;
+  reseeded.seed(const_seq);
+  EXPECT_TRUE(engine == reseeded);
+
+  DerivedPCG<engine_type> derived(123u);
+  derived();
+  engine_type from_derived(derived);
+  EXPECT_TRUE(from_derived == static_cast<const engine_type&>(derived));
+
+  ConvertibleSeedSeq conv_seq;
+  EXPECT_TRUE(engine_type(conv_seq) == engine_type(7u));
+
+  static_assert(!std::is_constructible_v<engine_type, int*>);
+  static_assert(!std::is_constructible_v<engine_type, void*>);
+  static_assert(!HasSeedMethod<engine_type, int*>::value);
+  static_assert(!HasSeedMethod<engine_type, void*>::value);
+
+  static_assert(std::is_constructible_v<engine_type, std::seed_seq&>);
+  static_assert(std::is_constructible_v<engine_type, std::seed_seq&&>);
+  static_assert(HasSeedMethod<engine_type, std::seed_seq&>::value);
+  static_assert(HasSeedMethod<engine_type, std::seed_seq&&>::value);
+
+  // Test non-const generate() rejection with a dedicated type because MSVC STL
+  // marks std::seed_seq::generate() const while libc++/libstdc++ do not.
+  static_assert(std::is_constructible_v<engine_type, NonConstGenerateSeedSeq&>);
+  static_assert(
+      std::is_constructible_v<engine_type, NonConstGenerateSeedSeq&&>);
+  static_assert(
+      !std::is_constructible_v<engine_type, const NonConstGenerateSeedSeq&>);
+  static_assert(
+      !std::is_constructible_v<engine_type, const NonConstGenerateSeedSeq&&>);
+  static_assert(HasSeedMethod<engine_type, NonConstGenerateSeedSeq&>::value);
+  static_assert(
+      !HasSeedMethod<engine_type, const NonConstGenerateSeedSeq&>::value);
+
+  static_assert(
+      std::is_constructible_v<engine_type, const ConstGenerateSeedSeq&>);
+  static_assert(HasSeedMethod<engine_type, const ConstGenerateSeedSeq&>::value);
+
+  // Reject missing or invalid [rand.req.seedseq] result_type across ctor and
+  // seed().
+  static_assert(!std::is_constructible_v<engine_type, NoResultTypeSeedSeq&>);
+  static_assert(!HasSeedMethod<engine_type, NoResultTypeSeedSeq&>::value);
+  static_assert(!std::is_constructible_v<engine_type, SignedResultSeedSeq&>);
+  static_assert(!HasSeedMethod<engine_type, SignedResultSeedSeq&>::value);
+  static_assert(!std::is_constructible_v<engine_type, NarrowResultSeedSeq&>);
+  static_assert(!HasSeedMethod<engine_type, NarrowResultSeedSeq&>::value);
+  static_assert(!std::is_constructible_v<engine_type, BoolResultSeedSeq&>);
+  static_assert(!HasSeedMethod<engine_type, BoolResultSeedSeq&>::value);
+  static_assert(!std::is_constructible_v<engine_type, ConstResultSeedSeq&>);
+  static_assert(!HasSeedMethod<engine_type, ConstResultSeedSeq&>::value);
+  static_assert(!std::is_constructible_v<engine_type, RefResultSeedSeq&>);
+  static_assert(!HasSeedMethod<engine_type, RefResultSeedSeq&>::value);
+  static_assert(!std::is_constructible_v<engine_type, VoidResultSeedSeq&>);
+  static_assert(!HasSeedMethod<engine_type, VoidResultSeedSeq&>::value);
+
+#ifdef ABSL_HAVE_EXCEPTIONS
+  ThrowingPCGSeedSeq throwing_seq;
+  const engine_type snapshot = engine;
+  EXPECT_THROW(engine.seed(throwing_seq), int);
+  EXPECT_TRUE(engine == snapshot);
+#endif
+}
+
+TYPED_TEST(PCGEngineTest, SeedSequenceWith64BitResultTypeMatches32Bit) {
+  using engine_type = TypeParam;
+  SeedSeq64 seq64;
+  SeedSeq32 seq32;
+  engine_type e64(seq64);
+  engine_type e32(seq32);
+  EXPECT_TRUE(e64 == e32);
+  EXPECT_EQ(e64(), e32());
+
+  e64.seed(seq64);
+  e32.seed(seq32);
+  EXPECT_TRUE(e64 == e32);
+  EXPECT_EQ(e64(), e32());
+}
+
 // ------------------------------------------------------------------
 // Stability tests for pcg64_2018_engine
 // ------------------------------------------------------------------
diff --git a/absl/random/internal/randen_engine.h b/absl/random/internal/randen_engine.h
index 0f51462..d951166 100644
--- a/absl/random/internal/randen_engine.h
+++ b/absl/random/internal/randen_engine.h
@@ -17,6 +17,7 @@
 
 #include <algorithm>
 #include <cinttypes>
+#include <cstddef>
 #include <cstdint>
 #include <cstdlib>
 #include <cstring>
@@ -33,6 +34,7 @@
 #include "absl/meta/type_traits.h"
 #include "absl/random/internal/iostream_state_saver.h"
 #include "absl/random/internal/randen.h"
+#include "absl/random/internal/traits.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
@@ -49,6 +51,13 @@
 // generator, faster in some benchmarks than std::mt19937_64 and pcg64_c32.
 template <typename T>
 class alignas(8) randen_engine {
+  template <class SeedSequence>
+  using EnableIfSeedSeq = std::conjunction<
+      std::negation<
+          std::is_base_of<randen_engine, absl::remove_cvref_t<SeedSequence>>>,
+      std::negation<std::is_convertible<SeedSequence, T>>,
+      HasSeedSeqGenerate<SeedSequence>, HasSeedSeqSize<SeedSequence>>;
+
  public:
   // C++11 URBG interface:
   using result_type = T;
@@ -68,8 +77,7 @@
   explicit randen_engine(result_type seed_value) { seed(seed_value); }
 
   template <class SeedSequence,
-            typename = typename std::enable_if_t<
-                !std::is_same_v<SeedSequence, randen_engine>>>
+            typename = std::enable_if_t<EnableIfSeedSeq<SeedSequence>::value>>
   explicit randen_engine(SeedSequence&& seq) {
     seed(seq);
   }
@@ -100,12 +108,11 @@
     return little_endian::ToHost(begin[next_++]);
   }
 
-  template <class SeedSequence>
-  typename std::enable_if_t<!std::is_convertible_v<SeedSequence, result_type>>
-  seed(SeedSequence&& seq) {
-    // Zeroes the state.
-    seed();
-    reseed(seq);
+  template <class SeedSequence,
+            typename = std::enable_if_t<EnableIfSeedSeq<SeedSequence>::value>>
+  void seed(SeedSequence&& seq) {
+    // Zeroes the state and absorbs seed material.
+    AbsorbSeed</*kMixExistingState=*/false>(seq);
   }
 
   void seed(result_type seed_value = result_type{0}) {
@@ -121,57 +128,10 @@
   // Inserts entropy into (part of) the state. Calling this periodically with
   // sufficient entropy ensures prediction resistance (attackers cannot predict
   // future outputs even if state is compromised).
-  template <class SeedSequence>
+  template <class SeedSequence,
+            typename = std::enable_if_t<EnableIfSeedSeq<SeedSequence&>::value>>
   void reseed(SeedSequence& seq) {
-    using sequence_result_type = typename SeedSequence::result_type;
-    static_assert(sizeof(sequence_result_type) == 4,
-                  "SeedSequence::result_type must be 32-bit");
-    constexpr size_t kBufferSize =
-        Randen::kSeedBytes / sizeof(sequence_result_type);
-    alignas(16) sequence_result_type buffer[kBufferSize];
-
-    // Randen::Absorb XORs the seed into state, which is then mixed by a call
-    // to Randen::Generate. Seeding with only the provided entropy is preferred
-    // to using an arbitrary generate() call, so use [rand.req.seed_seq]
-    // size as a proxy for the number of entropy units that can be generated
-    // without relying on seed sequence mixing...
-    const size_t entropy_size = seq.size();
-    if (entropy_size < kBufferSize) {
-      // ... and only request that many values, or 256-bits, when unspecified.
-      const size_t requested_entropy = (entropy_size == 0) ? 8u : entropy_size;
-      std::fill(buffer + requested_entropy, buffer + kBufferSize, 0);
-      seq.generate(buffer, buffer + requested_entropy);
-      // The Randen paper suggests preferentially initializing even-numbered
-      // 128-bit vectors of the randen state (there are 16 such vectors).
-      // The seed data is merged into the state offset by 128-bits, which
-      // implies preferring seed bytes [16..31, ..., 208..223]. Since the
-      // buffer is 32-bit values, we swap the corresponding buffer positions in
-      // 128-bit chunks.
-      size_t dst = kBufferSize;
-      while (dst > 7) {
-        // leave the odd bucket as-is.
-        dst -= 4;
-        size_t src = dst >> 1;
-        // swap 128-bits into the even bucket
-        std::swap(buffer[--dst], buffer[--src]);
-        std::swap(buffer[--dst], buffer[--src]);
-        std::swap(buffer[--dst], buffer[--src]);
-        std::swap(buffer[--dst], buffer[--src]);
-      }
-    } else {
-      seq.generate(buffer, buffer + kBufferSize);
-    }
-#ifdef ABSL_IS_BIG_ENDIAN
-    // Randen expects the seed buffer to be in Little Endian; reverse it on
-    // Big Endian platforms.
-    for (sequence_result_type& e : buffer) {
-      e = absl::little_endian::FromHost(e);
-    }
-#endif
-    impl_.Absorb(buffer, state());
-
-    // Generate will be called when operator() is called
-    next_ = kStateSizeT;
+    AbsorbSeed</*kMixExistingState=*/true>(seq);
   }
 
   void discard(uint64_t count) {
@@ -226,6 +186,8 @@
     auto saver = random_internal::make_istream_state_saver(is);
     result_type state[kStateSizeT];
     for (auto& elem : state) {
+      // It is not possible to read uint8_t from a stream, so it is necessary to
+      // read a wider type and then cast it to uint8_t.
       result_type value = 0;
       if (!random_internal::read_integral(is, value)) {
         return is;
@@ -251,6 +213,126 @@
   static constexpr size_t kCapacityT =
       Randen::kCapacityBytes / sizeof(result_type);
 
+  static void XorLane128(unsigned char* dst, const uint32_t* src) noexcept {
+    for (size_t i = 0; i < 16; i += sizeof(uint64_t)) {
+      uint64_t s = 0;
+      uint64_t d = 0;
+      std::memcpy(&s, reinterpret_cast<const unsigned char*>(src) + i,
+                  sizeof(s));
+      std::memcpy(&d, dst + i, sizeof(d));
+      d ^= s;
+      std::memcpy(dst + i, &d, sizeof(d));
+    }
+  }
+
+  template <bool kMixExistingState>
+  void PrepareStateForSeed(result_type* begin) {
+    if constexpr (kMixExistingState) {
+      // Permute the existing sponge state before absorbing new seed material so
+      // repeated reseed(s) calls cannot XOR-cancel and mid-buffer reseeds do
+      // not XOR directly onto already-emitted rate words. Also fold a nonzero
+      // domain tag and the current byte offset into the inner capacity (which
+      // Absorb() leaves untouched) to separate reseed() from ordinary block
+      // refills and distinguish reseeds at different mid-buffer positions.
+      static_assert(Randen::kCapacityBytes >= 4,
+                    "Randen capacity must hold domain separator bytes");
+      const size_t byte_offset = next_ * sizeof(result_type);
+      impl_.Generate(begin);
+      auto* capacity = reinterpret_cast<unsigned char*>(begin);
+      capacity[0] ^= 0x01;
+      capacity[1] ^= static_cast<unsigned char>(byte_offset & 0xff);
+      capacity[2] ^= static_cast<unsigned char>((byte_offset >> 8) & 0xff);
+    } else {
+      seed();
+    }
+  }
+
+  template <bool kMixExistingState, class SeedSequence>
+  void AbsorbSeed(SeedSequence& seq) {
+    if constexpr (IsDirectEntropySeedSeq<
+                      absl::remove_cvref_t<SeedSequence>>::value) {
+      // Direct entropy sources (such as RandenPoolSeedSeq) yield full-entropy
+      // words without needing full-rate [rand.req.seedseq] mixing. Draw 8 words
+      // (256 bits) rather than all 60 rate words (which would drain an entire
+      // RandenPool refill per BitGen construction) and place them directly into
+      // two even-numbered 128-bit sponge lanes (state[2] and state[4]), leaving
+      // the remaining 52 rate words zeroed (on seed) or unperturbed (on
+      // reseed).
+      constexpr size_t kDirectEntropyWords = 8;
+      constexpr size_t kLane0Offset = Randen::kCapacityBytes + 16;
+      constexpr size_t kLane1Offset = Randen::kCapacityBytes + 48;
+      static_assert(kLane1Offset + 16 <= Randen::kStateBytes,
+                    "Randen state must contain even 128-bit lanes 2 and 4");
+      alignas(16) uint32_t entropy[kDirectEntropyWords];
+      seq.generate(entropy, entropy + kDirectEntropyWords);
+#ifdef ABSL_IS_BIG_ENDIAN
+      for (uint32_t& e : entropy) {
+        e = absl::little_endian::FromHost(e);
+      }
+#endif
+      auto* begin = state();
+      PrepareStateForSeed<kMixExistingState>(begin);
+      auto* state_bytes = reinterpret_cast<unsigned char*>(begin);
+      if constexpr (kMixExistingState) {
+        XorLane128(state_bytes + kLane0Offset, entropy);
+        XorLane128(state_bytes + kLane1Offset, entropy + 4);
+      } else {
+        std::memcpy(state_bytes + kLane0Offset, entropy, 16);
+        std::memcpy(state_bytes + kLane1Offset, entropy + 4, 16);
+      }
+      next_ = kStateSizeT;
+      return;
+    }
+
+    constexpr size_t kBufferSize = Randen::kSeedBytes / sizeof(uint32_t);
+    alignas(16) uint32_t buffer[kBufferSize];
+
+    // Randen::Absorb XORs the seed into state, which is then mixed by a call
+    // to Randen::Generate. Seeding with only the provided entropy is preferred
+    // to using an arbitrary generate() call, so use [rand.req.seed_seq]
+    // size as a proxy for the number of entropy units that can be generated
+    // without relying on seed sequence mixing...
+    const size_t entropy_size = seq.size();
+    if (entropy_size < kBufferSize) {
+      // ... and only request that many values, or 256-bits, when unspecified.
+      const size_t requested_entropy = (entropy_size == 0) ? 8u : entropy_size;
+      std::fill(buffer + requested_entropy, buffer + kBufferSize, 0);
+      seq.generate(buffer, buffer + requested_entropy);
+      // The Randen paper suggests preferentially initializing even-numbered
+      // 128-bit vectors of the randen state (there are 16 such vectors).
+      // The seed data is merged into the state offset by 128-bits, which
+      // implies preferring seed bytes [16..31, ..., 208..223]. Since the
+      // buffer is 32-bit values, we swap the corresponding buffer positions in
+      // 128-bit chunks.
+      size_t dst = kBufferSize;
+      while (dst > 7) {
+        // leave the odd bucket as-is.
+        dst -= 4;
+        size_t src = dst >> 1;
+        // swap 128-bits into the even bucket
+        std::swap(buffer[--dst], buffer[--src]);
+        std::swap(buffer[--dst], buffer[--src]);
+        std::swap(buffer[--dst], buffer[--src]);
+        std::swap(buffer[--dst], buffer[--src]);
+      }
+    } else {
+      seq.generate(buffer, buffer + kBufferSize);
+    }
+#ifdef ABSL_IS_BIG_ENDIAN
+    // Randen expects the seed buffer to be in Little Endian; reverse it on
+    // Big Endian platforms.
+    for (uint32_t& e : buffer) {
+      e = absl::little_endian::FromHost(e);
+    }
+#endif
+    auto* begin = state();
+    PrepareStateForSeed<kMixExistingState>(begin);
+    impl_.Absorb(buffer, begin);
+
+    // Generate will be called when operator() is called.
+    next_ = kStateSizeT;
+  }
+
   // Returns the state array pointer, which is aligned to 16 bytes.
   // The first kCapacityT are the `inner' sponge; the remainder are available.
   result_type* state() {
diff --git a/absl/random/internal/randen_engine_test.cc b/absl/random/internal/randen_engine_test.cc
index 3f58184..e961371 100644
--- a/absl/random/internal/randen_engine_test.cc
+++ b/absl/random/internal/randen_engine_test.cc
@@ -30,6 +30,7 @@
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
+#include "absl/base/config.h"
 #include "absl/log/log.h"
 #include "absl/random/internal/explicit_seed_seq.h"
 #include "absl/time/clock.h"
@@ -255,11 +256,30 @@
   engine = std::move(*self_ptr);
   EXPECT_TRUE(engine == expected);
 
+  randen assigned;
+  assigned = expected;
+  EXPECT_TRUE(assigned == expected);
+
   for (int i = 0; i < 16; ++i) {
     EXPECT_EQ(engine(), expected());
   }
 }
 
+TYPED_TEST(RandenEngineTypedTest, NonConstCopyConstruction) {
+  using E = absl::random_internal::randen_engine<TypeParam>;
+  ExplicitSeedSeq seed_sequence{12, 34, 56};
+  E v(seed_sequence);
+  v.discard(5);
+
+  E copy_paren(v);
+  E copy_brace{v};
+  EXPECT_TRUE(copy_paren == v);
+  EXPECT_TRUE(copy_brace == v);
+  const auto expected = v();
+  EXPECT_EQ(copy_paren(), expected);
+  EXPECT_EQ(copy_brace(), expected);
+}
+
 TYPED_TEST(RandenEngineTypedTest, RandenEngineSFINAETest) {
   using randen = typename absl::random_internal::randen_engine<TypeParam>;
   using result_type = typename randen::result_type;
@@ -457,6 +477,430 @@
               FailsLeavingUnchanged());
 }
 
+template <typename Engine, typename Arg, typename = void>
+struct HasSeedMethod : std::false_type {};
+
+template <typename Engine, typename Arg>
+struct HasSeedMethod<
+    Engine, Arg,
+    std::void_t<decltype(std::declval<Engine&>().seed(std::declval<Arg>()))>>
+    : std::true_type {};
+
+template <typename Engine, typename Arg, typename = void>
+struct HasReseedMethod : std::false_type {};
+
+template <typename Engine, typename Arg>
+struct HasReseedMethod<
+    Engine, Arg,
+    std::void_t<decltype(std::declval<Engine&>().reseed(std::declval<Arg>()))>>
+    : std::true_type {};
+
+struct NoResultTypeSeedSeq {
+  size_t size() const { return 4; }
+  template <typename OutIt>
+  void generate(OutIt begin, OutIt end) const {
+    for (OutIt it = begin; it != end; ++it) *it = 1u;
+  }
+};
+
+struct ConvertibleSeedSeq {
+  using result_type = uint32_t;
+  size_t size() const { return 4; }
+  template <typename OutIt>
+  void generate(OutIt begin, OutIt end) const {
+    for (OutIt it = begin; it != end; ++it) *it = 1u;
+  }
+  operator uint64_t() const {
+    return 7u;
+  }  // NOLINT(google-explicit-constructor)
+};
+
+template <typename Engine>
+struct DerivedRanden : Engine {
+  using Engine::Engine;
+  size_t size() const { return 4; }
+  void generate(uint32_t*, uint32_t*) const {}
+};
+
+template <typename ResultT, bool kConstGenerate = true, uint32_t kStart = 1,
+          bool kConstSize = true, bool kHasSize = true>
+struct TestSeedSeq {
+  using result_type = ResultT;
+  size_t count = 4;
+
+  explicit TestSeedSeq(size_t n = 4) : count(n) {}
+
+  template <bool H = kHasSize, bool C = kConstSize,
+            std::enable_if_t<H && C, int> = 0>
+  size_t size() const {
+    return count;
+  }
+  template <bool H = kHasSize, bool C = kConstSize,
+            std::enable_if_t<H && !C, int> = 0>
+  size_t size() {
+    return count;
+  }
+
+  template <typename OutIt, bool C = kConstGenerate,
+            std::enable_if_t<C, int> = 0>
+  void generate(OutIt begin, OutIt end) const {
+    uint32_t v = kStart;
+    for (OutIt it = begin; it != end; ++it) *it = v++;
+  }
+  template <typename OutIt, bool C = kConstGenerate,
+            std::enable_if_t<!C, int> = 0>
+  void generate(OutIt begin, OutIt end) {
+    uint32_t v = kStart;
+    for (OutIt it = begin; it != end; ++it) *it = v++;
+  }
+};
+
+using NonConstGenerateSeedSeq = TestSeedSeq<uint32_t, /*kConstGenerate=*/false>;
+using ConstGenerateSeedSeq = TestSeedSeq<uint32_t>;
+using ConstGenerateNonConstSizeSeedSeq =
+    TestSeedSeq<uint32_t, /*kConstGenerate=*/true, 1, /*kConstSize=*/false>;
+using NoSizeSeedSeq =
+    TestSeedSeq<uint32_t, /*kConstGenerate=*/true, 1, /*kConstSize=*/true,
+                /*kHasSize=*/false>;
+using SeedSeq64 = TestSeedSeq<uint64_t, /*kConstGenerate=*/false, 0xdeadbeefu>;
+using SeedSeq32 = TestSeedSeq<uint32_t, /*kConstGenerate=*/false, 0xdeadbeefu>;
+using SignedResultSeedSeq = TestSeedSeq<int32_t>;
+using NarrowResultSeedSeq = TestSeedSeq<uint16_t>;
+using BoolResultSeedSeq = TestSeedSeq<bool>;
+using ConstResultSeedSeq = TestSeedSeq<const uint32_t>;
+using RefResultSeedSeq = TestSeedSeq<uint32_t&>;
+using VoidResultSeedSeq = TestSeedSeq<void>;
+
+#ifdef ABSL_HAVE_EXCEPTIONS
+struct ThrowingRandenSeedSeq {
+  using result_type = uint32_t;
+  size_t size() const { return 8; }
+  void generate(uint32_t* begin, uint32_t*) {
+    *begin = 0x12345678u;
+    throw 42;
+  }
+};
+#endif
+
+struct FixedEightWordSeedSeqBase {
+  using result_type = uint32_t;
+  mutable size_t calls = 0;
+  mutable size_t last_words_requested = 0;
+  size_t size() const { return 0; }
+  template <typename OutIt>
+  void generate(OutIt begin, OutIt end) const {
+    static constexpr uint32_t kWords[8] = {
+        0x01234567u, 0x89abcdefu, 0xfedcba98u, 0x76543210u,
+        0x13579bdfu, 0x2468ace0u, 0xdeadbeefu, 0xcafebabeu,
+    };
+    ++calls;
+    last_words_requested = static_cast<size_t>(std::distance(begin, end));
+    size_t i = 0;
+    for (OutIt it = begin; it != end; ++it, ++i) {
+      *it = kWords[i % 8];
+    }
+  }
+};
+
+struct GeneralZeroSizeEightWordSeedSeq : FixedEightWordSeedSeqBase {};
+struct DirectEntropyEightWordSeedSeq : FixedEightWordSeedSeqBase {};
+
+#ifdef ABSL_HAVE_EXCEPTIONS
+struct DirectThrowingRandenSeedSeq {
+  using result_type = uint32_t;
+  size_t size() const { return 0; }
+  void generate(uint32_t* begin, uint32_t*) const {
+    *begin = 0xabcdef01u;
+    throw 77;
+  }
+};
+#endif
+
+}  // namespace
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+template <>
+struct IsDirectEntropySeedSeq<DirectEntropyEightWordSeedSeq> : std::true_type {
+};
+#ifdef ABSL_HAVE_EXCEPTIONS
+template <>
+struct IsDirectEntropySeedSeq<DirectThrowingRandenSeedSeq> : std::true_type {};
+#endif
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+namespace {
+
+TYPED_TEST(RandenEngineTypedTest, SeedSequenceConstraintsAndConstSeeding) {
+  using randen = typename absl::random_internal::randen_engine<TypeParam>;
+
+  {
+    const ConstGenerateSeedSeq const_seq;
+    ConstGenerateSeedSeq mutable_seq;
+    randen engine(const_seq);
+    randen seeded;
+    seeded.seed(const_seq);
+    EXPECT_TRUE(engine == seeded);
+
+    engine.reseed(const_seq);
+    seeded.reseed(mutable_seq);
+    EXPECT_TRUE(engine == seeded);
+  }
+
+  {
+    ConstGenerateNonConstSizeSeedSeq seq;
+    randen engine(seq);
+    randen seeded;
+    seeded.seed(seq);
+    EXPECT_TRUE(engine == seeded);
+
+    ConstGenerateNonConstSizeSeedSeq seq2;
+    engine.reseed(seq);
+    seeded.reseed(seq2);
+    EXPECT_TRUE(engine == seeded);
+  }
+
+  static_assert(!std::is_constructible_v<randen, int*>);
+  static_assert(!std::is_constructible_v<randen, void*>);
+  static_assert(!HasSeedMethod<randen, int*>::value);
+  static_assert(!HasSeedMethod<randen, void*>::value);
+  static_assert(!HasReseedMethod<randen, int&>::value);
+  static_assert(!HasReseedMethod<randen, TypeParam&>::value);
+  static_assert(!HasReseedMethod<randen, int*&>::value);
+  static_assert(!HasReseedMethod<randen, void*&>::value);
+  static_assert(!HasReseedMethod<randen, randen&>::value);
+  static_assert(!HasReseedMethod<randen, DerivedRanden<randen>&>::value);
+  static_assert(!HasReseedMethod<randen, ConvertibleSeedSeq&>::value);
+
+  static_assert(std::is_constructible_v<randen, DerivedRanden<randen>&>);
+  static_assert(std::is_constructible_v<randen, std::seed_seq&>);
+  static_assert(std::is_constructible_v<randen, std::seed_seq&&>);
+  static_assert(HasSeedMethod<randen, std::seed_seq&>::value);
+  static_assert(HasSeedMethod<randen, std::seed_seq&&>::value);
+  static_assert(HasReseedMethod<randen, std::seed_seq&>::value);
+  static_assert(HasReseedMethod<randen, SeedSeq64&>::value);
+
+  // Test non-const generate() rejection with a dedicated type because MSVC STL
+  // marks std::seed_seq::generate() const while libc++/libstdc++ do not.
+  static_assert(std::is_constructible_v<randen, NonConstGenerateSeedSeq&>);
+  static_assert(std::is_constructible_v<randen, NonConstGenerateSeedSeq&&>);
+  static_assert(
+      !std::is_constructible_v<randen, const NonConstGenerateSeedSeq&>);
+  static_assert(
+      !std::is_constructible_v<randen, const NonConstGenerateSeedSeq&&>);
+  static_assert(HasSeedMethod<randen, NonConstGenerateSeedSeq&>::value);
+  static_assert(!HasSeedMethod<randen, const NonConstGenerateSeedSeq&>::value);
+  static_assert(HasReseedMethod<randen, NonConstGenerateSeedSeq&>::value);
+  static_assert(
+      !HasReseedMethod<randen, const NonConstGenerateSeedSeq&>::value);
+
+  static_assert(std::is_constructible_v<randen, const ConstGenerateSeedSeq&>);
+  static_assert(HasSeedMethod<randen, const ConstGenerateSeedSeq&>::value);
+  static_assert(HasReseedMethod<randen, const ConstGenerateSeedSeq&>::value);
+
+  static_assert(
+      std::is_constructible_v<randen, ConstGenerateNonConstSizeSeedSeq&>);
+  static_assert(
+      std::is_constructible_v<randen, ConstGenerateNonConstSizeSeedSeq&&>);
+  static_assert(
+      !std::is_constructible_v<randen,
+                               const ConstGenerateNonConstSizeSeedSeq&>);
+  static_assert(
+      !std::is_constructible_v<randen,
+                               const ConstGenerateNonConstSizeSeedSeq&&>);
+  static_assert(
+      HasSeedMethod<randen, ConstGenerateNonConstSizeSeedSeq&>::value);
+  static_assert(
+      !HasSeedMethod<randen, const ConstGenerateNonConstSizeSeedSeq&>::value);
+  static_assert(
+      HasReseedMethod<randen, ConstGenerateNonConstSizeSeedSeq&>::value);
+  static_assert(
+      !HasReseedMethod<randen, const ConstGenerateNonConstSizeSeedSeq&>::value);
+
+  static_assert(!std::is_constructible_v<randen, NoSizeSeedSeq&>);
+  static_assert(!std::is_constructible_v<randen, const NoSizeSeedSeq&>);
+  static_assert(!HasSeedMethod<randen, NoSizeSeedSeq&>::value);
+  static_assert(!HasSeedMethod<randen, const NoSizeSeedSeq&>::value);
+  static_assert(!HasReseedMethod<randen, NoSizeSeedSeq&>::value);
+  static_assert(!HasReseedMethod<randen, const NoSizeSeedSeq&>::value);
+
+  // Reject missing or invalid [rand.req.seedseq] result_type across ctor,
+  // seed(), and reseed().
+  static_assert(!std::is_constructible_v<randen, NoResultTypeSeedSeq&>);
+  static_assert(!HasSeedMethod<randen, NoResultTypeSeedSeq&>::value);
+  static_assert(!HasReseedMethod<randen, NoResultTypeSeedSeq&>::value);
+  static_assert(!std::is_constructible_v<randen, SignedResultSeedSeq&>);
+  static_assert(!HasSeedMethod<randen, SignedResultSeedSeq&>::value);
+  static_assert(!HasReseedMethod<randen, SignedResultSeedSeq&>::value);
+  static_assert(!std::is_constructible_v<randen, NarrowResultSeedSeq&>);
+  static_assert(!HasSeedMethod<randen, NarrowResultSeedSeq&>::value);
+  static_assert(!HasReseedMethod<randen, NarrowResultSeedSeq&>::value);
+  static_assert(!std::is_constructible_v<randen, BoolResultSeedSeq&>);
+  static_assert(!HasSeedMethod<randen, BoolResultSeedSeq&>::value);
+  static_assert(!HasReseedMethod<randen, BoolResultSeedSeq&>::value);
+  static_assert(!std::is_constructible_v<randen, ConstResultSeedSeq&>);
+  static_assert(!HasSeedMethod<randen, ConstResultSeedSeq&>::value);
+  static_assert(!HasReseedMethod<randen, ConstResultSeedSeq&>::value);
+  static_assert(!std::is_constructible_v<randen, RefResultSeedSeq&>);
+  static_assert(!HasSeedMethod<randen, RefResultSeedSeq&>::value);
+  static_assert(!HasReseedMethod<randen, RefResultSeedSeq&>::value);
+  static_assert(!std::is_constructible_v<randen, VoidResultSeedSeq&>);
+  static_assert(!HasSeedMethod<randen, VoidResultSeedSeq&>::value);
+  static_assert(!HasReseedMethod<randen, VoidResultSeedSeq&>::value);
+}
+
+TYPED_TEST(RandenEngineTypedTest, ReseedDoesNotSelfCancelAndDomainSeparates) {
+  using randen = typename absl::random_internal::randen_engine<TypeParam>;
+  constexpr size_t kRateT = (256 - 16) / sizeof(TypeParam);
+
+  ExplicitSeedSeq seq{12, 34, 56, 78};
+
+  // seed(s) followed immediately by reseed(s) must not XOR-cancel back to the
+  // default-seeded engine or stay equal to seed(s).
+  randen default_engine;
+  randen seeded_only(seq);
+  randen seed_then_reseed(seq);
+  seed_then_reseed.reseed(seq);
+  EXPECT_TRUE(seed_then_reseed != default_engine);
+  EXPECT_TRUE(seed_then_reseed != seeded_only);
+
+  // Back-to-back reseed(s); reseed(s) after emitting outputs must not cancel
+  // back to the pre-reseed state or equal a single reseed(s).
+  randen base(seq);
+  base.discard(3);
+  randen once = base;
+  once.reseed(seq);
+  randen twice = base;
+  twice.reseed(seq);
+  twice.reseed(seq);
+  EXPECT_TRUE(twice != base);
+  EXPECT_TRUE(twice != once);
+
+  // Also cover the full-rate (entropy_size >= 60) path in AbsorbSeed.
+  SeedSeq32 large_seq(64);
+  randen large_once(large_seq);
+  large_once.reseed(large_seq);
+  EXPECT_TRUE(large_once != default_engine);
+  EXPECT_TRUE(large_once != randen(large_seq));
+
+  // Reseeding with an all-zero sequence must still diverge from simply
+  // advancing across a block boundary (domain separation in capacity).
+  ExplicitSeedSeq zero_seq;
+  randen advanced(seq);
+  randen zero_reseeded = advanced;
+  advanced.discard(kRateT);
+  zero_reseeded.reseed(zero_seq);
+  EXPECT_TRUE(zero_reseeded != advanced);
+
+  // Reseeding at distinct mid-buffer positions must yield distinct states.
+  randen mid_a(seq);
+  randen mid_b(seq);
+  mid_a.discard(1);
+  mid_b.discard(5);
+  ASSERT_TRUE(mid_a != mid_b);
+  mid_a.reseed(seq);
+  mid_b.reseed(seq);
+  EXPECT_TRUE(mid_a != mid_b);
+
+#ifdef ABSL_HAVE_EXCEPTIONS
+  ThrowingRandenSeedSeq throwing_seq;
+  DirectThrowingRandenSeedSeq direct_throwing_seq;
+  randen survivor(seq);
+  survivor.discard(2);
+  const randen snapshot = survivor;
+  EXPECT_THROW(survivor.seed(throwing_seq), int);
+  EXPECT_TRUE(survivor == snapshot);
+  EXPECT_THROW(survivor.reseed(throwing_seq), int);
+  EXPECT_TRUE(survivor == snapshot);
+  EXPECT_THROW(survivor.seed(direct_throwing_seq), int);
+  EXPECT_TRUE(survivor == snapshot);
+  EXPECT_THROW(survivor.reseed(direct_throwing_seq), int);
+  EXPECT_TRUE(survivor == snapshot);
+#endif
+}
+
+TYPED_TEST(RandenEngineTypedTest, DirectEntropySeedSeqDraws8WordsAndMatches) {
+  using randen = typename absl::random_internal::randen_engine<TypeParam>;
+
+  DirectEntropyEightWordSeedSeq direct_seq;
+  const DirectEntropyEightWordSeedSeq const_direct_seq;
+  GeneralZeroSizeEightWordSeedSeq general_seq;
+
+  randen from_direct(direct_seq);
+  EXPECT_EQ(direct_seq.calls, 1u);
+  EXPECT_EQ(direct_seq.last_words_requested, 8u);
+
+  randen from_const_direct(const_direct_seq);
+  EXPECT_EQ(const_direct_seq.calls, 1u);
+  EXPECT_EQ(const_direct_seq.last_words_requested, 8u);
+
+  randen from_general(general_seq);
+  EXPECT_EQ(general_seq.calls, 1u);
+  EXPECT_EQ(general_seq.last_words_requested, 8u);
+
+  EXPECT_TRUE(from_direct == from_general);
+  EXPECT_TRUE(from_const_direct == from_general);
+
+  // Advance mid-buffer and verify reseed() also draws 8 words into even lanes
+  // state[2] and state[4] with bit-identical state and stream.
+  from_direct.discard(3);
+  from_general.discard(3);
+  from_direct.reseed(direct_seq);
+  from_general.reseed(general_seq);
+  EXPECT_EQ(direct_seq.calls, 2u);
+  EXPECT_EQ(direct_seq.last_words_requested, 8u);
+  EXPECT_TRUE(from_direct == from_general);
+
+  for (int i = 0; i < 64; ++i) {
+    EXPECT_EQ(from_direct(), from_general());
+  }
+}
+
+TEST(RandenTest, ReseedPreservesCrossWidthByteStream) {
+  ExplicitSeedSeq init_seq{1, 2, 3, 4};
+  ExplicitSeedSeq reseed_seq{9, 8, 7, 6};
+
+  randen_u64 e64(init_seq);
+  randen_u32 e32(init_seq);
+  // Advance both by 16 bytes so their mid-buffer byte offsets match.
+  e64.discard(2);
+  e32.discard(4);
+  e64.reseed(reseed_seq);
+  e32.reseed(reseed_seq);
+
+  for (int i = 0; i < 40; ++i) {
+    const uint64_t v64 = e64();
+    const uint64_t lo = e32();
+    const uint64_t hi = e32();
+    EXPECT_EQ(v64, lo | (hi << 32)) << "i=" << i;
+  }
+}
+
+TYPED_TEST(RandenEngineTypedTest, SeedSequenceWith64BitResultTypeMatches32Bit) {
+  using randen = typename absl::random_internal::randen_engine<TypeParam>;
+  static_assert(std::is_constructible_v<randen, SeedSeq64&>,
+                "randen_engine must be constructible from SeedSeq64&");
+  static_assert(HasSeedMethod<randen, SeedSeq64&>::value,
+                "randen_engine::seed must accept SeedSeq64&");
+
+  for (size_t seed_size : {size_t{4}, size_t{64}}) {
+    SeedSeq64 seq64(seed_size);
+    SeedSeq32 seq32(seed_size);
+    randen e64(seq64);
+    randen e32(seq32);
+    EXPECT_TRUE(e64 == e32);
+    EXPECT_EQ(e64(), e32());
+
+    e64.seed(seq64);
+    e32.seed(seq32);
+    EXPECT_TRUE(e64 == e32);
+    EXPECT_EQ(e64(), e32());
+  }
+}
+
 TEST(RandenTest, VerifyGoldenRanden64Default) {
   constexpr uint64_t kGolden[kNumGoldenOutputs] = {
       0xc3c14f134e433977, 0xdda9f47cd90410ee, 0x887bf3087fd8ca10,
diff --git a/absl/random/internal/salted_seed_seq.h b/absl/random/internal/salted_seed_seq.h
index 858a90f..ea77684 100644
--- a/absl/random/internal/salted_seed_seq.h
+++ b/absl/random/internal/salted_seed_seq.h
@@ -15,6 +15,8 @@
 #ifndef ABSL_RANDOM_INTERNAL_SALTED_SEED_SEQ_H_
 #define ABSL_RANDOM_INTERNAL_SALTED_SEED_SEQ_H_
 
+#include <algorithm>
+#include <cstddef>
 #include <cstdint>
 #include <cstdlib>
 #include <initializer_list>
@@ -29,6 +31,7 @@
 #include "absl/container/inlined_vector.h"
 #include "absl/meta/type_traits.h"
 #include "absl/random/internal/seed_material.h"
+#include "absl/random/internal/traits.h"
 #include "absl/types/optional.h"
 #include "absl/types/span.h"
 
@@ -36,6 +39,20 @@
 ABSL_NAMESPACE_BEGIN
 namespace random_internal {
 
+template <typename Iterator, bool IsPointer = std::is_pointer_v<Iterator>,
+          typename = void>
+struct IsIntegralIterator : std::false_type {};
+
+template <typename Iterator>
+struct IsIntegralIterator<Iterator, true, void>
+    : std::is_integral<std::remove_pointer_t<Iterator>> {};
+
+template <typename Iterator>
+struct IsIntegralIterator<
+    Iterator, false,
+    std::void_t<typename std::iterator_traits<Iterator>::value_type>>
+    : std::is_integral<typename std::iterator_traits<Iterator>::value_type> {};
+
 // This class conforms to the C++ Standard "Seed Sequence" concept
 // [rand.req.seedseq].
 //
@@ -46,19 +63,41 @@
 // not modified.
 template <typename SSeq>
 class SaltedSeedSeq {
+  static_assert(!std::is_rvalue_reference_v<SSeq>,
+                "SaltedSeedSeq cannot be instantiated with an rvalue "
+                "reference; use an owning type or an lvalue reference.");
+  using raw_sequence_type = std::remove_reference_t<SSeq>;
+
  public:
   using inner_sequence_type = SSeq;
-  using result_type = typename SSeq::result_type;
+  using result_type = typename raw_sequence_type::result_type;
 
-  SaltedSeedSeq() : seq_(std::make_unique<SSeq>()) {}
+  template <typename U = SSeq,
+            typename = std::enable_if_t<std::conjunction_v<
+                std::negation<std::is_reference<U>>,
+                std::is_default_constructible<std::remove_reference_t<U>>>>>
+  SaltedSeedSeq() : seq_(std::make_unique<raw_sequence_type>()) {}
 
-  template <typename Iterator>
+  template <
+      typename Iterator, typename U = SSeq,
+      typename = std::enable_if_t<std::conjunction_v<
+          std::negation<std::is_reference<U>>, IsIntegralIterator<Iterator>,
+          std::is_constructible<std::remove_reference_t<U>, Iterator,
+                                Iterator>>>>
   SaltedSeedSeq(Iterator begin, Iterator end)
-      : seq_(std::make_unique<SSeq>(begin, end)) {}
+      : seq_(std::make_unique<raw_sequence_type>(begin, end)) {}
 
-  template <typename T>
+  template <typename T, typename U = SSeq,
+            typename = std::enable_if_t<std::conjunction_v<
+                std::negation<std::is_reference<U>>, std::is_integral<T>,
+                std::is_constructible<std::remove_reference_t<U>,
+                                      std::initializer_list<T>>>>>
   SaltedSeedSeq(std::initializer_list<T> il)
-      : SaltedSeedSeq(il.begin(), il.end()) {}
+      : seq_(std::make_unique<raw_sequence_type>(il)) {}
+
+  template <typename U = SSeq,
+            typename = std::enable_if_t<std::is_lvalue_reference_v<U>>>
+  explicit SaltedSeedSeq(raw_sequence_type& seq) : seq_(&seq) {}
 
   SaltedSeedSeq(const SaltedSeedSeq&) = delete;
   SaltedSeedSeq& operator=(const SaltedSeedSeq&) = delete;
@@ -66,45 +105,82 @@
   SaltedSeedSeq(SaltedSeedSeq&&) = default;
   SaltedSeedSeq& operator=(SaltedSeedSeq&&) = default;
 
-  template <typename RandomAccessIterator>
+  template <typename RandomAccessIterator, typename U = raw_sequence_type,
+            typename = std::void_t<decltype(std::declval<U&>().generate(
+                std::declval<uint32_t*>(), std::declval<uint32_t*>()))>>
   void generate(RandomAccessIterator begin, RandomAccessIterator end) {
-    using U = typename std::iterator_traits<RandomAccessIterator>::value_type;
+    using V = typename std::iterator_traits<RandomAccessIterator>::value_type;
+    using Ref = typename std::iterator_traits<RandomAccessIterator>::reference;
 
     // The common case is that generate is called with ContiguousIterators
-    // to uint arrays. Such contiguous memory regions may be optimized,
+    // to uint32_t arrays. Such contiguous memory regions may be optimized,
     // which we detect here.
     using TagType = std::conditional_t<
-        (std::is_same_v<U, uint32_t> &&
+        (std::is_same_v<V, uint32_t> && std::is_same_v<Ref, uint32_t&> &&
          (std::is_pointer_v<RandomAccessIterator> ||
           std::is_same_v<RandomAccessIterator,
-                         typename std::vector<U>::iterator>)),
+                         typename std::vector<uint32_t>::iterator>)),
         ContiguousAndUint32Tag, DefaultTag>;
     if (begin != end) {
-      generate_impl(TagType{}, begin, end, std::distance(begin, end));
+      generate_impl(TagType{}, begin, end,
+                    static_cast<size_t>(std::distance(begin, end)));
     }
   }
 
-  template <typename OutIterator>
+  template <typename OutIterator, typename U = raw_sequence_type,
+            typename = std::void_t<decltype(std::declval<U&>().param(
+                std::declval<OutIterator>()))>>
   void param(OutIterator out) const {
     seq_->param(out);
   }
 
-  size_t size() const { return seq_->size(); }
+  template <typename U = raw_sequence_type,
+            typename = std::enable_if_t<std::is_convertible_v<
+                decltype(std::declval<U&>().size()), size_t>>>
+  size_t size() const {
+    return seq_->size();
+  }
 
  private:
   struct ContiguousAndUint32Tag {};
   struct DefaultTag {};
 
   // Generate which requires the iterators are contiguous pointers to uint32_t.
-  // Fills the initial seed buffer the underlying SSeq::generate() call,
-  // then mixes in the salt material.
+  // Fills the initial seed buffer from the underlying SSeq::generate() call,
+  // then mixes in the salt material if available. When `n < min(60, 2 * s)`,
+  // expands `generate()` to `min(60, 2 * s)` words first (satisfying
+  // `s <= m - p(m)` for all `1 <= s <= 33` so narrow requests such as `n = 2`
+  // or `n = 4` do not suffer `[rand.util.seedseq]` truncation collisions) and
+  // folds both the salt and the excess words into the `n`-word output.
   template <typename Contiguous>
   void generate_impl(ContiguousAndUint32Tag, Contiguous begin, Contiguous end,
                      size_t n) {
+    const auto salt = absl::random_internal::GetSaltMaterial();
+    if (!salt.has_value()) {
+      seq_->generate(begin, end);
+      return;
+    }
+    constexpr size_t kMaxExpanded = 60;
+    auto out = absl::Span<uint32_t>(&*begin, n);
+    if (n < kMaxExpanded) {
+      size_t s = 0;
+      if constexpr (HasSeedSeqSize<raw_sequence_type>::value) {
+        s = seq_->size();
+      }
+      const size_t target = (s >= kMaxExpanded / 2) ? kMaxExpanded : (2 * s);
+      if (n < target) {
+        uint32_t expanded[kMaxExpanded];
+        std::fill_n(expanded, target, uint32_t{0});
+        seq_->generate(expanded, expanded + target);
+        std::copy_n(expanded, n, out.data());
+        expanded[n - 1] = *salt;
+        MixIntoSeedMaterial(
+            absl::MakeConstSpan(expanded + (n - 1), target - n + 1), out);
+        return;
+      }
+    }
     seq_->generate(begin, end);
-    const uint32_t salt = absl::random_internal::GetSaltMaterial().value_or(0);
-    auto span = absl::Span<uint32_t>(&*begin, n);
-    MixIntoSeedMaterial(absl::MakeConstSpan(&salt, 1), span);
+    MixIntoSeedMaterial(absl::MakeConstSpan(&*salt, 1), out);
   }
 
   // The uncommon case for generate is that it is called with iterators over
@@ -122,42 +198,66 @@
   }
 
   // Because [rand.req.seedseq] is not required to be copy-constructible,
-  // copy-assignable nor movable, we wrap it with unique pointer to be able
-  // to move SaltedSeedSeq.
-  std::unique_ptr<SSeq> seq_;
+  // copy-assignable nor movable, owning instances wrap it with unique_ptr to be
+  // movable, while SaltedSeedSeq<SSeq&> holds a non-owning pointer.
+  std::conditional_t<std::is_lvalue_reference_v<SSeq>, raw_sequence_type*,
+                     std::unique_ptr<raw_sequence_type>>
+      seq_;
 };
 
-// is_salted_seed_seq indicates whether the type is a SaltedSeedSeq.
+// is_salted_seed_seq indicates whether the type (ignoring cvref) is a
+// SaltedSeedSeq.
 template <typename T, typename = void>
 struct is_salted_seed_seq : public std::false_type {};
 
 template <typename T>
 struct is_salted_seed_seq<
-    T, std::enable_if_t<
-           std::is_same_v<T, SaltedSeedSeq<typename T::inner_sequence_type>>>>
+    T,
+    std::enable_if_t<std::is_same_v<
+        absl::remove_cvref_t<T>,
+        SaltedSeedSeq<typename absl::remove_cvref_t<T>::inner_sequence_type>>>>
     : public std::true_type {};
 
+// UnwrappedSeedSeq unwraps `SaltedSeedSeq<Inner>` to
+// `absl::remove_cvref_t<Inner>`, or decays any other seed sequence type via
+// `absl::remove_cvref_t`.
+template <typename SSeq, bool = is_salted_seed_seq<SSeq>::value>
+struct UnwrappedSeedSeq {
+  using type = absl::remove_cvref_t<SSeq>;
+};
+
+template <typename SSeq>
+struct UnwrappedSeedSeq<SSeq, true> {
+  using type = absl::remove_cvref_t<
+      typename absl::remove_cvref_t<SSeq>::inner_sequence_type>;
+};
+
+template <typename SSeq>
+struct is_movable_owning_salted_seed_seq : std::false_type {};
+
+template <typename Inner>
+struct is_movable_owning_salted_seed_seq<SaltedSeedSeq<Inner>>
+    : std::negation<std::is_reference<Inner>> {};
+
 // MakeSaltedSeedSeq returns a salted variant of the seed sequence.
-// When provided with an existing SaltedSeedSeq, returns the input parameter,
+// When provided with an existing SaltedSeedSeq, preserves single salting,
 // otherwise constructs a new SaltedSeedSeq which embodies the original
 // non-salted seed parameters.
-template <
-    typename SSeq,  //
-    typename EnableIf = std::enable_if_t<is_salted_seed_seq<SSeq>::value>>
-SSeq MakeSaltedSeedSeq(SSeq&& seq) {
-  return SSeq(std::forward<SSeq>(seq));
-}
+template <typename SSeq>
+auto MakeSaltedSeedSeq(SSeq&& seq) {
+  if constexpr (is_movable_owning_salted_seed_seq<SSeq>::value) {
+    return SSeq(std::forward<SSeq>(seq));
+  } else {
+    using target_type = typename UnwrappedSeedSeq<SSeq>::type;
+    using result_type = typename target_type::result_type;
 
-template <
-    typename SSeq,  //
-    typename EnableIf = std::enable_if_t<!is_salted_seed_seq<SSeq>::value>>
-SaltedSeedSeq<std::decay_t<SSeq>> MakeSaltedSeedSeq(SSeq&& seq) {
-  using sseq_type = std::decay_t<SSeq>;
-  using result_type = typename sseq_type::result_type;
-
-  absl::InlinedVector<result_type, 8> data;
-  seq.param(std::back_inserter(data));
-  return SaltedSeedSeq<sseq_type>(data.begin(), data.end());
+    absl::InlinedVector<result_type, 8> data;
+    if constexpr (HasSeedSeqSize<SSeq>::value) {
+      data.reserve(seq.size());
+    }
+    seq.param(std::back_inserter(data));
+    return SaltedSeedSeq<target_type>(data.begin(), data.end());
+  }
 }
 
 }  // namespace random_internal
diff --git a/absl/random/internal/salted_seed_seq_test.cc b/absl/random/internal/salted_seed_seq_test.cc
index 3e8dfeb..d64f757 100644
--- a/absl/random/internal/salted_seed_seq_test.cc
+++ b/absl/random/internal/salted_seed_seq_test.cc
@@ -16,8 +16,11 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <initializer_list>
 #include <iterator>
+#include <optional>
 #include <random>
+#include <type_traits>
 #include <utility>
 #include <vector>
 
@@ -103,7 +106,7 @@
   uint32_t a[16];
   salted_seq.generate(std::begin(a), std::end(a));
 
-  // The second salting.
+  // The second salting (rvalue).
   SaltedSeedSeq<std::seed_seq> salted_salted_seq =
       MakeSaltedSeedSeq(std::move(salted_seq));
   uint32_t b[16];
@@ -111,6 +114,129 @@
 
   // ... both should be equal.
   EXPECT_THAT(b, Pointwise(Eq(), a)) << "a[0] " << a[0];
+
+  // Lvalue SaltedSeedSeq must also not be double-salted.
+  auto lvalue_salted_seq = MakeSaltedSeedSeq(salted_salted_seq);
+  uint32_t c[16];
+  lvalue_salted_seq.generate(std::begin(c), std::end(c));
+  EXPECT_THAT(c, Pointwise(Eq(), a));
+
+  // Const lvalue and const rvalue SaltedSeedSeq must also not be double-salted.
+  const SaltedSeedSeq<std::seed_seq> const_salted_seq(std::begin(init),
+                                                      std::end(init));
+  auto from_const_lvalue = MakeSaltedSeedSeq(const_salted_seq);
+  uint32_t e[16];
+  from_const_lvalue.generate(std::begin(e), std::end(e));
+  EXPECT_THAT(e, Pointwise(Eq(), a));
+
+  auto from_const_rvalue = MakeSaltedSeedSeq(std::move(const_salted_seq));
+  uint32_t f[16];
+  from_const_rvalue.generate(std::begin(f), std::end(f));
+  EXPECT_THAT(f, Pointwise(Eq(), a));
+}
+
+TEST(SaltedSeedSeq, BraceMoveInvokesMoveConstructor) {
+  SaltedSeedSeq<std::seed_seq> expected_seq{1, 3, 5, 7, 9};
+  uint32_t expected[16];
+  expected_seq.generate(std::begin(expected), std::end(expected));
+
+  SaltedSeedSeq<std::seed_seq> source{1, 3, 5, 7, 9};
+  SaltedSeedSeq<std::seed_seq> brace_moved{std::move(source)};
+  uint32_t actual[16];
+  brace_moved.generate(std::begin(actual), std::end(actual));
+  EXPECT_THAT(actual, Pointwise(Eq(), expected));
+}
+
+TEST(SaltedSeedSeq, MakeSaltedSeedSeqReturnsOwningFromNonOwningRef) {
+  uint32_t init[] = {1, 3, 5, 7, 9};
+  SaltedSeedSeq<std::seed_seq> expected_seq(std::begin(init), std::end(init));
+  uint32_t expected[16];
+  expected_seq.generate(std::begin(expected), std::end(expected));
+
+  std::optional<SaltedSeedSeq<std::seed_seq>> owned_from_mutable;
+  std::optional<SaltedSeedSeq<std::seed_seq>> owned_from_const;
+  {
+    std::seed_seq raw(std::begin(init), std::end(init));
+    auto made_mutable = MakeSaltedSeedSeq(SaltedSeedSeq<std::seed_seq&>(raw));
+    static_assert(
+        std::is_same_v<decltype(made_mutable), SaltedSeedSeq<std::seed_seq>>);
+    owned_from_mutable.emplace(std::move(made_mutable));
+
+    const std::seed_seq const_raw(std::begin(init), std::end(init));
+    auto made_const =
+        MakeSaltedSeedSeq(SaltedSeedSeq<const std::seed_seq&>(const_raw));
+    static_assert(
+        std::is_same_v<decltype(made_const), SaltedSeedSeq<std::seed_seq>>);
+    owned_from_const.emplace(std::move(made_const));
+  }
+
+  uint32_t from_mutable[16];
+  owned_from_mutable->generate(std::begin(from_mutable),
+                               std::end(from_mutable));
+  EXPECT_THAT(from_mutable, Pointwise(Eq(), expected));
+
+  uint32_t from_const[16];
+  owned_from_const->generate(std::begin(from_const), std::end(from_const));
+  EXPECT_THAT(from_const, Pointwise(Eq(), expected));
+}
+
+TEST(SaltedSeedSeq, ConstructorConstraints) {
+  static_assert(std::is_constructible_v<SaltedSeedSeq<std::seed_seq>,
+                                        std::initializer_list<int>>);
+  static_assert(std::is_constructible_v<SaltedSeedSeq<std::seed_seq>,
+                                        std::initializer_list<uint32_t>>);
+  static_assert(std::is_constructible_v<SaltedSeedSeq<std::seed_seq>,
+                                        std::initializer_list<uint64_t>>);
+  static_assert(!std::is_constructible_v<SaltedSeedSeq<std::seed_seq>,
+                                         std::initializer_list<double>>);
+  static_assert(!std::is_constructible_v<SaltedSeedSeq<std::seed_seq>,
+                                         std::initializer_list<const char*>>);
+  static_assert(std::is_constructible_v<SaltedSeedSeq<std::seed_seq>, uint32_t*,
+                                        uint32_t*>);
+  static_assert(
+      !std::is_constructible_v<SaltedSeedSeq<std::seed_seq>, double*, double*>);
+  static_assert(
+      !std::is_constructible_v<SaltedSeedSeq<std::seed_seq>, double, double>);
+  static_assert(
+      !std::is_constructible_v<SaltedSeedSeq<std::seed_seq>, void*, void*>);
+
+  static_assert(
+      !std::is_default_constructible_v<SaltedSeedSeq<std::seed_seq&>>);
+  static_assert(!std::is_constructible_v<SaltedSeedSeq<std::seed_seq&>,
+                                         std::initializer_list<uint32_t>>);
+  static_assert(!std::is_constructible_v<SaltedSeedSeq<std::seed_seq&>,
+                                         uint32_t*, uint32_t*>);
+  static_assert(
+      std::is_constructible_v<SaltedSeedSeq<std::seed_seq&>, std::seed_seq&>);
+
+  // Note: SaltedSeedSeq<T&&> is rejected by a class-scope static_assert.
+  static_assert(absl::random_internal::is_movable_owning_salted_seed_seq<
+                SaltedSeedSeq<std::seed_seq>>::value);
+  static_assert(!absl::random_internal::is_movable_owning_salted_seed_seq<
+                SaltedSeedSeq<std::seed_seq&>>::value);
+  static_assert(!absl::random_internal::is_movable_owning_salted_seed_seq<
+                const SaltedSeedSeq<std::seed_seq>>::value);
+
+  // Also cover >8 elements in MakeSaltedSeedSeq (out-of-line InlinedVector).
+  std::vector<uint32_t> large_init(20);
+  for (size_t i = 0; i < large_init.size(); ++i) {
+    large_init[i] = static_cast<uint32_t>(i * 3 + 1);
+  }
+  const std::seed_seq large_const(large_init.begin(), large_init.end());
+  SaltedSeedSeq<std::seed_seq> large_direct(large_init.begin(),
+                                            large_init.end());
+  auto large_made = MakeSaltedSeedSeq(large_const);
+  uint32_t expected_large[16];
+  uint32_t actual_large[16];
+  large_direct.generate(std::begin(expected_large), std::end(expected_large));
+  large_made.generate(std::begin(actual_large), std::end(actual_large));
+  EXPECT_THAT(actual_large, Pointwise(Eq(), expected_large));
+
+  SaltedSeedSeq<std::seed_seq> from_u32{1u, 2u, 3u};
+  EXPECT_EQ(from_u32.size(), 3u);
+
+  SaltedSeedSeq<std::seed_seq> from_u64{uint64_t{1}, uint64_t{2}};
+  EXPECT_EQ(from_u64.size(), 2u);
 }
 
 TEST(SaltedSeedSeq, SeedMaterialIsSalted) {
@@ -171,6 +297,144 @@
     seq.generate(std::begin(seed_material), std::end(seed_material));
     EXPECT_THAT(seed_material, Pointwise(Eq(), expected));
   }
+
+  // Volatile uint32_t outputs (routes through DefaultTag rather than Span).
+  {
+    volatile uint32_t seed_material[kNumBlocks] = {};
+    seq.generate(std::begin(seed_material), std::end(seed_material));
+    for (size_t i = 0; i < kNumBlocks; ++i) {
+      EXPECT_EQ(seed_material[i], expected[i]);
+    }
+  }
+
+  // Out-of-line (>8) DefaultTag buffer path.
+  {
+    constexpr size_t kLargeBlocks = 12;
+    uint32_t expected_large[kLargeBlocks];
+    uint64_t actual_large[kLargeBlocks];
+    seq.generate(std::begin(expected_large), std::end(expected_large));
+    seq.generate(std::begin(actual_large), std::end(actual_large));
+    EXPECT_THAT(actual_large, Pointwise(Eq(), expected_large));
+  }
+}
+
+struct CountingSeedSeq {
+  using result_type = uint32_t;
+  size_t reported_size = 0;
+  size_t calls = 0;
+  size_t last_requested = 0;
+
+  explicit CountingSeedSeq(size_t s) : reported_size(s) {}
+  size_t size() const { return reported_size; }
+  template <typename OutIt>
+  void generate(OutIt begin, OutIt end) {
+    ++calls;
+    last_requested = static_cast<size_t>(std::distance(begin, end));
+    uint32_t v = 1;
+    for (OutIt it = begin; it != end; ++it) {
+      *it = v++;
+    }
+  }
+};
+
+template <size_t S, size_t N>
+void VerifyTruncatedCollisionSeparated(const uint32_t (&seed_a)[S],
+                                       const uint32_t (&seed_b)[S]) {
+  std::seed_seq raw_a(std::begin(seed_a), std::end(seed_a));
+  std::seed_seq raw_b(std::begin(seed_b), std::end(seed_b));
+  uint32_t raw_out_a[N] = {};
+  uint32_t raw_out_b[N] = {};
+  raw_a.generate(std::begin(raw_out_a), std::end(raw_out_a));
+  raw_b.generate(std::begin(raw_out_b), std::end(raw_out_b));
+  // Precondition: raw std::seed_seq genuinely collides at width N.
+  ASSERT_THAT(raw_out_a, Pointwise(Eq(), raw_out_b));
+
+  SaltedSeedSeq<std::seed_seq> salted_a(std::begin(seed_a), std::end(seed_a));
+  SaltedSeedSeq<std::seed_seq> salted_b(std::begin(seed_b), std::end(seed_b));
+
+  // size() and param() remain unsalted per [rand.req.seedseq].
+  EXPECT_EQ(salted_a.size(), S);
+  EXPECT_EQ(salted_b.size(), S);
+  std::vector<uint32_t> params_a;
+  salted_a.param(std::back_inserter(params_a));
+  EXPECT_THAT(params_a, Pointwise(Eq(), seed_a));
+
+  if (GetSaltMaterial().has_value()) {
+    uint32_t salted_out_a[N] = {};
+    uint32_t salted_out_b[N] = {};
+    salted_a.generate(std::begin(salted_out_a), std::end(salted_out_a));
+    salted_b.generate(std::begin(salted_out_b), std::end(salted_out_b));
+    EXPECT_THAT(salted_out_a, testing::Not(Pointwise(Eq(), salted_out_b)));
+  }
+}
+
+TEST(SaltedSeedSeq, EliminatesKnownStdSeedSeqTruncationCollisions) {
+  // Exact [rand.util.seedseq] collision pairs where two distinct s-word seeds
+  // yield bit-for-bit identical n-word std::seed_seq::generate() outputs.
+  constexpr uint32_t kS2A[2] = {0x00000003u, 0xef243a0au};
+  constexpr uint32_t kS2B[2] = {0x0b8bb54eu, 0xfaafef55u};
+  VerifyTruncatedCollisionSeparated<2, 2>(kS2A, kS2B);
+
+  constexpr uint32_t kS3A[3] = {0x0000269du, 0x4cc2d2d4u, 0x507fd03cu};
+  constexpr uint32_t kS3B[3] = {0x00033c9bu, 0xa08a4e6cu, 0x5082e63au};
+  VerifyTruncatedCollisionSeparated<3, 3>(kS3A, kS3B);
+
+  constexpr uint32_t kS4A[4] = {0x00010253u, 0x4c1127d0u, 0xc406ad4cu,
+                                0x13a2704du};
+  constexpr uint32_t kS4B[4] = {0x000135d7u, 0xc89ecda0u, 0x24996d88u,
+                                0x13a2a3d1u};
+  VerifyTruncatedCollisionSeparated<4, 4>(kS4A, kS4B);
+
+  constexpr uint32_t kS8N8A[8] = {0x7496df94u, 0x2f701878u, 0xf374430bu,
+                                  0x33e4d291u, 0x8e5b51a3u, 0x0f511665u,
+                                  0xd44a6ec8u, 0xbb00fd0au};
+  constexpr uint32_t kS8N8B[8] = {0x64e949bau, 0x47fb3261u, 0xdeaae914u,
+                                  0xfdd32ba0u, 0xa4d1fd8du, 0x357706e1u,
+                                  0xc49cd8eeu, 0xbb01dbdfu};
+  VerifyTruncatedCollisionSeparated<8, 8>(kS8N8A, kS8N8B);
+
+  constexpr uint32_t kS8N4A[8] = {0x00000001u, 0x00000002u, 0x00000003u,
+                                  0x00000004u, 0x0000bf91u, 0x67c0a593u,
+                                  0x313389e7u, 0xee5c8e5cu};
+  constexpr uint32_t kS8N4B[8] = {0x00000001u, 0x00000002u, 0x00000003u,
+                                  0x00000004u, 0x00011835u, 0xa5168553u,
+                                  0xcee80a7au, 0xee5ce700u};
+  VerifyTruncatedCollisionSeparated<8, 4>(kS8N4A, kS8N4B);
+}
+
+TEST(SaltedSeedSeq, ExpansionRespectsZeroSizeAndCapsAt60Words) {
+  uint32_t out4[4] = {};
+
+  // Zero-size sequences (e.g. stateful entropy seeders) must never over-pull.
+  CountingSeedSeq zero_seq(0);
+  SaltedSeedSeq<CountingSeedSeq&> salted_zero(zero_seq);
+  salted_zero.generate(std::begin(out4), std::end(out4));
+  EXPECT_EQ(zero_seq.calls, 1u);
+  EXPECT_EQ(zero_seq.last_requested, 4u);
+
+  if (GetSaltMaterial().has_value()) {
+    // s = 4, n = 4 expands to 2 * s = 8.
+    CountingSeedSeq seq4(4);
+    SaltedSeedSeq<CountingSeedSeq&> salted4(seq4);
+    salted4.generate(std::begin(out4), std::end(out4));
+    EXPECT_EQ(seq4.last_requested, 8u);
+
+    // s >= 30 caps expansion at 60 without overflow even at SIZE_MAX.
+    CountingSeedSeq seq40(40);
+    SaltedSeedSeq<CountingSeedSeq&> salted40(seq40);
+    salted40.generate(std::begin(out4), std::end(out4));
+    EXPECT_EQ(seq40.last_requested, 60u);
+
+    CountingSeedSeq seq_max(static_cast<size_t>(-1));
+    SaltedSeedSeq<CountingSeedSeq&> salted_max(seq_max);
+    salted_max.generate(std::begin(out4), std::end(out4));
+    EXPECT_EQ(seq_max.last_requested, 60u);
+
+    // Requests already >= min(60, 2 * s) do not expand further.
+    uint32_t out8[8] = {};
+    salted4.generate(std::begin(out8), std::end(out8));
+    EXPECT_EQ(seq4.last_requested, 8u);
+  }
 }
 
 }  // namespace
diff --git a/absl/random/internal/traits.h b/absl/random/internal/traits.h
index 8404d93..d57718b 100644
--- a/absl/random/internal/traits.h
+++ b/absl/random/internal/traits.h
@@ -19,6 +19,7 @@
 #include <cstdint>
 #include <limits>
 #include <type_traits>
+#include <utility>
 
 #include "absl/base/config.h"
 #include "absl/meta/type_traits.h"
@@ -162,6 +163,52 @@
   }
 }
 
+// Detects whether `T` is a valid `[rand.req.seedseq]` `result_type`
+// (an unqualified unsigned integer type of at least 32 bits).
+template <typename T, typename = void>
+struct IsValidSeedSeqResultType : std::false_type {};
+
+template <typename T>
+struct IsValidSeedSeqResultType<
+    T, std::enable_if_t<std::is_same_v<T, absl::remove_cvref_t<T>> &&
+                        std::is_integral_v<T> && std::is_unsigned_v<T>>>
+    : std::bool_constant<(std::numeric_limits<T>::digits >= 32)> {};
+
+// Detects whether `std::remove_reference_t<SSeq>` has a valid `result_type`
+// and supports `seq.generate(uint32_t*, uint32_t*)` on an lvalue (preserving
+// `const`).
+template <typename SSeq, typename = void>
+struct HasSeedSeqGenerate : std::false_type {};
+
+template <typename SSeq>
+struct HasSeedSeqGenerate<
+    SSeq,
+    std::enable_if_t<
+        IsValidSeedSeqResultType<
+            typename std::remove_reference_t<SSeq>::result_type>::value,
+        std::void_t<
+            decltype(std::declval<std::remove_reference_t<SSeq>&>().generate(
+                std::declval<uint32_t*>(), std::declval<uint32_t*>()))>>>
+    : std::true_type {};
+
+// Detects whether `std::remove_reference_t<SSeq>` supports `seq.size()`
+// convertible to `size_t` on an lvalue (preserving `const`).
+template <typename SSeq, typename = void>
+struct HasSeedSeqSize : std::false_type {};
+
+template <typename SSeq>
+struct HasSeedSeqSize<
+    SSeq, std::enable_if_t<std::is_convertible_v<
+              decltype(std::declval<std::remove_reference_t<SSeq>&>().size()),
+              size_t>>> : std::true_type {};
+
+// Marks internal SeedSequence types (such as `RandenPoolSeedSeq`) that yield
+// full-entropy words directly from an internal entropy pool and can seed
+// `randen_engine` with a fixed 256-bit (8-word) draw rather than expanding
+// through general `[rand.req.seedseq]` mixing.
+template <typename SSeq>
+struct IsDirectEntropySeedSeq : std::false_type {};
+
 }  // namespace random_internal
 ABSL_NAMESPACE_END
 }  // namespace absl
diff --git a/absl/random/internal/traits_test.cc b/absl/random/internal/traits_test.cc
index 08361a4..b328833 100644
--- a/absl/random/internal/traits_test.cc
+++ b/absl/random/internal/traits_test.cc
@@ -14,6 +14,7 @@
 
 #include "absl/random/internal/traits.h"
 
+#include <cstddef>
 #include <cstdint>
 #include <random>
 #include <type_traits>
@@ -22,8 +23,12 @@
 
 namespace {
 
+using absl::random_internal::HasSeedSeqGenerate;
+using absl::random_internal::HasSeedSeqSize;
 using absl::random_internal::is_urbg;
 using absl::random_internal::is_widening_convertible;
+using absl::random_internal::IsDirectEntropySeedSeq;
+using absl::random_internal::IsValidSeedSeqResultType;
 
 static_assert(is_urbg<std::minstd_rand>::value);
 static_assert(!is_urbg<uint64_t>::value);
@@ -125,4 +130,62 @@
   CheckWideningConvertsTo<bool, float>();
 }
 
+enum UnscopedU32Enum : uint32_t { kZero = 0 };
+enum class ScopedU32Enum : uint32_t { kZero = 0 };
+struct EmptyStruct {};
+
+struct NoResultSeedSeq {
+  size_t size() const { return 1; }
+  void generate(uint32_t*, uint32_t*) {}
+};
+
+struct MutableOnlySeedSeq {
+  using result_type = uint32_t;
+  size_t size() { return 1; }
+  void generate(uint32_t*, uint32_t*) {}
+};
+
+struct ConstSeedSeq {
+  using result_type = uint64_t;
+  size_t size() const { return 1; }
+  void generate(uint32_t*, uint32_t*) const {}
+};
+
+static_assert(IsValidSeedSeqResultType<uint32_t>::value);
+static_assert(IsValidSeedSeqResultType<uint64_t>::value);
+static_assert(IsValidSeedSeqResultType<unsigned int>::value);
+static_assert(IsValidSeedSeqResultType<unsigned long>::value);       // NOLINT
+static_assert(IsValidSeedSeqResultType<unsigned long long>::value);  // NOLINT
+static_assert(IsValidSeedSeqResultType<std::seed_seq::result_type>::value);
+
+static_assert(!IsValidSeedSeqResultType<bool>::value);
+static_assert(!IsValidSeedSeqResultType<uint8_t>::value);
+static_assert(!IsValidSeedSeqResultType<uint16_t>::value);
+static_assert(!IsValidSeedSeqResultType<int32_t>::value);
+static_assert(!IsValidSeedSeqResultType<int64_t>::value);
+static_assert(!IsValidSeedSeqResultType<const uint32_t>::value);
+static_assert(!IsValidSeedSeqResultType<volatile uint32_t>::value);
+static_assert(!IsValidSeedSeqResultType<uint32_t&>::value);
+static_assert(!IsValidSeedSeqResultType<uint32_t&&>::value);
+static_assert(!IsValidSeedSeqResultType<float>::value);
+static_assert(!IsValidSeedSeqResultType<double>::value);
+static_assert(!IsValidSeedSeqResultType<void>::value);
+static_assert(!IsValidSeedSeqResultType<UnscopedU32Enum>::value);
+static_assert(!IsValidSeedSeqResultType<ScopedU32Enum>::value);
+static_assert(!IsValidSeedSeqResultType<EmptyStruct>::value);
+
+static_assert(!HasSeedSeqGenerate<NoResultSeedSeq>::value);
+static_assert(HasSeedSeqGenerate<MutableOnlySeedSeq&>::value);
+static_assert(!HasSeedSeqGenerate<const MutableOnlySeedSeq&>::value);
+static_assert(HasSeedSeqGenerate<const ConstSeedSeq&>::value);
+
+static_assert(HasSeedSeqSize<MutableOnlySeedSeq&>::value);
+static_assert(!HasSeedSeqSize<const MutableOnlySeedSeq&>::value);
+static_assert(HasSeedSeqSize<const ConstSeedSeq&>::value);
+static_assert(!HasSeedSeqSize<EmptyStruct>::value);
+
+static_assert(!IsDirectEntropySeedSeq<std::seed_seq>::value);
+static_assert(!IsDirectEntropySeedSeq<ConstSeedSeq>::value);
+static_assert(!IsDirectEntropySeedSeq<EmptyStruct>::value);
+
 }  // namespace