@knpkv/jira-cli 0.3.0 → 1.0.0

package/src/internal/sync/schemas.ts

@@ -0,0 +1,103 @@
+/**
+ * Runtime schemas for Jira Markdown Sync local workspace files.
+ *
+ * @internal
+ */
+import * as Effect from "effect/Effect"
+import * as Schema from "effect/Schema"
+import { FIELD_SHAPES } from "./types.js"
+
+const SiteUrl = Schema.String.pipe(
+  Schema.check(Schema.isPattern(/^https:\/\/[a-z0-9][a-z0-9-]*\.atlassian\.net$/))
+)
+
+const NonEmptyString = Schema.String.pipe(Schema.check(Schema.isMinLength(1)))
+
+export const FieldShapeSchema = Schema.Literals(FIELD_SHAPES)
+
+export const RequestedCustomFieldSchema = Schema.Struct({
+  displayName: NonEmptyString,
+  fieldId: Schema.optional(NonEmptyString),
+  shape: FieldShapeSchema,
+  ordered: Schema.optional(Schema.Boolean)
+})
+
+export const WorkspaceConfigSchema = Schema.Struct({
+  version: Schema.Literal(1).pipe(Schema.withDecodingDefaultTypeKey(Effect.succeed(1 as const))),
+  siteUrl: SiteUrl,
+  documentsDir: NonEmptyString.pipe(Schema.withDecodingDefaultTypeKey(Effect.succeed("issues"))),
+  customFields: Schema.Array(RequestedCustomFieldSchema).pipe(
+    Schema.withDecodingDefaultTypeKey(Effect.succeed([]))
+  )
+})
+
+export const ManifestIssueSchema = Schema.Struct({
+  issueId: NonEmptyString,
+  issueKey: NonEmptyString,
+  documentPath: NonEmptyString,
+  filenameMode: Schema.Literals(["convention", "custom"] as const)
+})
+
+export const SyncManifestSchema = Schema.Struct({
+  version: Schema.Literal(1),
+  siteUrl: SiteUrl,
+  issues: Schema.Array(ManifestIssueSchema)
+})
+
+const UserFieldValueSchema = Schema.Struct({
+  accountId: NonEmptyString,
+  displayName: NonEmptyString
+})
+
+const OptionFieldValueSchema = Schema.Struct({
+  id: Schema.optional(NonEmptyString),
+  value: NonEmptyString
+})
+
+const CascadingFieldValueSchema = Schema.Struct({
+  parent: OptionFieldValueSchema,
+  child: Schema.optional(OptionFieldValueSchema)
+})
+
+const SyncFieldValueItemSchema = Schema.Union([
+  Schema.String,
+  Schema.Number,
+  Schema.Boolean,
+  UserFieldValueSchema,
+  OptionFieldValueSchema
+])
+
+export const SyncFieldValueSchema = Schema.Union([
+  Schema.String,
+  Schema.Number,
+  Schema.Boolean,
+  Schema.Null,
+  UserFieldValueSchema,
+  OptionFieldValueSchema,
+  CascadingFieldValueSchema,
+  Schema.Array(SyncFieldValueItemSchema)
+])
+
+export const BaselineCustomFieldSchema = Schema.Struct({
+  fieldId: NonEmptyString,
+  displayName: NonEmptyString,
+  shape: FieldShapeSchema,
+  value: SyncFieldValueSchema
+})
+
+export const SyncBaselineSchema = Schema.Struct({
+  version: Schema.Literal(1),
+  issueId: NonEmptyString,
+  issueKey: NonEmptyString,
+  fields: Schema.Struct({
+    summary: Schema.String,
+    description: Schema.String,
+    labels: Schema.Array(Schema.String),
+    customFields: Schema.Record(Schema.String, BaselineCustomFieldSchema)
+  }),
+  comments: Schema.Array(Schema.Struct({ id: NonEmptyString }))
+})
+
+export type WorkspaceConfig = Schema.Schema.Type<typeof WorkspaceConfigSchema>
+export type SyncManifest = Schema.Schema.Type<typeof SyncManifestSchema>
+export type SyncBaseline = Schema.Schema.Type<typeof SyncBaselineSchema>

package/src/internal/sync/types.ts

