@knpkv/confluence-to-markdown 0.4.2 → 0.6.0

package/test/MarkdownConverter.test.ts

@@ -1,142 +1,157 @@
 import { describe, expect, it } from "@effect/vitest"
 import * as Effect from "effect/Effect"
-import { layer as MarkdownConverterLayer, MarkdownConverter, schemaBasedLayer } from "../src/MarkdownConverter.js"
+import * as Layer from "effect/Layer"
+import { layer as AdfSchemaValidatorLayer } from "../src/AdfSchemaValidator.js"
+import { layer as AtlaskitTransformersLayer } from "../src/AtlaskitTransformers.js"
+import { layer as MarkdownConverterLayer, MarkdownConverter } from "../src/MarkdownConverter.js"
 
-describe("MarkdownConverter", () => {
-  describe("htmlToMarkdown", () => {
-    it.effect("converts basic HTML to markdown", () =>
-      Effect.gen(function*() {
-        const converter = yield* MarkdownConverter
-        const html = "<p>Hello <strong>world</strong></p>"
-        const markdown = yield* converter.htmlToMarkdown(html)
-        expect(markdown).toContain("Hello")
-        expect(markdown).toContain("**world**")
-      }).pipe(Effect.provide(MarkdownConverterLayer)))
+const TestLayer = MarkdownConverterLayer.pipe(
+  Layer.provide(AtlaskitTransformersLayer),
+  Layer.provide(AdfSchemaValidatorLayer)
+)
 
-    it.effect("converts headings", () =>
-      Effect.gen(function*() {
-        const converter = yield* MarkdownConverter
-        const html = "<h1>Title</h1><h2>Subtitle</h2>"
-        const markdown = yield* converter.htmlToMarkdown(html)
-        expect(markdown).toContain("# Title")
-        expect(markdown).toContain("## Subtitle")
-      }).pipe(Effect.provide(MarkdownConverterLayer)))
+const minimalDoc = (content: ReadonlyArray<unknown>): string => JSON.stringify({ version: 1, type: "doc", content })
 
-    it.effect("converts lists", () =>
-      Effect.gen(function*() {
-        const converter = yield* MarkdownConverter
-        const html = "<ul><li>Item 1</li><li>Item 2</li></ul>"
-        const markdown = yield* converter.htmlToMarkdown(html)
-        // AST-based serializer uses - for unordered lists
-        expect(markdown).toContain("- Item 1")
-        expect(markdown).toContain("- Item 2")
-      }).pipe(Effect.provide(MarkdownConverterLayer)))
-
-    it.effect("converts links", () =>
+describe("MarkdownConverter", () => {
+  describe("adfToMarkdown", () => {
+    it.effect("converts a heading", () =>
       Effect.gen(function*() {
         const converter = yield* MarkdownConverter
-        const html = "<a href=\"https://example.com\">Link</a>"
-        const markdown = yield* converter.htmlToMarkdown(html)
-        expect(markdown).toContain("[Link](https://example.com)")
-      }).pipe(Effect.provide(MarkdownConverterLayer)))
+        const md = yield* converter.adfToMarkdown(
+          minimalDoc([{ type: "heading", attrs: { level: 1 }, content: [{ type: "text", text: "Hello" }] }])
+        )
+        expect(md).toContain("# Hello")
+      }).pipe(Effect.provide(TestLayer)))
 
-    it.effect("converts code blocks", () =>
+    it.effect("converts a paragraph with marks", () =>
       Effect.gen(function*() {
         const converter = yield* MarkdownConverter
-        const html = "<pre><code>const x = 1;</code></pre>"
-        const markdown = yield* converter.htmlToMarkdown(html)
-        expect(markdown).toContain("```")
-        expect(markdown).toContain("const x = 1;")
-      }).pipe(Effect.provide(MarkdownConverterLayer)))
+        const md = yield* converter.adfToMarkdown(
+          minimalDoc([{
+            type: "paragraph",
+            content: [
+              { type: "text", text: "Hello " },
+              { type: "text", text: "world", marks: [{ type: "strong" }] }
+            ]
+          }])
+        )
+        expect(md).toContain("Hello")
+        expect(md).toContain("**world**")
+      }).pipe(Effect.provide(TestLayer)))
 
-    it.effect("strips Confluence macros with rich-text-body", () =>
+    it.effect("converts a bullet list", () =>
       Effect.gen(function*() {
         const converter = yield* MarkdownConverter
-        const html =
-          "<ac:structured-macro ac:name=\"info\"><ac:rich-text-body><p>Content</p></ac:rich-text-body></ac:structured-macro>"
-        const markdown = yield* converter.htmlToMarkdown(html)
-        expect(markdown).toContain("Content")
-        expect(markdown).not.toContain("ac:structured-macro")
-      }).pipe(Effect.provide(MarkdownConverterLayer)))
+        const md = yield* converter.adfToMarkdown(
+          minimalDoc([{
+            type: "bulletList",
+            content: [
+              {
+                type: "listItem",
+                content: [{ type: "paragraph", content: [{ type: "text", text: "one" }] }]
+              },
+              {
+                type: "listItem",
+                content: [{ type: "paragraph", content: [{ type: "text", text: "two" }] }]
+              }
+            ]
+          }])
+        )
+        expect(md).toContain("- one")
+        expect(md).toContain("- two")
+      }).pipe(Effect.provide(TestLayer)))
 
-    it.effect("converts Confluence code macros to code blocks", () =>
+    it.effect("converts a code block with language", () =>
       Effect.gen(function*() {
         const converter = yield* MarkdownConverter
-        const html =
-          "<ac:structured-macro ac:name=\"code\"><ac:plain-text-body><![CDATA[const x = 1;]]></ac:plain-text-body></ac:structured-macro>"
-        const markdown = yield* converter.htmlToMarkdown(html)
-        expect(markdown).toContain("const x = 1;")
-        expect(markdown).toContain("```")
-      }).pipe(Effect.provide(MarkdownConverterLayer)))
-  })
+        const md = yield* converter.adfToMarkdown(
+          minimalDoc([{
+            type: "codeBlock",
+            attrs: { language: "ts" },
+            content: [{ type: "text", text: "const x = 1" }]
+          }])
+        )
+        expect(md).toContain("```ts")
+        expect(md).toContain("const x = 1")
+      }).pipe(Effect.provide(TestLayer)))
 
