@knpkv/confluence-to-markdown 0.2.0 → 0.4.2

package/test/schemas/ConfluencePreprocessor.test.ts

@@ -0,0 +1,180 @@
+import { describe, expect, it } from "@effect/vitest"
+import * as Effect from "effect/Effect"
+import * as Either from "effect/Either"
+import * as Schema from "effect/Schema"
+import { PreprocessedHtmlFromConfluence, PreprocessedHtmlSchema } from "../../src/schemas/preprocessing/index.js"
+
+describe("PreprocessedHtmlSchema", () => {
+  it("validates branded string", () => {
+    const result = Schema.decodeUnknownEither(PreprocessedHtmlSchema)("<p>Hello</p>")
+    expect(Either.isRight(result)).toBe(true)
+  })
+})
+
+describe("PreprocessedHtmlFromConfluence", () => {
+  describe("size limit", () => {
+    it.effect("rejects HTML exceeding size limit", () =>
+      Effect.gen(function*() {
+        const largeHtml = "x".repeat(1024 * 1024 + 1)
+        const result = yield* Effect.either(Schema.decode(PreprocessedHtmlFromConfluence)(largeHtml))
+        expect(Either.isLeft(result)).toBe(true)
+      }))
+
+    it.effect("accepts HTML within size limit", () =>
+      Effect.gen(function*() {
+        const html = "<p>Hello</p>"
+        const result = yield* Schema.decode(PreprocessedHtmlFromConfluence)(html)
+        expect(result).toContain("Hello")
+      }))
+  })
+
+  describe("structured macro expansion", () => {
+    it.effect("expands code macro", () =>
+      Effect.gen(function*() {
+        // Single line format that matches the regex pattern
+        const html =
+          `<ac:structured-macro ac:name="code"><ac:parameter ac:name="language">typescript</ac:parameter><ac:plain-text-body><![CDATA[const x = 1]]></ac:plain-text-body></ac:structured-macro>`
+        const result = yield* Schema.decode(PreprocessedHtmlFromConfluence)(html)
+        expect(result).toContain("data-macro=\"code\"")
+        expect(result).toContain("data-language=\"typescript\"")
+        expect(result).toContain("const x = 1")
+      }))
+
+    it.effect("expands info panel macro", () =>
+      Effect.gen(function*() {
+        const html = `<ac:structured-macro ac:name="info">
+          <ac:parameter ac:name="title">Note</ac:parameter>
+          <ac:rich-text-body><p>Content here</p></ac:rich-text-body>
+        </ac:structured-macro>`
+        const result = yield* Schema.decode(PreprocessedHtmlFromConfluence)(html)
+        expect(result).toContain("data-macro=\"info\"")
+        expect(result).toContain("data-title=\"Note\"")
+        expect(result).toContain("<p>Content here</p>")
+      }))
+
+    it.effect("expands expand macro", () =>
+      Effect.gen(function*() {
+        const html = `<ac:structured-macro ac:name="expand">
+          <ac:parameter ac:name="title">Click to expand</ac:parameter>
+          <ac:rich-text-body><p>Hidden content</p></ac:rich-text-body>
+        </ac:structured-macro>`
+        const result = yield* Schema.decode(PreprocessedHtmlFromConfluence)(html)
+        expect(result).toContain("<details")
+        expect(result).toContain("<summary>Click to expand</summary>")
+        expect(result).toContain("<p>Hidden content</p>")
+      }))
+
+    it.effect("expands TOC macro", () =>
+      Effect.gen(function*() {
+        const html = `<ac:structured-macro ac:name="toc">
+          <ac:parameter ac:name="minLevel">2</ac:parameter>
+          <ac:parameter ac:name="maxLevel">4</ac:parameter>
+        </ac:structured-macro>`
+        const result = yield* Schema.decode(PreprocessedHtmlFromConfluence)(html)
+        expect(result).toContain("data-macro=\"toc\"")
+        expect(result).toContain("data-min=\"2\"")
+        expect(result).toContain("data-max=\"4\"")
+      }))
+
+    it.effect("expands status macro", () =>
+      Effect.gen(function*() {
+        const html = `<ac:structured-macro ac:name="status">
+          <ac:parameter ac:name="colour">Green</ac:parameter>
+          <ac:parameter ac:name="title">Done</ac:parameter>
+        </ac:structured-macro>`
+        const result = yield* Schema.decode(PreprocessedHtmlFromConfluence)(html)
+        expect(result).toContain("data-macro=\"status\"")
+        expect(result).toContain("data-color=\"Green\"")
+        expect(result).toContain("Done")
+      }))
+  })
+
+  describe("task list preprocessing", () => {
+    it.effect("converts task list to ul", () =>
+      Effect.gen(function*() {
+        const html = `<ac:task-list>
+          <ac:task>
+            <ac:task-id>1</ac:task-id>
+            <ac:task-status>incomplete</ac:task-status>
+            <ac:task-body>Task one</ac:task-body>
+          </ac:task>
+        </ac:task-list>`
+        const result = yield* Schema.decode(PreprocessedHtmlFromConfluence)(html)
+        expect(result).toContain("<ul data-macro=\"task-list\">")
+        expect(result).toContain("data-task-id=\"1\"")
+        expect(result).toContain("data-task-status=\"incomplete\"")
+        expect(result).toContain("Task one")
+      }))
+  })
+
+  describe("image preprocessing", () => {
+    it.effect("converts attachment images", () =>
+      Effect.gen(function*() {
+        const html = `<ac:image ac:align="center" ac:width="250">
+          <ri:attachment ri:filename="test.png"/>
+        </ac:image>`
+        const result = yield* Schema.decode(PreprocessedHtmlFromConfluence)(html)
+        expect(result).toContain("data-attachment=\"test.png\"")
+        expect(result).toContain("data-align=\"center\"")
+        expect(result).toContain("data-width=\"250\"")
+      }))
+  })
+
+  describe("emoticon preprocessing", () => {
+    it.effect("converts emoticons", () =>
+      Effect.gen(function*() {
+        const html = `<ac:emoticon ac:emoji-shortname=":grinning:" ac:emoji-id="1f600" ac:emoji-fallback="😀"/>`
+        const result = yield* Schema.decode(PreprocessedHtmlFromConfluence)(html)
+        expect(result).toContain("data-emoji=\":grinning:\"")
+        expect(result).toContain("data-emoji-id=\"1f600\"")
+        expect(result).toContain("😀")
+      }))
+  })
+
+  describe("user mention preprocessing", () => {
+    it.effect("converts user mentions", () =>
+      Effect.gen(function*() {
+        const html = `<ac:link><ri:user ri:account-id="557058:abc123"/></ac:link>`
+        const result = yield* Schema.decode(PreprocessedHtmlFromConfluence)(html)
+        expect(result).toContain("data-user-mention=\"557058:abc123\"")
+      }))
+  })
+
+  describe("namespace stripping", () => {
+    it.effect("removes ac: and ri: tags", () =>
+      Effect.gen(function*() {
+        const html = `<p>Text<ac:parameter ac:name="foo">bar</ac:parameter></p>`
+        const result = yield* Schema.decode(PreprocessedHtmlFromConfluence)(html)
+        expect(result).not.toContain("ac:parameter")
+        expect(result).toContain("<p>Text</p>")
+      }))
+  })
+
+  describe("layout preprocessing", () => {
+    it.effect("adds layout markers", () =>
+      Effect.gen(function*() {
+        const html = `<ac:layout>
+          <ac:layout-section ac:type="two_equal">
+            <ac:layout-cell><p>Cell 1</p></ac:layout-cell>
+            <ac:layout-cell><p>Cell 2</p></ac:layout-cell>
+          </ac:layout-section>
+        </ac:layout>`
+        const result = yield* Schema.decode(PreprocessedHtmlFromConfluence)(html)
+        expect(result).toContain("<!--cf:layout-start-->")
+        expect(result).toContain("<!--cf:layout-end-->")
+        expect(result).toContain("<!--cf:section:0;")
+        expect(result).toContain("<p>Cell 1</p>")
+        expect(result).toContain("<p>Cell 2</p>")
+      }))
+  })
+
+  describe("encode (identity)", () => {
+    it.effect("encode returns same string", () =>
+      Effect.gen(function*() {
+        const html = "<p>Hello</p>"
+        const preprocessed = yield* Schema.decode(PreprocessedHtmlFromConfluence)(html)
+        const encoded = yield* Schema.encode(PreprocessedHtmlFromConfluence)(preprocessed)
+        expect(encoded).toBe(preprocessed)
+      }))
+  })
+})

