@abraca/mcp 1.9.1 → 2.3.0

package/src/converters/markdownToYjs.ts

@@ -1,932 +1,13 @@
-/**
- * Markdown → Y.js converter.
- * Ported from cou-sh/app/utils/markdownToYjs.ts with Vue dependency removed.
- */
-import * as Y from 'yjs'
-import type { PageMeta } from './types.ts'
-
-// ── Filename → readable label ────────────────────────────────────────────────
-
-export function filenameToLabel(raw: string): string {
-  const base = raw.replace(/\.[^.]+$/, '')
-  const spaced = base.replace(/([a-z])([A-Z])/g, '$1 $2')
-  const clean = spaced.replace(/[-_.]+/g, ' ').replace(/\s+/g, ' ').trim()
-  return clean.charAt(0).toUpperCase() + clean.slice(1)
-}
-
-// ── YAML frontmatter parser ──────────────────────────────────────────────────
-
-export interface FrontmatterResult {
-  title?: string
-  meta: Partial<PageMeta>
-  body: string
-}
-
-function coerceScalar(raw: string): string | number | boolean {
-  const trimmed = raw.trim()
-  if (trimmed === 'true') return true
-  if (trimmed === 'false') return false
-  const num = Number(trimmed)
-  if (!Number.isNaN(num) && trimmed !== '') return num
-  if ((trimmed.startsWith('"') && trimmed.endsWith('"'))
-    || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
-    return trimmed.slice(1, -1)
-  }
-  return trimmed
-}
-
-function parseInlineArray(raw: string): string[] {
-  return raw.slice(1, -1).split(',').map(s => s.trim()).filter(Boolean)
-}
-
-export function parseFrontmatter(markdown: string): FrontmatterResult {
-  const noResult: FrontmatterResult = { meta: {}, body: markdown }
-
-  const match = markdown.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/)
-  if (!match) return noResult
-
-  const yamlBlock = match[1]!
-  const body = markdown.slice(match[0].length)
-
-  const raw: Record<string, string | string[]> = {}
-  const lines = yamlBlock.split('\n')
-  let i = 0
-  while (i < lines.length) {
-    const line = lines[i]!
-    const blockSeqKey = line.match(/^(\w[\w-]*):\s*$/)
-    if (blockSeqKey && i + 1 < lines.length && /^\s+-\s/.test(lines[i + 1]!)) {
-      const key = blockSeqKey[1]!
-      const items: string[] = []
-      i++
-      while (i < lines.length && /^\s+-\s/.test(lines[i]!)) {
-        items.push(lines[i]!.replace(/^\s+-\s/, '').trim())
-        i++
-      }
-      raw[key] = items
-      continue
-    }
-    const kvMatch = line.match(/^(\w[\w-]*):\s*(.*)$/)
-    if (kvMatch) {
-      const key = kvMatch[1]!
-      const val = kvMatch[2]!.trim()
-      if (val.startsWith('[') && val.endsWith(']')) {
-        raw[key] = parseInlineArray(val)
-      } else {
-        raw[key] = val
-      }
-    }
-    i++
-  }
-
-  const meta: Partial<PageMeta> = {}
-
-  const getStr = (keys: string[]): string | undefined => {
-    for (const k of keys) {
-      const v = raw[k]
-      if (typeof v === 'string' && v) return v
-    }
-  }
-
-  if (raw['tags']) meta.tags = Array.isArray(raw['tags']) ? raw['tags'] : [raw['tags'] as string]
-  const color = getStr(['color'])
-  if (color) meta.color = color
-  const icon = getStr(['icon'])
-  if (icon) meta.icon = icon
-  const status = getStr(['status'])
-  if (status) meta.status = status
-
-  const priorityRaw = getStr(['priority'])
-  if (priorityRaw !== undefined) {
-    const map: Record<string, number> = { low: 1, medium: 2, high: 3, urgent: 4 }
-    meta.priority = map[priorityRaw.toLowerCase()] ?? (Number(priorityRaw) || 0)
-  }
-
-  const checkedRaw = raw['checked'] ?? raw['done']
-  if (checkedRaw !== undefined) meta.checked = checkedRaw === 'true' || checkedRaw === true
-
-  const dateStart = getStr(['date', 'created'])
-  if (dateStart) meta.dateStart = dateStart
-  const dateEnd = getStr(['due'])
-  if (dateEnd) meta.dateEnd = dateEnd
-
-  const subtitle = getStr(['description', 'subtitle'])
-  if (subtitle) meta.subtitle = subtitle
-  const url = getStr(['url'])
-  if (url) meta.url = url
-  const email = getStr(['email'])
-  if (email) meta.email = email
-  const phone = getStr(['phone'])
-  if (phone) meta.phone = phone
-
-  const ratingRaw = getStr(['rating'])
-  if (ratingRaw !== undefined) {
-    const n = Number(ratingRaw)
-    if (!Number.isNaN(n)) meta.rating = Math.min(5, Math.max(0, n))
-  }
-
-  // Datetime fields
-  const datetimeStart = getStr(['datetimeStart'])
-  if (datetimeStart) meta.datetimeStart = datetimeStart
-  const datetimeEnd = getStr(['datetimeEnd'])
-  if (datetimeEnd) meta.datetimeEnd = datetimeEnd
-  const allDayRaw = raw['allDay']
-  if (allDayRaw !== undefined) meta.allDay = allDayRaw === 'true' || allDayRaw === true
-
-  // Geo fields
-  const geoLatRaw = getStr(['geoLat'])
-  if (geoLatRaw !== undefined) { const n = Number(geoLatRaw); if (!Number.isNaN(n)) meta.geoLat = n }
-  const geoLngRaw = getStr(['geoLng'])
-  if (geoLngRaw !== undefined) { const n = Number(geoLngRaw); if (!Number.isNaN(n)) meta.geoLng = n }
-  const geoType = getStr(['geoType'])
-  if (geoType && (geoType === 'marker' || geoType === 'line' || geoType === 'measure')) {
-    meta.geoType = geoType
-  }
-  const geoDescription = getStr(['geoDescription'])
-  if (geoDescription) meta.geoDescription = geoDescription
-
-  // Numeric fields
-  const numberRaw = getStr(['number'])
-  if (numberRaw !== undefined) { const n = Number(numberRaw); if (!Number.isNaN(n)) meta.number = n }
-  const unit = getStr(['unit'])
-  if (unit) meta.unit = unit
-
-  // Note
-  const note = getStr(['note'])
-  if (note) meta.note = note
-
-  const title = typeof raw['title'] === 'string' ? raw['title'] : undefined
-
-  return { title, meta, body }
-}
-
-// ── Inline token parsing ─────────────────────────────────────────────────────
-
-interface InlineToken {
-  text: string
-  attrs?: Record<string, unknown>
-  /** If set, emit an inline Y.XmlElement with this nodeName instead of text+marks. */
-  node?: string
-  /** Attributes for the inline node (when node is set). */
-  nodeAttrs?: Record<string, string>
-}
-
-function parseInline(text: string): InlineToken[] {
-  const stripped = text.replace(/\{lang="[^"]*"\}/g, '')
-    .replace(/:(?!badge|icon|kbd)(\w[\w-]*)\[([^\]]*)\](\{[^}]*\})?/g, '$2')
-    .replace(/:(?!badge|icon|kbd)(\w[\w-]*)(\{[^}]*\})/g, '')
-
-  const tokens: InlineToken[] = []
-  const re = /:badge\[([^\]]*)\](\{[^}]*\})?|:icon\{([^}]*)\}|:kbd\{([^}]*)\}|!?\[\[([^\]|]+?)(?:\|([^\]]+?))?\]\]|~~(.+?)~~|\*\*(.+?)\*\*|\*(.+?)\*|_(.+?)_|`(.+?)`|\[(.+?)\]\((.+?)\)/g
-  let lastIndex = 0
-  let match: RegExpExecArray | null
-
-  while ((match = re.exec(stripped)) !== null) {
-    if (match.index > lastIndex) {
-      tokens.push({ text: stripped.slice(lastIndex, match.index) })
-    }
-    if (match[1] !== undefined) {
-      const badgeProps = parseMdcProps(match[2])
-      tokens.push({ text: match[1] || 'Badge', attrs: { badge: { label: match[1] || 'Badge', color: badgeProps['color'] || 'neutral', variant: badgeProps['variant'] || 'subtle' } } })
-    } else if (match[3] !== undefined) {
-      const iconProps = parseMdcProps(`{${match[3]}}`)
-      tokens.push({ text: '\u200B', attrs: { proseIcon: { name: iconProps['name'] || 'i-lucide-star' } } })
-    } else if (match[4] !== undefined) {
-      const kbdProps = parseMdcProps(`{${match[4]}}`)
-      tokens.push({ text: kbdProps['value'] || '', attrs: { kbd: { value: kbdProps['value'] || '' } } })
-    } else if (match[5] !== undefined) {
-      // Inline wikilink [[docId]] or [[docId|label]] → inline docLink node
-      // (the label is derived from the tree at render time; legacy label is dropped)
-      tokens.push({ text: '', node: 'docLink', nodeAttrs: { docId: match[5]! } })
-    } else if (match[7] !== undefined) {
-      tokens.push({ text: match[7], attrs: { strike: true } })
-    } else if (match[8] !== undefined) {
-      tokens.push({ text: match[8], attrs: { bold: true } })
-    } else if (match[9] !== undefined) {
-      tokens.push({ text: match[9], attrs: { italic: true } })
-    } else if (match[10] !== undefined) {
-      tokens.push({ text: match[10], attrs: { italic: true } })
-    } else if (match[11] !== undefined) {
-      tokens.push({ text: match[11], attrs: { code: true } })
-    } else if (match[12] !== undefined && match[13] !== undefined) {
-      tokens.push({ text: match[12], attrs: { link: { href: match[13] } } })
-    }
-    lastIndex = match.index + match[0].length
-  }
-
-  if (lastIndex < stripped.length) {
-    tokens.push({ text: stripped.slice(lastIndex) })
-  }
-  return tokens.filter(t => t.node || t.text.length > 0)
-}
-
-// ── Block-level parser ───────────────────────────────────────────────────────
-
-interface TaskItem {
-  text: string
-  checked: boolean
-}
-
-type Block =
-  | { type: 'heading'; level: number; text: string }
-  | { type: 'paragraph'; text: string }
-  | { type: 'bulletList'; items: string[] }
-  | { type: 'orderedList'; items: string[] }
-  | { type: 'taskList'; items: TaskItem[] }
-  | { type: 'codeBlock'; lang: string; code: string }
-  | { type: 'blockquote'; lines: string[] }
-  | { type: 'table'; headerRow: string[]; dataRows: string[][] }
-  | { type: 'hr' }
-  | { type: 'callout'; calloutType: string; innerBlocks: Block[] }
-  | { type: 'collapsible'; label: string; open: boolean; innerBlocks: Block[] }
-  | { type: 'steps'; innerBlocks: Block[] }
-  | { type: 'card'; title: string; icon: string; to: string; innerBlocks: Block[] }
-  | { type: 'cardGroup'; cards: Block[] }
-  | { type: 'codeCollapse'; codeBlocks: Block[] }
-  | { type: 'codeGroup'; codeBlocks: Block[] }
-  | { type: 'codePreview'; innerBlocks: Block[]; codeBlocks: Block[] }
-  | { type: 'codeTree'; files: string }
-  | { type: 'accordion'; items: { label: string; icon: string; innerBlocks: Block[] }[] }
-  | { type: 'tabs'; items: { label: string; icon: string; innerBlocks: Block[] }[] }
-  | { type: 'field'; name: string; fieldType: string; required: boolean; innerBlocks: Block[] }
-  | { type: 'fieldGroup'; fields: Block[] }
-  | { type: 'image'; src: string; alt: string; width?: string; height?: string }
-  | { type: 'docEmbed'; docId: string; seamless?: boolean }
-  | { type: 'svgEmbed'; svg: string; title: string }
-
-function parseTableRow(line: string): string[] {
-  const parts = line.split('|')
-  return parts.slice(1, parts.length - 1).map(c => c.trim())
-}
-
-function isTableSeparator(line: string): boolean {
-  return /^\|[\s|:-]+\|$/.test(line.trim())
-}
-
-function extractFencedCode(lines: string[]): Block[] {
-  const result: Block[] = []
-  let i = 0
-  while (i < lines.length) {
-    const line = lines[i]!
-    const fenceMatch = line.match(/^(`{3,})(\w*)/)
-    if (fenceMatch) {
-      const fence = fenceMatch[1]!
-      const lang = fenceMatch[2] ?? ''
-      const codeLines: string[] = []
-      i++
-      while (i < lines.length && !lines[i]!.startsWith(fence)) {
-        codeLines.push(lines[i]!)
-        i++
-      }
-      i++
-      result.push({ type: 'codeBlock', lang, code: codeLines.join('\n') })
-      continue
-    }
-    i++
-  }
-  return result
-}
-
-function parseMdcProps(propsStr: string | undefined): Record<string, string> {
-  if (!propsStr) return {}
-  const result: Record<string, string> = {}
-  const re = /(\w[\w-]*)="([^"]*)"/g
-  let m: RegExpExecArray | null
-  while ((m = re.exec(propsStr)) !== null) {
-    result[m[1]!] = m[2]!
-  }
-  return result
-}
-
-function parseMdcChildren(innerLines: string[], slotPrefix: string): { label: string; icon: string; innerBlocks: Block[] }[] {
-  const items: { label: string; icon: string; lines: string[] }[] = []
-  let current: { label: string; icon: string; lines: string[] } | null = null
-  const slotRe = new RegExp(`^#${slotPrefix}(\\{[^}]*\\})?\\s*$`)
-
-  for (const line of innerLines) {
-    const slotMatch = line.match(slotRe)
-    if (slotMatch) {
-      if (current) items.push(current)
-      const props = parseMdcProps(slotMatch[1])
-      current = { label: props['label'] || props['title'] || `Item ${items.length + 1}`, icon: props['icon'] || '', lines: [] }
-      continue
-    }
-    if (current) {
-      current.lines.push(line)
-    } else {
-      if (!items.length && !current) {
-        current = { label: `Item 1`, icon: '', lines: [line] }
-      }
-    }
-  }
-  if (current) items.push(current)
-
-  return items.map(item => ({
-    label: item.label,
-    icon: item.icon,
-    innerBlocks: parseBlocks(item.lines.join('\n')),
-  }))
-}
-
-const TASK_RE = /^[-*+]\s+\[([ xX])\]\s+(.*)/
-
-function parseBlocks(markdown: string): Block[] {
-  const rawLines = markdown.split('\n')
-  let firstContentLine = 0
-  while (firstContentLine < rawLines.length) {
-    const l = rawLines[firstContentLine]!
-    if (l.trim() === '' || /^import\s/.test(l) || /^export\s/.test(l)) {
-      firstContentLine++
-    } else {
-      break
-    }
-  }
-  const stripped = rawLines.slice(firstContentLine).join('\n')
-
-  const blocks: Block[] = []
-  const lines = stripped.split('\n')
-  let i = 0
-
-  while (i < lines.length) {
-    const line = lines[i]!
-
-    const fenceBlockMatch = line.match(/^(`{3,})(.*)$/)
-    if (fenceBlockMatch) {
-      const fence = fenceBlockMatch[1]!
-      const lang = fenceBlockMatch[2]!.trim()
-        .replace(/\{[^}]*\}$/, '')
-        .replace(/\s*\[.*\]$/, '')
-        .trim()
-      const codeLines: string[] = []
-      i++
-      while (i < lines.length && !lines[i]!.startsWith(fence)) {
-        codeLines.push(lines[i]!)
-        i++
-      }
-      i++
-      if (lang === 'svg' || lang.startsWith('svg ')) {
-        const svgTitle = lang === 'svg' ? '' : lang.slice(4).trim()
-        blocks.push({ type: 'svgEmbed', svg: codeLines.join('\n'), title: svgTitle })
-      } else {
-        blocks.push({ type: 'codeBlock', lang, code: codeLines.join('\n') })
-      }
-      continue
-    }
-
-    const headingMatch = line.match(/^(#{1,6})\s+(.*)/)
-    if (headingMatch) {
-      blocks.push({ type: 'heading', level: headingMatch[1]!.length, text: headingMatch[2]!.trim() })
-      i++
-      continue
-    }
-
-    if (/^[-*_]{3,}\s*$/.test(line)) {
-      blocks.push({ type: 'hr' })
-      i++
-      continue
-    }
-
-    const docEmbedMatch = line.match(/^!\[\[([^\]|]+?)(?:\|[^\]]*?)?\]\](\{[^}]*\})?\s*$/)
-    if (docEmbedMatch) {
-      const props = parseMdcProps(docEmbedMatch[2])
-      const seamless = 'seamless' in props || props['seamless'] === 'true' || /\{[^}]*\bseamless\b[^}]*\}/.test(docEmbedMatch[2] ?? '')
-      blocks.push({ type: 'docEmbed', docId: docEmbedMatch[1]!, seamless: seamless || undefined })
-      i++
-      continue
-    }
-
-    const imgMatch = line.match(/^!\[([^\]]*)\]\(([^)]+)\)(\{[^}]*\})?\s*$/)
-    if (imgMatch) {
-      const alt = imgMatch[1] ?? ''
-      const src = imgMatch[2] ?? ''
-      const attrs = parseMdcProps(imgMatch[3])
-      blocks.push({ type: 'image', src, alt, width: attrs['width'], height: attrs['height'] })
-      i++
-      continue
-    }
-
-    if (line.startsWith('> ') || line === '>') {
-      const bqLines: string[] = []
-      while (i < lines.length && (lines[i]!.startsWith('> ') || lines[i] === '>')) {
-        bqLines.push(lines[i]!.replace(/^>\s?/, ''))
-        i++
-      }
-      blocks.push({ type: 'blockquote', lines: bqLines })
-      continue
-    }
-
-    if (/^\s*\|/.test(line)) {
-      const tableLines: string[] = []
-      while (i < lines.length && /^\s*\|/.test(lines[i]!)) {
-        tableLines.push(lines[i]!)
-        i++
-      }
-      if (tableLines.length >= 2 && isTableSeparator(tableLines[1]!)) {
-        const headerRow = parseTableRow(tableLines[0]!)
-        const dataRows = tableLines.slice(2)
-          .filter(l => !isTableSeparator(l))
-          .map(parseTableRow)
-        blocks.push({ type: 'table', headerRow, dataRows })
-      } else {
-        for (const l of tableLines) blocks.push({ type: 'paragraph', text: l })
-      }
-      continue
-    }
-
-    const MDC_OPEN = /^\s*(:{2,})(\w[\w-]*)(\{[^}]*\})?\s*$/
-    if (MDC_OPEN.test(line)) {
-      const colons = line.match(/^\s*(:+)/)?.[1]?.length ?? 2
-      const componentName = line.match(/^\s*:{2,}(\w[\w-]*)/)?.[1] ?? ''
-      const innerLines: string[] = []
-      i++
-      while (i < lines.length) {
-        const l = lines[i]!
-        if (new RegExp(`^\\s*:{${colons}}\\s*$`).test(l)) { i++; break }
-        const innerFence = l.match(/^(\s*`{3,})/)
-        if (innerFence) {
-          const fenceStr = innerFence[1]!.trimStart()
-          innerLines.push(l)
-          i++
-          while (i < lines.length && !lines[i]!.trimStart().startsWith(fenceStr)) {
-            innerLines.push(lines[i]!)
-            i++
-          }
-          if (i < lines.length) { innerLines.push(lines[i]!); i++ }
-          continue
-        }
-        innerLines.push(l)
-        i++
-      }
-
-      const nonBlank = innerLines.filter(l => l.trim().length > 0)
-      if (nonBlank.length) {
-        const minIndent = Math.min(...nonBlank.map(l => l.match(/^(\s*)/)?.[1]?.length ?? 0))
-        if (minIndent > 0) {
-          for (let j = 0; j < innerLines.length; j++) {
-            innerLines[j] = innerLines[j]!.slice(Math.min(minIndent, innerLines[j]!.length))
-          }
-        }
-      }
-
-      let contentStart = 0
-      if (innerLines[0]?.trim() === '---') {
-        const fmEnd = innerLines.findIndex((l, idx) => idx > 0 && l.trim() === '---')
-        if (fmEnd !== -1) contentStart = fmEnd + 1
-      }
-      const contentLines = innerLines.slice(contentStart)
-
-      const defaultSlotLines: string[] = []
-      const codeSlotLines: string[] = []
-      let currentSlot: 'default' | 'code' | 'other' = 'default'
-      for (const l of contentLines) {
-        if (/^#code\s*$/.test(l)) { currentSlot = 'code'; continue }
-        if (/^#\w+/.test(l) && !/^#{2,}\s/.test(l)) { currentSlot = 'other'; continue }
-        if (currentSlot === 'default') defaultSlotLines.push(l)
-        else if (currentSlot === 'code') codeSlotLines.push(l)
-      }
-      const innerBlocks = parseBlocks(defaultSlotLines.join('\n'))
-
-      const codeBlocks = extractFencedCode(codeSlotLines)
-
-      const CALLOUT_NAMES = new Set(['tip', 'note', 'info', 'warning', 'caution', 'danger', 'callout', 'alert'])
-      if (CALLOUT_NAMES.has(componentName.toLowerCase())) {
-        blocks.push({ type: 'callout', calloutType: componentName.toLowerCase(), innerBlocks })
-      } else {
-        const mdcProps = parseMdcProps(line.match(MDC_OPEN)?.[3])
-        const lc = componentName.toLowerCase()
-
-        if (lc === 'collapsible') {
-          blocks.push({ type: 'collapsible', label: mdcProps['label'] || 'Details', open: mdcProps['open'] === 'true', innerBlocks })
-        } else if (lc === 'steps') {
-          blocks.push({ type: 'steps', innerBlocks })
-        } else if (lc === 'card') {
-          blocks.push({ type: 'card', title: mdcProps['title'] || '', icon: mdcProps['icon'] || '', to: mdcProps['to'] || '', innerBlocks })
-        } else if (lc === 'card-group') {
-          const cards = innerBlocks.filter(b => b.type === 'card')
-          if (cards.length) {
-            blocks.push({ type: 'cardGroup', cards })
-          } else {
-            blocks.push(...innerBlocks)
-          }
-        } else if (lc === 'code-collapse') {
-          blocks.push({ type: 'codeCollapse', codeBlocks: codeBlocks.length ? codeBlocks : innerBlocks.filter(b => b.type === 'codeBlock') })
-        } else if (lc === 'code-group') {
-          const allCode = [...innerBlocks.filter(b => b.type === 'codeBlock'), ...codeBlocks]
-          blocks.push({ type: 'codeGroup', codeBlocks: allCode })
-        } else if (lc === 'code-preview') {
-          blocks.push({ type: 'codePreview', innerBlocks, codeBlocks })
-        } else if (lc === 'code-tree') {
-          blocks.push({ type: 'codeTree', files: mdcProps['files'] || '[]' })
-        } else if (lc === 'accordion') {
-          const items = parseMdcChildren(contentLines, 'item')
-          if (items.length) {
-            blocks.push({ type: 'accordion', items })
-          } else {
-            blocks.push({ type: 'accordion', items: [{ label: 'Item 1', icon: '', innerBlocks }] })
-          }
-        } else if (lc === 'tabs') {
-          const items = parseMdcChildren(contentLines, 'tab')
-          if (items.length) {
-            blocks.push({ type: 'tabs', items })
-          } else {
-            blocks.push({ type: 'tabs', items: [{ label: 'Tab 1', icon: '', innerBlocks }] })
-          }
-        } else if (lc === 'field') {
-          blocks.push({ type: 'field', name: mdcProps['name'] || '', fieldType: mdcProps['type'] || 'string', required: mdcProps['required'] === 'true', innerBlocks })
-        } else if (lc === 'field-group') {
-          const fields = innerBlocks.filter(b => b.type === 'field')
-          if (fields.length) {
-            blocks.push({ type: 'fieldGroup', fields })
-          } else {
-            blocks.push(...innerBlocks)
-          }
-        } else {
-          blocks.push(...innerBlocks)
-          blocks.push(...codeBlocks)
-        }
-      }
-      continue
-    }
-
-    if (TASK_RE.test(line)) {
-      const items: TaskItem[] = []
-      while (i < lines.length && TASK_RE.test(lines[i]!)) {
-        const m = lines[i]!.match(TASK_RE)!
-        items.push({ checked: m[1]!.toLowerCase() === 'x', text: m[2]! })
-        i++
-      }
-      blocks.push({ type: 'taskList', items })
-      continue
-    }
-
-    if (/^[-*+]\s+/.test(line)) {
-      const items: string[] = []
-      while (i < lines.length && /^[-*+]\s+/.test(lines[i]!) && !TASK_RE.test(lines[i]!)) {
-        items.push(lines[i]!.replace(/^[-*+]\s+/, ''))
-        i++
-      }
-      if (items.length) {
-        blocks.push({ type: 'bulletList', items })
-        continue
-      }
-    }
-
-    if (/^\d+\.\s+/.test(line)) {
-      const items: string[] = []
-      while (i < lines.length && /^\d+\.\s+/.test(lines[i]!)) {
-        items.push(lines[i]!.replace(/^\d+\.\s+/, ''))
-        i++
-      }
-      blocks.push({ type: 'orderedList', items })
-      continue
-    }
-
-    if (line.trim() === '') {
-      i++
-      continue
-    }
-
-    const paraLines: string[] = []
-    while (
-      i < lines.length
-      && lines[i]!.trim() !== ''
-      && !/^(#{1,6}\s|[-*+]\s|\d+\.\s|>|`{3,}|\s*\||[-*_]{3,}\s*$|\s*:{2,}\w)/.test(lines[i]!)
-    ) {
-      paraLines.push(lines[i]!)
-      i++
-    }
-    if (paraLines.length) {
-      blocks.push({ type: 'paragraph', text: paraLines.join(' ') })
-    }
-  }
-
-  return blocks
-}
-
-// ── Y.js content population ──────────────────────────────────────────────────
-
-function fillTextInto(el: Y.XmlElement, tokens: InlineToken[]): void {
-  const filtered = tokens.filter(t => t.node || t.text.length > 0)
-  if (!filtered.length) return
-
-  const children: (Y.XmlText | Y.XmlElement)[] = filtered.map((tok) => {
-    if (tok.node) {
-      const xe = new Y.XmlElement(tok.node)
-      if (tok.nodeAttrs) {
-        for (const [k, v] of Object.entries(tok.nodeAttrs)) xe.setAttribute(k, v)
-      }
-      return xe
-    }
-    return new Y.XmlText()
-  })
-  el.insert(0, children)
-
-  filtered.forEach((tok, i) => {
-    if (tok.node) return
-    const xt = children[i] as Y.XmlText
-    if (tok.attrs) {
-      xt.insert(0, tok.text, tok.attrs as Record<string, boolean | object>)
-    } else {
-      xt.insert(0, tok.text)
-    }
-  })
-}
-
-function blockElName(b: Block): string {
-  switch (b.type) {
-    case 'heading': return 'heading'
-    case 'paragraph': return 'paragraph'
-    case 'bulletList': return 'bulletList'
-    case 'orderedList': return 'orderedList'
-    case 'taskList': return 'taskList'
-    case 'codeBlock': return 'codeBlock'
-    case 'blockquote': return 'blockquote'
-    case 'table': return 'table'
-    case 'hr': return 'horizontalRule'
-    case 'callout': return 'callout'
-    case 'collapsible': return 'collapsible'
-    case 'steps': return 'steps'
-    case 'card': return 'card'
-    case 'cardGroup': return 'cardGroup'
-    case 'codeCollapse': return 'codeCollapse'
-    case 'codeGroup': return 'codeGroup'
-    case 'codePreview': return 'codePreview'
-    case 'codeTree': return 'codeTree'
-    case 'accordion': return 'accordion'
-    case 'tabs': return 'tabs'
-    case 'field': return 'field'
-    case 'fieldGroup': return 'fieldGroup'
-    case 'image': return 'image'
-    case 'docEmbed': return 'docEmbed'
-    case 'svgEmbed': return 'svgEmbed'
-  }
-}
-
-function fillBlock(el: Y.XmlElement, block: Block): void {
-  switch (block.type) {
-    case 'heading': {
-      el.setAttribute('level', block.level as any)
-      fillTextInto(el, parseInline(block.text))
-      break
-    }
-    case 'paragraph': {
-      fillTextInto(el, parseInline(block.text))
-      break
-    }
-    case 'bulletList':
-    case 'orderedList': {
-      const listItemEls = block.items.map(() => new Y.XmlElement('listItem'))
-      el.insert(0, listItemEls)
-      block.items.forEach((text, i) => {
-        const paraEl = new Y.XmlElement('paragraph')
-        listItemEls[i]!.insert(0, [paraEl])
-        fillTextInto(paraEl, parseInline(text))
-      })
-      break
-    }
-    case 'taskList': {
-      const taskItemEls = block.items.map(() => new Y.XmlElement('taskItem'))
-      el.insert(0, taskItemEls)
-      block.items.forEach((item, i) => {
-        taskItemEls[i]!.setAttribute('checked', item.checked as any)
-        const paraEl = new Y.XmlElement('paragraph')
-        taskItemEls[i]!.insert(0, [paraEl])
-        fillTextInto(paraEl, parseInline(item.text))
-      })
-      break
-    }
-    case 'codeBlock': {
-      if (block.lang) el.setAttribute('language', block.lang)
-      const xt = new Y.XmlText()
-      el.insert(0, [xt])
-      xt.insert(0, block.code)
-      break
-    }
-    case 'blockquote': {
-      const paraEls = block.lines.map(() => new Y.XmlElement('paragraph'))
-      el.insert(0, paraEls)
-      block.lines.forEach((line, i) => fillTextInto(paraEls[i]!, parseInline(line)))
-      break
-    }
-    case 'table': {
-      const headerRowEl = new Y.XmlElement('tableRow')
-      const dataRowEls = block.dataRows.map(() => new Y.XmlElement('tableRow'))
-      el.insert(0, [headerRowEl, ...dataRowEls])
-
-      const headerCellEls = block.headerRow.map(() => new Y.XmlElement('tableHeader'))
-      headerRowEl.insert(0, headerCellEls)
-      block.headerRow.forEach((cellText, i) => {
-        const paraEl = new Y.XmlElement('paragraph')
-        headerCellEls[i]!.insert(0, [paraEl])
-        fillTextInto(paraEl, parseInline(cellText))
-      })
-
-      block.dataRows.forEach((row, ri) => {
-        const cellEls = row.map(() => new Y.XmlElement('tableCell'))
-        dataRowEls[ri]!.insert(0, cellEls)
-        row.forEach((cellText, ci) => {
-          const paraEl = new Y.XmlElement('paragraph')
-          cellEls[ci]!.insert(0, [paraEl])
-          fillTextInto(paraEl, parseInline(cellText))
-        })
-      })
-      break
-    }
-    case 'hr': break
-    case 'callout': {
-      el.setAttribute('type', block.calloutType)
-      if (!block.innerBlocks.length) {
-        const paraEl = new Y.XmlElement('paragraph')
-        el.insert(0, [paraEl])
-        break
-      }
-      const innerEls = block.innerBlocks.map(b => new Y.XmlElement(blockElName(b)))
-      el.insert(0, innerEls)
-      block.innerBlocks.forEach((b, i) => fillBlock(innerEls[i]!, b))
-      break
-    }
-    case 'collapsible': {
-      el.setAttribute('label', block.label)
-      el.setAttribute('open', block.open as any)
-      const inner = block.innerBlocks.length ? block.innerBlocks : [{ type: 'paragraph' as const, text: '' }]
-      const innerEls = inner.map(b => new Y.XmlElement(blockElName(b)))
-      el.insert(0, innerEls)
-      inner.forEach((b, i) => fillBlock(innerEls[i]!, b))
-      break
-    }
-    case 'steps': {
-      const inner = block.innerBlocks.length ? block.innerBlocks : [{ type: 'paragraph' as const, text: '' }]
-      const innerEls = inner.map(b => new Y.XmlElement(blockElName(b)))
-      el.insert(0, innerEls)
-      inner.forEach((b, i) => fillBlock(innerEls[i]!, b))
-      break
-    }
-    case 'card': {
-      if (block.title) el.setAttribute('title', block.title)
-      if (block.icon) el.setAttribute('icon', block.icon)
-      if (block.to) el.setAttribute('to', block.to)
-      const inner = block.innerBlocks.length ? block.innerBlocks : [{ type: 'paragraph' as const, text: '' }]
-      const innerEls = inner.map(b => new Y.XmlElement(blockElName(b)))
-      el.insert(0, innerEls)
-      inner.forEach((b, i) => fillBlock(innerEls[i]!, b))
-      break
-    }
-    case 'cardGroup': {
-      const cardEls = block.cards.map(b => new Y.XmlElement(blockElName(b)))
-      el.insert(0, cardEls)
-      block.cards.forEach((b, i) => fillBlock(cardEls[i]!, b))
-      break
-    }
-    case 'codeCollapse': {
-      const codes = block.codeBlocks.length ? block.codeBlocks : [{ type: 'codeBlock' as const, lang: '', code: '' }]
-      const codeEl = new Y.XmlElement('codeBlock')
-      el.insert(0, [codeEl])
-      fillBlock(codeEl, codes[0]!)
-      break
-    }
-    case 'codeGroup': {
-      const codes = block.codeBlocks.length ? block.codeBlocks : [{ type: 'codeBlock' as const, lang: '', code: '' }]
-      const codeEls = codes.map(() => new Y.XmlElement('codeBlock'))
-      el.insert(0, codeEls)
-      codes.forEach((b, i) => fillBlock(codeEls[i]!, b))
-      break
-    }
-    case 'codePreview': {
-      const all = [...block.innerBlocks, ...block.codeBlocks]
-      const inner = all.length ? all : [{ type: 'paragraph' as const, text: '' }]
-      const innerEls = inner.map(b => new Y.XmlElement(blockElName(b)))
-      el.insert(0, innerEls)
-      inner.forEach((b, i) => fillBlock(innerEls[i]!, b))
-      break
-    }
-    case 'codeTree': {
-      el.setAttribute('files', block.files)
-      break
-    }
-    case 'accordion': {
-      const itemEls = block.items.map(() => new Y.XmlElement('accordionItem'))
-      el.insert(0, itemEls)
-      block.items.forEach((item, i) => {
-        itemEls[i]!.setAttribute('label', item.label)
-        if (item.icon) itemEls[i]!.setAttribute('icon', item.icon)
-        const inner = item.innerBlocks.length ? item.innerBlocks : [{ type: 'paragraph' as const, text: '' }]
-        const childEls = inner.map(b => new Y.XmlElement(blockElName(b)))
-        itemEls[i]!.insert(0, childEls)
-        inner.forEach((b, ci) => fillBlock(childEls[ci]!, b))
-      })
-      break
-    }
-    case 'tabs': {
-      const itemEls = block.items.map(() => new Y.XmlElement('tabsItem'))
-      el.insert(0, itemEls)
-      block.items.forEach((item, i) => {
-        itemEls[i]!.setAttribute('label', item.label)
-        if (item.icon) itemEls[i]!.setAttribute('icon', item.icon)
-        const inner = item.innerBlocks.length ? item.innerBlocks : [{ type: 'paragraph' as const, text: '' }]
-        const childEls = inner.map(b => new Y.XmlElement(blockElName(b)))
-        itemEls[i]!.insert(0, childEls)
-        inner.forEach((b, ci) => fillBlock(childEls[ci]!, b))
-      })
-      break
-    }
-    case 'field': {
-      if (block.name) el.setAttribute('name', block.name)
-      el.setAttribute('type', block.fieldType)
-      el.setAttribute('required', block.required as any)
-      const inner = block.innerBlocks.length ? block.innerBlocks : [{ type: 'paragraph' as const, text: '' }]
-      const innerEls = inner.map(b => new Y.XmlElement(blockElName(b)))
-      el.insert(0, innerEls)
-      inner.forEach((b, i) => fillBlock(innerEls[i]!, b))
-      break
-    }
-    case 'fieldGroup': {
-      const fieldEls = block.fields.map(b => new Y.XmlElement(blockElName(b)))
-      el.insert(0, fieldEls)
-      block.fields.forEach((b, i) => fillBlock(fieldEls[i]!, b))
-      break
-    }
-    case 'image': {
-      el.setAttribute('src', block.src)
-      if (block.alt) el.setAttribute('alt', block.alt)
-      if (block.width) el.setAttribute('width', block.width)
-      if (block.height) el.setAttribute('height', block.height)
-      break
-    }
-    case 'docEmbed': {
-      el.setAttribute('docId', block.docId)
-      if (block.seamless) el.setAttribute('seamless', 'true')
-      break
-    }
-    case 'svgEmbed': {
-      el.setAttribute('svg', block.svg)
-      if (block.title) el.setAttribute('title', block.title)
-      break
-    }
-  }
-}
-
-// ── Public API ───────────────────────────────────────────────────────────────
-
-export function populateYDocFromMarkdown(
-  fragment: Y.XmlFragment,
-  markdown: string,
-  fallbackTitle = 'Untitled'
-): void {
-  const ydoc = fragment.doc
-  if (!ydoc) {
-    console.warn('[markdownToYjs] fragment has no doc — skipping population')
-    return
-  }
-
-  const blocks = parseBlocks(markdown)
-
-  let title = fallbackTitle
-  let contentBlocks = blocks
-  const h1 = blocks.findIndex(b => b.type === 'heading' && b.level === 1)
-  if (h1 !== -1) {
-    title = (blocks[h1] as { type: 'heading'; level: number; text: string }).text
-    contentBlocks = blocks.filter((_, i) => i !== h1)
-  }
-  if (!contentBlocks.length) contentBlocks = [{ type: 'paragraph', text: '' }]
-
-  ydoc.transact(() => {
-    const headerEl = new Y.XmlElement('documentHeader')
-    const metaEl = new Y.XmlElement('documentMeta')
-    const bodyEls: Y.XmlElement[] = contentBlocks.map((b) => {
-      switch (b.type) {
-        case 'heading': return new Y.XmlElement('heading')
-        case 'paragraph': return new Y.XmlElement('paragraph')
-        case 'bulletList': return new Y.XmlElement('bulletList')
-        case 'orderedList': return new Y.XmlElement('orderedList')
-        case 'taskList': return new Y.XmlElement('taskList')
-        case 'codeBlock': return new Y.XmlElement('codeBlock')
-        case 'blockquote': return new Y.XmlElement('blockquote')
-        case 'table': return new Y.XmlElement('table')
-        case 'hr': return new Y.XmlElement('horizontalRule')
-        case 'callout': return new Y.XmlElement('callout')
-        case 'collapsible': return new Y.XmlElement('collapsible')
-        case 'steps': return new Y.XmlElement('steps')
-        case 'card': return new Y.XmlElement('card')
-        case 'cardGroup': return new Y.XmlElement('cardGroup')
-        case 'codeCollapse': return new Y.XmlElement('codeCollapse')
-        case 'codeGroup': return new Y.XmlElement('codeGroup')
-        case 'codePreview': return new Y.XmlElement('codePreview')
-        case 'codeTree': return new Y.XmlElement('codeTree')
-        case 'accordion': return new Y.XmlElement('accordion')
-        case 'tabs': return new Y.XmlElement('tabs')
-        case 'field': return new Y.XmlElement('field')
-        case 'fieldGroup': return new Y.XmlElement('fieldGroup')
-        case 'image': return new Y.XmlElement('image')
-        case 'docEmbed': return new Y.XmlElement('docEmbed')
-        case 'svgEmbed': return new Y.XmlElement('svgEmbed')
-      }
-    })
-
-    fragment.insert(0, [headerEl, metaEl, ...bodyEls])
-
-    const headerXt = new Y.XmlText()
-    headerEl.insert(0, [headerXt])
-    headerXt.insert(0, title)
-
-    contentBlocks.forEach((block, i) => fillBlock(bodyEls[i]!, block))
-  })
-}
+// Thin re-export shim — markdown → Yjs conversion now lives in
+// @abraca/convert (extracted from cou-sh + abracadabra-nuxt + this
+// package). Existing imports inside the MCP server keep working
+// through this re-export.
+//
+// New code should import from @abraca/convert directly.
+
+export {
+  filenameToLabel,
+  parseFrontmatter,
+  populateYDocFromMarkdown,
+  type FrontmatterResult,
+} from '@abraca/convert'