@@ -0,0 +1,192 @@
+/**
+ * Core domain types for Jira Markdown Sync local workspace state.
+ *
+ * @internal
+ */
+
+export const FIELD_SHAPES = [
+  "text",
+  "multilineText",
+  "number",
+  "boolean",
+  "date",
+  "singleSelect",
+  "multiSelect",
+  "user",
+  "cascadingSelect"
+] as const
+
+export type FieldShape = typeof FIELD_SHAPES[number]
+
+export interface RequestedCustomField {
+  readonly displayName: string
+  readonly fieldId?: string | undefined
+  readonly shape: FieldShape
+  readonly ordered?: boolean | undefined
+}
+
+export interface WorkspaceConfig {
+  readonly version: 1
+  readonly siteUrl: string
+  readonly documentsDir: string
+  readonly customFields: ReadonlyArray<RequestedCustomField>
+}
+
+export type FilenameMode = "convention" | "custom"
+
+export interface ManifestIssue {
+  readonly issueId: string
+  readonly issueKey: string
+  readonly documentPath: string
+  readonly filenameMode: FilenameMode
+}
+
+export interface SyncManifest {
+  readonly version: 1
+  readonly siteUrl: string
+  readonly issues: ReadonlyArray<ManifestIssue>
+}
+
+export interface UserFieldValue {
+  readonly accountId: string
+  readonly displayName: string
+}
+
+export interface OptionFieldValue {
+  readonly id?: string | undefined
+  readonly value: string
+}
+
+export interface CascadingFieldValue {
+  readonly parent: OptionFieldValue
+  readonly child?: OptionFieldValue | undefined
+}
+
+export type SyncFieldScalar = string | number | boolean | null
+
+export type SyncFieldValue =
+  | SyncFieldScalar
+  | UserFieldValue
+  | OptionFieldValue
+  | CascadingFieldValue
+  | ReadonlyArray<string | number | boolean | UserFieldValue | OptionFieldValue>
+
+export interface BaselineCustomField {
+  readonly fieldId: string
+  readonly displayName: string
+  readonly shape: FieldShape
+  readonly value: SyncFieldValue
+}
+
+export interface SyncBaselineFields {
+  readonly summary: string
+  readonly description: string
+  readonly labels: ReadonlyArray<string>
+  readonly customFields: Readonly<Record<string, BaselineCustomField>>
+}
+
+export interface SyncBaselineComment {
+  readonly id: string
+}
+
+export interface SyncBaseline {
+  readonly version: 1
+  readonly issueId: string
+  readonly issueKey: string
+  readonly fields: SyncBaselineFields
+  readonly comments: ReadonlyArray<SyncBaselineComment>
+}
+
+export interface IssueDocumentFrontMatter {
+  readonly issueId: string
+  readonly issueKey: string
+  readonly summary: string
+  readonly status: string
+  readonly issueType: string
+  readonly priority: string | null
+  readonly assignee: UserFieldValue | null
+  readonly reporter: UserFieldValue | null
+  readonly labels: ReadonlyArray<string>
+  readonly customFields: Readonly<Record<string, SyncFieldValue>>
+}
+
+export interface CommentDraft {
+  readonly draftId: string
+  readonly body: string
+}
+
+export interface AcceptedComment {
+  readonly id: string
+  readonly author: string
+  readonly created: string
+  readonly body: string
+}
+
+export interface AttachmentReference {
+  readonly filename: string
+  readonly url: string
+}
+
+export interface IssueDocument {
+  readonly frontMatter: IssueDocumentFrontMatter
+  readonly description: string
+  readonly multilineCustomFields: Readonly<Record<string, string>>
+  readonly commentDrafts: ReadonlyArray<CommentDraft>
+  readonly acceptedComments: ReadonlyArray<AcceptedComment>
+  readonly attachments: ReadonlyArray<AttachmentReference>
+  readonly localNotes: string
+}
+
+export type SyncFieldPath =
+  | "summary"
+  | "description"
+  | "labels"
+  | `customFields.${string}`
+  | `readOnly.${string}`
+
+export interface SyncValidationFailure {
+  readonly _tag: "ValidationFailure"
+  readonly message: string
+  readonly issueKey?: string
+  readonly field?: SyncFieldPath
+  readonly path?: string
+}
+
+export interface SyncConflict {
+  readonly issueId: string
+  readonly issueKey: string
+  readonly field: SyncFieldPath
+  readonly baselineValue: SyncFieldValue
+  readonly jiraValue: SyncFieldValue
+  readonly documentValue: SyncFieldValue
+}
+
+export type PlannedFieldChange =
+  | {
+    readonly _tag: "RemoteOnly"
+    readonly issueId: string
+    readonly issueKey: string
+    readonly field: SyncFieldPath
+    readonly jiraValue: SyncFieldValue
+  }
+  | {
+    readonly _tag: "LocalOnly"
+    readonly issueId: string
+    readonly issueKey: string
+    readonly field: SyncFieldPath
+    readonly documentValue: SyncFieldValue
+  }
+  | {
+    readonly _tag: "Conflict"
+    readonly issueId: string
+    readonly issueKey: string
+    readonly field: SyncFieldPath
+    readonly baselineValue: SyncFieldValue
+    readonly jiraValue: SyncFieldValue
+    readonly documentValue: SyncFieldValue
+  }
+
+export interface SyncPlan {
+  readonly changes: ReadonlyArray<PlannedFieldChange>
+  readonly validationFailures: ReadonlyArray<SyncValidationFailure>
+}

