From 10fbde625b41801dc95b52699e09b1265999490b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Th=C3=A9ophile=20Choutri=20de=20Tarl=C3=A9?=
 <theophile@choutri.eu>
Date: Sat, 13 Jun 2026 11:56:44 +0200
Subject: [PATCH] Add code and outut style options

This PR adds styling options for the code fences and results in the
final document.

The idea is to support "cleaner" markdown generation for non-interactive
workflows so that neither the original code nor blockquotes are visible
in the generated markdown.
---
 app/Main.hs               | 56 ++++--------------------
 scripths.cabal            |  5 ++-
 src/ScriptHs/CLI/Types.hs | 72 +++++++++++++++++++++++++++++++
 src/ScriptHs/Markdown.hs  | 66 +++++++++++++++++++++++-----
 src/ScriptHs/Notebook.hs  | 43 ++++++++++++------
 test/Test/Integration.hs  |  9 +++-
 test/Test/Markdown.hs     | 91 ++++++++++++++++++++++++++-------------
 test/Test/Notebook.hs     | 49 ++++++++++++++++++---
 8 files changed, 282 insertions(+), 109 deletions(-)
 create mode 100644 src/ScriptHs/CLI/Types.hs

diff --git a/app/Main.hs b/app/Main.hs
index 1e999c1..2c66e55 100644
--- a/app/Main.hs
+++ b/app/Main.hs
@@ -1,7 +1,6 @@
 module Main where
 
 import Control.Monad (unless, when)
-import Data.List (isPrefixOf)
 import Data.Maybe (isJust)
 import qualified Data.Text as T
 import qualified Data.Text.IO as TIO
@@ -25,20 +24,8 @@ import ScriptHs.Version (
     tagStyleFor,
     tagVersion,
  )
-
--- | Parsed command-line options.
-data Args = Args
-    { argScript :: Maybe FilePath
-    , argOutput :: Maybe FilePath
-    , argPackages :: [FilePath]
-    , argNoLocalProject :: Bool
-    , argInPlace :: Bool
-    , argHelp :: Bool
-    , argVersion :: Bool
-    }
-
-emptyArgs :: Args
-emptyArgs = Args Nothing Nothing [] False False False False
+import ScriptHs.CLI.Types
+import ScriptHs.Markdown
 
 main :: IO ()
 main = do
@@ -61,7 +48,7 @@ main = do
                                 { roPackages = pkgs
                                 , roEnclosingProject = not (argNoLocalProject a)
                                 }
