diff --git a/LICENSE.txt b/LICENSE.txt
new file mode 100644
--- /dev/null
+++ b/LICENSE.txt
@@ -0,0 +1,19 @@
+Copyright © 2026 Matt Kline
+
+This software is provided 'as-is', without any express or implied
+warranty.  In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+   claim that you wrote the original software. If you use this software
+   in a product, an acknowledgment in the product documentation would be
+   appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source distribution.
diff --git a/hoare.cabal b/hoare.cabal
--- a/hoare.cabal
+++ b/hoare.cabal
@@ -10,14 +10,21 @@
     - Functions for using bounded STM types like
       `TBQueue` and `TMVar` as /channels/ between threads.
 
-    - A /closeable/ @TBCQueue@ for programs where the input ends.
-version: 0.1.1.0
+    - A /closeable/ @TBCQueue@ and @TCSlot@ for programs where the input ends.
+
+    - A "split" API on top of the above, using newtypes to distinguish
+      the producer side from the consumer side.
+
+    - Some wrappers to gather metrics (items produced/consumed, wait times).
+      This API is experimental and unstable.
+version: 0.2.0.0
 license: Zlib
+license-file: LICENSE.txt
 author: Matt Kline
 maintainer: matt@bitbashing.io
 category: Concurrency
 build-type: Simple
-tested-with: GHC==9.8.4
+tested-with: GHC==9.12.4
 
 source-repository head
     type:     git
@@ -32,29 +39,32 @@
                  -Wno-missing-import-lists
                  -Wno-missing-kind-signatures
                  -Wno-missing-local-signatures
+                 -Wno-missing-poly-kind-signatures
                  -Wno-missing-role-annotations
                  -Wno-missing-safe-haskell-mode
-                 -Wno-monomorphism-restriction
                  -Wno-safe
                  -Wno-type-defaults
                  -Wno-unsafe
                  -threaded
                  -fno-ignore-asserts
-    default-language: Haskell2010
-    default-extensions: BangPatterns,
-                        DerivingStrategies,
-                        ImportQualifiedPost,
-                        LambdaCase,
-                        OverloadedRecordDot,
-                        RecordWildCards,
+    default-language: GHC2024
+    default-extensions: OverloadedRecordDot
 
 library
     import: shared
     exposed-modules: Control.Concurrent.Channel
                      Control.Concurrent.Channel.Endless
+                     Control.Concurrent.Channel.Endless.Split
+                     Control.Concurrent.Channel.Metrics
+                     Control.Concurrent.Channel.Overwrite
+                     Control.Concurrent.Channel.Split
+                     Control.Concurrent.Channel.Try
                      Control.Concurrent.TBCQueue
+                     Control.Concurrent.TCSlot
+
     hs-source-dirs: lib
-    build-depends: base >=4.4 && < 5,
+    build-depends: base >=4.20 && < 5,
                    async >= 2.2 && < 3,
+                   clock >= 0.8.4 && < 0.9,
                    deepseq >= 1.5 && < 2,
                    stm >= 2.5 && < 3,
diff --git a/lib/Control/Concurrent/Channel.hs b/lib/Control/Concurrent/Channel.hs
--- a/lib/Control/Concurrent/Channel.hs
+++ b/lib/Control/Concurrent/Channel.hs
@@ -2,11 +2,19 @@
 -- with closeable channels.
 module Control.Concurrent.Channel(
     Channel (..),
+    OverwriteResult (..),
     writeChannel',
     evalWriteChannel,
     evalWriteChannel',
+    overwriteChannel',
+    evalOverwriteChannel,
+    evalOverwriteChannel',
     consumeChannel,
+    consumeChannelBatches,
+    consumeChannelBatches',
     stateConsumeChannel,
+    stateConsumeChannelBatches,
+    stateConsumeChannelBatches',
     feedChannel,
     evalFeedChannel,
     pipeline,
@@ -14,37 +22,67 @@
 ) where
 
 import Control.Concurrent.Async
+import Control.Concurrent.Channel.Overwrite
 import Control.Concurrent.STM
 import Control.Concurrent.TBCQueue
-import Control.Exception
+import Control.Concurrent.TCSlot
+import Control.Exception (evaluate, finally)
 import Control.DeepSeq
 import Control.Monad
+import Data.Function (fix)
+import Data.Maybe (maybeToList)
 
 class Channel c where
-    -- | Returns @Just value@ until the channel is closed, blocking for the next value.
+    -- | Reads from the channel, blocking if empty,
+    -- and returning @Nothing@ once it is empty and closed.
     readChannel :: c a -> STM (Maybe a)
 
-    -- | Writes the given value to the channel if it's still open.
+    -- | Drains the channel, blocking if it is empty.
+    --   Returns @[]@ if the channel is empty and closed.
     --
+    --   Useful for accumulating values to pass in bulk to an expensive operation,
+    --   like a @send()@ syscall.
+    drainChannel :: c a -> STM [a]
+
+    -- | Writes the given value to the channel if it's still open, blocking if full.
+    --
     -- Returns whether the channel is still open so producers know when consumers no longer care.
     writeChannel :: c a -> a -> STM Bool
 
+    -- | Writes the given value to the channel if it's still open.
+    --
+    -- When the channel is full, removes and returns the oldest value.
+    overwriteChannel :: c a -> a -> STM (OverwriteResult a)
+
     -- | Closes the channel so that future writes are no-ops and readers get @Nothing@
     -- after all values currently inside have been read.
     closeChannel :: c a -> STM ()
 
+    isEmptyChannel :: c a -> STM Bool
+
     isClosedChannel :: c a -> STM Bool
 