package/test/SyncWorkspace.test.ts

@@ -0,0 +1,76 @@
+import * as NodeServices from "@effect/platform-node/NodeServices"
+import { describe, expect, it } from "@effect/vitest"
+import * as Effect from "effect/Effect"
+import * as FileSystem from "effect/FileSystem"
+import * as Layer from "effect/Layer"
+import * as Path from "effect/Path"
+import type { SyncBaseline } from "../src/internal/sync/types.js"
+import { layer as SyncWorkspaceLayer, SyncWorkspace } from "../src/SyncWorkspace.js"
+
+const TestLayer = SyncWorkspaceLayer.pipe(
+  Layer.provide(NodeServices.layer),
+  Layer.provideMerge(NodeServices.layer)
+)
+
+const makeTempRoot = Effect.gen(function*() {
+  const fs = yield* FileSystem.FileSystem
+  return yield* fs.makeTempDirectoryScoped()
+})
+
+describe("SyncWorkspace", () => {
+  it.effect("initializes workspace metadata and visible documents directory", () =>
+    Effect.gen(function*() {
+      const root = yield* makeTempRoot
+      const workspace = yield* SyncWorkspace
+      const paths = yield* workspace.init({ root, siteUrl: "https://example.atlassian.net" })
+      const fs = yield* FileSystem.FileSystem
+
+      expect(yield* fs.exists(paths.documentsDir)).toBe(true)
+      expect(yield* fs.exists(paths.configFile)).toBe(true)
+      expect(yield* fs.exists(paths.manifestFile)).toBe(true)
+      expect(yield* fs.exists(paths.baselinesDir)).toBe(true)
+      expect(yield* fs.exists(paths.historyDir)).toBe(true)
+
+      const config = yield* workspace.readConfig(root)
+      const manifest = yield* workspace.readManifest(root)
+      expect(config.siteUrl).toBe("https://example.atlassian.net")
+      expect(config.documentsDir).toBe("issues")
+      expect(manifest.issues).toEqual([])
+    }).pipe(Effect.provide(TestLayer), Effect.scoped))
+
+  it.effect("writes and reads baselines by issue id", () =>
+    Effect.gen(function*() {
+      const root = yield* makeTempRoot
+      const workspace = yield* SyncWorkspace
+      yield* workspace.init({ root, siteUrl: "https://example.atlassian.net" })
+
+      const baseline: SyncBaseline = {
+        version: 1,
+        issueId: "100123",
+        issueKey: "PROJ-123",
+        fields: {
+          summary: "Fix checkout copy",
+          description: "Description",
+          labels: ["copy"],
+          customFields: {}
+        },
+        comments: []
+      }
+
+      yield* workspace.writeBaseline(root, baseline)
+      expect(yield* workspace.readBaseline(root, "100123")).toEqual(baseline)
+    }).pipe(Effect.provide(TestLayer), Effect.scoped))
+
+  it.effect("uses configured documents directory for convention document paths", () =>
+    Effect.gen(function*() {
+      const root = yield* makeTempRoot
+      const workspace = yield* SyncWorkspace
+      const path = yield* Path.Path
+      yield* workspace.init({ root, siteUrl: "https://example.atlassian.net" })
+      const config = yield* workspace.readConfig(root)
+      yield* workspace.writeConfig(root, { ...config, documentsDir: "issue-docs" })
+
+      const filePath = yield* workspace.conventionDocumentPath(root, "PROJ-123")
+      expect(filePath).toBe(path.join(root, "issue-docs", "PROJ-123.md"))
+    }).pipe(Effect.provide(TestLayer), Effect.scoped))
+})

