diff --git a/Sources/AsyncAlgorithms/AsyncBufferSequence.swift b/Sources/AsyncAlgorithms/AsyncBufferSequence.swift
index 96fad74c..c079289c 100644
--- a/Sources/AsyncAlgorithms/AsyncBufferSequence.swift
+++ b/Sources/AsyncAlgorithms/AsyncBufferSequence.swift
@@ -198,7 +198,7 @@ public actor AsyncLimitBuffer<Element: Sendable>: AsyncBuffer {
   }
 }
 
-extension AsyncSequence where Element: Sendable {
+extension AsyncSequence where Element: Sendable, Self: Sendable {
   /// Creates an asynchronous sequence that buffers elements using a buffer created from a supplied closure.
   ///
   /// Use the `buffer(_:)` method to account for `AsyncSequence` types that may produce elements faster
@@ -224,7 +224,7 @@ extension AsyncSequence where Element: Sendable {
 }
 
 /// An `AsyncSequence` that buffers elements utilizing an `AsyncBuffer`.
-public struct AsyncBufferSequence<Base: AsyncSequence, Buffer: AsyncBuffer> where Base.Element == Buffer.Input, Base.AsyncIterator: Sendable {
+public struct AsyncBufferSequence<Base: AsyncSequence & Sendable, Buffer: AsyncBuffer> where Base.Element == Buffer.Input {
   let base: Base
   let createBuffer: @Sendable () -> Buffer
   
@@ -246,11 +246,11 @@ extension AsyncBufferSequence: AsyncSequence {
       let buffer: Buffer
       let state: AsyncBufferState<Buffer.Input, Buffer.Output>
       
-      init(_ iterator: Base.AsyncIterator, buffer: Buffer, state: AsyncBufferState<Buffer.Input, Buffer.Output>) {
+      init(_ base: Base, buffer: Buffer, state: AsyncBufferState<Buffer.Input, Buffer.Output>) {
         self.buffer = buffer
         self.state = state
         task = Task {
-          var iter = iterator
+          var iter = base.makeAsyncIterator()
           do {
             while let item = try await iter.next() {
               await state.enqueue(item, buffer: buffer)
@@ -279,21 +279,21 @@ extension AsyncBufferSequence: AsyncSequence {
     }
     
     enum State {
-      case idle(Base.AsyncIterator, @Sendable () -> Buffer)
+      case idle(Base, @Sendable () -> Buffer)
       case active(Active)
     }
     
     var state: State
     
-    init(_ iterator: Base.AsyncIterator, createBuffer: @Sendable @escaping () -> Buffer) {
-      state = .idle(iterator, createBuffer)
+    init(_ base: Base, createBuffer: @Sendable @escaping () -> Buffer) {
+      state = .idle(base, createBuffer)
     }
     
     public mutating func next() async rethrows -> Element? {
       switch state {
-      case .idle(let iterator, let createBuffer):
+      case .idle(let base, let createBuffer):
         let bufferState = AsyncBufferState<Base.Element, Buffer.Output>()
-        let buffer = Active(iterator, buffer: createBuffer(), state: bufferState)
+        let buffer = Active(base, buffer: createBuffer(), state: bufferState)
         state = .active(buffer)
         return try await buffer.next()
       case .active(let buffer):
@@ -303,6 +303,6 @@ extension AsyncBufferSequence: AsyncSequence {
   }
   
   public func makeAsyncIterator() -> Iterator {
-    Iterator(base.makeAsyncIterator(), createBuffer: createBuffer)
+    Iterator(base, createBuffer: createBuffer)
   }
 }
diff --git a/Sources/AsyncAlgorithms/AsyncChannel.swift b/Sources/AsyncAlgorithms/AsyncChannel.swift
index 5c4f5a47..9b4a0036 100644
--- a/Sources/AsyncAlgorithms/AsyncChannel.swift
+++ b/Sources/AsyncAlgorithms/AsyncChannel.swift
@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-import OrderedCollections
+@preconcurrency import OrderedCollections
 
 /// A channel for sending elements from one task to another with back pressure.
 ///
@@ -58,7 +58,7 @@ public final class AsyncChannel<Element: Sendable>: AsyncSequence, Sendable {
   typealias Pending = ChannelToken<UnsafeContinuation<UnsafeContinuation<Element?, Never>?, Never>>
   typealias Awaiting = ChannelToken<UnsafeContinuation<Element?, Never>>
 
-  struct ChannelToken<Continuation>: Hashable {
+  struct ChannelToken<Continuation: Sendable>: Hashable, Sendable {
     var generation: Int
     var continuation: Continuation?
 
@@ -86,14 +86,14 @@ public final class AsyncChannel<Element: Sendable>: AsyncSequence, Sendable {
     case cancelled
   }
   
-  enum Emission {
+  enum Emission : Sendable {
     case idle
     case pending(OrderedSet<Pending>)
     case awaiting(OrderedSet<Awaiting>)
     case finished
   }
   
-  struct State {
+  struct State : Sendable {
     var emission: Emission = .idle
     var generation = 0
   }
diff --git a/Sources/AsyncAlgorithms/AsyncCompactedSequence.swift b/Sources/AsyncAlgorithms/AsyncCompactedSequence.swift
index 5b96bc9f..82d2c617 100644
--- a/Sources/AsyncAlgorithms/AsyncCompactedSequence.swift
+++ b/Sources/AsyncAlgorithms/AsyncCompactedSequence.swift
@@ -68,4 +68,4 @@ extension AsyncSequence {
   }
 }
 
-extension AsyncCompactedSequence: Sendable where Base: Sendable, Base.Element: Sendable, Base.AsyncIterator: Sendable { }
+extension AsyncCompactedSequence: Sendable where Base: Sendable, Base.Element: Sendable { }
diff --git a/Sources/AsyncAlgorithms/AsyncInterspersedSequence.swift b/Sources/AsyncAlgorithms/AsyncInterspersedSequence.swift
index 8d8e1b5b..43f8d974 100644
--- a/Sources/AsyncAlgorithms/AsyncInterspersedSequence.swift
+++ b/Sources/AsyncAlgorithms/AsyncInterspersedSequence.swift
@@ -99,4 +99,4 @@ extension AsyncInterspersedSequence: AsyncSequence {
   }
 }
 
-extension AsyncInterspersedSequence: Sendable where Base: Sendable, Base.Element: Sendable, Base.AsyncIterator: Sendable { }
+extension AsyncInterspersedSequence: Sendable where Base: Sendable, Base.Element: Sendable { }
diff --git a/Sources/AsyncAlgorithms/AsyncJoinedSequence.swift b/Sources/AsyncAlgorithms/AsyncJoinedSequence.swift
index cbcbbbe2..716f981e 100644
--- a/Sources/AsyncAlgorithms/AsyncJoinedSequence.swift
+++ b/Sources/AsyncAlgorithms/AsyncJoinedSequence.swift
@@ -91,4 +91,4 @@ public struct AsyncJoinedSequence<Base: AsyncSequence>: AsyncSequence where Base
 }
 
 extension AsyncJoinedSequence: Sendable
-where Base: Sendable, Base.Element: Sendable, Base.Element.Element: Sendable, Base.AsyncIterator: Sendable, Base.Element.AsyncIterator: Sendable { }
+where Base: Sendable, Base.Element: Sendable, Base.Element.Element: Sendable { }
diff --git a/Sources/AsyncAlgorithms/AsyncRemoveDuplicatesSequence.swift b/Sources/AsyncAlgorithms/AsyncRemoveDuplicatesSequence.swift
index 5fcd095f..fd1d2192 100644
--- a/Sources/AsyncAlgorithms/AsyncRemoveDuplicatesSequence.swift
+++ b/Sources/AsyncAlgorithms/AsyncRemoveDuplicatesSequence.swift
@@ -85,9 +85,6 @@ public struct AsyncRemoveDuplicatesSequence<Base: AsyncSequence>: AsyncSequence
   }
 }
 
-extension AsyncRemoveDuplicatesSequence: Sendable where Base: Sendable, Base.Element: Sendable, Base.AsyncIterator: Sendable { }
-
-
 /// An asynchronous sequence that omits repeated elements by testing them with an error-throwing predicate.
 public struct AsyncThrowingRemoveDuplicatesSequence<Base: AsyncSequence>: AsyncSequence {
   public typealias Element = Base.Element
@@ -143,4 +140,6 @@ public struct AsyncThrowingRemoveDuplicatesSequence<Base: AsyncSequence>: AsyncS
   }
 }
 
-extension AsyncThrowingRemoveDuplicatesSequence: Sendable where Base: Sendable, Base.Element: Sendable, Base.AsyncIterator: Sendable { }
+
+extension AsyncRemoveDuplicatesSequence: Sendable where Base: Sendable, Base.Element: Sendable { }
+extension AsyncThrowingRemoveDuplicatesSequence: Sendable where Base: Sendable, Base.Element: Sendable { }
diff --git a/Sources/AsyncAlgorithms/AsyncThrowingChannel.swift b/Sources/AsyncAlgorithms/AsyncThrowingChannel.swift
index 732b0906..6291a7b2 100644
--- a/Sources/AsyncAlgorithms/AsyncThrowingChannel.swift
+++ b/Sources/AsyncAlgorithms/AsyncThrowingChannel.swift
@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-import OrderedCollections
+@preconcurrency import OrderedCollections
 
 /// An error-throwing channel for sending elements from on task to another with back pressure.
 ///
@@ -61,7 +61,7 @@ public final class AsyncThrowingChannel<Element: Sendable, Failure: Error>: Asyn
   typealias Pending = ChannelToken<UnsafeContinuation<UnsafeContinuation<Element?, Error>?, Never>>
   typealias Awaiting = ChannelToken<UnsafeContinuation<Element?, Error>>
 
-  struct ChannelToken<Continuation>: Hashable {
+  struct ChannelToken<Continuation: Sendable>: Hashable, Sendable {
     var generation: Int
     var continuation: Continuation?
 
@@ -95,14 +95,14 @@ public final class AsyncThrowingChannel<Element: Sendable, Failure: Error>: Asyn
     case failed(Error)
   }
   
-  enum Emission {
+  enum Emission: Sendable {
     case idle
     case pending(OrderedSet<Pending>)
     case awaiting(OrderedSet<Awaiting>)
     case terminated(Termination)
   }
   
-  struct State {
+  struct State : Sendable {
     var emission: Emission = .idle
     var generation = 0
   }
diff --git a/Sources/AsyncAlgorithms/CombineLatest/AsyncCombineLatest2Sequence.swift b/Sources/AsyncAlgorithms/CombineLatest/AsyncCombineLatest2Sequence.swift
index 8ff0c038..c07bd099 100644
--- a/Sources/AsyncAlgorithms/CombineLatest/AsyncCombineLatest2Sequence.swift
+++ b/Sources/AsyncAlgorithms/CombineLatest/AsyncCombineLatest2Sequence.swift
@@ -35,7 +35,7 @@ public func combineLatest<
 public struct AsyncCombineLatest2Sequence<
   Base1: AsyncSequence,
   Base2: AsyncSequence
->: AsyncSequence where
+>: AsyncSequence, Sendable where
   Base1: Sendable,
   Base1.Element: Sendable,
   Base2: Sendable,
diff --git a/Sources/AsyncAlgorithms/CombineLatest/AsyncCombineLatest3Sequence.swift b/Sources/AsyncAlgorithms/CombineLatest/AsyncCombineLatest3Sequence.swift
index 0ba733e2..a1c7e51a 100644
--- a/Sources/AsyncAlgorithms/CombineLatest/AsyncCombineLatest3Sequence.swift
+++ b/Sources/AsyncAlgorithms/CombineLatest/AsyncCombineLatest3Sequence.swift
@@ -39,7 +39,7 @@ public struct AsyncCombineLatest3Sequence<
   Base1: AsyncSequence,
   Base2: AsyncSequence,
   Base3: AsyncSequence
->: AsyncSequence where
+>: AsyncSequence, Sendable where
   Base1: Sendable,
   Base1.Element: Sendable,
   Base2: Sendable,
diff --git a/Sources/AsyncAlgorithms/Zip/AsyncZip2Sequence.swift b/Sources/AsyncAlgorithms/Zip/AsyncZip2Sequence.swift
index 0ef591ba..6fb341ac 100644
--- a/Sources/AsyncAlgorithms/Zip/AsyncZip2Sequence.swift
+++ b/Sources/AsyncAlgorithms/Zip/AsyncZip2Sequence.swift
@@ -20,7 +20,7 @@ public func zip<Base1: AsyncSequence, Base2: AsyncSequence>(
 
 /// An asynchronous sequence that concurrently awaits values from two `AsyncSequence` types
 /// and emits a tuple of the values.
-public struct AsyncZip2Sequence<Base1: AsyncSequence, Base2: AsyncSequence>: AsyncSequence
+public struct AsyncZip2Sequence<Base1: AsyncSequence, Base2: AsyncSequence>: AsyncSequence, Sendable
   where Base1: Sendable, Base1.Element: Sendable, Base2: Sendable, Base2.Element: Sendable {
   public typealias Element = (Base1.Element, Base2.Element)
   public typealias AsyncIterator = Iterator
diff --git a/Sources/AsyncAlgorithms/Zip/AsyncZip3Sequence.swift b/Sources/AsyncAlgorithms/Zip/AsyncZip3Sequence.swift
index 43317aca..87474bae 100644
--- a/Sources/AsyncAlgorithms/Zip/AsyncZip3Sequence.swift
+++ b/Sources/AsyncAlgorithms/Zip/AsyncZip3Sequence.swift
@@ -21,7 +21,7 @@ public func zip<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncSequence
 
 /// An asynchronous sequence that concurrently awaits values from three `AsyncSequence` types
 /// and emits a tuple of the values.
-public struct AsyncZip3Sequence<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncSequence>: AsyncSequence
+public struct AsyncZip3Sequence<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncSequence>: AsyncSequence, Sendable
   where Base1: Sendable, Base1.Element: Sendable, Base2: Sendable, Base2.Element: Sendable, Base3: Sendable, Base3.Element: Sendable {
   public typealias Element = (Base1.Element, Base2.Element, Base3.Element)
   public typealias AsyncIterator = Iterator
diff --git a/Tests/AsyncAlgorithmsTests/Performance/ThroughputMeasurement.swift b/Tests/AsyncAlgorithmsTests/Performance/ThroughputMeasurement.swift
index f9356aae..16531d9b 100644
--- a/Tests/AsyncAlgorithmsTests/Performance/ThroughputMeasurement.swift
+++ b/Tests/AsyncAlgorithmsTests/Performance/ThroughputMeasurement.swift
@@ -11,7 +11,7 @@
 
 import AsyncAlgorithms
 import Foundation
-@preconcurrency import XCTest
+import XCTest
 
 #if canImport(Darwin)
 public struct InfiniteAsyncSequence<Value: Sendable>: AsyncSequence, Sendable {
diff --git a/Tests/AsyncAlgorithmsTests/Support/ReportingSequence.swift b/Tests/AsyncAlgorithmsTests/Support/ReportingSequence.swift
index a03e6f89..1f351d69 100644
--- a/Tests/AsyncAlgorithmsTests/Support/ReportingSequence.swift
+++ b/Tests/AsyncAlgorithmsTests/Support/ReportingSequence.swift
@@ -43,7 +43,7 @@ final class ReportingSequence<Element>: Sequence, IteratorProtocol {
   }
 }
 
-final class ReportingAsyncSequence<Element>: AsyncSequence, AsyncIteratorProtocol {
+final class ReportingAsyncSequence<Element: Sendable>: AsyncSequence, AsyncIteratorProtocol, @unchecked Sendable {
   enum Event: Equatable, CustomStringConvertible {
     case next
     case makeAsyncIterator
diff --git a/Tests/AsyncAlgorithmsTests/TestAdjacentPairs.swift b/Tests/AsyncAlgorithmsTests/TestAdjacentPairs.swift
index 3bcd73cf..843624f6 100644
--- a/Tests/AsyncAlgorithmsTests/TestAdjacentPairs.swift
+++ b/Tests/AsyncAlgorithmsTests/TestAdjacentPairs.swift
@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-@preconcurrency import XCTest
+import XCTest
 import AsyncAlgorithms
 
 final class TestAdjacentPairs: XCTestCase {
diff --git a/Tests/AsyncAlgorithmsTests/TestBuffer.swift b/Tests/AsyncAlgorithmsTests/TestBuffer.swift
index d6838203..cd989c41 100644
--- a/Tests/AsyncAlgorithmsTests/TestBuffer.swift
+++ b/Tests/AsyncAlgorithmsTests/TestBuffer.swift
@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-@preconcurrency import XCTest
+import XCTest
 import AsyncAlgorithms
 
 final class TestBuffer: XCTestCase {
@@ -225,212 +225,6 @@ final class TestBuffer: XCTestCase {
     XCTAssertEqual(data, collected)
   }
 
-  func test_multi_tasks() async {
-    var values = GatedSequence(Array(0 ... 10))
-    let bufferSeq = values.buffer(policy: .unbounded)
-    var iter_ = bufferSeq.makeAsyncIterator()
-
-    // Initiate the sequence's operation and creation of its Task and actor before sharing its iterator.
-    values.advance()
-    let _ = await iter_.next()
-
-    let iter = iter_
-
-    let task1 = Task<[Int], Never> {
-      var result = [Int]()
-      var iter1 = iter
-      while let val = await iter1.next() {
-        result.append(val)
-      }
-      return result
-    }
-
-    let task2 = Task<[Int], Never> {
-      var result = [Int]()
-      var iter2 = iter
-      while let val = await iter2.next() {
-        result.append(val)
-      }
-      return result
-    }
-
-    try? await Task.sleep(nanoseconds: 100_000_000)
-    values.advance()
-    values.advance()
-    values.advance()
-
-    try? await Task.sleep(nanoseconds: 100_000_000)
-    values.advance()
-    values.advance()
-    values.advance()
-
-    try? await Task.sleep(nanoseconds: 100_000_000)
-    values.advance()
-    values.advance()
-    values.advance()
-    values.advance()
-
-    let task1Results = await task1.value
-    let task2Results = await task2.value
-
-    XCTAssertEqual(task1Results.sorted(), task1Results)
-    XCTAssertEqual(task2Results.sorted(), task2Results)
-
-    let combined = (task1Results + task2Results).sorted()
-    XCTAssertEqual(combined, Array(1 ... 10))
-  }
-
-  func test_multi_tasks_error() async {
-    var values = GatedSequence(Array(0 ... 10))
-    let mapSeq = values.map { try throwOn(7, $0) }
-    let bufferSeq = mapSeq.buffer(policy: .unbounded)
-    var iter_ = bufferSeq.makeAsyncIterator()
-
-    // Initiate the sequence's operation and creation of its Task and actor before sharing its iterator.
-    values.advance()
-    let _ = try! await iter_.next()
-
-    let iter = iter_
-
-    let task1 = Task<([Int], Error?), Never> {
-      var result = [Int]()
-      var err: Error?
-      var iter1 = iter
-      do {
-        while let val = try await iter1.next() {
-          result.append(val)
-        }
-      } catch {
-        err = error
-      }
-      return (result, err)
-    }
-
-    let task2 = Task<([Int], Error?), Never> {
-      var result = [Int]()
-      var err: Error?
-      var iter2 = iter
-      do {
-        while let val = try await iter2.next() {
-          result.append(val)
-        }
-      } catch {
-        err = error
-      }
-      return (result, err)
-    }
-
-    try? await Task.sleep(nanoseconds: 100_000_000)
-    values.advance()
-    values.advance()
-    values.advance()
-
-    try? await Task.sleep(nanoseconds: 100_000_000)
-    values.advance()
-    values.advance()
-    values.advance()
-
-    try? await Task.sleep(nanoseconds: 100_000_000)
-    values.advance()
-
-    let task1Results = await task1.value
-    let task2Results = await task2.value
-
-    XCTAssertEqual(task1Results.0.sorted(), task1Results.0)
-    XCTAssertEqual(task2Results.0.sorted(), task2Results.0)
-
-    let combined = (task1Results.0 + task2Results.0).sorted()
-    XCTAssertEqual(combined, Array(1 ... 6))
-
-    XCTAssertEqual(1, [task1Results, task2Results].compactMap{ $0.1 }.count)
-  }
-
-  func test_multi_tasks_delegateBufferError() async {
-    actor BufferDelegate: AsyncBuffer {
-      var buffer = [Int]()
-      var pushed = [Int]()
-
-      func push(_ element: Int) async {
-        buffer.append(element)
-        pushed.append(element)
-      }
-
-      func pop() async throws -> Int? {
-        if buffer.count > 0 {
-          let value = buffer.removeFirst()
-          if value == 7 {
-            throw Failure()
-          }
-          return value
-        }
-        return nil
-      }
-    }
-    let delegate = BufferDelegate()
-
-    var values = GatedSequence(Array(0 ... 10))
-    let bufferSeq = values.buffer { delegate }
-    var iter_ = bufferSeq.makeAsyncIterator()
-
-    // Initiate the sequence's operation and creation of its Task and actor before sharing its iterator.
-    values.advance()
-    let _ = try! await iter_.next()
-
-    let iter = iter_
-
-    let task1 = Task<([Int], Error?), Never> {
-      var result = [Int]()
-      var err: Error?
-      var iter1 = iter
-      do {
-        while let val = try await iter1.next() {
-          result.append(val)
-        }
-      } catch {
-        err = error
-      }
-      return (result, err)
-    }
-
-    let task2 = Task<([Int], Error?), Never> {
-      var result = [Int]()
-      var err: Error?
-      var iter2 = iter
-      do {
-        while let val = try await iter2.next() {
-          result.append(val)
-        }
-      } catch {
-        err = error
-      }
-      return (result, err)
-    }
-
-    try? await Task.sleep(nanoseconds: 100_000_000)
-    values.advance()
-    values.advance()
-    values.advance()
-
-    try? await Task.sleep(nanoseconds: 100_000_000)
-    values.advance()
-    values.advance()
-    values.advance()
-
-    try? await Task.sleep(nanoseconds: 100_000_000)
-    values.advance()
-
-    let task1Results = await task1.value
-    let task2Results = await task2.value
-
-    XCTAssertEqual(task1Results.0.sorted(), task1Results.0)
-    XCTAssertEqual(task2Results.0.sorted(), task2Results.0)
-
-    let combined = (task1Results.0 + task2Results.0).sorted()
-    XCTAssertEqual(combined, Array(1 ... 6))
-
-    XCTAssertEqual(1, [task1Results, task2Results].compactMap{ $0.1 }.count)
-  }
-
   func test_bufferingOldest() async {
     validate {
       "X-12-   34-    5   |"
diff --git a/Tests/AsyncAlgorithmsTests/TestBufferedByteIterator.swift b/Tests/AsyncAlgorithmsTests/TestBufferedByteIterator.swift
index 9284cc67..ee6c5d12 100644
--- a/Tests/AsyncAlgorithmsTests/TestBufferedByteIterator.swift
+++ b/Tests/AsyncAlgorithmsTests/TestBufferedByteIterator.swift
@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-@preconcurrency import XCTest
+import XCTest
 import AsyncAlgorithms
 
 final class TestBufferedByteIterator: XCTestCase {
diff --git a/Tests/AsyncAlgorithmsTests/TestChain.swift b/Tests/AsyncAlgorithmsTests/TestChain.swift
index 2ef9fc85..b3be90a3 100644
--- a/Tests/AsyncAlgorithmsTests/TestChain.swift
+++ b/Tests/AsyncAlgorithmsTests/TestChain.swift
@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-@preconcurrency import XCTest
+import XCTest
 import AsyncAlgorithms
 
 final class TestChain2: XCTestCase {
diff --git a/Tests/AsyncAlgorithmsTests/TestChannel.swift b/Tests/AsyncAlgorithmsTests/TestChannel.swift
index 2d8797fa..3d53fe3a 100644
--- a/Tests/AsyncAlgorithmsTests/TestChannel.swift
+++ b/Tests/AsyncAlgorithmsTests/TestChannel.swift
@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-@preconcurrency import XCTest
+import XCTest
 import AsyncAlgorithms
 
 final class TestChannel: XCTestCase {
diff --git a/Tests/AsyncAlgorithmsTests/TestCombineLatest.swift b/Tests/AsyncAlgorithmsTests/TestCombineLatest.swift
index 78e08ae7..489252ae 100644
--- a/Tests/AsyncAlgorithmsTests/TestCombineLatest.swift
+++ b/Tests/AsyncAlgorithmsTests/TestCombineLatest.swift
@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-@preconcurrency import XCTest
+import XCTest
 import AsyncAlgorithms
 
 final class TestCombineLatest2: XCTestCase {
diff --git a/Tests/AsyncAlgorithmsTests/TestCompacted.swift b/Tests/AsyncAlgorithmsTests/TestCompacted.swift
index ddba2fa8..b82fe31e 100644
--- a/Tests/AsyncAlgorithmsTests/TestCompacted.swift
+++ b/Tests/AsyncAlgorithmsTests/TestCompacted.swift
@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-@preconcurrency import XCTest
+import XCTest
 import AsyncAlgorithms
 
 final class TestCompacted: XCTestCase {
diff --git a/Tests/AsyncAlgorithmsTests/TestInterspersed.swift b/Tests/AsyncAlgorithmsTests/TestInterspersed.swift
index 1fa6c386..79c93f73 100644
--- a/Tests/AsyncAlgorithmsTests/TestInterspersed.swift
+++ b/Tests/AsyncAlgorithmsTests/TestInterspersed.swift
@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-@preconcurrency import XCTest
+import XCTest
 import AsyncAlgorithms
 
 final class TestInterspersed: XCTestCase {
diff --git a/Tests/AsyncAlgorithmsTests/TestJoin.swift b/Tests/AsyncAlgorithmsTests/TestJoin.swift
index e545c1f0..04fd1772 100644
--- a/Tests/AsyncAlgorithmsTests/TestJoin.swift
+++ b/Tests/AsyncAlgorithmsTests/TestJoin.swift
@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-@preconcurrency import XCTest
+import XCTest
 import AsyncAlgorithms
 
 extension Sequence where Element: Sequence, Element.Element: Equatable & Sendable {
diff --git a/Tests/AsyncAlgorithmsTests/TestLazy.swift b/Tests/AsyncAlgorithmsTests/TestLazy.swift
index a173d80f..1ef69d29 100644
--- a/Tests/AsyncAlgorithmsTests/TestLazy.swift
+++ b/Tests/AsyncAlgorithmsTests/TestLazy.swift
@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-@preconcurrency import XCTest
+import XCTest
 import AsyncAlgorithms
 
 final class TestLazy: XCTestCase {
diff --git a/Tests/AsyncAlgorithmsTests/TestManualClock.swift b/Tests/AsyncAlgorithmsTests/TestManualClock.swift
index cc4d2640..045ba2de 100644
--- a/Tests/AsyncAlgorithmsTests/TestManualClock.swift
+++ b/Tests/AsyncAlgorithmsTests/TestManualClock.swift
@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-@preconcurrency import XCTest
+import XCTest
 import AsyncAlgorithms
 
 final class TestManualClock: XCTestCase {
diff --git a/Tests/AsyncAlgorithmsTests/TestMerge.swift b/Tests/AsyncAlgorithmsTests/TestMerge.swift
index 76ce5344..ef72d1ac 100644
--- a/Tests/AsyncAlgorithmsTests/TestMerge.swift
+++ b/Tests/AsyncAlgorithmsTests/TestMerge.swift
@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-@preconcurrency import XCTest
+import XCTest
 import AsyncAlgorithms
 
 final class TestMerge2: XCTestCase {
diff --git a/Tests/AsyncAlgorithmsTests/TestReductions.swift b/Tests/AsyncAlgorithmsTests/TestReductions.swift
index 82a0132b..ad9cf5ac 100644
--- a/Tests/AsyncAlgorithmsTests/TestReductions.swift
+++ b/Tests/AsyncAlgorithmsTests/TestReductions.swift
@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-@preconcurrency import XCTest
+import XCTest
 import AsyncAlgorithms
 
 final class TestReductions: XCTestCase {
diff --git a/Tests/AsyncAlgorithmsTests/TestRemoveDuplicates.swift b/Tests/AsyncAlgorithmsTests/TestRemoveDuplicates.swift
index eb859d01..01ddf3ff 100644
--- a/Tests/AsyncAlgorithmsTests/TestRemoveDuplicates.swift
+++ b/Tests/AsyncAlgorithmsTests/TestRemoveDuplicates.swift
@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-@preconcurrency import XCTest
+import XCTest
 import AsyncAlgorithms
 
 final class TestRemoveDuplicates: XCTestCase {
diff --git a/Tests/AsyncAlgorithmsTests/TestValidator.swift b/Tests/AsyncAlgorithmsTests/TestValidator.swift
index 2b4a152d..9c5ef9c2 100644
--- a/Tests/AsyncAlgorithmsTests/TestValidator.swift
+++ b/Tests/AsyncAlgorithmsTests/TestValidator.swift
@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-@preconcurrency import XCTest
+import XCTest
 import AsyncAlgorithms
 
 final class TestValidator: XCTestCase {
diff --git a/Tests/AsyncAlgorithmsTests/TestZip.swift b/Tests/AsyncAlgorithmsTests/TestZip.swift
index 80e8caf8..d27dd73d 100644
--- a/Tests/AsyncAlgorithmsTests/TestZip.swift
+++ b/Tests/AsyncAlgorithmsTests/TestZip.swift
@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-@preconcurrency import XCTest
+import XCTest
 import AsyncAlgorithms
 
 final class TestZip2: XCTestCase {