diff --git a/hasql-cursor-transaction.cabal b/hasql-cursor-transaction.cabal
--- a/hasql-cursor-transaction.cabal
+++ b/hasql-cursor-transaction.cabal
@@ -1,6 +1,6 @@
 cabal-version: 3.0
 name: hasql-cursor-transaction
-version: 0.6.5.2
+version: 0.6.6
 category: Hasql, Database, PostgreSQL, Streaming
 synopsis: An abstraction for simultaneous fetching from multiple PostgreSQL cursors
 homepage: https://github.com/nikita-volkov/hasql-cursor-transaction
@@ -66,11 +66,10 @@
 
   build-depends:
     base >=4.14 && <5,
-    base-prelude >=1 && <2,
     bytestring >=0.10 && <0.14,
-    bytestring-tree-builder ^>=0.2,
     contravariant >=1.5 && <2,
     contravariant-extras ^>=0.3.5.4,
-    hasql >=1.8 && <1.10,
-    hasql-transaction ^>=1.1,
-    transformers >=0.4 && <0.7,
+    hasql >=1.10 && <1.11,
+    hasql-transaction >=1.2 && <1.3,
+    text >=1.2 && <3,
+    transformers >=0.4 && <0.8,
diff --git a/library/Hasql/CursorTransaction/Private/CursorTransaction.hs b/library/Hasql/CursorTransaction/Private/CursorTransaction.hs
--- a/library/Hasql/CursorTransaction/Private/CursorTransaction.hs
+++ b/library/Hasql/CursorTransaction/Private/CursorTransaction.hs
@@ -1,11 +1,10 @@
 module Hasql.CursorTransaction.Private.CursorTransaction where
 
-import qualified ByteString.TreeBuilder as E
+import qualified Data.Text as Text
 import Hasql.CursorTransaction.Private.Prelude
 import qualified Hasql.CursorTransaction.Private.Specs as G
 import qualified Hasql.CursorTransaction.Private.Transactions as C
 import qualified Hasql.Decoders as F
-import qualified Hasql.Encoders as D
 import qualified Hasql.Transaction as A
 
 -- |
@@ -17,12 +16,12 @@
 -- |
 -- Cursor reference.
 newtype Cursor s
-  = Cursor ByteString
+  = Cursor Text
 
 -- |
 -- Given a template and encoded params produces a cursor,
 -- while automating its resource management.
-declareCursor :: ByteString -> G.EncodedParams -> CursorTransaction s (Cursor s)
+declareCursor :: Text -> G.EncodedParams -> CursorTransaction s (Cursor s)
 declareCursor template (G.EncodedParams (Supplied encoder params)) =
   CursorTransaction
     $ do
@@ -35,9 +34,7 @@
       return (Cursor name)
   where
     incToName inc =
-      E.toByteString
-        $ E.byteString "Hasql_CursorTransaction_"
-        <> E.asciiIntegral inc
+      "Hasql_CursorTransaction_" <> Text.pack (show inc)
 
 -- |
 -- Fetch from a cursor a batch of the given size and decode it using the specified result decoder.
diff --git a/library/Hasql/CursorTransaction/Private/Prelude.hs b/library/Hasql/CursorTransaction/Private/Prelude.hs
--- a/library/Hasql/CursorTransaction/Private/Prelude.hs
+++ b/library/Hasql/CursorTransaction/Private/Prelude.hs
@@ -3,17 +3,74 @@
   )
 where
 
-import BasePrelude as Exports hiding (assert, error, isLeft, isRight, left, right)
 import Contravariant.Extras as Exports
+import Control.Applicative as Exports
+import Control.Arrow as Exports
+import Control.Category as Exports
+import Control.Concurrent as Exports
+import Control.Exception as Exports
+import Control.Monad as Exports hiding (fail, forM, forM_, join, mapM, mapM_, msum, sequence, sequence_)
+import Control.Monad.Fail as Exports
+import Control.Monad.Fix as Exports hiding (fix)
 import Control.Monad.IO.Class as Exports
+import Control.Monad.ST as Exports
 import Control.Monad.Trans.Class as Exports
