diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index c0a524b..abfef6b 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -32,5 +32,6 @@ jobs:
       - run: nix develop --ignore-environment --command make vendor
 
       - run: nix develop --ignore-environment --command make fmt-check
+      - run: nix develop --ignore-environment --command make lint
       - run: nix develop --ignore-environment --command make vet
-      - run: nix develop --ignore-environment --command make test
\ No newline at end of file
+      - run: nix develop --ignore-environment --command make test
diff --git a/.golangci.yml b/.golangci.yml
new file mode 100644
index 0000000..7a88653
--- /dev/null
+++ b/.golangci.yml
@@ -0,0 +1,13 @@
+version: "2"
+
+linters:
+  default: none
+  enable:
+    - godox
+
+issues:
+  max-issues-per-linter: 0
+  max-same-issues: 0
+
+run:
+  modules-download-mode: vendor
diff --git a/.mockery.yaml b/.mockery.yaml
index c1a8c3a..ca80148 100644
--- a/.mockery.yaml
+++ b/.mockery.yaml
@@ -4,6 +4,10 @@ packages:
   litdoc/internal:
     interfaces:
       Cell:
+        config:
+          dir: ./internal/
+          pkgname: internal_test
+      CellParser:
         config:
           dir: ./internal/
           pkgname: internal_test
\ No newline at end of file
diff --git a/Makefile b/Makefile
index ecbc794..bdc198f 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,7 @@
 GO ?= go
 
 .PHONY: pre-pr
-pre-pr: clean mock fmt-check vet test
+pre-pr: clean mock fmt-check lint vet test
 
 .PHONY: fmt
 fmt:
@@ -20,6 +20,10 @@ fmt-check:
 vet:
 	@$(GO) vet ./...
 
+.PHONY: lint
+lint: vendor
+	@golangci-lint run ./...
+
 .PHONY: mock
 mock:
 	@mockery
diff --git a/cmd/file.go b/cmd/file.go
index e146666..9c2de53 100644
--- a/cmd/file.go
+++ b/cmd/file.go
@@ -6,6 +6,8 @@ import (
 	"path/filepath"
 
 	"litdoc/internal"
+	"litdoc/internal/bash"
+	"litdoc/internal/static"
 
 	"github.com/spf13/cobra"
 )