package/test/schemas/ConversionSchema.test.ts

@@ -0,0 +1,159 @@
+import { describe, expect, it } from "@effect/vitest"
+import { Effect, Schema } from "effect"
+import { ConfluenceToMarkdown, DocumentFromHast, DocumentFromMdast } from "../../src/schemas/ConversionSchema.js"
+import { HastFromHtml } from "../../src/schemas/hast/index.js"
+import { MdastFromMarkdown } from "../../src/schemas/mdast/index.js"
+
+describe("ConversionSchema", () => {
+  describe("DocumentFromHast", () => {
+    it.effect("converts simple HAST root to Document", () =>
+      Effect.gen(function*() {
+        const html = "<h1>Title</h1><p>Hello world</p>"
+        const hast = yield* Schema.decode(HastFromHtml)(html)
+        const doc = yield* Schema.decode(DocumentFromHast)(hast)
+
+        expect(doc.version).toBe(1)
+        expect(doc.children.length).toBe(2)
+        expect(doc.children[0]?._tag).toBe("Heading")
+        expect(doc.children[1]?._tag).toBe("Paragraph")
+      }))
+
+    it.effect("handles code blocks", () =>
+      Effect.gen(function*() {
+        const html = "<pre><code>const x = 1</code></pre>"
+        const hast = yield* Schema.decode(HastFromHtml)(html)
+        const doc = yield* Schema.decode(DocumentFromHast)(hast)
+
+        expect(doc.children[0]?._tag).toBe("CodeBlock")
+      }))
+
+    it.effect("handles empty input", () =>
+      Effect.gen(function*() {
+        const html = ""
+        const hast = yield* Schema.decode(HastFromHtml)(html)
+        const doc = yield* Schema.decode(DocumentFromHast)(hast)
+
+        expect(doc.children.length).toBe(0)
+      }))
+  })
+
+  describe("DocumentFromMdast", () => {
+    it.effect("converts simple MDAST root to Document", () =>
+      Effect.gen(function*() {
+        const md = "# Title\n\nHello world"
+        const mdast = yield* Schema.decode(MdastFromMarkdown)(md)
+        const doc = yield* Schema.decode(DocumentFromMdast)(mdast)
+
+        expect(doc.version).toBe(1)
+        expect(doc.children.length).toBe(2)
+        expect(doc.children[0]?._tag).toBe("Heading")
+        expect(doc.children[1]?._tag).toBe("Paragraph")
+      }))
+
+    it.effect("handles code blocks", () =>
+      Effect.gen(function*() {
+        const md = "```ts\nconst x = 1\n```"
+        const mdast = yield* Schema.decode(MdastFromMarkdown)(md)
+        const doc = yield* Schema.decode(DocumentFromMdast)(mdast)
+
+        expect(doc.children[0]?._tag).toBe("CodeBlock")
+      }))
+
+    it.effect("handles lists", () =>
+      Effect.gen(function*() {
+        const md = "- Item 1\n- Item 2"
+        const mdast = yield* Schema.decode(MdastFromMarkdown)(md)
+        const doc = yield* Schema.decode(DocumentFromMdast)(mdast)
+
+        expect(doc.children[0]?._tag).toBe("List")
+      }))
+  })
+
+  describe("ConfluenceToMarkdown", () => {
+    it.effect("decodes simple Confluence HTML to Markdown", () =>
+      Effect.gen(function*() {
+        const html = "<h1>Title</h1><p>Hello world</p>"
+        const md = yield* Schema.decode(ConfluenceToMarkdown)(html)
+
+        expect(md).toContain("# Title")
+        expect(md).toContain("Hello world")
+      }))
+
+    it.effect("decodes code blocks", () =>
+      Effect.gen(function*() {
+        const html = "<pre><code class=\"language-ts\">const x = 1</code></pre>"
+        const md = yield* Schema.decode(ConfluenceToMarkdown)(html)
+
+        expect(md).toContain("```")
+        expect(md).toContain("const x = 1")
+      }))
+
+    it.effect("decodes inline formatting", () =>
+      Effect.gen(function*() {
+        const html = "<p><strong>bold</strong> and <em>italic</em></p>"
+        const md = yield* Schema.decode(ConfluenceToMarkdown)(html)
+
+        expect(md).toContain("**bold**")
+        expect(md).toContain("_italic_")
+      }))
+
+    it.effect("encodes Markdown to basic HTML (structure only)", () =>
+      Effect.gen(function*() {
+        const md = "# Title\n\nHello world"
+        const html = yield* Schema.encode(ConfluenceToMarkdown)(md)
+
+        // Note: basic HTML encoding only preserves structure, not content
+        expect(html).toContain("<h1>")
+        expect(html).toContain("<p>")
+      }))
+
+    it.effect("handles links", () =>
+      Effect.gen(function*() {
+        const html = "<p><a href=\"https://example.com\">Click here</a></p>"
+        const md = yield* Schema.decode(ConfluenceToMarkdown)(html)
+
+        expect(md).toContain("[Click here](https://example.com)")
+      }))
+
+    it.effect("handles horizontal rules", () =>
+      Effect.gen(function*() {
+        const html = "<hr />"
+        const md = yield* Schema.decode(ConfluenceToMarkdown)(html)
+
+        expect(md).toContain("---")
+      }))
+
+    it.effect("handles lists", () =>
+      Effect.gen(function*() {
+        const html = "<ul><li><p>Item 1</p></li><li><p>Item 2</p></li></ul>"
+        const md = yield* Schema.decode(ConfluenceToMarkdown)(html)
+
+        expect(md).toContain("- ")
+        expect(md).toContain("Item 1")
+        expect(md).toContain("Item 2")
+      }))
+
+    it.effect("handles tables", () =>
+      Effect.gen(function*() {
+        const html = "<table><tr><th>A</th></tr><tr><td>1</td></tr></table>"
+        const md = yield* Schema.decode(ConfluenceToMarkdown)(html)
+
+        expect(md).toContain("|")
+        expect(md).toContain("---")
+      }))
+  })
+
+  describe("roundtrip", () => {
+    it.effect("HTML -> Markdown -> HTML preserves structure", () =>
+      Effect.gen(function*() {
+        // Start from HTML since that direction is fully supported
+        const originalHtml = "<h1>Hello</h1><p>World</p>"
+        const md = yield* Schema.decode(ConfluenceToMarkdown)(originalHtml)
+        const html = yield* Schema.encode(ConfluenceToMarkdown)(md)
+
+        // Structure is preserved
+        expect(html).toContain("<h1>")
+        expect(html).toContain("<p>")
+      }))
+  })
+})

