@knpkv/confluence-to-markdown 0.5.0 → 0.7.0

package/test/Schemas.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 type { ContentHash, PageId } from "../src/Brand.js"
 import {
@@ -17,11 +17,11 @@ describe("Schemas", () => {
         rootPageId: "123456",
         baseUrl: "https://mysite.atlassian.net"
       }
-      const result = Schema.decodeUnknownEither(ConfluenceConfigFileSchema)(config)
-      expect(Either.isRight(result)).toBe(true)
-      if (Either.isRight(result)) {
-        expect(result.right.docsPath).toBe(".confluence/docs")
-        expect(result.right.excludePatterns).toEqual([])
+      const result = Schema.decodeUnknownResult(ConfluenceConfigFileSchema)(config)
+      expect(Result.isSuccess(result)).toBe(true)
+      if (Result.isSuccess(result)) {
+        expect(result.success.docsPath).toBe(".confluence/docs")
+        expect(result.success.excludePatterns).toEqual([])
       }
     })
 
@@ -33,11 +33,11 @@ describe("Schemas", () => {
         docsPath: "docs",
         excludePatterns: ["*.tmp"]
       }
-      const result = Schema.decodeUnknownEither(ConfluenceConfigFileSchema)(config)
-      expect(Either.isRight(result)).toBe(true)
-      if (Either.isRight(result)) {
-        expect(result.right.spaceKey).toBe("DEV")
-        expect(result.right.docsPath).toBe("docs")
+      const result = Schema.decodeUnknownResult(ConfluenceConfigFileSchema)(config)
+      expect(Result.isSuccess(result)).toBe(true)
+      if (Result.isSuccess(result)) {
+        expect(result.success.spaceKey).toBe("DEV")
+        expect(result.success.docsPath).toBe("docs")
       }
     })
 
@@ -46,14 +46,14 @@ describe("Schemas", () => {
         rootPageId: "123456",
         baseUrl: "http://invalid.com"
       }
-      const result = Schema.decodeUnknownEither(ConfluenceConfigFileSchema)(config)
-      expect(Either.isLeft(result)).toBe(true)
+      const result = Schema.decodeUnknownResult(ConfluenceConfigFileSchema)(config)
+      expect(Result.isFailure(result)).toBe(true)
     })
 
     it("rejects missing required fields", () => {
       const config = { baseUrl: "https://mysite.atlassian.net" }
-      const result = Schema.decodeUnknownEither(ConfluenceConfigFileSchema)(config)
-      expect(Either.isLeft(result)).toBe(true)
+      const result = Schema.decodeUnknownResult(ConfluenceConfigFileSchema)(config)
+      expect(Result.isFailure(result)).toBe(true)
     })
   })
 
@@ -68,8 +68,8 @@ describe("Schemas", () => {
         updated: new Date().toISOString(),
         contentHash: validHash
       }
-      const result = Schema.decodeUnknownEither(PageFrontMatterSchema)(fm)
-      expect(Either.isRight(result)).toBe(true)
+      const result = Schema.decodeUnknownResult(PageFrontMatterSchema)(fm)
+      expect(Result.isSuccess(result)).toBe(true)
     })
 
     it("decodes front matter with optional fields", () => {
@@ -82,11 +82,11 @@ describe("Schemas", () => {
         position: 0,
         contentHash: validHash
       }
-      const result = Schema.decodeUnknownEither(PageFrontMatterSchema)(fm)
-      expect(Either.isRight(result)).toBe(true)
-      if (Either.isRight(result)) {
-        expect(result.right.parentId).toBe("456")
-        expect(result.right.position).toBe(0)
+      const result = Schema.decodeUnknownResult(PageFrontMatterSchema)(fm)
+      expect(Result.isSuccess(result)).toBe(true)
+      if (Result.isSuccess(result)) {
+        expect(result.success.parentId).toBe("456")
+        expect(result.success.position).toBe(0)
       }
     })
 
@@ -98,8 +98,8 @@ describe("Schemas", () => {
         updated: new Date().toISOString(),
         contentHash: validHash
       }
-      const result = Schema.decodeUnknownEither(PageFrontMatterSchema)(fm)
-      expect(Either.isLeft(result)).toBe(true)
+      const result = Schema.decodeUnknownResult(PageFrontMatterSchema)(fm)
+      expect(Result.isFailure(result)).toBe(true)
     })
   })
 
