diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,9 @@
+# v0.1.0.1
+
+## Fixes
+
+- Removed remaining `OverloadedRecordDot` usages from the source, since that extension (along with `DuplicateRecordFields` and `NoFieldSelectors`) was dropped from the default extensions to support GHC 8.10
+
 # v0.1.0.0
 
 ## Breaking
diff --git a/pqi-conformance.cabal b/pqi-conformance.cabal
--- a/pqi-conformance.cabal
+++ b/pqi-conformance.cabal
@@ -1,6 +1,6 @@
 cabal-version: 3.0
 name: pqi-conformance
-version: 0.1.0.0
+version: 0.1.0.1
 category: Database, PostgreSQL, Testing
 synopsis: Differential conformance tests for pqi adapters
 description:
@@ -27,7 +27,6 @@
 common base
   default-language: Haskell2010
   default-extensions:
-    ApplicativeDo
     BangPatterns
     BinaryLiterals
     BlockArguments
@@ -40,7 +39,6 @@
     DeriveTraversable
     DerivingStrategies
     DerivingVia
-    DuplicateRecordFields
     EmptyDataDecls
     ExistentialQuantification
     FlexibleContexts
@@ -54,11 +52,9 @@
     MultiParamTypeClasses
     MultiWayIf
     NamedFieldPuns
-    NoFieldSelectors
     NoImplicitPrelude
     NoMonomorphismRestriction
     NumericUnderscores
-    OverloadedRecordDot
     OverloadedStrings
     ParallelListComp
     PatternGuards
@@ -68,7 +64,6 @@
     ScopedTypeVariables
     StandaloneDeriving
     StrictData
-    TemplateHaskell
     TupleSections
     TypeApplications
     TypeFamilies
diff --git a/src/library/Pqi/Conformance/Harness.hs b/src/library/Pqi/Conformance/Harness.hs
--- a/src/library/Pqi/Conformance/Harness.hs
+++ b/src/library/Pqi/Conformance/Harness.hs
@@ -55,8 +55,8 @@
   Expectation
 differential adapter adminConninfo scenario =
   withTestDb adminConninfo \testConninfo -> do
-    candidate <- bracket (adapter.connectdb testConninfo) (.finish) scenario
-    reference <- bracket (Reference.adapter.connectdb testConninfo) (.finish) scenario
+    candidate <- bracket (Pqi.connectdb adapter testConninfo) Pqi.finish scenario
+    reference <- bracket (Pqi.connectdb Reference.adapter testConninfo) Pqi.finish scenario
     candidate `shouldBe` reference
 
 -- Create a uniquely named database, run the action against it, and drop it on
@@ -76,9 +76,9 @@
 
 adminExec :: ByteString -> ByteString -> IO ()
 adminExec conninfo sql = do
-  conn <- Reference.adapter.connectdb conninfo
-  _ <- conn.exec sql
-  conn.finish
+  conn <- Pqi.connectdb Reference.adapter conninfo
+  _ <- Pqi.exec conn sql
+  Pqi.finish conn
 
 -- | Like 'differential', but for scenarios that exercise connection
 -- establishment itself ('Pqi.connectdb' on a broken conninfo,
diff --git a/src/library/Pqi/Conformance/Observation.hs b/src/library/Pqi/Conformance/Observation.hs
--- a/src/library/Pqi/Conformance/Observation.hs
+++ b/src/library/Pqi/Conformance/Observation.hs
@@ -68,45 +68,45 @@
 -- | Project a result into a 'ResultObservation'.
 observeResult :: Lq.Result -> IO ResultObservation
 observeResult result = do
-  status <- result.resultStatus
+  status <- Lq.resultStatus result
   errorFields <-
     traverse
-      (\code -> (,) code <$> result.resultErrorField code)
+      (\code -> (,) code <$> Lq.resultErrorField result code)
       [minBound .. maxBound]
-  errorMessage <- result.resultErrorMessage
-  ntuples <- result.ntuples
-  nfields <- result.nfields
-  nparams <- result.nparams
-  paramTypes <- traverse result.paramtype [0 .. nparams - 1]
+  errorMessage <- Lq.resultErrorMessage result
+  ntuples <- Lq.ntuples result
+  nfields <- Lq.nfields result
+  nparams <- Lq.nparams result
+  paramTypes <- traverse (Lq.paramtype result) [0 .. nparams - 1]
   fields <- traverse (observeField result) [0 .. nfields - 1]
   rows <- traverse (\row -> traverse (observeCell result row) [0 .. nfields - 1]) [0 .. ntuples - 1]
-  cmdStatus <- result.cmdStatus
-  cmdTuples <- result.cmdTuples
+  cmdStatus <- Lq.cmdStatus result
+  cmdTuples <- Lq.cmdTuples result
   pure ResultObservation {..}
 
 observeField :: Lq.Result -> Int32 -> IO FieldObservation
 observeField result column = do
-  name <- result.fname column
-  typeOid <- result.ftype column
-  modifier <- result.fmod column
-  size <- result.fsize column
-  format <- result.fformat column
-  tableOid <- result.ftable column
-  tableColumn <- result.ftablecol column
+  name <- Lq.fname result column
+  typeOid <- Lq.ftype result column
+  modifier <- Lq.fmod result column
+  size <- Lq.fsize result column
+  format <- Lq.fformat result column
+  tableOid <- Lq.ftable result column
+  tableColumn <- Lq.ftablecol result column
   pure FieldObservation {..}
 
 observeCell :: Lq.Result -> Int32 -> Int32 -> IO CellObservation
 observeCell result row column = do
-  value <- result.getvalue row column
-  isNull <- result.getisnull row column
-  length <- result.getlength row column
+  value <- Lq.getvalue result row column
+  isNull <- Lq.getisnull result row column
+  length <- Lq.getlength result row column
   pure CellObservation {..}
 
 -- | A snapshot of the comparable portion of a connection's state. The
 -- candidate and the reference open their connections from the same conninfo
 -- string, so the conninfo-derived identity accessors agree as well.
 data ConnectionObservation = ConnectionObservation
-  { status :: Lq.ConnStatus,
+  { connectionStatus :: Lq.ConnStatus,
     transactionStatus :: Lq.TransactionStatus,
     serverVersion :: Int,
     serverVersionParam :: Maybe ByteString,
@@ -119,25 +119,25 @@
     options :: Maybe ByteString,
     connectionNeedsPassword :: Bool,
     connectionUsedPassword :: Bool,
-    isNull :: Bool
+    connectionIsNull :: Bool
   }
   deriving stock (Eq, Show)
 
 -- | Project a connection into a 'ConnectionObservation'.
 observeConnection :: Lq.Connection -> IO ConnectionObservation
 observeConnection connection = do
-  status <- connection.status
-  transactionStatus <- connection.transactionStatus
-  serverVersion <- connection.serverVersion
-  serverVersionParam <- connection.parameterStatus "server_version"
-  protocolVersion <- connection.protocolVersion
-  db <- connection.db
-  user <- connection.user
-  pass <- connection.pass
-  host <- connection.host
-  port <- connection.port
-  options <- connection.options
-  connectionNeedsPassword <- connection.connectionNeedsPassword
-  connectionUsedPassword <- connection.connectionUsedPassword
-  let isNull = connection.isNullConnection
+  connectionStatus <- Lq.status connection
+  transactionStatus <- Lq.transactionStatus connection
+  serverVersion <- Lq.serverVersion connection
+  serverVersionParam <- Lq.parameterStatus connection "server_version"
+  protocolVersion <- Lq.protocolVersion connection
+  db <- Lq.db connection
+  user <- Lq.user connection
+  pass <- Lq.pass connection
+  host <- Lq.host connection
+  port <- Lq.port connection
+  options <- Lq.options connection
+  connectionNeedsPassword <- Lq.connectionNeedsPassword connection
+  connectionUsedPassword <- Lq.connectionUsedPassword connection
+  let connectionIsNull = Lq.isNullConnection connection
   pure ConnectionObservation {..}
diff --git a/src/library/Pqi/Conformance/Operation/BackendPID.hs b/src/library/Pqi/Conformance/Operation/BackendPID.hs
--- a/src/library/Pqi/Conformance/Operation/BackendPID.hs
+++ b/src/library/Pqi/Conformance/Operation/BackendPID.hs
@@ -17,4 +17,4 @@
   describe "backendPID" do
     it "is positive on an open connection" \conninfo ->
       differential adapter conninfo \connection ->
-        (> 0) <$> connection.backendPID
+        (> 0) <$> Pqi.backendPID connection
diff --git a/src/library/Pqi/Conformance/Operation/Cancel.hs b/src/library/Pqi/Conformance/Operation/Cancel.hs
--- a/src/library/Pqi/Conformance/Operation/Cancel.hs
+++ b/src/library/Pqi/Conformance/Operation/Cancel.hs
@@ -22,15 +22,15 @@
   describe "cancel" do
     it "succeeds on an idle connection" \conninfo ->
       differential adapter conninfo \connection -> do
-        handle <- connection.getCancel
-        for handle (.cancel)
+        handle <- Pqi.getCancel connection
+        for handle Pqi.cancel
 
     it "fails a running query with 57014" \conninfo ->
       differential adapter conninfo \connection -> do
-        sent <- connection.sendQuery "select pg_sleep(10)"
+        sent <- Pqi.sendQuery connection "select pg_sleep(10)"
         threadDelay 100000
-        handle <- connection.getCancel
-        cancelled <- for handle (.cancel)
+        handle <- Pqi.getCancel connection
+        cancelled <- for handle Pqi.cancel
         results <- drainResults connection
         usable <- execScenario "select 1" connection
         pure (sent, cancelled, results, usable)
@@ -38,10 +38,10 @@
     it "leaves the connection usable after cancelling a short-running query" \conninfo ->
       differential adapter conninfo \connection -> do
         outcomes <- replicateM 3 do
-          sent <- connection.sendQuery "select pg_sleep(0.1)"
+          sent <- Pqi.sendQuery connection "select pg_sleep(0.1)"
           threadDelay 50000
-          handle <- connection.getCancel
-          cancelled <- for handle (.cancel)
+          handle <- Pqi.getCancel connection
+          cancelled <- for handle Pqi.cancel
           results <- drainResults connection
           usable <- execScenario "select 1" connection
           pure (sent, cancelled, results, usable)
diff --git a/src/library/Pqi/Conformance/Operation/Cancel/Cleanup.hs b/src/library/Pqi/Conformance/Operation/Cancel/Cleanup.hs
--- a/src/library/Pqi/Conformance/Operation/Cancel/Cleanup.hs
+++ b/src/library/Pqi/Conformance/Operation/Cancel/Cleanup.hs
@@ -38,11 +38,11 @@
     --   5. exec runs a follow-up command — it must NOT be cancelled by the
     --      stale signal that arrived in step 2.
     it "does not corrupt subsequent commands when cancel is called after pipeline results are drained" \conninfo ->
-      bracket (adapter.connectdb conninfo) (.finish) \connection -> do
+      bracket (Lq.connectdb adapter conninfo) Lq.finish \connection -> do
         -- Enter pipeline mode and dispatch a fast query.
-        _ <- connection.enterPipelineMode
-        _ <- connection.sendQueryParams "select 1" [] Lq.Text
-        _ <- connection.pipelineSync
+        _ <- Lq.enterPipelineMode connection
+        _ <- Lq.sendQueryParams connection "select 1" [] Lq.Text
+        _ <- Lq.pipelineSync connection
 
         -- Wait for the server to process the query so both messages
         -- (CommandComplete + ReadyForQuery) are already in the socket by the
@@ -53,7 +53,7 @@
         -- After this loop exits, asyncPending=True in pqi-native because
         -- ReadyForQuery has not been read yet.
         let drainAll = do
-              mr <- connection.getResult
+              mr <- Lq.getResult connection
               case mr of
                 Nothing -> pure ()
                 Just _ -> drainAll
@@ -61,8 +61,8 @@
 
         -- Send cancel.  Because asyncPending=True in pqi-native, a cancel
         -- request is dispatched to the server despite the query being done.
-        handle <- connection.getCancel
-        for_ handle (.cancel)
+        handle <- Lq.getCancel connection
+        for_ handle Lq.cancel
 
         -- Give the stale cancel enough time to reach the server and set
         -- QueryCancelPending before the next command arrives.
@@ -72,13 +72,13 @@
         drainAll
 
         -- Exit pipeline mode (sends an implicit Sync in the reference impl).
-        _ <- connection.exitPipelineMode
+        _ <- Lq.exitPipelineMode connection
 
         -- A follow-up command must succeed; 57014 here means the stale cancel
         -- corrupted the connection.
-        mResult <- connection.exec "select 1"
+        mResult <- Lq.exec connection "select 1"
         case mResult of
           Nothing -> expectationFailure "exec returned no result after pipeline cleanup"
           Just result -> do
-            status <- result.resultStatus
+            status <- Lq.resultStatus result
             status `shouldBe` Lq.TuplesOk
diff --git a/src/library/Pqi/Conformance/Operation/Cancel/Stale.hs b/src/library/Pqi/Conformance/Operation/Cancel/Stale.hs
--- a/src/library/Pqi/Conformance/Operation/Cancel/Stale.hs
+++ b/src/library/Pqi/Conformance/Operation/Cancel/Stale.hs
@@ -67,16 +67,16 @@
   ByteString ->
   IO (Maybe (Lq.ExecStatus, Maybe ByteString))
 runScenario adapter conninfo =
-  bracket (adapter.connectdb conninfo) (.finish) \connection -> do
+  bracket (Lq.connectdb adapter conninfo) Lq.finish \connection -> do
     -- Build a pipeline with a fast query followed by a slow one, mirroring the
     -- sequence hasql issues.  Two prepared statements keep pendingParses in
     -- play, matching the real-world reproduction.
-    _ <- connection.enterPipelineMode
-    _ <- connection.sendPrepare "s1" "select $1::int" Nothing
-    _ <- connection.sendQueryPrepared "s1" [Just ("42", Lq.Text)] Lq.Text
-    _ <- connection.sendPrepare "s2" "select pg_sleep($1)" (Just [float8Oid])
-    _ <- connection.sendQueryPrepared "s2" [Just ("0.1", Lq.Text)] Lq.Text
-    _ <- connection.pipelineSync
+    _ <- Lq.enterPipelineMode connection
+    _ <- Lq.sendPrepare connection "s1" "select $1::int" Nothing
+    _ <- Lq.sendQueryPrepared connection "s1" [Just ("42", Lq.Text)] Lq.Text
+    _ <- Lq.sendPrepare connection "s2" "select pg_sleep($1)" (Just [float8Oid])
+    _ <- Lq.sendQueryPrepared connection "s2" [Just ("0.1", Lq.Text)] Lq.Text
+    _ <- Lq.pipelineSync connection
 
     -- Interrupt the read mid-pipeline, exactly as hasql's timeout does: the
     -- slow pg_sleep is still running when the read is abandoned.
@@ -85,27 +85,27 @@
     -- cleanUpAfterInterruption: drain, cancel, drain.  The cancel is sent while
     -- the pipeline is mid-flight; on buggy code its SIGINT can arrive late.
     _ <- drainResults connection
-    mHandle <- connection.getCancel
-    _ <- for mHandle (.cancel)
+    mHandle <- Lq.getCancel connection
+    _ <- for mHandle Lq.cancel
     _ <- drainResults connection
 
     -- leavePipeline: the exact restore sequence hasql performs, including the
     -- retry it falls back to.
-    statusBefore <- connection.pipelineStatus
+    statusBefore <- Lq.pipelineStatus connection
     when (statusBefore == Lq.PipelineOn) do
-      _ <- connection.pipelineSync
+      _ <- Lq.pipelineSync connection
       _ <- drainResults connection
-      _ <- connection.sendFlushRequest
+      _ <- Lq.sendFlushRequest connection
       _ <- drainResults connection
-      ok <- connection.exitPipelineMode
+      ok <- Lq.exitPipelineMode connection
       unless ok do
         _ <- drainResults connection
-        void connection.exitPipelineMode
+        void (Lq.exitPipelineMode connection)
 
     -- The victim.  It must not be cancelled by the stale signal.
     execScenario "select 99" connection >>= \case
       Nothing -> pure (Just (Lq.FatalError, Just "no-result"))
       Just observation ->
-        case observation.status of
+        case status observation of
           Lq.TuplesOk -> pure Nothing
-          status -> pure (Just (status, fromMaybe Nothing (lookup Lq.DiagSqlstate observation.errorFields)))
+          status -> pure (Just (status, fromMaybe Nothing (lookup Lq.DiagSqlstate (errorFields observation))))
diff --git a/src/library/Pqi/Conformance/Operation/ClientEncoding.hs b/src/library/Pqi/Conformance/Operation/ClientEncoding.hs
--- a/src/library/Pqi/Conformance/Operation/ClientEncoding.hs
+++ b/src/library/Pqi/Conformance/Operation/ClientEncoding.hs
@@ -17,11 +17,11 @@
   describe "clientEncoding" do
     it "round-trips and governs result re-encoding" \conninfo ->
       differential adapter conninfo \connection -> do
-        initial <- connection.clientEncoding
-        setOk <- connection.setClientEncoding "LATIN1"
-        switched <- connection.clientEncoding
-        reported <- connection.parameterStatus "client_encoding"
+        initial <- Pqi.clientEncoding connection
+        setOk <- Pqi.setClientEncoding connection "LATIN1"
+        switched <- Pqi.clientEncoding connection
+        reported <- Pqi.parameterStatus connection "client_encoding"
         latinCell <- execScenario "select chr(233) as e" connection
-        restoreOk <- connection.setClientEncoding "UTF8"
+        restoreOk <- Pqi.setClientEncoding connection "UTF8"
         utfCell <- execScenario "select chr(233) as e" connection
         pure (initial, setOk, switched, reported, latinCell, restoreOk, utfCell)
diff --git a/src/library/Pqi/Conformance/Operation/CmdStatus.hs b/src/library/Pqi/Conformance/Operation/CmdStatus.hs
--- a/src/library/Pqi/Conformance/Operation/CmdStatus.hs
+++ b/src/library/Pqi/Conformance/Operation/CmdStatus.hs
@@ -15,8 +15,8 @@
   describe "cmdStatus" do
     it "reports the command tag for each command" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.exec "create temporary table conformance_cmd_status (id int4, label text)"
-        let tagOf sql = connection.exec sql >>= traverse (.cmdStatus)
+        _ <- Pqi.exec connection "create temporary table conformance_cmd_status (id int4, label text)"
+        let tagOf sql = Pqi.exec connection sql >>= traverse Pqi.cmdStatus
         insert <- tagOf "insert into conformance_cmd_status values (1, 'a'), (2, 'b')"
         update <- tagOf "update conformance_cmd_status set label = 'c' where id = 1"
         delete <- tagOf "delete from conformance_cmd_status where id = 2"
diff --git a/src/library/Pqi/Conformance/Operation/CmdTuples.hs b/src/library/Pqi/Conformance/Operation/CmdTuples.hs
--- a/src/library/Pqi/Conformance/Operation/CmdTuples.hs
+++ b/src/library/Pqi/Conformance/Operation/CmdTuples.hs
@@ -15,8 +15,8 @@
   describe "cmdTuples" do
     it "reports the affected-row count for each command" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.exec "create temporary table conformance_cmd_tuples (id int4, label text)"
-        let countOf sql = connection.exec sql >>= traverse (.cmdTuples)
+        _ <- Pqi.exec connection "create temporary table conformance_cmd_tuples (id int4, label text)"
+        let countOf sql = Pqi.exec connection sql >>= traverse Pqi.cmdTuples
         insert <- countOf "insert into conformance_cmd_tuples values (1, 'a'), (2, 'b')"
         update <- countOf "update conformance_cmd_tuples set label = 'c' where id = 1"
         delete <- countOf "delete from conformance_cmd_tuples where id = 2"
diff --git a/src/library/Pqi/Conformance/Operation/ConnectPoll.hs b/src/library/Pqi/Conformance/Operation/ConnectPoll.hs
--- a/src/library/Pqi/Conformance/Operation/ConnectPoll.hs
+++ b/src/library/Pqi/Conformance/Operation/ConnectPoll.hs
@@ -16,8 +16,8 @@
   describe "connectPoll" do
     it "reaches a terminal polling status and a ready connection" \conninfo ->
       differentialConnect adapter conninfo \adapter' conninfo' -> do
-        connection <- adapter'.connectStart conninfo'
-        terminal <- pollUntilDone connection.connectPoll
-        connStatus <- connection.status
-        connection.finish
+        connection <- Pqi.connectStart adapter' conninfo'
+        terminal <- pollUntilDone (Pqi.connectPoll connection)
+        connStatus <- Pqi.status connection
+        Pqi.finish connection
         pure (terminal, connStatus)
diff --git a/src/library/Pqi/Conformance/Operation/ConnectStart.hs b/src/library/Pqi/Conformance/Operation/ConnectStart.hs
--- a/src/library/Pqi/Conformance/Operation/ConnectStart.hs
+++ b/src/library/Pqi/Conformance/Operation/ConnectStart.hs
@@ -17,8 +17,8 @@
   describe "connectStart" do
     it "begins an asynchronous connection that polls to readiness" \conninfo ->
       differentialConnect adapter conninfo \adapter' conninfo' -> do
-        connection <- adapter'.connectStart conninfo'
-        polled <- pollUntilDone connection.connectPoll
+        connection <- Pqi.connectStart adapter' conninfo'
+        polled <- pollUntilDone (Pqi.connectPoll connection)
         observation <- observeConnection connection
-        connection.finish
+        Pqi.finish connection
         pure (polled, observation)
diff --git a/src/library/Pqi/Conformance/Operation/Connectdb.hs b/src/library/Pqi/Conformance/Operation/Connectdb.hs
--- a/src/library/Pqi/Conformance/Operation/Connectdb.hs
+++ b/src/library/Pqi/Conformance/Operation/Connectdb.hs
@@ -27,33 +27,33 @@
 
     it "accepts a URI-format conninfo" \conninfo ->
       differentialConnect adapter conninfo \adapter' conninfo' -> do
-        connection <- adapter'.connectdb (kvToUri conninfo')
-        s <- connection.status
-        connection.finish
+        connection <- Pqi.connectdb adapter' (kvToUri conninfo')
+        s <- Pqi.status connection
+        Pqi.finish connection
         pure s
 
     it "rejects an unknown database" \conninfo ->
       differentialConnect adapter conninfo \adapter' conninfo' -> do