-import Control.Monad.Trans.Cont as Exports hiding (shift)
-import Control.Monad.Trans.Except as Exports hiding (liftCallCC, liftListen, liftPass)
-import Control.Monad.Trans.Maybe as Exports hiding (liftCallCC, liftCatch, liftPass)
-import Control.Monad.Trans.Reader as Exports hiding (liftCallCC)
-import Control.Monad.Trans.State.Strict as Exports hiding (liftCatch, liftListen, liftPass)
-import Control.Monad.Trans.Writer.Strict as Exports hiding (liftCallCC, liftCatch)
+import Control.Monad.Trans.Maybe as Exports hiding (liftListen, liftPass)
+import Control.Monad.Trans.Reader as Exports hiding (liftCallCC, liftCatch)
+import Control.Monad.Trans.State.Strict as Exports hiding (liftCallCC, liftCatch, liftListen, liftPass)
+import Data.Bits as Exports
+import Data.Bool as Exports
 import Data.ByteString as Exports (ByteString)
+import Data.Char as Exports
+import Data.Coerce as Exports
+import Data.Complex as Exports
+import Data.Data as Exports
+import Data.Dynamic as Exports
+import Data.Either as Exports
+import Data.Fixed as Exports
+import Data.Foldable as Exports hiding (toList)
+import Data.Function as Exports hiding (id, (.))
+import Data.Functor as Exports hiding (unzip)
 import Data.Functor.Contravariant as Exports
 import Data.Functor.Contravariant.Divisible as Exports
 import Data.Functor.Identity as Exports
