diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,23 @@
 # Revision history for lossy-chan
 
+## 0.2.0.0 -- 2026-11-19
+
+* Change type of `new` to `Word8 -> IO (InChan a, OutChan a)`.
+
+  This change was made to reflect the fact that the channel ring buffer uses
+  a `SmallArray` and therefore the buffer length should not be much bigger than
+  128. This is now reflected in the argument type.
+
+* Fix issue where `NoInChanError` was raised early.
+
+  In previous versions, `receive` and `tryReceive` would raise `NoInChanError`
+  if no live code path could call `out`. This was due to an error where the
+  value used for liveness testing was stored in the `InChan` separately from
+  the channel ring buffer and was only used in `out`. Hence, if no live code
+  path could call `out`, the value used for liveness would be garbage collected
+  and `receive` and `tryReceive` would erroneously raise `NoInChanError` if
+  they caught up with the input channel.
+
 ## 0.1.1.0 -- 2026-11-12
 
 * Support creating a new output channel from the input channel.
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -103,52 +103,11 @@
 
 The time benchmark, created using `criterion`, shows that a `lossy-chan` channel is roughly as fast as an `unagi-chan` channel, and both are significantly faster than the `base` and `stm` channels. Moreover, the buffer size doesn't appear to significanly affect the performance of a `lossy-chan` channel.
 