-        connection <- adapter'.connectdb (conninfo' <> " dbname=pqi_no_such_db")
-        observation <- connection.status
-        nullness <- pure connection.isNullConnection
-        connection.finish
+        connection <- Pqi.connectdb adapter' (conninfo' <> " dbname=pqi_no_such_db")
+        observation <- Pqi.status connection
+        nullness <- pure (Pqi.isNullConnection connection)
+        Pqi.finish connection
         pure (observation, nullness)
 
     it "rejects an unknown user" \conninfo ->
       differentialConnect adapter conninfo \adapter' conninfo' -> do
-        connection <- adapter'.connectdb (conninfo' <> " user=pqi_no_such_user")
-        observation <- connection.status
-        connection.finish
+        connection <- Pqi.connectdb adapter' (conninfo' <> " user=pqi_no_such_user")
+        observation <- Pqi.status connection
+        Pqi.finish connection
         pure observation
 
     it "defaults the user like the reference when user is omitted" \conninfo ->
       differentialConnect adapter conninfo \adapter' conninfo' -> do
-        connection <- adapter'.connectdb (dropUser conninfo')
-        resolvedUser <- connection.user
-        observedStatus <- connection.status
-        observedError <- connection.errorMessage
-        connection.finish
+        connection <- Pqi.connectdb adapter' (dropUser conninfo')
+        resolvedUser <- Pqi.user connection
+        observedStatus <- Pqi.status connection
+        observedError <- Pqi.errorMessage connection
+        Pqi.finish connection
         pure (resolvedUser, observedStatus, observedError)
 
   describe "SCRAM-SHA-256 authentication" do
@@ -66,7 +66,7 @@
               }
 
           scramScenario :: Pqi.Connection -> IO (Maybe ResultObservation)
-          scramScenario connection = connection.exec "select 1 as scram_works" >>= traverse observeResult
+          scramScenario connection = Pqi.exec connection "select 1 as scram_works" >>= traverse observeResult
        in TcPg.run scramConfig \(host, port) -> do
             let conninfo =
                   ByteString.Char8.pack
@@ -76,8 +76,8 @@
                         <> show port
                         <> " user=scram password=secret dbname=scram"
                     )
-            candidate <- bracket (adapter.connectdb conninfo) (.finish) scramScenario
-            reference <- bracket (Reference.adapter.connectdb conninfo) (.finish) scramScenario
+            candidate <- bracket (Pqi.connectdb adapter conninfo) Pqi.finish scramScenario
+            reference <- bracket (Pqi.connectdb Reference.adapter conninfo) Pqi.finish scramScenario
             candidate `shouldBe` reference
 
 -- | Drop the @user=…@ token from a @key=value@ conninfo, leaving the user
diff --git a/src/library/Pqi/Conformance/Operation/ConnectionNeedsPassword.hs b/src/library/Pqi/Conformance/Operation/ConnectionNeedsPassword.hs
--- a/src/library/Pqi/Conformance/Operation/ConnectionNeedsPassword.hs
+++ b/src/library/Pqi/Conformance/Operation/ConnectionNeedsPassword.hs
@@ -14,4 +14,4 @@
 spec adapter =
   describe "connectionNeedsPassword" do
     it "reports whether a password was needed" \conninfo ->
-      differential adapter conninfo (.connectionNeedsPassword)
+      differential adapter conninfo Pqi.connectionNeedsPassword
diff --git a/src/library/Pqi/Conformance/Operation/ConnectionUsedPassword.hs b/src/library/Pqi/Conformance/Operation/ConnectionUsedPassword.hs
--- a/src/library/Pqi/Conformance/Operation/ConnectionUsedPassword.hs
+++ b/src/library/Pqi/Conformance/Operation/ConnectionUsedPassword.hs
@@ -14,4 +14,4 @@
 spec adapter =
   describe "connectionUsedPassword" do
     it "reports whether a password was used" \conninfo ->
-      differential adapter conninfo (.connectionUsedPassword)
+      differential adapter conninfo Pqi.connectionUsedPassword
diff --git a/src/library/Pqi/Conformance/Operation/ConsumeInput.hs b/src/library/Pqi/Conformance/Operation/ConsumeInput.hs
--- a/src/library/Pqi/Conformance/Operation/ConsumeInput.hs
+++ b/src/library/Pqi/Conformance/Operation/ConsumeInput.hs
@@ -17,11 +17,11 @@
   describe "consumeInput" do
     it "drives result collection together with isBusy" \conninfo ->
       differential adapter conninfo \connection -> do
-        sent <- connection.sendQuery "select 42"
+        sent <- Pqi.sendQuery connection "select 42"
         let settle (0 :: Int) = pure False
             settle n = do
-              consumed <- connection.consumeInput
-              busy <- connection.isBusy
+              consumed <- Pqi.consumeInput connection
+              busy <- Pqi.isBusy connection
               if busy then threadDelay 1000 >> settle (n - 1) else pure consumed
         consumed <- settle 10000
         results <- drainResults connection
diff --git a/src/library/Pqi/Conformance/Operation/Db.hs b/src/library/Pqi/Conformance/Operation/Db.hs
--- a/src/library/Pqi/Conformance/Operation/Db.hs
+++ b/src/library/Pqi/Conformance/Operation/Db.hs
@@ -13,4 +13,4 @@
 spec adapter =
   describe "db" do
     it "reports the database name from the conninfo" \conninfo ->
-      differential adapter conninfo (.db)
+      differential adapter conninfo Pqi.db
diff --git a/src/library/Pqi/Conformance/Operation/DescribePortal.hs b/src/library/Pqi/Conformance/Operation/DescribePortal.hs
--- a/src/library/Pqi/Conformance/Operation/DescribePortal.hs
+++ b/src/library/Pqi/Conformance/Operation/DescribePortal.hs
@@ -16,12 +16,12 @@
   describe "describePortal" do
     it "describes a declared cursor" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.exec "begin"
+        _ <- Pqi.exec connection "begin"
         _ <-
-          connection.exec
+          Pqi.exec connection
             "declare conformance_cursor cursor for select 1 :: int4 as n, 'x' :: text as t"
-        connection.describePortal "conformance_cursor" >>= traverse observeResult
+        Pqi.describePortal connection "conformance_cursor" >>= traverse observeResult
 
     it "rejects an unknown portal" \conninfo ->
       differential adapter conninfo \connection ->
-        connection.describePortal "conformance_no_portal" >>= traverse observeResult
+        Pqi.describePortal connection "conformance_no_portal" >>= traverse observeResult
diff --git a/src/library/Pqi/Conformance/Operation/DescribePrepared.hs b/src/library/Pqi/Conformance/Operation/DescribePrepared.hs
--- a/src/library/Pqi/Conformance/Operation/DescribePrepared.hs
+++ b/src/library/Pqi/Conformance/Operation/DescribePrepared.hs
@@ -18,14 +18,14 @@
   describe "describePrepared" do
     it "reports parameter types" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.prepare "conformance_desc" "select $1 :: int4, $2 :: text" Nothing
-        connection.describePrepared "conformance_desc" >>= traverse observeResult
+        _ <- Pqi.prepare connection "conformance_desc" "select $1 :: int4, $2 :: text" Nothing
+        Pqi.describePrepared connection "conformance_desc" >>= traverse observeResult
 
     it "reports explicit parameter types" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.prepare "conformance_typed" "select $1" (Just [int8Oid])
-        connection.describePrepared "conformance_typed" >>= traverse observeResult
+        _ <- Pqi.prepare connection "conformance_typed" "select $1" (Just [int8Oid])
+        Pqi.describePrepared connection "conformance_typed" >>= traverse observeResult
 
     it "rejects an unknown statement" \conninfo ->
       differential adapter conninfo \connection ->
-        connection.describePrepared "conformance_missing" >>= traverse observeResult
+        Pqi.describePrepared connection "conformance_missing" >>= traverse observeResult
diff --git a/src/library/Pqi/Conformance/Operation/DisableNoticeReporting.hs b/src/library/Pqi/Conformance/Operation/DisableNoticeReporting.hs
--- a/src/library/Pqi/Conformance/Operation/DisableNoticeReporting.hs
+++ b/src/library/Pqi/Conformance/Operation/DisableNoticeReporting.hs
@@ -15,13 +15,13 @@
   describe "disableNoticeReporting" do
     it "stops retaining notices once disabled" \conninfo ->
       differential adapter conninfo \connection -> do
-        connection.enableNoticeReporting
+        Pqi.enableNoticeReporting connection
         whileEnabled <- raiseNoticeAndCollect connection
-        connection.disableNoticeReporting
+        Pqi.disableNoticeReporting connection
         whileDisabled <- raiseNoticeAndCollect connection
         pure (whileEnabled, whileDisabled)
 
 raiseNoticeAndCollect :: Pqi.Connection -> IO Bool
 raiseNoticeAndCollect connection = do
-  _ <- connection.exec "do $$ begin raise notice 'conformance notice'; end $$"
-  isJust <$> connection.getNotice
+  _ <- Pqi.exec connection "do $$ begin raise notice 'conformance notice'; end $$"
+  isJust <$> Pqi.getNotice connection
diff --git a/src/library/Pqi/Conformance/Operation/EnableNoticeReporting.hs b/src/library/Pqi/Conformance/Operation/EnableNoticeReporting.hs
--- a/src/library/Pqi/Conformance/Operation/EnableNoticeReporting.hs
+++ b/src/library/Pqi/Conformance/Operation/EnableNoticeReporting.hs
@@ -17,11 +17,11 @@
     it "makes a raised notice retrievable" \conninfo ->
       differential adapter conninfo \connection -> do
         beforeEnable <- raiseNoticeAndCollect connection
