diff --git a/Control/Comonad/Trans/Class.hs b/Control/Comonad/Trans/Class.hs
--- a/Control/Comonad/Trans/Class.hs
+++ b/Control/Comonad/Trans/Class.hs
@@ -8,14 +8,14 @@
 -- Stability   :  provisional
 -- Portability :  portable
 ----------------------------------------------------------------------------
-module Control.Comonad.Trans.Class 
+module Control.Comonad.Trans.Class
   ( ComonadTrans(..) ) where
 
 import Control.Comonad
 import Control.Monad.Trans.Identity
 
 class ComonadTrans t where
-  lower :: Extend w => t w a -> w a 
+  lower :: Comonad w => t w a -> w a
 
 -- avoiding orphans
 instance ComonadTrans IdentityT where
diff --git a/Control/Comonad/Trans/Env.hs b/Control/Comonad/Trans/Env.hs
--- a/Control/Comonad/Trans/Env.hs
+++ b/Control/Comonad/Trans/Env.hs
@@ -1,4 +1,5 @@
-{-# LANGUAGE CPP, FlexibleContexts #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE FlexibleContexts #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Comonad.Trans.Env
@@ -37,6 +38,7 @@
 import Data.Traversable
 import Data.Functor.Apply
 import Data.Functor.Identity
+import Data.Functor.Extend
 import Data.Semigroup
 
 #ifdef __GLASGOW_HASKELL__
@@ -100,9 +102,10 @@
   fmap g (EnvT e wa) = EnvT e (fmap g wa)
 
 instance Extend w => Extend (EnvT e w) where
-  duplicate (EnvT e wa) = EnvT e (extend (EnvT e) wa)
+  duplicated (EnvT e wa) = EnvT e (extended (EnvT e) wa)
 
 instance Comonad w => Comonad (EnvT e w) where
+  duplicate (EnvT e wa) = EnvT e (extend (EnvT e) wa)
   extract (EnvT _ wa) = extract wa
 
 instance ComonadTrans (EnvT e) where
@@ -116,6 +119,9 @@
 
 instance (Semigroup e, Apply w) => Apply (EnvT e w) where
   EnvT ef wf <.> EnvT ea wa = EnvT (ef <> ea) (wf <.> wa)
+
+instance (Semigroup e, ComonadApply w) => ComonadApply (EnvT e w) where
+  EnvT ef wf <@> EnvT ea wa = EnvT (ef <> ea) (wf <@> wa)
 
 instance Foldable w => Foldable (EnvT e w) where
   foldMap f (EnvT _ w) = foldMap f w
diff --git a/Control/Comonad/Trans/Identity.hs b/Control/Comonad/Trans/Identity.hs
--- a/Control/Comonad/Trans/Identity.hs
+++ b/Control/Comonad/Trans/Identity.hs
@@ -7,7 +7,7 @@
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
 -- Portability :  portable
--- 
+--
 ----------------------------------------------------------------------------
 module Control.Comonad.Trans.Identity
   ( IdentityT(..)
diff --git a/Control/Comonad/Trans/Store.hs b/Control/Comonad/Trans/Store.hs
--- a/Control/Comonad/Trans/Store.hs
+++ b/Control/Comonad/Trans/Store.hs
@@ -37,6 +37,7 @@
 import Control.Comonad.Trans.Class
 import Data.Functor.Identity
 import Data.Functor.Apply
+import Data.Functor.Extend
 import Data.Semigroup
 
 #ifdef __GLASGOW_HASKELL__
@@ -83,15 +84,20 @@
 instance (Apply w, Semigroup s) => Apply (StoreT s w) where
   StoreT ff m <.> StoreT fa n = StoreT ((<*>) <$> ff <.> fa) (m <> n)
 
-instance (Applicative w, Semigroup s, Monoid s) => Applicative (StoreT s w) where
+instance (ComonadApply w, Semigroup s) => ComonadApply (StoreT s w) where
+  StoreT ff m <@> StoreT fa n = StoreT ((<*>) <$> ff <@> fa) (m <> n)
+
+instance (Applicative w, Monoid s) => Applicative (StoreT s w) where
   pure a = StoreT (pure (const a)) mempty
-  StoreT ff m <*> StoreT fa n = StoreT ((<*>) <$> ff <*> fa) (m `mappend` n)
+  StoreT ff m <*> StoreT fa n = StoreT ((<*>) <$> ff <*> fa) (mappend m n)
 
 instance Extend w => Extend (StoreT s w) where
-  duplicate (StoreT wf s) = StoreT (extend StoreT wf) s
-  extend f (StoreT wf s) = StoreT (extend (\wf' s' -> f (StoreT wf' s')) wf) s
+  duplicated (StoreT wf s) = StoreT (extended StoreT wf) s
+  extended f (StoreT wf s) = StoreT (extended (\wf' s' -> f (StoreT wf' s')) wf) s
 
 instance Comonad w => Comonad (StoreT s w) where
+  duplicate (StoreT wf s) = StoreT (extend StoreT wf) s
+  extend f (StoreT wf s) = StoreT (extend (\wf' s' -> f (StoreT wf' s')) wf) s
   extract (StoreT wf s) = extract wf s
 
 instance ComonadTrans (StoreT s) where
diff --git a/Control/Comonad/Trans/Traced.hs b/Control/Comonad/Trans/Traced.hs
--- a/Control/Comonad/Trans/Traced.hs
+++ b/Control/Comonad/Trans/Traced.hs
@@ -34,6 +34,7 @@
 import Control.Comonad.Trans.Class
 import Data.Distributive
 import Data.Functor.Apply
+import Data.Functor.Extend
 import Data.Functor.Identity
 import Data.Semigroup
 import Data.Typeable
@@ -54,26 +55,30 @@
 instance Apply w => Apply (TracedT m w) where
   TracedT wf <.> TracedT wa = TracedT (ap <$> wf <.> wa)
 
+instance (ComonadApply w, Monoid m) => ComonadApply (TracedT m w) where
+  TracedT wf <@> TracedT wa = TracedT (ap <$> wf <@> wa)
+
 instance Applicative w => Applicative (TracedT m w) where
   pure = TracedT . pure . const
   TracedT wf <*> TracedT wa = TracedT (ap <$> wf <*> wa)
 
 instance (Extend w, Semigroup m) => Extend (TracedT m w) where
-  extend f = TracedT . extend (\wf m -> f (TracedT (fmap (. (<>) m) wf))) . runTracedT
+  extended f = TracedT . extended (\wf m -> f (TracedT (fmap (. (<>) m) wf))) . runTracedT
 
-instance (Comonad w, Semigroup m, Monoid m) => Comonad (TracedT m w) where
+instance (Comonad w, Monoid m) => Comonad (TracedT m w) where
+  extend f = TracedT . extend (\wf m -> f (TracedT (fmap (. mappend m) wf))) . runTracedT
   extract (TracedT wf) = extract wf mempty
 
-instance (Semigroup m, Monoid m) => ComonadTrans (TracedT m) where
+instance Monoid m => ComonadTrans (TracedT m) where
   lower = fmap ($mempty) . runTracedT
 
-instance (Semigroup m, Monoid m) => ComonadHoist (TracedT m) where
+instance Monoid m => ComonadHoist (TracedT m) where
   cohoist = traced . extract . runTracedT
 
 instance Distributive w => Distributive (TracedT m w) where
   distribute = TracedT . fmap (\tma m -> fmap ($m) tma) . collect runTracedT
 
-trace :: (Comonad w, Monoid m) => m -> TracedT m w a -> a
+trace :: Comonad w => m -> TracedT m w a -> a
 trace m (TracedT wf) = extract wf m
 
 listen :: Functor w => TracedT m w a -> TracedT m w (a, m)
diff --git a/Data/Functor/Coproduct.hs b/Data/Functor/Coproduct.hs
--- a/Data/Functor/Coproduct.hs
+++ b/Data/Functor/Coproduct.hs
@@ -17,6 +17,7 @@
 
 import Control.Comonad
 import Data.Functor.Contravariant
+import Data.Functor.Extend
 import Data.Foldable
 import Data.Traversable
 import Data.Semigroup.Foldable
@@ -53,11 +54,14 @@
     (fmap (Coproduct . Right) . traverse1 f)
 
 instance (Extend f, Extend g) => Extend (Coproduct f g) where
+  extended f = Coproduct . coproduct
+    (Left . extended (f . Coproduct . Left))
+    (Right . extended (f . Coproduct . Right))
+
+instance (Comonad f, Comonad g) => Comonad (Coproduct f g) where
   extend f = Coproduct . coproduct
     (Left . extend (f . Coproduct . Left))
     (Right . extend (f . Coproduct . Right))
-
-instance (Comonad f, Comonad g) => Comonad (Coproduct f g) where
   extract = coproduct extract extract
 
 instance (Contravariant f, Contravariant g) => Contravariant (Coproduct f g) where
diff --git a/comonad-transformers.cabal b/comonad-transformers.cabal
--- a/comonad-transformers.cabal
+++ b/comonad-transformers.cabal
@@ -1,6 +1,6 @@
 name:          comonad-transformers
 category:      Control, Comonads
-version:       2.1.2
+version:       3.0
 license:       BSD3
 cabal-version: >= 1.6
 license-file:  LICENSE
@@ -22,11 +22,11 @@
 library
   build-depends:
     base          >= 4       && < 5,
-    comonad       >= 1.1.1.5 && < 1.2,
+    comonad       >= 3.0     && < 3.1,
     containers    >= 0.3     && < 0.6,
     contravariant >= 0.2.0.1 && < 0.3,
     distributive  >= 0.2.2   && < 0.3,
-    semigroupoids >= 1.3.1.2 && < 1.4,
+    semigroupoids >= 3.0     && < 3.1,
     semigroups    >= 0.8.3.1 && < 0.9,
     transformers  >= 0.2     && < 0.4