-![Benchmark that compares lossy-chan with unagi-chan.](https://github.com/well-typed/lossy-chan/blob/ed2abb0ee3b55a549fce7f466f6a872c4bc6ec25/assets/benchmark.png?raw=true)
+![Benchmark that compares run-time for lossy-chan with base, stm, and unagi-chan.](https://github.com/well-typed/lossy-chan/blob/bb868200a8dd6dfe7af5da810fa6f0308a79bb77/assets/lossy-chan-benchmark-time-2026-11-19.png?raw=true)
 
 ### Space
 
-The space benchmark, created using `weigh`, shows that a `lossy-chan` channel has much lower maximum residency when compared to the other channel implementations, and that its maximum residency scales with the buffer size. This is expected from the use of a ring buffer.
-
+The space benchmark, created using `weigh`, shows that a `lossy-chan` channel has much lower maximum residency when compared to the other channel implementations – so much so, that it had to be rendered in a separate plot.
+Moreover, `lossy-chan`'s maximum residency scales up with the buffer size, as expected from the use of a ring buffer.
 
-| Benchmark        | Case                   |  Allocated | Max Residency |
-| :--------------- | :--------------------- | ---------: | ------------: |
-| `base`           | 1 senders, 1 receivers | 25,604,448 |     8,348,840 |
-|                  | 2 senders, 2 receivers | 51,208,176 |    12,275,048 |
-|                  | 3 senders, 3 receivers | 76,811,928 |    16,699,824 |
-|                  | 4 senders, 4 receivers | 96,154,064 |    24,617,800 |
-| `stm`            | 1 senders, 1 receivers | 16,805,400 |     8,830,408 |
-|                  | 2 senders, 2 receivers | 33,609,720 |     9,845,000 |
-|                  | 3 senders, 3 receivers | 50,414,848 |    14,717,096 |
-|                  | 4 senders, 4 receivers | 55,414,888 |    17,660,312 |
-| `unagi-chan`     | 1 senders, 1 receivers | 18,439,984 |     4,540,792 |
-|                  | 2 senders, 2 receivers | 36,862,432 |     4,541,464 |
-|                  | 3 senders, 3 receivers | 55,277,096 |    10,573,080 |
-|                  | 4 senders, 4 receivers | 73,698,768 |    10,573,984 |
-| `lossy-chan-2`   | 1 senders, 1 receivers | 12,008,624 |         3,088 |
-|                  | 2 senders, 2 receivers | 24,013,384 |         4,960 |
-|                  | 3 senders, 3 receivers | 36,018,184 |         6,816 |
-|                  | 4 senders, 4 receivers | 48,021,576 |         8,672 |
-| `lossy-chan-4`   | 1 senders, 1 receivers | 12,008,928 |         3,168 |
-|                  | 2 senders, 2 receivers | 24,014,392 |         5,040 |
-|                  | 3 senders, 3 receivers | 36,018,456 |         6,896 |
-|                  | 4 senders, 4 receivers | 48,021,664 |         8,752 |
-| `lossy-chan-8`   | 1 senders, 1 receivers | 12,009,536 |         3,328 |
-|                  | 2 senders, 2 receivers | 24,015,448 |         5,200 |
-|                  | 3 senders, 3 receivers | 36,019,056 |         7,056 |
-|                  | 4 senders, 4 receivers | 48,024,952 |         8,912 |
-| `lossy-chan-16`  | 1 senders, 1 receivers | 12,010,472 |         3,648 |
-|                  | 2 senders, 2 receivers | 24,017,080 |         5,520 |
-|                  | 3 senders, 3 receivers | 36,019,840 |         7,376 |
-|                  | 4 senders, 4 receivers | 48,028,224 |         9,232 |
-| `lossy-chan-32`  | 1 senders, 1 receivers | 12,011,728 |         4,288 |
-|                  | 2 senders, 2 receivers | 24,017,720 |         6,160 |
-|                  | 3 senders, 3 receivers | 36,028,936 |         8,016 |
-|                  | 4 senders, 4 receivers | 48,037,104 |         9,872 |
-| `lossy-chan-64`  | 1 senders, 1 receivers | 12,014,464 |         5,568 |
-|                  | 2 senders, 2 receivers | 24,030,232 |         7,440 |
-|                  | 3 senders, 3 receivers | 36,041,456 |         9,296 |
-|                  | 4 senders, 4 receivers | 48,067,576 |        11,152 |
-| `lossy-chan-128` | 1 senders, 1 receivers | 12,021,448 |         8,128 |
-|                  | 2 senders, 2 receivers | 24,047,128 |        10,000 |
-|                  | 3 senders, 3 receivers | 36,065,520 |        11,856 |
-|                  | 4 senders, 4 receivers | 48,083,512 |        13,712 |
+![Benchmark that compares heap usage for lossy-chan with base, stm, and unagi-chan.](https://github.com/well-typed/lossy-chan/blob/bb868200a8dd6dfe7af5da810fa6f0308a79bb77/assets/lossy-chan-benchmark-space-2026-11-19.png?raw=true)
diff --git a/benchmark/Benchmark/Chan.hs b/benchmark/Benchmark/Chan.hs
--- a/benchmark/Benchmark/Chan.hs
+++ b/benchmark/Benchmark/Chan.hs
@@ -18,7 +18,7 @@
 import Control.Concurrent.STM.TChan qualified as STM
 import Control.Monad.STM (atomically)
 import Data.Kind (Type)
-import Data.Word (Word32)
+import Data.Word (Word8)
 
 {- |
 An abstraction over channel libraries.
@@ -34,7 +34,7 @@
 {- |
 The `Chan` instance for @lossy-chan@.
 -}
-lossyChan :: Word32 -> Chan LC.InChan LC.OutChan
+lossyChan :: Word8 -> Chan LC.InChan LC.OutChan
 lossyChan len =
   MkChan
     { new = LC.new len
diff --git a/benchmark/space.hs b/benchmark/space.hs
--- a/benchmark/space.hs
+++ b/benchmark/space.hs
@@ -15,7 +15,7 @@
 main = do
   mainWith $ do
     setColumns [Case, Allocated, Max]
-    setFormat Markdown
+    setFormat Plain
     wgroup "base" $
       for_ [1 .. 4] $ \s ->
         weighChanWith baseChan s s
diff --git a/lossy-chan.cabal b/lossy-chan.cabal
--- a/lossy-chan.cabal
+++ b/lossy-chan.cabal
@@ -1,6 +1,6 @@
 cabal-version: 3.0
 name: lossy-chan
-version: 0.1.1.0
+version: 0.2.0.0
 synopsis: Fast, bounded, and lossy broadcast channels backed by a ring buffer
 description: Fast, bounded, and /lossy/ broadcast channels backed by a ring buffer.
 license: BSD-3-Clause
@@ -61,6 +61,7 @@
   main-is: Main.hs
   build-depends:
     base >=4.16 && <5,
+    heapsize,
     lossy-chan,
     tasty,
     tasty-hunit,
diff --git a/src/Control/Concurrent/LossyChan.hs b/src/Control/Concurrent/LossyChan.hs
--- a/src/Control/Concurrent/LossyChan.hs
+++ b/src/Control/Concurrent/LossyChan.hs
@@ -16,10 +16,13 @@
 
 import Control.Exception (Exception (..), mask_)
 import Control.Monad (when)
+import Data.Functor (void)
+import Data.IORef (IORef, mkWeakIORef, newIORef, readIORef)
+import Data.Word (Word32, Word8)
 import GHC.Conc (STM (..), TVar (..), atomically, newTVar, newTVarIO, orElse, readTVar, retry, throwSTM, writeTVar)
-import GHC.Exts (Int#, MutVar#, RealWorld, SmallArray#, State#, TVar#, Weak#, Word32#, deRefWeak#, indexSmallArray#, isTrue#, mkWeak#, newMutVar#, newSmallArray#, newTVar#, readTVar#, unsafeFreezeSmallArray#, word2Int#, word32ToWord#, writeSmallArray#, writeTVar#, (+#), (==#))
+import GHC.Exts (Int#, RealWorld, SmallArray#, State#, TVar#, Word8#, indexSmallArray#, isTrue#, mkWeak#, newSmallArray#, newTVar#, readTVar#, unsafeFreezeSmallArray#, word2Int#, word8ToWord#, writeSmallArray#, writeTVar#, (+#), (==#))
 import GHC.IO (IO (..))
-import GHC.Word (Word32 (..))
+import GHC.Word (Word8 (..))
 
 #ifdef LOSSY_CHAN_SMALL_LOOP_COUNTER
 -- If the small-loop-counter flag is set, use Word8.
@@ -27,7 +30,7 @@
 
 type LoopCounter = Word8
 #else
--- Otherwise, use Word32.
+-- Otherwise, use Word8.
 type LoopCounter = Word32
 #endif
 
@@ -47,28 +50,47 @@
   will treat its current position as live, which may cause it to skip some of
   the messages in the buffer.
   -}
-  , next :: {-# UNPACK #-} !Word32
+  , next :: {-# UNPACK #-} !Word8
   {- ^
   This value tracks the next position that should be read (for receivers) or
   written to (for senders).
   -}
+  , done :: {-# UNPACK #-} !Word8
+  {- ^
+  This value tracks whether or not the `InChan` is connected.
+
+  If the value is @0@, the `InChan` is live. Otherwise, it was garbage collected.
+  -}
   }
-  deriving (Eq, Show)
+  deriving (Show)
 
 {- |
 The initial position in a channel ring buffer.
 -}
 zero :: ChanPos
-zero = MkChanPos{loop = 0, next = 0}
+zero = MkChanPos{done = 0, loop = 0, next = 0}
 {-# INLINE zero #-}
 
 {- |
+Check whether two `ChanPos` are at the same position.
+-}
+eqPos :: ChanPos -> ChanPos -> Bool
+eqPos icPos ocPos =
+  loop icPos == loop ocPos && next icPos == next ocPos
+
+{- |
+Check whether the input channel `ChanPos` is done.
+-}
+isDone :: ChanPos -> Bool
+isDone icPos = done icPos >= 1
+
+{- |
 Advance to the next channel position.
 -}
-advance :: Word32# -> ChanPos -> ChanPos
+advance :: Word8# -> ChanPos -> ChanPos
 advance len# MkChanPos{..}
-  | next < W32# len# - 1 = MkChanPos{next = next + 1, ..}
-  | otherwise = MkChanPos{loop = loop + 1, next = 0}
+  | next < W8# len# - 1 = MkChanPos{next = next + 1, ..}
+  | otherwise = MkChanPos{loop = loop + 1, next = 0, ..}
 {-# INLINE advance #-}
 
 {- |
@@ -83,7 +105,7 @@
   -- position is aheaad of the input channel.
   | loop ocPos == loop icPos - 1 && next ocPos >= next icPos = ocPos
   -- The output channel is several loops behind the input channel.
-  | otherwise = icPos{loop = loop icPos - 1}
+  | otherwise = ocPos{loop = loop icPos - 1, next = next icPos}
 {-# INLINE live #-}
 
 data Entry a
@@ -98,7 +120,7 @@
 unpack the @TVar@ inside of a @SmallArray@.
 -}
 data ChanBuf a = MkChanBuf
-  { len# :: Word32#
+  { len# :: Word8#
   -- ^ The length of the channel ring buffer.
   , arr# :: SmallArray# (TVar# RealWorld (Entry a))
   -- ^ The array that backs the channel ring buffer.
@@ -107,13 +129,13 @@
 {- |
 Create a new channel buffer.
 -}
-newChanBuf :: Word32 -> IO (ChanBuf a)
-newChanBuf (W32# len#) = IO $ \s1# ->
-  case word32ToInt# len# of
+newChanBuf :: Word8 -> IO (ChanBuf a)
+newChanBuf (W8# len#) = IO $ \s1# ->
+  case word8ToInt# len# of
     ilen# ->
       case newTVar# Empty s1# of
         (# s2#, var0# #) ->
-          case newSmallArray# (word32ToInt# len#) var0# s2# of
+          case newSmallArray# (word8ToInt# len#) var0# s2# of
             (# s3#, mutarr# #) ->
               let go :: Int# -> State# RealWorld -> State# RealWorld
                   go i# = \s4# ->
@@ -130,10 +152,10 @@
 {- |
 Read the value from the given position in a `ChanBuf`.
 -}
-takeChanBuf :: ChanBuf a -> Word -> Word32 -> STM (Maybe a)
-takeChanBuf MkChanBuf{..} ocCount (W32# i#) =
+takeChanBuf :: ChanBuf a -> Word -> Word8 -> STM (Maybe a)
+takeChanBuf MkChanBuf{..} ocCount (W8# i#) =
   STM $ \s1# ->
-    case indexSmallArray# arr# (word32ToInt# i#) of
+    case indexSmallArray# arr# (word8ToInt# i#) of
       (# vari# #) ->
         case readTVar# vari# s1# of
           (# s2#, Empty #) ->
@@ -149,10 +171,10 @@
 {- |
 Read the value from the given position in a `ChanBuf`.
 -}
-isEmptyChanBuf :: ChanBuf a -> Word32 -> STM Bool
-isEmptyChanBuf MkChanBuf{..} (W32# i#) =
+isEmptyChanBuf :: ChanBuf a -> Word8 -> STM Bool
+isEmptyChanBuf MkChanBuf{..} (W8# i#) =
   STM $ \s1# ->
-    case indexSmallArray# arr# (word32ToInt# i#) of
+    case indexSmallArray# arr# (word8ToInt# i#) of
       (# vari# #) ->
         case readTVar# vari# s1# of
           (# s2#, Empty #) ->
@@ -163,10 +185,10 @@
 {- |
 Write the given value to a `ChanBuf` at the given position.
 -}
-writeChanBuf :: ChanBuf a -> Word32 -> Entry a -> STM ()
-writeChanBuf MkChanBuf{..} (W32# i#) a =
+writeChanBuf :: ChanBuf a -> Word8 -> Entry a -> STM ()
+writeChanBuf MkChanBuf{..} (W8# i#) a =
   STM $ \s1# ->
-    case indexSmallArray# arr# (word32ToInt# i#) of
+    case indexSmallArray# arr# (word8ToInt# i#) of
       (# vari# #) ->
         case writeTVar# vari# a s1# of
           s2# ->
@@ -180,10 +202,10 @@
 This function returns `Just` `True` if the entry was freed, `Just` `False`
 if the entry was not freed, and `Nothing` if the entry was uninitialised.
 -}
-tryFreeChanBufAt :: ChanBuf a -> Word -> Word32 -> STM (Maybe Bool)
-tryFreeChanBufAt MkChanBuf{..} ocCount (W32# i#) =
+tryFreeChanBufAt :: ChanBuf a -> Word -> Word8 -> STM (Maybe Bool)
+tryFreeChanBufAt MkChanBuf{..} ocCount (W8# i#) =
   STM $ \s1# ->
-    case indexSmallArray# arr# (word32ToInt# i#) of
+    case indexSmallArray# arr# (word8ToInt# i#) of
       (# vari# #) ->
         case readTVar# vari# s1# of
           (# s2#, Empty #) ->
@@ -211,16 +233,11 @@
 An input channel.
 -}
 data InChan a = MkInChan
-  { icState :: {-# UNPACK #-} !(ChanState a)
+  { icStateRef :: {-# UNPACK #-} !(IORef (ChanState a))
   {- ^
-  The underlying channel state.
+  An `IORef` to the underlying channel state.
 
-  This is shared between all input and output channels.
-  -}
-  , icLive :: {-# UNPACK #-} !Live
-  {- ^
-  When this value is dropped, the corresponding `IsLive`
-  values in the output channels can be used to detect it.
+  This `IORef` is /never/ written and exists only to attach a finalizer.
   -}
   }
 
@@ -228,22 +245,37 @@
 An output channel.
 
 An output channel has a finalizer that frees unreachable values in the ring buffer.
-The worst-case complexity of this operation is $O(N)$ where $N$ is the length of the ring buffer.
+The worst-case complexity of this operation is /O(N)/ where /N/ is the length of the ring buffer.
 -}
 data OutChan a = MkOutChan
-  { ocState :: !(ChanState a)
+  { ocState :: {-# UNPACK #-} !(ChanState a)
   {- ^
   The underlying channel state.
 
   This is shared between all input and output channels.
   -}
-  , ocIsLive :: !IsLive
-  -- ^ A value used test whether the corresponding input channel is live.
-  , ocPosVar :: !(TVar ChanPos)
+  , ocPosVar :: {-# UNPACK #-} !(TVar ChanPos)
   -- ^ A variable that holds this output channel's position.
   }
 
 {- |
+Free an input channel.
+-}
+freeInChan :: ChanState a -> IO ()
+freeInChan MkChanState{..} =
+  atomically $ do
+    icPos <- readTVar icPosVar
+    writeTVar icPosVar icPos{done = 1}
+
+{- |
+Add a finalizer to an `IORef`.
+
+Adapted from @mkWeakTVar in @stm@.
+-}
+addFinalizerIORef :: IORef a -> IO () -> IO ()
+addFinalizerIORef ref finalizer = void (mkWeakIORef ref finalizer)
+
+{- |
 Free an output channel.
 
 __Warning:__
@@ -262,15 +294,15 @@
     -- Walk the buffer to free values that have been seen by every remaining OutChan.
     icPos <- readTVar icPosVar
     ocPos <- live icPos <$> readTVar ocPosVar
-    let go cp
-          | icPos == cp = pure ()
+    let go pos
+          | icPos `eqPos` pos = pure ()
           | otherwise = do
-              mbSuccess <- tryFreeChanBufAt buffer ocCount (next cp)
+              mbSuccess <- tryFreeChanBufAt buffer ocCount (next pos)
               case mbSuccess of
                 Nothing
-                  | loop icPos == 0 && next icPos <= next cp -> go zero
+                  | loop icPos == 0 && next icPos <= next pos -> go zero
                   | otherwise -> pure ()
-                Just True -> go (advance len# cp)
+                Just True -> go (advance len# pos)
                 Just False -> pure ()
     go ocPos
 
@@ -290,20 +322,20 @@
 
 The ring buffer is represented as a @SmallArray@, so @len@ should be smaller than 128.
 -}
-new :: Word32 -> IO (InChan a, OutChan a)
+new :: Word8 -> IO (InChan a, OutChan a)
 new len = do
   -- Create the input channel.
   buffer <- newChanBuf len
   icPosVar <- newTVarIO zero
   ocCountVar <- newTVarIO 1
-  icLive <- mkLive
   let icState = MkChanState{..}
+  icStateRef <- newIORef icState
+  addFinalizerIORef icStateRef (freeInChan icState)
   let ic = MkInChan{..}
 
   -- Create the output channel.
   ocPosVar <- newTVarIO zero
   let ocState = icState
-  ocIsLive <- mkIsLive icLive
   let oc = MkOutChan{..}
   addFinalizerTVar ocPosVar (freeOutChan oc)
 
@@ -315,7 +347,8 @@
 __Warning:__ If there are no output channels, the value is discarded.
 -}
 send :: InChan a -> a -> IO ()
-send MkInChan{icState = MkChanState{buffer = buffer@MkChanBuf{..}, ..}} a =
+send MkInChan{..} a = do
+  MkChanState{buffer = buffer@MkChanBuf{..}, ..} <- readIORef icStateRef
   atomically $ do
     ocCount <- readTVar ocCountVar
     when (ocCount > 0) $ do
@@ -358,10 +391,14 @@
 {- |
 @`out` i@ creates a new output channel from the input channel @i@.
 
-This worst-case complexity of this operation is $O(N)$ where $N$ is the length of the ring buffer.
+The new output channel starts receiving messages from the oldest position that still holds a live value.
+This is non-determinstic, as it depends on garbage collection.
+
+This worst-case complexity of this operation is /O(N)/ where /N/ is the length of the ring buffer.
 -}
 out :: InChan a -> IO (OutChan a)
-out MkInChan{icState = icState@MkChanState{..}, ..} =
+out MkInChan{..} = do
+  icState@MkChanState{..} <- readIORef icStateRef
   -- This operation is masked to ensure that the finalizer is attached.
   mask_ $ do
     -- See `dup` for an explanation for the use of `atomically`.
@@ -375,7 +412,6 @@
 
     -- Create the output channel.
     let ocState = icState
-    ocIsLive <- mkIsLive icLive
     let oc = MkOutChan{..}
     addFinalizerTVar ocPosVar (freeOutChan oc)
 
@@ -395,7 +431,7 @@
           atomically $ do
             icPos <- readTVar icPosVar
             ocPos <- live icPos <$> readTVar ocPosVar
-            if icPos == ocPos
+            if icPos `eqPos` ocPos
               then pure False
               else do
                 isEmpty <- isEmptyChanBuf buffer (next ocPos)
@@ -431,14 +467,13 @@
   receiveT_ icPos ocPos
  where
   receiveT_ icPos ocPos
-    | icPos == ocPos = do
-        -- If the input channel is still live...
-        icLive <- isLive ocIsLive
-        if icLive
-          -- ...we retry.
-          then retry
-          -- Otherwise, throw an NoInChanError.
-          else throwSTM ErrNoInChan
+    | icPos `eqPos` ocPos = do
+        -- If the input channel is done...
+        if isDone icPos
+          -- ...throw an NoInChanError.
+          then throwSTM ErrNoInChan
+          -- Otherwise, we retry
+          else retry
     | otherwise = do
         ocCount <- readTVar ocCountVar
         mbVal <- takeChanBuf buffer ocCount (next ocPos)
@@ -471,57 +506,9 @@
   atomically ((Just <$> receiveT o) `orElse` (pure Nothing))
 
 {- |
-This type is used to test for liveness.
-
-The target should hold on to a value of this type, the tester can use
-the corresponding `IsLive` to test whether the target is still live.
--}
-data Live = MkLive (MutVar# RealWorld ())
-
-{- |
-Create a value of type `Live`.
--}
-mkLive :: IO Live
-mkLive =
-  IO $ \s1# ->
-    case newMutVar# () s1# of
-      (# s2#, mv# #) ->
-        (# s2#, MkLive mv# #)
-
-{- |
-This type is used to test for liveness.
-
-See `Live`.
--}
-data IsLive = MkIsLive (Weak# (MutVar# RealWorld ()))
-
-{- |
-Create an `IsLive` value that tests whether the given `Live` value is live.
--}
-mkIsLive :: Live -> IO IsLive
-mkIsLive (MkLive mv#) =
-  IO $ \s1# ->
-    case mkWeak# mv# mv# (\s3# -> (# s3#, () #)) s1# of
-      (# s2#, wmv# #) ->
-        (# s2#, MkIsLive wmv# #)
-
-{- |
-Test whether the `Live` value that corresponds to the given `IsLive`
-value is still live.
--}
-isLive :: IsLive -> STM Bool
-isLive (MkIsLive wmv#) =
-  STM $ \s1# ->
-    case deRefWeak# wmv# s1# of
-      (# s2#, flag#, _ #) ->
-        case flag# of
-          0# -> (# s2#, False #)
-          _ -> (# s2#, True #)
-
-{- |
-The channel ring buffer is indexed by a `Word32`,
+The channel ring buffer is indexed by a `Word8`,
 which we must convert to an `Int` to index the underlying `SmallArray#`.
 -}
-word32ToInt# :: Word32# -> Int#
-word32ToInt# = \i# -> word2Int# (word32ToWord# i#)
-{-# INLINE word32ToInt# #-}
+word8ToInt# :: Word8# -> Int#
+word8ToInt# = \i# -> word2Int# (word8ToWord# i#)
+{-# INLINE word8ToInt# #-}
diff --git a/test/Main.hs b/test/Main.hs
--- a/test/Main.hs
+++ b/test/Main.hs
@@ -2,10 +2,11 @@
 {-# LANGUAGE InstanceSigs #-}
 {-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE ScopedTypeVariables #-}
 
 module Main where
 
-import Control.Concurrent (threadDelay)
+import Control.Concurrent (forkIO, threadDelay)
 import Control.Concurrent.LossyChan qualified as LC
 import Control.Concurrent.MVar (MVar, newEmptyMVar, putMVar, takeMVar)
 import Control.Exception (ArrayException (IndexOutOfBounds), assert, handle, throw)
@@ -15,11 +16,12 @@
 import Data.Traversable (for)
 import Data.Word (Word32, Word8)
 import GHC.Stack (HasCallStack)
+import HeapSize (recursiveSize, runHeapsize)
 import System.Mem (performMajorGC)
 import System.Mem.Weak (Weak)
 import System.Timeout (timeout)
 import Test.Tasty (TestTree, defaultMain, testGroup)
-import Test.Tasty.HUnit (assertFailure, testCase, (@?=))
+import Test.Tasty.HUnit (assertBool, assertFailure, testCase, (@?=))
 import Test.Tasty.QuickCheck (Arbitrary (..), Gen, Property, chooseBoundedIntegral, counterexample, forAll, ioProperty, label, oneof, testProperty)
 
 main :: IO ()
@@ -27,10 +29,11 @@
   defaultMain $
     testGroup
       "Tests"
-      [ unitTests 2
-      , unitTests 8
-      , unitTests 32
-      , unitTests 128
+      [ unitTestsFor 2
+      , unitTestsFor 8
+      , unitTestsFor 32
+      , unitTestsFor 128
+      , unitTests
       , propTests
       ]
 
@@ -53,11 +56,11 @@
 -}
 prop_LosslessWhenKeepingUpSimp :: Property
 prop_LosslessWhenKeepingUpSimp =
-  forAll (chooseBoundedIntegral (1, 128)) $ \n ->
-    forAll (chooseBoundedIntegral (1, 2 * n * maxLoop)) $ \m ->
-      label (if n >= m then "N >= M" else "N <  M") $
+  forAll (chooseBoundedIntegral (1, 128)) $ \(n :: Word8) ->
+    forAll (chooseBoundedIntegral (1, 2 * word8ToWord n * maxLoop)) $ \(m :: Word) ->
+      label (if word8ToWord n >= m then "N >= M" else "N <  M") $
         ioProperty $ do
-          (i, o) <- LC.new @Word32 n
+          (i, o) <- LC.new @Word n
           let xs = [0 .. m]
           and
             <$> ( for xs $ \x -> do
@@ -88,7 +91,7 @@
     | otherwise = "N == 1  "
   mLabel :: String
   mLabel
-    | m >= n * maxLoop = "M >= N * maxLoop"
+    | m >= word8ToWord n * maxLoop = "M >= N * maxLoop"
     | otherwise = "M <  N * maxLoop"
   oknLabel :: String
   oknLabel
@@ -107,8 +110,8 @@
 prop_Lose1WhenLaggingByNPlus1 =
   forAll (chooseBoundedIntegral (1, 128)) $ \n ->
     ioProperty $ do
-      (i, o) <- LC.new @Word32 n
-      let xs = [0 .. n]
+      (i, o) <- LC.new @Word n
+      let xs = [0 .. word8ToWord n]
       for_ xs $ (LC.send i)
       mby <- LC.tryReceive o
       pure $
@@ -122,22 +125,67 @@
 prop_LoseNWhenLaggingBy2NPlus1 =
   forAll (chooseBoundedIntegral (1, 128)) $ \n ->
     ioProperty $ do
-      (i, o) <- LC.new @Word32 n
-      let xs = [0 .. 2 * n]
+      (i, o) <- LC.new @Word n
+      let xs = [0 .. 2 * word8ToWord n]
       for_ xs $ (LC.send i)
       mby <- LC.tryReceive o
       pure $
         counterexample ("Expected " <> show (n + 1) <> ", but received " <> show mby) $
-          mby == Just (n + 1)
+          mby == Just (word8ToWord n + 1)
 
 {- |
-Unit tests.
+Unit tests that do not depend on buffer length.
 -}
-unitTests :: Word32 -> TestTree
-unitTests n =
+unitTests :: TestTree
+unitTests =
+  testGroup "Unit" $
+    [ testCase "early free" $ do
+        p1 <- newEmptyMVar
+        t1 <- mkTattleTale p1
+        (i, o) <- LC.new 64
+        LC.send i (Left t1)
+        LC.send i (Right ())
+        void (LC.receive o)
+        performMajorGC
+        timeout 100000 (takeMVar p1)
+          >>= maybe (assertFailure "t1 was not freed") pure
+    , testCase "receive throws when InChan is dropped" $ do
+        let handleNoChan LC.ErrNoInChan = pure $ Left LC.ErrNoInChan
+        (_, o) <- LC.new @() 64
+        performMajorGC
+        v <- handle handleNoChan (Right <$> timeout 10000 (LC.receive o))
+        case v of
+          Left LC.ErrNoInChan -> pure ()
+          Right _ -> assertFailure "ErrNoInChan exception not thrown."
+    , testCase "receive does not throw when InChan is not dropped" $ do
+        let handleNoChan LC.ErrNoInChan = pure False
+        (i, o) <- LC.new @Word32 64
+        performMajorGC
+        _ <- forkIO $
+          for_ [0 .. 256] $ \x ->
+            LC.send i x
+        let go :: Word32 -> IO ()
+            go k
+              | k >= 256 = pure ()
+              | otherwise =
+                  timeout 10000 (LC.receive o)
+                    >>= maybe (pure ()) (const $ go (k + 1))
+        success <- handle handleNoChan (go 0 >> pure True)
+        LC.send i 0
+        assertBool "ErrNoInChan was thrown" success
+    , testCase "size of ChanPos is 2" $ do
+        size <- runHeapsize 10 $! recursiveSize MkChanPos{done = 0, loop = 0, next = 0}
+        size @?= Just 2
+    ]
+
+{- |
+Unit tests for a specific buffer length.
+-}
+unitTestsFor :: Word8 -> TestTree
+unitTestsFor n =
   testGroup ("Unit (with N = " <> show n <> ")") $
     [ testCase "out continues from oldest live value" $ do
-        (i, o1) <- LC.new @Word32 n
+        (i, o1) <- LC.new @Word n
         for_ [1, 2] (LC.send i)
 
         -- receive 1; is no longer live
@@ -155,7 +203,7 @@
         m2' <- LC.receive o2
         m2' @?= 2
     , testCase "send discards message if there are no output channels" $ do
-        (i, _) <- LC.new @Word32 n
+        (i, _) <- LC.new @Word n
         performMajorGC
         threadDelay 1000000
         LC.send i 1
@@ -164,7 +212,7 @@
         m2 <- LC.receive o
         m2 @?= 2
     , testCase "send i 1 >> receive o ==> 1" $ do
-        (i, o) <- LC.new @Word32 n
+        (i, o) <- LC.new @Word n
         v <- LC.send i 1 >> LC.receive o
         v @?= 1
     , testCase "for [1,2] (\\x -> send i x >> receive 0) ==> [1,2]" $ do
@@ -174,49 +222,66 @@
         x2 <- LC.send i 2 >> LC.receive o
         x2 @?= 2
     , testCase "send i 1 >> receive o >> receive o ==> block" $ do
-        (i, o) <- LC.new @Word32 n
+        (i, o) <- LC.new @Word n
         v <- LC.send i 1 >> LC.receive o
         v @?= 1
         w <- timeout 1000 (LC.receive o)
         w @?= Nothing
     , testCase "for_ [0..N] (send i) >> receive o ==> 1" $ do
-        (i, o) <- LC.new @Word32 n
-        v <- for_ [0 .. n] (LC.send i) >> LC.receive o
+        (i, o) <- LC.new @Word n
+        v <- for_ [0 .. word8ToWord n] (LC.send i) >> LC.receive o
         v @?= 1
     , testCase "for_ [0..N*2] (send i) >> receive o ==> N + 1" $ do
-        (i, o) <- LC.new @Word32 n
-        v <- for_ [0 .. n * 2] (LC.send i) >> LC.receive o
-        v @?= n + 1
+        (i, o) <- LC.new @Word n
+        v <- for_ [0 .. word8ToWord n * 2] (LC.send i) >> LC.receive o
+        v @?= word8ToWord n + 1
     , testCase "for_ [0..N*L+1] (send i) >> receive o ==> N * (L - 1) + 1" $ do
-        (i, o) <- LC.new @Word32 n
-        v <- for_ [0 .. n * maxLoop] (LC.send i) >> LC.receive o
-        v @?= n * (maxLoop - 1) + 1
+        (i, o) <- LC.new @Word n
+        v <- for_ [0 .. word8ToWord n * maxLoop] (LC.send i) >> LC.receive o
+        v @?= word8ToWord n * (maxLoop - 1) + 1
     , testCase "send i 1 >> traverse receive [o1,o2] ==> [1,1]" $ do
-        (i, o1) <- LC.new @Word32 n
+        (i, o1) <- LC.new @Word n
         o2 <- LC.dup o1
         vs <- LC.send i 1 >> traverse LC.receive [o1, o2]
         vs @?= [1, 1]
-    , testCase "early free" $ do
-        p1 <- newEmptyMVar
-        t1 <- mkTattleTale p1
-        (i, o) <- LC.new n
-        LC.send i (Left t1)
-        LC.send i (Right ())
-        void (LC.receive o)
-        performMajorGC
-        timeout 100000 (takeMVar p1)
-          >>= maybe (assertFailure "t1 was not freed") pure
-    , testCase "receive hangs if InChan is dropped" $ do
-        let handleNoChan LC.ErrNoInChan = pure $ Left LC.ErrNoInChan
-        (_, o) <- LC.new @() n
-        performMajorGC
-        v <- handle handleNoChan (Right <$> timeout 10000 (LC.receive o))
-        case v of
-          Left LC.ErrNoInChan -> pure ()
-          Right _ -> assertFailure "ErrNoInChan exception not thrown."
     ]
 
 --------------------------------------------------------------------------------
+-- ChanPos
+--------------------------------------------------------------------------------
+
+{- |
+__Warning:__
+This definition is copied from "Control.Concurrent.LossyChan" and should be kept
+up to date. Otherwise, the heapsize test is meaningless.
+-}
+data ChanPos = MkChanPos
+  { loop :: {-# UNPACK #-} !Word32
+  {- ^
+  This value tracks the current loop around the channel ring buffer, which is
+  used to determine whether or not a channel position refers to a live value.
+
+  The `maxBound` of this type determines the resilience of the `OutChan`.
+  If a receiver stops at loop @N@ and does not resume until the sender has
+  written @`maxBound` - 1@ or @`maxBound`@ values and the loop counter has
+  wrapped around all the way back to loop @N - 1 @ or @N@, then the receiver
+  will treat its current position as live, which may cause it to skip some of
+  the messages in the buffer.
+  -}
+  , next :: {-# UNPACK #-} !Word8
+  {- ^
+  This value tracks the next position that should be read (for receivers) or
+  written to (for senders).
+  -}
+  , done :: {-# UNPACK #-} !Word8
+  {- ^
+  This value tracks whether or not the `InChan` is connected.
+
+  If the value is @1@, the `InChan` is done and has been garbage collected.
+  -}
+  }
+
+--------------------------------------------------------------------------------
 -- Maximum Loop Count
 --------------------------------------------------------------------------------
 
@@ -224,11 +289,11 @@
 The maximum loop value for a @ChanPos@.
 
 This value is the `maxBound` of `Word8`. In the actual implementation,
-`maxLoop` would be `maxBound` of `Word32`. To test the overflow cases,
+`maxLoop` would be `maxBound` of `Word`. To test the overflow cases,
 build the library with @--flags=+small-loop-counter@.
 -}
-maxLoop :: Word32
-maxLoop = fromIntegral (maxBound :: Word8)
+maxLoop :: Word
+maxLoop = word8ToWord (maxBound :: Word8)
 
 --------------------------------------------------------------------------------
 -- TattleTale
@@ -275,9 +340,9 @@
 This type holds the configuration for trace generation.
 -}
 data TraceConfig = MkTraceConfig
-  { n :: !Word32
+  { n :: !Word8
   -- ^ The size of the channel ring buffer.
-  , m :: !Word32
+  , m :: !Word
   -- ^ The total number of messages to send.
   , okn :: !Int
   -- ^ The total number of receivers that must keep up.
@@ -291,9 +356,9 @@
 -}
 data TraceOp
   = -- | @`Send` x t@ sends @x@ over the `LC.InChan`.
-    Send !Word32
+    Send !Word
   | -- | @`ReceiveK` k x t@ receives @x@ over the @k@'th `LC.OutChan` that must keep up.
-    ReceiveK !Int !Word32
+    ReceiveK !Int !Word
   | -- | @`Receive` l t@ receives some value over the @l@'th `LC.OutChan` that may lag behind.
     ReceiveL !Int
   deriving (Show)
@@ -315,11 +380,11 @@
 This type holds the state of the system after at some point in a `Trace`.
 -}
 data TraceState = MkTraceState
-  { ic :: !Word32
+  { ic :: !Word
   -- ^ Number of messages sent over `LC.InChan`.
-  , okcs :: ![Word32]
+  , okcs :: ![Word]
   -- ^ Number of messages received per `LC.OutChan` that must keep up.
-  , olcs :: ![Word32]
+  , olcs :: ![Word]
   -- ^ Number of messages received per `LC.OutChan` that may lag behind.
   }
   deriving (Show)
@@ -371,8 +436,8 @@
 -}
 genTraceConfig :: Gen TraceConfig
 genTraceConfig = do
-  n <- chooseBoundedIntegral (1, 128)
-  m <- chooseBoundedIntegral (2 * n, 2 * n * maxLoop)
+  (n :: Word8) <- chooseBoundedIntegral (1, 128)
+  (m :: Word) <- chooseBoundedIntegral (2 * word8ToWord n, 2 * word8ToWord n * maxLoop)
   okn <- chooseBoundedIntegral (2, 4)
   oln <- chooseBoundedIntegral (0, 2)
   pure MkTraceConfig{..}
@@ -441,14 +506,11 @@
       ic <= m
     , -- The difference between the number of sent and the number of received
       -- messages by channels that must keep up is at least 0 and at most n.
-      all (\okc -> let dm = asInt ic - asInt okc in 0 <= dm && dm <= asInt n) okcs
+      all (\okc -> let dm = wordToInt ic - wordToInt okc in 0 <= dm && dm <= wordToInt (word8ToWord n)) okcs
     , -- The difference between the number of sent and the number of received
       -- messages by channels that may lag behind is at least 0.
-      all (\olc -> let dm = asInt ic - asInt olc in 0 <= dm) olcs
+      all (\olc -> let dm = wordToInt ic - wordToInt olc in 0 <= dm) olcs
     ]
- where
-  asInt :: Word32 -> Int
-  asInt = fromIntegral
 
 {- |
 Apply the given function at the given index in the given list.
@@ -500,3 +562,12 @@
   Send _ -> True
   ReceiveK k _ -> k < okn
   ReceiveL l -> l < oln
+
+
+word8ToWord :: Word8 -> Word
+word8ToWord = fromIntegral
+{-# INLINE word8ToWord #-}
+
+wordToInt :: Word -> Int
+wordToInt = fromIntegral
+{-# INLINE wordToInt #-}