-        connection.enableNoticeReporting
+        Pqi.enableNoticeReporting connection
         afterEnable <- raiseNoticeAndCollect connection
         pure (beforeEnable, afterEnable)
 
 raiseNoticeAndCollect :: Pqi.Connection -> IO Bool
 raiseNoticeAndCollect connection = do
-  _ <- connection.exec "do $$ begin raise notice 'conformance notice'; end $$"
-  isJust <$> connection.getNotice
+  _ <- Pqi.exec connection "do $$ begin raise notice 'conformance notice'; end $$"
+  isJust <$> Pqi.getNotice connection
diff --git a/src/library/Pqi/Conformance/Operation/EnterPipelineMode.hs b/src/library/Pqi/Conformance/Operation/EnterPipelineMode.hs
--- a/src/library/Pqi/Conformance/Operation/EnterPipelineMode.hs
+++ b/src/library/Pqi/Conformance/Operation/EnterPipelineMode.hs
@@ -15,9 +15,9 @@
   describe "enterPipelineMode" do
     it "enters pipeline mode and is idempotent" \conninfo ->
       differential adapter conninfo \connection -> do
-        before <- connection.pipelineStatus
-        entered <- connection.enterPipelineMode
-        enteredAgain <- connection.enterPipelineMode
-        while <- connection.pipelineStatus
-        _ <- connection.exitPipelineMode
+        before <- Pqi.pipelineStatus connection
+        entered <- Pqi.enterPipelineMode connection
+        enteredAgain <- Pqi.enterPipelineMode connection
+        while <- Pqi.pipelineStatus connection
+        _ <- Pqi.exitPipelineMode connection
         pure (before, entered, enteredAgain, while)
diff --git a/src/library/Pqi/Conformance/Operation/ErrorMessage.hs b/src/library/Pqi/Conformance/Operation/ErrorMessage.hs
--- a/src/library/Pqi/Conformance/Operation/ErrorMessage.hs
+++ b/src/library/Pqi/Conformance/Operation/ErrorMessage.hs
@@ -26,37 +26,37 @@
   describe "errorMessage" do
     it "is empty on a healthy connection" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.exec "select 1"
-        connection.errorMessage
+        _ <- Pqi.exec connection "select 1"
+        Pqi.errorMessage connection
 
     it "is populated after a failed exec and cleared by a subsequent success" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.exec "do $$ begin raise exception 'conformance error'; end $$"
-        afterFail <- connection.errorMessage
-        _ <- connection.exec "select 1"
-        afterSuccess <- connection.errorMessage
+        _ <- Pqi.exec connection "do $$ begin raise exception 'conformance error'; end $$"
+        afterFail <- Pqi.errorMessage connection
+        _ <- Pqi.exec connection "select 1"
+        afterSuccess <- Pqi.errorMessage connection
         pure (afterFail, afterSuccess)
 
     it "is populated after a failed getResult and cleared by a subsequent success" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.sendQuery "do $$ begin raise exception 'conformance error'; end $$"
+        _ <- Pqi.sendQuery connection "do $$ begin raise exception 'conformance error'; end $$"
         _ <- drainResults connection
-        afterFail <- connection.errorMessage
-        _ <- connection.sendQuery "select 1"
+        afterFail <- Pqi.errorMessage connection
+        _ <- Pqi.sendQuery connection "select 1"
         _ <- drainResults connection
-        afterSuccess <- connection.errorMessage
+        afterSuccess <- Pqi.errorMessage connection
         pure (afterFail, afterSuccess)
 
     it "is populated after a connection failure" \conninfo ->
       differentialConnect adapter conninfo \adapter' conninfo' -> do
-        conn <- adapter'.connectdb (conninfo' <> " user=pqi_no_such_user")
-        msg <- conn.errorMessage
-        conn.finish
+        conn <- Pqi.connectdb adapter' (conninfo' <> " user=pqi_no_such_user")
+        msg <- Pqi.errorMessage conn
+        Pqi.finish conn
         pure msg
 
     it "is the null-connection sentinel on a null connection" \conninfo ->
       differentialConnect adapter conninfo \adapter' _ -> do
-        conn <- adapter'.newNullConnection
-        msg <- conn.errorMessage
-        conn.finish
+        conn <- Pqi.newNullConnection adapter'
+        msg <- Pqi.errorMessage conn
+        Pqi.finish conn
         pure msg
diff --git a/src/library/Pqi/Conformance/Operation/EscapeByteaConn.hs b/src/library/Pqi/Conformance/Operation/EscapeByteaConn.hs
--- a/src/library/Pqi/Conformance/Operation/EscapeByteaConn.hs
+++ b/src/library/Pqi/Conformance/Operation/EscapeByteaConn.hs
@@ -16,7 +16,7 @@
   describe "escapeByteaConn" do
     it "escapes a range of binary inputs" \conninfo ->
       differential adapter conninfo \connection ->