+    isFullChannel :: c a -> STM Bool
+
 instance Channel TBCQueue where
     readChannel = readTBCQueue
-
+    drainChannel = drainTBCQueue
     writeChannel = writeTBCQueue
-
+    overwriteChannel = overwriteTBCQueue
     closeChannel = closeTBCQueue
-
+    isEmptyChannel = isEmptyTBCQueue
     isClosedChannel = isClosedTBCQueue
+    isFullChannel = isFullTBCQueue
 
--- More to follow? A TMVar-like closeable slot?
+instance Channel TCSlot where
+    readChannel = readTCSlot
+    drainChannel = fmap maybeToList <$> readTCSlot
+    writeChannel = writeTCSlot
+    overwriteChannel = overwriteTCSlot
+    closeChannel = closeTCSlot
+    isEmptyChannel = isEmptyTCSlot
+    isClosedChannel = isClosedTCSlot
+    isFullChannel = isFullTCSlot
 
 -- | Writes to the channel, asserting that it hasn't been closed.
 --
@@ -73,16 +111,55 @@
     atomically $ writeChannel' c v'
 {-# INLINE evalWriteChannel' #-}
 
--- | Consume the given channel until it closes,
--- passing values to the given action and collecting its results.
-consumeChannel :: (Channel c, Monoid m) => c a -> (a -> IO m) -> IO m
-consumeChannel c f = go mempty where
-    go !acc = atomically (readChannel c) >>= \case
-        Just v -> do
-            res <- f v
-            go $ acc <> res
-        Nothing -> pure acc
+-- | Overwrites the channel, asserting that it hasn't been closed
+-- and returning any overwritten value.
+--
+-- Useful in situations where only the writer closes the channel (when finished).
+overwriteChannel' :: (Channel c) => c a -> a -> STM (Maybe a)
+overwriteChannel' c v = overwriteChannel c v >>= \case
+    Wrote -> pure Nothing
+    Overwrote o -> pure $ Just o
+    Closed -> error "absurd: overwriteChannel' on closed channel"
 
+-- | Force a value to normal form before overwriting the given channel with it.
+evalOverwriteChannel :: (Channel c, NFData a) => c a -> a -> IO (OverwriteResult a)
+evalOverwriteChannel c v = do
+    v' <- evaluate $ force v
+    atomically $ overwriteChannel c v'
+{-# INLINE evalOverwriteChannel #-}
+
+-- | `overwriteChannel'` meets `evalOverwriteChannel`
+evalOverwriteChannel' :: (Channel c, NFData a) => c a -> a -> IO (Maybe a)
+evalOverwriteChannel' c v = do
+    v' <- evaluate $ force v
+    atomically $ overwriteChannel' c v'
+{-# INLINE evalOverwriteChannel' #-}
+
+-- | Consume the given channel until it closes, passing values to the given action.
+--
+-- See 'stateConsumeChannel' to accumulate state at each step.
+consumeChannel :: (Channel c) => c a -> (a -> IO ()) -> IO ()
+consumeChannel c f = fix $ \loop -> atomically (readChannel c) >>= \case
+    Just v -> f v >> loop
+    Nothing -> pure ()
+
+-- | Consume the given channel until it closes, passing batches of values to the given action.
+--
+-- Each batch is all the values in the channel at the time of the read (see `drainChannel`).
+-- When the consumer falls behind, this uses fewer STM transactions than `consumeChannel`
+-- at the cost of weaker backpressure.
+consumeChannelBatches :: (Channel c) => c a -> ([a] -> IO ()) -> IO ()
+consumeChannelBatches c f = fix $ \loop -> atomically (drainChannel c) >>= \case
+    [] -> pure ()
+    vs -> f vs >> loop
+
+-- | `consumeChannelBatches`, but with an action for each value instead of each batch.
+--
+-- This has the same interface as `consumeChannel`,
+-- but uses fewer STM transactions when the consumer falls behind.
+consumeChannelBatches' :: (Channel c) => c a -> (a -> IO ()) -> IO ()
+consumeChannelBatches' c f = consumeChannelBatches c $ mapM_ f
+
 -- | Consume the given channel until it closes,
 -- with each action updating some state. Returns the final state.
 stateConsumeChannel :: (Channel c) => c a -> s -> (s -> a -> IO s) -> IO s
@@ -92,6 +169,22 @@
         stateConsumeChannel c next f
     Nothing -> pure state
 
+-- | `consumeChannelBatches`, but with each action updating some state.
+-- Returns the final state.
+stateConsumeChannelBatches :: (Channel c) => c a -> s -> (s -> [a] -> IO s) -> IO s
+stateConsumeChannelBatches c !state f = atomically (drainChannel c) >>= \case
+    [] -> pure state
+    vs -> do
+        next <- f state vs
+        stateConsumeChannelBatches c next f
+
+-- | `stateConsumeChannelBatches`, but with an action for each value instead of each batch.
+--
+-- This has the same interface as `stateConsumeChannel`,
+-- but uses fewer STM transactions when the consumer falls behind.
+stateConsumeChannelBatches' :: (Channel c) => c a -> s -> (s -> a -> IO s) -> IO s
+stateConsumeChannelBatches' c state f = stateConsumeChannelBatches c state $ foldM (\ !s v -> f s v)
+
 feedChannel' :: (Channel c) => c a -> IO (Maybe a) -> IO ()
 feedChannel' c f = f >>= \case
     Just v -> do
@@ -122,7 +215,8 @@
 pipeline new producer consumer = do
     c <- new
     let producer' = producer c `finally` atomically (closeChannel c)
-    concurrently producer' (consumer c)
+    let consumer' = consumer c `finally` atomically (closeChannel c)
+    concurrently producer' consumer'
 
 -- | `pipeline`, but ignore the results.
 pipeline_ :: (Channel c) => IO (c a) -> (c a -> IO x) -> (c a -> IO y) -> IO ()
diff --git a/lib/Control/Concurrent/Channel/Endless.hs b/lib/Control/Concurrent/Channel/Endless.hs
--- a/lib/Control/Concurrent/Channel/Endless.hs
+++ b/lib/Control/Concurrent/Channel/Endless.hs
@@ -7,7 +7,13 @@
 module Control.Concurrent.Channel.Endless(
     Channel (..),
     evalWriteChannel,
+    evalOverwriteChannel,
     consumeChannel,
+    consumeChannelBatches,
+    consumeChannelBatches',
+    stateConsumeChannel,
+    stateConsumeChannelBatches,
+    stateConsumeChannelBatches',
     feedChannel,
     evalFeedChannel,
     pipeline,
@@ -21,28 +27,103 @@
 import Control.Monad
 
 class Channel c where
+    -- | Reads the next value, blocking if empty.
     readChannel :: c a -> STM a
 
+    -- | Drains the channel, blocking if it is empty.
+    --
+    --   Useful for accumulating values to pass in bulk to an expensive operation,
+    --   like a @send()@ syscall.
+    drainChannel :: c a -> STM [a]
+
+    -- | Writes the next value, blocking if full.
     writeChannel :: c a -> a -> STM ()
 
+    -- | Writes the next value, returning the oldest if the channel was full.
+    overwriteChannel :: c a -> a -> STM (Maybe a)
+
 instance Channel TBQueue where
     readChannel = readTBQueue
 
+    drainChannel c = do
+        vs <- flushTBQueue c
+        when (null vs) retry
+        pure vs
+
     writeChannel = writeTBQueue
 
+    overwriteChannel c v = do
+        wasFull <- isFullTBQueue c
+        if wasFull
+            then do
+                o <- readTBQueue c
+                writeTBQueue c v
+                pure $ Just o
+            else do
+                writeTBQueue c v
+                pure Nothing
+
 instance Channel TMVar where
     readChannel = takeTMVar
 
-    writeChannel = writeTMVar
+    drainChannel = fmap (: []) <$> takeTMVar
 
+    writeChannel = putTMVar
+
+    overwriteChannel c v = do
+        o <- tryTakeTMVar c
+        putTMVar c v
+        pure o
+
 evalWriteChannel :: (Channel c, NFData a) => c a -> a -> IO ()
 evalWriteChannel c v = do
     v' <- evaluate $ force v
     atomically $ writeChannel c v'
 {-# INLINE evalWriteChannel #-}
 
+evalOverwriteChannel :: (Channel c, NFData a) => c a -> a -> IO (Maybe a)
+evalOverwriteChannel c v = do
+    v' <- evaluate $ force v
+    atomically $ overwriteChannel c v'
+{-# INLINE evalOverwriteChannel #-}
+
 consumeChannel :: (Channel c) => c a -> (a -> IO ()) -> IO ()
 consumeChannel c f = forever $ atomically (readChannel c) >>= f
+
+-- | Consume the given channel, passing batches of values to the given action.
+--
+-- Each batch is all the values in the channel at the time of the read (see `drainChannel`).
+-- When the consumer falls behind, this uses fewer STM transactions than `consumeChannel`
+-- at the cost of weaker backpressure.
+consumeChannelBatches :: (Channel c) => c a -> ([a] -> IO ()) -> IO ()
+consumeChannelBatches c f = forever $ atomically (drainChannel c) >>= f
+
+-- | `consumeChannelBatches`, but with an action for each value instead of each batch.
+--
+-- This has the same interface as `consumeChannel`,
+-- but uses fewer STM transactions when the consumer falls behind.
+consumeChannelBatches' :: (Channel c) => c a -> (a -> IO ()) -> IO ()
+consumeChannelBatches' c f = consumeChannelBatches c $ mapM_ f
+
+stateConsumeChannel :: (Channel c) => c a -> s -> (s -> a -> IO s) -> IO ()
+stateConsumeChannel c !state f = do
+    v <- atomically (readChannel c)
+    next <- f state v
+    stateConsumeChannel c next f
+
+-- | `consumeChannelBatches`, but with each action updating some state.
+stateConsumeChannelBatches :: (Channel c) => c a -> s -> (s -> [a] -> IO s) -> IO ()
+stateConsumeChannelBatches c !state f = do
+    vs <- atomically (drainChannel c)
+    next <- f state vs
+    stateConsumeChannelBatches c next f
+
+-- | `stateConsumeChannelBatches`, but with an action for each value instead of each batch.
+--
+-- This has the same interface as `stateConsumeChannel`,
+-- but uses fewer STM transactions when the consumer falls behind.
+stateConsumeChannelBatches' :: (Channel c) => c a -> s -> (s -> a -> IO s) -> IO ()
+stateConsumeChannelBatches' c state f = stateConsumeChannelBatches c state $ foldM (\ !s v -> f s v)
 
 feedChannel :: (Channel c) => c a -> IO a -> IO ()
 feedChannel c f = forever $ f >>= atomically . writeChannel c
diff --git a/lib/Control/Concurrent/Channel/Endless/Split.hs b/lib/Control/Concurrent/Channel/Endless/Split.hs
new file mode 100644
--- /dev/null
+++ b/lib/Control/Concurrent/Channel/Endless/Split.hs
@@ -0,0 +1,96 @@
+-- | "Control.Concurrent.Channel.Endless" with newtypes for producer and consumer sides.
+module Control.Concurrent.Channel.Endless.Split(
+    Reader (..),
+    Writer (..),
+    TBQReader,
+    TBQWriter,
+    TMVReader,
+    TMVWriter,
+
+    split,
+    readChannel,
+    drainChannel,
+    writeChannel,
+    overwriteChannel,
+    evalWriteChannel,
+    evalOverwriteChannel,
+    consumeChannel,
+    consumeChannelBatches,
+    consumeChannelBatches',
+    stateConsumeChannel,
+    stateConsumeChannelBatches,
+    stateConsumeChannelBatches',
+    feedChannel,
+    evalFeedChannel,
+    pipeline,
+    pipeline_
+) where
+
+import Control.Concurrent.STM
+import Control.Concurrent.Channel.Endless qualified as E
+import Control.DeepSeq
+
+-- | The consumer side of a channel @c@.
+newtype Reader c a = Reader { unReader :: c a }
+
+-- | The producer side of a channel @c@.
+newtype Writer c a = Writer { unWriter :: c a }
+
+-- | Give the producer and consumer sides of the given channel.
+split :: c a -> (Writer c a, Reader c a)
+split c = (Writer c, Reader c)
+
+type TBQReader = Reader TBQueue
+type TBQWriter = Writer TBQueue
+type TMVReader = Reader TMVar
+type TMVWriter = Writer TMVar
+
+readChannel :: (E.Channel c) => Reader c a -> STM a
+readChannel = E.readChannel . unReader
+
+drainChannel :: (E.Channel c) => Reader c a -> STM [a]
+drainChannel = E.drainChannel . unReader
+
+writeChannel :: (E.Channel c) => Writer c a -> a -> STM ()
+writeChannel = E.writeChannel . unWriter
+
+overwriteChannel :: (E.Channel c) => Writer c a -> a -> STM (Maybe a)
+overwriteChannel = E.overwriteChannel . unWriter
+
+evalWriteChannel :: (E.Channel c, NFData a) => Writer c a -> a -> IO ()
+evalWriteChannel = E.evalWriteChannel . unWriter
+
+evalOverwriteChannel :: (E.Channel c, NFData a) => Writer c a -> a -> IO (Maybe a)
+evalOverwriteChannel = E.evalOverwriteChannel . unWriter
+
+consumeChannel :: (E.Channel c) => Reader c a -> (a -> IO ()) -> IO ()
+consumeChannel = E.consumeChannel . unReader
+
+consumeChannelBatches :: (E.Channel c) => Reader c a -> ([a] -> IO ()) -> IO ()
+consumeChannelBatches = E.consumeChannelBatches . unReader
+
+consumeChannelBatches' :: (E.Channel c) => Reader c a -> (a -> IO ()) -> IO ()
+consumeChannelBatches' = E.consumeChannelBatches' . unReader
+
+stateConsumeChannel :: (E.Channel c) => Reader c a -> s -> (s -> a -> IO s) -> IO ()
+stateConsumeChannel = E.stateConsumeChannel . unReader
+
+stateConsumeChannelBatches :: (E.Channel c) => Reader c a -> s -> (s -> [a] -> IO s) -> IO ()
+stateConsumeChannelBatches = E.stateConsumeChannelBatches . unReader
+
+stateConsumeChannelBatches' :: (E.Channel c) => Reader c a -> s -> (s -> a -> IO s) -> IO ()
+stateConsumeChannelBatches' = E.stateConsumeChannelBatches' . unReader
+
+feedChannel :: (E.Channel c) => Writer c a -> IO a -> IO ()
+feedChannel = E.feedChannel . unWriter
+
+evalFeedChannel :: (E.Channel c, NFData a) => Writer c a -> IO a -> IO ()
+evalFeedChannel = E.evalFeedChannel . unWriter
+
+-- | Create a channel with the given action,
+-- then give its writer to the producer and its reader to the consumer.
+pipeline :: IO (c a) -> (Writer c a -> IO x) -> (Reader c a -> IO y) -> IO (x, y)
+pipeline new producer consumer = E.pipeline new (producer . Writer) (consumer . Reader)
+
+pipeline_ :: IO (c a) -> (Writer c a -> IO x) -> (Reader c a -> IO y) -> IO ()
+pipeline_ new producer consumer = E.pipeline_ new (producer . Writer) (consumer . Reader)
diff --git a/lib/Control/Concurrent/Channel/Metrics.hs b/lib/Control/Concurrent/Channel/Metrics.hs
new file mode 100644
--- /dev/null
+++ b/lib/Control/Concurrent/Channel/Metrics.hs
@@ -0,0 +1,172 @@
+-- |
+-- Stability : experimental
+--
+-- Wrappers around "Control.Concurrent.Channel.Split" that gather metrics
+-- at handoffs between threads.
+module Control.Concurrent.Channel.Metrics (
+    ReaderMetrics(..),
+    newReaderMetrics,
+    readChannel,
+    drainChannel,
+    WriterMetrics(..),
+    newWriterMetrics,
+    writeChannel,
+    overwriteChannel,
+    consumeChannel,
+    consumeChannelBatches,
+    consumeChannelBatches',
+    stateConsumeChannel,
+    stateConsumeChannelBatches,
+    stateConsumeChannelBatches',
+    feedChannel,
+    evalFeedChannel
+) where
+
+import Control.Concurrent.Async
+import Control.Concurrent.STM
+import Control.DeepSeq
+import Control.Exception (evaluate)
+import Control.Monad
+import Data.Functor ((<&>))
+import Data.IORef
+import Data.Maybe
+import Data.Word
+import System.Clock.Seconds
+
+import Control.Concurrent.Channel qualified as C
+import Control.Concurrent.Channel.Overwrite
+import Control.Concurrent.Channel.Split (Reader, Writer)
+import Control.Concurrent.Channel.Split qualified as CS
+import Control.Concurrent.Channel.Try
+
+data ReaderMetrics = ReaderMetrics {
+    elapsedWait :: !Seconds,
+    totalRead :: !Word64,
+    waitedFor :: !Word64
+}
+
+newReaderMetrics :: ReaderMetrics
+newReaderMetrics = ReaderMetrics 0 0 0
+
+mlen :: Maybe a -> Word64
+mlen j = if isJust j then 1 else 0
+
+delayedReader :: Word64 -> Seconds -> ReaderMetrics -> ReaderMetrics
+delayedReader n dt m = if wasFirst then m1 else mrest where
+    wasFirst = m.totalRead == 0
+    -- Don't count blocking for the first item against our wait.
+    m1 = ReaderMetrics{elapsedWait = 0, totalRead = n, waitedFor = 0}
+    mrest = m{
+        elapsedWait = m.elapsedWait + dt,
+        totalRead = m.totalRead + n,
+        waitedFor = m.waitedFor + n
+        }
+
+readChannel :: (C.Channel c) => Reader c a -> ReaderMetrics -> IO (Maybe a, ReaderMetrics)
+readChannel r !m = timedAtomically (CS.readChannel r) <&> \case
+    (v, Nothing) -> (v, m{totalRead = m.totalRead + mlen v})
+    (v, Just dt) -> (v, delayedReader (mlen v) dt m)
+
+wlen :: [a] -> Word64
+wlen vs = fromIntegral $ length vs
+
+drainChannel :: (C.Channel c) => Reader c a -> ReaderMetrics -> IO ([a], ReaderMetrics)
+drainChannel r !m = timedAtomically (CS.drainChannel r) <&> \case
+    (vs, Nothing) -> (vs, m{totalRead = m.totalRead + wlen vs})
+    (vs, Just dt) -> (vs, delayedReader (wlen vs) dt m)
+
+data WriterMetrics = WriterMetrics {
+    elapsedBlocked :: !Seconds,
+    totalWritten :: !Word64,
+    wereBlocked :: !Word64,
+    totalOverwritten :: !Word64
+}
+
+newWriterMetrics :: WriterMetrics
+newWriterMetrics = WriterMetrics 0 0 0 0
+
+-- Substantially simpler than `delayedReader` since a channel presumably never starts blocked,
+-- so we don't have to ignore the first guy.
+delayedWriter :: Seconds -> WriterMetrics -> WriterMetrics
+delayedWriter dt m = m{
+    elapsedBlocked = m.elapsedBlocked + dt,
+    totalWritten = m.totalWritten + 1,
+    wereBlocked = m.wereBlocked + 1
+    }
+
+writeChannel :: (C.Channel c) => Writer c a -> a -> WriterMetrics -> IO (Bool, WriterMetrics)
+writeChannel w v !m = timedAtomically (CS.writeChannel w v) <&> \case
+    (True, Nothing) -> (True, m{totalWritten = m.totalWritten + 1})
+    (True, Just dt) -> (True, delayedWriter dt m)
+    (False, Nothing) -> (False, m)
+    (False, Just dt) -> (False, m{elapsedBlocked = m.elapsedBlocked + dt})
+
+overwriteChannel :: (C.Channel c) => Writer c a -> a -> WriterMetrics -> STM (OverwriteResult a, WriterMetrics)
+overwriteChannel w v !m = CS.overwriteChannel w v <&> \case
+    Closed -> (Closed, m)
+    Wrote -> (Wrote, m{totalWritten = m.totalWritten + 1})
+    o@(Overwrote _) -> (o, m{
+        totalWritten = m.totalWritten + 1,
+        totalOverwritten = m.totalOverwritten + 1
+        })
+
+consumeChannel :: (C.Channel c) => Reader c a -> (a -> IO ()) -> IO ReaderMetrics
+consumeChannel r f = go newReaderMetrics where
+    go :: ReaderMetrics -> IO ReaderMetrics
+    go !m = readChannel r m >>= \case
+        (Just v, m') -> f v >> go m'
+        (Nothing, m') -> pure m'
+
+consumeChannelBatches :: (C.Channel c) => Reader c a -> ([a] -> IO ()) -> IO ReaderMetrics
+consumeChannelBatches r f = go newReaderMetrics where
+    go :: ReaderMetrics -> IO ReaderMetrics
+    go !m = drainChannel r m >>= \case
+        ([], m') -> pure m'
+        (vs, m') -> f vs >> go m'
+
+consumeChannelBatches' :: (C.Channel c) => Reader c a -> (a -> IO ()) -> IO ReaderMetrics
+consumeChannelBatches' r f = consumeChannelBatches r $ mapM_ f
+
+stateConsumeChannel :: forall a c s. (C.Channel c) => Reader c a -> s -> (s -> a -> IO s) -> IO (s, ReaderMetrics)
+stateConsumeChannel r initialState f = go initialState newReaderMetrics where
+    go :: s -> ReaderMetrics -> IO (s, ReaderMetrics)
+    go !state !m = readChannel r m >>= \case
+        (Just v, m') -> do
+            next <- f state v
+            go next m'
+        (Nothing, m') -> pure (state, m')
+
+stateConsumeChannelBatches :: forall a c s. (C.Channel c) => Reader c a -> s -> (s -> [a] -> IO s) -> IO (s, ReaderMetrics)
+stateConsumeChannelBatches r initialState f = go initialState newReaderMetrics where
+    go :: s -> ReaderMetrics -> IO (s, ReaderMetrics)
+    go !state !m = drainChannel r m >>= \case
+        ([], m') -> pure (state, m')
+        (vs, m') -> do
+            next <- f state vs
+            go next m'
+
+stateConsumeChannelBatches' :: (C.Channel c) => Reader c a -> s -> (s -> a -> IO s) -> IO (s, ReaderMetrics)
+stateConsumeChannelBatches' r initialState f = stateConsumeChannelBatches r initialState $ foldM (\ !s v -> f s v)
+
+feedChannel' :: (C.Channel c) => Writer c a -> IO (Maybe a) -> IORef WriterMetrics -> IO ()
+feedChannel' w f mr = f >>= \case
+    Just v -> do
+        m <- readIORef mr
+        (stillOpen, m') <- writeChannel w v m
+        writeIORef mr m'
+        when stillOpen $ feedChannel' w f mr
+    Nothing -> atomically $ CS.closeChannel w
+
+feedChannel :: (C.Channel c) => Writer c a -> IO (Maybe a) -> IO WriterMetrics
+feedChannel w f = do
+    -- Stop when the consumer closes the channel, even if f blocks.
+    -- For example, f can block for a long time on a network socket.
+    let chanClosed = atomically $ CS.isClosedChannel w >>= check
+    mr <- newIORef newWriterMetrics
+    race_ (feedChannel' w f mr) chanClosed
+    readIORef mr
+
+evalFeedChannel :: (C.Channel c, NFData a) => Writer c a -> IO (Maybe a) -> IO WriterMetrics
+evalFeedChannel w f = feedChannel w f' where
+    f' = f >>= evaluate . force
+{-# INLINE evalFeedChannel #-}
diff --git a/lib/Control/Concurrent/Channel/Overwrite.hs b/lib/Control/Concurrent/Channel/Overwrite.hs
new file mode 100644
--- /dev/null
+++ b/lib/Control/Concurrent/Channel/Overwrite.hs
@@ -0,0 +1,4 @@
+module Control.Concurrent.Channel.Overwrite where
+
+data OverwriteResult a = Wrote | Overwrote a | Closed
+    deriving stock (Show, Eq, Foldable, Functor, Traversable)
diff --git a/lib/Control/Concurrent/Channel/Split.hs b/lib/Control/Concurrent/Channel/Split.hs
new file mode 100644
--- /dev/null
+++ b/lib/Control/Concurrent/Channel/Split.hs
@@ -0,0 +1,142 @@
+-- | "Control.Concurrent.Channel" with newtypes for producer and consumer sides.
+module Control.Concurrent.Channel.Split(
+    Reader (..),
+    Writer (..),
+    TBCQReader,
+    TBCQWriter,
+    TCSReader,
+    TCSWriter,
+    End (..),
+    C.OverwriteResult (..),
+
+    split,
+    closeChannel,
+    isClosedChannel,
+    isEmptyChannel,
+    isFullChannel,
+    readChannel,
+    drainChannel,
+    writeChannel,
+    overwriteChannel,
+    writeChannel',
+    evalWriteChannel,
+    evalWriteChannel',
+    overwriteChannel',
+    evalOverwriteChannel,
+    evalOverwriteChannel',
+    consumeChannel,
+    consumeChannelBatches,
+    consumeChannelBatches',
+    stateConsumeChannel,
+    stateConsumeChannelBatches,
+    stateConsumeChannelBatches',
+    feedChannel,
+    evalFeedChannel,
+    pipeline,
+    pipeline_
+) where
+
+import Control.Concurrent.STM
+import Control.Concurrent.Channel qualified as C
+import Control.Concurrent.TBCQueue
+import Control.Concurrent.TCSlot
+import Control.DeepSeq
+
+-- | The consumer side of a channel @c@.
+newtype Reader c a = Reader { unReader :: c a }
+
+-- | The producer side of a channel @c@.
+newtype Writer c a = Writer { unWriter :: c a }
+
+-- | Give the producer and consumer sides of the given channel.
+split :: c a -> (Writer c a, Reader c a)
+split c = (Writer c, Reader c)
+
+type TBCQReader = Reader TBCQueue
+type TBCQWriter = Writer TBCQueue
+type TCSReader = Reader TCSlot
+type TCSWriter = Writer TCSlot
+
+-- | Operations that either side of a channel can do.
+class End e where
+    unEnd :: e c a -> c a
+
+instance End Reader where
+    unEnd = unReader
+
+instance End Writer where
+    unEnd = unWriter
+
+closeChannel :: (End e, C.Channel c) => e c a -> STM ()
+closeChannel = C.closeChannel . unEnd
+
+isClosedChannel :: (End e, C.Channel c) => e c a -> STM Bool
+isClosedChannel = C.isClosedChannel . unEnd
+
+isEmptyChannel :: (End e, C.Channel c) => e c a -> STM Bool
+isEmptyChannel = C.isEmptyChannel . unEnd
+
+isFullChannel :: (End e, C.Channel c) => e c a -> STM Bool
+isFullChannel = C.isFullChannel . unEnd
+
+readChannel :: (C.Channel c) => Reader c a -> STM (Maybe a)
+readChannel = C.readChannel . unReader
+
+drainChannel :: (C.Channel c) => Reader c a -> STM [a]
+drainChannel = C.drainChannel . unReader
+
+writeChannel :: (C.Channel c) => Writer c a -> a -> STM Bool
+writeChannel = C.writeChannel . unWriter
+
+overwriteChannel :: (C.Channel c) => Writer c a -> a -> STM (C.OverwriteResult a)
+overwriteChannel = C.overwriteChannel . unWriter
+
+writeChannel' :: (C.Channel c) => Writer c a -> a -> STM ()
+writeChannel' = C.writeChannel' . unWriter
+
+evalWriteChannel :: (C.Channel c, NFData a) => Writer c a -> a -> IO Bool
+evalWriteChannel = C.evalWriteChannel . unWriter
+
+evalWriteChannel' :: (C.Channel c, NFData a) => Writer c a -> a -> IO ()
+evalWriteChannel' = C.evalWriteChannel' . unWriter
+
+overwriteChannel' :: (C.Channel c) => Writer c a -> a -> STM (Maybe a)
+overwriteChannel' = C.overwriteChannel' . unWriter
+
+evalOverwriteChannel :: (C.Channel c, NFData a) => Writer c a -> a -> IO (C.OverwriteResult a)
+evalOverwriteChannel = C.evalOverwriteChannel . unWriter
+
+evalOverwriteChannel' :: (C.Channel c, NFData a) => Writer c a -> a -> IO (Maybe a)
+evalOverwriteChannel' = C.evalOverwriteChannel' . unWriter
+
+consumeChannel :: (C.Channel c) => Reader c a -> (a -> IO ()) -> IO ()
+consumeChannel = C.consumeChannel . unReader
+
+consumeChannelBatches :: (C.Channel c) => Reader c a -> ([a] -> IO ()) -> IO ()
+consumeChannelBatches = C.consumeChannelBatches . unReader
+
+consumeChannelBatches' :: (C.Channel c) => Reader c a -> (a -> IO ()) -> IO ()
+consumeChannelBatches' = C.consumeChannelBatches' . unReader
+
+stateConsumeChannel :: (C.Channel c) => Reader c a -> s -> (s -> a -> IO s) -> IO s
+stateConsumeChannel = C.stateConsumeChannel . unReader
+
+stateConsumeChannelBatches :: (C.Channel c) => Reader c a -> s -> (s -> [a] -> IO s) -> IO s
+stateConsumeChannelBatches = C.stateConsumeChannelBatches . unReader
+
+stateConsumeChannelBatches' :: (C.Channel c) => Reader c a -> s -> (s -> a -> IO s) -> IO s
+stateConsumeChannelBatches' = C.stateConsumeChannelBatches' . unReader
+
+feedChannel :: (C.Channel c) => Writer c a -> IO (Maybe a) -> IO ()
+feedChannel = C.feedChannel . unWriter
+
+evalFeedChannel :: (C.Channel c, NFData a) => Writer c a -> IO (Maybe a) -> IO ()
+evalFeedChannel = C.evalFeedChannel . unWriter
+
+-- | Create a channel with the given action,
+-- then give its writer to the producer and its reader to the consumer.
+pipeline :: (C.Channel c) => IO (c a) -> (Writer c a -> IO x) -> (Reader c a -> IO y) -> IO (x, y)
+pipeline new producer consumer = C.pipeline new (producer . Writer) (consumer . Reader)
+
+pipeline_ :: (C.Channel c) => IO (c a) -> (Writer c a -> IO x) -> (Reader c a -> IO y) -> IO ()
+pipeline_ new producer consumer = C.pipeline_ new (producer . Writer) (consumer . Reader)
diff --git a/lib/Control/Concurrent/Channel/Try.hs b/lib/Control/Concurrent/Channel/Try.hs
new file mode 100644
--- /dev/null
+++ b/lib/Control/Concurrent/Channel/Try.hs
@@ -0,0 +1,25 @@
+module Control.Concurrent.Channel.Try where
+
+import Control.Concurrent.STM
+import System.Clock.Seconds
+
+data Tried a = Done a | Blocked
+    deriving stock (Show, Eq, Foldable, Functor, Traversable)
+
+-- | Attempt any STM action, returning immediately with @Blocked@ if it retries.
+try :: STM a -> STM (Tried a)
+try s = fmap Done s `orElse` pure Blocked
+{-# INLINE try #-}
+
+-- | Run the STM action, and give the time that it blocked, if it blocked.
+--
+-- Transactions can't detect their own retry without unsafeIOToSTM horrors,
+-- so blocked transactions need to run again after getting the time.
+timedAtomically :: STM a -> IO (a, Maybe Seconds)
+timedAtomically s = atomically (try s) >>= \case
+    Done v -> pure (v, Nothing)
+    Blocked -> do
+        t1 <- getTime Monotonic
+        v <- atomically s
+        t2 <- getTime Monotonic
+        pure (v, Just (t2 - t1))
diff --git a/lib/Control/Concurrent/TBCQueue.hs b/lib/Control/Concurrent/TBCQueue.hs
--- a/lib/Control/Concurrent/TBCQueue.hs
+++ b/lib/Control/Concurrent/TBCQueue.hs
@@ -4,13 +4,18 @@
     newTBCQueue,
     newTBCQueueIO,
     readTBCQueue,
+    drainTBCQueue,
     writeTBCQueue,
+    overwriteTBCQueue,
     closeTBCQueue,
     isOpenTBCQueue,
     isClosedTBCQueue,
+    isEmptyTBCQueue,
+    isFullTBCQueue,
     lengthTBCQueue
 ) where
 
+import Control.Concurrent.Channel.Overwrite
 import Control.Concurrent.STM
 import Control.Monad
 import Numeric.Natural
@@ -26,19 +31,29 @@
 newTBCQueueIO :: Natural -> IO (TBCQueue a)
 newTBCQueueIO = atomically . newTBCQueue
 
--- | Returns @Just value@ until the queue is closed, blocking for the next value.
+-- | Reads from the queue, blocking if empty,
+-- and returning @Nothing@ once it is empty and closed.
 readTBCQueue :: TBCQueue a -> STM (Maybe a)
-readTBCQueue c = do
-    mv <- tryReadTBQueue c.q
-    case mv of
-        Just v -> pure $ Just v
-        Nothing -> do
+readTBCQueue c = tryReadTBQueue c.q >>= \case
+    Just v -> pure $ Just v
+    Nothing -> do
+        stillOpen <- readTVar c.open
+        if stillOpen
+            then retry
+            else pure Nothing
+
+drainTBCQueue :: TBCQueue a -> STM [a]
+drainTBCQueue c = do
+    f <- flushTBQueue c.q
+    if null f
+        then do
             stillOpen <- readTVar c.open
             if stillOpen
                 then retry
-                else pure Nothing
+                else pure []
+        else pure f
 
--- | Writes the given value to the queue if it's still open.
+-- | Writes the given value to the queue if it's still open, blocking if full.
 --
 -- Returns whether the queue is still open so producers know when consumers no longer care.
 writeTBCQueue :: TBCQueue a -> a -> STM Bool
@@ -47,6 +62,22 @@
     when stillOpen $ writeTBQueue c.q v
     pure stillOpen
 
+overwriteTBCQueue :: TBCQueue a -> a -> STM (OverwriteResult a)
+overwriteTBCQueue c !v = do
+    stillOpen <- readTVar c.open
+    if stillOpen
+        then do
+            wasFull <- isFullTBQueue c.q
+            if wasFull
+                then do
+                    o <- readTBQueue c.q
+                    writeTBQueue c.q v
+                    pure $ Overwrote o
+                else do
+                    writeTBQueue c.q v
+                    pure Wrote
+        else pure Closed
+
 -- | Closes the queue so that future writes are no-ops and readers get @Nothing@
 -- after all values currently inside have been read.
 closeTBCQueue :: TBCQueue a -> STM ()
@@ -57,6 +88,12 @@
 
 isClosedTBCQueue :: TBCQueue a -> STM Bool
 isClosedTBCQueue = fmap not . isOpenTBCQueue
+
+isEmptyTBCQueue :: TBCQueue a -> STM Bool
+isEmptyTBCQueue c = isEmptyTBQueue c.q
+
+isFullTBCQueue :: TBCQueue a -> STM Bool
+isFullTBCQueue c = isFullTBQueue c.q
 
 -- | The number of items currently in the queue.
 --
diff --git a/lib/Control/Concurrent/TCSlot.hs b/lib/Control/Concurrent/TCSlot.hs
new file mode 100644
--- /dev/null
+++ b/lib/Control/Concurrent/TCSlot.hs
@@ -0,0 +1,84 @@
+-- | A /closeable/, single-element STM queue.
+--
+-- Identical to @TBCQueue@ but has a max length of 1.
+-- Helpful when you want to minimize latency,
+-- and has simpler ops since values are just held in a @TVar (Maybe a)@.
+module Control.Concurrent.TCSlot(
+    TCSlot,
+    newTCSlot,
+    newTCSlotIO,
+    readTCSlot,
+    writeTCSlot,
+    overwriteTCSlot,
+    closeTCSlot,
+    isOpenTCSlot,
+    isClosedTCSlot,
+    isEmptyTCSlot,
+    isFullTCSlot,
+) where
+
+import Control.Concurrent.Channel.Overwrite
+import Control.Concurrent.STM
+import Control.Monad
+import Data.Maybe (isNothing)
+
+
+data TCSlot a = TCSlot {
+    slot :: TVar (Maybe a),
+    open :: TVar Bool
+    }
+
+newTCSlot :: STM (TCSlot a)
+newTCSlot = TCSlot <$> newTVar Nothing <*> newTVar True
+
+newTCSlotIO :: IO (TCSlot a)
+newTCSlotIO = atomically newTCSlot
+
+readTCSlot :: TCSlot a -> STM (Maybe a)
+readTCSlot c = readTVar c.slot >>= \case
+    Just v -> do
+        writeTVar c.slot Nothing
+        pure $ Just v
+    Nothing -> do
+        stillOpen <- readTVar c.open
+        if stillOpen
+            then retry
+            else pure Nothing
+
+writeTCSlot :: TCSlot a -> a -> STM Bool
+writeTCSlot c !v = do
+    stillOpen <- readTVar c.open
+    when stillOpen $ do
+        check . isNothing =<< readTVar c.slot
+        writeTVar c.slot $ Just v
+    pure stillOpen
+
+overwriteTCSlot :: TCSlot a -> a -> STM (OverwriteResult a)
+overwriteTCSlot c !v = do
+    stillOpen <- readTVar c.open
+    if stillOpen
+        then readTVar c.slot >>= \case
+            Just o -> do
+                writeTVar c.slot $ Just v
+                pure $ Overwrote o
+            Nothing -> do
+                writeTVar c.slot $ Just v
+                pure Wrote
+        else pure Closed
+
+closeTCSlot :: TCSlot a -> STM  ()
+closeTCSlot c = writeTVar c.open False
+
+isOpenTCSlot :: TCSlot a -> STM Bool
+isOpenTCSlot c = readTVar c.open
+
+isClosedTCSlot :: TCSlot a -> STM Bool
+isClosedTCSlot = fmap not . isOpenTCSlot
+
+isEmptyTCSlot :: TCSlot a -> STM Bool
+isEmptyTCSlot = fmap not . isFullTCSlot
+
+isFullTCSlot :: TCSlot a -> STM Bool
+isFullTCSlot c = readTVar c.slot >>= \case
+    Just _ -> pure True
+    Nothing -> pure False
