md-redline 0.1.0

package/src/lib/selection-resolver.ts

@@ -0,0 +1,37 @@
+import type { SelectionInfo } from '../types';
+import { getVisibleTextContent, getVisibleTextOffset } from './visible-text';
+
+export function resolveSelection(containerEl: HTMLElement): SelectionInfo | null {
+  const sel = window.getSelection();
+  if (!sel || sel.isCollapsed) return null;
+
+  const rawText = sel.toString();
+  const text = rawText.trim();
+  if (!text || text.length < 2) return null;
+
+  const range = sel.getRangeAt(0);
+  if (!containerEl.contains(range.commonAncestorContainer)) return null;
+
+  // Get surrounding context from the rendered text
+  const fullText = getVisibleTextContent(containerEl);
+  const selStart = getVisibleTextOffset(containerEl, range.startContainer, range.startOffset);
+
+  // Adjust for leading whitespace that trim() removed so context windows
+  // align with the trimmed anchor text, not the raw selection boundaries.
+  const leadingTrim = rawText.length - rawText.trimStart().length;
+  const adjustedStart = selStart + leadingTrim;
+  const selEnd = adjustedStart + text.length;
+
+  const contextBefore = fullText.slice(Math.max(0, adjustedStart - 40), adjustedStart);
+  const contextAfter = fullText.slice(selEnd, selEnd + 40);
+
+  const rect = range.getBoundingClientRect();
+
+  return {
+    text,
+    rect,
+    contextBefore,
+    contextAfter,
+    offset: adjustedStart,
+  };
+}

package/src/lib/settings.test.ts

