diff --git a/edges.cabal b/edges.cabal
--- a/edges.cabal
+++ b/edges.cabal
@@ -1,7 +1,7 @@
 name:
   edges
 version:
-  0.4.0.1
+  0.4.0.2
 category:
   Graphs
 synopsis:
@@ -61,9 +61,9 @@
     monad-par >=0.3.4.8 && <0.4,
     pointed >=5 && <6,
     potoki >=2.0.2 && <2.1,
-    potoki-cereal >=0.2.1.1 && <0.3,
+    potoki-cereal >=0.3 && <0.4,
     primitive >=0.6.4 && <0.7,
-    primitive-extras >=0.3 && <0.4,
+    primitive-extras >=0.6.1 && <0.7,
     profunctors >=5 && <6,
     QuickCheck >=2.8.1 && <3,
     semigroupoids >=5.2 && <6,
diff --git a/library/Edges/Cereal/Get.hs b/library/Edges/Cereal/Get.hs
--- a/library/Edges/Cereal/Get.hs
+++ b/library/Edges/Cereal/Get.hs
@@ -4,19 +4,22 @@
 import Edges.Prelude
 import Edges.Types
 import Data.Serialize.Get
-import PrimitiveExtras.Cereal.Get
+import qualified PrimitiveExtras.PrimArray as PrimArray
+import qualified PrimitiveExtras.PrimMultiArray as PrimMultiArray
 
 
+int :: Get Int
+int = fromIntegral <$> getInt64le
+
 nodeCounts :: Get (NodeCounts entity)
 nodeCounts =
-  NodeCounts <$> primArray getWord32le
+  NodeCounts <$> PrimArray.cerealGet int getWord32le
 
 edges :: Get (Edges a b)
-edges =
-  do
-    targetSpace <- fromIntegral <$> getInt64le
-    pma <- primMultiArray getWord32le
-    return (Edges targetSpace pma)
+edges = do
+  targetSpace <- int
+  pma <- PrimMultiArray.cerealGet int getWord32le
+  return (Edges targetSpace pma)
 
 node :: Get (Node a)
-node = Node . fromIntegral <$> getInt64le
+node = Node <$> int
diff --git a/library/Edges/Cereal/Put.hs b/library/Edges/Cereal/Put.hs
--- a/library/Edges/Cereal/Put.hs
+++ b/library/Edges/Cereal/Put.hs
@@ -4,19 +4,21 @@
 import Edges.Prelude
 import Edges.Types
 import Data.Serialize.Put
-import PrimitiveExtras.Cereal.Put
+import qualified PrimitiveExtras.PrimArray as PrimArray
+import qualified PrimitiveExtras.PrimMultiArray as PrimMultiArray
 
 
+int :: Putter Int
+int = putInt64le . fromIntegral
+
 nodeCounts :: Putter (NodeCounts entity)
 nodeCounts (NodeCounts pa) =
-  primArray putWord32le pa
+  PrimArray.cerealPut int putWord32le pa
 
 edges :: Putter (Edges a b)
-edges (Edges targetSpaceValue mpaValue) =
-  targetSpace <> mpa
-  where
-    targetSpace = putInt64le (fromIntegral targetSpaceValue)
-    mpa = primMultiArray putWord32le mpaValue
+edges (Edges targetSpaceValue mpaValue) = targetSpace <> mpa where
+  targetSpace = int targetSpaceValue
+  mpa = PrimMultiArray.cerealPut int putWord32le mpaValue
 
 node :: Putter (Node a)
-node (Node int) = putInt64le (fromIntegral int)
+node (Node x) = int x
diff --git a/library/Edges/Edges.hs b/library/Edges/Edges.hs
--- a/library/Edges/Edges.hs
+++ b/library/Edges/Edges.hs
@@ -13,10 +13,9 @@
 import Edges.Prelude
 import Edges.Types
 import Edges.Cereal.Instances ()
-import qualified PrimitiveExtras.Monad as Monad
+import qualified PrimitiveExtras.PrimMultiArray as PrimMultiArray
 import qualified Control.Foldl as Foldl
 import qualified Control.Monad.Par as Par
-import qualified PrimitiveExtras.UnfoldM as UnfoldM
 import qualified DeferredFolds.UnfoldM as UnfoldM
 import qualified Test.QuickCheck.Gen as Gen
 
@@ -55,13 +54,13 @@
 
 primFoldableWithAmounts :: Foldable f => Int -> Int -> f (Int, Word32) -> Edges a b
 primFoldableWithAmounts aAmount bAmount foldable =
-  Edges bAmount $ runIdentity $ Monad.primMultiArray aAmount $ \ fold ->
+  Edges bAmount $ runIdentity $ PrimMultiArray.create aAmount $ \ fold ->
   Identity $ Foldl.fold fold foldable
 
 toAssocUnfoldM :: Monad m => Edges a b -> UnfoldM m (Node a, Node b)
 toAssocUnfoldM (Edges _ mpa) =
   fmap (\ (aInt, bWord32) -> (Node aInt, Node (fromIntegral bWord32))) $
-  UnfoldM.primMultiArrayAssocs mpa
+  PrimMultiArray.toAssocsUnfoldM mpa
 
 toAssocList :: Edges a b -> [(Node a, Node b)]
 toAssocList edges =
diff --git a/library/Edges/NodeCounts.hs b/library/Edges/NodeCounts.hs
--- a/library/Edges/NodeCounts.hs
+++ b/library/Edges/NodeCounts.hs
@@ -12,12 +12,11 @@
 import Edges.Prelude hiding (index, toList)
 import Edges.Types
 import Edges.Cereal.Instances ()