-  describe("markdownToHtml", () => {
-    it.effect("converts basic markdown to HTML", () =>
+    it.effect("converts a panel to a GitHub admonition", () =>
       Effect.gen(function*() {
         const converter = yield* MarkdownConverter
-        const markdown = "Hello **world**"
-        const html = yield* converter.markdownToHtml(markdown)
-        expect(html).toContain("<strong>world</strong>")
-      }).pipe(Effect.provide(MarkdownConverterLayer)))
+        const md = yield* converter.adfToMarkdown(
+          minimalDoc([{
+            type: "panel",
+            attrs: { panelType: "info" },
+            content: [{ type: "paragraph", content: [{ type: "text", text: "heads up" }] }]
+          }])
+        )
+        expect(md).toContain("[!NOTE]")
+        expect(md).toContain("heads up")
+      }).pipe(Effect.provide(TestLayer)))
 
-    it.effect("converts headings", () =>
+    it.effect("fails with ConversionError on invalid JSON", () =>
       Effect.gen(function*() {
         const converter = yield* MarkdownConverter
-        const markdown = "# Title\n\n## Subtitle"
-        const html = yield* converter.markdownToHtml(markdown)
-        expect(html).toContain("<h1>Title</h1>")
-        expect(html).toContain("<h2>Subtitle</h2>")
-      }).pipe(Effect.provide(MarkdownConverterLayer)))
+        const result = yield* Effect.either(converter.adfToMarkdown("not json"))
+        expect(result._tag).toBe("Left")
+        if (result._tag === "Left") {
+          expect(result.left._tag).toBe("ConversionError")
+          expect(result.left.direction).toBe("adfToMarkdown")
+        }
+      }).pipe(Effect.provide(TestLayer)))
 