@@ -113,8 +113,8 @@ describe("Schemas", () => {
         cloud_id: "abc123",
         site_url: "https://mysite.atlassian.net"
       }
-      const result = Schema.decodeUnknownEither(OAuthTokenSchema)(token)
-      expect(Either.isRight(result)).toBe(true)
+      const result = Schema.decodeUnknownResult(OAuthTokenSchema)(token)
+      expect(Result.isSuccess(result)).toBe(true)
     })
 
     it("decodes token with user info", () => {
@@ -131,10 +131,10 @@ describe("Schemas", () => {
           email: "test@example.com"
         }
       }
-      const result = Schema.decodeUnknownEither(OAuthTokenSchema)(token)
-      expect(Either.isRight(result)).toBe(true)
-      if (Either.isRight(result)) {
-        expect(result.right.user?.name).toBe("Test User")
+      const result = Schema.decodeUnknownResult(OAuthTokenSchema)(token)
+      expect(Result.isSuccess(result)).toBe(true)
+      if (Result.isSuccess(result)) {
+        expect(result.success.user?.name).toBe("Test User")
       }
     })
 
@@ -147,8 +147,8 @@ describe("Schemas", () => {
         cloud_id: "abc123",
         site_url: "https://mysite.atlassian.net"
       }
-      const result = Schema.decodeUnknownEither(OAuthTokenSchema)(token)
-      expect(Either.isLeft(result)).toBe(true)
+      const result = Schema.decodeUnknownResult(OAuthTokenSchema)(token)
+      expect(Result.isFailure(result)).toBe(true)
     })
   })
 
@@ -158,16 +158,16 @@ describe("Schemas", () => {
         clientId: "client_id_value",
         clientSecret: "client_secret_value"
       }
-      const result = Schema.decodeUnknownEither(OAuthConfigSchema)(config)
-      expect(Either.isRight(result)).toBe(true)
+      const result = Schema.decodeUnknownResult(OAuthConfigSchema)(config)
+      expect(Result.isSuccess(result)).toBe(true)
     })
 
     it("rejects missing clientSecret", () => {
       const config = {
         clientId: "client_id_value"
       }
-      const result = Schema.decodeUnknownEither(OAuthConfigSchema)(config)
-      expect(Either.isLeft(result)).toBe(true)
+      const result = Schema.decodeUnknownResult(OAuthConfigSchema)(config)
+      expect(Result.isFailure(result)).toBe(true)
     })
   })
 
@@ -178,8 +178,8 @@ describe("Schemas", () => {
         name: "Test User",
         email: "test@example.com"
       }
-      const result = Schema.decodeUnknownEither(OAuthUserSchema)(user)
-      expect(Either.isRight(result)).toBe(true)
+      const result = Schema.decodeUnknownResult(OAuthUserSchema)(user)
+      expect(Result.isSuccess(result)).toBe(true)
     })
 
     it("rejects missing email", () => {
@@ -187,8 +187,8 @@ describe("Schemas", () => {
         account_id: "user123",
         name: "Test User"
       }
-      const result = Schema.decodeUnknownEither(OAuthUserSchema)(user)
-      expect(Either.isLeft(result)).toBe(true)
+      const result = Schema.decodeUnknownResult(OAuthUserSchema)(user)
+      expect(Result.isFailure(result)).toBe(true)
     })
   })
 })

