diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,2 +1,10 @@
 v 0.1.0.0  
 * Initial version
+
+v 0.2.0.0
+* Documentation Fixes
+* Added export of newPandoc and NamedDoc to Knit.Report to facilitate multi-doc use.
+* Removed redundant imports from Knit.Report.Input.Table.Colonnade
+* Added a multi-doc example
+* (internal) Removed odd, and no longer necessary, "LastMember" constraint from knit functions. 
+* Updated effects for polysemy 1.2
diff --git a/examples/MtlExample.hs b/examples/MtlExample.hs
--- a/examples/MtlExample.hs
+++ b/examples/MtlExample.hs
@@ -61,7 +61,7 @@
 
 makeDoc :: (K.Member K.ToPandoc effs
            , K.PandocEffects effs
-           , K.KnitBase ExampleApp effs) => K.Semantic effs ()
+           , K.KnitBase ExampleApp effs) => K.Sem effs ()
 makeDoc = K.wrapPrefix "makeDoc" $ do
   K.logLE K.Info "adding some markdown..."
   K.addMarkDown md1
diff --git a/examples/MultiDocExample.hs b/examples/MultiDocExample.hs
new file mode 100644
--- /dev/null
+++ b/examples/MultiDocExample.hs
@@ -0,0 +1,91 @@
+{-# LANGUAGE QuasiQuotes       #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeApplications  #-}
+{-# LANGUAGE GADTs             #-}
+module Main where
+
+import qualified Knit.Report as K    
+
+import qualified Data.Map                      as M
+import qualified Data.Text.IO                  as T
+import qualified Data.Text.Lazy                as TL
+import qualified Data.Text                     as T
+import           Data.String.Here (here)
+import qualified Graphics.Vega.VegaLite        as V
+
+templateVars :: M.Map String String
+templateVars = M.fromList
+  [ ("lang"     , "English")
+  , ("author"   , "Adam Conner-Sax")
+  , ("pagetitle", "knit-haskell simple multi-doc example")
+--  , ("tufte","True")
+  ]
+
+main :: IO ()
+main = do
+  let writeNamedHtml (K.NamedDoc n lt) = T.writeFile (T.unpack $ "examples/html/" <> n <> ".html") $ TL.toStrict lt
+      writeAllHtml = fmap (const ()) . traverse writeNamedHtml
+      pandocWriterConfig = K.PandocWriterConfig (Just "pandoc-templates/minWithVega-pandoc.html")  templateVars K.mindocOptionsF
+  resE <- K.knitHtmls (Just "SimpleExample.Main") K.logAll pandocWriterConfig $ do
+    K.newPandoc "multi_doc1" makeDoc1
+    K.newPandoc "multi_doc2" makeDoc2
+  case resE of
+    Right namedDocs -> writeAllHtml namedDocs 
+    Left err -> putStrLn $ "pandoc error: " ++ show err
+    
+md1 :: T.Text
+md1 = [here|
+## Some example markdown
+* [Markdown][MarkdownLink] is a nice way to write formatted notes with a minimum of code.
+* It supports links and tables and some *styling* information.
+
+[MarkDownLink]:<https://pandoc.org/MANUAL.html#pandocs-markdown>
+|]
+
+makeDoc1 :: (K.Member K.ToPandoc effs -- required for the single-document variant
+           , K.PandocEffects effs -- all effects for knitting
+           ) 
+        => K.Sem effs ()
+makeDoc1 = K.wrapPrefix "makeDoc1" $ do
+  K.logLE K.Info "adding some markdown."
+  K.addMarkDown md1
+  K.logLE K.Info "adding some latex."
+  K.addMarkDown "## Some example latex (Doc 1)"
+  K.addLatex "Overused favorite equation: $e^{i\\pi} + 1 = 0$"
+  K.logLE K.Info "adding a visualization."
+  K.addMarkDown "## An example hvega visualization (Doc 1)"
+  K.addHvega "someID" exampleVis
+
+md2 :: T.Text
+md2 = [here|
+## Some example markdown
+* This is some more markdown! Now for document 2. It's still a nice way to write formatted notes with a minimum of code.
+* It supports links and tables and some *styling* information.
+
+[MarkDownLink]:<https://pandoc.org/MANUAL.html#pandocs-markdown>
+|]
+
+makeDoc2 :: (K.Member K.ToPandoc effs -- required for the single-document variant
+           , K.PandocEffects effs -- all effects for knitting
+           ) 
+        => K.Sem effs ()
+makeDoc2 = K.wrapPrefix "makeDoc2" $ do
+  K.logLE K.Info "adding some markdown."
+  K.addMarkDown md2
+  K.logLE K.Info "adding some latex."
+  K.addMarkDown "## Some example latex (Doc 2)"
+  K.addLatex "A different equation: $a^2 + b^2 = c^2$"
+  K.logLE K.Info "adding a visualization."
+  K.addMarkDown "## An example hvega visualization (Doc 2)"
+  K.addHvega "someID" exampleVis  
+
+exampleVis :: V.VegaLite
+exampleVis =
+  let cars =  V.dataFromUrl "https://vega.github.io/vega-datasets/data/cars.json" []
+      enc = V.encoding
+        . V.position V.X [ V.PName "Horsepower", V.PmType V.Quantitative ]
+        . V.position V.Y [ V.PName "Miles_per_Gallon", V.PmType V.Quantitative ]
+        . V.color [ V.MName "Origin", V.MmType V.Nominal ]
+      bkg = V.background "rgba(0, 0, 0, 0.05)"
+  in V.toVegaLite [ bkg, cars, V.mark V.Circle [], enc [] ]  
diff --git a/examples/RandomExample.hs b/examples/RandomExample.hs
--- a/examples/RandomExample.hs
+++ b/examples/RandomExample.hs
@@ -69,7 +69,7 @@
 makeDoc :: (K.Member K.ToPandoc effs
            , K.PandocEffects effs
            , K.Member KR.Random effs -- this one needs to be handled before knitting
-           , K.KnitBase ExampleApp effs) => K.Semantic effs ()
+           , K.KnitBase ExampleApp effs) => K.Sem effs ()
 makeDoc = K.wrapPrefix "makeDoc" $ do
   K.logLE K.Info "adding some markdown..."
   K.addMarkDown md1
diff --git a/examples/SimpleExample.hs b/examples/SimpleExample.hs
--- a/examples/SimpleExample.hs
+++ b/examples/SimpleExample.hs
@@ -45,7 +45,7 @@
 makeDoc :: (K.Member K.ToPandoc effs -- required for the single-document variant
            , K.PandocEffects effs -- all effects for knitting
            ) 
-        => K.Semantic effs ()
+        => K.Sem effs ()
 makeDoc = K.wrapPrefix "makeDoc" $ do
   K.logLE K.Info "adding some markdown..."
   K.addMarkDown md1
diff --git a/knit-haskell.cabal b/knit-haskell.cabal
--- a/knit-haskell.cabal
+++ b/knit-haskell.cabal
@@ -1,7 +1,7 @@
 cabal-version:       2.2
 
 name:                knit-haskell
-version:             0.1.0.0
+version:             0.2.0.0
 synopsis:            a minimal Rmarkdown sort-of-thing for haskell, by way of Pandoc
 description:         knit-haskell is a beginning attempt at bringing some of the benefits of
                      Rmarkdown to Haskell.
@@ -35,7 +35,7 @@
     Location: https://github.com/adamConnerSax/knit-haskell
                                       
 library
-  ghc-options: -Wall -funbox-strict-fields
+  ghc-options: -Wall -fno-warn-unused-top-binds -funbox-strict-fields
   exposed-modules: Knit.Effect.Logger
                  , Knit.Effect.Docs
                  , Knit.Effect.Html
@@ -71,13 +71,13 @@
                     network                           >= 2.8.0.0 && < 3.1.0.0,
                     network-uri                       >= 2.6.1.0 && < 2.7.0.0,
                     text                              >= 1.2.3 && < 1.3,
-                    time                              >= 1.8.0 && < 1.9,
+                    time                              >= 1.8.0 && < 2.0.0,
                     random                            >= 1.1 && < 1.2,
                     blaze-html                        >= 0.9.1 && < 0.10,
                     hvega                             >= 0.1.0 && <= 0.2.0.0,
                     logging-effect                    >= 1.3.3 && < 1.4,
                     mtl                               >= 2.2.2 && < 2.3,
-                    polysemy                          >= 0.1.1.0 && < 0.2.0.0,
+                    polysemy                          >= 0.1.2.0 && < 0.2.0.0,
                     prettyprinter                     >= 1.2.1 && < 1.3,
                     lucid                             >= 2.9.11 && < 2.10,
                     pandoc                            >= 2.7.2 && < 2.8,
@@ -90,6 +90,20 @@
 
 executable SimpleExample
     main-is: SimpleExample.hs
+    hs-source-dirs: examples
+    ghc-options: -Wall 
+    build-depends: base,
+                   blaze-html,
+                   containers,
+                   here                              >= 1.2.10 && < 1.3.0,
+                   hvega,     
+                   knit-haskell                      -any,
+                   polysemy,  
+                   text      
+    default-language: Haskell2010
+
+executable MultiDocExample
+    main-is: MultiDocExample.hs
     hs-source-dirs: examples
     ghc-options: -Wall 
     build-depends: base,
diff --git a/src/Knit/Effect/Docs.hs b/src/Knit/Effect/Docs.hs
--- a/src/Knit/Effect/Docs.hs
+++ b/src/Knit/Effect/Docs.hs
@@ -54,7 +54,7 @@
   NewDoc :: T.Text -> a -> Docs a m ()
 
 -- | Action of the 'Docs' Effect.  Store a named document.
-newDoc :: P.Member (Docs a) effs => T.Text -> a -> P.Semantic effs ()
+newDoc :: P.Member (Docs a) effs => T.Text -> a -> P.Sem effs ()
 newDoc name doc = send $ NewDoc name doc
 
 -- | Data type to hold one named document of type @a@. 
@@ -62,18 +62,14 @@
 
 -- | Intepret 'Docs' in @Polysemy.Writer [NamedDoc a]'
 toWriter
-  :: P.Semantic (Docs a ': effs) ()
-  -> P.Semantic (P.Writer [NamedDoc a] ': effs) ()
+  :: P.Sem (Docs a ': effs) () -> P.Sem (P.Writer [NamedDoc a] ': effs) ()
 toWriter = P.reinterpret f
  where
-  f :: Docs a m x -> P.Semantic (P.Writer [NamedDoc a] ': effs) x
+  f :: Docs a m x -> P.Sem (P.Writer [NamedDoc a] ': effs) x
   f (NewDoc n d) = P.tell [NamedDoc n d]
 
 -- | Interpret 'Docs' (via 'Polysemy.Writer'), producing a list of @NamedDoc a@
-toNamedDocList
-  :: P.Typeable a
-  => P.Semantic (Docs a ': effs) ()
-  -> P.Semantic effs [NamedDoc a]
+toNamedDocList :: P.Sem (Docs a ': effs) () -> P.Sem effs [NamedDoc a]
 toNamedDocList = fmap fst . P.runWriter . toWriter
 
 -- | Map over the doc part of @Functor m => m [NamedDoc a]@ with an @a->b@ resulting in @m [NamedDoc b]@
@@ -86,17 +82,11 @@
 
 -- | Combine the interpretation and mapping step.  Commonly used to "run" the effect and map the results to your deisred output format.
 toNamedDocListWith
-  :: P.Typeable a
-  => (a -> b)
-  -> P.Semantic (Docs a ': effs) ()
-  -> P.Semantic effs [NamedDoc b]
+  :: (a -> b) -> P.Sem (Docs a ': effs) () -> P.Sem effs [NamedDoc b]
 toNamedDocListWith f = mapNamedDocs f . toNamedDocList
 
 -- | Combine the interpretation and effectful mapping step.  Commonly used to "run" the effect and map the results to your deisred output format.
 toNamedDocListWithM
-  :: P.Typeable a
-  => (a -> P.Semantic effs b)
-  -> P.Semantic (Docs a ': effs) ()
-  -> P.Semantic effs [NamedDoc b]
+  :: (a -> P.Sem effs b) -> P.Sem (Docs a ': effs) () -> P.Sem effs [NamedDoc b]
 toNamedDocListWithM f = mapNamedDocsM f . toNamedDocList
 
diff --git a/src/Knit/Effect/Html.hs b/src/Knit/Effect/Html.hs
--- a/src/Knit/Effect/Html.hs
+++ b/src/Knit/Effect/Html.hs
@@ -78,11 +78,11 @@
 type Blaze = P.Writer BH.Html
 
 -- | Add a Lucid html fragment to the current Lucid doc.
-lucid :: P.Member Lucid effs => LH.Html () -> P.Semantic effs ()
+lucid :: P.Member Lucid effs => LH.Html () -> P.Sem effs ()
 lucid = P.tell
 
 -- | Add a Blaze html fragment to the current Blaze doc.
-blaze :: P.Member Blaze effs => BH.Html -> P.Semantic effs ()
+blaze :: P.Member Blaze effs => BH.Html -> P.Sem effs ()
 blaze = P.tell
 
 -- | Type-Alias for the 'Knit.Effects.Docs' effect (multi-document Writer), specialized to Lucid docs.
@@ -99,8 +99,8 @@
 newLucidDoc
   :: P.Member LucidDocs effs
   => T.Text
-  -> P.Semantic (Lucid ': effs) ()
-  -> P.Semantic effs ()
+  -> P.Sem (Lucid ': effs) ()
+  -> P.Sem effs ()
 newLucidDoc n l = (fmap fst $ P.runWriter l) >>= newDoc n
 
 -- | take the current Blaze HTML in the writer and add it to the set of named docs with the given name
@@ -109,33 +109,33 @@
 newBlazeDoc
   :: P.Member BlazeDocs effs
   => T.Text
-  -> P.Semantic (Blaze ': effs) ()
-  -> P.Semantic effs ()
+  -> P.Sem (Blaze ': effs) ()
+  -> P.Sem effs ()
 newBlazeDoc n l = (fmap fst $ P.runWriter l) >>= newDoc n
 
 -- | Interpret the LucidDocs effect (via Writer), producing a list of named Lucid docs, suitable for writing to disk.
 lucidToNamedText
-  :: P.Semantic (LucidDocs ': effs) () -> P.Semantic effs [NamedDoc TL.Text]
+  :: P.Sem (LucidDocs ': effs) () -> P.Sem effs [NamedDoc TL.Text]
 lucidToNamedText = fmap (fmap (fmap LH.renderText)) . toNamedDocList -- monad, list, NamedDoc itself
 
 -- | Interpret the BlazeDocs effect (via Writer), producing a list of named Blaze docs.
 blazeToNamedText
-  :: P.Semantic (BlazeDocs ': effs) () -> P.Semantic effs [NamedDoc TL.Text]
+  :: P.Sem (BlazeDocs ': effs) () -> P.Sem effs [NamedDoc TL.Text]
 blazeToNamedText = fmap (fmap (fmap BH.renderHtml)) . toNamedDocList -- monad, list, NamedDoc itself
 
 -- | Interprest the Lucid effect (via Writer), producing a Lucid @Html ()@ from the currently written doc
-lucidHtml :: P.Semantic (Lucid ': effs) () -> P.Semantic effs (LH.Html ())
+lucidHtml :: P.Sem (Lucid ': effs) () -> P.Sem effs (LH.Html ())
 lucidHtml = fmap fst . P.runWriter
 
 -- | Interpret the Lucid effect (via Writer), producing @Text@ from the currently written doc
-lucidToText :: P.Semantic (Lucid ': effs) () -> P.Semantic effs TL.Text
+lucidToText :: P.Sem (Lucid ': effs) () -> P.Sem effs TL.Text
 lucidToText = fmap LH.renderText . lucidHtml
 
 -- | Interpret the Blaze effect (via Writer), producing a Blaze @Html@ from the currently written doc.
-blazeHtml :: P.Semantic (Blaze ': effs) () -> P.Semantic effs BH.Html
+blazeHtml :: P.Sem (Blaze ': effs) () -> P.Sem effs BH.Html
 blazeHtml = fmap fst . P.runWriter
 
 -- | Interpret the Blaze effect (via Writer), producing @Text@ from the currently written doc.
-blazeToText :: P.Semantic (Blaze ': effs) () -> P.Semantic effs TL.Text
+blazeToText :: P.Sem (Blaze ': effs) () -> P.Sem effs TL.Text
 blazeToText = fmap BH.renderHtml . blazeHtml
 
diff --git a/src/Knit/Effect/Logger.hs b/src/Knit/Effect/Logger.hs
--- a/src/Knit/Effect/Logger.hs
+++ b/src/Knit/Effect/Logger.hs
@@ -54,7 +54,7 @@
   , LogWithPrefixesLE
 
   -- * Re-Exports
-  , Semantic
+  , Sem
   , Member
   , Handler
   )
@@ -62,7 +62,7 @@
 
 import qualified Polysemy                      as P
 import           Polysemy                       ( Member
-                                                , Semantic
+                                                , Sem
                                                 )
 import           Polysemy.Internal              ( send )
 import qualified Polysemy.State                as P
@@ -122,22 +122,17 @@
   Log :: a -> Logger a m ()
 
 -- | Add one log entry of arbitrary type.  If you want to log with another type besides @LogEntry.
-log :: P.Member (Logger a) effs => a -> P.Semantic effs ()
+log :: P.Member (Logger a) effs => a -> P.Sem effs ()
 log = send . Log
 
 -- | Add one log-entry of the @LogEntry@ type.
 logLE
-  :: P.Member (Logger LogEntry) effs
-  => LogSeverity
-  -> T.Text
-  -> P.Semantic effs ()
+  :: P.Member (Logger LogEntry) effs => LogSeverity -> T.Text -> P.Sem effs ()
 logLE ls lm = log (LogEntry ls lm)
 
 -- | Helper function for logging with monad-logger handler.
 logWithHandler
-  :: Handler (P.Semantic effs) a
-  -> P.Semantic (Logger a ': effs) x
-  -> P.Semantic effs x
+  :: Handler (P.Sem effs) a -> P.Sem (Logger a ': effs) x -> P.Sem effs x
 logWithHandler handler = P.interpret (\(Log a) -> handler a)
 
 -- | Prefix Effect
@@ -147,20 +142,19 @@
   GetPrefix :: PrefixLog m T.Text -- ^ Represents retrieving the current prefix
 
 -- | Add one level of prefix.
-addPrefix :: P.Member PrefixLog effs => T.Text -> P.Semantic effs ()
+addPrefix :: P.Member PrefixLog effs => T.Text -> P.Sem effs ()
 addPrefix = send . AddPrefix
 
 -- | Remove last prefix.
-removePrefix :: P.Member PrefixLog effs => P.Semantic effs ()
+removePrefix :: P.Member PrefixLog effs => P.Sem effs ()
 removePrefix = send RemovePrefix
 
 -- | Get current prefix 
-getPrefix :: P.Member PrefixLog effs => P.Semantic effs T.Text
+getPrefix :: P.Member PrefixLog effs => P.Sem effs T.Text
 getPrefix = send $ GetPrefix
 
 -- | Add a prefix for the block of code.
-wrapPrefix
-  :: P.Member PrefixLog effs => T.Text -> P.Semantic effs a -> P.Semantic effs a
+wrapPrefix :: P.Member PrefixLog effs => T.Text -> P.Sem effs a -> P.Sem effs a
 wrapPrefix p l = do
   addPrefix p
   res <- l
@@ -170,15 +164,15 @@
 -- | Interpret LogPrefix in @Polysemy.State [T.Text]@.
 prefixInState
   :: forall effs a
-   . P.Semantic (PrefixLog ': effs) a
-  -> P.Semantic (P.State [T.Text] ': effs) a
+   . P.Sem (PrefixLog ': effs) a
+  -> P.Sem (P.State [T.Text] ': effs) a
 prefixInState = P.reinterpret $ \case
   AddPrefix t  -> P.modify (t :)
   RemovePrefix -> P.modify @[T.Text] tail -- type application required here since tail is polymorphic
   GetPrefix    -> fmap (T.intercalate "." . List.reverse) P.get
 
 -- | Interpret the 'LogPrefix' effect in State and run that.
-runPrefix :: P.Semantic (PrefixLog ': effs) a -> P.Semantic effs a
+runPrefix :: P.Sem (PrefixLog ': effs) a -> P.Sem effs a
 runPrefix = fmap snd . P.runState [] . prefixInState
 
 -- | Monad-logger style wrapper to add prefixes to log messages.
@@ -191,8 +185,8 @@
 -- | Use @PrefixLog@ Effect to re-interpret all the logged messages to WithPrefix form.
 logPrefixed
   :: P.Member PrefixLog effs
-  => P.Semantic (Logger a ': effs) x
-  -> P.Semantic (Logger (WithPrefix a) ': effs) x
+  => P.Sem (Logger a ': effs) x
+  -> P.Sem (Logger (WithPrefix a) ': effs) x
 logPrefixed =
   P.reinterpret (\(Log a) -> getPrefix >>= (\p -> log (WithPrefix p a)))
 
@@ -202,9 +196,9 @@
 -- messages via that handler.
 logAndHandlePrefixed
   :: forall effs a x
-   . Handler (P.Semantic effs) (WithPrefix a)
-  -> P.Semantic (Logger a ': (PrefixLog ': effs)) x
-  -> P.Semantic effs x
+   . Handler (P.Sem effs) (WithPrefix a)
+  -> P.Sem (Logger a ': (PrefixLog ': effs)) x
+  -> P.Sem effs x
 logAndHandlePrefixed handler =
   runPrefix
     . logWithHandler (P.raise . handler)
@@ -233,10 +227,10 @@
 
 -- | Run the Logger and PrefixLog effects using the preferred handler and filter output in any Polysemy monad with IO in the union.
 filteredLogEntriesToIO
-  :: MonadIO (P.Semantic effs)
+  :: MonadIO (P.Sem effs)
   => [LogSeverity]
-  -> P.Semantic (Logger LogEntry ': (PrefixLog ': effs)) x
-  -> P.Semantic effs x
+  -> P.Sem (Logger LogEntry ': (PrefixLog ': effs)) x
+  -> P.Sem effs x
 filteredLogEntriesToIO lss = logAndHandlePrefixed
   (filterLog f lss $ prefixedLogEntryToIO)
   where f lss' a = (severity $ discardPrefix a) `List.elem` lss'
@@ -247,24 +241,3 @@
 -- | Constraint helper for @LogEntry@ type with prefixes
 type LogWithPrefixesLE effs = LogWithPrefixes LogEntry effs --(P.Member PrefixLog effs, P.Member (Logger a) effs)
 
-{-
-TODO: Working instance of logging-effect MonadLog.  Maybe.
-
-• Illegal instance declaration for
-        ‘ML.MonadLog a (P.Semantic effs)’
-        The liberal coverage condition fails in class ‘ML.MonadLog’
-          for functional dependency: ‘m -> message’
-        Reason: lhs type ‘P.Semantic effs’ does not determine rhs type ‘a’
-        Un-determined variable: a
-    • In the instance declaration for ‘ML.MonadLog a (P.Semantic effs)’
-
-
--- not sure how to use this in practice but we might need it if we call a function with a MonadLog constraint.
--- | instance to support using an existing function with a MonadLog constraint from a freer-simple stack. 
-instance (ML.MonadLog a m, P.Member (P.Lift m) effs) => ML.MonadLog a (P.Semantic effs) where
-  logMessageFree :: (ML.MonadLog a m, P.Member (P.Lift m) effs,forall n. Monoid n => (a -> n) -> n) -> P.Semantic effs ()
-  logMessageFree inj = P.sendM @m $ ML.logMessageFree inj
-
-instance (P.Member (Logger a) effs) => ML.MonadLog a (P.Semantic effs) where
-  logMessageFree inj = mapM_ log (inj $ pure @[])
--}
diff --git a/src/Knit/Effect/Pandoc.hs b/src/Knit/Effect/Pandoc.hs
--- a/src/Knit/Effect/Pandoc.hs
+++ b/src/Knit/Effect/Pandoc.hs
@@ -161,11 +161,11 @@
   => PandocReadFormat a
   -> PA.ReaderOptions
   -> a
-  -> P.Semantic effs ()
+  -> P.Sem effs ()
 addFrom prf pro doc' = send $ AddFrom prf pro doc'
 
 -- | Add a requirement that the output format must satisfy.
-require :: P.Member ToPandoc effs => Requirement -> P.Semantic effs ()
+require :: P.Member ToPandoc effs => Requirement -> P.Sem effs ()
 require r = send $ Require r
 
 -- | Write given doc in requested format
@@ -174,7 +174,7 @@
   => PandocWriteFormat a
   -> PA.WriterOptions
   -> PA.Pandoc
-  -> P.Semantic effs a
+  -> P.Sem effs a
 writeTo pwf pwo pdoc = send $ WriteTo pwf pwo pdoc
 
 -- | Convert a to Pandoc with the given options
@@ -224,8 +224,8 @@
 -- | Re-interpret ToPandoc in Writer
 toWriter
   :: PM.PandocEffects effs
-  => P.Semantic (ToPandoc ': effs) a
-  -> P.Semantic (P.Writer PandocWithRequirements ': effs) a
+  => P.Sem (ToPandoc ': effs) a
+  -> P.Sem (P.Writer PandocWithRequirements ': effs) a
 toWriter = P.reinterpret $ \case
   (AddFrom rf ro x) ->
     P.raise (fmap justDoc $ toPandoc rf ro x) >>= P.tell @PandocWithRequirements
@@ -234,8 +234,8 @@
 -- | Run ToPandoc by interpreting in Writer and then running that Writer.
 runPandocWriter
   :: PM.PandocEffects effs
-  => P.Semantic (ToPandoc ': effs) ()
-  -> P.Semantic effs PandocWithRequirements
+  => P.Sem (ToPandoc ': effs) ()
+  -> P.Sem effs PandocWithRequirements
 runPandocWriter = fmap fst . P.runWriter . toWriter
 
 -- | Type-alias for use with the @Docs@ effect.
@@ -246,15 +246,15 @@
   :: P.Member Pandocs effs
   => T.Text -- ^ name for document
   -> PandocWithRequirements -- ^ document and union of all input requirements
-  -> P.Semantic effs ()
+  -> P.Sem effs ()
 newPandocPure = newDoc
 
 -- | Add the Pandoc stored in the writer-style ToPandoc effect to the named docs collection with the given name.
 newPandoc
   :: (PM.PandocEffects effs, P.Member Pandocs effs)
   => T.Text -- ^ name of document
-  -> P.Semantic (ToPandoc ': effs) ()
-  -> P.Semantic effs ()
+  -> P.Sem (ToPandoc ': effs) ()
+  -> P.Sem effs ()
 newPandoc n l = fmap fst (P.runWriter $ toWriter l) >>= newPandocPure n
 
 -- | Given a write format and options, convert the NamedDoc to the requested format
@@ -274,8 +274,8 @@
   :: PM.PandocEffects effs
   => PandocWriteFormat a -- ^ format for Pandoc output
   -> PA.WriterOptions -- ^ options for the Pandoc Writer
-  -> P.Semantic (Pandocs ': effs) () -- ^ effects stack to be (partially) run to get documents
-  -> P.Semantic effs [NamedDoc a] -- ^ documents in requested format, within the effects monad
+  -> P.Sem (Pandocs ': effs) () -- ^ effects stack to be (partially) run to get documents
+  -> P.Sem effs [NamedDoc a] -- ^ documents in requested format, within the effects monad
 pandocsToNamed pwf pwo =
   (traverse (namedPandocFrom pwf pwo) =<<) . toNamedDocList
 
@@ -284,7 +284,7 @@
   :: PM.PandocEffects effs
   => PandocWriteFormat a -- ^ format for Pandoc output
   -> PA.WriterOptions -- ^ options for the Pandoc Writer
-  -> P.Semantic (ToPandoc ': effs) () -- ^ effects stack to be (partially) run to get document
-  -> P.Semantic effs a -- ^ document in requested format, within the effects monad
+  -> P.Sem (ToPandoc ': effs) () -- ^ effects stack to be (partially) run to get document
+  -> P.Sem effs a -- ^ document in requested format, within the effects monad
 fromPandocE pwf pwo = ((fromPandoc pwf pwo . fst) =<<) . P.runWriter . toWriter
 
diff --git a/src/Knit/Effect/PandocMonad.hs b/src/Knit/Effect/PandocMonad.hs
--- a/src/Knit/Effect/PandocMonad.hs
+++ b/src/Knit/Effect/PandocMonad.hs
@@ -73,7 +73,7 @@
 import qualified Knit.Effect.Logger            as Log
 
 import qualified Polysemy                      as P
-import qualified Polysemy.IO                   as P
+--import qualified Polysemy.IO                   as P
 import           Polysemy.Internal              ( send )
 import           Polysemy.Internal.Combinators  ( stateful )
 import qualified Polysemy.Error                as P
@@ -149,11 +149,11 @@
   LogOutput :: PA.LogMessage -> Pandoc m ()
   Trace :: String -> Pandoc m ()
 
-P.makeSemantic ''Pandoc
+P.makeSem ''Pandoc
 
 -- TODO: Understand the error pieces better.  Some things are thrown in IO, not sure we catch those??
 -- | Split off the error piece. We will handle directly with the polysemy @Error@ effect
-instance (P.Member (P.Error PA.PandocError) effs) => MonadError PA.PandocError (P.Semantic effs) where
+instance (P.Member (P.Error PA.PandocError) effs) => MonadError PA.PandocError (P.Sem effs) where
   throwError = P.throw
   catchError = P.catch
 
@@ -167,9 +167,7 @@
 
 -- | Handle the logging with the knit-haskell logging effect.
 logPandocMessage
-  :: P.Member (Log.Logger Log.LogEntry) effs
-  => PA.LogMessage
-  -> P.Semantic effs ()
+  :: P.Member (Log.Logger Log.LogEntry) effs => PA.LogMessage -> P.Sem effs ()
 logPandocMessage lm = send $ Log.Log $ Log.LogEntry
   (pandocSeverity lm)
   (T.pack . PA.showLogMessage $ lm)
@@ -182,7 +180,7 @@
   , P.Member (Log.Logger Log.LogEntry) effs)
 
 -- | PandocMonad instance so that pandoc functions can be run in the polysemy union effect
-instance PandocEffects effs => PA.PandocMonad (P.Semantic effs) where
+instance PandocEffects effs => PA.PandocMonad (P.Sem effs) where
   lookupEnv = lookupEnv
   getCurrentTime = getCurrentTime
   getCurrentTimeZone = getCurrentTimeZone
@@ -215,13 +213,13 @@
      , P.Member (P.Lift IO) effs
      , P.Member (P.Error PA.PandocError) effs
      )
-  => P.Semantic (Pandoc ': effs) a
-  -> P.Semantic effs a
+  => P.Sem (Pandoc ': effs) a
+  -> P.Sem effs a
 interpretInIO = fmap snd . stateful f PA.def
  where
   liftPair :: forall f x y . Functor f => (x, f y) -> f (x, y)
   liftPair (x, fy) = fmap (x, ) fy
-  f :: Pandoc m x -> PA.CommonState -> P.Semantic effs (PA.CommonState, x)
+  f :: Pandoc m x -> PA.CommonState -> P.Sem effs (PA.CommonState, x)
   f (LookupEnv s)         cs = liftPair (cs, liftIO $ IO.lookupEnv s)
   f GetCurrentTime        cs = liftPair (cs, liftIO $ IO.getCurrentTime)
   f GetCurrentTimeZone    cs = liftPair (cs, liftIO IO.getCurrentTimeZone)
@@ -252,8 +250,8 @@
      , P.Member (P.Lift m) effs
      , P.Member (Log.Logger Log.LogEntry) effs
      )
-  => P.Semantic (Pandoc ': effs) a
-  -> P.Semantic effs a
+  => P.Sem (Pandoc ': effs) a
+  -> P.Sem effs a
 interpretInPandocMonad = P.interpret
   (\case
     LookupEnv s            -> P.sendM @m $ PA.lookupEnv s
@@ -281,7 +279,7 @@
 -- If there is a Pandoc error, you will get a Left in the resulting Either.
 runIO
   :: [Log.LogSeverity]
-  -> P.Semantic
+  -> P.Sem
        '[Pandoc, Log.Logger Log.LogEntry, Log.PrefixLog, P.Error
          PA.PandocError, P.Lift IO]
        a
@@ -298,9 +296,7 @@
      )
   => PA.CommonState
   -> String
-  -> P.Semantic
-       effs
-       (PA.CommonState, (BS.ByteString, Maybe PA.MimeType))
+  -> P.Sem effs (PA.CommonState, (BS.ByteString, Maybe PA.MimeType))
 openURLWithState cs u
   | Just u'' <- L.stripPrefix "data:" u = do
     let mime = L.takeWhile (/= ',') u''
@@ -338,7 +334,7 @@
   :: (P.Member (Log.Logger Log.LogEntry) effs)
   => PA.CommonState
   -> PA.LogMessage
-  -> P.Semantic effs PA.CommonState
+  -> P.Sem effs PA.CommonState
 report cs msg = do
   let verbosity = PA.stVerbosity cs
       level     = PA.messageVerbosity msg
@@ -347,12 +343,12 @@
       cs'    = cs { PA.stLog = stLog' }
   return cs'
 
--- | Utility function to lift IO errors into Semantic
+-- | Utility function to lift IO errors into Sem
 liftIOError
   :: (P.Member (P.Error PA.PandocError) effs, P.Member (P.Lift IO) effs)
   => (String -> IO a)
   -> String
-  -> P.Semantic effs a
+  -> P.Sem effs a
 liftIOError f u = do
   res <- liftIO $ IO.tryIOError $ f u
   case res of
@@ -363,6 +359,7 @@
 -- or maybe the actual version on each machine has a correct local version??
 -- TODO: Fix/Understand this
 datadir :: FilePath
+datadir
   = "/home/builder/hackage-server/build-cache/tmp-install/share/x86_64-linux-ghc-8.6.3/pandoc-2.7.2"
 
 getDataFileName' :: FilePath -> IO FilePath
diff --git a/src/Knit/Effect/RandomFu.hs b/src/Knit/Effect/RandomFu.hs
--- a/src/Knit/Effect/RandomFu.hs
+++ b/src/Knit/Effect/RandomFu.hs
@@ -62,26 +62,25 @@
   GetRandomPrim :: R.Prim t -> Random m t
 
 -- | Convert a random-fu RVar to the Random Effect
-sampleRVar :: (P.Member Random effs) => R.RVar t -> P.Semantic effs t
+sampleRVar :: (P.Member Random effs) => R.RVar t -> P.Sem effs t
 sampleRVar = send . SampleRVar
 
 -- | Convert a random-fu Distribution to the Random Effect
-sampleDist
-  :: (P.Member Random effs, R.Distribution d t) => d t -> P.Semantic effs t
+sampleDist :: (P.Member Random effs, R.Distribution d t) => d t -> P.Sem effs t
 sampleDist = sampleRVar . R.rvar
 
-getRandomPrim :: P.Member Random effs => R.Prim t -> P.Semantic effs t
+getRandomPrim :: P.Member Random effs => R.Prim t -> P.Sem effs t
 getRandomPrim = send . GetRandomPrim
 
 -- | Run in IO using default random-fu IO source
 runRandomIOSimple
   :: forall effs a
-   . MonadIO (P.Semantic effs)
-  => P.Semantic (Random ': effs) a
-  -> P.Semantic effs a
+   . MonadIO (P.Sem effs)
+  => P.Sem (Random ': effs) a
+  -> P.Sem effs a
 runRandomIOSimple = P.interpret f
  where
-  f :: forall m x . (Random m x -> P.Semantic effs x)
+  f :: forall m x . (Random m x -> P.Sem effs x)
   f r = case r of
     SampleRVar    rv -> liftIO $ R.sample rv
     GetRandomPrim pt -> liftIO $ R.getRandomPrim pt
@@ -89,28 +88,28 @@
 -- | Run using the given source
 runRandomFromSource
   :: forall s effs a
-   . R.RandomSource (P.Semantic effs) s
+   . R.RandomSource (P.Sem effs) s
   => s
-  -> P.Semantic (Random ': effs) a
-  -> P.Semantic effs a
+  -> P.Sem (Random ': effs) a
+  -> P.Sem effs a
 runRandomFromSource source = P.interpret f
  where
-  f :: forall m x . (Random m x -> P.Semantic effs x)
+  f :: forall m x . (Random m x -> P.Sem effs x)
   f r = case r of
     SampleRVar    rv -> R.runRVar (R.sample rv) source
     GetRandomPrim pt -> R.runRVar (R.getRandomPrim pt) source
 
 -- | Run in 'IO', using the given 'PureMT' source stored in an 'IORef'
 runRandomIOPureMT
-  :: MonadIO (P.Semantic effs)
+  :: MonadIO (P.Sem effs)
   => R.PureMT
-  -> P.Semantic (Random ': effs) a
-  -> P.Semantic effs a
+  -> P.Sem (Random ': effs) a
+  -> P.Sem effs a
 runRandomIOPureMT source re =
   liftIO (newIORef source) >>= flip runRandomFromSource re
 
 -- | supply instance of MonadRandom for functions which require it
 $(R.monadRandom [d|
-        instance P.Member Random effs => R.MonadRandom (P.Semantic effs) where
+        instance P.Member Random effs => R.MonadRandom (P.Sem effs) where
             getRandomPrim = getRandomPrim
     |])
diff --git a/src/Knit/Report.hs b/src/Knit/Report.hs
--- a/src/Knit/Report.hs
+++ b/src/Knit/Report.hs
@@ -58,13 +58,14 @@
     -- * Effects
   , module Polysemy
   , module Knit.Effect.Pandoc
+  , module Knit.Effect.Docs
   , module Knit.Effect.PandocMonad
   , module Knit.Effect.Logger
   )
 where
 
 import           Polysemy                       ( Member
-                                                , Semantic
+                                                , Sem
                                                 , Lift
                                                 )
 import           Knit.Effect.Pandoc             ( ToPandoc
@@ -72,7 +73,9 @@
                                                 , PandocReadFormat(..)
                                                 , PandocWriteFormat(..)
                                                 , Pandocs
+                                                , newPandoc
                                                 )
+import           Knit.Effect.Docs               ( NamedDoc(..) )
 import           Knit.Effect.PandocMonad
 import           Knit.Effect.Logger             ( LogSeverity(..)
                                                 , logAll
@@ -108,7 +111,6 @@
 import           Control.Monad.Except           ( MonadIO )
 import qualified Data.Text                     as T
 import qualified Data.Text.Lazy                as TL
-import           GHC.Exts                       ( Constraint )
 
 import qualified Polysemy                      as P
 import qualified Polysemy.Error                as PE
@@ -128,37 +130,39 @@
 
 -- | Create multiple HTML docs (as Text) from the named sets of pandoc fragments.
 -- In use, you may need a type-application to specify m.
--- This allows use of any underlying monad to handle the Pandoc effects.  
+-- This allows use of any underlying monad to handle the Pandoc effects.
+-- NB: Resulting documents are *Lazy* Text, as produced by the Blaze render function.
 knitHtmls
-  :: forall m
-   . (MonadIO m, LastMember (P.Lift m) (KnitEffectStack m))
+  :: MonadIO m
   => Maybe T.Text -- ^ outer logging prefix
   -> [KLog.LogSeverity] -- ^ what to output in log
   -> PandocWriterConfig -- ^ configuration for the Pandoc Html Writer
-  -> P.Semantic (KnitEffectDocsStack m) () -- ^ Knit effects "over" m
-  -> m (Either PA.PandocError [KP.NamedDoc TL.Text]) -- ^  named documents, converted to Html as Text or error
+  -> P.Sem (KnitEffectDocsStack m) ()
+  -> m (Either PA.PandocError [KP.NamedDoc TL.Text])
 knitHtmls loggingPrefixM ls writeConfig =
-  runSemT (consumeKnitEffectMany loggingPrefixM ls writeConfig)
+  consumeKnitEffectStack loggingPrefixM ls . KD.toNamedDocListWithM
+    (fmap BH.renderHtml . KO.toBlazeDocument writeConfig)
 
 -- | Create HTML Text from pandoc fragments
 -- In use, you may need a type-application to specify m.
--- This allows use of any underlying monad to handle the Pandoc effects.  
+-- This allows use of any underlying monad to handle the Pandoc effects.
+-- NB: Resulting document is *Lazy* Text, as produced by the Blaze render function.
 knitHtml
-  :: forall m
-   . (MonadIO m, LastMember (P.Lift m) (KnitEffectStack m))
+  :: MonadIO m
   => Maybe T.Text -- ^ outer logging prefix
   -> [KLog.LogSeverity] -- ^ what to output in log
   -> PandocWriterConfig -- ^ configuration for the Pandoc Html Writer
-  -> P.Semantic (KnitEffectDocStack m) () -- ^ Knit effects "over" m
-  -> m (Either PA.PandocError TL.Text) -- ^  document, converted to Html as Text, or error
+  -> P.Sem (KnitEffectDocStack m) ()
+  -> m (Either PA.PandocError TL.Text)
 knitHtml loggingPrefixM ls writeConfig =
-  runSemT (consumeKnitEffectOne loggingPrefixM ls writeConfig)
+  fmap (fmap (fmap BH.renderHtml)) (consumeKnitEffectStack loggingPrefixM ls)
+    . KO.pandocWriterToBlazeDocument writeConfig
 
--- | Constraints required to build a document while also using effects from a base monad m.
+-- | Constraints required to knit a document using effects from a base monad m.
 type KnitBase m effs = (MonadIO m, P.Member (P.Lift m) effs)
 
--- | lift an action in a base monad into a Polysemy monad
-liftKnit :: Member (Lift m) r => m a -> Semantic r a
+-- | lift an action in a base monad into a Polysemy monad.  This is just a renaming for convenience.
+liftKnit :: Member (Lift m) r => m a -> Sem r a
 liftKnit = P.sendM
 
 -- From here down is unexported.  
@@ -172,90 +176,25 @@
    , P.Lift IO
    , P.Lift m
    ]
-
 -- | Add a Multi-doc writer to the front of the effect list
 type KnitEffectDocsStack m = (KD.Docs KP.PandocWithRequirements ': KnitEffectStack m)
 
 -- | Add a single-doc writer to the front of the effect list
 type KnitEffectDocStack m = (KP.ToPandoc ': KnitEffectStack m)
 
--- | require that the effect @eff@ be last in the list of effects @r@
-type family LastMember (eff :: k) (r :: [k]) :: Constraint where
-  LastMember eff '[] = ()
-  LastMember eff (e : es) = (P.Member eff (e ': es), LastMember eff es)
-
--- | run all effects, given that last one is @Lift m@
-runSemT
-  :: Monad m
-  => (P.Semantic r a -> P.Semantic '[P.Lift m] b)
-  -> P.Semantic r a
-  -> m b
-runSemT consume = P.runM . consume
-
--- | run all effects in @KnitEffectStack m@ except the final @Lift m@
+-- | run all knit-effects in @KnitEffectStack m@
 consumeKnitEffectStack
   :: forall m a
-   . (MonadIO m, LastMember (P.Lift m) (KnitEffectStack m))
+   . MonadIO m
   => Maybe T.Text -- ^ outer logging prefix
   -> [KLog.LogSeverity] -- ^ what to output in log
-  -> P.Semantic (KnitEffectStack m) a
-  -> P.Semantic '[P.Lift m] (Either PA.PandocError a)
+  -> P.Sem (KnitEffectStack m) a
+  -> m (Either PA.PandocError a)
 consumeKnitEffectStack loggingPrefixM ls =
-  PI.runIO @m -- interpret (Lift IO) using m
+  P.runM
+    . PI.runIO @m -- interpret (Lift IO) using m
     . PE.runError
     . KLog.filteredLogEntriesToIO ls
     . KPM.interpretInIO -- PA.PandocIO
     . maybe id KLog.wrapPrefix loggingPrefixM
 
--- | run all effects in @KnitEffectDocsStack m@ except the final @Lift m@
-consumeKnitEffectMany
-  :: forall m
-   . (MonadIO m, LastMember (P.Lift m) (KnitEffectStack m))
-  => Maybe T.Text -- ^ outer logging prefix
-  -> [KLog.LogSeverity] -- ^ what to output in log
-  -> PandocWriterConfig -- ^ configuration for the Pandoc Html Writer
-  -> P.Semantic (KnitEffectDocsStack m) ()
-  -> P.Semantic
-       '[P.Lift m]
-       (Either PA.PandocError [KP.NamedDoc TL.Text])
-consumeKnitEffectMany loggingPrefixM ls writeConfig =
-  consumeKnitEffectStack @m loggingPrefixM ls . KD.toNamedDocListWithM
-    (fmap BH.renderHtml . KO.toBlazeDocument writeConfig)
-
--- | run all effects in @KnitEffectDocStack m@ except the final @Lift m@
-consumeKnitEffectOne
-  :: forall m
-   . (MonadIO m, LastMember (P.Lift m) (KnitEffectStack m))
-  => Maybe T.Text -- ^ outer logging prefix
-  -> [KLog.LogSeverity] -- ^ what to output in log
-  -> PandocWriterConfig -- ^ configuration for the Pandoc Html Writer
-  -> P.Semantic (KnitEffectDocStack m) ()
-  -> P.Semantic '[P.Lift m] (Either PA.PandocError TL.Text)
-consumeKnitEffectOne loggingPrefixM ls writeConfig =
-  fmap (fmap (fmap BH.renderHtml)) (consumeKnitEffectStack @m loggingPrefixM ls)
-    . KO.pandocWriterToBlazeDocument writeConfig
-
-
-{-
-type KnitEffectC m r = (
-    P.Member KPM.Pandoc r
-  , KLog.LogWithPrefixesLE r
-  , P.Member (PE.Error PA.PandocError) r
-  , P.Member (P.Lift IO) r
-  , P.Member (P.Lift m) r
-  )
-
-consumeKnitEffectPoly
-  :: forall m r a
-   . (PA.PandocMonad m, MonadIO m, KnitEffectC m r, LastMember (P.Lift m) r)
-  => Maybe T.Text -- ^ outer logging prefix
-  -> [KLog.LogSeverity] -- ^ what to output in log
-  -> P.Semantic r a
-  -> P.Semantic '[P.Lift m] (Either PA.PandocError a)
-consumeKnitEffectPoly loggingPrefixM ls =
-  PI.runIO @m
-    . PE.runError
-    . KLog.filteredLogEntriesToIO ls
-    . KPM.runPandoc @m -- PA.PandocIO
-    . maybe id KLog.wrapPrefix loggingPrefixM
--}
diff --git a/src/Knit/Report/Input/Html.hs b/src/Knit/Report/Input/Html.hs
--- a/src/Knit/Report/Input/Html.hs
+++ b/src/Knit/Report/Input/Html.hs
@@ -49,12 +49,12 @@
 addStrictTextHtml
   :: (PM.PandocEffects effs, P.Member PE.ToPandoc effs)
   => T.Text
-  -> P.Semantic effs ()
+  -> P.Sem effs ()
 addStrictTextHtml = PE.addFrom PE.ReadHtml htmlReaderOptions
 
 -- | Add Lazy Text Html to current Pandoc
 addLazyTextHtml
   :: (PM.PandocEffects effs, P.Member PE.ToPandoc effs)
   => LT.Text
-  -> P.Semantic effs ()
+  -> P.Sem effs ()
 addLazyTextHtml = addStrictTextHtml . LT.toStrict
diff --git a/src/Knit/Report/Input/Html/Blaze.hs b/src/Knit/Report/Input/Html/Blaze.hs
--- a/src/Knit/Report/Input/Html/Blaze.hs
+++ b/src/Knit/Report/Input/Html/Blaze.hs
@@ -17,18 +17,18 @@
   )
 where
 
-import Knit.Report.Input.Html (addLazyTextHtml)
+import           Knit.Report.Input.Html         ( addLazyTextHtml )
 import qualified Text.Blaze.Html               as BH
 import qualified Text.Blaze.Html.Renderer.Text as BH
 
 import qualified Polysemy                      as P
-import qualified Knit.Effect.Pandoc           as PE
-import qualified Knit.Effect.PandocMonad      as PM
+import qualified Knit.Effect.Pandoc            as PE
+import qualified Knit.Effect.PandocMonad       as PM
 
 
 -- | Add Blaze Html 
 addBlaze
   :: (PM.PandocEffects effs, P.Member PE.ToPandoc effs)
   => BH.Html
-  -> P.Semantic effs ()
+  -> P.Sem effs ()
 addBlaze = addLazyTextHtml . BH.renderHtml
diff --git a/src/Knit/Report/Input/Html/Lucid.hs b/src/Knit/Report/Input/Html/Lucid.hs
--- a/src/Knit/Report/Input/Html/Lucid.hs
+++ b/src/Knit/Report/Input/Html/Lucid.hs
@@ -17,16 +17,16 @@
   )
 where
 
-import Knit.Report.Input.Html (addLazyTextHtml)
+import           Knit.Report.Input.Html         ( addLazyTextHtml )
 import qualified Lucid                         as LH
 
 import qualified Polysemy                      as P
-import qualified Knit.Effect.Pandoc           as PE
-import qualified Knit.Effect.PandocMonad      as PM
+import qualified Knit.Effect.Pandoc            as PE
+import qualified Knit.Effect.PandocMonad       as PM
 
 -- | Add Lucid Html
 addLucid
   :: (PM.PandocEffects effs, P.Member PE.ToPandoc effs)
   => LH.Html ()
-  -> P.Semantic effs ()
+  -> P.Sem effs ()
 addLucid = addLazyTextHtml . LH.renderText
diff --git a/src/Knit/Report/Input/Latex.hs b/src/Knit/Report/Input/Latex.hs
--- a/src/Knit/Report/Input/Latex.hs
+++ b/src/Knit/Report/Input/Latex.hs
@@ -21,14 +21,14 @@
 import qualified Text.Pandoc                   as PA
 
 import qualified Polysemy                      as P
-import qualified Knit.Effect.Pandoc           as PE
-import qualified Knit.Effect.PandocMonad      as PM
+import qualified Knit.Effect.Pandoc            as PE
+import qualified Knit.Effect.PandocMonad       as PM
 
 -- | Add LaTeX
 addLatex
   :: (PM.PandocEffects effs, P.Member PE.ToPandoc effs)
   => T.Text
-  -> P.Semantic effs ()
+  -> P.Sem effs ()
 addLatex lText = do
   PE.require PE.LatexSupport
   PE.addFrom PE.ReadLaTeX PA.def lText
diff --git a/src/Knit/Report/Input/MarkDown/PandocMarkDown.hs b/src/Knit/Report/Input/MarkDown/PandocMarkDown.hs
--- a/src/Knit/Report/Input/MarkDown/PandocMarkDown.hs
+++ b/src/Knit/Report/Input/MarkDown/PandocMarkDown.hs
@@ -54,13 +54,13 @@
   :: (PM.PandocEffects effs, P.Member PE.ToPandoc effs)
   => PA.ReaderOptions
   -> T.Text
-  -> P.Semantic effs ()
+  -> P.Sem effs ()
 addMarkDownWithOptions = PE.addFrom PE.ReadMarkDown
 
 -- | Add a Pandoc MarkDown fragment with default options
 addMarkDown
   :: (PM.PandocEffects effs, P.Member PE.ToPandoc effs)
   => T.Text
-  -> P.Semantic effs ()
+  -> P.Sem effs ()
 addMarkDown = addMarkDownWithOptions markDownReaderOptions
 
diff --git a/src/Knit/Report/Input/Table/Colonnade.hs b/src/Knit/Report/Input/Table/Colonnade.hs
--- a/src/Knit/Report/Input/Table/Colonnade.hs
+++ b/src/Knit/Report/Input/Table/Colonnade.hs
@@ -30,14 +30,10 @@
 import qualified Colonnade                     as C
 import qualified Text.Blaze.Colonnade          as BC
 import qualified Text.Blaze.Html               as BH
-import qualified Text.Blaze.Html.Renderer.Text as BH
 import qualified Text.Blaze.Html5.Attributes   as BHA
 import           Knit.Report.Input.Html.Blaze   ( addBlaze )
-import           Knit.Report.Input.MarkDown.PandocMarkDown
-                                                ( addMarkDown )
 
 import           Data.Text                      ( Text )
-import qualified Data.Text.Lazy                as TL
 import qualified Polysemy                      as P
 import qualified Knit.Effect.Pandoc            as PE
 import qualified Knit.Effect.PandocMonad       as PM
@@ -47,7 +43,7 @@
   :: (PM.PandocEffects effs, P.Member PE.ToPandoc effs, Foldable f)
   => C.Colonnade C.Headed a Text -- ^ How to encode data as columns
   -> f a -- ^ collection of data
-  -> P.Semantic effs ()
+  -> P.Sem effs ()
 addColonnadeTextTable colonnade rows = do
   let toCell t = BC.Cell (BHA.style "border: 1px solid black") (BH.toHtml t) -- styling here gets lost.  But maybe I can fix?
   addBlaze $ BC.encodeCellTable
@@ -61,7 +57,7 @@
   => BH.Attribute -- ^ Attributes of <table> Html element, currently unused by knit-haskell
   -> C.Colonnade C.Headed a BH.Html -- ^ How to encode data as columns
   -> f a -- ^ collection of data
-  -> P.Semantic effs ()
+  -> P.Sem effs ()
 addColonnadeHtmlTable attr colonnade rows =
   addBlaze $ BC.encodeHtmlTable attr colonnade rows
 
@@ -71,6 +67,6 @@
   => BH.Attribute -- ^ Attributes of <table> Html element, currently unused by knit-haskell
   -> C.Colonnade C.Headed a BC.Cell -- ^ How to encode data as columns
   -> f a -- ^ collection of data
-  -> P.Semantic effs ()
+  -> P.Sem effs ()
 addColonnadeCellTable attr colonnade rows =
   addBlaze $ BC.encodeCellTable attr colonnade rows
diff --git a/src/Knit/Report/Input/Visualization/Hvega.hs b/src/Knit/Report/Input/Visualization/Hvega.hs
--- a/src/Knit/Report/Input/Visualization/Hvega.hs
+++ b/src/Knit/Report/Input/Visualization/Hvega.hs
@@ -44,7 +44,7 @@
   :: (PM.PandocEffects effs, P.Member PE.ToPandoc effs)
   => T.Text
   -> GV.VegaLite
-  -> P.Semantic effs ()
+  -> P.Sem effs ()
 addHvega vizId vl = do
   PE.require PE.VegaSupport
   addBlaze $ placeVisualization vizId vl
diff --git a/src/Knit/Report/Output/Html.hs b/src/Knit/Report/Output/Html.hs
--- a/src/Knit/Report/Output/Html.hs
+++ b/src/Knit/Report/Output/Html.hs
@@ -79,7 +79,7 @@
 markDownTextToBlazeFragment
   :: PM.PandocEffects effs
   => T.Text -- ^ markDown Text
-  -> P.Semantic effs BH.Html
+  -> P.Sem effs BH.Html
 markDownTextToBlazeFragment =
   PE.fromPandocE PE.WriteHtml5 htmlWriterOptions
     . PE.addFrom PE.ReadMarkDown markDownReaderOptions
@@ -91,7 +91,7 @@
   :: PM.PandocEffects effs
   => PandocWriterConfig
   -> PE.PandocWithRequirements -- ^ Document and union of input requirements 
-  -> P.Semantic effs BH.Html
+  -> P.Sem effs BH.Html
 toBlazeDocument writeConfig pdocWR = do
   writerOptions <- htmlFullDocWriterOptions (templateFP writeConfig)
                                             (templateVars writeConfig)
@@ -102,8 +102,8 @@
 pandocWriterToBlazeDocument
   :: PM.PandocEffects effs
   => PandocWriterConfig -- ^ Configuration info for the Pandoc writer
-  -> P.Semantic (PE.ToPandoc ': effs) () -- ^ Effects stack to run to get Pandoc
-  -> P.Semantic effs BH.Html -- ^ Blaze Html (in remaining effects)
+  -> P.Sem (PE.ToPandoc ': effs) () -- ^ Effects stack to run to get Pandoc
+  -> P.Sem effs BH.Html -- ^ Blaze Html (in remaining effects)
 pandocWriterToBlazeDocument writeConfig pw =
   PE.runPandocWriter pw >>= toBlazeDocument writeConfig