@@ -18,7 +20,11 @@ var fileCmd = &cobra.Command{
 	Args:  cobra.ExactArgs(1),
 	Run: func(cmd *cobra.Command, args []string) {
 		path := args[0]
-		data, err := internal.ProcessFile(path)
+		parsers := map[string]internal.CellParser{
+			"static": internal.CellParserFunc(static.ParseCell),
+			"bash":   internal.CellParserFunc(bash.ParseCell),
+		}
+		data, err := internal.ProcessFile(path, parsers)
 		if err != nil {
 			fmt.Fprintln(os.Stderr, err)
 			os.Exit(1)
diff --git a/flake.nix b/flake.nix
index ca92971..b81c8fb 100644
--- a/flake.nix
+++ b/flake.nix
@@ -14,6 +14,7 @@
         devShells.default = pkgs.mkShell {
           packages = with pkgs; [
             go
+            golangci-lint
             go-mockery
             cacert
           ];
@@ -27,4 +28,4 @@
         };
       }
     );
-}
\ No newline at end of file
+}
diff --git a/internal/CellParser_mock_test.go b/internal/CellParser_mock_test.go
new file mode 100644
index 0000000..0e4317d
--- /dev/null
+++ b/internal/CellParser_mock_test.go
@@ -0,0 +1,112 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+
+package internal_test
+
+import (
+	"litdoc/internal"
+
+	mock "github.com/stretchr/testify/mock"
+)
+
+// NewMockCellParser creates a new instance of MockCellParser. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockCellParser(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockCellParser {
+	mock := &MockCellParser{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// MockCellParser is an autogenerated mock type for the CellParser type
+type MockCellParser struct {
+	mock.Mock
+}
+
+type MockCellParser_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockCellParser) EXPECT() *MockCellParser_Expecter {
+	return &MockCellParser_Expecter{mock: &_m.Mock}
+}
+
+// Parse provides a mock function for the type MockCellParser
+func (_mock *MockCellParser) Parse(block internal.Block, following []internal.Block) (internal.Cell, int, error) {
+	ret := _mock.Called(block, following)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Parse")
+	}
+
+	var r0 internal.Cell
+	var r1 int
+	var r2 error
+	if returnFunc, ok := ret.Get(0).(func(internal.Block, []internal.Block) (internal.Cell, int, error)); ok {
+		return returnFunc(block, following)
+	}
+	if returnFunc, ok := ret.Get(0).(func(internal.Block, []internal.Block) internal.Cell); ok {
+		r0 = returnFunc(block, following)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(internal.Cell)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(internal.Block, []internal.Block) int); ok {
+		r1 = returnFunc(block, following)
+	} else {
+		r1 = ret.Get(1).(int)
+	}
+	if returnFunc, ok := ret.Get(2).(func(internal.Block, []internal.Block) error); ok {
+		r2 = returnFunc(block, following)
+	} else {
+		r2 = ret.Error(2)
+	}
+	return r0, r1, r2
+}
+
+// MockCellParser_Parse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Parse'
+type MockCellParser_Parse_Call struct {
+	*mock.Call
+}
+
+// Parse is a helper method to define mock.On call
+//   - block internal.Block
+//   - following []internal.Block
+func (_e *MockCellParser_Expecter) Parse(block interface{}, following interface{}) *MockCellParser_Parse_Call {
+	return &MockCellParser_Parse_Call{Call: _e.mock.On("Parse", block, following)}
+}
+
+func (_c *MockCellParser_Parse_Call) Run(run func(block internal.Block, following []internal.Block)) *MockCellParser_Parse_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 internal.Block
+		if args[0] != nil {
+			arg0 = args[0].(internal.Block)
+		}
+		var arg1 []internal.Block
+		if args[1] != nil {
+			arg1 = args[1].([]internal.Block)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *MockCellParser_Parse_Call) Return(cell internal.Cell, n int, err error) *MockCellParser_Parse_Call {
+	_c.Call.Return(cell, n, err)
+	return _c
+}
+
+func (_c *MockCellParser_Parse_Call) RunAndReturn(run func(block internal.Block, following []internal.Block) (internal.Cell, int, error)) *MockCellParser_Parse_Call {
+	_c.Call.Return(run)
+	return _c
+}
diff --git a/internal/bash/cell.go b/internal/bash/cell.go
new file mode 100644
index 0000000..0292b1c
--- /dev/null
+++ b/internal/bash/cell.go
@@ -0,0 +1,57 @@
+package bash
+
+import (
+	"fmt"
+
+	"litdoc/internal"
+)
+
+type Cell struct {
+	block  internal.Block
+	output internal.Output
+}
+
+func MakeCellFromRaw(content, indent string, output internal.Output) Cell {
+	return Cell{
+		block:  internal.MakeBlockFromRaw(internal.BlockKindFencedCode, content, indent, false),
+		output: output,
+	}
+}
+
+func ParseCell(
+	block internal.Block,
+	following []internal.Block,
+) (
+	internal.Cell,
+	int,
+	error,
+) {
+	return parseCellWith(block, following, internal.OutputFromBlocks)
+}
+
+func parseCellWith(
+	block internal.Block,
+	following []internal.Block,
+	parseOutput func(internal.Block, []internal.Block) (internal.Output, int, error),
+) (
+	internal.Cell,
+	int,
+	error,
+) {
+	output, consumed, err := parseOutput(block, following)
+	if err != nil {
+		return nil, 0, fmt.Errorf("parsing output: %w", err)
+	}
+	return Cell{block: block, output: output}, consumed, nil
+}
+
+func (c Cell) Execute() (internal.Cell, error) {
+	return Cell{
+		block:  c.block,
+		output: internal.MakeOutput("output", c.block.Indent()),
+	}, nil
+}
+
+func (c Cell) Render() (string, error) {
+	return c.block.Render() + c.output.Render(), nil
+}
diff --git a/internal/bash/cell_test.go b/internal/bash/cell_test.go
new file mode 100644
index 0000000..b7ad715
--- /dev/null
+++ b/internal/bash/cell_test.go
@@ -0,0 +1,135 @@
+package bash_test
+
+import (
+	"strings"
+	"testing"
+
+	"litdoc/internal"
+	"litdoc/internal/bash"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func joinLines(lines ...string) string {
+	return strings.Join(lines, "\n")
+}
+
+func TestMakeCellFromRaw(t *testing.T) {
+	// given
+	code := joinLines(
+		"```bash",
+		"echo hello",
+		"```",
+		"",
+	)
+	output := internal.MakeOutput("hello", "")
+	cell := bash.MakeCellFromRaw(code, "", output)
+
+	// when
+	got, err := cell.Render()
+
+	// then
+	require.NoError(t, err)
+	assert.Equal(t, "```bash\necho hello\n```\n"+output.Render(), got)
+}
+
+func TestParseCellWith(t *testing.T) {
+	block := internal.MakeBlockFromRaw(internal.BlockKindFencedCode, joinLines(
+		"```bash",
+		"echo hello",
+		"```",
+		"",
+	), "", false)
+
+	t.Run("assembles cell from block and output", func(t *testing.T) {
+		// given
+		output := internal.MakeOutput("hello", "")
+		parseOutput := func(internal.Block, []internal.Block) (internal.Output, int, error) {
+			return output, 3, nil
+		}
+
+		// when
+		cell, consumed, err := bash.ParseCellWith(block, nil, parseOutput)
+
+		// then
+		require.NoError(t, err)
+		assert.Equal(t, 3, consumed)
+		rendered, err := cell.Render()
+		require.NoError(t, err)
+		assert.Equal(t, block.Render()+output.Render(), rendered)
+	})
+
+	t.Run("output parsing error is wrapped", func(t *testing.T) {
+		// given
+		parseOutput := func(internal.Block, []internal.Block) (internal.Output, int, error) {
+			return internal.Output{}, 0, assert.AnError
+		}
+
+		// when
+		_, _, err := bash.ParseCellWith(block, nil, parseOutput)
+
+		// then
+		require.ErrorContains(t, err, "parsing output")
+		require.ErrorIs(t, err, assert.AnError)
+	})
+}
+
+func TestRender(t *testing.T) {
+	t.Run("without output", func(t *testing.T) {
+		// given
+		code := joinLines(
+			"```bash",
+			"echo hello",
+			"```",
+			"",
+		)
+		cell := bash.MakeCellFromRaw(code, "", internal.MakeOutput("", ""))
+
+		// when
+		gotContent, err := cell.Render()
+
+		// then
+		require.NoError(t, err)
+		assert.Equal(t, code, gotContent)
+	})
+
+	t.Run("with output", func(t *testing.T) {
+		// given
+		fencedCode := joinLines(
+			"```bash",
+			"echo hello",
+			"```",
+			"",
+		)
+		output := internal.MakeOutput("hello", "")
+		cell := bash.MakeCellFromRaw(fencedCode, "", output)
+
+		// when
+		gotContent, err := cell.Render()
+
+		// then
+		require.NoError(t, err)
+		assert.Equal(t, fencedCode+output.Render(), gotContent)
+	})
+}
+
+func TestExecute(t *testing.T) {
+	// given
+	fencedCode := joinLines(
+		"```bash",
+		"echo hello",
+		"```",
+		"",
+	)
+	cell := bash.MakeCellFromRaw(fencedCode, "", internal.MakeOutput("", ""))
+
+	// when
+	gotCell, err := cell.Execute()
+
+	// then
+	require.NoError(t, err)
+	rendered, err := gotCell.Render()
+	require.NoError(t, err)
+	assert.Equal(t, fencedCode+internal.MakeOutput("output", "").Render(), rendered)
+}
diff --git a/internal/bash/export_test.go b/internal/bash/export_test.go
new file mode 100644
index 0000000..4d90090
--- /dev/null
+++ b/internal/bash/export_test.go
@@ -0,0 +1,3 @@
+package bash
+
+var ParseCellWith = parseCellWith
diff --git a/internal/block.go b/internal/block.go
index d6ef63f..75196a1 100644
--- a/internal/block.go
+++ b/internal/block.go
@@ -25,7 +25,7 @@ type Block struct {
 	// indent characters potentially nested blockquotes and lists
 	indent  string
 	content string
-	// continuation when preceding block is on the smame line
+	// continuation when a preceding block is on the same line
 	continuation bool
 }
 
@@ -51,8 +51,70 @@ func (b Block) Content() string { return b.content }
 
 func (b Block) Continuation() bool { return b.continuation }
 
-func (b Block) String() string {
-	return fmt.Sprintf("{%s %q}", b.kind, b.content)
+// headerLine returns the text on the block's opening line after stripping
+// the syntactic delimiter (fence characters for fenced code blocks,
+// "<!--" for HTML comments).
+func (b Block) headerLine() string {
+	firstLine := b.content
+	if i := strings.IndexByte(b.content, '\n'); i >= 0 {
+		firstLine = b.content[:i]
+	}
+	switch b.kind {
+	case BlockKindFencedCode:
+		return strings.TrimLeft(firstLine, "`~")
+	case BlockKindHTMLComment:
+		return strings.TrimSpace(strings.TrimPrefix(firstLine, "<!--"))
+	default:
+		return ""
+	}
+}
+
+func blankBlockQuoteLinePrefix(indent string) string {
+	if idx := strings.LastIndex(indent, ">"); idx >= 0 {
+		return indent[:idx+1]
+	}
+	return ""
+}
+
+func RenderIndent(indent string) string {
+	if idx := strings.LastIndex(indent, "> "); idx >= 0 {
+		prefixLen := idx + len("> ")
+		return indent[:prefixLen] + strings.Repeat(" ", len(indent)-prefixLen)
+	}
+	return strings.Repeat(" ", len(indent))
+}
+
+func (b Block) Render() string {
+	if len(b.indent) == 0 {
+		return b.content
+	}
+
+	lines := strings.Split(b.content, "\n")
+	var rendered strings.Builder
+	renderedIndent := RenderIndent(b.indent)
+	blankLineIndent := blankBlockQuoteLinePrefix(b.indent)
+	for i, line := range lines {
+		if i == len(lines)-1 && len(line) == 0 {
+			break
+		}
+		if i > 0 {
+			rendered.WriteByte('\n')
+		}
+		if len(line) == 0 {
+			rendered.WriteString(blankLineIndent)
+			continue
+		}
+		if i > 0 {
+			rendered.WriteString(renderedIndent)
+		} else if !b.continuation {
+			rendered.WriteString(b.indent)
+		}
+		rendered.WriteString(line)
+	}
+	if strings.HasSuffix(b.content, "\n") {
+		rendered.WriteByte('\n')
+	}
+	return rendered.String()
 }
 
 func MakeBlocksFromMarkdown(content []byte) ([]Block, error) {
@@ -181,7 +243,7 @@ func (c *blockCollector) appendTextGap(end uint32, stripPrefix, indent []byte) {
 	}
 	gap := stripIndent(c.content[c.pos:end], stripPrefix)
 	if len(bytes.TrimSpace(gap)) == 0 {
-		indent = []byte(renderIndent(string(indent)))
+		indent = []byte(RenderIndent(string(indent)))
 	}
 	c.appendBlock(BlockKindText, gap, indent)
 }
@@ -291,7 +353,7 @@ func blockPrefixes(
 // continuation indent) rather than the rendered block indent. Detect this case
 // and return the rendered indent so the marker is classified correctly.
 func normalizeHTMLCommentPrefix(raw, linePrefix, containerIndent []byte) ([]byte, bool) {
-	renderedIndent := []byte(renderIndent(string(containerIndent)))
+	renderedIndent := []byte(RenderIndent(string(containerIndent)))
 	if !bytes.HasPrefix(linePrefix, renderedIndent) {
 		return nil, false
 	}
diff --git a/internal/cell.go b/internal/cell.go
index 5d618a4..0d71913 100644
--- a/internal/cell.go
+++ b/internal/cell.go
@@ -10,46 +10,14 @@ type Cell interface {
 	Render() (string, error)
 }
 
-type StaticCell struct {
-	content string
+type CellParser interface {
+	Parse(block Block, following []Block) (Cell, int, error)
 }
 
-func MakeStaticCellFromRaw(content string) StaticCell {
-	return StaticCell{content: content}
-}
-
-func (t StaticCell) Execute() (Cell, error) {
-	return t, nil
-}
+type CellParserFunc func(block Block, following []Block) (Cell, int, error)
 
-func (t StaticCell) Render() (string, error) {
-	return t.content, nil
-}
-
-type BashCell struct {
-	fencedCode string
-	indent     string
-	output     Output
-}
-
-func MakeBashCellFromRaw(fencedCode string, output Output) BashCell {
-	return BashCell{
-		fencedCode: fencedCode,
-		indent:     leadingIndent(fencedCode),
-		output:     output,
-	}
-}
-
-func (c BashCell) Execute() (Cell, error) {
-	return BashCell{
-		fencedCode: c.fencedCode,
-		indent:     c.indent,
-		output:     MakeOutput("output"),
-	}, nil
-}
-
-func (c BashCell) Render() (string, error) {
-	return c.fencedCode + c.output.Render(renderIndent(c.indent)), nil
+func (f CellParserFunc) Parse(block Block, following []Block) (Cell, int, error) {
+	return f(block, following)
 }
 
 type InfoString struct {
@@ -57,18 +25,9 @@ type InfoString struct {
 	Litdoc bool
 }
 
-func ParseInfoString(b Block) InfoString {
-	firstLine := b.content
-	if i := strings.IndexByte(b.content, '\n'); i >= 0 {
-		firstLine = b.content[:i]
-	}
-	var raw string
-	switch b.kind {
-	case BlockKindFencedCode:
-		raw = strings.TrimLeft(firstLine, "`~")
-	case BlockKindHTMLComment:
-		raw = strings.TrimSpace(strings.TrimPrefix(firstLine, "<!--"))
-	default:
+func InfoStringFromBlock(b Block) InfoString {
+	raw := b.headerLine()
+	if raw == "" {
 		return InfoString{}
 	}
 	parts := strings.SplitN(raw, " | ", 2)
@@ -77,100 +36,50 @@ func ParseInfoString(b Block) InfoString {
 	return InfoString{Lang: lang, Litdoc: litdoc}
 }
 
-func Classify(blocks []Block) ([]Cell, error) {
+func Classify(blocks []Block, parsers map[string]CellParser) ([]Cell, error) {
+	static, ok := parsers["static"]
+	if !ok {
+		return nil, fmt.Errorf("no static parser provided")
+	}
 	var cells []Cell
 	i := 0
 	for i < len(blocks) {
 		b := blocks[i]
 		switch b.kind {
 		case BlockKindFencedCode, BlockKindHTMLComment:
-			info := ParseInfoString(b)
+			info := InfoStringFromBlock(b)
 			switch {
-			case info.Litdoc && info.Lang == "bash":
-				output, consumed, err := OutputFromBlocks(b, blocks[i+1:])
+			case info.Litdoc:
+				parser, ok := parsers[info.Lang]
+				if !ok {
+					return nil, fmt.Errorf("unsupported language: %q", info.Lang)
+				}
+				cell, consumed, err := parser.Parse(b, blocks[i+1:])
 				if err != nil {
-					return nil, fmt.Errorf("parsing output: %w", err)
+					return nil, fmt.Errorf("parsing %q cell: %w", info.Lang, err)
 				}
-				cells = append(cells, BashCell{
-					fencedCode: renderStaticBlock(b),
-					indent:     b.indent,
-					output:     output,
-				})
+				cells = append(cells, cell)
 				i += 1 + consumed
 				continue
-			case info.Litdoc:
-				return nil, fmt.Errorf("unsupported language: %q", info.Lang)
 			default:
-				cells = append(cells, MakeStaticCellFromRaw(renderStaticBlock(b)))
+				cell, _, err := static.Parse(b, nil)
+				if err != nil {
+					return nil, fmt.Errorf("parsing static, non-litdoc cell: %w", err)
+				}
+				cells = append(cells, cell)
 			}
 		default:
-			cells = append(cells, MakeStaticCellFromRaw(renderStaticBlock(b)))
+			cell, _, err := static.Parse(b, nil)
+			if err != nil {
+				return nil, fmt.Errorf("parsing static cell: %w", err)
+			}
+			cells = append(cells, cell)
 		}
 		i++
 	}
 	return cells, nil
 }
 
-func renderStaticBlock(b Block) string {
-	if len(b.indent) == 0 {
-		return b.content
-	}
-
-	lines := strings.Split(b.content, "\n")
-	var rendered strings.Builder
-	renderedIndent := renderIndent(b.indent)
-	blankLineIndent := blankBlockQuoteLinePrefix(b.indent)
-	for i, line := range lines {
-		if i == len(lines)-1 && len(line) == 0 {
-			break
-		}
-		if i > 0 {
-			rendered.WriteByte('\n')
-		}
-		if len(line) == 0 {
-			rendered.WriteString(blankLineIndent)
-			continue
-		}
-		if i > 0 {
-			rendered.WriteString(renderedIndent)
-		} else if !b.continuation {
-			rendered.WriteString(b.indent)
-		}
-		rendered.WriteString(line)
-	}
-	if strings.HasSuffix(b.content, "\n") {
-		rendered.WriteByte('\n')
-	}
-	return rendered.String()
-}
-
-func blankBlockQuoteLinePrefix(indent string) string {
-	if idx := strings.LastIndex(indent, ">"); idx >= 0 {
-		return indent[:idx+1]
-	}
-	return ""
-}
-
-func renderIndent(indent string) string {
-	if idx := strings.LastIndex(indent, "> "); idx >= 0 {
-		prefixLen := idx + len("> ")
-		return indent[:prefixLen] + strings.Repeat(" ", len(indent)-prefixLen)
-	}
-	return strings.Repeat(" ", len(indent))
-}
-
-func leadingIndent(s string) string {
-	line := s
-	if i := strings.IndexByte(s, '\n'); i >= 0 {
-		line = s[:i]
-	}
-	i := 0
-	for i < len(line) && (line[i] == ' ' || line[i] == '\t') {
-		i++
-	}
-	return line[:i]
-}
-
 func Execute(cells []Cell) ([]Cell, error) {
 	var executedCells []Cell
 	for _, c := range cells {
diff --git a/internal/cell_test.go b/internal/cell_test.go
index 06fd766..b1feced 100644
--- a/internal/cell_test.go
+++ b/internal/cell_test.go
@@ -4,39 +4,15 @@ import (
 	"testing"
 
 	"litdoc/internal"
+	"litdoc/internal/bash"
+	"litdoc/internal/static"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 )
 
-func TestStaticCell(t *testing.T) {
-	t.Run("renders raw content", func(t *testing.T) {
-		// given
-		content := "hello"
-		cell := internal.MakeStaticCellFromRaw(content)
-
-		// when
-		gotContent, err := cell.Render()
-
-		// then
-		require.NoError(t, err)
-		assert.Equal(t, content, gotContent)
-	})
-
-	t.Run("executes to itself", func(t *testing.T) {
-		// given
-		cell := internal.MakeStaticCellFromRaw("hello")
-
-		// when
-		gotCell, err := cell.Execute()
-
-		// then
-		require.NoError(t, err)
-		assert.Equal(t, cell, gotCell)
-	})
-}
-
-func TestParseInfoString(t *testing.T) {
+func TestInfoStringFromBlock(t *testing.T) {
 	tests := []struct {
 		name  string
 		block internal.Block
@@ -177,135 +153,12 @@ func TestParseInfoString(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got := internal.ParseInfoString(tt.block)
+			got := internal.InfoStringFromBlock(tt.block)
 			assert.Equal(t, tt.want, got)
 		})
 	}
 }
 
-func TestBashCell(t *testing.T) {
-	t.Run("without output", func(t *testing.T) {
-		// given
-		code := joinLines(
-			"```bash",
-			"echo hello",
-			"```",
-			"",
-		)
-		cell := internal.MakeBashCellFromRaw(code, internal.Output{})
-
-		// when
-		gotContent, err := cell.Render()
-
-		// then
-		require.NoError(t, err)
-		assert.Equal(t, code, gotContent)
-	})
-
-	t.Run("with output", func(t *testing.T) {
-		// given
-		fencedCode := joinLines(
-			"```bash",
-			"echo hello",
-			"```",
-			"",
-		)
-		output := internal.MakeOutput("hello")
-		cell := internal.MakeBashCellFromRaw(fencedCode, output)
-
-		// when
-		gotContent, err := cell.Render()
-
-		// then
-		require.NoError(t, err)
-		assert.Equal(t, fencedCode+output.Render(""), gotContent)
-	})
-
-	t.Run("execute produces stub output", func(t *testing.T) {
-		// given
-		fencedCode := joinLines(
-			"```bash",
-			"echo hello",
-			"```",
-			"",
-		)
-		cell := internal.MakeBashCellFromRaw(fencedCode, internal.Output{})
-
-		// when
-		gotCell, err := cell.Execute()
-
-		// then
-		require.NoError(t, err)
-		rendered, err := gotCell.Render()
-		require.NoError(t, err)
-		assert.Equal(t, fencedCode+internal.MakeOutput("output").Render(""), rendered)
-	})
-}
-
-func TestExecute(t *testing.T) {
-	t.Run("happy path", func(t *testing.T) {
-		// given
-		result := NewMockCell(t)
-		cell := NewMockCell(t)
-		cell.EXPECT().Execute().Return(result, nil)
-		cells := []internal.Cell{cell}
-
-		// when
-		gotCells, err := internal.Execute(cells)
-
-		// then
-		require.NoError(t, err)
-		require.Len(t, gotCells, 1)
-		assert.Equal(t, result, gotCells[0])
-	})
-
-	t.Run("cell.Execute fails", func(t *testing.T) {
-		// given
-		cell := NewMockCell(t)
-		cell.EXPECT().Execute().Return(nil, assert.AnError)
-		cells := []internal.Cell{cell}
-
-		// when
-		_, err := internal.Execute(cells)
-
-		// then
-		require.ErrorContains(t, err, "executing cell")
-		require.ErrorIs(t, err, assert.AnError)
-	})
-}
-
-func TestCompose(t *testing.T) {
-	t.Run("happy path", func(t *testing.T) {
-		// given
-		cell1 := NewMockCell(t)
-		cell1.EXPECT().Render().Return("hello", nil)
-		cell2 := NewMockCell(t)
-		cell2.EXPECT().Render().Return(" world", nil)
-		cells := []internal.Cell{cell1, cell2}
-
-		// when
-		got, err := internal.Compose(cells)
-
-		// then
-		require.NoError(t, err)
-		assert.Equal(t, "hello world", got)
-	})
-
-	t.Run("cell.Render fails", func(t *testing.T) {
-		// given
-		cell := NewMockCell(t)
-		cell.EXPECT().Render().Return("", assert.AnError)
-		cells := []internal.Cell{cell}
-
-		// when
-		_, err := internal.Compose(cells)
-
-		// then
-		require.ErrorContains(t, err, "rendering cell")
-		require.ErrorIs(t, err, assert.AnError)
-	})
-}
-
 func TestClassify(t *testing.T) {
 	type wantCell struct {
 		kind     string
@@ -586,10 +439,15 @@ func TestClassify(t *testing.T) {
 		},
 	}
 
+	parsers := map[string]internal.CellParser{
+		"static": internal.CellParserFunc(static.ParseCell),
+		"bash":   internal.CellParserFunc(bash.ParseCell),
+	}
+
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			// when
-			cells, err := internal.Classify(tt.blocks)
+			cells, err := internal.Classify(tt.blocks, parsers)
 
 			// then
 			if tt.wantErrText != "" {
@@ -613,15 +471,150 @@ func TestClassify(t *testing.T) {
 			assert.Equal(t, wantComposed, gotComposed)
 		})
 	}
+
+	t.Run("no static parser", func(t *testing.T) {
+		// when
+		_, err := internal.Classify(nil, map[string]internal.CellParser{})
+
+		// then
+		require.ErrorContains(t, err, "no static parser provided")
+	})
+
+	t.Run("litdoc parser fails", func(t *testing.T) {
+		// given
+		blocks := []internal.Block{
+			code("", "```bash | litdoc\necho hello\n```\n", false),
+		}
+		failingParser := NewMockCellParser(t)
+		failingParser.EXPECT().
+			Parse(mock.Anything, mock.Anything).
+			Return(nil, 0, assert.AnError)
+
+		// when
+		_, err := internal.Classify(blocks, map[string]internal.CellParser{
+			"static": internal.CellParserFunc(static.ParseCell),
+			"bash":   failingParser,
+		})
+
+		// then
+		require.ErrorContains(t, err, `parsing "bash" cell`)
+		require.ErrorIs(t, err, assert.AnError)
+	})
+
+	t.Run("static parser fails", func(t *testing.T) {
+		t.Run("non-litdoc fenced code", func(t *testing.T) {
+			// given
+			blocks := []internal.Block{
+				code("", "```bash\necho hello\n```\n", false),
+			}
+			failingStatic := NewMockCellParser(t)
+			failingStatic.EXPECT().
+				Parse(mock.Anything, mock.Anything).
+				Return(nil, 0, assert.AnError)
+
+			// when
+			_, err := internal.Classify(blocks, map[string]internal.CellParser{
+				"static": failingStatic,
+				"bash":   internal.CellParserFunc(bash.ParseCell),
+			})
+
+			// then
+			require.ErrorContains(t, err, "parsing static, non-litdoc cell")
+			require.ErrorIs(t, err, assert.AnError)
+		})
+
+		t.Run("default block", func(t *testing.T) {
+			// given
+			blocks := []internal.Block{text("", "hello", false)}
+			failingStatic := NewMockCellParser(t)
+			failingStatic.EXPECT().
+				Parse(mock.Anything, mock.Anything).
+				Return(nil, 0, assert.AnError)
+
+			// when
+			_, err := internal.Classify(blocks, map[string]internal.CellParser{
+				"static": failingStatic,
+				"bash":   internal.CellParserFunc(bash.ParseCell),
+			})
+
+			// then
+			require.ErrorContains(t, err, "parsing static cell")
+			require.ErrorIs(t, err, assert.AnError)
+		})
+	})
 }
 
 func cellKind(cell internal.Cell) string {
 	switch cell.(type) {
-	case internal.StaticCell:
+	case static.Cell:
 		return "StaticCell"
-	case internal.BashCell:
+	case bash.Cell:
 		return "BashCell"
 	default:
 		return "unknown"
 	}
 }
+
+func TestExecute(t *testing.T) {
+	t.Run("happy path", func(t *testing.T) {
+		// given
+		result := NewMockCell(t)
+		cell := NewMockCell(t)
+		cell.EXPECT().Execute().Return(result, nil)
+		cells := []internal.Cell{cell}
+
+		// when
+		gotCells, err := internal.Execute(cells)
+
+		// then
+		require.NoError(t, err)
+		require.Len(t, gotCells, 1)
+		assert.Equal(t, result, gotCells[0])
+	})
+
+	t.Run("cell.Execute fails", func(t *testing.T) {
+		// given
+		cell := NewMockCell(t)
+		cell.EXPECT().Execute().Return(nil, assert.AnError)
+		cells := []internal.Cell{cell}
+
+		// when
+		_, err := internal.Execute(cells)
+
+		// then
+		require.ErrorContains(t, err, "executing cell")
+		require.ErrorIs(t, err, assert.AnError)
+	})
+}
+
+func TestCompose(t *testing.T) {
+	t.Run("happy path", func(t *testing.T) {
+		// given
+		cell1 := NewMockCell(t)
+		cell1.EXPECT().Render().Return("hello", nil)
+		cell2 := NewMockCell(t)
+		cell2.EXPECT().Render().Return(" world", nil)
+		cells := []internal.Cell{cell1, cell2}
+
+		// when
+		got, err := internal.Compose(cells)
+
+		// then
+		require.NoError(t, err)
+		assert.Equal(t, "hello world", got)
+	})
+
+	t.Run("cell.Render fails", func(t *testing.T) {
+		// given
+		cell := NewMockCell(t)
+		cell.EXPECT().Render().Return("", assert.AnError)
+		cells := []internal.Cell{cell}
+
+		// when
+		_, err := internal.Compose(cells)
+
+		// then
+		require.ErrorContains(t, err, "rendering cell")
+		require.ErrorIs(t, err, assert.AnError)
+	})
+}
diff --git a/internal/file.go b/internal/file.go
index 314001a..5dba9a5 100644
--- a/internal/file.go
+++ b/internal/file.go
@@ -5,7 +5,7 @@ import (
 	"os"
 )
 
-func ProcessFile(srcFilePath string) (string, error) {
+func ProcessFile(srcFilePath string, parsers map[string]CellParser) (string, error) {
 	srcContent, err := os.ReadFile(srcFilePath)
 	if err != nil {
 		return "", fmt.Errorf("reading source file: %w", err)
@@ -16,7 +16,7 @@ func ProcessFile(srcFilePath string) (string, error) {
 		return "", fmt.Errorf("parsing source file: %w", err)
 	}
 
-	cells, err := Classify(blocks)
+	cells, err := Classify(blocks, parsers)
 	if err != nil {
 		return "", fmt.Errorf("classifying blocks into cells: %w", err)
 	}
diff --git a/internal/file_test.go b/internal/file_test.go
index 8e63423..9b8bf4d 100644
--- a/internal/file_test.go
+++ b/internal/file_test.go
@@ -6,6 +6,8 @@ import (
 	"testing"
 
 	"litdoc/internal"
+	"litdoc/internal/bash"
+	"litdoc/internal/static"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -38,7 +40,11 @@ func TestProcessFile(t *testing.T) {
 			require.NoError(t, err)
 
 			// when
-			got, err := internal.ProcessFile(f.Name())
+			got, err := internal.ProcessFile(
+				f.Name(), map[string]internal.CellParser{
+					"static": internal.CellParserFunc(static.ParseCell),
+					"bash":   internal.CellParserFunc(bash.ParseCell),
+				})
 
 			// then
 			require.NoError(t, err)
@@ -46,25 +52,3 @@ func TestProcessFile(t *testing.T) {
 		})
 	}
 }
-
-func TestProcessFileNestedListIndent(t *testing.T) {
-	// given
-	input := "- Level 1\n\n  - Level 2\n\n    ```bash | litdoc\n    echo hello\n    ```\n"
-	f, err := os.CreateTemp(t.TempDir(), "*.md")
-	require.NoError(t, err)
-	_, err = f.Write([]byte(input))
-	require.NoError(t, err)
-	err = f.Close()
-	require.NoError(t, err)
-
-	// when
-	got, err := internal.ProcessFile(f.Name())
-
-	// then
-	require.NoError(t, err)
-	want := "- Level 1\n\n  - Level 2\n\n    ```bash | litdoc\n    echo hello\n    ```\n" +
-		"\n    " + internal.OutputBeginMarker + "\n" +
-		"    output\n" +
-		"    " + internal.OutputEndMarker + "\n"
-	assert.Equal(t, want, got)
-}
diff --git a/internal/output.go b/internal/output.go
index 3323f6d..967a2bc 100644
--- a/internal/output.go
+++ b/internal/output.go
@@ -11,28 +11,22 @@ const (
 )
 
 type Output struct {
-	content string
+	block Block
 }
 
-func MakeOutput(content string) Output {
-	return Output{content: content}
-}
-
-func (o Output) Render(linePrefix string) string {
-	if o.content == "" {
-		return ""
-	}
-
-	var buf strings.Builder
-	buf.WriteString(blankBlockQuoteLinePrefix(linePrefix))
-	buf.WriteByte('\n')
-	buf.WriteString(linePrefix + OutputBeginMarker + "\n")
-	for _, line := range strings.Split(strings.TrimSuffix(o.content, "\n"), "\n") {
-		buf.WriteString(linePrefix + line + "\n")
+func MakeOutput(content, indent string) Output {
+	if content == "" {
+		return Output{}
 	}
-	buf.WriteString(linePrefix + OutputEndMarker + "\n")
+	linePrefix := RenderIndent(indent)
+	assembled := "\n" + OutputBeginMarker + "\n" +
+		strings.TrimSuffix(content, "\n") + "\n" +
+		OutputEndMarker + "\n"
+	return Output{block: MakeBlockFromRaw(BlockKindText, assembled, linePrefix, false)}
+}
 
-	return buf.String()
+func (o Output) Render() string {
+	return o.block.Render()
 }
 
 func isOutputBegin(b Block) bool {
@@ -48,7 +42,7 @@ func isOutputEnd(b Block) bool {
 func OutputFromBlocks(litdoc Block, blocks []Block) (Output, int, error) {
 	// Output belongs to the preceding litdoc block, so its lines must use the
 	// indentation that rendering that block would use for following content.
-	outputIndent := renderIndent(litdoc.indent)
+	outputIndent := RenderIndent(litdoc.indent)
 	i := 0
 
 	var err error
@@ -98,7 +92,7 @@ func OutputFromBlocks(litdoc Block, blocks []Block) (Output, int, error) {
 			// Consume the newline or trailing whitespace after an inline end
 			// marker so callers resume at the next meaningful block.
 			i = skipOutputMarkerLineRemainder(blocks, i)
-			return MakeOutput(buf.String()), i, nil
+			return MakeOutput(buf.String(), litdoc.indent), i, nil
 		}
 		content, err := outputContent(blocks[i], outputIndent)
 		if err != nil {
diff --git a/internal/output_test.go b/internal/output_test.go
index d93e2f7..ce94650 100644
--- a/internal/output_test.go
+++ b/internal/output_test.go
@@ -14,10 +14,10 @@ func TestMakeOutput(t *testing.T) {
 	content := "hello"
 
 	// when
-	got := internal.MakeOutput(content)
+	got := internal.MakeOutput(content, "")
 
 	// then
-	assert.Contains(t, got.Render(""), content)
+	assert.Contains(t, got.Render(), content)
 }
 
 func TestOutput_RenderWithIndent(t *testing.T) {
@@ -26,10 +26,10 @@ func TestOutput_RenderWithIndent(t *testing.T) {
 	indent := "  "
 
 	// when
-	got := internal.MakeOutput(content)
+	got := internal.MakeOutput(content, indent)
 
 	// then
-	assert.Contains(t, got.Render(indent), indent+content)
+	assert.Contains(t, got.Render(), indent+content)
 }
 
 func TestOutput_Render(t *testing.T) {
@@ -106,10 +106,10 @@ func TestOutput_Render(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			// given
-			output := internal.MakeOutput(tt.content)
+			output := internal.MakeOutput(tt.content, tt.indent)
 
 			// when
-			got := output.Render(tt.indent)
+			got := output.Render()
 
 			// then
 			assert.Equal(t, tt.want, got)
@@ -119,7 +119,7 @@ func TestOutput_Render(t *testing.T) {
 
 func TestOutputFromBlocks(t *testing.T) {
 	wantOutput := func(indent, content string) string {
-		return internal.MakeOutput(content).Render(indent)
+		return internal.MakeOutput(content, indent).Render()
 	}
 
 	t.Run("output block is scanned in", func(t *testing.T) {
@@ -136,7 +136,7 @@ func TestOutputFromBlocks(t *testing.T) {
 
 		// then
 		require.NoError(t, err)
-		assert.Equal(t, wantOutput("", "hello"), output.Render(""))
+		assert.Equal(t, wantOutput("", "hello"), output.Render())
 		assert.Equal(t, 3, consumed)
 	})
 
@@ -155,7 +155,7 @@ func TestOutputFromBlocks(t *testing.T) {
 
 		// then
 		require.NoError(t, err)
-		assert.Equal(t, wantOutput("", "hello"), output.Render(""))
+		assert.Equal(t, wantOutput("", "hello"), output.Render())
 		assert.Equal(t, 4, consumed)
 	})
 
@@ -173,7 +173,7 @@ func TestOutputFromBlocks(t *testing.T) {
 
 		// then
 		require.NoError(t, err)
-		assert.Equal(t, wantOutput("    ", "hello\nworld"), output.Render("    "))
+		assert.Equal(t, wantOutput("    ", "hello\nworld"), output.Render())
 		assert.Equal(t, 3, consumed)
 	})
 
@@ -197,7 +197,7 @@ func TestOutputFromBlocks(t *testing.T) {
 
 		// then
 		require.NoError(t, err)
-		assert.Equal(t, wantOutput(" ", "output"), output.Render(" "))
+		assert.Equal(t, wantOutput(" ", "output"), output.Render())
 		assert.Equal(t, 8, consumed)
 	})
 
@@ -220,7 +220,7 @@ func TestOutputFromBlocks(t *testing.T) {
 
 		// then
 		require.NoError(t, err)
-		assert.Equal(t, wantOutput("  ", "hello\nworld"), output.Render("  "))
+		assert.Equal(t, wantOutput("  ", "hello\nworld"), output.Render())
 		assert.Equal(t, 8, consumed)
 	})
 
@@ -239,7 +239,7 @@ func TestOutputFromBlocks(t *testing.T) {
 
 		// then
 		require.NoError(t, err)
-		assert.Equal(t, wantOutput("  ", "hello"), output.Render("  "))
+		assert.Equal(t, wantOutput("  ", "hello"), output.Render())
 		assert.Equal(t, 4, consumed)
 	})
 
@@ -336,7 +336,7 @@ func TestOutputFromBlocks(t *testing.T) {
 
 		// then
 		require.NoError(t, err)
-		assert.Equal(t, "", output.Render(""))
+		assert.Equal(t, "", output.Render())
 		assert.Equal(t, 0, consumed)
 	})
 
@@ -349,7 +349,7 @@ func TestOutputFromBlocks(t *testing.T) {
 
 		// then
 		require.NoError(t, err)
-		assert.Equal(t, "", output.Render(""))
+		assert.Equal(t, "", output.Render())
 		assert.Equal(t, 0, consumed)
 	})
 
diff --git a/internal/static/cell.go b/internal/static/cell.go
new file mode 100644
index 0000000..c374e05
--- /dev/null
+++ b/internal/static/cell.go
@@ -0,0 +1,30 @@
+package static
+
+import "litdoc/internal"
+
+type Cell struct {
+	block internal.Block
+}
+
+func MakeCellFromRaw(content string) Cell {
+	return Cell{block: internal.MakeBlockFromRaw(internal.BlockKindText, content, "", false)}
+}
+
+func ParseCell(
+	block internal.Block,
+	_ []internal.Block,
+) (
+	internal.Cell,
+	int,
+	error,
+) {
+	return Cell{block: block}, 0, nil
+}
+
+func (c Cell) Execute() (internal.Cell, error) {
+	return c, nil
+}
+
+func (c Cell) Render() (string, error) {
+	return c.block.Render(), nil
+}
diff --git a/internal/static/cell_test.go b/internal/static/cell_test.go
new file mode 100644
index 0000000..e594e04
--- /dev/null
+++ b/internal/static/cell_test.go
@@ -0,0 +1,62 @@
+package static_test
+
+import (
+	"testing"
+
+	"litdoc/internal"
+	"litdoc/internal/static"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestMakeCellFromRaw(t *testing.T) {
+	// given
+	cell := static.MakeCellFromRaw("hello")
+
+	// when
+	got, err := cell.Render()
+
+	// then
+	require.NoError(t, err)
+	assert.Equal(t, "hello", got)
+}
+
+func TestParseCell(t *testing.T) {
+	// given
+	block := internal.MakeBlockFromRaw(internal.BlockKindText, "hello", "", false)
+
+	// when
+	cell, consumed, err := static.ParseCell(block, nil)
+
+	// then
+	require.NoError(t, err)
+	assert.Equal(t, 0, consumed)
+	rendered, err := cell.Render()
+	require.NoError(t, err)
+	assert.Equal(t, block.Render(), rendered)
+}
+
+func TestRender(t *testing.T) {
+	// given
+	cell := static.MakeCellFromRaw("hello")
+
+	// when
+	got, err := cell.Render()
+
+	// then
+	require.NoError(t, err)
+	assert.Equal(t, "hello", got)
+}
+
+func TestExecute(t *testing.T) {
+	// given
+	cell := static.MakeCellFromRaw("hello")
+
+	// when
+	got, err := cell.Execute()
+
+	// then
+	require.NoError(t, err)
+	assert.Equal(t, cell, got)
+}