package/test/adfMetadata.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, it } from "@effect/vitest"
+import { collectAdfMetadataHrefs, externalizeAdfMetadata, hydrateAdfMetadata } from "../src/internal/adfMetadata.js"
+
+const toBase64 = (text: string): string => {
+  const bytes = new TextEncoder().encode(text)
+  return btoa(String.fromCharCode(...bytes))
+}
+
+describe("ADF metadata sidecars", () => {
+  it("moves decoded placeholder metadata into a linked sidecar", () => {
+    const markdown = [
+      `<!-- adf:panel type=info attrs={"panelType":"info"} -->`,
+      "",
+      "Body",
+      "",
+      "<!-- adf:/panel -->",
+      "",
+      `Regular link: <!-- adf:inlineCard attrs={"url":"https://www.atlassian.com"} -->.`
+    ].join("\n")
+
+    const prepared = externalizeAdfMetadata(markdown, "./123.adf.json")
+
+    expect(prepared.markdown).toContain("<!-- adf:panel type=info ref=./123.adf.json#panel-1 -->")
+    expect(prepared.markdown).toContain("<!-- adf:inlineCard ref=./123.adf.json#inlineCard-2 -->")
+    expect(prepared.markdown).not.toContain("attrs={")
+    expect(prepared.sidecar).toEqual({
+      version: 1,
+      entries: {
+        "panel-1": {
+          kind: "attrs",
+          value: { panelType: "info" }
+        },
+        "inlineCard-2": {
+          kind: "attrs",
+          value: { url: "https://www.atlassian.com" }
+        }
+      }
+    })
+  })
+
+  it("moves base64 placeholder metadata into a linked sidecar", () => {
+    const attrs = {
+      extensionKey: "toc",
+      extensionType: "com.atlassian.confluence.macro.core",
+      parameters: {
+        macroMetadata: {
+          title: "Table of Contents"
+        }
+      }
+    }
+    const encodedAttrs = toBase64(JSON.stringify(attrs))
+    const markdown =
+      `| **On this page** | <!-- adf:extension key=toc type=com.atlassian.confluence.macro.core attrs=${encodedAttrs} --> |`
+
+    const prepared = externalizeAdfMetadata(markdown, "./2731114497.adf.json")
+
+    expect(prepared.markdown).toBe(
+      "| **On this page** | <!-- adf:extension key=toc type=com.atlassian.confluence.macro.core ref=./2731114497.adf.json#extension-1 --> |"
+    )
+    expect(prepared.markdown).not.toContain(encodedAttrs)
+    expect(prepared.sidecar).toEqual({
+      version: 1,
+      entries: {
+        "extension-1": {
+          kind: "attrs",
+          value: attrs
+        }
+      }
+    })
+  })
+
+  it("hydrates linked sidecar metadata back into placeholders for push", () => {
+    const markdown = `<!-- adf:taskList ref=./123.adf.json#taskList-1 -->`
+    const hydrated = hydrateAdfMetadata(
+      markdown,
+      new Map([
+        [
+          "./123.adf.json",
+          {
+            version: 1,
+            entries: {
+              "taskList-1": {
+                kind: "node",
+                value: {
+                  type: "taskList",
+                  attrs: { localId: "task-list" },
+                  content: [{ type: "taskItem", attrs: { state: "DONE" } }]
+                }
+              }
+            }
+          }
+        ]
+      ])
+    )
+
+    expect(hydrated).toBe(
+      `<!-- adf:taskList node={"attrs":{"localId":"task-list"},"content":[{"attrs":{"state":"DONE"},"type":"taskItem"}],"type":"taskList"} -->`
+    )
+  })
+
+  it("collects each referenced sidecar href once", () => {
+    const hrefs = collectAdfMetadataHrefs([
+      "<!-- adf:panel ref=./123.adf.json#panel-1 -->",
+      "<!-- adf:taskList ref=./123.adf.json#taskList-2 -->",
+      "<!-- adf:panel ref=./456.adf.json#panel-1 -->"
+    ].join("\n"))
+
+    expect([...hrefs].sort()).toEqual(["./123.adf.json", "./456.adf.json"])
+  })
+})

package/test/cleanMarkdown.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "@effect/vitest"
+import { cleanMarkdown } from "../src/internal/cleanMarkdown.js"
+
+describe("cleanMarkdown", () => {
+  it("removes full-line ADF metadata comments", () => {
+    const markdown = [
+      "# Title",
+      "",
+      "<!-- adf:panel type=info attrs={} -->",
+      "",
+      "Body",
+      "",
+      "<!-- adf:/panel -->"
+    ].join("\n")
+
+    expect(cleanMarkdown(markdown)).toBe("# Title\n\nBody\n")
+  })
+
+  it("removes inline ADF metadata comments", () => {
+    expect(cleanMarkdown("Card <!-- adf:inlineCard attrs={} --> text")).toBe("Card  text\n")
+  })
+
+  it("keeps regular markdown, native macros, status spans, and non-ADF comments", () => {
+    const markdown = [
+      "[[toc]]",
+      "",
+      "<span data-adf-status=\"todo\" data-adf-color=\"blue\">TODO</span>",
+      "",
+      "<!-- keep this comment -->",
+      "",
+      "- item"
+    ].join("\n")
+
+    expect(cleanMarkdown(markdown)).toBe(`${markdown}\n`)
+  })
+})