-import qualified PrimitiveExtras.UnfoldM as A
-import qualified PrimitiveExtras.Pure as C
-import qualified PrimitiveExtras.IO as D
-import qualified PrimitiveExtras.Fold as E
-import qualified DeferredFolds.UnfoldM as B
-import qualified Data.Vector.Unboxed as F
+import qualified PrimitiveExtras.PrimArray as PrimArray
+import qualified PrimitiveExtras.PrimMultiArray as PrimMultiArray
+import qualified PrimitiveExtras.TVarArray as TVarArray
+import qualified DeferredFolds.UnfoldM as UnfoldM
+import qualified Data.Vector.Unboxed as UnboxedVector
 import qualified Control.Monad.Par.IO as Par
 import qualified Control.Monad.Par as Par hiding (runParIO)
 
@@ -27,18 +26,18 @@
 
 node :: Edges entity anyEntity -> Node entity -> NodeCounts entity
 node (Edges _ edgesPma) =
-  let size = C.primMultiArrayOuterLength edgesPma
+  let size = PrimMultiArray.outerLength edgesPma
       in nodeWithSize size
 
 nodeWithSize :: Int -> Node entity -> NodeCounts entity
 nodeWithSize size (Node index) =
-  NodeCounts (C.oneHotPrimArray size index 1)
+  NodeCounts (PrimArray.oneHot size index 1)
 
-nodeTargets :: Edges surce target -> Node source -> NodeCounts target
+nodeTargets :: Edges source target -> Node source -> NodeCounts target
 nodeTargets (Edges targetAmount edgesPma) (Node sourceIndex) =
-  let indexUnfold = fmap fromIntegral (A.primMultiArrayAt edgesPma sourceIndex)
-      indexFold = E.indexCounts targetAmount
-      countPa = B.fold indexFold indexUnfold
+  let indexUnfold = fmap fromIntegral (PrimMultiArray.toUnfoldAtM edgesPma sourceIndex)
+      indexFold = PrimArray.indexCountsFold targetAmount
+      countPa = UnfoldM.fold indexFold indexUnfold
       in NodeCounts countPa
 
 {-|
@@ -49,19 +48,19 @@
 targets :: Edges source target -> NodeCounts source -> NodeCounts target
 targets (Edges targetAmount edgesPma) (NodeCounts sourceCountsPa) =
   unsafePerformIO $ Par.runParIO $ do
-    targetCountVarTable <- liftIO (D.newTVarArray 0 targetAmount)
+    targetCountVarTable <- liftIO (TVarArray.new 0 targetAmount)
     Par.parFor (Par.InclusiveRange 0 (pred (sizeofPrimArray sourceCountsPa))) $ \ sourceIndex ->
       case indexPrimArray sourceCountsPa sourceIndex of
         0 -> return ()
         sourceCount ->
           liftIO $
-          B.forM_ (A.primMultiArrayAt edgesPma sourceIndex) $ \ targetIndex ->
-          D.modifyTVarArrayAt targetCountVarTable (fromIntegral targetIndex) (+ sourceCount)
-    targetCountsPa <- liftIO (D.freezeTVarArrayAsPrimArray targetCountVarTable)
+          UnfoldM.forM_ (PrimMultiArray.toUnfoldAtM edgesPma sourceIndex) $ \ targetIndex ->
+          TVarArray.modifyAt targetCountVarTable (fromIntegral targetIndex) (+ sourceCount)
+    targetCountsPa <- liftIO (TVarArray.freezeAsPrimArray targetCountVarTable)
     return (NodeCounts targetCountsPa)
 
 toList :: NodeCounts entity -> [Word32]
 toList (NodeCounts pa) = foldrPrimArray' (:) [] pa
 
-toUnboxedVector :: NodeCounts entity -> F.Vector Word32
-toUnboxedVector (NodeCounts pa) = C.primArrayUnboxedVector pa
+toUnboxedVector :: NodeCounts entity -> UnboxedVector.Vector Word32
+toUnboxedVector (NodeCounts pa) = PrimArray.toUnboxedVector pa
diff --git a/library/Edges/Potoki/Produce.hs b/library/Edges/Potoki/Produce.hs
--- a/library/Edges/Potoki/Produce.hs
+++ b/library/Edges/Potoki/Produce.hs
@@ -5,7 +5,7 @@
 import Edges.Types
 import Edges.NodeCounts ()
 import Potoki.Produce
-import qualified PrimitiveExtras.Pure as A
+import qualified PrimitiveExtras.PrimMultiArray as PrimMultiArray
 import qualified Potoki.Transform as B
 import qualified Potoki.Cereal.Produce as C
 
@@ -13,7 +13,7 @@
 nodes :: Edges a x -> Produce (Node a)
 nodes (Edges _ pma) =
   coerce $
-  enumInRange 0 (pred (A.primMultiArrayOuterLength pma))
+  enumInRange 0 (pred (PrimMultiArray.outerLength pma))
 
 nodeCounts :: Edges a x -> (Node a -> NodeCounts b) -> Produce (Node a, NodeCounts b)
 nodeCounts edges nodeCounts =
diff --git a/library/Edges/Prelude.hs b/library/Edges/Prelude.hs
--- a/library/Edges/Prelude.hs
+++ b/library/Edges/Prelude.hs
@@ -113,13 +113,14 @@
 import Data.Primitive as Exports
 import Control.Monad.Primitive as Exports
 
--- vector
+-- primitive-extras
 -------------------------
-import Data.Vector as Exports (Vector)
+import PrimitiveExtras.PrimMultiArray as Exports (PrimMultiArray)
+import PrimitiveExtras.TVarArray as Exports (TVarArray)
 
--- primitive-extras
+-- vector
 -------------------------
-import PrimitiveExtras.Data as Exports
+import Data.Vector as Exports (Vector)
 
 -- text
 -------------------------