@@ -0,0 +1,152 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { loadSettings, saveSettings, DEFAULT_SETTINGS, DEFAULT_TEMPLATES } from './settings';
+
+// Mock localStorage
+const store: Record<string, string> = {};
+const localStorageMock = {
+  getItem: vi.fn((key: string) => store[key] ?? null),
+  setItem: vi.fn((key: string, value: string) => {
+    store[key] = value;
+  }),
+  removeItem: vi.fn((key: string) => {
+    delete store[key];
+  }),
+  clear: vi.fn(() => {
+    for (const key in store) delete store[key];
+  }),
+  get length() {
+    return Object.keys(store).length;
+  },
+  key: vi.fn((i: number) => Object.keys(store)[i] ?? null),
+};
+Object.defineProperty(globalThis, 'localStorage', { value: localStorageMock, writable: true });
+
+beforeEach(() => {
+  localStorageMock.clear();
+  vi.clearAllMocks();
+});
+
+describe('loadSettings', () => {
+  it('returns defaults when nothing is stored', () => {
+    expect(loadSettings()).toEqual(DEFAULT_SETTINGS);
+  });
+
+  it('returns defaults when stored value is invalid JSON', () => {
+    store['md-redline-settings'] = 'not-json!!!';
+    expect(loadSettings()).toEqual(DEFAULT_SETTINGS);
+  });
+
+  it('returns defaults for empty object', () => {
+    store['md-redline-settings'] = '{}';
+    const result = loadSettings();
+    expect(result).toEqual(DEFAULT_SETTINGS);
+  });
+
+  it('preserves valid enableResolve value', () => {
+    store['md-redline-settings'] = JSON.stringify({ enableResolve: true });
+    expect(loadSettings().enableResolve).toBe(true);
+  });
+
+  it('falls back to default when enableResolve is not a boolean', () => {
+    store['md-redline-settings'] = JSON.stringify({ enableResolve: 'yes' });
+    expect(loadSettings().enableResolve).toBe(false);
+  });
+
+  it('preserves valid quickComment value', () => {
+    store['md-redline-settings'] = JSON.stringify({ quickComment: true });
+    expect(loadSettings().quickComment).toBe(true);
+  });
+
+  it('falls back to default when quickComment is not a boolean', () => {
+    store['md-redline-settings'] = JSON.stringify({ quickComment: 42 });
+    expect(loadSettings().quickComment).toBe(false);
+  });
+
+  it('preserves valid showTemplatesByDefault value', () => {
+    store['md-redline-settings'] = JSON.stringify({ showTemplatesByDefault: true });
+    expect(loadSettings().showTemplatesByDefault).toBe(true);
+  });
+
+  it('falls back to default when showTemplatesByDefault is not a boolean', () => {
+    store['md-redline-settings'] = JSON.stringify({ showTemplatesByDefault: null });
+    expect(loadSettings().showTemplatesByDefault).toBe(true);
+  });
+
+  it('preserves valid commentMaxLength', () => {
+    store['md-redline-settings'] = JSON.stringify({ commentMaxLength: 1000 });
+    expect(loadSettings().commentMaxLength).toBe(1000);
+  });
+
+  it('falls back to default for zero commentMaxLength', () => {
+    store['md-redline-settings'] = JSON.stringify({ commentMaxLength: 0 });
+    expect(loadSettings().commentMaxLength).toBe(1000);
+  });
+
+  it('falls back to default for negative commentMaxLength', () => {
+    store['md-redline-settings'] = JSON.stringify({ commentMaxLength: -10 });
+    expect(loadSettings().commentMaxLength).toBe(1000);
+  });
+
+  it('falls back to default for non-numeric commentMaxLength', () => {
+    store['md-redline-settings'] = JSON.stringify({ commentMaxLength: 'big' });
+    expect(loadSettings().commentMaxLength).toBe(1000);
+  });
+
+  it('preserves valid templates array', () => {
+    const templates = [{ label: 'Custom', text: 'Custom text' }];
+    store['md-redline-settings'] = JSON.stringify({ templates });
+    expect(loadSettings().templates).toEqual(templates);
+  });
+
+  it('falls back to default templates when templates is not an array', () => {
+    store['md-redline-settings'] = JSON.stringify({ templates: 'not-an-array' });
+    expect(loadSettings().templates).toEqual(DEFAULT_TEMPLATES);
+  });
+
+  it('handles missing new fields gracefully (migration from older version)', () => {
+    // Simulate stored settings from before enableResolve and quickComment existed
+    store['md-redline-settings'] = JSON.stringify({
+      templates: DEFAULT_TEMPLATES,
+      commentMaxLength: 1000,
+      showTemplatesByDefault: false,
+    });
+    const result = loadSettings();
+    expect(result.enableResolve).toBe(false);
+    expect(result.quickComment).toBe(false);
+    expect(result.commentMaxLength).toBe(1000);
+    expect(result.showTemplatesByDefault).toBe(false);
+  });
+
+  it('preserves a full valid settings object', () => {
+    const full = {
+      templates: [{ label: 'A', text: 'B' }],
+      commentMaxLength: 750,
+      showTemplatesByDefault: true,
+      enableResolve: true,
+      quickComment: true,
+    };
+    store['md-redline-settings'] = JSON.stringify(full);
+    expect(loadSettings()).toEqual(full);
+  });
+});
+
+describe('saveSettings', () => {
+  it('persists settings to localStorage', () => {
+    saveSettings(DEFAULT_SETTINGS);
+    expect(localStorageMock.setItem).toHaveBeenCalledWith(
+      'md-redline-settings',
+      JSON.stringify(DEFAULT_SETTINGS),
+    );
+  });
+
+  it('round-trips through load', () => {
+    const custom = {
+      ...DEFAULT_SETTINGS,
+      enableResolve: true,
+      quickComment: true,
+      commentMaxLength: 999,
+    };
+    saveSettings(custom);
+    expect(loadSettings()).toEqual(custom);
+  });
+});

package/src/lib/settings.ts