package/test/schemas/HastSchema.test.ts

@@ -0,0 +1,138 @@
+import { describe, expect, it } from "@effect/vitest"
+import * as Effect from "effect/Effect"
+import * as Either from "effect/Either"
+import * as Schema from "effect/Schema"
+import {
+  getTextContent,
+  HastFromHtml,
+  HastNodeSchema,
+  HastRootSchema,
+  isHastElement,
+  isHastText,
+  makeHastElement,
+  makeHastRoot,
+  makeHastText
+} from "../../src/schemas/hast/index.js"
+
+describe("HastSchema", () => {
+  describe("constructors", () => {
+    it("creates text node", () => {
+      const node = makeHastText("hello")
+      expect(node._tag).toBe("text")
+      expect(node.value).toBe("hello")
+    })
+
+    it("creates element node", () => {
+      const node = makeHastElement("div", { class: "test" }, [makeHastText("child")])
+      expect(node._tag).toBe("element")
+      expect(node.tagName).toBe("div")
+      expect(node.properties.class).toBe("test")
+      expect(node.children).toHaveLength(1)
+    })
+
+    it("creates root node", () => {
+      const root = makeHastRoot([makeHastElement("p", {}, [makeHastText("text")])])
+      expect(root._tag).toBe("root")
+      expect(root.children).toHaveLength(1)
+    })
+  })
+
+  describe("type guards", () => {
+    it("isHastText returns true for text node", () => {
+      expect(isHastText(makeHastText("hello"))).toBe(true)
+      expect(isHastText(makeHastElement("div"))).toBe(false)
+    })
+
+    it("isHastElement returns true for element node", () => {
+      expect(isHastElement(makeHastElement("div"))).toBe(true)
+      expect(isHastElement(makeHastText("hello"))).toBe(false)
+    })
+  })
+
+  describe("getTextContent", () => {
+    it("extracts text from text node", () => {
+      expect(getTextContent(makeHastText("hello"))).toBe("hello")
+    })
+
+    it("extracts text from nested elements", () => {
+      const el = makeHastElement("div", {}, [
+        makeHastText("hello "),
+        makeHastElement("strong", {}, [makeHastText("world")])
+      ])
+      expect(getTextContent(el)).toBe("hello world")
+    })
+  })
+
+  describe("HastNodeSchema", () => {
+    it("validates text node", () => {
+      const result = Schema.decodeUnknownEither(HastNodeSchema)(makeHastText("test"))
+      expect(Either.isRight(result)).toBe(true)
+    })
+
+    it("validates element node", () => {
+      const result = Schema.decodeUnknownEither(HastNodeSchema)(makeHastElement("p"))
+      expect(Either.isRight(result)).toBe(true)
+    })
+  })
+
+  describe("HastRootSchema", () => {
+    it("validates root node", () => {
+      const root = makeHastRoot([makeHastElement("p", {}, [makeHastText("text")])])
+      const result = Schema.decodeUnknownEither(HastRootSchema)(root)
+      expect(Either.isRight(result)).toBe(true)
+    })
+  })
+})
+
+describe("HastFromHtml", () => {
+  describe("decode (HTML -> HAST)", () => {
+    it.effect("parses simple HTML", () =>
+      Effect.gen(function*() {
+        const hast = yield* Schema.decode(HastFromHtml)("<p>Hello</p>")
+        expect(hast._tag).toBe("root")
+        expect(hast.children).toHaveLength(1)
+        const p = hast.children[0]
+        expect(isHastElement(p) && p.tagName).toBe("p")
+      }))
+
+    it.effect("parses nested HTML", () =>
+      Effect.gen(function*() {
+        const hast = yield* Schema.decode(HastFromHtml)("<div><p>Text</p></div>")
+        expect(hast.children).toHaveLength(1)
+        const div = hast.children[0]
+        if (isHastElement(div)) {
+          expect(div.tagName).toBe("div")
+          expect(div.children).toHaveLength(1)
+        }
+      }))
+
+    it.effect("parses HTML with attributes", () =>
+      Effect.gen(function*() {
+        const hast = yield* Schema.decode(HastFromHtml)("<a href=\"https://example.com\">Link</a>")
+        const a = hast.children[0]
+        if (isHastElement(a)) {
+          expect(a.properties.href).toBe("https://example.com")
+        }
+      }))
+  })
+
+  describe("encode (HAST -> HTML)", () => {
+    it.effect("stringifies HAST to HTML", () =>
+      Effect.gen(function*() {
+        const hast = makeHastRoot([
+          makeHastElement("p", {}, [makeHastText("Hello")])
+        ])
+        const html = yield* Schema.encode(HastFromHtml)(hast)
+        expect(html).toContain("<p>")
+        expect(html).toContain("Hello")
+      }))
+
+    it.effect("roundtrips HTML", () =>
+      Effect.gen(function*() {
+        const original = "<p>Test paragraph</p>"
+        const hast = yield* Schema.decode(HastFromHtml)(original)
+        const html = yield* Schema.encode(HastFromHtml)(hast)
+        expect(html.replace(/\s/g, "")).toBe(original.replace(/\s/g, ""))
+      }))
+  })
+})

