@knpkv/confluence-to-markdown 0.5.0 → 0.7.0

package/test/parsers/ConfluenceParser.test.ts

@@ -1,452 +0,0 @@
-import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem"
-import * as NodePath from "@effect/platform-node/NodePath"
-import * as FileSystem from "@effect/platform/FileSystem"
-import * as Path from "@effect/platform/Path"
-import { describe, expect, it } from "@effect/vitest"
-import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
-import { parseConfluenceHtml } from "../../src/parsers/ConfluenceParser.js"
-import { parseMarkdown } from "../../src/parsers/MarkdownParser.js"
-import { serializeToConfluence } from "../../src/serializers/ConfluenceSerializer.js"
-import { serializeToMarkdown } from "../../src/serializers/MarkdownSerializer.js"
-
-const PlatformLive = Layer.mergeAll(NodeFileSystem.layer, NodePath.layer)
-
-const getFixturesDir = Effect.gen(function*() {
-  const path = yield* Path.Path
-  return path.join(import.meta.dirname, "../fixtures")
-})
-
-const readFixture = (filename: string) =>
-  Effect.gen(function*() {
-    const fs = yield* FileSystem.FileSystem
-    const path = yield* Path.Path
-    const fixturesDir = yield* getFixturesDir
-    return yield* fs.readFileString(path.join(fixturesDir, filename))
-  }).pipe(Effect.provide(PlatformLive))
-
-describe("ConfluenceParser", () => {
-  describe("parseConfluenceHtml", () => {
-    it.effect("parses basic headings", () =>
-      Effect.gen(function*() {
-        const html = "<h1>Title</h1><h2>Subtitle</h2>"
-        const doc = yield* parseConfluenceHtml(html)
-        expect(doc.children.length).toBe(2)
-        expect(doc.children[0]?._tag).toBe("Heading")
-      }))
-
-    it.effect("parses paragraphs", () =>
-      Effect.gen(function*() {
-        const html = "<p>Hello world</p>"
-        const doc = yield* parseConfluenceHtml(html)
-        expect(doc.children.length).toBe(1)
-        expect(doc.children[0]?._tag).toBe("Paragraph")
-      }))
-
-    it.effect("parses task lists", () =>
-      Effect.gen(function*() {
-        const html = `<ac:task-list ac:task-list-id="test">
-          <ac:task>
-            <ac:task-id>1</ac:task-id>
-            <ac:task-uuid>uuid-1</ac:task-uuid>
-            <ac:task-status>incomplete</ac:task-status>
-            <ac:task-body><span>Task 1</span></ac:task-body>
-          </ac:task>
-          <ac:task>
-            <ac:task-id>2</ac:task-id>
-            <ac:task-uuid>uuid-2</ac:task-uuid>
-            <ac:task-status>complete</ac:task-status>
-            <ac:task-body><span>Task 2</span></ac:task-body>
-          </ac:task>
-        </ac:task-list>`
-        const doc = yield* parseConfluenceHtml(html)
-        expect(doc.children.length).toBe(1)
-        const taskList = doc.children[0]
-        expect(taskList?._tag).toBe("TaskList")
-        if (taskList?._tag === "TaskList") {
-          expect(taskList.children.length).toBe(2)
-          expect(taskList.children[0]?.status).toBe("incomplete")
-          expect(taskList.children[0]?.body[0]?._tag).toBe("Text")
-          expect(taskList.children[1]?.status).toBe("complete")
-        }
-      }))
-
-    it.effect("parses images with attachments", () =>
-      Effect.gen(function*() {
-        const html = `<ac:image ac:align="center" ac:width="250" ac:alt="logo">
-          <ri:attachment ri:filename="logo.svg"/>
-        </ac:image>`
-        const doc = yield* parseConfluenceHtml(html)
-        expect(doc.children.length).toBe(1)
-        const image = doc.children[0]
-        expect(image?._tag).toBe("Image")
-        if (image?._tag === "Image") {
-          expect(image.attachment?.filename).toBe("logo.svg")
-          expect(image.align).toBe("center")
-          expect(image.width).toBe(250)
-          expect(image.alt).toBe("logo")
-        }
-      }))
-
-    it.effect("parses emoticons", () =>
-      Effect.gen(function*() {
-        const html =
-          `<p><ac:emoticon ac:emoji-shortname=":grinning:" ac:emoji-id="1f600" ac:emoji-fallback="smile"/></p>`
-        const doc = yield* parseConfluenceHtml(html)
-        expect(doc.children.length).toBe(1)
-        const para = doc.children[0]
-        expect(para?._tag).toBe("Paragraph")
-        if (para?._tag === "Paragraph") {
-          const emoticon = para.children[0]
-          expect(emoticon?._tag).toBe("Emoticon")
-          if (emoticon?._tag === "Emoticon") {
-            expect(emoticon.shortname).toBe(":grinning:")
-            expect(emoticon.emojiId).toBe("1f600")
-            expect(emoticon.fallback).toBe("smile")
-          }
-        }
-      }))
-
-    it.effect("parses user mentions", () =>
-      Effect.gen(function*() {
-        const html = `<p><ac:link><ri:user ri:account-id="557058:abc123"/></ac:link></p>`
-        const doc = yield* parseConfluenceHtml(html)
-        expect(doc.children.length).toBe(1)
-        const para = doc.children[0]
-        if (para?._tag === "Paragraph") {
-          const mention = para.children[0]
-          expect(mention?._tag).toBe("UserMention")
-          if (mention?._tag === "UserMention") {
-            expect(mention.accountId).toBe("557058:abc123")
-          }
-        }
-      }))
-
-    it.effect("parses colored text", () =>
-      Effect.gen(function*() {
-        const html = `<p><span style="color: rgb(255,0,0);">Red text</span></p>`
-        const doc = yield* parseConfluenceHtml(html)
-        const para = doc.children[0]
-        if (para?._tag === "Paragraph") {
-          const colored = para.children[0]
-          expect(colored?._tag).toBe("ColoredText")
-          if (colored?._tag === "ColoredText") {
-            expect(colored.color).toBe("rgb(255,0,0)")
-          }
-        }
-      }))
-
-    it.effect("parses highlighted text", () =>
-      Effect.gen(function*() {
-        const html = `<p><span style="background-color: rgb(255,255,0);">Highlighted</span></p>`
-        const doc = yield* parseConfluenceHtml(html)
-        const para = doc.children[0]
-        if (para?._tag === "Paragraph") {
-          const highlight = para.children[0]
-          expect(highlight?._tag).toBe("Highlight")
-          if (highlight?._tag === "Highlight") {
-            expect(highlight.backgroundColor).toBe("rgb(255,255,0)")
-          }
-        }
-      }))
-
-    it.effect("parses paragraph with alignment", () =>
-      Effect.gen(function*() {
-        const html = `<p style="text-align: center;">Centered</p>`
-        const doc = yield* parseConfluenceHtml(html)
-        const para = doc.children[0]
-        expect(para?._tag).toBe("Paragraph")
-        if (para?._tag === "Paragraph") {
-          expect(para.alignment).toBe("center")
-        }
-      }))
-
-    it.effect("parses paragraph with indent", () =>
-      Effect.gen(function*() {
-        const html = `<p style="margin-left: 30px;">Indented</p>`
-        const doc = yield* parseConfluenceHtml(html)
-        const para = doc.children[0]
-        expect(para?._tag === "Paragraph").toBe(true)
-        if (para?._tag === "Paragraph") {
-          expect(para.indent).toBe(30)
-        }
-      }))
-
-    it.effect("parses underline, subscript, superscript", () =>
-      Effect.gen(function*() {
-        const html = `<p><u>Underline</u> <sub>Sub</sub> <sup>Sup</sup></p>`
-        const doc = yield* parseConfluenceHtml(html)
-        const para = doc.children[0]
-        if (para?._tag === "Paragraph") {
-          const [u, , sub, , sup] = para.children
-          expect(u?._tag).toBe("Underline")
-          expect(sub?._tag).toBe("Subscript")
-          expect(sup?._tag).toBe("Superscript")
-        }
-      }))
-
-    it.effect("parses tables with proper cell content", () =>
-      Effect.gen(function*() {
-        const html = `<table>
-          <thead><tr><th><p>Header 1</p></th><th><p>Header 2</p></th></tr></thead>
-          <tbody><tr><td><p>Cell 1</p></td><td><p>Cell 2</p></td></tr></tbody>
-        </table>`
-        const doc = yield* parseConfluenceHtml(html)
-        const table = doc.children[0]
-        expect(table?._tag).toBe("Table")
-        if (table?._tag === "Table") {
-          // Header should have 2 cells
-          expect(table.header?.cells.length).toBe(2)
-          // First header cell should have text "Header 1"
-          const headerCell = table.header?.cells[0]
-          if (headerCell) {
-            expect(headerCell.children[0]?._tag).toBe("Text")
-            if (headerCell.children[0]?._tag === "Text") {
-              expect(headerCell.children[0].value).toBe("Header 1")
-            }
-          }
-          // Body rows
-          expect(table.rows.length).toBe(1)
-          const bodyCell = table.rows[0]?.cells[0]
-          if (bodyCell) {
-            expect(bodyCell.children[0]?._tag).toBe("Text")
-            if (bodyCell.children[0]?._tag === "Text") {
-              expect(bodyCell.children[0].value).toBe("Cell 1")
-            }
-          }
-        }
-      }))
-
-    it.effect("parses nested unordered list as nested List AST", () =>
-      Effect.gen(function*() {
-        const html = `<ul><li><p>Outer</p><ul><li><p>Inner A</p></li><li><p>Inner B</p></li></ul></li></ul>`
-        const doc = yield* parseConfluenceHtml(html)
-        const outerList = doc.children[0]
-        expect(outerList?._tag).toBe("List")
-        if (outerList?._tag === "List") {
-          expect(outerList.children.length).toBe(1)
-          const outerItem = outerList.children[0]
-          expect(outerItem?.children.length).toBe(2)
-          // First child is the "Outer" paragraph
-          expect(outerItem?.children[0]?._tag).toBe("Paragraph")
-          // Second child is the nested List (no longer UnsupportedBlock)
-          const nested = outerItem?.children[1]
-          expect(nested?._tag).toBe("List")
-          if (nested?._tag === "List") {
-            expect(nested.children.length).toBe(2)
-            const firstInner = nested.children[0]
-            expect(firstInner?.children[0]?._tag).toBe("Paragraph")
-          }
-        }
-      }))
-
-    it.effect("serializes nested list as indented markdown bullets", () =>
-      Effect.gen(function*() {
-        const html = `<ul><li><p>Outer</p><ul><li><p>Inner A</p></li><li><p>Inner B</p></li></ul></li></ul>`
-        const doc = yield* parseConfluenceHtml(html)
-        const md = yield* serializeToMarkdown(doc, { includeRawSource: false })
-        expect(md).toContain("- Outer")
-        expect(md).toContain("   - Inner A")
-        expect(md).toContain("   - Inner B")
-        expect(md).not.toContain("<ul")
-        expect(md).not.toContain("local-id")
-      }))
-
-    it.effect("unwraps table cell with leading empty <p> placeholder", () =>
-      Effect.gen(function*() {
-        // Confluence editor frequently emits an empty <p/> alongside the real content.
-        const html = `<table><tbody>
-          <tr><td><p local-id="empty"/><p><strong>Must</strong></p></td><td><p>Text</p></td></tr>
-        </tbody></table>`
-        const doc = yield* parseConfluenceHtml(html)
-        const table = doc.children[0]
-        expect(table?._tag).toBe("Table")
-        if (table?._tag === "Table") {
-          const cell = table.rows[0]?.cells[0]
-          expect(cell?.children.length).toBe(1)
-          const strong = cell?.children[0]
-          expect(strong?._tag).toBe("Strong")
-        }
-      }))
-  })
-
-  describe("integration test fixture", () => {
-    it.effect("parses and serializes integration test fixture", () =>
-      Effect.gen(function*() {
-        const html = yield* readFixture("integration-test.html.fixture")
-        const doc = yield* parseConfluenceHtml(html)
-
-        // Doc should have children - layout markers plus actual content
-        expect(doc.children.length).toBeGreaterThan(0)
-
-        // Serialize to markdown - content should be readable (not URL-encoded)
-        const markdown = yield* serializeToMarkdown(doc)
-        // Layout markers should be present as comments
-        expect(markdown).toContain("cf:layout-start")
-        expect(markdown).toContain("cf:section:")
-        // Content should be readable markdown, not URL-encoded
-        expect(markdown).toContain("# Heading 1")
-        expect(markdown).toContain("## Heading 2")
-
-        // Serialize to confluence - should reconstruct layout structure
-        const confluenceHtml = yield* serializeToConfluence(doc)
-        expect(confluenceHtml).toContain("<ac:layout>")
-        expect(confluenceHtml).toContain("<ac:layout-section")
-        expect(confluenceHtml).toContain("<ac:layout-cell>")
-        // Note: ac:task-list may have attributes, so search for the tag name
-        expect(confluenceHtml).toContain("ac:task-list")
-        expect(confluenceHtml).toContain("<ac:task-status>incomplete</ac:task-status>")
-        expect(confluenceHtml).toContain("<ac:task-status>complete</ac:task-status>")
-        expect(confluenceHtml).toContain("ac:emoticon")
-        expect(confluenceHtml).toContain("ri:account-id")
-      }))
-  })
-
-  describe("roundtrip HTML -> MD -> HTML", () => {
-    it.effect("roundtrips integration-test.html with 1-to-1 preservation", () =>
-      Effect.gen(function*() {
-        const originalHtml = yield* readFixture("integration-test.html.fixture")
-        const doc1 = yield* parseConfluenceHtml(originalHtml)
-        const md = yield* serializeToMarkdown(doc1)
-        const doc2 = yield* parseMarkdown(md)
-        const finalHtml = yield* serializeToConfluence(doc2)
-
-        // 1-to-1 roundtrip: finalHtml should EXACTLY match originalHtml
-        expect(finalHtml).toBe(originalHtml)
-      }))
-
-    it.effect("renders UserMention as visible markdown link and roundtrips", () =>
-      Effect.gen(function*() {
-        const originalHtml = `<p><ac:link><ri:user ri:account-id="557058:abc123"/></ac:link></p>`
-        const doc1 = yield* parseConfluenceHtml(originalHtml)
-        const md = yield* serializeToMarkdown(doc1, { includeRawSource: false })
-        expect(md).toContain("[@557058:abc123](#cf-user:")
-        expect(md).not.toContain("<!--cf:user:")
-        const doc2 = yield* parseMarkdown(md)
-        const finalHtml = yield* serializeToConfluence(doc2)
-        expect(finalHtml).toContain("ri:account-id=\"557058:abc123\"")
-      }))
-
-    it.effect("renders inline StatusMacro as visible link and roundtrips", () =>
-      Effect.gen(function*() {
-        const originalHtml =
-          `<p><ac:structured-macro ac:name="status"><ac:parameter ac:name="title">READY</ac:parameter><ac:parameter ac:name="colour">Blue</ac:parameter></ac:structured-macro></p>`
-        const doc1 = yield* parseConfluenceHtml(originalHtml)
-        const md = yield* serializeToMarkdown(doc1, { includeRawSource: false })
-        expect(md).toContain("[READY](#cf-status:Blue)")
-        expect(md).not.toContain("<!--cf:status:")
-        const doc2 = yield* parseMarkdown(md)
-        const finalHtml = yield* serializeToConfluence(doc2)
-        expect(finalHtml).toContain("ac:name=\"status\"")
-        expect(finalHtml).toContain("READY")
-        expect(finalHtml).toContain("Blue")
-      }))
-
-    it.effect("decodes multi-word status title for visible link text", () =>
-      Effect.gen(function*() {
-        const originalHtml =
-          `<p><ac:structured-macro ac:name="status"><ac:parameter ac:name="title">In Progress</ac:parameter><ac:parameter ac:name="colour">Yellow</ac:parameter></ac:structured-macro></p>`
-        const doc1 = yield* parseConfluenceHtml(originalHtml)
-        const md = yield* serializeToMarkdown(doc1, { includeRawSource: false })
-        // Display text is decoded; URL fragment carries the encoded value.
-        expect(md).toContain("[In Progress](#cf-status:Yellow)")
-        expect(md).not.toContain("In%20Progress")
-        const finalHtml = yield* serializeToConfluence(yield* parseMarkdown(md))
-        expect(finalHtml).toContain("In Progress")
-      }))
-
-    it.effect("preserves real <thead> with empty header cells (no synthetic-header drop)", () =>
-      Effect.gen(function*() {
-        // A legitimate empty <thead> in the source must round-trip intact —
-        // it must NOT be confused with the synthetic empty header the
-        // serializer emits for <tbody>-only tables.
-        const originalHtml =
-          `<table><thead><tr><th></th><th></th></tr></thead><tbody><tr><td>a</td><td>b</td></tr></tbody></table>`
-        const doc1 = yield* parseConfluenceHtml(originalHtml)
-        const md = yield* serializeToMarkdown(doc1, { includeRawSource: false })
-        expect(md).not.toContain("cf:synth-thead")
-        const doc2 = yield* parseMarkdown(md)
-        const finalHtml = yield* serializeToConfluence(doc2)
-        expect(finalHtml).toBe(originalHtml)
-      }))
-
-    it.effect("renders view-file macro as a link to the attachment", () =>
-      Effect.gen(function*() {
-        const originalHtml =
-          `<p><ac:structured-macro ac:name="view-file"><ac:parameter ac:name="name"><ri:attachment ri:filename="guidelines.md"/></ac:parameter></ac:structured-macro></p>`
-        const doc1 = yield* parseConfluenceHtml(originalHtml)
-        const md = yield* serializeToMarkdown(doc1, { includeRawSource: false })
-        expect(md).toContain("[guidelines.md](attachment:guidelines.md)")
-        const doc2 = yield* parseMarkdown(md)
-        const finalHtml = yield* serializeToConfluence(doc2)
-        expect(finalHtml).toContain("ac:name=\"view-file\"")
-        expect(finalHtml).toContain("ri:filename=\"guidelines.md\"")
-      }))
-
-    it.effect("roundtrips nested unordered list HTML -> markdown -> HTML", () =>
-      Effect.gen(function*() {
-        const originalHtml = `<ul><li><p>Outer</p><ul><li><p>Inner A</p></li><li><p>Inner B</p></li></ul></li></ul>`
-        const doc1 = yield* parseConfluenceHtml(originalHtml)
-        const md = yield* serializeToMarkdown(doc1, { includeRawSource: false })
-        const doc2 = yield* parseMarkdown(md)
-        const finalHtml = yield* serializeToConfluence(doc2)
-        expect(finalHtml).toBe(originalHtml)
-      }))
-
-    it.effect("emits markdown header divider for headerless table and roundtrips", () =>
-      Effect.gen(function*() {
-        // Tables without <thead> need a synthetic header in markdown to render.
-        const originalHtml =
-          `<table><tbody><tr><td>Cell A1</td><td>Cell A2</td></tr><tr><td>Cell B1</td><td>Cell B2</td></tr></tbody></table>`
-        const doc1 = yield* parseConfluenceHtml(originalHtml)
-        const md = yield* serializeToMarkdown(doc1, { includeRawSource: false })
-        // Synthetic empty header + divider so md viewers render it as a table.
-        expect(md).toMatch(/\|\s*\|\s*\|\n\| --- \| --- \|/)
-        expect(md).toContain("| Cell A1 | Cell A2 |")
-        expect(md).toContain("| Cell B1 | Cell B2 |")
-        // Roundtrip: the synthetic empty header is dropped on parse, so the
-        // Confluence output omits <thead> just like the source.
-        const doc2 = yield* parseMarkdown(md)
-        const finalHtml = yield* serializeToConfluence(doc2)
-        expect(finalHtml).toBe(originalHtml)
-      }))
-
-    it.effect("renders ExpandMacro as <details>/<summary> and roundtrips", () =>
-      Effect.gen(function*() {
-        const originalHtml =
-          `<ac:structured-macro ac:name="expand"><ac:parameter ac:name="title">Glossary term</ac:parameter><ac:rich-text-body><p>Body content here.</p></ac:rich-text-body></ac:structured-macro>`
-        const doc1 = yield* parseConfluenceHtml(originalHtml)
-        const md = yield* serializeToMarkdown(doc1, { includeRawSource: false })
-        expect(md).toContain("<details>")
-        expect(md).toContain("<summary>Glossary term</summary>")
-        expect(md).toContain("Body content here.")
-        expect(md).toContain("</details>")
-        // No more opaque cf:expand comment.
-        expect(md).not.toContain("<!--cf:expand:")
-
-        const doc2 = yield* parseMarkdown(md)
-        expect(doc2.children[0]?._tag).toBe("ExpandMacro")
-        const finalHtml = yield* serializeToConfluence(doc2)
-        expect(finalHtml).toContain("ac:name=\"expand\"")
-        expect(finalHtml).toContain("Glossary term")
-        expect(finalHtml).toContain("Body content here.")
-      }))
-
-    it.effect("roundtrips TOC macro", () =>
-      Effect.gen(function*() {
-        const html =
-          `<ac:structured-macro ac:name="toc"><ac:parameter ac:name="minLevel">2</ac:parameter></ac:structured-macro>`
-        const doc1 = yield* parseConfluenceHtml(html)
-        expect(doc1.children[0]?._tag).toBe("TocMacro")
-
-        const md = yield* serializeToMarkdown(doc1)
-        expect(md).toContain("[[toc]]")
-
-        const doc2 = yield* parseMarkdown(md)
-        expect(doc2.children[0]?._tag).toBe("TocMacro")
-
-        const html2 = yield* serializeToConfluence(doc2)
-        expect(html2).toContain("<ac:structured-macro ac:name=\"toc\">")
-      }))
-  })
-})

package/test/schemas/ConfluencePreprocessor.test.ts

@@ -1,180 +0,0 @@
-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)
-      }))
-  })
-})