@@ -0,0 +1,78 @@
+export interface CommentTemplate {
+  label: string;
+  text: string;
+}
+
+export interface AppSettings {
+  templates: CommentTemplate[];
+  commentMaxLength: number;
+  showTemplatesByDefault: boolean;
+  /** Enable resolve/reopen workflow for human-to-human review. When off, comments are simply deleted after being addressed. */
+  enableResolve: boolean;
+  /** Skip the "Comment" button and go straight to the comment form when text is selected. */
+  quickComment: boolean;
+}
+
+export const DEFAULT_TEMPLATES: CommentTemplate[] = [
+  { label: 'Rewrite this', text: 'Rewrite this section — it needs to be clearer.' },
+  { label: 'Add detail', text: 'Add more detail here.' },
+  { label: 'Remove', text: 'Remove this — it is not needed.' },
+  { label: 'Needs example', text: 'Add an example to illustrate this.' },
+  { label: 'Too vague', text: 'This is too vague — be more specific.' },
+  { label: 'Fix formatting', text: 'Fix the formatting in this section.' },
+  { label: 'Factually wrong', text: 'This is factually incorrect — please verify and correct.' },
+  { label: 'Out of scope', text: 'This is out of scope — remove or move to a separate doc.' },
+];
+
+export const DEFAULT_SETTINGS: AppSettings = {
+  templates: DEFAULT_TEMPLATES,
+  commentMaxLength: 1000,
+  showTemplatesByDefault: true,
+  enableResolve: false,
+  quickComment: false,
+};
+
+const STORAGE_KEY = 'md-redline-settings';
+
+export function loadSettings(): AppSettings {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (!raw) return DEFAULT_SETTINGS;
+    const parsed = JSON.parse(raw);
+    return {
+      templates: Array.isArray(parsed.templates) ? parsed.templates : DEFAULT_SETTINGS.templates,
+      commentMaxLength:
+        typeof parsed.commentMaxLength === 'number' && parsed.commentMaxLength > 0
+          ? parsed.commentMaxLength
+          : DEFAULT_SETTINGS.commentMaxLength,
+      showTemplatesByDefault:
+        typeof parsed.showTemplatesByDefault === 'boolean'
+          ? parsed.showTemplatesByDefault
+          : DEFAULT_SETTINGS.showTemplatesByDefault,
+      enableResolve:
+        typeof parsed.enableResolve === 'boolean'
+          ? parsed.enableResolve
+          : DEFAULT_SETTINGS.enableResolve,
+      quickComment:
+        typeof parsed.quickComment === 'boolean'
+          ? parsed.quickComment
+          : DEFAULT_SETTINGS.quickComment,
+    };
+  } catch {
+    return DEFAULT_SETTINGS;
+  }
+}
+
+export function saveSettings(settings: AppSettings): void {
+  try {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(settings));
+  } catch {
+    // Storage unavailable
+  }
+  // Dual-write to disk (fire-and-forget)
+  import('./preferences-client')
+    .then(({ savePreferencesToDisk }) => {
+      savePreferencesToDisk({ settings: settings as unknown as Record<string, unknown> });
+    })
+    .catch(() => {});
+}

package/src/lib/shortcut-label.tsx

@@ -0,0 +1,18 @@
+/**
+ * Renders a shortcut string with ⇧ scaled up to match ⌘ visually.
+ */
+export function StyledShortcut({ text }: { text: string }) {
+  if (!text.includes('\u21e7')) return <>{text}</>;
+
+  const parts = text.split('\u21e7');
+  return (
+    <>
+      {parts.map((part, i) => (
+        <span key={i}>
+          {i > 0 && <span className="text-[1.3em] leading-none align-baseline">{'\u21e7'}</span>}
+          {part}
+        </span>
+      ))}
+    </>
+  );
+}

package/src/lib/themes.ts

@@ -0,0 +1,21 @@
+export interface ThemeDef {
+  key: string;
+  label: string;
+  colors: [string, string, string];
+}
+
+export const LIGHT_THEMES: ThemeDef[] = [
+  { key: 'light', label: 'Light', colors: ['#ffffff', '#4f46e5', '#f59e0b'] },
+  { key: 'sepia', label: 'Sepia', colors: ['#faf6f1', '#8b5e3c', '#d4a04a'] },
+  { key: 'solarized', label: 'Solarized', colors: ['#fdf6e3', '#268bd2', '#b58900'] },
+  { key: 'github', label: 'GitHub', colors: ['#ffffff', '#0969da', '#bf8700'] },
+];
+
+export const DARK_THEMES: ThemeDef[] = [
+  { key: 'dark', label: 'Dark', colors: ['#0f172a', '#818cf8', '#f59e0b'] },
+  { key: 'nord', label: 'Nord', colors: ['#2e3440', '#88c0d0', '#ebcb8b'] },
+  { key: 'rose-pine', label: 'Rosé Pine', colors: ['#191724', '#c4a7e7', '#f6c177'] },
+  { key: 'catppuccin', label: 'Catppuccin', colors: ['#1e1e2e', '#cba6f7', '#f9e2af'] },
+];
+
+export const ALL_THEMES: ThemeDef[] = [...LIGHT_THEMES, ...DARK_THEMES];

package/src/lib/visible-text.test.ts