package/test/commandTree.test.ts

@@ -0,0 +1,266 @@
+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 * as Terminal from "effect/Terminal"
+import { Command } from "effect/unstable/cli"
+import { issueCommand } from "../src/commands/issue.js"
+import { versionCommand } from "../src/commands/version.js"
+import { type Issue, IssueService } from "../src/IssueService.js"
+import { MarkdownWriter } from "../src/MarkdownWriter.js"
+import { type RelatedWork, type Version, VersionService } from "../src/VersionService.js"
+
+interface CommandCalls {
+  readonly issueGet: number
+  readonly issueSearch: number
+  readonly versionList: number
+  readonly versionGet: number
+  readonly versionUpdate: number
+  readonly relatedWorkList: number
+  readonly relatedWorkAdd: number
+  readonly writeMulti: number
+}
+
+const emptyCalls: CommandCalls = {
+  issueGet: 0,
+  issueSearch: 0,
+  relatedWorkAdd: 0,
+  relatedWorkList: 0,
+  versionGet: 0,
+  versionList: 0,
+  versionUpdate: 0,
+  writeMulti: 0
+}
+
+const sampleIssue: Issue = {
+  assignee: null,
+  attachments: [],
+  comments: [],
+  components: [],
+  created: new Date("2026-01-01T00:00:00.000Z"),
+  description: "",
+  fixVersions: [],
+  id: "10000",
+  key: "PROJ-123",
+  labels: [],
+  priority: null,
+  reporter: null,
+  status: "Done",
+  summary: "Sample issue",
+  type: "Task",
+  updated: new Date("2026-01-01T00:00:00.000Z"),
+  url: "https://example.atlassian.net/browse/PROJ-123"
+}
+
+const sampleVersion: Version = {
+  approvers: [],
+  archived: false,
+  contributors: [],
+  description: null,
+  driver: null,
+  id: "10042",
+  name: "1.0.0",
+  releaseDate: null,
+  released: false,
+  startDate: null,
+  tickets: [],
+  url: "https://example.atlassian.net/projects/PROJ/versions/10042"
+}
+
+const sampleRelatedWork: RelatedWork = {
+  category: "Communication",
+  relatedWorkId: "20000",
+  title: "Release notes",
+  url: "https://example.atlassian.net/wiki/spaces/PROJ/pages/123"
+}
+
+const CaptureTerminalLayer = (stdout: Ref.Ref<string>) =>
+  Layer.succeed(
+    Terminal.Terminal,
+    Terminal.Terminal.of({
+      columns: Effect.succeed(100),
+      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 CommandServicesLayer = (calls: Ref.Ref<CommandCalls>) =>
+  Layer.mergeAll(
+    Layer.succeed(
+      IssueService,
+      IssueService.of({
+        getByKey: () =>
+          Ref.update(calls, (state) => ({ ...state, issueGet: state.issueGet + 1 })).pipe(
+            Effect.as(sampleIssue)
+          ),
+        search: () => Effect.die("IssueService.search should not be called"),
+        searchAll: () =>
+          Ref.update(calls, (state) => ({ ...state, issueSearch: state.issueSearch + 1 })).pipe(
+            Effect.as([sampleIssue])
+          )
+      })
+    ),
+    Layer.succeed(
+      MarkdownWriter,
+      MarkdownWriter.of({
+        writeMulti: () => Ref.update(calls, (state) => ({ ...state, writeMulti: state.writeMulti + 1 })),
+        writeSingle: () => Effect.die("MarkdownWriter.writeSingle should not be called")
+      })
+    ),
+    Layer.succeed(
+      VersionService,
+      VersionService.of({
+        addRelatedWork: () =>
+          Ref.update(calls, (state) => ({ ...state, relatedWorkAdd: state.relatedWorkAdd + 1 })).pipe(
+            Effect.as(sampleRelatedWork)
+          ),
+        getVersion: () =>
+          Ref.update(calls, (state) => ({ ...state, versionGet: state.versionGet + 1 })).pipe(
+            Effect.as(sampleVersion)
+          ),
+        listProjectVersions: () =>
+          Ref.update(calls, (state) => ({ ...state, versionList: state.versionList + 1 })).pipe(
+            Effect.as([sampleVersion])
+          ),
+        listRelatedWork: () =>
+          Ref.update(calls, (state) => ({ ...state, relatedWorkList: state.relatedWorkList + 1 })).pipe(
+            Effect.as([sampleRelatedWork])
+          ),
+        updateVersion: () =>
+          Ref.update(calls, (state) => ({ ...state, versionUpdate: state.versionUpdate + 1 })).pipe(
+            Effect.as(sampleVersion)
+          )
+      })
+    )
+  )
+
+const runJiraCommand = (
+  args: ReadonlyArray<string>,
+  calls: Ref.Ref<CommandCalls>,
+  stdout: Ref.Ref<string>
+) => {
+  const command = Command.make("jira").pipe(
+    Command.withDescription("Jira CLI commands"),
+    Command.withSubcommands([issueCommand, versionCommand])
+  )
+  const cli = Command.runWith(command, { version: "0.0.0-test" })
+  return cli(args).pipe(
+    Effect.provide(Layer.merge(CommandServicesLayer(calls), CaptureTerminalLayer(stdout))),
+    Effect.exit
+  )
+}
+
+describe("Jira command tree", () => {
+  it.effect("exposes canonical issue commands and removes top-level issue aliases", () =>
+    Effect.gen(function*() {
+      const calls = yield* Ref.make(emptyCalls)
+      const getOutput = yield* Ref.make("")
+      const searchOutput = yield* Ref.make("")
+      const legacyGetOutput = yield* Ref.make("")
+      const legacySearchOutput = yield* Ref.make("")
+
+      const getExit = yield* runJiraCommand(["issue", "get", "PROJ-123"], calls, getOutput)
+      const searchExit = yield* runJiraCommand(["issue", "search", "project = PROJ"], calls, searchOutput)
+      const legacyGetExit = yield* runJiraCommand(["get", "PROJ-123"], calls, legacyGetOutput)
+      const legacySearchExit = yield* runJiraCommand(["search", "project = PROJ"], calls, legacySearchOutput)
+
+      expect(getExit._tag).toBe("Success")
+      expect(searchExit._tag).toBe("Success")
+      expect(legacyGetExit._tag).toBe("Failure")
+      expect(legacySearchExit._tag).toBe("Failure")
+
+      expect(yield* Ref.get(calls)).toMatchObject({
+        issueGet: 1,
+        issueSearch: 1,
+        writeMulti: 2
+      })
+    }))
+
+  it.effect("exposes canonical version commands and rejects legacy names", () =>
+    Effect.gen(function*() {
+      const calls = yield* Ref.make(emptyCalls)
+      const output = yield* Ref.make("")
+      const legacyViewOutput = yield* Ref.make("")
+      const legacySetOutput = yield* Ref.make("")
+      const legacyRelatedWorkOutput = yield* Ref.make("")
+
+      const listExit = yield* runJiraCommand(["version", "list", "--project", "PROJ"], calls, output)
+      const getExit = yield* runJiraCommand(["version", "get", "10042"], calls, output)
+      const updateExit = yield* runJiraCommand(
+        [
+          "version",
+          "update",
+          "10042",
+          "--description",
+          "Q3 release"
+        ],
+        calls,
+        output
+      )
+      const relatedWorkListExit = yield* runJiraCommand(
+        [
+          "version",
+          "related-work",
+          "list",
+          "10042"
+        ],
+        calls,
+        output
+      )
+      const relatedWorkAddExit = yield* runJiraCommand(
+        [
+          "version",
+          "related-work",
+          "add",
+          "10042",
+          "--title",
+          "Release notes",
+          "--url",
+          "https://example.atlassian.net/wiki/spaces/PROJ/pages/123"
+        ],
+        calls,
+        output
+      )
+      const legacyViewExit = yield* runJiraCommand(["version", "view", "10042"], calls, legacyViewOutput)
+      const legacySetExit = yield* runJiraCommand(
+        [
+          "version",
+          "set",
+          "10042",
+          "--description",
+          "Q3 release"
+        ],
+        calls,
+        legacySetOutput
+      )
+      const legacyRelatedWorkExit = yield* runJiraCommand(
+        [
+          "version",
+          "relatedwork",
+          "list",
+          "10042"
+        ],
+        calls,
+        legacyRelatedWorkOutput
+      )
+
+      expect(listExit._tag).toBe("Success")
+      expect(getExit._tag).toBe("Success")
+      expect(updateExit._tag).toBe("Success")
+      expect(relatedWorkListExit._tag).toBe("Success")
+      expect(relatedWorkAddExit._tag).toBe("Success")
+      expect(legacyViewExit._tag).toBe("Failure")
+      expect(legacySetExit._tag).toBe("Failure")
+      expect(legacyRelatedWorkExit._tag).toBe("Failure")
+
+      expect(yield* Ref.get(calls)).toMatchObject({
+        relatedWorkAdd: 1,
+        relatedWorkList: 1,
+        versionGet: 1,
+        versionList: 1,
+        versionUpdate: 1
+      })
+    }))
+})

package/test/frontmatter.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from "@effect/vitest"
+import * as yaml from "js-yaml"
+import { extractFrontMatter, serializeIssue } from "../src/internal/frontmatter.js"
+import type { Issue } from "../src/IssueService.js"
+
+/**
+ * Parse the YAML front-matter block of a serialized issue using js-yaml 4
+ * directly. We avoid gray-matter's default parser here because it calls the
+ * removed `safeLoad` — the same incompatibility this module works around.
+ */
+const parseFrontMatter = (output: string): Record<string, unknown> => {
+  const match = output.match(/^---\n([\s\S]*?)\n---/)
+  return match ? (yaml.load(match[1]) as Record<string, unknown>) : {}
+}
+
+const makeIssue = (overrides: Partial<Issue> = {}): Issue => ({
+  key: "OOB-81",
+  id: "10081",
+  summary: "Test ticket",
+  status: "Done",
+  type: "Story",
+  priority: "High",
+  assignee: "Alice",
+  reporter: "Bob",
+  created: new Date("2026-01-01T00:00:00.000Z"),
+  updated: new Date("2026-02-01T00:00:00.000Z"),
+  fixVersions: ["OOB 81"],
+  labels: ["a", "b"],
+  components: ["x"],
+  description: "Hello",
+  attachments: [],
+  comments: [],
+  ...overrides
+})
+
+describe("frontmatter", () => {
+  describe("serializeIssue", () => {
+    // Regression: gray-matter's default YAML engine calls js-yaml's removed
+    // `safeDump`, which throws under the workspace's js-yaml 4 override. The
+    // custom engine must serialize without throwing.
+    it("serializes without throwing under js-yaml 4", () => {
+      expect(() => serializeIssue(makeIssue())).not.toThrow()
+    })
+
+    it("produces parseable YAML front-matter round-tripping the data", () => {
+      const output = serializeIssue(makeIssue())
+      const data = parseFrontMatter(output)
+      expect(data.key).toBe("OOB-81")
+      expect(data.fixVersions).toEqual(["OOB 81"])
+      expect(data.labels).toEqual(["a", "b"])
+      expect(output).toContain("# OOB-81: Test ticket")
+    })
+
+    it("emits null for absent optional fields", () => {
+      const output = serializeIssue(makeIssue({ priority: null, assignee: null, reporter: null }))
+      const data = parseFrontMatter(output)
+      expect(data.priority).toBeNull()
+      expect(data.assignee).toBeNull()
+    })
+  })
+
+  describe("extractFrontMatter", () => {
+    it("renders dates as ISO strings", () => {
+      const fm = extractFrontMatter(makeIssue())
+      expect(fm.created).toBe("2026-01-01T00:00:00.000Z")
+      expect(fm.updated).toBe("2026-02-01T00:00:00.000Z")
+    })
+  })
+})