package/test/schemas/MdastSchema.test.ts

@@ -0,0 +1,145 @@
+import { describe, expect, it } from "@effect/vitest"
+import * as Effect from "effect/Effect"
+import * as Either from "effect/Either"
+import * as Schema from "effect/Schema"
+import {
+  isMdastHeading,
+  isMdastParagraph,
+  isMdastText,
+  makeMdastHeading,
+  makeMdastParagraph,
+  makeMdastRoot,
+  makeMdastText,
+  MdastFromMarkdown,
+  MdastRootSchema,
+  MdastTextSchema
+} from "../../src/schemas/mdast/index.js"
+
+describe("MdastSchema", () => {
+  describe("constructors", () => {
+    it("creates text node", () => {
+      const node = makeMdastText("hello")
+      expect(node.type).toBe("text")
+      expect(node.value).toBe("hello")
+    })
+
+    it("creates heading node", () => {
+      const node = makeMdastHeading(2, [makeMdastText("Title")])
+      expect(node.type).toBe("heading")
+      expect(node.depth).toBe(2)
+      expect(node.children).toHaveLength(1)
+    })
+
+    it("creates paragraph node", () => {
+      const node = makeMdastParagraph([makeMdastText("content")])
+      expect(node.type).toBe("paragraph")
+      expect(node.children).toHaveLength(1)
+    })
+
+    it("creates root node", () => {
+      const root = makeMdastRoot([makeMdastParagraph([makeMdastText("text")])])
+      expect(root.type).toBe("root")
+      expect(root.children).toHaveLength(1)
+    })
+  })
+
+  describe("type guards", () => {
+    it("isMdastText returns true for text node", () => {
+      expect(isMdastText(makeMdastText("hello"))).toBe(true)
+      expect(isMdastText(makeMdastHeading(1, []))).toBe(false)
+    })
+
+    it("isMdastHeading returns true for heading node", () => {
+      expect(isMdastHeading(makeMdastHeading(1, []))).toBe(true)
+      expect(isMdastHeading(makeMdastText("hello"))).toBe(false)
+    })
+
+    it("isMdastParagraph returns true for paragraph node", () => {
+      expect(isMdastParagraph(makeMdastParagraph([]))).toBe(true)
+      expect(isMdastParagraph(makeMdastText("hello"))).toBe(false)
+    })
+  })
+
+  describe("MdastTextSchema", () => {
+    it("validates text node", () => {
+      const result = Schema.decodeUnknownEither(MdastTextSchema)(makeMdastText("test"))
+      expect(Either.isRight(result)).toBe(true)
+    })
+
+    it("rejects invalid type", () => {
+      const result = Schema.decodeUnknownEither(MdastTextSchema)({ type: "other", value: "x" })
+      expect(Either.isLeft(result)).toBe(true)
+    })
+  })
+
+  describe("MdastRootSchema", () => {
+    it("validates root node", () => {
+      const root = makeMdastRoot([makeMdastParagraph([makeMdastText("text")])])
+      const result = Schema.decodeUnknownEither(MdastRootSchema)(root)
+      expect(Either.isRight(result)).toBe(true)
+    })
+  })
+})
+
+describe("MdastFromMarkdown", () => {
+  describe("decode (Markdown -> MDAST)", () => {
+    it.effect("parses heading", () =>
+      Effect.gen(function*() {
+        const mdast = yield* Schema.decode(MdastFromMarkdown)("# Hello")
+        expect(mdast.type).toBe("root")
+        expect(mdast.children).toHaveLength(1)
+        const heading = mdast.children[0]
+        expect(heading.type).toBe("heading")
+      }))
+
+    it.effect("parses paragraph", () =>
+      Effect.gen(function*() {
+        const mdast = yield* Schema.decode(MdastFromMarkdown)("Hello world")
+        expect(mdast.children).toHaveLength(1)
+        expect(mdast.children[0].type).toBe("paragraph")
+      }))
+
+    it.effect("parses code block", () =>
+      Effect.gen(function*() {
+        const mdast = yield* Schema.decode(MdastFromMarkdown)("```ts\nconst x = 1\n```")
+        expect(mdast.children).toHaveLength(1)
+        const code = mdast.children[0]
+        expect(code.type).toBe("code")
+      }))
+
+    it.effect("parses list", () =>
+      Effect.gen(function*() {
+        const mdast = yield* Schema.decode(MdastFromMarkdown)("- item 1\n- item 2")
+        expect(mdast.children).toHaveLength(1)
+        expect(mdast.children[0].type).toBe("list")
+      }))
+  })
+
+  describe("encode (MDAST -> Markdown)", () => {
+    it.effect("stringifies heading", () =>
+      Effect.gen(function*() {
+        const mdast = makeMdastRoot([
+          makeMdastHeading(1, [makeMdastText("Title")])
+        ])
+        const md = yield* Schema.encode(MdastFromMarkdown)(mdast)
+        expect(md.trim()).toBe("# Title")
+      }))
+
+    it.effect("stringifies paragraph", () =>
+      Effect.gen(function*() {
+        const mdast = makeMdastRoot([
+          makeMdastParagraph([makeMdastText("Hello world")])
+        ])
+        const md = yield* Schema.encode(MdastFromMarkdown)(mdast)
+        expect(md.trim()).toBe("Hello world")
+      }))
+
+    it.effect("roundtrips markdown", () =>
+      Effect.gen(function*() {
+        const original = "# Title\n\nParagraph text."
+        const mdast = yield* Schema.decode(MdastFromMarkdown)(original)
+        const md = yield* Schema.encode(MdastFromMarkdown)(mdast)
+        expect(md.trim()).toBe(original)
+      }))
+  })
+})