@knpkv/confluence-to-markdown 0.6.0 → 0.7.0

package/test/AdfPlaceholders.test.ts

@@ -3,6 +3,7 @@ import { revertPlaceholders } from "../src/AdfPlaceholders.js"
 
 const docOf = (content: ReadonlyArray<unknown>) => ({ version: 1, type: "doc", content })
 const para = (text: string) => ({ type: "paragraph", content: [{ type: "text", text }] })
+const b64 = (value: unknown): string => Buffer.from(JSON.stringify(value)).toString("base64")
 
 describe("revertPlaceholders", () => {
   it("rewrites a status span placeholder into a status node", () => {
@@ -31,6 +32,53 @@ describe("revertPlaceholders", () => {
     })
   })
 
+  it("rewrites native TOC syntax into a Confluence core extension node", () => {
+    const out = revertPlaceholders(docOf([para("[[toc]]")])) as {
+      content: Array<{ type: string; attrs?: Record<string, unknown> }>
+    }
+
+    expect(out.content[0]).toEqual({
+      type: "extension",
+      attrs: {
+        extensionKey: "toc",
+        extensionType: "com.atlassian.confluence.macro.core"
+      }
+    })
+  })
+
+  it("rewrites native TOC syntax with levels into macro parameters", () => {
+    const out = revertPlaceholders(docOf([para("[[toc:min=2,max=4]]")])) as {
+      content: Array<{ type: string; attrs?: Record<string, unknown> }>
+    }
+
+    expect(out.content[0]).toEqual({
+      type: "extension",
+      attrs: {
+        extensionKey: "toc",
+        extensionType: "com.atlassian.confluence.macro.core",
+        parameters: {
+          macroParams: {
+            minLevel: { value: "2" },
+            maxLevel: { value: "4" }
+          }
+        }
+      }
+    })
+  })
+
+  it("leaves invalid or code-marked native TOC syntax as text", () => {
+    const invalid = revertPlaceholders(docOf([para("[[toc:min=0]]")])) as {
+      content: Array<{ type: string; content?: ReadonlyArray<unknown> }>
+    }
+    const quoted = revertPlaceholders(docOf([{
+      type: "paragraph",
+      content: [{ type: "text", text: "[[toc]]", marks: [{ type: "code" }] }]
+    }])) as { content: Array<{ type: string; content?: ReadonlyArray<unknown> }> }
+
+    expect(invalid.content[0]!.type).toBe("paragraph")
+    expect(quoted.content[0]!.type).toBe("paragraph")
+  })
+
   it("rewrites status and extension placeholders inside table cells", () => {
     const cell = (text: string) => ({
       type: "tableCell",
@@ -85,6 +133,67 @@ describe("revertPlaceholders", () => {
     })
   })
 
+  it("rewrites fallback inline formatting HTML into native marks", () => {
+    const out = revertPlaceholders(
+      docOf([para(
+        `Plain <u>underline</u>, H<sub>2</sub>O, x<sup>2</sup>, ` +
+          `<span style="color:#ff5630">Colored text</span>, ` +
+          `<span style="background-color:#f8e6a0">highlighted text</span>.`
+      )])
+    ) as {
+      content: Array<{
+        content: Array<{ type: string; text?: string; marks?: ReadonlyArray<{ type: string; attrs?: unknown }> }>
+      }>
+    }
+
+    const inlineContent = out.content[0]!.content
+    expect(inlineContent).toContainEqual({
+      type: "text",
+      text: "underline",
+      marks: [{ type: "underline" }]
+    })
+    expect(inlineContent).toContainEqual({
+      type: "text",
+      text: "2",
+      marks: [{ type: "subsup", attrs: { type: "sub" } }]
+    })
+    expect(inlineContent).toContainEqual({
+      type: "text",
+      text: "2",
+      marks: [{ type: "subsup", attrs: { type: "sup" } }]
+    })
+    expect(inlineContent).toContainEqual({
+      type: "text",
+      text: "Colored text",
+      marks: [{ type: "textColor", attrs: { color: "#ff5630" } }]
+    })
+    expect(inlineContent).toContainEqual({
+      type: "text",
+      text: "highlighted text",
+      marks: [{ type: "backgroundColor", attrs: { color: "#f8e6a0" } }]
+    })
+  })
+
+  it("rewrites inlineCard placeholders into native smart-link nodes", () => {
+    const attrs = { url: "https://www.atlassian.com" }
+    const out = revertPlaceholders(
+      docOf([para(`Inline smart link: <!-- adf:inlineCard attrs=${b64(attrs)} -->.`)])
+    ) as { content: Array<{ content: Array<{ type: string; attrs?: Record<string, unknown> }> }> }
+
+    expect(out.content[0]!.content[1]).toEqual({ type: "inlineCard", attrs })
+  })
+
+  it("rewrites encoded date and emoji placeholders into native inline nodes", () => {
+    const date = { type: "date", attrs: { timestamp: "1782259200000" } }
+    const emoji = { type: "emoji", attrs: { shortName: ":white_check_mark:", text: "✅" } }
+    const out = revertPlaceholders(
+      docOf([para(`Example <!-- adf:date node=${b64(date)} --> <!-- adf:emoji node=${b64(emoji)} -->`)])
+    ) as { content: Array<{ content: Array<unknown> }> }
+
+    expect(out.content[0]!.content).toContainEqual(date)
+    expect(out.content[0]!.content).toContainEqual(emoji)
+  })
+
   it("restores the full attrs (parameters included) from an attrs blob", () => {
     const attrs = {
       extensionKey: "toc",
@@ -135,6 +244,110 @@ describe("revertPlaceholders", () => {
     expect(out.content[1]).toEqual(para("after"))
   })
 
+  it("re-attaches the blocks between panel markers as a panel body", () => {
+    const attrs = { panelType: "warning" }
+    const blob = Buffer.from(JSON.stringify(attrs)).toString("base64")
+    const out = revertPlaceholders(
+      docOf([
+        para(`<!-- adf:panel type=warning attrs=${blob} -->`),
+        para("panel body"),
+        para(`<!-- adf:/panel -->`),
+        para("after")
+      ])
+    ) as { content: Array<{ type: string; attrs?: Record<string, unknown>; content?: ReadonlyArray<unknown> }> }
+
+    expect(out.content).toHaveLength(2)
+    expect(out.content[0]).toEqual({
+      type: "panel",
+      attrs,
+      content: [para("panel body")]
+    })
+    expect(out.content[1]).toEqual(para("after"))
+  })
+
+  it("re-attaches paragraph-level marks from paragraph markers", () => {
+    const marks = [{ type: "alignment", attrs: { align: "center" } }]
+    const out = revertPlaceholders(
+      docOf([
+        para(`<!-- adf:paragraph marks=${b64(marks)} -->`),
+        para("Centered paragraph for alignment validation."),
+        para(`<!-- adf:/paragraph -->`)
+      ])
+    ) as { content: Array<{ type: string; marks?: unknown; content?: ReadonlyArray<unknown> }> }
+
+    expect(out.content).toEqual([{
+      type: "paragraph",
+      marks,
+      content: [{ type: "text", text: "Centered paragraph for alignment validation." }]
+    }])
+  })
+
+  it("restores encoded native block nodes", () => {
+    const taskList = {
+      type: "taskList",
+      attrs: { localId: "tasks-1" },
+      content: [{
+        type: "taskItem",
+        attrs: { localId: "task-1", state: "DONE" },
+        content: [{ type: "text", text: "Existing primitive coverage reviewed" }]
+      }]
+    }
+    const decisionList = {
+      type: "decisionList",
+      attrs: { localId: "decisions-1" },
+      content: [{
+        type: "decisionItem",
+        attrs: { localId: "decision-1", state: "DECIDED" },
+        content: [{ type: "text", text: "Decide whether to maintain a separate asset for advanced macros." }]
+      }]
+    }
+    const expand = {
+      type: "expand",
+      attrs: { title: "Expandable supplementary content" },
+      content: [para("This section can be expanded.")]
+    }
+    const table = {
+      type: "table",
+      content: [{ type: "tableRow", content: [{ type: "tableCell", content: [para("Date")] }] }]
+    }
+    const layoutSection = {
+      type: "layoutSection",
+      content: [{ type: "layoutColumn", attrs: { width: 50 }, content: [para("Left column")] }]
+    }
+    const blockCard = { type: "blockCard", attrs: { url: "https://www.atlassian.com/software/confluence" } }
+    const embedCard = {
+      type: "embedCard",
+      attrs: { url: "https://www.atlassian.com/software/confluence", layout: "center" }
+    }
+    const out = revertPlaceholders(
+      docOf([
+        para(`<!-- adf:taskList node=${b64(taskList)} -->`),
+        para("[x] Existing primitive coverage reviewed"),
+        para("<!-- adf:/taskList -->"),
+        para(`<!-- adf:decisionList node=${b64(decisionList)} -->`),
+        para("This page will act as the baseline integration test asset for editor primitive coverage."),
+        para("<!-- adf:/decisionList -->"),
+        para(`<!-- adf:expand node=${b64(expand)} -->`),
+        para("This section can be expanded."),
+        para("<!-- adf:/expand -->"),
+        para(`<!-- adf:table node=${b64(table)} -->`),
+        para("| Date |"),
+        para("<!-- adf:/table -->"),
+        para(`<!-- adf:layoutSection node=${b64(layoutSection)} -->`),
+        para("Left column"),
+        para("<!-- adf:/layoutSection -->"),
+        para(`<!-- adf:blockCard node=${b64(blockCard)} -->`),
+        para("https://www.atlassian.com/software/confluence"),
+        para("<!-- adf:/blockCard -->"),
+        para(`<!-- adf:embedCard node=${b64(embedCard)} -->`),
+        para("https://www.atlassian.com/software/confluence"),
+        para("<!-- adf:/embedCard -->")
+      ])
+    ) as { content: Array<unknown> }
+
+    expect(out.content).toEqual([taskList, decisionList, expand, table, layoutSection, blockCard, embedCard])
+  })
+
   it("reverts an extension marker nested inside a bodiedExtension body", () => {
     const out = revertPlaceholders(
       docOf([

package/test/AdfSchemaValidator.test.ts

@@ -23,12 +23,12 @@ describe("AdfSchemaValidator", () => {
         type: "doc",
         content: [{ type: "paragraph", content: [{ type: "text", text: 42 }] }]
       }
-      const result = yield* Effect.either(v.check(doc, "incoming"))
-      expect(result._tag).toBe("Left")
-      if (result._tag === "Left") {
-        expect(result.left._tag).toBe("AdfSchemaError")
-        expect(result.left.direction).toBe("incoming")
-        expect(result.left.issues.length).toBeGreaterThan(0)
+      const result = yield* Effect.result(v.check(doc, "incoming"))
+      expect(result._tag).toBe("Failure")
+      if (result._tag === "Failure") {
+        expect(result.failure._tag).toBe("AdfSchemaError")
+        expect(result.failure.direction).toBe("incoming")
+        expect(result.failure.issues.length).toBeGreaterThan(0)
       }
     }).pipe(Effect.provide(AdfSchemaValidatorLayer)))
 })

package/test/AdfWalker.test.ts

@@ -4,9 +4,18 @@ import { walk } from "../src/AdfWalker.js"
 
 const doc = (content: ReadonlyArray<unknown>): DocNode => ({ version: 1, type: "doc", content } as unknown as DocNode)
 
-// Expected `attrs=` blob: base64 of the attrs JSON with keys sorted (write
-// the literal in sorted key order so JSON.stringify matches the walker).
-const b64 = (attrs: Record<string, unknown>): string => Buffer.from(JSON.stringify(attrs)).toString("base64")
+const stableStringify = (v: unknown): string => {
+  if (Array.isArray(v)) return `[${v.map(stableStringify).join(",")}]`
+  if (v !== null && typeof v === "object") {
+    return `{${
+      Object.entries(v as Record<string, unknown>)
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .map(([k, value]) => `${JSON.stringify(k)}:${stableStringify(value)}`)
+        .join(",")
+    }}`
+  }
+  return JSON.stringify(v) ?? "null"
+}
 
 describe("AdfWalker", () => {
   it("emits a heading at the right level", () => {
@@ -159,34 +168,57 @@ describe("AdfWalker", () => {
     expect(r.markdown).toContain("| 1 | 2 |")
   })
 
-  it("renders a panel as a GitHub admonition", () => {
+  it("renders a panel as a Confluence-preserving placeholder", () => {
     const r = walk(doc([{
       type: "panel",
       attrs: { panelType: "warning" },
       content: [{ type: "paragraph", content: [{ type: "text", text: "be careful" }] }]
     }]))
-    expect(r.markdown).toContain("[!WARNING]")
+    expect(r.markdown).toContain(
+      `<!-- adf:panel type=warning attrs=${stableStringify({ panelType: "warning" })} -->`
+    )
     expect(r.markdown).toContain("be careful")
+    expect(r.markdown).toContain("<!-- adf:/panel -->")
   })
 
   it("renders task lists with checkbox state", () => {
-    const r = walk(doc([{
+    const node = {
       type: "taskList",
+      attrs: { localId: "tasks-1" },
       content: [
         {
           type: "taskItem",
-          attrs: { state: "DONE" },
+          attrs: { localId: "task-1", state: "DONE" },
           content: [{ type: "text", text: "done" }]
         },
         {
           type: "taskItem",
-          attrs: { state: "TODO" },
+          attrs: { localId: "task-2", state: "TODO" },
           content: [{ type: "text", text: "todo" }]
         }
       ]
-    }]))
+    }
+    const r = walk(doc([node]))
+    expect(r.markdown).toContain(`<!-- adf:taskList node=${stableStringify(node)} -->`)
     expect(r.markdown).toContain("- [x] done")
     expect(r.markdown).toContain("- [ ] todo")
+    expect(r.markdown).toContain("<!-- adf:/taskList -->")
+  })
+
+  it("wraps decision lists so they survive push as native decisions", () => {
+    const node = {
+      type: "decisionList",
+      attrs: { localId: "decisions-1" },
+      content: [{
+        type: "decisionItem",
+        attrs: { localId: "decision-1", state: "DECIDED" },
+        content: [{ type: "text", text: "decide" }]
+      }]
+    }
+    const r = walk(doc([node]))
+    expect(r.markdown).toContain(`<!-- adf:decisionList node=${stableStringify(node)} -->`)
+    expect(r.markdown).toContain("- 🔘 decide")
+    expect(r.markdown).toContain("<!-- adf:/decisionList -->")
   })
 
   it("renders every child of a mediaGroup", () => {
@@ -237,23 +269,51 @@ describe("AdfWalker", () => {
     expect(r.markdown).not.toContain("confluence-mention")
   })
 
-  it("preserves the full attrs (parameters included) in the extension placeholder", () => {
+  it("renders a representable TOC extension as readable native syntax", () => {
+    const r = walk(doc([{
+      type: "extension",
+      attrs: {
+        extensionKey: "toc",
+        extensionType: "com.atlassian.confluence.macro.core"
+      }
+    }]))
+    expect(r.markdown).toContain("[[toc]]")
+    expect(r.warnings).not.toContainEqual(
+      expect.objectContaining({ _tag: "UnsupportedExtension", extensionKey: "toc" })
+    )
+  })
+
+  it("renders representable TOC levels in readable native syntax", () => {
     const r = walk(doc([{
       type: "extension",
       attrs: {
         extensionType: "com.atlassian.confluence.macro.core",
         extensionKey: "toc",
-        parameters: { macroParams: { maxLevel: { value: "3" } } }
+        parameters: {
+          macroParams: {
+            minLevel: { value: "2" },
+            maxLevel: { value: "4" }
+          }
+        }
       }
     }]))
-    const attrs = b64({
+    expect(r.markdown).toContain("[[toc:min=2,max=4]]")
+  })
+
+  it("falls back to a generic placeholder when TOC attrs are not fully representable", () => {
+    const rawAttrs = {
       extensionKey: "toc",
       extensionType: "com.atlassian.confluence.macro.core",
+      layout: "default",
+      localId: "abc-123",
       parameters: { macroParams: { maxLevel: { value: "3" } } }
-    })
+    }
+    const r = walk(doc([{ type: "extension", attrs: rawAttrs }]))
+    const attrs = stableStringify(rawAttrs)
     expect(r.markdown).toContain(
       `<!-- adf:extension key=toc type=com.atlassian.confluence.macro.core attrs=${attrs} -->`
     )
+    expect(r.markdown).not.toContain("[[toc")
     expect(
       r.warnings.some((w) =>
         w._tag === "UnsupportedExtension" && w.extensionKey === "toc" && w.nodeType === "extension"
@@ -261,6 +321,27 @@ describe("AdfWalker", () => {
     ).toBe(true)
   })
 
+  it("falls back to a generic placeholder for Confluence TOC macroMetadata", () => {
+    const rawAttrs = {
+      extensionKey: "toc",
+      extensionType: "com.atlassian.confluence.macro.core",
+      layout: "default",
+      parameters: {
+        macroMetadata: {
+          schemaVersion: { value: "1" },
+          title: "Table of Contents"
+        },
+        macroParams: {}
+      }
+    }
+    const r = walk(doc([{ type: "extension", attrs: rawAttrs }]))
+    const attrs = stableStringify(rawAttrs)
+    expect(r.markdown).toContain(
+      `<!-- adf:extension key=toc type=com.atlassian.confluence.macro.core attrs=${attrs} -->`
+    )
+    expect(r.markdown).not.toContain("[[toc")
+  })
+
   it("emits the same attrs blob regardless of source key order", () => {
     const a = walk(doc([{ type: "extension", attrs: { extensionKey: "toc", extensionType: "t" } }]))
     const b = walk(doc([{ type: "extension", attrs: { extensionType: "t", extensionKey: "toc" } }]))
@@ -283,8 +364,8 @@ describe("AdfWalker", () => {
         content: [{ type: "paragraph", content: [{ type: "text", text: "body" }] }]
       }
     ]))
-    const inlineAttrs = b64({ extensionKey: "jira-issue", extensionType: "com.example" })
-    const bodiedAttrs = b64({ extensionKey: "details", extensionType: "com.example" })
+    const inlineAttrs = stableStringify({ extensionKey: "jira-issue", extensionType: "com.example" })
+    const bodiedAttrs = stableStringify({ extensionKey: "details", extensionType: "com.example" })
     expect(r.markdown).toContain(
       `<!-- adf:inlineExtension key=jira-issue type=com.example attrs=${inlineAttrs} -->`
     )
@@ -325,7 +406,7 @@ describe("AdfWalker", () => {
       }]
     }]))
     expect(r.markdown).not.toContain("adf:/bodiedExtension")
-    expect(r.markdown).not.toContain("body")
+    expect(r.markdown).not.toContain("\n\nbody\n\n")
     expect(r.markdown).toContain("<!-- adf:bodiedExtension key=details type=com.example")
   })
 
@@ -362,6 +443,42 @@ describe("AdfWalker", () => {
     expect(r.markdown).toContain("![diagram](https://x.test/d.png)\n_Figure 1_")
   })
 
+  it("renders layout sections and columns as visible markdown content", () => {
+    const r = walk(doc([{
+      type: "layoutSection",
+      content: [
+        {
+          type: "layoutColumn",
+          attrs: { width: 50 },
+          content: [{ type: "paragraph", content: [{ type: "text", text: "left" }] }]
+        },
+        {
+          type: "layoutColumn",
+          attrs: { width: 50 },
+          content: [{ type: "paragraph", content: [{ type: "text", text: "right" }] }]
+        }
+      ]
+    }]))
+    expect(r.markdown).toContain("left\n\nright")
+    expect(r.warnings.some((w) => w._tag === "UnsupportedNode" && w.nodeType === "layoutSection")).toBe(false)
+    expect(r.warnings.some((w) => w._tag === "UnsupportedNode" && w.nodeType === "layoutColumn")).toBe(false)
+  })
+
+  it("renders block and embed smart cards from direct and nested urls", () => {
+    const blockCard = { type: "blockCard", attrs: { url: "https://x.test/block" } }
+    const embedCard = { type: "embedCard", attrs: { data: { url: "https://x.test/embed" } } }
+    const r = walk(doc([
+      blockCard,
+      embedCard
+    ]))
+    expect(r.markdown).toContain(`<!-- adf:blockCard node=${stableStringify(blockCard)} -->`)
+    expect(r.markdown).toContain("<https://x.test/block>")
+    expect(r.markdown).toContain(`<!-- adf:embedCard node=${stableStringify(embedCard)} -->`)
+    expect(r.markdown).toContain("<https://x.test/embed>")
+    expect(r.warnings.some((w) => w._tag === "UnsupportedNode" && w.nodeType === "blockCard")).toBe(false)
+    expect(r.warnings.some((w) => w._tag === "UnsupportedNode" && w.nodeType === "embedCard")).toBe(false)
+  })
+
   it("backslash-escapes nestedExpand titles inside table cells (inline HTML context)", () => {
     const r = walk(doc([{
       type: "table",
@@ -386,7 +503,8 @@ describe("AdfWalker", () => {
       attrs: { title: `v2 *beta* <a href="x">` },
       content: [{ type: "paragraph", content: [{ type: "text", text: "inner" }] }]
     }]))
-    expect(r.markdown).toContain(`<summary>v2 *beta* &lt;a href=&quot;x&quot;&gt;</summary>`)
+    expect(r.markdown).toContain(`<!-- adf:expand node=`)
+    expect(r.markdown).toContain(`v2 *beta* <a href="x">`)
     expect(r.markdown).not.toContain("\\*beta\\*")
   })
 
@@ -465,13 +583,39 @@ describe("AdfWalker", () => {
       type: "paragraph",
       content: [
         { type: "text", text: "before " },
-        { type: "inlineCard", attrs: { data: { url: "https://hidden.test" } } },
+        { type: "inlineCard", attrs: { data: { title: "hidden" } } },
         { type: "text", text: " after" }
       ]
     }]))
     expect(r.warnings.some((w) => w._tag === "UnsupportedNode" && w.nodeType === "inlineCard")).toBe(true)
   })
 
+  it("renders inline cards from nested data urls", () => {
+    const r = walk(doc([{
+      type: "paragraph",
+      content: [
+        { type: "text", text: "see " },
+        { type: "inlineCard", attrs: { data: { url: "https://x.test/inline" } } }
+      ]
+    }]))
+    expect(r.markdown).toContain(
+      `see <!-- adf:inlineCard attrs=${stableStringify({ data: { url: "https://x.test/inline" } })} -->`
+    )
+    expect(r.warnings.some((w) => w._tag === "UnsupportedNode" && w.nodeType === "inlineCard")).toBe(false)
+  })
+
+  it("wraps paragraph-level marks so alignment and indentation survive push", () => {
+    const marks = [{ type: "alignment", attrs: { align: "center" } }]
+    const r = walk(doc([{
+      type: "paragraph",
+      marks,
+      content: [{ type: "text", text: "centered" }]
+    }]))
+    expect(r.markdown).toContain(`<!-- adf:paragraph marks=${stableStringify(marks)} -->`)
+    expect(r.markdown).toContain("centered")
+    expect(r.markdown).toContain("<!-- adf:/paragraph -->")
+  })
+
   it("does not double-wrap an em-marked caption", () => {
     const r = walk(doc([{
       type: "mediaSingle",
@@ -505,7 +649,7 @@ describe("AdfWalker", () => {
     expect(r.markdown).toContain("_orphan_")
   })
 
-  it("maps note panels to IMPORTANT and success panels to TIP", () => {
+  it("preserves note and success panel types", () => {
     const r = walk(doc([
       {
         type: "panel",
@@ -518,8 +662,10 @@ describe("AdfWalker", () => {
         content: [{ type: "paragraph", content: [{ type: "text", text: "s" }] }]
       }
     ]))
-    expect(r.markdown).toContain("[!IMPORTANT]")
-    expect(r.markdown).toContain("[!TIP]")
+    expect(r.markdown).toContain(`<!-- adf:panel type=note attrs=${stableStringify({ panelType: "note" })} -->`)
+    expect(r.markdown).toContain(
+      `<!-- adf:panel type=success attrs=${stableStringify({ panelType: "success" })} -->`
+    )
   })
 
   it("ends output with exactly one newline", () => {

package/test/AtlaskitTransformers.test.ts

@@ -14,12 +14,12 @@ describe("AtlaskitTransformers", () => {
   it.effect("surfaces synchronous throws as AtlaskitTransformersError", () =>
     Effect.gen(function*() {
       const t = yield* AtlaskitTransformers
-      const result = yield* Effect.either(t.use(() => {
+      const result = yield* Effect.result(t.use(() => {
         throw new Error("boom")
       }))
-      expect(result._tag).toBe("Left")
-      if (result._tag === "Left") {
-        expect(result.left._tag).toBe("AtlaskitTransformersError")
+      expect(result._tag).toBe("Failure")
+      if (result._tag === "Failure") {
+        expect(result.failure._tag).toBe("AtlaskitTransformersError")
       }
     }).pipe(Effect.provide(AtlaskitTransformersLayer)))
 })

package/test/Brand.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "@effect/vitest"
-import * as Either from "effect/Either"
+import * as Result from "effect/Result"
 import * as Schema from "effect/Schema"
 import { ContentHash, PageId, PageIdSchema, SpaceKey, SpaceKeySchema } from "../src/Brand.js"
 
@@ -17,13 +17,13 @@ describe("Brand", () => {
 
   describe("PageIdSchema", () => {
     it("decodes valid page IDs", () => {
-      const result = Schema.decodeEither(PageIdSchema)("123456")
-      expect(Either.isRight(result)).toBe(true)
+      const result = Schema.decodeUnknownResult(PageIdSchema)("123456")
+      expect(Result.isSuccess(result)).toBe(true)
     })
 
     it("rejects empty strings", () => {
-      const result = Schema.decodeEither(PageIdSchema)("")
-      expect(Either.isLeft(result)).toBe(true)
+      const result = Schema.decodeUnknownResult(PageIdSchema)("")
+      expect(Result.isFailure(result)).toBe(true)
     })
   })
 
@@ -40,18 +40,18 @@ describe("Brand", () => {
 
   describe("SpaceKeySchema", () => {
     it("decodes uppercase alphanumeric keys", () => {
-      const result = Schema.decodeEither(SpaceKeySchema)("MYSPACE123")
-      expect(Either.isRight(result)).toBe(true)
+      const result = Schema.decodeUnknownResult(SpaceKeySchema)("MYSPACE123")
+      expect(Result.isSuccess(result)).toBe(true)
     })
 
     it("rejects lowercase keys", () => {
-      const result = Schema.decodeEither(SpaceKeySchema)("myspace")
-      expect(Either.isLeft(result)).toBe(true)
+      const result = Schema.decodeUnknownResult(SpaceKeySchema)("myspace")
+      expect(Result.isFailure(result)).toBe(true)
     })
 
     it("rejects keys with special characters", () => {
-      const result = Schema.decodeEither(SpaceKeySchema)("MY-SPACE")
-      expect(Either.isLeft(result)).toBe(true)
+      const result = Schema.decodeUnknownResult(SpaceKeySchema)("MY-SPACE")
+      expect(Result.isFailure(result)).toBe(true)
     })
   })
 

package/test/GitService.test.ts

@@ -1,5 +1,7 @@
+import { NodeServices } from "@effect/platform-node"
 import { describe, expect, it } from "@effect/vitest"
 import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
 import { GitService, layer as GitServiceLayer } from "../src/GitService.js"
 import { getConflictedFiles, GIT_LOG_FORMAT, parseGitLog, parseGitStatus } from "../src/internal/gitCommands.js"
 
@@ -7,6 +9,8 @@ import { getConflictedFiles, GIT_LOG_FORMAT, parseGitLog, parseGitStatus } from
  * Tests for git parsing utilities and GitService.
  */
 describe("GitService", () => {
+  const TestLayer = Layer.provideMerge(GitServiceLayer, NodeServices.layer)
+
   describe("parseGitStatus", () => {
     it("parses empty status", () => {
       const entries = parseGitStatus("")
@@ -197,13 +201,13 @@ M  normal.ts`
         const git = yield* GitService
         const version = yield* git.validateGit()
         expect(version).toContain("git version")
-      }).pipe(Effect.provide(GitServiceLayer)))
+      }).pipe(Effect.provide(TestLayer)))
 
     it.effect("isInitialized returns boolean", () =>
       Effect.gen(function*() {
         const git = yield* GitService
         const initialized = yield* git.isInitialized()
         expect(typeof initialized).toBe("boolean")
-      }).pipe(Effect.provide(GitServiceLayer)))
+      }).pipe(Effect.provide(TestLayer)))
   })
 })