@@ -0,0 +1,86 @@
+// @vitest-environment jsdom
+
+import { describe, expect, it } from 'vitest';
+import {
+  collectVisibleTextNodes,
+  getVisibleTextContent,
+  getVisibleTextOffset,
+} from './visible-text';
+
+describe('visible-text helpers', () => {
+  it('ignores hidden text containers such as svg defs and style tags', () => {
+    document.body.innerHTML = `
+      <div id="root">
+        Intro
+        <style>.x { color: red; }</style>
+        <svg>
+          <defs>marker text</defs>
+          <desc>diagram description</desc>
+          <text>Visible label</text>
+        </svg>
+        <script>console.log('ignore me')</script>
+        <span>Outro</span>
+      </div>
+    `;
+
+    const root = document.getElementById('root')!;
+    expect(getVisibleTextContent(root).replace(/\s+/g, ' ').trim()).toBe(
+      'Intro Visible label Outro',
+    );
+  });
+
+  it('collects only visible text nodes', () => {
+    document.body.innerHTML = `
+      <div id="root">
+        <span>Alpha</span>
+        <svg><metadata>hidden</metadata><text>Beta</text></svg>
+        <template>Gamma</template>
+        <span>Delta</span>
+      </div>
+    `;
+
+    const root = document.getElementById('root')!;
+    expect(
+      collectVisibleTextNodes(root)
+        .map((node) => node.textContent?.trim())
+        .filter(Boolean),
+    ).toEqual(['Alpha', 'Beta', 'Delta']);
+  });
+
+  it('computes offsets without counting hidden svg text', () => {
+    document.body.innerHTML =
+      '<div id="root"><span id="before">Alpha </span><svg><defs>hidden marker</defs><text>Beta</text></svg><span id="after"> Gamma</span></div>';
+
+    const root = document.getElementById('root')!;
+    const betaNode = root.querySelector('svg text')!.firstChild!;
+    const gammaNode = document.getElementById('after')!.firstChild!;
+
+    expect(getVisibleTextOffset(root, betaNode, 2)).toBe('Alpha '.length + 2);
+    expect(getVisibleTextOffset(root, gammaNode, 1)).toBe('Alpha Beta'.length + 1);
+  });
+
+  it('resolves Element targetNode with offset pointing to a child index', () => {
+    document.body.innerHTML =
+      '<div id="root"><span id="parent"><em>Hello</em><strong> World</strong></span></div>';
+
+    const root = document.getElementById('root')!;
+    const parent = document.getElementById('parent')!;
+
+    // offset=1 means the 2nd child node (<strong> World</strong>)
+    // Should resolve to the text node inside <strong> at offset 0
+    expect(getVisibleTextOffset(root, parent, 1)).toBe('Hello'.length);
+  });
+
+  it('resolves Element targetNode when offset === childNodes.length (after last child)', () => {
+    // Use a parent whose children are bare text nodes so the "after last child"
+    // path resolves without needing to descend through wrapper elements.
+    document.body.innerHTML = '<div id="root"><span id="parent">Hello World</span></div>';
+
+    const root = document.getElementById('root')!;
+    const parent = document.getElementById('parent')!;
+
+    // parent has 1 child text node "Hello World"; offset 1 === childNodes.length
+    // means "after last child" — should return end of the text node (length 11)
+    expect(getVisibleTextOffset(root, parent, parent.childNodes.length)).toBe('Hello World'.length);
+  });
+});

package/src/lib/visible-text.ts

