@lovett/ui 0.0.11 → 0.2.0

package/src/thread/__tests__/markdown-spec.test.ts

@@ -0,0 +1,469 @@
+/**
+ * markdown-spec — the round-trip ADR-148 actually promises.
+ *
+ * AC#2 is PROPERTY-TESTED: a generator over D3's grammar (hand-rolled, seeded —
+ * no fast-check, no new dependency) produces markdown, and for every sample
+ * `parse → serialize → parse` yields an identical editor document and
+ * `serialize(parse(serialized)) === serialized`. Documents are compared after
+ * `normalizeRichDocument`, which is what `editor.setContent` produces — attrs
+ * with their defaults, content validated — so this is `editor.getJSON()`
+ * equality without a DOM.
+ *
+ * Deterministic on purpose (CLAUDE.md §7): the PRNG is mulberry32 with a fixed
+ * seed, so a failure names a reproducible sample.
+ */
+
+import { describe, expect, it } from 'vitest'
+import {
+  EMOJI_INPUT_RULE,
+  UNDERLINE_INPUT_RULE,
+  isRichEditable,
+  normalizeRichDocument,
+  parseRichMarkdown,
+  serializeRichMarkdown,
+} from '../markdown-spec'
+
+/* ── Seeded PRNG + generator over D3's grammar ────────────────────────────── */
+
+type Rng = () => number
+
+function mulberry32(seed: number): Rng {
+  let a = seed >>> 0
+  return () => {
+    a = (a + 0x6d2b79f5) >>> 0
+    let t = a
+    t = Math.imul(t ^ (t >>> 15), t | 1)
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61)
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296
+  }
+}
+
+function pick<T>(rng: Rng, items: readonly T[]): T {
+  const item = items[Math.floor(rng() * items.length)]
+  if (item === undefined) throw new Error('empty choice')
+  return item
+}
+
+function int(rng: Rng, min: number, max: number): number {
+  return min + Math.floor(rng() * (max - min + 1))
+}
+
+/** Plain words, plus words carrying LITERAL syntax already escaped as markdown. */
+const WORDS = [
+  'flight',
+  'pacing',
+  'brief',
+  'client',
+  'quarter',
+  'creative',
+  'holds',
+  'a\\*b',
+  'c\\_d',
+  'x\\[y\\]',
+  'p\\+\\+q',
+  '\\~t',
+  'v1.2',
+  'C\\+\\+',
+  'a&b',
+  'x<y',
+] as const
+
+const URLS = [
+  'https://example.com/plan',
+  'https://example.com/a?b=1&c=2',
+  'mailto:team@example.com',
+] as const
+
+const MENTIONS = [
+  '@[Marcus Webb](user:usr_9f2)',
+  '@[Slice B migration](task_item:tit_44a)',
+  '@[Board](task_board:tbd_1)',
+] as const
+
+type Wrap = 'bold' | 'italic' | 'underline' | 'strike'
+
+function word(rng: Rng): string {
+  return pick(rng, WORDS)
+}
+
+function inline(rng: Rng, depth: number, open: ReadonlySet<Wrap>, inLink: boolean): string {
+  const count = int(rng, 1, 3)
+  const parts: string[] = []
+  for (let index = 0; index < count; index += 1) {
+    // Inside a wrap, the FIRST item is never another wrap: an emphasis run
+    // that opens with a nested one (`***a* *b***`) is valid CommonMark that
+    // marked mis-parses — pinned below as a known limitation, kept out of
+    // the property by construction rather than by luck.
+    const first = index === 0 && open.size > 0
+    parts.push(first ? word(rng) : inlineItem(rng, depth, open, inLink))
+  }
+  return parts.join(' ')
+}
+
+function inlineItem(rng: Rng, depth: number, open: ReadonlySet<Wrap>, inLink: boolean): string {
+  const roll = rng()
+  if (depth >= 2 || roll < 0.45) return word(rng)
+  // A code span only where no mark is open: TipTap's `code` mark excludes
+  // every other mark, so emphasis or a link OVER a code span is outside what
+  // the schema can hold — the detector fails it closed (asserted below).
+  if (roll < 0.55 && open.size === 0 && !inLink) return `\`${word(rng).replace(/\\/g, '')}\``
+  if (roll < 0.63 && !inLink) return pick(rng, MENTIONS)
+  if (roll < 0.72 && !inLink) return `[${inline(rng, depth + 1, open, true)}](${pick(rng, URLS)})`
+  const wraps: readonly Wrap[] = (['bold', 'italic', 'underline', 'strike'] as const).filter(
+    (wrap) => !open.has(wrap),
+  )
+  if (wraps.length === 0) return word(rng)
+  const wrap = pick(rng, wraps)
+  const next = new Set(open)
+  next.add(wrap)
+  const inner = inline(rng, depth + 1, next, inLink)
+  switch (wrap) {
+    case 'bold':
+      return `**${inner}**`
+    case 'italic':
+      return `*${inner}*`
+    case 'underline':
+      return `++${inner}++`
+    case 'strike':
+      return `~~${inner}~~`
+  }
+}
+
+function block(rng: Rng): string {
+  const roll = rng()
+  const empty = new Set<Wrap>()
+  if (roll < 0.35) return inline(rng, 0, empty, false)
+  if (roll < 0.5) return `${'#'.repeat(int(rng, 1, 3))} ${inline(rng, 0, empty, false)}`
+  if (roll < 0.65) {
+    const items = int(rng, 1, 3)
+    return Array.from({ length: items }, () => `- ${inline(rng, 0, empty, false)}`).join('\n')
+  }
+  if (roll < 0.75) {
+    const items = int(rng, 1, 3)
+    return Array.from(
+      { length: items },
+      (_, index) => `${String(index + 1)}. ${inline(rng, 0, empty, false)}`,
+    ).join('\n')
+  }
+  if (roll < 0.85) return `> ${inline(rng, 0, empty, false)}`
+  if (roll < 0.93) {
+    const lang = pick(rng, ['', 'ts', 'sql'])
+    return `\`\`\`${lang}\nconst ${word(rng).replace(/\\/g, '')} = 1\n\`\`\``
+  }
+  return '---'
+}
+
+function document(rng: Rng): string {
+  const blocks = int(rng, 1, 4)
+  return Array.from({ length: blocks }, () => block(rng)).join('\n\n')
+}
+
+/** parse → serialize → parse identity, and the serialized form is a fixed point. */
+function assertRoundTrip(markdown: string): void {
+  const first = normalizeRichDocument(parseRichMarkdown(markdown))
+  const serialized = serializeRichMarkdown(first)
+  const second = normalizeRichDocument(parseRichMarkdown(serialized))
+  expect(second, `document drifted for:\n${markdown}\n→\n${serialized}`).toEqual(first)
+  expect(serializeRichMarkdown(second), `no fixed point for:\n${markdown}`).toBe(serialized)
+}
+
+describe('AC#2 — semantic round-trip is lossless for the subset (property)', () => {
+  it('holds for 300 generated documents', () => {
+    const rng = mulberry32(0x5eed)
+    for (let sample = 0; sample < 300; sample += 1) {
+      assertRoundTrip(document(rng))
+    }
+  })
+
+  it.each([
+    ['nested emphasis', '**bold with *italic inside* it**'],
+    ['italic wrapping bold', '*italic **bold** italic*'],
+    ['code span inside a list item', '- item with `code` in it\n- second'],
+    ['link text containing **', '[a **bold** label](https://example.com/plan)'],
+    ['a literal asterisk', 'a \\* b'],
+    ['++ inside **', '**bold ++underlined++ bold**'],
+    ['an h3 directly above a list', '### Title\n\n- one\n- two'],
+    ['a divider between paragraphs', 'first\n\n---\n\nsecond'],
+    ['a mention in running text', 'Flagging @[Priya Raman](user:u2) on the second one.'],
+    ['ordered list starting past one', '3. three\n4. four'],
+    ['blockquote with emphasis', '> a **quoted** line'],
+    ['hard break', 'line one  \nline two'],
+    ['fenced code with a language', '```ts\nconst a = 1\n```'],
+    ['emphasis spanning a mention', '*see @[Priya Raman](user:u2) here*'],
+    ['nested emphasis with interior spaces', '*a **b** c*'],
+    ['emphasis on a trailing space', '**bold **and more'],
+    ['a code span with boundary spaces', 'x ` y ` z'],
+  ])('%s', (_label, markdown) => {
+    assertRoundTrip(markdown)
+  })
+
+  it('canonicalizes spelling rather than preserving it (D3 rule 1)', () => {
+    const doc = normalizeRichDocument(parseRichMarkdown('_italic_ and __bold__\n\n* item'))
+    expect(serializeRichMarkdown(doc)).toBe('*italic* and **bold**\n\n- item')
+  })
+
+  it('KNOWN LIMITATION (marked): a bold run that opens with an italic and holds a second one', () => {
+    // CommonMark: strong(em(a) " " em(b)). marked 17 reads `***a* *b***` as
+    // one em(strong(...)) run, so the EDITOR shows a single bold-italic span
+    // where the renderer (micromark) shows two italics inside bold. The
+    // serializer's output is the correct CommonMark; the editor-side parse
+    // is where the loss happens. This pins the current behaviour so a marked
+    // fix — or a custom emphasis tokenizer — is noticed the day it lands.
+    const doc = normalizeRichDocument(parseRichMarkdown('***a* *b***'))
+    const nodes = doc.content?.[0]?.content ?? []
+    expect(nodes).toHaveLength(1)
+    expect(nodes[0]?.text).toBe('a* *b')
+    expect(nodes[0]?.marks?.map((mark) => mark.type).sort()).toEqual(['bold', 'italic'])
+  })
+
+  it('keeps emphasis boundaries off whitespace, and leaves nested emphasis alone', () => {
+    // Italic on the space beside a mention cannot be spelled; it moves off.
+    const spanning = normalizeRichDocument(parseRichMarkdown('*see @[Priya Raman](user:u2) here*'))
+    expect(serializeRichMarkdown(spanning)).toBe('*see* @[Priya Raman](user:u2) *here*')
+    // Interior spaces keep their marks: the bold run is all three nodes.
+    const nested = normalizeRichDocument(parseRichMarkdown('**bold with *italic inside* it**'))
+    expect(serializeRichMarkdown(nested)).toBe('**bold with *italic inside* it**')
+  })
+})
+
+describe('AC#4 — mention and underline syntax round-trip', () => {
+  it('parses @[Name](user:id) into a mention node and serializes it back byte-for-byte', () => {
+    const doc = normalizeRichDocument(parseRichMarkdown('Hi @[Marcus Webb](user:usr_9f2) there'))
+    const paragraph = doc.content?.[0]
+    const mention = paragraph?.content?.find((node) => node.type === 'mention')
+    expect(mention?.attrs).toMatchObject({ id: 'usr_9f2', label: 'Marcus Webb', type: 'user' })
+    expect(serializeRichMarkdown(doc)).toBe('Hi @[Marcus Webb](user:usr_9f2) there')
+  })
+
+  it.each(['task_item:tit_44a', 'task_board:tbd_1'])('accepts the %s scheme', (href) => {
+    const markdown = `See @[Slice B](${href}).`
+    const doc = normalizeRichDocument(parseRichMarkdown(markdown))
+    expect(doc.content?.[0]?.content?.some((node) => node.type === 'mention')).toBe(true)
+    expect(serializeRichMarkdown(doc)).toBe(markdown)
+  })
+
+  it('leaves an @[…](https://…) link alone — it is a link, not a mention', () => {
+    const markdown = 'ping @[x](https://example.com/x) please'
+    const doc = normalizeRichDocument(parseRichMarkdown(markdown))
+    const paragraph = doc.content?.[0]
+    expect(paragraph?.content?.some((node) => node.type === 'mention')).toBe(false)
+    const linked = paragraph?.content?.find((node) =>
+      (node.marks ?? []).some((mark) => mark.type === 'link'),
+    )
+    expect(linked?.text).toBe('x')
+    expect(serializeRichMarkdown(doc)).toBe(markdown)
+  })
+
+  it('leaves an unknown scheme alone', () => {
+    const markdown = '@[x](mailto:x@example.com)'
+    const doc = normalizeRichDocument(parseRichMarkdown(markdown))
+    expect(doc.content?.[0]?.content?.some((node) => node.type === 'mention')).toBe(false)
+    expect(serializeRichMarkdown(doc)).toBe(markdown)
+  })
+
+  it('escapes brackets in a mention label and reads them back', () => {
+    const doc = normalizeRichDocument(
+      parseRichMarkdown('@[Ops \\[west\\]](task_board:tbd_9)'),
+    )
+    const mention = doc.content?.[0]?.content?.find((node) => node.type === 'mention')
+    expect(mention?.attrs?.['label']).toBe('Ops [west]')
+    expect(serializeRichMarkdown(doc)).toBe('@[Ops \\[west\\]](task_board:tbd_9)')
+  })
+
+  it('parses ++text++ into an underline mark and serializes it back', () => {
+    const doc = normalizeRichDocument(parseRichMarkdown('a ++under lined++ b'))
+    const underlined = doc.content?.[0]?.content?.find((node) =>
+      (node.marks ?? []).some((mark) => mark.type === 'underline'),
+    )
+    expect(underlined?.text).toBe('under lined')
+    expect(serializeRichMarkdown(doc)).toBe('a ++under lined++ b')
+  })
+
+  it.each([
+    ['whitespace touching the markers', '++ x ++'],
+    ['whitespace before the closer', '++x ++'],
+    ['a marker alone', 'a ++ b'],
+    ['an unclosed opener', '++unclosed'],
+  ])('treats %s as literal text', (_label, markdown) => {
+    const doc = normalizeRichDocument(parseRichMarkdown(markdown))
+    const marks = doc.content?.[0]?.content?.flatMap((node) => node.marks ?? []) ?? []
+    expect(marks.some((mark) => mark.type === 'underline')).toBe(false)
+    expect(doc.content?.[0]?.content?.map((node) => node.text).join('')).toBe(markdown)
+  })
+
+  it('does not nest: the innermost pair wins and the outer markers stay literal', () => {
+    const doc = normalizeRichDocument(parseRichMarkdown('++a ++b++ c++'))
+    const nodes = doc.content?.[0]?.content ?? []
+    const underlined = nodes.filter((node) =>
+      (node.marks ?? []).some((mark) => mark.type === 'underline'),
+    )
+    expect(underlined.map((node) => node.text)).toEqual(['b'])
+    expect(nodes.map((node) => node.text).join('')).toBe('++a b c++')
+  })
+})
+
+describe('serialization escapes what the manager does not', () => {
+  const paragraph = (text: string) => ({
+    type: 'doc',
+    content: [{ type: 'paragraph', content: [{ type: 'text', text }] }],
+  })
+
+  it.each([
+    ['a literal ++ run', 'a++b++c', 'a\\+\\+b\\+\\+c'],
+    ['a leading #', '# not a heading', '\\# not a heading'],
+    ['a leading dash', '- not a list', '\\- not a list'],
+    ['a leading plus', '+ not a list', '\\+ not a list'],
+    ['a leading number', '1. not a list', '1\\. not a list'],
+    ['a dashed rule', '---', '\\---'],
+    ['a leading >', '> not a quote', '&gt; not a quote'],
+  ])('%s survives serialize → parse unchanged', (_label, text, expected) => {
+    const doc = normalizeRichDocument(paragraph(text))
+    const serialized = serializeRichMarkdown(doc)
+    expect(serialized).toBe(expected)
+    expect(normalizeRichDocument(parseRichMarkdown(serialized))).toEqual(doc)
+  })
+
+  it('escapes a block starter after a hard break, not only at the paragraph start', () => {
+    const doc = normalizeRichDocument({
+      type: 'doc',
+      content: [
+        {
+          type: 'paragraph',
+          content: [
+            { type: 'text', text: 'first' },
+            { type: 'hardBreak' },
+            { type: 'text', text: '# second' },
+          ],
+        },
+      ],
+    })
+    const serialized = serializeRichMarkdown(doc)
+    expect(normalizeRichDocument(parseRichMarkdown(serialized))).toEqual(doc)
+  })
+
+  it('leaves code alone', () => {
+    const doc = normalizeRichDocument({
+      type: 'doc',
+      content: [
+        { type: 'codeBlock', attrs: { language: null }, content: [{ type: 'text', text: '# ++x++' }] },
+        {
+          type: 'paragraph',
+          content: [{ type: 'text', text: '++x++', marks: [{ type: 'code' }] }],
+        },
+      ],
+    })
+    expect(serializeRichMarkdown(doc)).toBe('```\n# ++x++\n```\n\n`++x++`')
+  })
+
+  it('drops a stray private-use sentinel from user text instead of turning it into a backslash', () => {
+    const doc = normalizeRichDocument(paragraph('a\u{E000}b'))
+    expect(serializeRichMarkdown(doc)).toBe('ab')
+  })
+})
+
+describe('AC#3 — unsupported markdown never enters the rich editor', () => {
+  it.each([
+    ['a table', '| a | b |\n|---|---|\n| 1 | 2 |'],
+    ['an h4', '#### deep heading'],
+    ['an h6', '###### deeper'],
+    ['block raw HTML', '<div>hi</div>'],
+    ['inline raw HTML', 'a <u>b</u> c'],
+    ['a script tag', '<script>alert(1)</script>'],
+    ['a task list', '- [ ] todo\n- [x] done'],
+    ['an image', '![alt](https://example.com/x.png)'],
+    ['a table nested in a quote', '> | a |\n> |---|\n> | 1 |'],
+    ['an h4 inside a list', '- #### nope'],
+    // TipTap's `code` mark excludes all other marks: the schema cannot hold
+    // emphasis or a link over a code span, so these fail closed rather than
+    // silently dropping the outer mark.
+    ['a code span inside emphasis', '*see `x` here*'],
+    ['a code span inside a link', '[see `x`](https://example.com)'],
+  ])('%s fails closed', (_label, markdown) => {
+    expect(isRichEditable(markdown)).toBe(false)
+  })
+
+  it.each([
+    ['an empty body', ''],
+    ['a plain paragraph', 'Looks right to me.'],
+    ['every subset construct at once',
+      '# Title\n\n## Sub\n\n### Third\n\n**b** *i* ++u++ ~~s~~ `c` [l](https://example.com)\n\n- a\n- b\n\n1. one\n\n> quote\n\n```\ncode\n```\n\n---\n\n@[Marcus Webb](user:usr_1) line  \nbreak'],
+    ['non-canonical spelling', '_italic_ and __bold__\n\n* item'],
+    ['malformed inline syntax (CommonMark says it is text)', 'hello [ and ](url) and `world and **bold'],
+    ['an unclosed fence', '```\nnever closed'],
+    ['an invalid mention target (it is a link)', '@[foo](user:not-valid) and @[x](nope:1)'],
+    ['an autolink', '<https://example.com>'],
+    ['an entity', 'a &lt; b'],
+  ])('%s opens rich', (_label, markdown) => {
+    expect(isRichEditable(markdown)).toBe(true)
+  })
+})
+
+describe('input rules — markdown that formats AS YOU TYPE', () => {
+  /**
+   * Owner, 2026-09-07: "is it not like obsidian where you type them in and it
+   * autoformats for you as you type?" It is, for everything StarterKit ships.
+   * The local underline mark (D13) had commands, a shortcut and full markdown
+   * serialization and NO input rule, so `++text++` was the one thing that did
+   * nothing as you typed.
+   *
+   * What is pinned here is the PATTERN. Input rules fire on real text input,
+   * which jsdom cannot faithfully simulate (`insertContent` bypasses them
+   * entirely), so an end-to-end test here would assert nothing. All thirteen
+   * shortcuts were verified in a real browser instead; the regex is where a
+   * bug would actually live, and that is testable.
+   */
+  const fires = (typed: string): boolean => UNDERLINE_INPUT_RULE.test(typed)
+
+  it('fires on a well-formed run, at the line start or after whitespace', () => {
+    expect(fires('++under++')).toBe(true)
+    expect(fires('see ++under++')).toBe(true)
+  })
+
+  it('does NOT fire on code — the flanking rule, not "no spaces"', () => {
+    // The defect this guards: a whitespace-only rule underlined "; j" here.
+    expect(fires('i++; j++;')).toBe(false)
+    expect(fires('C++')).toBe(false)
+    expect(fires('x = i++')).toBe(false)
+  })
+
+  it('does NOT fire with whitespace inside the markers', () => {
+    expect(fires('++ under++')).toBe(false)
+    expect(fires('++under ++')).toBe(false)
+  })
+
+  it('does NOT match greedily across several runs or a +++ run', () => {
+    expect(fires('+++x+++')).toBe(false)
+    // `[^+]+` stops the content swallowing a second pair.
+    const m = UNDERLINE_INPUT_RULE.exec('a ++one++')
+    expect(m?.[2]).toBe('one')
+  })
+
+  it('only fires at the END of the typed run — it is an input rule', () => {
+    expect(fires('++under++ trailing')).toBe(false)
+  })
+
+  describe('closing-colon emoji shortcodes', () => {
+    const converts = (typed: string): boolean => EMOJI_INPUT_RULE(typed) !== null
+
+    it('matches canonical names and aliases at a text boundary', () => {
+      expect(converts(':tada:')).toBe(true)
+      expect(converts('ship it :side-eye:')).toBe(true)
+      expect(converts(':side_eye:')).toBe(true)
+      expect(converts(':TADA:')).toBe(true)
+    })
+
+    it('does not match a shape the shortcode table does not actually hold', () => {
+      expect(converts(':not_a_real_emoji:')).toBe(false)
+      // `ship` is a SEARCH keyword for `tada`, not a declared shortcode.
+      expect(converts(':ship:')).toBe(false)
+    })
+
+    it('leaves incomplete, spaced, and embedded prose literal', () => {
+      expect(converts(':')).toBe(false)
+      expect(converts(':tada')).toBe(false)
+      expect(converts(':side eye:')).toBe(false)
+      expect(converts('prefix:tada:')).toBe(false)
+      expect(converts(':tada: trailing')).toBe(false)
+    })
+  })
+})