package/test/commandHarness.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it } from "@effect/vitest"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Ref from "effect/Ref"
+import type { PageId } from "../src/Brand.js"
+import { makeFetchCommand } from "../src/commands/fetch.js"
+import { ConfluenceClient } from "../src/ConfluenceClient.js"
+import type { PageResponse } from "../src/Schemas.js"
+import { CommandHarnessLayer, runConfluenceCommand } from "./commandHarness.js"
+
+const page: PageResponse = {
+  id: "2333334354",
+  title: "Harness Page",
+  version: { number: 1 },
+  body: {
+    atlas_doc_format: {
+      representation: "atlas_doc_format",
+      value: JSON.stringify({ type: "doc", version: 1, content: [] })
+    }
+  }
+}
+
+const FetchClientLayer = Layer.succeed(
+  ConfluenceClient,
+  ConfluenceClient.of({
+    getPage: (pageId: PageId) =>
+      pageId === "2333334354"
+        ? Effect.succeed(page)
+        : Effect.die(`unexpected page ID: ${pageId}`),
+    getChildren: () => Effect.die("unused"),
+    getAllChildren: () => Effect.die("unused"),
+    createPage: () => Effect.die("unused"),
+    updatePage: () => Effect.die("unused"),
+    deletePage: () => Effect.die("unused"),
+    getPageVersions: () => Effect.die("unused"),
+    getUser: () => Effect.die("unused"),
+    getSpaceId: () => Effect.die("unused"),
+    setEditorVersion: () => Effect.die("unused")
+  })
+)
+
+describe("command harness", () => {
+  it.effect("runs fetch through the root command without calling GitService", () =>
+    Effect.gen(function*() {
+      const gitCalls = yield* Ref.make(0)
+      const stdout = yield* Ref.make("")
+      const fetch = makeFetchCommand({ makeClientLayer: () => FetchClientLayer })
+
+      const exit = yield* runConfluenceCommand([
+        "fetch",
+        "--url",
+        "https://example.atlassian.net/wiki/pages/2333334354"
+      ], { fetch }).pipe(Effect.provide(CommandHarnessLayer({ gitCalls, stdout })))
+      const calls = yield* Ref.get(gitCalls)
+      const output = yield* Ref.get(stdout)
+
+      expect(exit._tag).toBe("Success")
+      expect(output).toBe("# Harness Page\n")
+      expect(calls).toBe(0)
+    }))
+
+  it.effect("rejects conflicting clone URL input before calling GitService", () =>
+    Effect.gen(function*() {
+      const gitCalls = yield* Ref.make(0)
+      const stdout = yield* Ref.make("")
+
+      const exit = yield* runConfluenceCommand([
+        "clone",
+        "--url",
+        "https://example.atlassian.net/wiki/pages/2333334354",
+        "--base-url",
+        "https://example.atlassian.net"
+      ]).pipe(Effect.provide(CommandHarnessLayer({ gitCalls, stdout })))
+      const calls = yield* Ref.get(gitCalls)
+
+      expect(exit._tag).toBe("Failure")
+      expect(calls).toBe(0)
+    }))
+})

package/test/commandHarness.ts