-    it.effect("converts GFM tables", () =>
+    it.effect("treats schema-invalid incoming ADF as advisory and still converts", () =>
       Effect.gen(function*() {
         const converter = yield* MarkdownConverter
-        const markdown = "| A | B |\n|---|---|\n| 1 | 2 |"
-        const html = yield* converter.markdownToHtml(markdown)
-        expect(html).toContain("<table>")
-        expect(html).toContain("<th>A</th>")
-        expect(html).toContain("<td>1</td>")
-      }).pipe(Effect.provide(MarkdownConverterLayer)))
+        // Missing `version`, and `attrs.level` should be a number — both are
+        // schema violations Confluence would never produce, but representative
+        // of the schema drift we tolerate on the incoming side.
+        const md = yield* converter.adfToMarkdown(JSON.stringify({
+          type: "doc",
+          content: [{
+            type: "heading",
+            attrs: { level: "1" },
+            content: [{ type: "text", text: "Hello" }]
+          }]
+        }))
+        expect(md).toContain("Hello")
+      }).pipe(Effect.provide(TestLayer)))
 
-    it.effect("converts task lists", () =>
+    it.effect("still fails on input too malformed to walk", () =>
       Effect.gen(function*() {
+        // Advisory validation tolerates schema drift, not non-documents:
+        // walking `null` is a defect, `{}`/arrays silently produce an empty
+        // page that could overwrite a real local file.
         const converter = yield* MarkdownConverter
-        const markdown = "- [ ] Todo\n- [x] Done"
-        const html = yield* converter.markdownToHtml(markdown)
-        expect(html).toContain("checkbox")
-      }).pipe(Effect.provide(MarkdownConverterLayer)))
+        for (const bad of ["null", "{}", "[1,2]", `{"type":"doc","content":"not an array"}`]) {
+          const result = yield* Effect.either(converter.adfToMarkdown(bad))
+          expect(result._tag).toBe("Left")
+          if (result._tag === "Left") {
+            expect(result.left._tag).toBe("ConversionError")
+          }
+        }
+      }).pipe(Effect.provide(TestLayer)))
   })
 
-  describe("schemaBasedLayer", () => {
-    it.effect("htmlToMarkdown converts basic HTML", () =>
-      Effect.gen(function*() {
-        const converter = yield* MarkdownConverter
-        const html = "<h1>Title</h1><p>Hello world</p>"
-        const markdown = yield* converter.htmlToMarkdown(html)
-        expect(markdown).toContain("# Title")
-        expect(markdown).toContain("Hello world")
-      }).pipe(Effect.provide(schemaBasedLayer)))
-
-    it.effect("htmlToAst parses HTML to Document", () =>
+  describe("markdownToAdf", () => {
+    it.effect("produces a valid ADF doc for a heading", () =>
       Effect.gen(function*() {
         const converter = yield* MarkdownConverter
-        const html = "<h1>Title</h1><p>Content</p>"
-        const doc = yield* converter.htmlToAst(html)
-        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")
-      }).pipe(Effect.provide(schemaBasedLayer)))
+        const adf = yield* converter.markdownToAdf("# Title\n\nBody")
+        const parsed = JSON.parse(adf) as { type: string; version: number; content: ReadonlyArray<{ type: string }> }
+        expect(parsed.type).toBe("doc")
+        expect(parsed.version).toBe(1)
+        expect(parsed.content[0]?.type).toBe("heading")
+      }).pipe(Effect.provide(TestLayer)))
 
-    it.effect("markdownToAst parses Markdown to Document", () =>
+    it.effect("round-trips a heading + paragraph through both directions", () =>
       Effect.gen(function*() {
         const converter = yield* MarkdownConverter
-        const md = "# Title\n\nContent"
-        const doc = yield* converter.markdownToAst(md)
-        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")
-      }).pipe(Effect.provide(schemaBasedLayer)))
+        const md1 = "# Title\n\nHello **world**"
+        const adf = yield* converter.markdownToAdf(md1)
+        const md2 = yield* converter.adfToMarkdown(adf)
+        expect(md2).toContain("# Title")
+        expect(md2).toContain("**world**")
+      }).pipe(Effect.provide(TestLayer)))
   })
 })

package/test/RoundTrip.test.ts