@@ -0,0 +1,77 @@
+const HIDDEN_TEXT_ANCESTOR_TAGS = new Set([
+  'STYLE',
+  'SCRIPT',
+  'NOSCRIPT',
+  'TEMPLATE',
+  'TITLE',
+  'DESC',
+  'DEFS',
+  'METADATA',
+]);
+
+function shouldIgnoreTextNode(node: Text): boolean {
+  let el = node.parentElement;
+  while (el) {
+    if (HIDDEN_TEXT_ANCESTOR_TAGS.has(el.tagName.toUpperCase())) return true;
+    el = el.parentElement;
+  }
+  return false;
+}
+
+export function createVisibleTextWalker(root: Node): TreeWalker {
+  return document.createTreeWalker(root, NodeFilter.SHOW_TEXT, {
+    acceptNode: (node) =>
+      shouldIgnoreTextNode(node as Text) ? NodeFilter.FILTER_REJECT : NodeFilter.FILTER_ACCEPT,
+  });
+}
+
+export function collectVisibleTextNodes(root: Node): Text[] {
+  const walker = createVisibleTextWalker(root);
+  const textNodes: Text[] = [];
+  let node: Text | null;
+  while ((node = walker.nextNode() as Text | null)) {
+    textNodes.push(node);
+  }
+  return textNodes;
+}
+
+export function getVisibleTextContent(root: Node): string {
+  return collectVisibleTextNodes(root)
+    .map((node) => node.textContent || '')
+    .join('');
+}
+
+export function getVisibleTextOffset(root: Node, targetNode: Node, offset: number): number {
+  // When the target is an Element (not a Text node), the offset refers to
+  // the Nth child node.  Resolve to the corresponding text node so the
+  // walker can match it.
+  let resolvedNode = targetNode;
+  let resolvedOffset = offset;
+  if (targetNode.nodeType !== Node.TEXT_NODE && targetNode.childNodes.length > 0) {
+    if (offset < targetNode.childNodes.length) {
+      resolvedNode = targetNode.childNodes[offset];
+      resolvedOffset = 0;
+    } else {
+      // offset === childNodes.length means "after last child" — point to end of last text node
+      const last = targetNode.childNodes[targetNode.childNodes.length - 1];
+      resolvedNode = last;
+      resolvedOffset = last.textContent?.length ?? 0;
+    }
+    // If we landed on another element, descend to its first text node
+    while (resolvedNode.nodeType !== Node.TEXT_NODE && resolvedNode.firstChild) {
+      resolvedNode = resolvedNode.firstChild;
+      resolvedOffset = 0;
+    }
+  }
+
+  let total = 0;
+  const walker = createVisibleTextWalker(root);
+  let node: Node | null;
+  while ((node = walker.nextNode())) {
+    if (node === resolvedNode) {
+      return total + resolvedOffset;
+    }
+    total += node.textContent?.length || 0;
+  }
+  return total;
+}

package/src/main.tsx

@@ -0,0 +1,22 @@
+import { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+import { ThemeProvider } from 'next-themes';
+import { SettingsProvider } from './contexts/SettingsContext';
+import { ALL_THEMES } from './lib/themes';
+import App from './App';
+import './index.css';
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <ThemeProvider
+      attribute="data-theme"
+      defaultTheme="system"
+      themes={ALL_THEMES.map((t) => t.key)}
+      enableSystem={true}
+    >
+      <SettingsProvider>
+        <App />
+      </SettingsProvider>
+    </ThemeProvider>
+  </StrictMode>,
+);

package/src/markdown/pipeline.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect } from 'vitest';
+import { renderMarkdown } from './pipeline';
+
+describe('renderMarkdown', () => {
+  it('renders basic markdown (headings, paragraphs, bold, italic)', () => {
+    const md = '# Hello\n\nThis is **bold** and *italic*.';
+    const html = renderMarkdown(md);
+    expect(html).toContain('<h1>Hello</h1>');
+    expect(html).toContain('<strong>bold</strong>');
+    expect(html).toContain('<em>italic</em>');
+  });
+
+  it('renders GFM tables correctly', () => {
+    const md = '| A | B |\n| --- | --- |\n| 1 | 2 |';
+    const html = renderMarkdown(md);
+    expect(html).toContain('<table>');
+    expect(html).toContain('<th>A</th>');
+    expect(html).toContain('<td>1</td>');
+  });
+
+  it('renders strikethrough correctly', () => {
+    const md = '~~deleted~~';
+    const html = renderMarkdown(md);
+    expect(html).toContain('<del>deleted</del>');
+  });
+
+  it('allows <mark> elements with className', () => {
+    const md = '<mark class="highlight">important</mark>';
+    const html = renderMarkdown(md);
+    expect(html).toContain('<mark');
+    expect(html).toContain('important</mark>');
+    expect(html).toContain('class="highlight"');
+  });
+
+  it('strips <script> tags', () => {
+    const md = 'Hello <script>alert("xss")</script> world';
+    const html = renderMarkdown(md);
+    expect(html).not.toContain('<script>');
+    expect(html).not.toContain('alert');
+  });
+
+  it('strips <style> tags', () => {
+    const md = 'Hello <style>body{display:none}</style> world';
+    const html = renderMarkdown(md);
+    expect(html).not.toContain('<style>');
+    // rehype-sanitize removes the tag but may leave text content; the key
+    // guarantee is the <style> element itself is gone so no CSS executes.
+  });
+
+  it('strips onclick and other event handler attributes', () => {
+    const md = '<div onclick="alert(1)">click me</div>';
+    const html = renderMarkdown(md);
+    expect(html).not.toContain('onclick');
+    expect(html).toContain('click me');
+  });
+
+  it('preserves className attribute on elements', () => {
+    const md = '<span class="custom">text</span>';
+    const html = renderMarkdown(md);
+    expect(html).toContain('class="custom"');
+  });
+
+  it('handles YAML frontmatter (should not appear in output)', () => {
+    const md = '---\ntitle: Test\nauthor: Someone\n---\n\n# Content';
+    const html = renderMarkdown(md);
+    expect(html).not.toContain('title: Test');
+    expect(html).not.toContain('author: Someone');
+    expect(html).toContain('<h1>Content</h1>');
+  });
+
+  it('handles empty input', () => {
+    const html = renderMarkdown('');
+    expect(html).toBe('');
+  });
+
+  it('handles fenced code blocks', () => {
+    const md = '```js\nconsole.log("hi");\n```';
+    const html = renderMarkdown(md);
+    expect(html).toContain('<code');
+    expect(html).toContain('console.log');
+  });
+});