-                    dispatch opts path outPath
+                    dispatch (argOutputStyle a) (argCodeStyle a) opts path outPath
 
 {- | Resolve the output destination, honouring @--in-place@: write back over the
 notebook itself. In-place is only meaningful for notebooks (the @.ghci@\/@.hs@
@@ -80,43 +67,16 @@ resolveOutput a path
 isNotebook :: FilePath -> Bool
 isNotebook path = takeExtension path `elem` [".md", ".markdown"]
 
-dispatch :: RunOptions -> FilePath -> Maybe FilePath -> IO ()
-dispatch opts path outputPath =
+dispatch :: OutputStyle ->  CodeStyle -> RunOptions -> FilePath -> Maybe FilePath -> IO ()
+dispatch outputStyle codeStyle opts path outputPath =
     case takeExtension path of
-        ".md" -> runNotebook opts path outputPath
-        ".markdown" -> runNotebook opts path outputPath
+        ".md" -> runNotebook outputStyle codeStyle opts path outputPath
+        ".markdown" -> runNotebook outputStyle codeStyle opts path outputPath
         _ -> do
             contents <- TIO.readFile path
             let sf = parseScript contents
             runScript opts path sf
 
-{- | Parse args: @[-o FILE | --output=FILE] [-i | --in-place] [--package DIR |
--p DIR | --package=DIR]... [--no-local-project] [-h | --help] <script>@. The
-script is the sole non-flag argument.
--}
-parseArgs :: [String] -> Either String Args
-parseArgs = go emptyArgs
-  where
-    go a [] = Right a
-    go a ("-o" : f : rest) = go a{argOutput = Just f} rest
-    go _ ["-o"] = Left "-o requires a filename"
-    go a (tok : rest)
-        | tok == "-p" || tok == "--package" = case rest of
-            (d : rest') -> go a{argPackages = argPackages a ++ [d]} rest'
-            [] -> Left (tok ++ " requires a directory")
-        | Just f <- stripFlag "--output=" tok = go a{argOutput = Just f} rest
-        | Just d <- stripFlag "--package=" tok =
-            go a{argPackages = argPackages a ++ [d]} rest
-        | tok == "--no-local-project" = go a{argNoLocalProject = True} rest
-        | tok == "-i" || tok == "--in-place" = go a{argInPlace = True} rest
-        | tok == "-h" || tok == "--help" = go a{argHelp = True} rest
-        | tok == "-v" || tok == "--version" = go a{argVersion = True} rest
-        | "-" `isPrefixOf` tok = Left ("unknown flag: " ++ tok)
-        | otherwise = case argScript a of
-            Nothing -> go a{argScript = Just tok} rest
-            Just _ -> Left ("unexpected extra argument: " ++ tok)
-    stripFlag p s = if p `isPrefixOf` s then Just (drop (length p) s) else Nothing
-
 -- | Resolve a @--package@ dir to absolute, requiring a package root (a @.cabal@).
 resolvePackageDir :: FilePath -> IO FilePath
 resolvePackageDir dir = do
@@ -171,6 +131,8 @@ helpText prog =
         , "  --no-local-project        do not auto-include the enclosing cabal project"
         , "  -h, --help                show this help"
         , "  -v, --version             show the scripths version"
+        , "  --code-style=display|remove    control how code fences should appear after processing (default: display)"
+        , "  --output-style=quoted|raw      control how evaluted code is outputed (default: quoted)"
         , ""
         , "Files may carry a first-line version tag recording the scripths that wrote"
         , "them ('-- scripths: X' in scripts, '<!-- scripths: X -->' in notebooks); a"
diff --git a/scripths.cabal b/scripths.cabal
index 56ac4cc..54fc544 100644
--- a/scripths.cabal
+++ b/scripths.cabal
@@ -23,11 +23,12 @@ common warnings
 
 library
     import:           warnings
-    exposed-modules:  ScriptHs.Parser,
+    exposed-modules:  ScriptHs.CLI.Types,
                       ScriptHs.Compiled,
-                      ScriptHs.Render,
                       ScriptHs.Markdown,
                       ScriptHs.Notebook,
+                      ScriptHs.Parser,
+                      ScriptHs.Render,
                       ScriptHs.Repl,
                       ScriptHs.Run,
                       ScriptHs.Version
diff --git a/src/ScriptHs/CLI/Types.hs b/src/ScriptHs/CLI/Types.hs
new file mode 100644
index 0000000..4df1378
--- /dev/null
+++ b/src/ScriptHs/CLI/Types.hs
@@ -0,0 +1,72 @@
+module ScriptHs.CLI.Types (
+    Args (..),
+    emptyArgs,
+    parseArgs,
+) where
+
+import Data.List (isPrefixOf)
+import ScriptHs.Markdown
+
+-- | Parsed command-line options.
+data Args = Args
+    { argScript :: Maybe FilePath
+    , argOutput :: Maybe FilePath
+    , argPackages :: [FilePath]
+    , argNoLocalProject :: Bool
+    , argInPlace :: Bool
+    , argHelp :: Bool
+    , argVersion :: Bool
+    , argCodeStyle :: CodeStyle
+    , argOutputStyle :: OutputStyle
+    }
+
+emptyArgs :: Args
+emptyArgs =
+    Args
+        { argScript = Nothing
+        , argOutput = Nothing
+        , argPackages = []
+        , argNoLocalProject = False
+        , argInPlace = False
+        , argHelp = False
+        , argVersion = False
+        , argCodeStyle = DisplayCode
+        , argOutputStyle = OutputQuoted
+        }
+
+{- | Parse args: @[-o FILE | --output=FILE] [-i | --in-place] [--package DIR |
+-p DIR | --package=DIR]... [--no-local-project] [-h | --help] <script>@. The
+script is the sole non-flag argument.
+-}
+parseArgs :: [String] -> Either String Args
+parseArgs = go emptyArgs
+  where
+    go a [] = Right a
+    go a ("-o" : f : rest) = go a{argOutput = Just f} rest
+    go _ ["-o"] = Left "-o requires a filename"
+    go a (tok : rest)
+        | tok == "-p" || tok == "--package" = case rest of
+            (d : rest') -> go a{argPackages = argPackages a ++ [d]} rest'
+            [] -> Left (tok ++ " requires a directory")
+        | Just f <- stripFlag "--output=" tok = go a{argOutput = Just f} rest
+        | Just d <- stripFlag "--package=" tok =
+            go a{argPackages = argPackages a ++ [d]} rest
+        | tok == "--no-local-project" = go a{argNoLocalProject = True} rest
+        | tok == "-i" || tok == "--in-place" = go a{argInPlace = True} rest
+        | tok == "-h" || tok == "--help" = go a{argHelp = True} rest
+        | tok == "-v" || tok == "--version" = go a{argVersion = True} rest
+        | tok == "--code-style" = case rest of
+            (d : rest') -> case parseCodeStyle d of
+                Just codeStyle -> go a{argCodeStyle = codeStyle} rest'
+                Nothing -> Left ("Could not parse code style: " ++ tok)
+            [] -> Left (tok ++ " requires a code style")
+        | tok == "--output-style" = case rest of
+            (d : rest') -> case parseOutputStyle d of
+                Just codeStyle -> go a{argOutputStyle = codeStyle} rest'
+                Nothing -> Left ("Could not parse output style: " ++ tok)
+            [] -> Left (tok ++ " requires a output style")
+        | "-" `isPrefixOf` tok = Left ("unknown flag: " ++ tok)
+        | otherwise = case argScript a of
+            Nothing -> go a{argScript = Just tok} rest
+            Just _ -> Left ("unexpected extra argument: " ++ tok)
+    stripFlag p s = if p `isPrefixOf` s then Just (drop (length p) s) else Nothing
diff --git a/src/ScriptHs/Markdown.hs b/src/ScriptHs/Markdown.hs
index bee4004..4ec9abd 100644
--- a/src/ScriptHs/Markdown.hs
+++ b/src/ScriptHs/Markdown.hs
@@ -4,11 +4,46 @@ module ScriptHs.Markdown (
     reassemble,
     MimeType (..),
     CodeOutput (..),
+    CodeStyle (..),
+    parseCodeStyle,
+    defaultCodeStyle,
+    OutputStyle (..),
+    parseOutputStyle,
+    defaultOutputStyle,
 ) where
 
 import Data.Text (Text)
 import qualified Data.Text as T
 
+{- |  Directs how the original code fences are styled
+  in the processed output.
+-}
+data CodeStyle
+    = DisplayCode
+    | RemoveCode
+    deriving (Eq, Ord, Show)
+
+parseCodeStyle :: String -> Maybe CodeStyle
+parseCodeStyle "display" = Just DisplayCode
+parseCodeStyle "remove" = Just RemoveCode
+parseCodeStyle _ = Nothing
+
+defaultCodeStyle :: CodeStyle
+defaultCodeStyle = DisplayCode
+
+data OutputStyle
+    = OutputQuoted
+    | OutputRaw
+    deriving (Eq, Ord, Show)
+
+parseOutputStyle :: String -> Maybe OutputStyle
+parseOutputStyle "quoted" = Just OutputQuoted
+parseOutputStyle "raw" = Just OutputRaw
+parseOutputStyle _ = Nothing
+
+defaultOutputStyle :: OutputStyle
+defaultOutputStyle = OutputQuoted
+
 data MimeType
     = MimeHtml
     | MimeMarkdown
@@ -19,7 +54,8 @@ data MimeType
     | MimePlain
     deriving (Show, Eq)
 
-data CodeOutput = CodeOutput MimeType Text deriving (Show, Eq)
+data CodeOutput = CodeOutput OutputStyle MimeType Text
+    deriving (Show, Eq)
 
 data Segment
     = Prose Text
@@ -48,7 +84,8 @@ parseMarkdown' acc (line : rest) = case fenceLang line of
                                 (cOutput, afterOutput) = span (T.isPrefixOf "> ") xs
                                 mType = mimeFromTag x
                              in
-                                ( Just (CodeOutput mType (T.unlines (map (T.drop (T.length "> ")) cOutput)))
+                                ( Just
+                                    (CodeOutput OutputQuoted mType (T.unlines (map (T.drop (T.length "> ")) cOutput)))
                                 , afterOutput
                                 )
                 [] -> (Nothing, rest')
@@ -91,8 +128,8 @@ fenceCodeSegment lang output
 seam between segments collapses to one blank line and the document's leading/
 trailing blanks are trimmed, so re-running (e.g. @--in-place@) adds no new lines.
 -}
-reassemble :: [Segment] -> Text
-reassemble = finalize . foldr (joinSeam . renderSegment) ""
+reassemble :: CodeStyle -> [Segment] -> Text
+reassemble codeStyle = finalize . foldr (joinSeam . renderSegment codeStyle) ""
   where
     joinSeam "" acc = acc
     joinSeam piece "" = piece
@@ -106,19 +143,26 @@ reassemble = finalize . foldr (joinSeam . renderSegment) ""
         let stripped = T.dropWhileEnd (== '\n') (T.dropWhile (== '\n') t)
          in if T.null stripped then "" else stripped <> "\n"
 
-renderSegment :: Segment -> Text
-renderSegment (Prose t) = t
-renderSegment (CodeBlock lang code Nothing) = fenceCodeSegment lang code
-renderSegment (CodeBlock lang code (Just output)) = fenceCodeSegment lang code <> blockQuote output
+renderSegment :: CodeStyle -> Segment -> Text
+renderSegment _ (Prose t) = t
+renderSegment _ (CodeBlock lang code Nothing) = fenceCodeSegment lang code
+renderSegment codeStyle (CodeBlock lang code (Just output)) =
+    let codeFence = case codeStyle of
+            DisplayCode -> fenceCodeSegment lang code
+            RemoveCode -> mempty
+     in codeFence <> blockQuote output
 
 blockQuote :: CodeOutput -> Text
-blockQuote (CodeOutput mimeType t) =
+blockQuote (CodeOutput outputStyle mimeType t) =
     let
         ls = (mimeMarker <> mimeIndicator mimeType <> " -->") : T.lines t
         trimmed = reverse $ dropWhile T.null $ reverse ls
-        quoted = T.unlines $ map (\l -> if T.null l then "> " else "> " <> l) trimmed
+        styling = case outputStyle of
+            OutputQuoted -> "> "
+            OutputRaw -> ""
+        output = T.unlines $ map (\l -> if T.null l then styling else styling <> l) trimmed
      in
-        quoted <> "\n"
+        output <> "\n"
 
 mimeIndicator :: MimeType -> Text
 mimeIndicator m = case m of
diff --git a/src/ScriptHs/Notebook.hs b/src/ScriptHs/Notebook.hs
index c5ad303..3f9389b 100644
--- a/src/ScriptHs/Notebook.hs
+++ b/src/ScriptHs/Notebook.hs
@@ -13,7 +13,9 @@ import System.CPUTime (getCPUTime)
 
 import ScriptHs.Markdown (
     CodeOutput (..),
+    CodeStyle,
     MimeType (..),
+    OutputStyle,
     Segment (..),
     parseMarkdown,
     reassemble,
@@ -37,10 +39,11 @@ type IndexedBlocks = [(Int, [Line])]
 clean; output written to a file (@-o@ or @--in-place@) is stamped with the
 current scripths version tag at the top.
 -}
-runNotebook :: RunOptions -> FilePath -> Maybe FilePath -> IO ()
-runNotebook opts path outputPath = do
+runNotebook ::
+    OutputStyle -> CodeStyle -> RunOptions -> FilePath -> Maybe FilePath -> IO ()
+runNotebook outputStyle codeStyle opts path outputPath = do
     contents <- stripBom <$> TIO.readFile path
-    outputMd <- processNotebook opts path contents
+    outputMd <- processNotebook outputStyle codeStyle opts path contents
     case outputPath of
         Nothing -> TIO.putStr outputMd
         Just output -> TIO.writeFile output (stampVersion NotebookTag outputMd)
@@ -49,22 +52,33 @@ runNotebook opts path outputPath = do
 stripBom :: Text -> Text
 stripBom t = fromMaybe t (T.stripPrefix "\65279" t)
 
-processNotebook :: RunOptions -> FilePath -> Text -> IO Text
-processNotebook opts notebookPath contents = do
+processNotebook ::
+    OutputStyle -> CodeStyle -> RunOptions -> FilePath -> Text -> IO Text
+processNotebook outputStyle codeStyle opts notebookPath contents = do
     let indexedSegments = zip [0 ..] (parseMarkdown contents)
         (metas, indexedCodeBlocks) = parseBlocks indexedSegments
     if null indexedCodeBlocks
         then pure contents
-        else executeCodeCells opts notebookPath metas indexedSegments indexedCodeBlocks
+        else
+            executeCodeCells
+                outputStyle
+                codeStyle
+                opts
+                notebookPath
+                metas
+                indexedSegments
+                indexedCodeBlocks
 
 executeCodeCells ::
+    OutputStyle ->
+    CodeStyle ->
     RunOptions ->
     FilePath ->
     CabalMeta ->
     IndexedSegments ->
     IndexedBlocks ->
     IO Text
-executeCodeCells opts notebookPath meta allSegments codeBlocks = do
+executeCodeCells outputStyle codeStyle opts notebookPath meta allSegments codeBlocks = do
     let ghciScript0 = generatedMarkedScript "" codeBlocks
     nonce <- makeNonce ghciScript0
     let ghciScript = generatedMarkedScript nonce codeBlocks
@@ -76,8 +90,8 @@ executeCodeCells opts notebookPath meta allSegments codeBlocks = do
             map
                 (fmap (scrubCellOutput nonce indices))
                 (splitByMarkers nonce rawOutput indices)
-        blocksWithOutput = addOutputToSegments outputs allSegments
-    pure $ reassemble blocksWithOutput
+        blocksWithOutput = addOutputToSegments outputStyle outputs allSegments
+    pure $ reassemble codeStyle blocksWithOutput
 
 {- | A per-run hex nonce woven into every cell-end marker so a cell's own output
 cannot spoof a marker and misattribute another cell's output. Mixes the process
@@ -104,11 +118,16 @@ scrubCellOutput nonce indices =
   where
     stripMarkers t = foldr (\i acc -> T.replace (mkMarker nonce i) "" acc) t indices
 
-addOutputToSegments :: [(Int, Text)] -> IndexedSegments -> [Segment]
-addOutputToSegments outputs = map addOutput
+addOutputToSegments ::
+    OutputStyle -> [(Int, Text)] -> IndexedSegments -> [Segment]
+addOutputToSegments outputStyle outputs = map addOutput
   where
     addOutput :: (Int, Segment) -> Segment
-    addOutput (i, CodeBlock lang code _) = CodeBlock lang code (fmap (CodeOutput MimePlain) (lookup i outputs))
+    addOutput (i, CodeBlock lang code _) =
+        CodeBlock
+            lang
+            code
+            (fmap (CodeOutput outputStyle MimePlain) (lookup i outputs))
     addOutput (_, seg) = seg
 
 mkIndexedCodeSegments :: IndexedSegments -> IndexedSegments
diff --git a/test/Test/Integration.hs b/test/Test/Integration.hs
index 142e3cb..d014533 100644
--- a/test/Test/Integration.hs
+++ b/test/Test/Integration.hs
@@ -5,6 +5,7 @@ import System.Environment (lookupEnv)
 import Test.Tasty (TestTree, testGroup)
 import Test.Tasty.HUnit (assertBool, testCase)
 
+import ScriptHs.Markdown
 import ScriptHs.Notebook (processNotebook)
 import ScriptHs.Run (defaultRunOptions)
 
@@ -34,7 +35,13 @@ integrationTests =
                                 , "\"rendered-ok\" :: String"
                                 , "```"
                                 ]
-                    out <- processNotebook defaultRunOptions "/tmp/scripths-integration.md" nb
+                    out <-
+                        processNotebook
+                            defaultOutputStyle
+                            defaultCodeStyle
+                            defaultRunOptions
+                            "/tmp/scripths-integration.md"
+                            nb
                     assertBool "renders the cell value" ("rendered-ok" `T.isInfixOf` out)
                     assertBool
                         "no ScripthsInternal leak"
diff --git a/test/Test/Markdown.hs b/test/Test/Markdown.hs
index 4089232..d8f2eaf 100644
--- a/test/Test/Markdown.hs
+++ b/test/Test/Markdown.hs
@@ -10,13 +10,7 @@ import Test.Tasty.HUnit (
 
 import Data.Text (Text)
 import qualified Data.Text as T
-import ScriptHs.Markdown (
-    CodeOutput (..),
-    MimeType (..),
-    Segment (CodeBlock, Prose),
-    parseMarkdown,
-    reassemble,
- )
+import ScriptHs.Markdown
 
 markdownTests :: TestTree
 markdownTests =
@@ -105,7 +99,7 @@ markdownTests =
                 let segs = parseMarkdown input
                 length segs @?= 2
                 case segs of
-                    [CodeBlock _ _ (Just (CodeOutput m _)), Prose _] -> assertBool "mime is latex" (m == MimeLatex)
+                    [CodeBlock _ _ (Just (CodeOutput _ m _)), Prose _] -> assertBool "mime is latex" (m == MimeLatex)
                     other -> assertFailure $ "expected [CodeBlock, Prose], got: " ++ show other
             , testCase "svg mimetype" $ do
                 let input =
@@ -122,7 +116,7 @@ markdownTests =
                 let segs = parseMarkdown input
                 length segs @?= 2
                 case segs of
-                    [CodeBlock _ _ (Just (CodeOutput m _)), Prose _] -> assertBool "mime is svg" (m == MimeSvg)
+                    [CodeBlock _ _ (Just (CodeOutput _ m _)), Prose _] -> assertBool "mime is svg" (m == MimeSvg)
                     other -> assertFailure $ "expected [CodeBlock, Prose], got: " ++ show other
             , testCase "multiple code blocks" $ do
                 let input =
@@ -152,7 +146,7 @@ markdownTests =
                 length outputBlocks @?= 2
                 assertBool
                     "all mimeType plain"
-                    (all (== MimePlain) [m | (Just (CodeOutput m _)) <- outputBlocks])
+                    (all (== MimePlain) [m | (Just (CodeOutput _ m _)) <- outputBlocks])
             , testCase "non-haskell code block preserved" $ do
                 let input =
                         T.unlines
@@ -197,32 +191,50 @@ markdownTests =
         , testGroup
             "reassemble"
             [ testCase "prose without output" $ do
-                let result = reassemble [Prose "Hello\n"]
+                let result = reassemble defaultCodeStyle [Prose "Hello\n"]
                 result @?= "Hello\n"
             , testCase "code block without output" $ do
-                let result = reassemble [CodeBlock "haskell" "print 42\n" Nothing]
+                let result = reassemble defaultCodeStyle [CodeBlock "haskell" "print 42\n" Nothing]
                 assertBool "has fence" (T.isInfixOf "```haskell" result)
                 assertBool "has code" (T.isInfixOf "print 42" result)
                 assertBool "no blockquote" (not $ T.isInfixOf "> " result)
             , testCase "code block with output" $ do
                 let result =
-                        reassemble [CodeBlock "haskell" "print 42\n" (Just $ CodeOutput MimePlain "42")]
+                        reassemble
+                            defaultCodeStyle
+                            [ CodeBlock
+                                "haskell"
+                                "print 42\n"
+                                (Just $ CodeOutput defaultOutputStyle MimePlain "42")
+                            ]
                 assertBool "has fence" (T.isInfixOf "```haskell" result)
                 assertBool "has code" (T.isInfixOf "print 42" result)
                 assertBool "has blockquote" (T.isInfixOf "> 42" result)
             , testCase "code block with multi-line output" $ do
                 let result =
-                        reassemble [CodeBlock "hs" "print [1,2]\n" (Just $ CodeOutput MimePlain "1\n2")]
+                        reassemble
+                            defaultCodeStyle
+                            [ CodeBlock
+                                "hs"
+                                "print [1,2]\n"
+                                (Just $ CodeOutput defaultOutputStyle MimePlain "1\n2")
+                            ]
                 assertBool "has > 1" (T.isInfixOf "> 1" result)
                 assertBool "has > 2" (T.isInfixOf "> 2" result)
             , testCase "full document roundtrip" $ do
                 let segs =
                         [ Prose "# Title\n\n"
-                        , CodeBlock "haskell" "print 42\n" (Just $ CodeOutput MimePlain "42")
+                        , CodeBlock
+                            "haskell"
+                            "print 42\n"
+                            (Just $ CodeOutput defaultOutputStyle MimePlain "42")
                         , Prose "\nSome text.\n"
-                        , CodeBlock "haskell" "print 99\n" (Just $ CodeOutput MimePlain "99")
+                        , CodeBlock
+                            "haskell"
+                            "print 99\n"
+                            (Just $ CodeOutput defaultOutputStyle MimePlain "99")
                         ]
-                let result = reassemble segs
+                let result = reassemble defaultCodeStyle segs
 
                 assertBool "has title" (T.isInfixOf "# Title" result)
                 assertBool "has first output" (T.isInfixOf "> 42" result)
@@ -238,17 +250,38 @@ markdownTests =
                 assertBool "middle before code2" (middleIdx < code2Idx)
             ]
         , testGroup
-            "blockquote"
-            [ testCase "single line" $ do
-                let result = reassemble [CodeBlock "hs" "x\n" (Just $ CodeOutput MimePlain "hello")]
-                assertBool "blockquoted" (T.isInfixOf "> hello" result)
-            , testCase "empty lines in output get bare >" $ do
-                let result = reassemble [CodeBlock "hs" "x\n" (Just $ CodeOutput MimePlain "a\n\nb")]
-                assertBool "has bare >" (T.isInfixOf "\n> \n" result)
-            , testCase "renders the scripths:mime marker (not the legacy sabela)" $ do
-                let result = reassemble [CodeBlock "hs" "x\n" (Just $ CodeOutput MimePlain "y")]
-                assertBool "uses scripths:mime" (T.isInfixOf "scripths:mime" result)
-                assertBool "no sabela:mime" (not (T.isInfixOf "sabela:mime" result))
+            "Output style"
+            [ testGroup
+                "raw"
+                [ testCase "Raw output" $ do
+                    let result =
+                            reassemble
+                                defaultCodeStyle
+                                [CodeBlock "hs" "x\n" (Just $ CodeOutput OutputRaw MimePlain "hello")]
+                    assertBool "Not quoted" (T.isInfixOf "hello" result)
+                ]
+            , testGroup
+                "blockquote"
+                [ testCase "single line" $ do
+                    let result =
+                            reassemble
+                                defaultCodeStyle
+                                [CodeBlock "hs" "x\n" (Just $ CodeOutput defaultOutputStyle MimePlain "hello")]
+                    assertBool "blockquoted" (T.isInfixOf "> hello" result)
+                , testCase "empty lines in output get bare >" $ do
+                    let result =
+                            reassemble
+                                defaultCodeStyle
+                                [CodeBlock "hs" "x\n" (Just $ CodeOutput defaultOutputStyle MimePlain "a\n\nb")]
+                    assertBool "has bare >" (T.isInfixOf "\n> \n" result)
+                , testCase "renders the scripths:mime marker (not the legacy sabela)" $ do
+                    let result =
+                            reassemble
+                                defaultCodeStyle
+                                [CodeBlock "hs" "x\n" (Just $ CodeOutput defaultOutputStyle MimePlain "y")]
+                    assertBool "uses scripths:mime" (T.isInfixOf "scripths:mime" result)
+                    assertBool "no sabela:mime" (not (T.isInfixOf "sabela:mime" result))
+                ]
             ]
         , testGroup
             "idempotency (no extra blank lines on re-run)"
@@ -297,7 +330,7 @@ markdownTests =
         ]
 
 roundTrip :: Text -> Text
-roundTrip = reassemble . parseMarkdown
+roundTrip = reassemble defaultCodeStyle . parseMarkdown
 
 nlCount :: Text -> Int
 nlCount = T.length . T.filter (== '\n')
diff --git a/test/Test/Notebook.hs b/test/Test/Notebook.hs
index f401a77..a327923 100644
--- a/test/Test/Notebook.hs
+++ b/test/Test/Notebook.hs
@@ -5,7 +5,14 @@ import Test.Tasty.HUnit (assertBool, assertFailure, testCase, (@?=))
 
 import qualified Data.Text as T
 
-import ScriptHs.Markdown (CodeOutput (..), MimeType (..), Segment (..))
+import ScriptHs.Markdown (
+    CodeOutput (..),
+    CodeStyle (..),
+    MimeType (..),
+    Segment (..),
+    defaultCodeStyle,
+    defaultOutputStyle,
+ )
 import ScriptHs.Notebook (
     addOutputToSegments,
     generatedMarkedScript,
@@ -151,12 +158,12 @@ notebookTests =
                             , CodeBlock
                                 "hs"
                                 "print 3\n"
-                                (Just $ CodeOutput MimePlain "old-should-be-replaced")
+                                (Just $ CodeOutput defaultOutputStyle MimePlain "old-should-be-replaced")
                             )
                         , (4, Prose "outro\n")
                         ]
 
-                let result = addOutputToSegments outputs indexedSegs
+                let result = addOutputToSegments defaultOutputStyle outputs indexedSegs
 
                 length result @?= length indexedSegs
 
@@ -164,8 +171,15 @@ notebookTests =
                 result !! 4 @?= Prose "outro\n"
 
                 result !! 1
-                    @?= CodeBlock "haskell" "print 1\n" (Just $ CodeOutput MimePlain "out-1")
-                result !! 3 @?= CodeBlock "hs" "print 3\n" (Just $ CodeOutput MimePlain "out-3")
+                    @?= CodeBlock
+                        "haskell"
+                        "print 1\n"
+                        (Just $ CodeOutput defaultOutputStyle MimePlain "out-1")
+                result !! 3
+                    @?= CodeBlock
+                        "hs"
+                        "print 3\n"
+                        (Just $ CodeOutput defaultOutputStyle MimePlain "out-3")
 
                 result !! 2 @?= CodeBlock "python" "print('x')\n" Nothing
             ]
@@ -231,7 +245,8 @@ notebookTests =
             "processNotebook"
             [ testCase "no code blocks => returns input unchanged" $ do
                 let input = T.unlines ["# Title", "", "Just prose.", ""]
-                out <- processNotebook defaultRunOptions "" input
+                out <-
+                    processNotebook defaultOutputStyle defaultCodeStyle defaultRunOptions "" input
                 out @?= input
             , testCase "non-haskell code blocks only => returns input unchanged" $ do
                 let input =
@@ -244,7 +259,8 @@ notebookTests =
                             , ""
                             , "more prose"
                             ]
-                out <- processNotebook defaultRunOptions "" input
+                out <-
+                    processNotebook defaultOutputStyle defaultCodeStyle defaultRunOptions "" input
                 out @?= input
             ]
         , testGroup
@@ -265,4 +281,23 @@ notebookTests =
                 let out = "real data: " <> mkMarker tn 5
                 scrubCellOutput tn [0] out @?= out
             ]
+        , testGroup
+            "Code style"
+            [ testCase "Removed code in final output" $ do
+                let input =
+                        T.unlines
+                            [ "# Title"
+                            , "```haskell"
+                            , "1 + 1"
+                            , "```"
+                            ]
+                result <-
+                    processNotebook defaultOutputStyle RemoveCode defaultRunOptions "" input
+                result
+                    @?= T.unlines
+                        [ "# Title"
+                        , "> <!-- scripths:mime text/plain -->"
+                        , "> 2"
+                        ]
+            ]
         ]