@@ -0,0 +1,266 @@
+/**
+ * Markdown → ADF → Markdown round-trip fidelity tests for the new pipeline.
+ *
+ * Replaces the structural fidelity coverage previously held by the deleted
+ * `ConfluenceParser`/`MarkdownParser`/`ConversionSchema`/fixture tests. We
+ * pin the *substantive* output of the round-trip (heading structure, list
+ * markers, code-block fences, table layout, link/title fidelity) rather than
+ * exact whitespace, since the @atlaskit transformer normalizes whitespace
+ * and we don't want to over-couple to its emission.
+ */
+import { describe, expect, it } from "@effect/vitest"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import { layer as AdfSchemaValidatorLayer } from "../src/AdfSchemaValidator.js"
+import { layer as AtlaskitTransformersLayer } from "../src/AtlaskitTransformers.js"
+import { layer as MarkdownConverterLayer, MarkdownConverter } from "../src/MarkdownConverter.js"
+
+const TestLayer = MarkdownConverterLayer.pipe(
+  Layer.provide(AtlaskitTransformersLayer),
+  Layer.provide(AdfSchemaValidatorLayer)
+)
+
+const roundTrip = (source: string) =>
+  Effect.gen(function*() {
+    const converter = yield* MarkdownConverter
+    const adf = yield* converter.markdownToAdf(source)
+    return yield* converter.adfToMarkdown(adf)
+  })
+
+describe("MarkdownConverter round-trip", () => {
+  it.effect("preserves nested headings", () =>
+    Effect.gen(function*() {
+      const md = yield* roundTrip("# H1\n\n## H2\n\n### H3\n")
+      expect(md).toContain("# H1")
+      expect(md).toContain("## H2")
+      expect(md).toContain("### H3")
+    }).pipe(Effect.provide(TestLayer)))
+
+  it.effect("preserves a fenced code block with language", () =>
+    Effect.gen(function*() {
+      const md = yield* roundTrip("```ts\nconst x: number = 1\n```\n")
+      expect(md).toContain("```ts")
+      expect(md).toContain("const x: number = 1")
+    }).pipe(Effect.provide(TestLayer)))
+
+  it.effect("preserves a blockquote", () =>
+    Effect.gen(function*() {
+      const md = yield* roundTrip("> a quote\n")
+      expect(md).toMatch(/^> a quote/m)
+    }).pipe(Effect.provide(TestLayer)))
+
+  it.effect("preserves a bullet list", () =>
+    Effect.gen(function*() {
+      const md = yield* roundTrip("- one\n- two\n- three\n")
+      expect(md).toContain("- one")
+      expect(md).toContain("- two")
+      expect(md).toContain("- three")
+    }).pipe(Effect.provide(TestLayer)))
+
+  it.effect("preserves an ordered list", () =>
+    Effect.gen(function*() {
+      const md = yield* roundTrip("1. one\n2. two\n3. three\n")
+      expect(md).toMatch(/1\. one/)
+      expect(md).toMatch(/2\. two/)
+      expect(md).toMatch(/3\. three/)
+    }).pipe(Effect.provide(TestLayer)))
+
+  it.effect("preserves a GFM table with header", () =>
+    Effect.gen(function*() {
+      const md = yield* roundTrip("| A | B |\n| --- | --- |\n| 1 | 2 |\n")
+      expect(md).toContain("| A | B |")
+      expect(md).toContain("| --- | --- |")
+      expect(md).toContain("| 1 | 2 |")
+    }).pipe(Effect.provide(TestLayer)))
+
+  // The @atlaskit markdown transformer drops link titles when parsing
+  // markdown (its ProseMirror schema for `link` does not capture `title`).
+  // So we only assert that text + href survive the round-trip; the title
+  // attribute is documented as round-trip-lossy via this test's name.
+  it.effect("preserves link text and href (title is lossy via @atlaskit)", () =>
+    Effect.gen(function*() {
+      const md = yield* roundTrip(`[home](https://example.com "Home")\n`)
+      expect(md).toContain("[home]")
+      expect(md).toContain("https://example.com")
+    }).pipe(Effect.provide(TestLayer)))
+
+  it.effect("preserves bold, italic, and inline code combinations", () =>
+    Effect.gen(function*() {
+      const md = yield* roundTrip("a **b** _c_ `d` text\n")
+      expect(md).toContain("**b**")
+      expect(md).toContain("_c_")
+      expect(md).toContain("`d`")
+    }).pipe(Effect.provide(TestLayer)))
+
+  it.effect("does not over-escape ordinary version strings", () =>
+    Effect.gen(function*() {
+      const md = yield* roundTrip("Released v1.0.0 on 2026-05-03\n")
+      expect(md).toContain("v1.0.0")
+      expect(md).toContain("2026-05-03")
+      expect(md).not.toContain("v1\\.0\\.0")
+      expect(md).not.toContain("2026\\-05\\-03")
+    }).pipe(Effect.provide(TestLayer)))
+
+  it.effect("does not escape parentheses or other line-start-only characters", () =>
+    Effect.gen(function*() {
+      const md = yield* roundTrip("a (b) c+ d!\n")
+      expect(md).toContain("a (b) c+ d!")
+      expect(md).not.toContain("\\(")
+      expect(md).not.toContain("\\+")
+    }).pipe(Effect.provide(TestLayer)))
+
+  // Regression: escaping inside code spans put literal backslashes into the
+  // ADF text, which the next pull re-escaped — doubling them on every
+  // round-trip (`a_b` → `a\_b` → `a\\\_b` → …).
+  it.effect("code spans with markdown-special characters are a round-trip fixed point", () =>
+    Effect.gen(function*() {
+      const source = "x `a_b` y `c()` (z)\n"
+      const once = yield* roundTrip(source)
+      const twice = yield* roundTrip(once)
+      expect(once).toContain("`a_b`")
+      expect(once).toContain("`c()`")
+      expect(once).not.toContain("\\")
+      expect(twice).toBe(once)
+    }).pipe(Effect.provide(TestLayer)))
+
+  it.effect("preserves an inline status placeholder through round-trip", () =>
+    Effect.gen(function*() {
+      const md = yield* roundTrip(
+        `Status: <span class="adf-status" data-color="blue">TESTING</span>\n`
+      )
+      expect(md).toContain(`<span class="adf-status" data-color="blue">TESTING</span>`)
+    }).pipe(Effect.provide(TestLayer)))
+
+  it.effect("upgrades a legacy block extension placeholder to the attrs form, then stays fixed", () =>
+    Effect.gen(function*() {
+      const md = yield* roundTrip(
+        `<!-- adf:extension key=toc type=com.atlassian.confluence.macro.core -->\n`
+      )
+      expect(md).toContain("<!-- adf:extension key=toc type=com.atlassian.confluence.macro.core attrs=")
+      const again = yield* roundTrip(md)
+      expect(again).toBe(md)
+    }).pipe(Effect.provide(TestLayer)))
+
+  it.effect("round-trips macro parameters through the placeholder attrs blob", () =>
+    Effect.gen(function*() {
+      const converter = yield* MarkdownConverter
+      const attrs = {
+        extensionKey: "toc",
+        extensionType: "com.atlassian.confluence.macro.core",
+        layout: "default",
+        localId: "abc-123",
+        parameters: { macroParams: { maxLevel: { value: "3" } } }
+      }
+      const md = yield* converter.adfToMarkdown(JSON.stringify({
+        version: 1,
+        type: "doc",
+        content: [{ type: "extension", attrs }]
+      }))
+      const adfOut = JSON.parse(yield* converter.markdownToAdf(md)) as {
+        content: Array<{ type: string; attrs: Record<string, unknown> }>
+      }
+      expect(adfOut.content[0]).toEqual({ type: "extension", attrs })
+    }).pipe(Effect.provide(TestLayer)))
+
+  it.effect("round-trips a bodiedExtension with its body re-attached", () =>
+    Effect.gen(function*() {
+      const converter = yield* MarkdownConverter
+      const attrs = { extensionKey: "details", extensionType: "com.atlassian.confluence.macro.core" }
+      const md = yield* converter.adfToMarkdown(JSON.stringify({
+        version: 1,
+        type: "doc",
+        content: [{
+          type: "bodiedExtension",
+          attrs,
+          content: [
+            { type: "paragraph", content: [{ type: "text", text: "first body paragraph" }] },
+            { type: "paragraph", content: [{ type: "text", text: "second body paragraph" }] }
+          ]
+        }]
+      }))
+      const adfOut = JSON.parse(yield* converter.markdownToAdf(md)) as {
+        content: Array<{ type: string; attrs: Record<string, unknown>; content: Array<unknown> }>
+      }
+      expect(adfOut.content).toHaveLength(1)
+      expect(adfOut.content[0]).toMatchObject({ type: "bodiedExtension", attrs })
+      expect(adfOut.content[0]!.content).toEqual([
+        { type: "paragraph", content: [{ type: "text", text: "first body paragraph" }] },
+        { type: "paragraph", content: [{ type: "text", text: "second body paragraph" }] }
+      ])
+    }).pipe(Effect.provide(TestLayer)))
+
+  // Regression: `|` in a cell was escaped twice (escapeText + the table-cell
+  // pass), emitting `\\|` — GFM reads that as literal backslash + bare pipe,
+  // which opens a phantom column and breaks the row.
+  it.effect("escapes a pipe inside a table cell exactly once", () =>
+    Effect.gen(function*() {
+      const md = yield* roundTrip("| A |\n| --- |\n| a\\|b |\n")
+      expect(md).toContain("a\\|b")
+      expect(md).not.toContain("a\\\\|b")
+    }).pipe(Effect.provide(TestLayer)))
+
+  // Regression: a code fence *quoting* the placeholder syntax got structured
+  // nodes injected into the codeBlock, failing outgoing schema validation.
+  it.effect("does not expand placeholder-looking text inside a code fence", () =>
+    Effect.gen(function*() {
+      const fence = "```html\n" +
+        `<span class="adf-status" data-color="blue">X</span>\n` +
+        `<!-- adf:inlineExtension key=k type=t -->\n` +
+        "```\n"
+      const md = yield* roundTrip(fence)
+      expect(md).toContain(`<span class="adf-status" data-color="blue">X</span>`)
+      expect(md).toContain(`<!-- adf:inlineExtension key=k type=t -->`)
+      expect(md).toContain("```html")
+    }).pipe(Effect.provide(TestLayer)))
+
+  // Regression: the inline twin of the fence case — a code *span* quoting a
+  // placeholder was replaced by a real status node, silently dropping the
+  // quoted sample.
+  it.effect("does not expand placeholder-looking text inside a code span", () =>
+    Effect.gen(function*() {
+      const converter = yield* MarkdownConverter
+      const source = `Use \`<span class="adf-status" data-color="green">DONE</span>\` in docs\n`
+      const adf = JSON.parse(yield* converter.markdownToAdf(source)) as {
+        content: Array<{ content: Array<{ type: string }> }>
+      }
+      expect(adf.content[0]!.content.some((n) => n.type === "status")).toBe(false)
+    }).pipe(Effect.provide(TestLayer)))
+
+  // Regression: '# x' / '> x' / '+ x' paragraph text became real headings,
+  // quotes, and lists after the ESCAPE_RE narrowing dropped those characters.
+  it.effect("keeps line-start block markers in paragraph text as text", () =>
+    Effect.gen(function*() {
+      const converter = yield* MarkdownConverter
+      const paragraph = (text: string) => ({ type: "paragraph", content: [{ type: "text", text }] })
+      const md = yield* converter.adfToMarkdown(JSON.stringify({
+        version: 1,
+        type: "doc",
+        content: [paragraph("# not a heading"), paragraph("> not a quote"), paragraph("+ not a list")]
+      }))
+      const adfOut = JSON.parse(yield* converter.markdownToAdf(md)) as {
+        content: Array<{ type: string }>
+      }
+      expect(adfOut.content.map((n) => n.type)).toEqual(["paragraph", "paragraph", "paragraph"])
+    }).pipe(Effect.provide(TestLayer)))
+
+  it.effect("keeps the bodied kind for an empty-body bodied extension", () =>
+    Effect.gen(function*() {
+      const converter = yield* MarkdownConverter
+      const attrs = { extensionKey: "excerpt", extensionType: "com.atlassian.confluence.macro.core" }
+      const md = yield* converter.adfToMarkdown(JSON.stringify({
+        version: 1,
+        type: "doc",
+        content: [{ type: "bodiedExtension", attrs, content: [{ type: "paragraph", content: [] }] }]
+      }))
+      const adfOut = JSON.parse(yield* converter.markdownToAdf(md)) as {
+        content: Array<{ type: string }>
+      }
+      expect(adfOut.content[0]!.type).toBe("bodiedExtension")
+    }).pipe(Effect.provide(TestLayer)))
+
+  it.effect("preserves a mention's accountId through round-trip", () =>
+    Effect.gen(function*() {
+      const md = yield* roundTrip(`[@Andrey Konopkov](confluence-mention://557057%3Aabc-123)\n`)
+      expect(md).toContain("[@Andrey Konopkov](confluence-mention://557057%3Aabc-123)")
+    }).pipe(Effect.provide(TestLayer)))
+})

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 knpkv
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/src/SchemaConverterError.ts