@@ -0,0 +1,147 @@
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Ref from "effect/Ref"
+import * as Terminal from "effect/Terminal"
+import { Command } from "effect/unstable/cli"
+import type { PageId } from "../src/Brand.js"
+import type { ConfluenceCommandOptions } from "../src/commands/root.js"
+import { makeConfluenceCommand } from "../src/commands/root.js"
+import { ConfluenceAuth } from "../src/ConfluenceAuth.js"
+import { ConfluenceClient } from "../src/ConfluenceClient.js"
+import { layerFromValues as ConfluenceConfigLayerFromValues } from "../src/ConfluenceConfig.js"
+import { GitService } from "../src/GitService.js"
+import { MarkdownConverter } from "../src/MarkdownConverter.js"
+import { SyncEngine } from "../src/SyncEngine.js"
+
+const notCalled = (calls: Ref.Ref<number>) =>
+  Ref.update(calls, (count) => count + 1).pipe(
+    Effect.flatMap(() => Effect.die("GitService should not be called"))
+  )
+
+export const GitShouldNotBeCalledLayer = (calls: Ref.Ref<number>) =>
+  Layer.succeed(
+    GitService,
+    GitService.of({
+      validateGit: () => notCalled(calls),
+      init: () => notCalled(calls),
+      isInitialized: () => notCalled(calls),
+      status: () => notCalled(calls),
+      commit: () => notCalled(calls),
+      log: () => notCalled(calls),
+      diff: () => notCalled(calls),
+      addAll: () => notCalled(calls),
+      hasConflicts: () => notCalled(calls),
+      mergeContinue: () => notCalled(calls),
+      syncFromDocs: () => notCalled(calls),
+      syncToDocs: () => notCalled(calls),
+      getHead: () => notCalled(calls),
+      getCurrentBranch: () => notCalled(calls),
+      createBranch: () => notCalled(calls),
+      checkout: () => notCalled(calls),
+      reset: () => notCalled(calls),
+      deleteBranch: () => notCalled(calls),
+      getParent: () => notCalled(calls),
+      cherryPick: () => notCalled(calls),
+      getChangedFiles: () => notCalled(calls),
+      showFile: () => notCalled(calls),
+      amend: () => notCalled(calls),
+      logRange: () => notCalled(calls),
+      branchExists: () => notCalled(calls),
+      updateBranch: () => notCalled(calls),
+      merge: () => notCalled(calls),
+      getDeletedFiles: () => notCalled(calls),
+      getFileContentAt: () => notCalled(calls)
+    })
+  )
+
+export interface CommandHarnessRefs {
+  readonly gitCalls: Ref.Ref<number>
+  readonly stdout: Ref.Ref<string>
+}
+
+const CaptureTerminalLayer = (stdout: Ref.Ref<string>) =>
+  Layer.succeed(
+    Terminal.Terminal,
+    Terminal.Terminal.of({
+      columns: Effect.succeed(80),
+      rows: Effect.succeed(24),
+      readInput: Effect.die("readInput should not be called"),
+      readLine: Effect.die("readLine should not be called"),
+      display: (text) => Ref.update(stdout, (output) => output + text)
+    })
+  )
+
+const AuthLayer = Layer.succeed(
+  ConfluenceAuth,
+  ConfluenceAuth.of({
+    configure: () => Effect.void,
+    isConfigured: () => Effect.succeed(true),
+    login: () => Effect.void,
+    logout: () => Effect.void,
+    getAccessToken: () => Effect.succeed("access-token"),
+    getCloudId: () => Effect.succeed("cloud-id"),
+    getCurrentUser: () => Effect.succeed(null),
+    isLoggedIn: () => Effect.succeed(true)
+  })
+)
+
+const SyncEngineLayer = Layer.succeed(
+  SyncEngine,
+  SyncEngine.of({
+    pull: () => Effect.die("SyncEngine should not be called"),
+    push: () => Effect.die("SyncEngine should not be called"),
+    status: () => Effect.die("SyncEngine should not be called")
+  })
+)
+
+const MarkdownConverterLayer = Layer.succeed(
+  MarkdownConverter,
+  MarkdownConverter.of({
+    adfToMarkdown: () => Effect.succeed("# Harness Page\n"),
+    markdownToAdf: () => Effect.die("markdownToAdf should not be called")
+  })
+)
+
+const DummyConfluenceClientLayer = Layer.succeed(
+  ConfluenceClient,
+  ConfluenceClient.of({
+    getPage: () => Effect.die("Use an injected fetch client layer in command tests"),
+    getChildren: () => Effect.die("ConfluenceClient should not be called"),
+    getAllChildren: () => Effect.die("ConfluenceClient should not be called"),
+    createPage: () => Effect.die("ConfluenceClient should not be called"),
+    updatePage: () => Effect.die("ConfluenceClient should not be called"),
+    deletePage: () => Effect.die("ConfluenceClient should not be called"),
+    getPageVersions: () => Effect.die("ConfluenceClient should not be called"),
+    getUser: () => Effect.die("ConfluenceClient should not be called"),
+    getSpaceId: () => Effect.die("ConfluenceClient should not be called"),
+    setEditorVersion: () => Effect.die("ConfluenceClient should not be called")
+  })
+)
+
+const ConfigLayer = ConfluenceConfigLayerFromValues({
+  rootPageId: "dummy" as PageId,
+  baseUrl: "https://dummy.atlassian.net",
+  docsPath: ".confluence/docs",
+  excludePatterns: [],
+  saveSource: false,
+  trackedPaths: ["**/*.md"]
+})
+
+export const CommandHarnessLayer = (refs: CommandHarnessRefs) =>
+  Layer.mergeAll(
+    AuthLayer,
+    GitShouldNotBeCalledLayer(refs.gitCalls),
+    SyncEngineLayer,
+    MarkdownConverterLayer,
+    DummyConfluenceClientLayer,
+    ConfigLayer,
+    CaptureTerminalLayer(refs.stdout)
+  )
+
+export const runConfluenceCommand = (
+  args: ReadonlyArray<string>,
+  options: ConfluenceCommandOptions = {}
+) => {
+  const cli = Command.runWith(makeConfluenceCommand(options), { version: "0.0.0-test" })
+  return cli(args).pipe(Effect.exit)
+}