-        traverse connection.escapeByteaConn byteaCases
+        traverse (Pqi.escapeByteaConn connection) byteaCases
   where
     byteaCases =
       [ "",
diff --git a/src/library/Pqi/Conformance/Operation/EscapeIdentifier.hs b/src/library/Pqi/Conformance/Operation/EscapeIdentifier.hs
--- a/src/library/Pqi/Conformance/Operation/EscapeIdentifier.hs
+++ b/src/library/Pqi/Conformance/Operation/EscapeIdentifier.hs
@@ -16,11 +16,11 @@
   describe "escapeIdentifier" do
     it "escapes a range of identifiers" \conninfo ->
       differential adapter conninfo \connection ->
-        traverse connection.escapeIdentifier identifierCases
+        traverse (Pqi.escapeIdentifier connection) identifierCases
 
     it "produces identifiers that round-trip through a query" \conninfo ->
       differential adapter conninfo \connection -> do
-        escaped <- connection.escapeIdentifier "Wéird \"column\" name"
+        escaped <- Pqi.escapeIdentifier connection "Wéird \"column\" name"
         for escaped \identifier ->
           execScenario ("select 1 as " <> identifier) connection
   where
diff --git a/src/library/Pqi/Conformance/Operation/EscapeStringConn.hs b/src/library/Pqi/Conformance/Operation/EscapeStringConn.hs
--- a/src/library/Pqi/Conformance/Operation/EscapeStringConn.hs
+++ b/src/library/Pqi/Conformance/Operation/EscapeStringConn.hs
@@ -16,15 +16,15 @@
   describe "escapeStringConn" do
     it "escapes a range of strings" \conninfo ->
       differential adapter conninfo \connection ->
-        traverse connection.escapeStringConn stringCases
+        traverse (Pqi.escapeStringConn connection) stringCases
 
     it "rejects invalid encoding" \conninfo ->
       differential adapter conninfo \connection ->
-        connection.escapeStringConn "\255\254"
+        Pqi.escapeStringConn connection "\255\254"
 
     it "produces literals that round-trip through a query" \conninfo ->
       differential adapter conninfo \connection -> do
-        escaped <- connection.escapeStringConn "it's \\ tricky\nstuff"
+        escaped <- Pqi.escapeStringConn connection "it's \\ tricky\nstuff"
         for escaped \literal ->
           execScenario ("select '" <> literal <> "' :: text") connection
   where
diff --git a/src/library/Pqi/Conformance/Operation/ExecParams.hs b/src/library/Pqi/Conformance/Operation/ExecParams.hs
--- a/src/library/Pqi/Conformance/Operation/ExecParams.hs
+++ b/src/library/Pqi/Conformance/Operation/ExecParams.hs
@@ -50,7 +50,7 @@
           Lq.Text
     it "DML with parameters" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.exec "create temporary table conformance_exec_params (id int4)"
+        _ <- Lq.exec connection "create temporary table conformance_exec_params (id int4)"
         insert <-
           observed
             "insert into conformance_exec_params values ($1), ($2)"
diff --git a/src/library/Pqi/Conformance/Operation/ExecPrepared.hs b/src/library/Pqi/Conformance/Operation/ExecPrepared.hs
--- a/src/library/Pqi/Conformance/Operation/ExecPrepared.hs
+++ b/src/library/Pqi/Conformance/Operation/ExecPrepared.hs
@@ -17,29 +17,29 @@
   describe "execPrepared" do
     it "executes a prepared statement" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.prepare "conformance_stmt" "select $1 :: text as a, $2 :: int4 as b" Nothing
-        connection.execPrepared "conformance_stmt" [Just ("hello", Lq.Text), Just ("7", Lq.Text)] Lq.Text
+        _ <- Lq.prepare connection "conformance_stmt" "select $1 :: text as a, $2 :: int4 as b" Nothing
+        Lq.execPrepared connection "conformance_stmt" [Just ("hello", Lq.Text), Just ("7", Lq.Text)] Lq.Text
           >>= traverse observeResult
 
     it "executes the unnamed prepared statement" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.prepare "" "select $1 :: int4 + 1" Nothing
-        connection.execPrepared "" [Just ("41", Lq.Text)] Lq.Text
+        _ <- Lq.prepare connection "" "select $1 :: int4 + 1" Nothing
+        Lq.execPrepared connection "" [Just ("41", Lq.Text)] Lq.Text
           >>= traverse observeResult
 
     it "executes a zero-parameter statement" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.prepare "conformance_no_params" "select 42" Nothing
-        connection.execPrepared "conformance_no_params" [] Lq.Text
+        _ <- Lq.prepare connection "conformance_no_params" "select 42" Nothing
+        Lq.execPrepared connection "conformance_no_params" [] Lq.Text
           >>= traverse observeResult
 
     it "binds null and binary parameters with a binary result" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.prepare "conformance_binary" "select $1 :: text, $2 :: bytea" Nothing
-        connection.execPrepared "conformance_binary" [Nothing, Just ("\NUL\1\255", Lq.Binary)] Lq.Binary
+        _ <- Lq.prepare connection "conformance_binary" "select $1 :: text, $2 :: bytea" Nothing
+        Lq.execPrepared connection "conformance_binary" [Nothing, Just ("\NUL\1\255", Lq.Binary)] Lq.Binary
           >>= traverse observeResult
 
     it "rejects an unknown statement" \conninfo ->
       differential adapter conninfo \connection ->
-        connection.execPrepared "conformance_missing" [] Lq.Text
+        Lq.execPrepared connection "conformance_missing" [] Lq.Text
           >>= traverse observeResult
diff --git a/src/library/Pqi/Conformance/Operation/ExitPipelineMode.hs b/src/library/Pqi/Conformance/Operation/ExitPipelineMode.hs
--- a/src/library/Pqi/Conformance/Operation/ExitPipelineMode.hs
+++ b/src/library/Pqi/Conformance/Operation/ExitPipelineMode.hs
@@ -17,20 +17,20 @@
   describe "exitPipelineMode" do
     it "returns the connection to its non-pipeline status" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.enterPipelineMode
-        exited <- connection.exitPipelineMode
-        after <- connection.pipelineStatus
+        _ <- Lq.enterPipelineMode connection
+        exited <- Lq.exitPipelineMode connection
+        after <- Lq.pipelineStatus connection
         pure (exited, after)
 
     it "fails with work pending and succeeds once drained" \conninfo ->
       differential adapter conninfo \connection -> do
-        entered <- connection.enterPipelineMode
-        sent <- connection.sendQueryParams "select 1" [] Lq.Text
-        prematureExit <- connection.exitPipelineMode
-        synced <- connection.pipelineSync
+        entered <- Lq.enterPipelineMode connection
+        sent <- Lq.sendQueryParams connection "select 1" [] Lq.Text
+        prematureExit <- Lq.exitPipelineMode connection
+        synced <- Lq.pipelineSync connection
         results <- takeCommandResults connection
         syncResult <- takeResult connection
-        exited <- connection.exitPipelineMode
+        exited <- Lq.exitPipelineMode connection
         pure (entered, sent, prematureExit, synced, results, syncResult, exited)
 
     -- Reproduces the cleanup sequence that hasql's cleanUpAfterInterruption +
@@ -41,13 +41,13 @@
     -- sequence that hasql uses.
     it "recovers after mid-pipeline cancel (mirrors cleanUpAfterInterruption)" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.enterPipelineMode
-        _ <- connection.sendPrepare "s1" "select 1" Nothing
-        _ <- connection.sendQueryPrepared "s1" [] Lq.Text
-        _ <- connection.sendPrepare "s2" "select pg_sleep($1)" (Just [float8Oid])
-        _ <- connection.sendQueryPrepared "s2" [Just ("0.5", Lq.Text)] Lq.Text
-        _ <- connection.pipelineSync
-        _ <- connection.sendFlushRequest
+        _ <- Lq.enterPipelineMode connection
+        _ <- Lq.sendPrepare connection "s1" "select 1" Nothing
+        _ <- Lq.sendQueryPrepared connection "s1" [] Lq.Text
+        _ <- Lq.sendPrepare connection "s2" "select pg_sleep($1)" (Just [float8Oid])
+        _ <- Lq.sendQueryPrepared connection "s2" [Just ("0.5", Lq.Text)] Lq.Text
+        _ <- Lq.pipelineSync connection
+        _ <- Lq.sendFlushRequest connection
         -- Consume what toPipelineIO would have read before the timeout:
         -- parse1 result + separator, exec1 result + separator, parse2 result + separator.
         _ <- takeCommandResults connection
@@ -55,17 +55,17 @@
         _ <- takeCommandResults connection
         -- exec2 (pg_sleep) is still running; cancel it to simulate the
         -- timeout-triggered cancel in cleanUpAfterInterruption.
-        mHandle <- connection.getCancel
-        _ <- for mHandle (.cancel)
+        mHandle <- Lq.getCancel connection
+        _ <- for mHandle Lq.cancel
         -- cleanUpAfterInterruption: drain1, then drain2 (after cancel)
         _ <- drainResults connection
         _ <- drainResults connection
         -- leavePipeline: new Sync, drain, Flush, drain
-        _ <- connection.pipelineSync
+        _ <- Lq.pipelineSync connection
         _ <- drainResults connection
-        _ <- connection.sendFlushRequest
+        _ <- Lq.sendFlushRequest connection
         _ <- drainResults connection
-        exited <- connection.exitPipelineMode
+        exited <- Lq.exitPipelineMode connection
         pure exited
 
     -- Reproduces the failure seen in hasql's "Leaves the connection usable
@@ -82,35 +82,35 @@
     -- captures.
     it "recovers after timeout interrupts mid-pipeline read" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.enterPipelineMode
-        _ <- connection.sendPrepare "s1" "select $1::int" Nothing
-        _ <- connection.sendQueryPrepared "s1" [Just ("42", Lq.Text)] Lq.Text
-        _ <- connection.sendPrepare "s2" "select pg_sleep($1)" (Just [float8Oid])
-        _ <- connection.sendQueryPrepared "s2" [Just ("0.1", Lq.Text)] Lq.Text
-        _ <- connection.pipelineSync
+        _ <- Lq.enterPipelineMode connection
+        _ <- Lq.sendPrepare connection "s1" "select $1::int" Nothing
+        _ <- Lq.sendQueryPrepared connection "s1" [Just ("42", Lq.Text)] Lq.Text
+        _ <- Lq.sendPrepare connection "s2" "select pg_sleep($1)" (Just [float8Oid])
+        _ <- Lq.sendQueryPrepared connection "s2" [Just ("0.1", Lq.Text)] Lq.Text
+        _ <- Lq.pipelineSync connection
         -- Interrupt the read just like hasql's Connection.use + timeout does.
         _ <- timeout 50000 (drainResults connection)
         -- cleanUpAfterInterruption
         _ <- drainResults connection
-        mHandle <- connection.getCancel
-        _ <- for mHandle (.cancel)
+        mHandle <- Lq.getCancel connection
+        _ <- for mHandle Lq.cancel
         _ <- drainResults connection
         -- leavePipeline (including the retry that hasql performs)
-        pipelineStatusBefore <- connection.pipelineStatus
+        pipelineStatusBefore <- Lq.pipelineStatus connection
         exited <-
           if pipelineStatusBefore == Lq.PipelineOn
             then do
-              _ <- connection.pipelineSync
+              _ <- Lq.pipelineSync connection
               _ <- drainResults connection
-              _ <- connection.sendFlushRequest
+              _ <- Lq.sendFlushRequest connection
               _ <- drainResults connection
-              ok <- connection.exitPipelineMode
+              ok <- Lq.exitPipelineMode connection
               if ok
                 then pure True
                 else do
                   _ <- drainResults connection
-                  connection.exitPipelineMode
+                  Lq.exitPipelineMode connection
             else pure True
-        afterStatus <- connection.pipelineStatus
+        afterStatus <- Lq.pipelineStatus connection
         usable <- execScenario "select 99" connection
         pure (exited, afterStatus, usable)
diff --git a/src/library/Pqi/Conformance/Operation/Fformat.hs b/src/library/Pqi/Conformance/Operation/Fformat.hs
--- a/src/library/Pqi/Conformance/Operation/Fformat.hs
+++ b/src/library/Pqi/Conformance/Operation/Fformat.hs
@@ -17,10 +17,10 @@
     it "follows the requested result format" \conninfo ->
       differential adapter conninfo \connection -> do
         let formatsOf fmt =
-              connection.execParams "select 1 :: int4, 'x' :: text" [] fmt
+              Lq.execParams connection "select 1 :: int4, 'x' :: text" [] fmt
                 >>= traverse \r -> do
-                  n <- r.nfields
-                  traverse r.fformat [0 .. n - 1]
+                  n <- Lq.nfields r
+                  traverse (Lq.fformat r) [0 .. n - 1]
         textFormats <- formatsOf Lq.Text
         binaryFormats <- formatsOf Lq.Binary
         pure (textFormats, binaryFormats)
diff --git a/src/library/Pqi/Conformance/Operation/Finish.hs b/src/library/Pqi/Conformance/Operation/Finish.hs
--- a/src/library/Pqi/Conformance/Operation/Finish.hs
+++ b/src/library/Pqi/Conformance/Operation/Finish.hs
@@ -15,13 +15,13 @@
   describe "finish" do
     it "closes an open connection cleanly" \conninfo ->
       differentialConnect adapter conninfo \adapter' conninfo' -> do
-        connection <- adapter'.connectdb conninfo'
-        before <- connection.status
-        connection.finish
+        connection <- Pqi.connectdb adapter' conninfo'
+        before <- Pqi.status connection
+        Pqi.finish connection
         pure before
 
     it "closes the null sentinel cleanly" \conninfo ->
       differentialConnect adapter conninfo \adapter' _ -> do
-        connection <- adapter'.newNullConnection
-        connection.finish
+        connection <- Pqi.newNullConnection adapter'
+        Pqi.finish connection
         pure ()
diff --git a/src/library/Pqi/Conformance/Operation/Flush.hs b/src/library/Pqi/Conformance/Operation/Flush.hs
--- a/src/library/Pqi/Conformance/Operation/Flush.hs
+++ b/src/library/Pqi/Conformance/Operation/Flush.hs
@@ -16,9 +16,9 @@
   describe "flush" do
     it "flushes queued output to completion in non-blocking mode" \conninfo ->
       differential adapter conninfo \connection -> do
-        setOk <- connection.setnonblocking True
-        sent <- connection.sendQuery "select 1"
-        flushed <- flushUntilDone connection.flush
+        setOk <- Pqi.setnonblocking connection True
+        sent <- Pqi.sendQuery connection "select 1"
+        flushed <- flushUntilDone (Pqi.flush connection)
         results <- drainResults connection
-        restoreOk <- connection.setnonblocking False
+        restoreOk <- Pqi.setnonblocking connection False
         pure (setOk, sent, flushed, results, restoreOk)
diff --git a/src/library/Pqi/Conformance/Operation/Fmod.hs b/src/library/Pqi/Conformance/Operation/Fmod.hs
--- a/src/library/Pqi/Conformance/Operation/Fmod.hs
+++ b/src/library/Pqi/Conformance/Operation/Fmod.hs
@@ -16,9 +16,9 @@
     it "reports type modifiers and degrades out of range" \conninfo ->
       differential adapter conninfo \connection -> do
         result <-
-          connection.exec "select 1.5 :: numeric(10,2), 'pad' :: char(5), 'x' :: varchar(3), true, 1 :: int4"
+          Pqi.exec connection "select 1.5 :: numeric(10,2), 'pad' :: char(5), 'x' :: varchar(3), true, 1 :: int4"
         for result \r -> do
-          n <- r.nfields
-          modifiers <- traverse r.fmod [0 .. n - 1]
-          outOfRange <- r.fmod 9
+          n <- Pqi.nfields r
+          modifiers <- traverse (Pqi.fmod r) [0 .. n - 1]
+          outOfRange <- Pqi.fmod r 9
           pure (modifiers, outOfRange)
diff --git a/src/library/Pqi/Conformance/Operation/Fname.hs b/src/library/Pqi/Conformance/Operation/Fname.hs
--- a/src/library/Pqi/Conformance/Operation/Fname.hs
+++ b/src/library/Pqi/Conformance/Operation/Fname.hs
@@ -15,9 +15,9 @@
   describe "fname" do
     it "names columns and degrades out of range" \conninfo ->
       differential adapter conninfo \connection -> do
-        result <- connection.exec "select 1 as foo, 2 as bar"
+        result <- Pqi.exec connection "select 1 as foo, 2 as bar"
         for result \r -> do
-          n <- r.nfields
-          names <- traverse r.fname [0 .. n - 1]
-          outOfRange <- r.fname 5
+          n <- Pqi.nfields r
+          names <- traverse (Pqi.fname r) [0 .. n - 1]
+          outOfRange <- Pqi.fname r 5
           pure (names, outOfRange)
diff --git a/src/library/Pqi/Conformance/Operation/Fnumber.hs b/src/library/Pqi/Conformance/Operation/Fnumber.hs
--- a/src/library/Pqi/Conformance/Operation/Fnumber.hs
+++ b/src/library/Pqi/Conformance/Operation/Fnumber.hs
@@ -16,8 +16,8 @@
   describe "fnumber" do
     it "resolves names like an identifier" \conninfo ->
       differential adapter conninfo \connection -> do
-        result <- connection.exec "select 1 as foo, 2 as \"Bar\""
+        result <- Pqi.exec connection "select 1 as foo, 2 as \"Bar\""
         for result \r ->
           traverse
-            r.fnumber
+            (Pqi.fnumber r)
             ["foo", "FOO", "Foo", "Bar", "bar", "\"Bar\"", "\"foo\"", "missing"]
diff --git a/src/library/Pqi/Conformance/Operation/Fsize.hs b/src/library/Pqi/Conformance/Operation/Fsize.hs
--- a/src/library/Pqi/Conformance/Operation/Fsize.hs
+++ b/src/library/Pqi/Conformance/Operation/Fsize.hs
@@ -15,9 +15,9 @@
   describe "fsize" do
     it "reports type sizes and degrades out of range" \conninfo ->
       differential adapter conninfo \connection -> do
-        result <- connection.exec "select 1 :: int2, 1 :: int4, 1 :: int8, 'x' :: text, true"
+        result <- Pqi.exec connection "select 1 :: int2, 1 :: int4, 1 :: int8, 'x' :: text, true"
         for result \r -> do
-          n <- r.nfields
-          sizes <- traverse r.fsize [0 .. n - 1]
-          outOfRange <- r.fsize 9
+          n <- Pqi.nfields r
+          sizes <- traverse (Pqi.fsize r) [0 .. n - 1]
+          outOfRange <- Pqi.fsize r 9
           pure (sizes, outOfRange)
diff --git a/src/library/Pqi/Conformance/Operation/Ftable.hs b/src/library/Pqi/Conformance/Operation/Ftable.hs
--- a/src/library/Pqi/Conformance/Operation/Ftable.hs
+++ b/src/library/Pqi/Conformance/Operation/Ftable.hs
@@ -18,7 +18,7 @@
   describe "ftable" do
     it "reports the source-table OID, or none for a computed column" \conninfo ->
       differential adapter conninfo \connection -> do
-        result <- connection.exec "select relname, relkind, 1 as computed from pg_catalog.pg_class where false"
+        result <- Pqi.exec connection "select relname, relkind, 1 as computed from pg_catalog.pg_class where false"
         for result \r -> do
-          n <- r.nfields
-          traverse r.ftable [0 .. n - 1]
+          n <- Pqi.nfields r
+          traverse (Pqi.ftable r) [0 .. n - 1]
diff --git a/src/library/Pqi/Conformance/Operation/Ftablecol.hs b/src/library/Pqi/Conformance/Operation/Ftablecol.hs
--- a/src/library/Pqi/Conformance/Operation/Ftablecol.hs
+++ b/src/library/Pqi/Conformance/Operation/Ftablecol.hs
@@ -18,7 +18,7 @@
   describe "ftablecol" do
     it "reports the source-column number, or zero for a computed column" \conninfo ->
       differential adapter conninfo \connection -> do
-        result <- connection.exec "select relname, relkind, 1 as computed from pg_catalog.pg_class where false"
+        result <- Pqi.exec connection "select relname, relkind, 1 as computed from pg_catalog.pg_class where false"
         for result \r -> do
-          n <- r.nfields
-          traverse r.ftablecol [0 .. n - 1]
+          n <- Pqi.nfields r
+          traverse (Pqi.ftablecol r) [0 .. n - 1]
diff --git a/src/library/Pqi/Conformance/Operation/Ftype.hs b/src/library/Pqi/Conformance/Operation/Ftype.hs
--- a/src/library/Pqi/Conformance/Operation/Ftype.hs
+++ b/src/library/Pqi/Conformance/Operation/Ftype.hs
@@ -15,9 +15,9 @@
   describe "ftype" do
     it "reports type OIDs and degrades out of range" \conninfo ->
       differential adapter conninfo \connection -> do
-        result <- connection.exec "select 1 :: int4, 'x' :: text, true, 1.5 :: float8, 1 :: int2"
+        result <- Pqi.exec connection "select 1 :: int4, 'x' :: text, true, 1.5 :: float8, 1 :: int2"
         for result \r -> do
-          n <- r.nfields
-          types <- traverse r.ftype [0 .. n - 1]
-          outOfRange <- r.ftype 9
+          n <- Pqi.nfields r
+          types <- traverse (Pqi.ftype r) [0 .. n - 1]
+          outOfRange <- Pqi.ftype r 9
           pure (types, outOfRange)
diff --git a/src/library/Pqi/Conformance/Operation/GetCancel.hs b/src/library/Pqi/Conformance/Operation/GetCancel.hs
--- a/src/library/Pqi/Conformance/Operation/GetCancel.hs
+++ b/src/library/Pqi/Conformance/Operation/GetCancel.hs
@@ -15,4 +15,4 @@
   describe "getCancel" do
     it "produces a handle for an open connection" \conninfo ->
       differential adapter conninfo \connection ->
-        isJust <$> connection.getCancel
+        isJust <$> Pqi.getCancel connection
diff --git a/src/library/Pqi/Conformance/Operation/GetNotice.hs b/src/library/Pqi/Conformance/Operation/GetNotice.hs
--- a/src/library/Pqi/Conformance/Operation/GetNotice.hs
+++ b/src/library/Pqi/Conformance/Operation/GetNotice.hs
@@ -20,8 +20,8 @@
   describe "getNotice" do
     it "yields the formatted notice while enabled and then drains" \conninfo ->
       differential adapter conninfo \connection -> do
-        connection.enableNoticeReporting
-        _ <- connection.exec "do $$ begin raise notice 'conformance notice'; end $$"
-        firstNotice <- connection.getNotice
-        afterDrain <- connection.getNotice
+        Pqi.enableNoticeReporting connection
+        _ <- Pqi.exec connection "do $$ begin raise notice 'conformance notice'; end $$"
+        firstNotice <- Pqi.getNotice connection
+        afterDrain <- Pqi.getNotice connection
         pure (firstNotice, afterDrain)
diff --git a/src/library/Pqi/Conformance/Operation/GetResult.hs b/src/library/Pqi/Conformance/Operation/GetResult.hs
--- a/src/library/Pqi/Conformance/Operation/GetResult.hs
+++ b/src/library/Pqi/Conformance/Operation/GetResult.hs
@@ -16,7 +16,7 @@
   describe "getResult" do
     it "yields each result then a Nothing terminator" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.sendQuery "select 1 :: int4"
+        _ <- Pqi.sendQuery connection "select 1 :: int4"
         first <- takeResult connection
         terminator <- takeResult connection
         afterTerminator <- takeResult connection
diff --git a/src/library/Pqi/Conformance/Operation/Getisnull.hs b/src/library/Pqi/Conformance/Operation/Getisnull.hs
--- a/src/library/Pqi/Conformance/Operation/Getisnull.hs
+++ b/src/library/Pqi/Conformance/Operation/Getisnull.hs
@@ -15,9 +15,9 @@
   describe "getisnull" do
     it "distinguishes null, empty, and non-empty cells" \conninfo ->
       differential adapter conninfo \connection -> do
-        result <- connection.exec "select 'x' :: text, '' :: text, null :: int4"
+        result <- Pqi.exec connection "select 'x' :: text, '' :: text, null :: int4"
         for result \r -> do
-          nonEmpty <- r.getisnull 0 0
-          empty <- r.getisnull 0 1
-          nullCell <- r.getisnull 0 2
+          nonEmpty <- Pqi.getisnull r 0 0
+          empty <- Pqi.getisnull r 0 1
+          nullCell <- Pqi.getisnull r 0 2
           pure (nonEmpty, empty, nullCell)
diff --git a/src/library/Pqi/Conformance/Operation/Getlength.hs b/src/library/Pqi/Conformance/Operation/Getlength.hs
--- a/src/library/Pqi/Conformance/Operation/Getlength.hs
+++ b/src/library/Pqi/Conformance/Operation/Getlength.hs
@@ -15,7 +15,7 @@
   describe "getlength" do
     it "reports byte lengths across cell shapes" \conninfo ->
       differential adapter conninfo \connection -> do
-        result <- connection.exec "select 'hello' :: text, 'héllo' :: text, '' :: text, null :: int4"
+        result <- Pqi.exec connection "select 'hello' :: text, 'héllo' :: text, '' :: text, null :: int4"
         for result \r -> do
-          n <- r.nfields
-          traverse (r.getlength 0) [0 .. n - 1]
+          n <- Pqi.nfields r
+          traverse (Pqi.getlength r 0) [0 .. n - 1]
diff --git a/src/library/Pqi/Conformance/Operation/Getvalue.hs b/src/library/Pqi/Conformance/Operation/Getvalue.hs
--- a/src/library/Pqi/Conformance/Operation/Getvalue.hs
+++ b/src/library/Pqi/Conformance/Operation/Getvalue.hs
@@ -15,10 +15,10 @@
   describe "getvalue" do
     it "reads cells, nulls, and degrades out of range" \conninfo ->
       differential adapter conninfo \connection -> do
-        result <- connection.exec "select 'hello' :: text, null :: int4"
+        result <- Pqi.exec connection "select 'hello' :: text, null :: int4"
         for result \r -> do
-          present <- r.getvalue 0 0
-          nullCell <- r.getvalue 0 1
-          badRow <- r.getvalue 1 0
-          badColumn <- r.getvalue 0 5
+          present <- Pqi.getvalue r 0 0
+          nullCell <- Pqi.getvalue r 0 1
+          badRow <- Pqi.getvalue r 1 0
+          badColumn <- Pqi.getvalue r 0 5
           pure (present, nullCell, badRow, badColumn)
diff --git a/src/library/Pqi/Conformance/Operation/GetvalueCopy.hs b/src/library/Pqi/Conformance/Operation/GetvalueCopy.hs
--- a/src/library/Pqi/Conformance/Operation/GetvalueCopy.hs
+++ b/src/library/Pqi/Conformance/Operation/GetvalueCopy.hs
@@ -15,9 +15,9 @@
   describe "getvalue'" do
     it "copies cells that survive freeing the result" \conninfo ->
       differential adapter conninfo \connection -> do
-        result <- connection.exec "select 'copied' :: text, null :: int4"
+        result <- Pqi.exec connection "select 'copied' :: text, null :: int4"
         for result \r -> do
-          first <- r.getvalue' 0 0
-          second <- r.getvalue' 0 1
-          r.unsafeFreeResult
+          first <- Pqi.getvalue' r 0 0
+          second <- Pqi.getvalue' r 0 1
+          Pqi.unsafeFreeResult r
           pure (first, second)
diff --git a/src/library/Pqi/Conformance/Operation/Host.hs b/src/library/Pqi/Conformance/Operation/Host.hs
--- a/src/library/Pqi/Conformance/Operation/Host.hs
+++ b/src/library/Pqi/Conformance/Operation/Host.hs
@@ -13,4 +13,4 @@
 spec adapter =
   describe "host" do
     it "reports the host from the conninfo" \conninfo ->
-      differential adapter conninfo (.host)
+      differential adapter conninfo Pqi.host
diff --git a/src/library/Pqi/Conformance/Operation/IsBusy.hs b/src/library/Pqi/Conformance/Operation/IsBusy.hs
--- a/src/library/Pqi/Conformance/Operation/IsBusy.hs
+++ b/src/library/Pqi/Conformance/Operation/IsBusy.hs
@@ -16,11 +16,11 @@
   describe "isBusy" do
     it "settles to not-busy after the result arrives" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.sendQuery "select 42"
-        let settle (0 :: Int) = connection.isBusy
+        _ <- Pqi.sendQuery connection "select 42"
+        let settle (0 :: Int) = Pqi.isBusy connection
             settle n = do
-              _ <- connection.consumeInput
-              busy <- connection.isBusy
+              _ <- Pqi.consumeInput connection
+              busy <- Pqi.isBusy connection
               if busy then threadDelay 1000 >> settle (n - 1) else pure busy
         stillBusy <- settle 10000
         _ <- drainResults connection
diff --git a/src/library/Pqi/Conformance/Operation/IsNullConnection.hs b/src/library/Pqi/Conformance/Operation/IsNullConnection.hs
--- a/src/library/Pqi/Conformance/Operation/IsNullConnection.hs
+++ b/src/library/Pqi/Conformance/Operation/IsNullConnection.hs
@@ -15,10 +15,10 @@
   describe "isNullConnection" do
     it "is True for the null sentinel and False for an open connection" \conninfo ->
       differentialConnect adapter conninfo \adapter' conninfo' -> do
-        nullConn <- adapter'.newNullConnection
-        let nullIsNull = nullConn.isNullConnection
-        nullConn.finish
-        openConn <- adapter'.connectdb conninfo'
-        let openIsNull = openConn.isNullConnection
-        openConn.finish
+        nullConn <- Pqi.newNullConnection adapter'
+        let nullIsNull = Pqi.isNullConnection nullConn
+        Pqi.finish nullConn
+        openConn <- Pqi.connectdb adapter' conninfo'
+        let openIsNull = Pqi.isNullConnection openConn
+        Pqi.finish openConn
         pure (nullIsNull, openIsNull)
diff --git a/src/library/Pqi/Conformance/Operation/Isnonblocking.hs b/src/library/Pqi/Conformance/Operation/Isnonblocking.hs
--- a/src/library/Pqi/Conformance/Operation/Isnonblocking.hs
+++ b/src/library/Pqi/Conformance/Operation/Isnonblocking.hs
@@ -15,7 +15,7 @@
   describe "isnonblocking" do
     it "is off initially and reflects a change" \conninfo ->
       differential adapter conninfo \connection -> do
-        initially <- connection.isnonblocking
-        _ <- connection.setnonblocking True
-        afterEnable <- connection.isnonblocking
+        initially <- Pqi.isnonblocking connection
+        _ <- Pqi.setnonblocking connection True
+        afterEnable <- Pqi.isnonblocking connection
         pure (initially, afterEnable)
diff --git a/src/library/Pqi/Conformance/Operation/LoClose.hs b/src/library/Pqi/Conformance/Operation/LoClose.hs
--- a/src/library/Pqi/Conformance/Operation/LoClose.hs
+++ b/src/library/Pqi/Conformance/Operation/LoClose.hs
@@ -18,11 +18,11 @@
     it "closes the descriptor and invalidates further reads" \conninfo ->
       differential adapter conninfo \connection ->
         inTransaction connection do
-          oid <- connection.loCreat
+          oid <- Pqi.loCreat connection
           outcome <- for oid \o -> do
-            fd <- connection.loOpen o ReadMode
-            closed <- for fd (connection.loClose)
-            readAfterClose <- join <$> for fd \f -> connection.loRead f 10
+            fd <- Pqi.loOpen connection o ReadMode
+            closed <- for fd (Pqi.loClose connection)
+            readAfterClose <- join <$> for fd \f -> Pqi.loRead connection f 10
             pure (closed, readAfterClose)
-          traverse_ connection.loUnlink oid
+          traverse_ (Pqi.loUnlink connection) oid
           pure outcome
diff --git a/src/library/Pqi/Conformance/Operation/LoCreat.hs b/src/library/Pqi/Conformance/Operation/LoCreat.hs
--- a/src/library/Pqi/Conformance/Operation/LoCreat.hs
+++ b/src/library/Pqi/Conformance/Operation/LoCreat.hs
@@ -20,6 +20,6 @@
     it "creates a large object" \conninfo ->
       differential adapter conninfo \connection ->
         inTransaction connection do
-          oid <- connection.loCreat
-          traverse_ connection.loUnlink oid
+          oid <- Pqi.loCreat connection
+          traverse_ (Pqi.loUnlink connection) oid
           pure (isJust oid)
diff --git a/src/library/Pqi/Conformance/Operation/LoCreate.hs b/src/library/Pqi/Conformance/Operation/LoCreate.hs
--- a/src/library/Pqi/Conformance/Operation/LoCreate.hs
+++ b/src/library/Pqi/Conformance/Operation/LoCreate.hs
@@ -22,9 +22,9 @@
         inTransaction connection do
           -- Best-effort cleanup of leftovers from an earlier crashed run; its
           -- outcome legitimately differs between runs, so it is not observed.
-          _ <- connection.loUnlink explicitOid
-          created <- connection.loCreate explicitOid
-          unlinked <- for created connection.loUnlink
+          _ <- Pqi.loUnlink connection explicitOid
+          created <- Pqi.loCreate connection explicitOid
+          unlinked <- for created (Pqi.loUnlink connection)
           pure (created, unlinked)
   where
     explicitOid = 424242
diff --git a/src/library/Pqi/Conformance/Operation/LoExport.hs b/src/library/Pqi/Conformance/Operation/LoExport.hs
--- a/src/library/Pqi/Conformance/Operation/LoExport.hs
+++ b/src/library/Pqi/Conformance/Operation/LoExport.hs
@@ -26,9 +26,9 @@
         hClose importHandle
         (exportPath, exportHandle) <- openBinaryTempFile "/tmp" "pqi-conformance-export-out"
         hClose exportHandle
-        imported <- connection.loImport importPath
-        exported <- for imported \o -> connection.loExport o exportPath
-        traverse_ connection.loUnlink imported
+        imported <- Pqi.loImport connection importPath
+        exported <- for imported \o -> Pqi.loExport connection o exportPath
+        traverse_ (Pqi.loUnlink connection) imported
         roundTripped <- ByteString.readFile exportPath
         removeFile importPath
         removeFile exportPath
diff --git a/src/library/Pqi/Conformance/Operation/LoImport.hs b/src/library/Pqi/Conformance/Operation/LoImport.hs
--- a/src/library/Pqi/Conformance/Operation/LoImport.hs
+++ b/src/library/Pqi/Conformance/Operation/LoImport.hs
@@ -24,7 +24,7 @@
         (path, handle) <- openBinaryTempFile "/tmp" "pqi-conformance-import"
         ByteString.hPut handle "pqi conformance payload"
         hClose handle
-        imported <- connection.loImport path
-        traverse_ connection.loUnlink imported
+        imported <- Pqi.loImport connection path
+        traverse_ (Pqi.loUnlink connection) imported
         removeFile path
         pure (isJust imported)
diff --git a/src/library/Pqi/Conformance/Operation/LoImportWithOid.hs b/src/library/Pqi/Conformance/Operation/LoImportWithOid.hs
--- a/src/library/Pqi/Conformance/Operation/LoImportWithOid.hs
+++ b/src/library/Pqi/Conformance/Operation/LoImportWithOid.hs
@@ -25,9 +25,9 @@
         (path, handle) <- openBinaryTempFile "/tmp" "pqi-conformance-import-oid"
         ByteString.hPut handle "pqi conformance payload"
         hClose handle
-        _ <- connection.loUnlink explicitOid
-        imported <- connection.loImportWithOid path explicitOid
-        unlinked <- for imported connection.loUnlink
+        _ <- Pqi.loUnlink connection explicitOid
+        imported <- Pqi.loImportWithOid connection path explicitOid
+        unlinked <- for imported (Pqi.loUnlink connection)
         removeFile path
         pure (imported, unlinked)
   where
diff --git a/src/library/Pqi/Conformance/Operation/LoOpen.hs b/src/library/Pqi/Conformance/Operation/LoOpen.hs
--- a/src/library/Pqi/Conformance/Operation/LoOpen.hs
+++ b/src/library/Pqi/Conformance/Operation/LoOpen.hs
@@ -18,13 +18,13 @@
     it "opens an existing object and rejects a missing one" \conninfo ->
       differential adapter conninfo \connection ->
         inTransaction connection do
-          oid <- connection.loCreat
+          oid <- Pqi.loCreat connection
           opened <- for oid \o -> do
-            fd <- connection.loOpen o ReadWriteMode
-            traverse_ connection.loClose fd
+            fd <- Pqi.loOpen connection o ReadWriteMode
+            traverse_ (Pqi.loClose connection) fd
             pure (isJust fd)
           loUnlink' oid connection
-          missing <- connection.loOpen 4242424 ReadMode
+          missing <- Pqi.loOpen connection 4242424 ReadMode
           pure (opened, isJust missing)
   where
-    loUnlink' oid connection = traverse_ connection.loUnlink oid
+    loUnlink' oid connection = traverse_ (Pqi.loUnlink connection) oid
diff --git a/src/library/Pqi/Conformance/Operation/LoRead.hs b/src/library/Pqi/Conformance/Operation/LoRead.hs
--- a/src/library/Pqi/Conformance/Operation/LoRead.hs
+++ b/src/library/Pqi/Conformance/Operation/LoRead.hs
@@ -18,14 +18,14 @@
     it "reads back what was written" \conninfo ->
       differential adapter conninfo \connection ->
         inTransaction connection do
-          oid <- connection.loCreat
+          oid <- Pqi.loCreat connection
           outcome <- for oid \o -> do
-            fd <- connection.loOpen o ReadWriteMode
+            fd <- Pqi.loOpen connection o ReadWriteMode
             readBytes <- for fd \f -> do
-              _ <- connection.loWrite f "hello, large object"
-              _ <- connection.loSeek f AbsoluteSeek 0
-              connection.loRead f 5
-            traverse_ connection.loClose fd
+              _ <- Pqi.loWrite connection f "hello, large object"
+              _ <- Pqi.loSeek connection f AbsoluteSeek 0
+              Pqi.loRead connection f 5
+            traverse_ (Pqi.loClose connection) fd
             pure readBytes
-          traverse_ connection.loUnlink oid
+          traverse_ (Pqi.loUnlink connection) oid
           pure outcome
diff --git a/src/library/Pqi/Conformance/Operation/LoSeek.hs b/src/library/Pqi/Conformance/Operation/LoSeek.hs
--- a/src/library/Pqi/Conformance/Operation/LoSeek.hs
+++ b/src/library/Pqi/Conformance/Operation/LoSeek.hs
@@ -18,16 +18,16 @@
     it "seeks absolutely, relatively, and from the end" \conninfo ->
       differential adapter conninfo \connection ->
         inTransaction connection do
-          oid <- connection.loCreat
+          oid <- Pqi.loCreat connection
           outcome <- for oid \o -> do
-            fd <- connection.loOpen o ReadWriteMode
+            fd <- Pqi.loOpen connection o ReadWriteMode
             seeks <- for fd \f -> do
-              _ <- connection.loWrite f "hello, large object"
-              absolute <- connection.loSeek f AbsoluteSeek 0
-              relative <- connection.loSeek f RelativeSeek 2
-              fromEnd <- connection.loSeek f SeekFromEnd (-6)
+              _ <- Pqi.loWrite connection f "hello, large object"
+              absolute <- Pqi.loSeek connection f AbsoluteSeek 0
+              relative <- Pqi.loSeek connection f RelativeSeek 2
+              fromEnd <- Pqi.loSeek connection f SeekFromEnd (-6)
               pure (absolute, relative, fromEnd)
-            traverse_ connection.loClose fd
+            traverse_ (Pqi.loClose connection) fd
             pure seeks
-          traverse_ connection.loUnlink oid
+          traverse_ (Pqi.loUnlink connection) oid
           pure outcome
diff --git a/src/library/Pqi/Conformance/Operation/LoTell.hs b/src/library/Pqi/Conformance/Operation/LoTell.hs
--- a/src/library/Pqi/Conformance/Operation/LoTell.hs
+++ b/src/library/Pqi/Conformance/Operation/LoTell.hs
@@ -18,16 +18,16 @@
     it "reports the position after a write and a seek" \conninfo ->
       differential adapter conninfo \connection ->
         inTransaction connection do
-          oid <- connection.loCreat
+          oid <- Pqi.loCreat connection
           outcome <- for oid \o -> do
-            fd <- connection.loOpen o ReadWriteMode
+            fd <- Pqi.loOpen connection o ReadWriteMode
             positions <- for fd \f -> do
-              _ <- connection.loWrite f "hello, large object"
-              afterWrite <- connection.loTell f
-              _ <- connection.loSeek f AbsoluteSeek 3
-              afterSeek <- connection.loTell f
+              _ <- Pqi.loWrite connection f "hello, large object"
+              afterWrite <- Pqi.loTell connection f
+              _ <- Pqi.loSeek connection f AbsoluteSeek 3
+              afterSeek <- Pqi.loTell connection f
               pure (afterWrite, afterSeek)
-            traverse_ connection.loClose fd
+            traverse_ (Pqi.loClose connection) fd
             pure positions
-          traverse_ connection.loUnlink oid
+          traverse_ (Pqi.loUnlink connection) oid
           pure outcome
diff --git a/src/library/Pqi/Conformance/Operation/LoTruncate.hs b/src/library/Pqi/Conformance/Operation/LoTruncate.hs
--- a/src/library/Pqi/Conformance/Operation/LoTruncate.hs
+++ b/src/library/Pqi/Conformance/Operation/LoTruncate.hs
@@ -18,15 +18,15 @@
     it "truncates to a new size" \conninfo ->
       differential adapter conninfo \connection ->
         inTransaction connection do
-          oid <- connection.loCreat
+          oid <- Pqi.loCreat connection
           outcome <- for oid \o -> do
-            fd <- connection.loOpen o ReadWriteMode
+            fd <- Pqi.loOpen connection o ReadWriteMode
             result <- for fd \f -> do
-              _ <- connection.loWrite f "hello, large object"
-              truncated <- connection.loTruncate f 5
-              newEnd <- connection.loSeek f SeekFromEnd 0
+              _ <- Pqi.loWrite connection f "hello, large object"
+              truncated <- Pqi.loTruncate connection f 5
+              newEnd <- Pqi.loSeek connection f SeekFromEnd 0
               pure (truncated, newEnd)
-            traverse_ connection.loClose fd
+            traverse_ (Pqi.loClose connection) fd
             pure result
-          traverse_ connection.loUnlink oid
+          traverse_ (Pqi.loUnlink connection) oid
           pure outcome
diff --git a/src/library/Pqi/Conformance/Operation/LoUnlink.hs b/src/library/Pqi/Conformance/Operation/LoUnlink.hs
--- a/src/library/Pqi/Conformance/Operation/LoUnlink.hs
+++ b/src/library/Pqi/Conformance/Operation/LoUnlink.hs
@@ -17,7 +17,7 @@
     it "removes an existing object and rejects a missing one" \conninfo ->
       differential adapter conninfo \connection ->
         inTransaction connection do
-          oid <- connection.loCreat
-          removed <- for oid connection.loUnlink
-          missing <- connection.loUnlink 4242424
+          oid <- Pqi.loCreat connection
+          removed <- for oid (Pqi.loUnlink connection)
+          missing <- Pqi.loUnlink connection 4242424
           pure (removed, missing)
diff --git a/src/library/Pqi/Conformance/Operation/LoWrite.hs b/src/library/Pqi/Conformance/Operation/LoWrite.hs
--- a/src/library/Pqi/Conformance/Operation/LoWrite.hs
+++ b/src/library/Pqi/Conformance/Operation/LoWrite.hs
@@ -17,11 +17,11 @@
     it "reports the number of bytes written" \conninfo ->
       differential adapter conninfo \connection ->
         inTransaction connection do
-          oid <- connection.loCreat
+          oid <- Pqi.loCreat connection
           outcome <- for oid \o -> do
-            fd <- connection.loOpen o ReadWriteMode
-            written <- for fd \f -> connection.loWrite f "hello, large object"
-            traverse_ connection.loClose fd
+            fd <- Pqi.loOpen connection o ReadWriteMode
+            written <- for fd \f -> Pqi.loWrite connection f "hello, large object"
+            traverse_ (Pqi.loClose connection) fd
             pure written
-          traverse_ connection.loUnlink oid
+          traverse_ (Pqi.loUnlink connection) oid
           pure outcome
diff --git a/src/library/Pqi/Conformance/Operation/NewNullConnection.hs b/src/library/Pqi/Conformance/Operation/NewNullConnection.hs
--- a/src/library/Pqi/Conformance/Operation/NewNullConnection.hs
+++ b/src/library/Pqi/Conformance/Operation/NewNullConnection.hs
@@ -15,8 +15,8 @@
   describe "newNullConnection" do
     it "produces a connection that is null and bad" \conninfo ->
       differentialConnect adapter conninfo \adapter' _ -> do
-        connection <- adapter'.newNullConnection
-        nullness <- pure connection.isNullConnection
-        badness <- connection.status
-        connection.finish
+        connection <- Pqi.newNullConnection adapter'
+        nullness <- pure (Pqi.isNullConnection connection)
+        badness <- Pqi.status connection
+        Pqi.finish connection
         pure (nullness, badness)
diff --git a/src/library/Pqi/Conformance/Operation/Nfields.hs b/src/library/Pqi/Conformance/Operation/Nfields.hs
--- a/src/library/Pqi/Conformance/Operation/Nfields.hs
+++ b/src/library/Pqi/Conformance/Operation/Nfields.hs
@@ -15,7 +15,7 @@
   describe "nfields" do
     it "counts columns across result shapes" \conninfo ->
       differential adapter conninfo \connection -> do
-        let countOf sql = connection.exec sql >>= traverse (.nfields)
+        let countOf sql = Pqi.exec connection sql >>= traverse Pqi.nfields
         several <- countOf "select 1, 2, 3"
         zero <- countOf "select"
         command <- countOf "create temporary table conformance_nfields (id int4)"
diff --git a/src/library/Pqi/Conformance/Operation/Notifies.hs b/src/library/Pqi/Conformance/Operation/Notifies.hs
--- a/src/library/Pqi/Conformance/Operation/Notifies.hs
+++ b/src/library/Pqi/Conformance/Operation/Notifies.hs
@@ -5,7 +5,7 @@
 -- candidate and the reference are distinct backends — so 'bePid' is omitted
 -- from the cross-adapter comparison. Each scenario that receives a
 -- notification instead asserts independently (per adapter) that
--- @notification.bePid == backendPID connection@, verifying that the PID field
+-- @Pqi.bePid notification == backendPID connection@, verifying that the PID field
 -- is correctly populated without comparing it across adapters.
 module Pqi.Conformance.Operation.Notifies
   ( spec,
@@ -23,36 +23,36 @@
   describe "notifies" do
     it "is empty with no pending notifications" \conninfo ->
       differential adapter conninfo \connection ->
-        fmap channelAndPayload <$> connection.notifies
+        fmap channelAndPayload <$> Pqi.notifies connection
 
     it "delivers a listen/notify round-trip and then drains" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.exec "listen conformance_channel"
-        _ <- connection.exec "notify conformance_channel, 'payload-1'"
-        notification <- connection.notifies
-        pid <- connection.backendPID
-        for_ notification \n -> n.bePid `shouldBe` pid
-        drained <- fmap channelAndPayload <$> connection.notifies
+        _ <- Pqi.exec connection "listen conformance_channel"
+        _ <- Pqi.exec connection "notify conformance_channel, 'payload-1'"
+        notification <- Pqi.notifies connection
+        pid <- Pqi.backendPID connection
+        for_ notification \n -> Pqi.bePid n `shouldBe` pid
+        drained <- fmap channelAndPayload <$> Pqi.notifies connection
         pure (fmap channelAndPayload notification, drained)
 
     it "queues notifications in order" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.exec "listen conformance_channel"
-        _ <- connection.exec "notify conformance_channel, 'first'"
-        _ <- connection.exec "notify conformance_channel, 'second'"
-        first <- connection.notifies
-        second <- connection.notifies
-        third <- connection.notifies
-        pid <- connection.backendPID
-        for_ first \n -> n.bePid `shouldBe` pid
-        for_ second \n -> n.bePid `shouldBe` pid
+        _ <- Pqi.exec connection "listen conformance_channel"
+        _ <- Pqi.exec connection "notify conformance_channel, 'first'"
+        _ <- Pqi.exec connection "notify conformance_channel, 'second'"
+        first <- Pqi.notifies connection
+        second <- Pqi.notifies connection
+        third <- Pqi.notifies connection
+        pid <- Pqi.backendPID connection
+        for_ first \n -> Pqi.bePid n `shouldBe` pid
+        for_ second \n -> Pqi.bePid n `shouldBe` pid
         pure (fmap channelAndPayload first, fmap channelAndPayload second, fmap channelAndPayload third)
 
     it "stops delivery after unlisten" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.exec "listen conformance_channel"
-        _ <- connection.exec "unlisten conformance_channel"
-        _ <- connection.exec "notify conformance_channel, 'lost'"
-        fmap channelAndPayload <$> connection.notifies
+        _ <- Pqi.exec connection "listen conformance_channel"
+        _ <- Pqi.exec connection "unlisten conformance_channel"
+        _ <- Pqi.exec connection "notify conformance_channel, 'lost'"
+        fmap channelAndPayload <$> Pqi.notifies connection
   where
-    channelAndPayload notification = (notification.relname, notification.extra)
+    channelAndPayload notification = (Pqi.relname notification, Pqi.extra notification)
diff --git a/src/library/Pqi/Conformance/Operation/Nparams.hs b/src/library/Pqi/Conformance/Operation/Nparams.hs
--- a/src/library/Pqi/Conformance/Operation/Nparams.hs
+++ b/src/library/Pqi/Conformance/Operation/Nparams.hs
@@ -15,12 +15,12 @@
   describe "nparams" do
     it "counts the parameters of a prepared statement" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.prepare "conformance_nparams" "select $1 :: int4, $2 :: text" Nothing
-        described <- connection.describePrepared "conformance_nparams"
-        for described (.nparams)
+        _ <- Pqi.prepare connection "conformance_nparams" "select $1 :: int4, $2 :: text" Nothing
+        described <- Pqi.describePrepared connection "conformance_nparams"
+        for described Pqi.nparams
 
     it "is zero for a parameterless statement" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.prepare "conformance_nparams_zero" "select 42" Nothing
-        described <- connection.describePrepared "conformance_nparams_zero"
-        for described (.nparams)
+        _ <- Pqi.prepare connection "conformance_nparams_zero" "select 42" Nothing
+        described <- Pqi.describePrepared connection "conformance_nparams_zero"
+        for described Pqi.nparams
diff --git a/src/library/Pqi/Conformance/Operation/Ntuples.hs b/src/library/Pqi/Conformance/Operation/Ntuples.hs
--- a/src/library/Pqi/Conformance/Operation/Ntuples.hs
+++ b/src/library/Pqi/Conformance/Operation/Ntuples.hs
@@ -15,7 +15,7 @@
   describe "ntuples" do
     it "counts rows across result shapes" \conninfo ->
       differential adapter conninfo \connection -> do
-        let countOf sql = connection.exec sql >>= traverse (.ntuples)
+        let countOf sql = Pqi.exec connection sql >>= traverse Pqi.ntuples
         many <- countOf "select i from generate_series (1, 3) as i"
         none <- countOf "select 1 where false"
         command <- countOf "create temporary table conformance_ntuples (id int4)"
diff --git a/src/library/Pqi/Conformance/Operation/Options.hs b/src/library/Pqi/Conformance/Operation/Options.hs
--- a/src/library/Pqi/Conformance/Operation/Options.hs
+++ b/src/library/Pqi/Conformance/Operation/Options.hs
@@ -14,4 +14,4 @@
 spec adapter =
   describe "options" do
     it "reports the command-line options from the conninfo" \conninfo ->
-      differential adapter conninfo (.options)
+      differential adapter conninfo Pqi.options
diff --git a/src/library/Pqi/Conformance/Operation/ParameterStatus.hs b/src/library/Pqi/Conformance/Operation/ParameterStatus.hs
--- a/src/library/Pqi/Conformance/Operation/ParameterStatus.hs
+++ b/src/library/Pqi/Conformance/Operation/ParameterStatus.hs
@@ -15,11 +15,11 @@
   describe "parameterStatus" do
     it "reports parameter statuses, including GUC_REPORT updates" \conninfo ->
       differential adapter conninfo \connection -> do
-        before <- connection.parameterStatus "application_name"
-        _ <- connection.exec "set application_name to 'pqi-conformance'"
-        after <- connection.parameterStatus "application_name"
-        clientEncoding <- connection.parameterStatus "client_encoding"
-        standardConformingStrings <- connection.parameterStatus "standard_conforming_strings"
-        integerDatetimes <- connection.parameterStatus "integer_datetimes"
-        missing <- connection.parameterStatus "no_such_parameter"
+        before <- Pqi.parameterStatus connection "application_name"
+        _ <- Pqi.exec connection "set application_name to 'pqi-conformance'"
+        after <- Pqi.parameterStatus connection "application_name"
+        clientEncoding <- Pqi.parameterStatus connection "client_encoding"
+        standardConformingStrings <- Pqi.parameterStatus connection "standard_conforming_strings"
+        integerDatetimes <- Pqi.parameterStatus connection "integer_datetimes"
+        missing <- Pqi.parameterStatus connection "no_such_parameter"
         pure (before, after, clientEncoding, standardConformingStrings, integerDatetimes, missing)
diff --git a/src/library/Pqi/Conformance/Operation/Paramtype.hs b/src/library/Pqi/Conformance/Operation/Paramtype.hs
--- a/src/library/Pqi/Conformance/Operation/Paramtype.hs
+++ b/src/library/Pqi/Conformance/Operation/Paramtype.hs
@@ -16,16 +16,16 @@
   describe "paramtype" do
     it "reports inferred parameter types" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.prepare "conformance_paramtype" "select $1 :: int4, $2 :: text" Nothing
-        described <- connection.describePrepared "conformance_paramtype"
+        _ <- Pqi.prepare connection "conformance_paramtype" "select $1 :: int4, $2 :: text" Nothing
+        described <- Pqi.describePrepared connection "conformance_paramtype"
         for described \r -> do
-          n <- r.nparams
-          traverse r.paramtype [0 .. n - 1]
+          n <- Pqi.nparams r
+          traverse (Pqi.paramtype r) [0 .. n - 1]
 
     it "reports explicitly requested parameter types" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.prepare "conformance_paramtype_typed" "select $1" (Just [int8Oid])
-        described <- connection.describePrepared "conformance_paramtype_typed"
+        _ <- Pqi.prepare connection "conformance_paramtype_typed" "select $1" (Just [int8Oid])
+        described <- Pqi.describePrepared connection "conformance_paramtype_typed"
         for described \r -> do
-          n <- r.nparams
-          traverse r.paramtype [0 .. n - 1]
+          n <- Pqi.nparams r
+          traverse (Pqi.paramtype r) [0 .. n - 1]
diff --git a/src/library/Pqi/Conformance/Operation/Pass.hs b/src/library/Pqi/Conformance/Operation/Pass.hs
--- a/src/library/Pqi/Conformance/Operation/Pass.hs
+++ b/src/library/Pqi/Conformance/Operation/Pass.hs
@@ -14,4 +14,4 @@
 spec adapter =
   describe "pass" do
     it "reports the password from the conninfo" \conninfo ->
-      differential adapter conninfo (.pass)
+      differential adapter conninfo Pqi.pass
diff --git a/src/library/Pqi/Conformance/Operation/PipelineStatus.hs b/src/library/Pqi/Conformance/Operation/PipelineStatus.hs
--- a/src/library/Pqi/Conformance/Operation/PipelineStatus.hs
+++ b/src/library/Pqi/Conformance/Operation/PipelineStatus.hs
@@ -18,16 +18,16 @@
   describe "pipelineStatus" do
     it "reports off, on, aborted, and recovery" \conninfo ->
       differential adapter conninfo \connection -> do
-        off <- connection.pipelineStatus
-        _ <- connection.enterPipelineMode
-        on <- connection.pipelineStatus
-        _ <- traverse (\sql -> connection.sendQueryParams sql [] Lq.Text) ["select 1", "select 1 / 0", "select 3"]
-        _ <- connection.pipelineSync
+        off <- Lq.pipelineStatus connection
+        _ <- Lq.enterPipelineMode connection
+        on <- Lq.pipelineStatus connection
+        _ <- traverse (\sql -> Lq.sendQueryParams connection sql [] Lq.Text) ["select 1", "select 1 / 0", "select 3"]
+        _ <- Lq.pipelineSync connection
         _ <- takeCommandResults connection
         _ <- takeCommandResults connection
-        aborted <- connection.pipelineStatus
+        aborted <- Lq.pipelineStatus connection
         _ <- takeCommandResults connection
         _ <- takeResult connection
-        recovered <- connection.pipelineStatus
-        _ <- connection.exitPipelineMode
+        recovered <- Lq.pipelineStatus connection
+        _ <- Lq.exitPipelineMode connection
         pure (off, on, aborted, recovered)
diff --git a/src/library/Pqi/Conformance/Operation/PipelineSync.hs b/src/library/Pqi/Conformance/Operation/PipelineSync.hs
--- a/src/library/Pqi/Conformance/Operation/PipelineSync.hs
+++ b/src/library/Pqi/Conformance/Operation/PipelineSync.hs
@@ -19,40 +19,40 @@
     Parity.spec adapter
     it "collects pipelined queries per sync" \conninfo ->
       differential adapter conninfo \connection -> do
-        entered <- connection.enterPipelineMode
+        entered <- Lq.enterPipelineMode connection
         sent <-
           traverse
-            (\sql -> connection.sendQueryParams sql [] Lq.Text)
+            (\sql -> Lq.sendQueryParams connection sql [] Lq.Text)
             ["select 1 :: int4", "select 'two' :: text", "select 3 :: int4, 'three' :: text"]
-        synced <- connection.pipelineSync
+        synced <- Lq.pipelineSync connection
         first <- takeCommandResults connection
         second <- takeCommandResults connection
         third <- takeCommandResults connection
         syncResult <- takeResult connection
         idle <- takeResult connection
-        exited <- connection.exitPipelineMode
+        exited <- Lq.exitPipelineMode connection
         pure (entered, sent, synced, first, second, third, syncResult, idle, exited)
 
     it "aborts the rest of the pipeline after an error" \conninfo ->
       differential adapter conninfo \connection -> do
-        entered <- connection.enterPipelineMode
+        entered <- Lq.enterPipelineMode connection
         sent <-
           traverse
-            (\sql -> connection.sendQueryParams sql [] Lq.Text)
+            (\sql -> Lq.sendQueryParams connection sql [] Lq.Text)
             ["select 1", "select 1 / 0", "select 3"]
-        synced <- connection.pipelineSync
+        synced <- Lq.pipelineSync connection
         first <- takeCommandResults connection
         failed <- takeCommandResults connection
         aborted <- takeCommandResults connection
         syncResult <- takeResult connection
-        exited <- connection.exitPipelineMode
+        exited <- Lq.exitPipelineMode connection
         pure (entered, sent, synced, first, failed, aborted, syncResult, exited)
 
     it "returns a sync result when called without prior commands" \conninfo ->
       differential adapter conninfo \connection -> do
-        entered <- connection.enterPipelineMode
-        synced <- connection.pipelineSync
+        entered <- Lq.enterPipelineMode connection
+        synced <- Lq.pipelineSync connection
         syncResult <- takeResult connection
         trailing <- takeResult connection
-        exited <- connection.exitPipelineMode
+        exited <- Lq.exitPipelineMode connection
         pure (entered, synced, syncResult, trailing, exited)
diff --git a/src/library/Pqi/Conformance/Operation/PipelineSync/Parity.hs b/src/library/Pqi/Conformance/Operation/PipelineSync/Parity.hs
--- a/src/library/Pqi/Conformance/Operation/PipelineSync/Parity.hs
+++ b/src/library/Pqi/Conformance/Operation/PipelineSync/Parity.hs
@@ -25,13 +25,13 @@
       differential adapter conninfo \connection -> do
         let query = "SELECT 1, 2"
         sequential <- replicateM 100 (observed query [] Lq.Text connection)
-        entered <- connection.enterPipelineMode
-        sent <- replicateM 100 (connection.sendQueryParams query [] Lq.Text)
-        synced <- connection.pipelineSync
+        entered <- Lq.enterPipelineMode connection
+        sent <- replicateM 100 (Lq.sendQueryParams connection query [] Lq.Text)
+        synced <- Lq.pipelineSync connection
         pipeline <- replicateM 100 (takeCommandResults connection)
         syncResult <- takeResult connection
         trailing <- takeResult connection
-        exited <- connection.exitPipelineMode
+        exited <- Lq.exitPipelineMode connection
         let pipelineResults = map fst pipeline
         sequential `shouldBe` pipelineResults
         pure (entered, sent, synced, pipeline, syncResult, trailing, exited, sequential)
@@ -40,13 +40,13 @@
       differential adapter conninfo \connection -> do
         let query = "SELECT generate_series(0,1000) as a, generate_series(1000,2000) as b"
         sequential <- replicateM 100 (observed query [] Lq.Text connection)
-        entered <- connection.enterPipelineMode
-        sent <- replicateM 100 (connection.sendQueryParams query [] Lq.Text)
-        synced <- connection.pipelineSync
+        entered <- Lq.enterPipelineMode connection
+        sent <- replicateM 100 (Lq.sendQueryParams connection query [] Lq.Text)
+        synced <- Lq.pipelineSync connection
         pipeline <- replicateM 100 (takeCommandResults connection)
         syncResult <- takeResult connection
         trailing <- takeResult connection
-        exited <- connection.exitPipelineMode
+        exited <- Lq.exitPipelineMode connection
         let pipelineResults = map fst pipeline
         sequential `shouldBe` pipelineResults
         pure (entered, sent, synced, pipeline, syncResult, trailing, exited, sequential)
diff --git a/src/library/Pqi/Conformance/Operation/Port.hs b/src/library/Pqi/Conformance/Operation/Port.hs
--- a/src/library/Pqi/Conformance/Operation/Port.hs
+++ b/src/library/Pqi/Conformance/Operation/Port.hs
@@ -13,4 +13,4 @@
 spec adapter =
   describe "port" do
     it "reports the port from the conninfo" \conninfo ->
-      differential adapter conninfo (.port)
+      differential adapter conninfo Pqi.port
diff --git a/src/library/Pqi/Conformance/Operation/Prepare.hs b/src/library/Pqi/Conformance/Operation/Prepare.hs
--- a/src/library/Pqi/Conformance/Operation/Prepare.hs
+++ b/src/library/Pqi/Conformance/Operation/Prepare.hs
@@ -16,13 +16,13 @@
   describe "prepare" do
     it "reports its own result" \conninfo ->
       differential adapter conninfo \connection ->
-        connection.prepare "conformance_prep_result" "select $1 :: int4" Nothing
+        Pqi.prepare connection "conformance_prep_result" "select $1 :: int4" Nothing
           >>= traverse observeResult
 
     it "rejects a duplicate statement name" \conninfo ->
       differential adapter conninfo \connection -> do
         first <-
-          connection.prepare "conformance_dup" "select 1" Nothing >>= traverse observeResult
+          Pqi.prepare connection "conformance_dup" "select 1" Nothing >>= traverse observeResult
         second <-
-          connection.prepare "conformance_dup" "select 2" Nothing >>= traverse observeResult
+          Pqi.prepare connection "conformance_dup" "select 2" Nothing >>= traverse observeResult
         pure (first, second)
diff --git a/src/library/Pqi/Conformance/Operation/ProtocolVersion.hs b/src/library/Pqi/Conformance/Operation/ProtocolVersion.hs
--- a/src/library/Pqi/Conformance/Operation/ProtocolVersion.hs
+++ b/src/library/Pqi/Conformance/Operation/ProtocolVersion.hs
@@ -14,4 +14,4 @@
 spec adapter =
   describe "protocolVersion" do
     it "reports the protocol version" \conninfo ->
-      differential adapter conninfo (.protocolVersion)
+      differential adapter conninfo Pqi.protocolVersion
diff --git a/src/library/Pqi/Conformance/Operation/PutCopyData.hs b/src/library/Pqi/Conformance/Operation/PutCopyData.hs
--- a/src/library/Pqi/Conformance/Operation/PutCopyData.hs
+++ b/src/library/Pqi/Conformance/Operation/PutCopyData.hs
@@ -16,11 +16,11 @@
   describe "putCopyData" do
     it "streams rows into a COPY FROM STDIN" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.exec "create temporary table conformance_copy (id int4, label text)"
+        _ <- Pqi.exec connection "create temporary table conformance_copy (id int4, label text)"
         started <- execScenario "copy conformance_copy from stdin" connection
-        firstRow <- connection.putCopyData "1\thello\n"
-        secondRow <- connection.putCopyData "2\tworld\n"
-        ended <- connection.putCopyEnd Nothing
+        firstRow <- Pqi.putCopyData connection "1\thello\n"
+        secondRow <- Pqi.putCopyData connection "2\tworld\n"
+        ended <- Pqi.putCopyEnd connection Nothing
         outcome <- drainResults connection
         check <-
           execScenario "select count(*), min(label), max(label) from conformance_copy" connection
@@ -28,9 +28,9 @@
 
     it "feeds malformed data that the server rejects" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.exec "create temporary table conformance_copy_bad (id int4)"
+        _ <- Pqi.exec connection "create temporary table conformance_copy_bad (id int4)"
         started <- execScenario "copy conformance_copy_bad from stdin" connection
-        row <- connection.putCopyData "not-a-number\n"
-        ended <- connection.putCopyEnd Nothing
+        row <- Pqi.putCopyData connection "not-a-number\n"
+        ended <- Pqi.putCopyEnd connection Nothing
         outcome <- drainResults connection
         pure (started, row, ended, outcome)
diff --git a/src/library/Pqi/Conformance/Operation/PutCopyEnd.hs b/src/library/Pqi/Conformance/Operation/PutCopyEnd.hs
--- a/src/library/Pqi/Conformance/Operation/PutCopyEnd.hs
+++ b/src/library/Pqi/Conformance/Operation/PutCopyEnd.hs
@@ -16,20 +16,20 @@
   describe "putCopyEnd" do
     it "commits the copied rows when ended without an error" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.exec "create temporary table conformance_copy_end (id int4)"
+        _ <- Pqi.exec connection "create temporary table conformance_copy_end (id int4)"
         started <- execScenario "copy conformance_copy_end from stdin" connection
-        row <- connection.putCopyData "1\n"
-        ended <- connection.putCopyEnd Nothing
+        row <- Pqi.putCopyData connection "1\n"
+        ended <- Pqi.putCopyEnd connection Nothing
         outcome <- drainResults connection
         check <- execScenario "select count(*) from conformance_copy_end" connection
         pure (started, row, ended, outcome, check)
 
     it "aborts the copy when ended with an error" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.exec "create temporary table conformance_copy_abort (id int4)"
+        _ <- Pqi.exec connection "create temporary table conformance_copy_abort (id int4)"
         started <- execScenario "copy conformance_copy_abort from stdin" connection
-        row <- connection.putCopyData "1\n"
-        ended <- connection.putCopyEnd (Just "conformance abort")
+        row <- Pqi.putCopyData connection "1\n"
+        ended <- Pqi.putCopyEnd connection (Just "conformance abort")
         outcome <- drainResults connection
         check <- execScenario "select count(*) from conformance_copy_abort" connection
         pure (started, row, ended, outcome, check)
diff --git a/src/library/Pqi/Conformance/Operation/Reset.hs b/src/library/Pqi/Conformance/Operation/Reset.hs
--- a/src/library/Pqi/Conformance/Operation/Reset.hs
+++ b/src/library/Pqi/Conformance/Operation/Reset.hs
@@ -16,11 +16,11 @@
   describe "reset" do
     it "restores a fresh session" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.prepare "conformance_reset" "select 1" Nothing
-        _ <- connection.exec "begin"
-        inTransaction <- connection.transactionStatus
-        connection.reset
+        _ <- Pqi.prepare connection "conformance_reset" "select 1" Nothing
+        _ <- Pqi.exec connection "begin"
+        inTransaction <- Pqi.transactionStatus connection
+        Pqi.reset connection
         afterReset <- observeConnection connection
         -- The prepared statement must be gone in the fresh session.
-        describeAfter <- connection.describePrepared "conformance_reset" >>= traverse observeResult
+        describeAfter <- Pqi.describePrepared connection "conformance_reset" >>= traverse observeResult
         pure (inTransaction, afterReset, describeAfter)
diff --git a/src/library/Pqi/Conformance/Operation/ResetPoll.hs b/src/library/Pqi/Conformance/Operation/ResetPoll.hs
--- a/src/library/Pqi/Conformance/Operation/ResetPoll.hs
+++ b/src/library/Pqi/Conformance/Operation/ResetPoll.hs
@@ -16,8 +16,8 @@
   describe "resetPoll" do
     it "reaches a terminal polling status and a ready connection" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.exec "begin"
-        started <- connection.resetStart
-        terminal <- pollUntilDone connection.resetPoll
-        afterStatus <- connection.transactionStatus
+        _ <- Pqi.exec connection "begin"
+        started <- Pqi.resetStart connection
+        terminal <- pollUntilDone (Pqi.resetPoll connection)
+        afterStatus <- Pqi.transactionStatus connection
         pure (started, terminal, afterStatus)
diff --git a/src/library/Pqi/Conformance/Operation/ResetStart.hs b/src/library/Pqi/Conformance/Operation/ResetStart.hs
--- a/src/library/Pqi/Conformance/Operation/ResetStart.hs
+++ b/src/library/Pqi/Conformance/Operation/ResetStart.hs
@@ -17,8 +17,8 @@
   describe "resetStart" do
     it "begins an asynchronous reset that polls to a fresh session" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.exec "begin"
-        started <- connection.resetStart
-        polled <- pollUntilDone connection.resetPoll
+        _ <- Pqi.exec connection "begin"
+        started <- Pqi.resetStart connection
+        polled <- pollUntilDone (Pqi.resetPoll connection)
         afterReset <- observeConnection connection
         pure (started, polled, afterReset)
diff --git a/src/library/Pqi/Conformance/Operation/ResultErrorMessage.hs b/src/library/Pqi/Conformance/Operation/ResultErrorMessage.hs
--- a/src/library/Pqi/Conformance/Operation/ResultErrorMessage.hs
+++ b/src/library/Pqi/Conformance/Operation/ResultErrorMessage.hs
@@ -23,9 +23,9 @@
     it "matches the full formatted libpq error string on failure and is empty on success" \conninfo ->
       differential adapter conninfo \connection -> do
         failed <-
-          connection.exec "do $$ begin raise exception 'conformance error'; end $$"
-            >>= traverse (.resultErrorMessage)
+          Pqi.exec connection "do $$ begin raise exception 'conformance error'; end $$"
+            >>= traverse Pqi.resultErrorMessage
         succeeded <-
-          connection.exec "select 1"
-            >>= traverse (.resultErrorMessage)
+          Pqi.exec connection "select 1"
+            >>= traverse Pqi.resultErrorMessage
         pure (failed, succeeded)
diff --git a/src/library/Pqi/Conformance/Operation/ResultStatus.hs b/src/library/Pqi/Conformance/Operation/ResultStatus.hs
--- a/src/library/Pqi/Conformance/Operation/ResultStatus.hs
+++ b/src/library/Pqi/Conformance/Operation/ResultStatus.hs
@@ -15,7 +15,7 @@
   describe "resultStatus" do
     it "reports the status for each kind of result" \conninfo ->
       differential adapter conninfo \connection -> do
-        let statusOf sql = connection.exec sql >>= traverse (.resultStatus)
+        let statusOf sql = Pqi.exec connection sql >>= traverse Pqi.resultStatus
         tuples <- statusOf "select 1"
         command <- statusOf "create temporary table conformance_status (id int4)"
         empty <- statusOf ""
diff --git a/src/library/Pqi/Conformance/Operation/SendDescribePortal.hs b/src/library/Pqi/Conformance/Operation/SendDescribePortal.hs
--- a/src/library/Pqi/Conformance/Operation/SendDescribePortal.hs
+++ b/src/library/Pqi/Conformance/Operation/SendDescribePortal.hs
@@ -16,8 +16,8 @@
   describe "sendDescribePortal" do
     it "describes a declared cursor asynchronously" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.exec "begin"
-        _ <- connection.exec "declare conformance_async_cursor cursor for select 1 :: int4 as n"
-        sent <- connection.sendDescribePortal "conformance_async_cursor"
+        _ <- Pqi.exec connection "begin"
+        _ <- Pqi.exec connection "declare conformance_async_cursor cursor for select 1 :: int4 as n"
+        sent <- Pqi.sendDescribePortal connection "conformance_async_cursor"
         results <- drainResults connection
         pure (sent, results)
diff --git a/src/library/Pqi/Conformance/Operation/SendDescribePrepared.hs b/src/library/Pqi/Conformance/Operation/SendDescribePrepared.hs
--- a/src/library/Pqi/Conformance/Operation/SendDescribePrepared.hs
+++ b/src/library/Pqi/Conformance/Operation/SendDescribePrepared.hs
@@ -16,8 +16,8 @@
   describe "sendDescribePrepared" do
     it "describes a prepared statement asynchronously" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.sendPrepare "conformance_send_desc" "select $1 :: int4 * 2" Nothing
+        _ <- Pqi.sendPrepare connection "conformance_send_desc" "select $1 :: int4 * 2" Nothing
         _ <- drainResults connection
-        sent <- connection.sendDescribePrepared "conformance_send_desc"
+        sent <- Pqi.sendDescribePrepared connection "conformance_send_desc"
         results <- drainResults connection
         pure (sent, results)
diff --git a/src/library/Pqi/Conformance/Operation/SendFlushRequest.hs b/src/library/Pqi/Conformance/Operation/SendFlushRequest.hs
--- a/src/library/Pqi/Conformance/Operation/SendFlushRequest.hs
+++ b/src/library/Pqi/Conformance/Operation/SendFlushRequest.hs
@@ -17,11 +17,11 @@
   describe "sendFlushRequest" do
     it "delivers results without a sync" \conninfo ->
       differential adapter conninfo \connection -> do
-        entered <- connection.enterPipelineMode
-        sent <- connection.sendQueryParams "select 42" [] Lq.Text
-        flushRequested <- connection.sendFlushRequest
+        entered <- Lq.enterPipelineMode connection
+        sent <- Lq.sendQueryParams connection "select 42" [] Lq.Text
+        flushRequested <- Lq.sendFlushRequest connection
         results <- takeCommandResults connection
-        synced <- connection.pipelineSync
+        synced <- Lq.pipelineSync connection
         syncResult <- takeResult connection
-        exited <- connection.exitPipelineMode
+        exited <- Lq.exitPipelineMode connection
         pure (entered, sent, flushRequested, results, synced, syncResult, exited)
diff --git a/src/library/Pqi/Conformance/Operation/SendPrepare.hs b/src/library/Pqi/Conformance/Operation/SendPrepare.hs
--- a/src/library/Pqi/Conformance/Operation/SendPrepare.hs
+++ b/src/library/Pqi/Conformance/Operation/SendPrepare.hs
@@ -16,6 +16,6 @@
   describe "sendPrepare" do
     it "prepares a statement asynchronously" \conninfo ->
       differential adapter conninfo \connection -> do
-        sent <- connection.sendPrepare "conformance_send_prepare" "select $1 :: int4 * 2" Nothing
+        sent <- Pqi.sendPrepare connection "conformance_send_prepare" "select $1 :: int4 * 2" Nothing
         results <- drainResults connection
         pure (sent, results)
diff --git a/src/library/Pqi/Conformance/Operation/SendQuery.hs b/src/library/Pqi/Conformance/Operation/SendQuery.hs
--- a/src/library/Pqi/Conformance/Operation/SendQuery.hs
+++ b/src/library/Pqi/Conformance/Operation/SendQuery.hs
@@ -17,7 +17,7 @@
   describe "sendQuery" do
     let sendAndDrain sql conninfo =
           differential adapter conninfo \connection -> do
-            sent <- connection.sendQuery sql
+            sent <- Pqi.sendQuery connection sql
             results <- drainResults connection
             pure (sent, results)
     it "sends a query and collects its result"
diff --git a/src/library/Pqi/Conformance/Operation/SendQueryParams.hs b/src/library/Pqi/Conformance/Operation/SendQueryParams.hs
--- a/src/library/Pqi/Conformance/Operation/SendQueryParams.hs
+++ b/src/library/Pqi/Conformance/Operation/SendQueryParams.hs
@@ -18,7 +18,7 @@
     it "sends a parameterized query and collects its result" \conninfo ->
       differential adapter conninfo \connection -> do
         sent <-
-          connection.sendQueryParams
+          Lq.sendQueryParams connection
             "select $1 :: int4 + $2 :: int4, $3 :: text"
             [Just (int4Oid, "40", Lq.Text), Just (int4Oid, "2", Lq.Text), Nothing]
             Lq.Text
diff --git a/src/library/Pqi/Conformance/Operation/SendQueryPrepared.hs b/src/library/Pqi/Conformance/Operation/SendQueryPrepared.hs
--- a/src/library/Pqi/Conformance/Operation/SendQueryPrepared.hs
+++ b/src/library/Pqi/Conformance/Operation/SendQueryPrepared.hs
@@ -17,8 +17,8 @@
   describe "sendQueryPrepared" do
     it "executes a prepared statement asynchronously" \conninfo ->
       differential adapter conninfo \connection -> do
-        _ <- connection.sendPrepare "conformance_send_exec" "select $1 :: int4 * 2" Nothing
+        _ <- Lq.sendPrepare connection "conformance_send_exec" "select $1 :: int4 * 2" Nothing
         _ <- drainResults connection
-        sent <- connection.sendQueryPrepared "conformance_send_exec" [Just ("21", Lq.Text)] Lq.Text
+        sent <- Lq.sendQueryPrepared connection "conformance_send_exec" [Just ("21", Lq.Text)] Lq.Text
         results <- drainResults connection
         pure (sent, results)
diff --git a/src/library/Pqi/Conformance/Operation/ServerVersion.hs b/src/library/Pqi/Conformance/Operation/ServerVersion.hs
--- a/src/library/Pqi/Conformance/Operation/ServerVersion.hs
+++ b/src/library/Pqi/Conformance/Operation/ServerVersion.hs
@@ -14,4 +14,4 @@
 spec adapter =
   describe "serverVersion" do
     it "reports the server version as an integer" \conninfo ->
-      differential adapter conninfo (.serverVersion)
+      differential adapter conninfo Pqi.serverVersion
diff --git a/src/library/Pqi/Conformance/Operation/SetClientEncoding.hs b/src/library/Pqi/Conformance/Operation/SetClientEncoding.hs
--- a/src/library/Pqi/Conformance/Operation/SetClientEncoding.hs
+++ b/src/library/Pqi/Conformance/Operation/SetClientEncoding.hs
@@ -16,8 +16,8 @@
   describe "setClientEncoding" do
     it "rejects an unknown encoding and leaves the session usable" \conninfo ->
       differential adapter conninfo \connection -> do
-        rejected <- connection.setClientEncoding "BOGUS_ENCODING"
-        unchanged <- connection.clientEncoding
-        stillIdle <- connection.transactionStatus
+        rejected <- Pqi.setClientEncoding connection "BOGUS_ENCODING"
+        unchanged <- Pqi.clientEncoding connection
+        stillIdle <- Pqi.transactionStatus connection
         stillWorks <- execScenario "select 1" connection
         pure (rejected, unchanged, stillIdle, stillWorks)
diff --git a/src/library/Pqi/Conformance/Operation/SetErrorVerbosity.hs b/src/library/Pqi/Conformance/Operation/SetErrorVerbosity.hs
--- a/src/library/Pqi/Conformance/Operation/SetErrorVerbosity.hs
+++ b/src/library/Pqi/Conformance/Operation/SetErrorVerbosity.hs
@@ -16,7 +16,7 @@
   describe "setErrorVerbosity" do
     it "returns the previous setting" \conninfo ->
       differential adapter conninfo \connection -> do
-        beforeTerse <- connection.setErrorVerbosity Lq.ErrorsTerse
-        beforeVerbose <- connection.setErrorVerbosity Lq.ErrorsVerbose
-        beforeDefault <- connection.setErrorVerbosity Lq.ErrorsDefault
+        beforeTerse <- Lq.setErrorVerbosity connection Lq.ErrorsTerse
+        beforeVerbose <- Lq.setErrorVerbosity connection Lq.ErrorsVerbose
+        beforeDefault <- Lq.setErrorVerbosity connection Lq.ErrorsDefault
         pure (beforeTerse, beforeVerbose, beforeDefault)
diff --git a/src/library/Pqi/Conformance/Operation/SetSingleRowMode.hs b/src/library/Pqi/Conformance/Operation/SetSingleRowMode.hs
--- a/src/library/Pqi/Conformance/Operation/SetSingleRowMode.hs
+++ b/src/library/Pqi/Conformance/Operation/SetSingleRowMode.hs
@@ -16,14 +16,14 @@
   describe "setSingleRowMode" do
     it "splits a multi-row result into single-row results" \conninfo ->
       differential adapter conninfo \connection -> do
-        sent <- connection.sendQuery "select i from generate_series (1, 3) as i"
-        singleRow <- connection.setSingleRowMode
+        sent <- Pqi.sendQuery connection "select i from generate_series (1, 3) as i"
+        singleRow <- Pqi.setSingleRowMode connection
         results <- drainResults connection
         pure (sent, singleRow, results)
 
     it "handles an empty result" \conninfo ->
       differential adapter conninfo \connection -> do
-        sent <- connection.sendQuery "select 1 where false"
-        singleRow <- connection.setSingleRowMode
+        sent <- Pqi.sendQuery connection "select 1 where false"
+        singleRow <- Pqi.setSingleRowMode connection
         results <- drainResults connection
         pure (sent, singleRow, results)
diff --git a/src/library/Pqi/Conformance/Operation/Setnonblocking.hs b/src/library/Pqi/Conformance/Operation/Setnonblocking.hs
--- a/src/library/Pqi/Conformance/Operation/Setnonblocking.hs
+++ b/src/library/Pqi/Conformance/Operation/Setnonblocking.hs
@@ -15,8 +15,8 @@
   describe "setnonblocking" do
     it "turns the non-blocking flag on and off" \conninfo ->
       differential adapter conninfo \connection -> do
-        setOn <- connection.setnonblocking True
-        nowOn <- connection.isnonblocking
-        setOff <- connection.setnonblocking False
-        nowOff <- connection.isnonblocking
+        setOn <- Pqi.setnonblocking connection True
+        nowOn <- Pqi.isnonblocking connection
+        setOff <- Pqi.setnonblocking connection False
+        nowOff <- Pqi.isnonblocking connection
         pure (setOn, nowOn, setOff, nowOff)
diff --git a/src/library/Pqi/Conformance/Operation/Socket.hs b/src/library/Pqi/Conformance/Operation/Socket.hs
--- a/src/library/Pqi/Conformance/Operation/Socket.hs
+++ b/src/library/Pqi/Conformance/Operation/Socket.hs
@@ -17,4 +17,4 @@
   describe "socket" do
     it "is present on an open connection" \conninfo ->
       differential adapter conninfo \connection ->
-        isJust <$> connection.socket
+        isJust <$> Pqi.socket connection
diff --git a/src/library/Pqi/Conformance/Operation/Status.hs b/src/library/Pqi/Conformance/Operation/Status.hs
--- a/src/library/Pqi/Conformance/Operation/Status.hs
+++ b/src/library/Pqi/Conformance/Operation/Status.hs
@@ -13,4 +13,4 @@
 spec adapter =
   describe "status" do
     it "reports a ready connection as OK" \conninfo ->
-      differential adapter conninfo (.status)
+      differential adapter conninfo Pqi.status
diff --git a/src/library/Pqi/Conformance/Operation/TransactionStatus.hs b/src/library/Pqi/Conformance/Operation/TransactionStatus.hs
--- a/src/library/Pqi/Conformance/Operation/TransactionStatus.hs
+++ b/src/library/Pqi/Conformance/Operation/TransactionStatus.hs
@@ -15,11 +15,11 @@
   describe "transactionStatus" do
     it "tracks status through a transaction" \conninfo ->
       differential adapter conninfo \connection -> do
-        idle <- connection.transactionStatus
-        _ <- connection.exec "begin"
-        inTransaction <- connection.transactionStatus
-        _ <- connection.exec "select 1 / 0"
-        inError <- connection.transactionStatus
-        _ <- connection.exec "rollback"
-        afterRollback <- connection.transactionStatus
+        idle <- Pqi.transactionStatus connection
+        _ <- Pqi.exec connection "begin"
+        inTransaction <- Pqi.transactionStatus connection
+        _ <- Pqi.exec connection "select 1 / 0"
+        inError <- Pqi.transactionStatus connection
+        _ <- Pqi.exec connection "rollback"
+        afterRollback <- Pqi.transactionStatus connection
         pure (idle, inTransaction, inError, afterRollback)
diff --git a/src/library/Pqi/Conformance/Operation/UnescapeBytea.hs b/src/library/Pqi/Conformance/Operation/UnescapeBytea.hs
--- a/src/library/Pqi/Conformance/Operation/UnescapeBytea.hs
+++ b/src/library/Pqi/Conformance/Operation/UnescapeBytea.hs
@@ -16,8 +16,8 @@
   describe "unescapeBytea" do
     for_ cases \input ->
       it (show input) \_ -> do
-        candidate <- adapter.unescapeBytea input
-        reference <- Reference.adapter.unescapeBytea input
+        candidate <- Pqi.unescapeBytea adapter input
+        reference <- Pqi.unescapeBytea Reference.adapter input
         candidate `shouldBe` reference
   where
     cases =
diff --git a/src/library/Pqi/Conformance/Operation/UnsafeFreeResult.hs b/src/library/Pqi/Conformance/Operation/UnsafeFreeResult.hs
--- a/src/library/Pqi/Conformance/Operation/UnsafeFreeResult.hs
+++ b/src/library/Pqi/Conformance/Operation/UnsafeFreeResult.hs
@@ -21,6 +21,6 @@
   describe "unsafeFreeResult" do
     it "leaves the connection usable" \conninfo ->
       differential adapter conninfo \connection -> do
-        result <- connection.exec "select 1"
-        traverse_ (.unsafeFreeResult) result
+        result <- Pqi.exec connection "select 1"
+        traverse_ Pqi.unsafeFreeResult result
         execScenario "select 2" connection
diff --git a/src/library/Pqi/Conformance/Operation/User.hs b/src/library/Pqi/Conformance/Operation/User.hs
--- a/src/library/Pqi/Conformance/Operation/User.hs
+++ b/src/library/Pqi/Conformance/Operation/User.hs
@@ -13,4 +13,4 @@
 spec adapter =
   describe "user" do
     it "reports the user name from the conninfo" \conninfo ->
-      differential adapter conninfo (.user)
+      differential adapter conninfo Pqi.user
diff --git a/src/library/Pqi/Conformance/Scenario.hs b/src/library/Pqi/Conformance/Scenario.hs
--- a/src/library/Pqi/Conformance/Scenario.hs
+++ b/src/library/Pqi/Conformance/Scenario.hs
@@ -42,7 +42,7 @@
 
 -- | Run 'Pqi.exec' and observe its result (if any).
 execScenario :: ByteString -> Pqi.Connection -> IO (Maybe ResultObservation)
-execScenario sql connection = connection.exec sql >>= traverse observeResult
+execScenario sql connection = Pqi.exec connection sql >>= traverse observeResult
 
 -- | Run a sequence of statements with 'Pqi.exec', observing every result.
 execAllScenario :: [ByteString] -> Pqi.Connection -> IO [Maybe ResultObservation]
@@ -56,7 +56,7 @@
   Pqi.Connection ->
   IO (Maybe ResultObservation)
 observed sql params resultFormat connection =
-  connection.execParams sql params resultFormat >>= traverse observeResult
+  Pqi.execParams connection sql params resultFormat >>= traverse observeResult
 
 -- | Collect and observe results with 'Pqi.getResult' until it reports
 -- completion with 'Nothing'.
@@ -64,7 +64,7 @@
 drainResults connection = go []
   where
     go acc =
-      connection.getResult >>= \case
+      Pqi.getResult connection >>= \case
         Nothing -> pure (reverse acc)
         Just result -> do
           observation <- observeResult result
@@ -72,7 +72,7 @@
 
 -- | One 'Pqi.getResult' step, observed.
 takeResult :: Pqi.Connection -> IO (Maybe ResultObservation)
-takeResult connection = connection.getResult >>= traverse observeResult
+takeResult connection = Pqi.getResult connection >>= traverse observeResult
 
 -- | The results of one pipelined command: its result and the 'Nothing'
 -- separator that ends it.
@@ -91,7 +91,7 @@
   where
     go 0 acc = pure (reverse acc)
     go n acc =
-      connection.getCopyData False >>= \case
+      Pqi.getCopyData connection False >>= \case
         CopyOutRow row -> go (n - 1) (CopyOutRow row : acc)
         terminal -> pure (reverse (terminal : acc))
 
@@ -122,9 +122,9 @@
 -- run inside a transaction block.
 inTransaction :: Pqi.Connection -> IO a -> IO a
 inTransaction connection action = do
-  _ <- connection.exec "begin"
+  _ <- Pqi.exec connection "begin"
   result <- action
-  _ <- connection.exec "commit"
+  _ <- Pqi.exec connection "commit"
   pure result
 
 boolOid :: Word32