package/src/thread/__tests__/relative-time.test.ts

@@ -0,0 +1,71 @@
+// @vitest-environment node
+/**
+ * ADR-147 D16 — relative time is a PURE function of (value, now).
+ * Nothing here reads a clock, which is the whole point: a component that calls
+ * Date.now() while rendering cannot be frozen from outside and cannot be
+ * asserted on.
+ */
+
+import { describe, expect, it } from 'vitest'
+import {
+  formatAbsoluteTime,
+  formatRelativeTime,
+  toIsoTimestamp,
+} from '../relative-time'
+import { FIXTURE_NOW } from './fixtures/thread-fixture'
+
+const MINUTE = 60_000
+const HOUR = 60 * MINUTE
+const DAY = 24 * HOUR
+
+describe('formatRelativeTime', () => {
+  it('reads "now" under a minute', () => {
+    expect(formatRelativeTime(FIXTURE_NOW, FIXTURE_NOW, 'en-GB')).toBe('now')
+    expect(formatRelativeTime(FIXTURE_NOW - 59_000, FIXTURE_NOW, 'en-GB')).toBe('now')
+  })
+
+  it('counts minutes, hours, then days', () => {
+    expect(formatRelativeTime(FIXTURE_NOW - MINUTE, FIXTURE_NOW, 'en-GB')).toBe('1m')
+    expect(formatRelativeTime(FIXTURE_NOW - 59 * MINUTE, FIXTURE_NOW, 'en-GB')).toBe('59m')
+    expect(formatRelativeTime(FIXTURE_NOW - HOUR, FIXTURE_NOW, 'en-GB')).toBe('1h')
+    expect(formatRelativeTime(FIXTURE_NOW - 23 * HOUR, FIXTURE_NOW, 'en-GB')).toBe('23h')
+    expect(formatRelativeTime(FIXTURE_NOW - DAY, FIXTURE_NOW, 'en-GB')).toBe('1d')
+    expect(formatRelativeTime(FIXTURE_NOW - 6 * DAY, FIXTURE_NOW, 'en-GB')).toBe('6d')
+  })
+
+  it('crosses over to an absolute date at seven days', () => {
+    const label = formatRelativeTime(FIXTURE_NOW - 8 * DAY, FIXTURE_NOW, 'en-GB')
+    expect(label).not.toMatch(/^\d+d$/)
+    expect(label).toContain('Aug')
+  })
+
+  it('adds the year once the date is not in the current one', () => {
+    const label = formatRelativeTime(Date.UTC(2025, 0, 4), FIXTURE_NOW, 'en-GB')
+    expect(label).toContain('2025')
+  })
+
+  it('treats clock skew from the future as "now" rather than a negative age', () => {
+    expect(formatRelativeTime(FIXTURE_NOW + 5 * MINUTE, FIXTURE_NOW, 'en-GB')).toBe('now')
+  })
+
+  it('returns an empty string rather than NaN for unusable input', () => {
+    expect(formatRelativeTime(Number.NaN, FIXTURE_NOW, 'en-GB')).toBe('')
+  })
+})
+
+describe('toIsoTimestamp', () => {
+  it('carries the exact instant for the datetime attribute', () => {
+    expect(toIsoTimestamp(FIXTURE_NOW)).toBe('2026-09-06T12:00:00.000Z')
+  })
+
+  it('degrades to an empty string rather than throwing', () => {
+    expect(toIsoTimestamp(Number.POSITIVE_INFINITY)).toBe('')
+    expect(toIsoTimestamp(Number.NaN)).toBe('')
+  })
+})
+
+describe('formatAbsoluteTime', () => {
+  it('produces something unambiguous for the hover title', () => {
+    expect(formatAbsoluteTime(FIXTURE_NOW, 'en-GB')).toContain('2026')
+  })
+})