package/test/fetch.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "@effect/vitest"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import type { PageId } from "../src/Brand.js"
+import { fetchPageMarkdown } from "../src/commands/fetch.js"
+import { ConfluenceClient } from "../src/ConfluenceClient.js"
+import { MarkdownConverter } from "../src/MarkdownConverter.js"
+import type { PageResponse } from "../src/Schemas.js"
+
+const page: PageResponse = {
+  id: "2333334354",
+  title: "Fetched Page",
+  version: { number: 7 },
+  body: {
+    atlas_doc_format: {
+      representation: "atlas_doc_format",
+      value: JSON.stringify({ type: "doc", version: 1, content: [] })
+    }
+  }
+}
+
+const TestLayer = Layer.mergeAll(
+  Layer.succeed(
+    ConfluenceClient,
+    ConfluenceClient.of({
+      getPage: () => Effect.succeed(page),
+      getChildren: () => Effect.die("unused"),
+      getAllChildren: () => Effect.die("unused"),
+      createPage: () => Effect.die("unused"),
+      updatePage: () => Effect.die("unused"),
+      deletePage: () => Effect.die("unused"),
+      getPageVersions: () => Effect.die("unused"),
+      getUser: () => Effect.die("unused"),
+      getSpaceId: () => Effect.die("unused"),
+      setEditorVersion: () => Effect.die("unused")
+    })
+  ),
+  Layer.succeed(
+    MarkdownConverter,
+    MarkdownConverter.of({
+      adfToMarkdown: () => Effect.succeed("# Fetched Page\n\n<!-- adf:panel attrs={} -->\n\nBody\n"),
+      markdownToAdf: () => Effect.die("unused")
+    })
+  )
+)
+
+describe("fetchPageMarkdown", () => {
+  it.effect("returns preserving markdown by default", () =>
+    Effect.gen(function*() {
+      const markdown = yield* fetchPageMarkdown("2333334354" as PageId, { cleanMarkdown: false })
+
+      expect(markdown).toContain("<!-- adf:panel attrs={} -->")
+    }).pipe(Effect.provide(TestLayer)))
+
+  it.effect("can return clean markdown", () =>
+    Effect.gen(function*() {
+      const markdown = yield* fetchPageMarkdown("2333334354" as PageId, { cleanMarkdown: true })
+
+      expect(markdown).toBe("# Fetched Page\n\nBody\n")
+    }).pipe(Effect.provide(TestLayer)))
+})

package/test/frontmatter.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "@effect/vitest"
+import * as Effect from "effect/Effect"
+import { ContentHash, PageId } from "../src/Brand.js"
+import { parseMarkdown, serializeMarkdown, serializeNewPageMarkdown } from "../src/internal/frontmatter.js"
+
+describe("frontmatter serialization", () => {
+  it.effect("serializes existing page frontmatter without gray-matter safeDump", () =>
+    Effect.gen(function*() {
+      const serialized = serializeMarkdown(
+        {
+          pageId: PageId("123"),
+          version: 7,
+          title: "A page",
+          updated: new Date("2026-06-24T10:00:00.000Z"),
+          parentId: PageId("456"),
+          contentHash: ContentHash("a".repeat(64))
+        },
+        "Body\n"
+      )
+
+      expect(serialized).toContain("pageId: '123'")
+      expect(serialized).toContain("version: 7")
+      expect(serialized).toContain("updated: '2026-06-24T10:00:00.000Z'")
+
+      const parsed = yield* parseMarkdown("page.md", serialized)
+      expect(parsed.isNew).toBe(false)
+      expect(parsed.content).toBe("Body")
+    }))
+
+  it("serializes new page frontmatter", () => {
+    const serialized = serializeNewPageMarkdown(
+      {
+        title: "New page",
+        parentId: PageId("456")
+      },
+      "Draft"
+    )
+
+    expect(serialized).toBe("---\ntitle: New page\nparentId: '456'\n---\nDraft\n")
+  })
+})