+import Data.IORef as Exports
+import Data.Int as Exports
+import Data.Ix as Exports
+import Data.List as Exports hiding (all, and, any, concat, concatMap, elem, find, foldl, foldl', foldl1, foldr, foldr1, isSubsequenceOf, mapAccumL, mapAccumR, maximum, maximumBy, minimum, minimumBy, notElem, or, product, sortOn, sum, uncons)
+import Data.Maybe as Exports
+import Data.Monoid as Exports hiding (Alt, First (..), Last (..), (<>))
+import Data.Ord as Exports
+import Data.Proxy as Exports
+import Data.Ratio as Exports
+import Data.STRef as Exports
+import Data.Semigroup as Exports
+import Data.String as Exports
+import Data.Text as Exports (Text)
+import Data.Traversable as Exports
+import Data.Tuple as Exports
+import Data.Unique as Exports
+import Data.Version as Exports
+import Data.Word as Exports
+import Debug.Trace as Exports
+import Foreign.ForeignPtr as Exports
+import Foreign.Ptr as Exports
+import Foreign.StablePtr as Exports
+import Foreign.Storable as Exports hiding (alignment, sizeOf)
+import GHC.Conc as Exports hiding (threadWaitRead, threadWaitReadSTM, threadWaitWrite, threadWaitWriteSTM, withMVar)
+import GHC.Exts as Exports (IsList (..), groupWith, inline, lazy, sortWith)
+import GHC.Generics as Exports (Generic, Generic1)
+import GHC.IO.Exception as Exports
+import Numeric as Exports
+import System.Environment as Exports
+import System.Exit as Exports
+import System.IO as Exports
+import System.IO.Error as Exports
+import System.IO.Unsafe as Exports
+import System.Mem as Exports
+import System.Mem.StableName as Exports
+import System.Timeout as Exports
+import Text.Printf as Exports (hPrintf, printf)
+import Text.Read as Exports (Read (..), readEither, readMaybe)
+import Unsafe.Coerce as Exports
+import Prelude as Exports hiding (all, and, any, concat, concatMap, elem, fail, foldl, foldl1, foldr, foldr1, id, mapM, mapM_, maximum, minimum, notElem, or, product, sequence, sequence_, sum, (.))
diff --git a/library/Hasql/CursorTransaction/Private/Specs.hs b/library/Hasql/CursorTransaction/Private/Specs.hs
--- a/library/Hasql/CursorTransaction/Private/Specs.hs
+++ b/library/Hasql/CursorTransaction/Private/Specs.hs
@@ -1,7 +1,6 @@
 module Hasql.CursorTransaction.Private.Specs where
 
 import Hasql.CursorTransaction.Private.Prelude
-import qualified Hasql.Decoders as B
 import qualified Hasql.Encoders as A
 
 -- |
diff --git a/library/Hasql/CursorTransaction/Private/Statements.hs b/library/Hasql/CursorTransaction/Private/Statements.hs
--- a/library/Hasql/CursorTransaction/Private/Statements.hs
+++ b/library/Hasql/CursorTransaction/Private/Statements.hs
@@ -1,39 +1,37 @@
 module Hasql.CursorTransaction.Private.Statements where
 
-import qualified ByteString.TreeBuilder as D
+import qualified Data.Text as Text
 import Hasql.CursorTransaction.Private.Prelude
 import qualified Hasql.CursorTransaction.Private.Specs as F
 import qualified Hasql.Decoders as C
 import qualified Hasql.Encoders as B
 import Hasql.Statement
 
-declareCursor :: ByteString -> ByteString -> B.Params a -> Statement a ()
+declareCursor :: Text -> Text -> B.Params a -> Statement a ()
 declareCursor name sql encoder =
-  Statement sql' encoder C.noResult False
+  unpreparable sql' encoder C.noResult
   where
     sql' =
-      D.toByteString
-        $ "DECLARE "
-        <> D.byteString name
+      "DECLARE "
+        <> name
         <> " NO SCROLL CURSOR FOR "
-        <> D.byteString sql
+        <> sql
 
-closeCursor :: ByteString -> Statement () ()
+closeCursor :: Text -> Statement () ()
 closeCursor name =
-  Statement sql B.noParams C.noResult True
+  preparable sql B.noParams C.noResult
   where
     sql =
       "CLOSE " <> name
 
-fetchFromCursor :: ByteString -> F.BatchSize -> C.Result result -> Statement () result
+fetchFromCursor :: Text -> F.BatchSize -> C.Result result -> Statement () result
 fetchFromCursor name (F.BatchSize batchSize) decoder =
-  Statement sql encoder decoder True
+  preparable sql encoder decoder
   where
     sql =
-      D.toByteString
-        $ "FETCH FORWARD "
-        <> D.asciiIntegral batchSize
+      "FETCH FORWARD "
+        <> Text.pack (show batchSize)
         <> " FROM "
-        <> D.byteString name
+        <> name
     encoder =
       B.noParams
diff --git a/library/Hasql/CursorTransaction/Private/Transactions.hs b/library/Hasql/CursorTransaction/Private/Transactions.hs
--- a/library/Hasql/CursorTransaction/Private/Transactions.hs
+++ b/library/Hasql/CursorTransaction/Private/Transactions.hs
@@ -7,14 +7,14 @@
 import qualified Hasql.Encoders as F
 import qualified Hasql.Transaction as C
 
-declareCursor :: ByteString -> ByteString -> F.Params params -> params -> C.Transaction ()
+declareCursor :: Text -> Text -> F.Params params -> params -> C.Transaction ()
 declareCursor cursorName template paramsEncoder params =
   C.statement params (A.declareCursor cursorName template paramsEncoder)
 
-closeCursor :: ByteString -> C.Transaction ()
+closeCursor :: Text -> C.Transaction ()
 closeCursor cursorName =
   C.statement () (A.closeCursor cursorName)
 
-fetchFromCursor :: ByteString -> B.BatchSize -> E.Result result -> C.Transaction result
+fetchFromCursor :: Text -> B.BatchSize -> E.Result result -> C.Transaction result
 fetchFromCursor cursorName batchSize decoder =
   C.statement () (A.fetchFromCursor cursorName batchSize decoder)
diff --git a/library/Hasql/CursorTransaction/Sessions.hs b/library/Hasql/CursorTransaction/Sessions.hs
--- a/library/Hasql/CursorTransaction/Sessions.hs
+++ b/library/Hasql/CursorTransaction/Sessions.hs
@@ -4,7 +4,6 @@
 where
 
 import qualified Hasql.CursorTransaction.Private.CursorTransaction as A
-import Hasql.CursorTransaction.Private.Prelude
 import qualified Hasql.Session as C
 import qualified Hasql.Transaction.Sessions as D
 
diff --git a/library/Hasql/CursorTransaction/Transactions.hs b/library/Hasql/CursorTransaction/Transactions.hs
--- a/library/Hasql/CursorTransaction/Transactions.hs
+++ b/library/Hasql/CursorTransaction/Transactions.hs
@@ -3,10 +3,11 @@
   )
 where
 
-import qualified Hasql.CursorTransaction.Private.CursorTransaction as B
-import qualified Hasql.CursorTransaction.Private.Transactions as A
+import qualified Hasql.CursorTransaction.Private.CursorTransaction as CursorTransaction
+import qualified Hasql.Transaction as Transaction
 
 -- |
 -- Executes CursorTransaction in Transaction.
+cursorTransaction :: (forall s. CursorTransaction.CursorTransaction s result) -> Transaction.Transaction result
 cursorTransaction =
-  B.run
+  CursorTransaction.run