@@ -1,108 +0,0 @@
-/**
- * Error types for schema-based conversion.
- *
- * @module
- */
-import * as Data from "effect/Data"
-
-/**
- * Error thrown when parsing HTML or Markdown fails.
- *
- * @example
- * ```typescript
- * import { Effect } from "effect"
- * import { ParseError } from "@knpkv/confluence-to-markdown/SchemaConverterError"
- *
- * Effect.gen(function* () {
- *   // ... parsing operation
- * }).pipe(
- *   Effect.catchTag("ParseError", (error) =>
- *     Effect.sync(() => console.error(`Parse error: ${error.message}`))
- *   )
- * )
- * ```
- *
- * @category Errors
- */
-export class ParseError extends Data.TaggedError("ParseError")<{
-  readonly source: "confluence" | "markdown"
-  readonly message: string
-  readonly position?: { readonly line: number; readonly column: number }
-  readonly rawContent?: string
-}> {}
-
-/**
- * Error thrown when serializing AST to HTML or Markdown fails.
- *
- * @example
- * ```typescript
- * import { Effect } from "effect"
- * import { SerializeError } from "@knpkv/confluence-to-markdown/SchemaConverterError"
- *
- * Effect.gen(function* () {
- *   // ... serialization operation
- * }).pipe(
- *   Effect.catchTag("SerializeError", (error) =>
- *     Effect.sync(() => console.error(`Serialize error: ${error.message}`))
- *   )
- * )
- * ```
- *
- * @category Errors
- */
-export class SerializeError extends Data.TaggedError("SerializeError")<{
-  readonly target: "confluence" | "markdown"
-  readonly nodeType: string
-  readonly message: string
-}> {}
-
-/**
- * Error thrown when migrating between schema versions fails.
- *
- * @example
- * ```typescript
- * import { Effect } from "effect"
- * import { MigrationError } from "@knpkv/confluence-to-markdown/SchemaConverterError"
- *
- * Effect.gen(function* () {
- *   // ... migration operation
- * }).pipe(
- *   Effect.catchTag("MigrationError", (error) =>
- *     Effect.sync(() =>
- *       console.error(`Migration error: ${error.nodeType} v${error.fromVersion} -> v${error.toVersion}`)
- *     )
- *   )
- * )
- * ```
- *
- * @category Errors
- */
-export class MigrationError extends Data.TaggedError("MigrationError")<{
-  readonly nodeType: string
-  readonly fromVersion: number
-  readonly toVersion: number
-  readonly message: string
-}> {}
-
-/**
- * Union of all schema converter errors.
- *
- * @category Errors
- */
-export type SchemaConverterError = ParseError | SerializeError | MigrationError
-
-/**
- * Type guard to check if error is a SchemaConverterError.
- *
- * @param error - The error to check
- * @returns True if error is a SchemaConverterError
- *
- * @category Utilities
- */
-export const isSchemaConverterError = (error: unknown): error is SchemaConverterError =>
-  typeof error === "object" &&
-  error !== null &&
-  "_tag" in error &&
-  ["ParseError", "SerializeError", "MigrationError"].includes(
-    (error as { _tag: string })._tag
-  )