package/src/markdown/pipeline.ts

@@ -0,0 +1,33 @@
+import { unified } from 'unified';
+import remarkParse from 'remark-parse';
+import remarkFrontmatter from 'remark-frontmatter';
+import remarkGfm from 'remark-gfm';
+import remarkRehype from 'remark-rehype';
+import rehypeRaw from 'rehype-raw';
+import rehypeSanitize, { defaultSchema } from 'rehype-sanitize';
+import rehypeStringify from 'rehype-stringify';
+
+// Allow mark elements (used for comment highlights) and data-* attributes
+const sanitizeSchema = {
+  ...defaultSchema,
+  tagNames: [...(defaultSchema.tagNames || []), 'mark'],
+  attributes: {
+    ...defaultSchema.attributes,
+    mark: ['className', 'dataCommentIds'],
+    '*': [...(defaultSchema.attributes?.['*'] || []), 'className'],
+  },
+};
+
+const processor = unified()
+  .use(remarkParse)
+  .use(remarkFrontmatter, ['yaml', 'toml'])
+  .use(remarkGfm)
+  .use(remarkRehype, { allowDangerousHtml: true })
+  .use(rehypeRaw)
+  .use(rehypeSanitize, sanitizeSchema)
+  .use(rehypeStringify);
+
+export function renderMarkdown(markdown: string): string {
+  const file = processor.processSync(markdown);
+  return String(file);
+}

package/src/types.test.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect } from 'vitest';
+import { getEffectiveStatus } from './types';
+import type { MdComment } from './types';
+
+function makeComment(overrides: Partial<MdComment> = {}): MdComment {
+  return {
+    id: 'test-id',
+    anchor: 'some text',
+    text: 'a comment',
+    author: 'User',
+    timestamp: '2024-01-01T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
+describe('getEffectiveStatus', () => {
+  it("returns 'open' when status is 'open'", () => {
+    expect(getEffectiveStatus(makeComment({ status: 'open' }))).toBe('open');
+  });
+
+  it("returns 'resolved' when status is 'resolved'", () => {
+    expect(getEffectiveStatus(makeComment({ status: 'resolved' }))).toBe('resolved');
+  });
+
+  it("returns 'resolved' when status is 'accepted' (legacy backward compat)", () => {
+    const comment = makeComment();
+    // Cast to bypass type checking since 'accepted' is a legacy value
+    (comment as unknown as Record<string, unknown>).status = 'accepted';
+    expect(getEffectiveStatus(comment)).toBe('resolved');
+  });
+
+  it("returns 'resolved' when resolved boolean is true (legacy)", () => {
+    expect(getEffectiveStatus(makeComment({ resolved: true }))).toBe('resolved');
+  });
+
+  it("returns 'open' when no status and no resolved field", () => {
+    expect(getEffectiveStatus(makeComment())).toBe('open');
+  });
+
+  it("returns 'open' when status is undefined and resolved is false", () => {
+    expect(getEffectiveStatus(makeComment({ status: undefined, resolved: false }))).toBe('open');
+  });
+});