@abraca/convert 2.3.0

package/src/file-blocks/manifest.ts

@@ -0,0 +1,169 @@
+// ── Manifest: docId <-> filesystem path mapping ─────────────────────────────
+//
+// The manifest tracks which doc on the server maps to which file on
+// disk, plus per-doc upload (binary attachment) records and content
+// hashes for change detection.
+//
+// Filesystem I/O is INJECTABLE so Node hosts (memfs for tests, fs/promises
+// for Electron, @tauri-apps/plugin-fs for Tauri) can all use this code
+// without the package taking a hard dep on any one. If no adapter has
+// been wired and we're inside Tauri, we lazily fall back to the Tauri
+// plugin. Pure-test setups should always call `setFsAdapter()` first.
+
+export interface FsAdapter {
+  readTextFile: (path: string) => Promise<string>
+  writeTextFile: (path: string, contents: string) => Promise<void>
+  mkdir: (path: string, options?: { recursive?: boolean }) => Promise<void>
+  readBinaryFile?: (path: string) => Promise<Uint8Array>
+  writeBinaryFile?: (path: string, contents: Uint8Array) => Promise<void>
+  exists?: (path: string) => Promise<boolean>
+  remove?: (path: string) => Promise<void>
+}
+
+let _adapter: FsAdapter | null = null
+
+/** Install a filesystem adapter. Call this once at boot. */
+export function setFsAdapter(adapter: FsAdapter): void {
+  _adapter = adapter
+}
+
+/** Read back the active adapter — useful for tests and for layered code. */
+export function getFsAdapter(): FsAdapter | null {
+  return _adapter
+}
+
+async function loadFsApi(): Promise<FsAdapter> {
+  if (_adapter) return _adapter
+  throw new Error(
+    '@abraca/convert: no FsAdapter installed. '
+    + 'Call setFsAdapter({readTextFile, writeTextFile, mkdir, …}) at boot. '
+    + 'Tauri hosts can pass `@tauri-apps/plugin-fs` directly; Node hosts can pass '
+    + 'a wrapper over `fs/promises`; tests can use the in-memory adapter from '
+    + 'tests/file-blocks.test.ts as a template.',
+  )
+}
+
+// ── Types ────────────────────────────────────────────────────────────────────
+
+export interface UploadManifestEntry {
+  uploadId: string
+  filename: string
+  relativePath: string // e.g. "_files/abc123/photo.jpg"
+  contentHash: string
+}
+
+export interface ManifestEntry {
+  docId: string
+  relativePath: string // e.g. "projects/my-project/_index.md"
+  contentHash: string // hash of last-written/read markdown
+  lastWrittenAt: number
+  lastReadAt: number
+  uploads: UploadManifestEntry[]
+}
+
+export interface FsSyncManifest {
+  version: 2
+  spaceId: string
+  lastSyncAt: number
+  entries: Record<string, ManifestEntry> // keyed by docId
+}
+
+// ── CRUD ─────────────────────────────────────────────────────────────────────
+
+const MANIFEST_DIR = '.abracadabra'
+const MANIFEST_FILE = 'manifest.json'
+
+function manifestPath(syncDir: string): string {
+  return `${syncDir}/${MANIFEST_DIR}/${MANIFEST_FILE}`
+}
+
+export function manifestDir(syncDir: string): string {
+  return `${syncDir}/${MANIFEST_DIR}`
+}
+
+export function trashDir(syncDir: string): string {
+  return `${syncDir}/${MANIFEST_DIR}/trash`
+}
+
+export function orphansDir(syncDir: string): string {
+  return `${syncDir}/${MANIFEST_DIR}/orphans`
+}
+
+export function conflictsDir(syncDir: string): string {
+  return `${syncDir}/${MANIFEST_DIR}/conflicts`
+}
+
+export function createEmptyManifest(spaceId: string): FsSyncManifest {
+  return {
+    version: 2,
+    spaceId,
+    lastSyncAt: 0,
+    entries: {}
+  }
+}
+
+export async function loadManifest(syncDir: string, spaceId: string): Promise<FsSyncManifest> {
+  const fs = await loadFsApi()
+  try {
+    const raw = await fs.readTextFile(manifestPath(syncDir))
+    const parsed = JSON.parse(raw) as FsSyncManifest
+    if (parsed.version === 2) return parsed
+  }
+  catch {
+    // missing or corrupt — return fresh
+  }
+  return createEmptyManifest(spaceId)
+}
+
+export async function saveManifest(syncDir: string, manifest: FsSyncManifest): Promise<void> {
+  const fs = await loadFsApi()
+  const dir = `${syncDir}/${MANIFEST_DIR}`
+  try {
+    await fs.mkdir(dir, { recursive: true })
+  }
+  catch {
+    // already exists
+  }
+  manifest.lastSyncAt = Date.now()
+  await fs.writeTextFile(manifestPath(syncDir), JSON.stringify(manifest, null, 2))
+}
+
+// ── Lookups ──────────────────────────────────────────────────────────────────
+
+export function lookupByDocId(manifest: FsSyncManifest, docId: string): ManifestEntry | undefined {
+  return manifest.entries[docId]
+}
+
+export function lookupByPath(manifest: FsSyncManifest, relativePath: string): ManifestEntry | undefined {
+  for (const entry of Object.values(manifest.entries)) {
+    if (entry.relativePath === relativePath) return entry
+  }
+  return undefined
+}
+
+export function lookupByHash(manifest: FsSyncManifest, contentHash: string): ManifestEntry | undefined {
+  for (const entry of Object.values(manifest.entries)) {
+    if (entry.contentHash === contentHash) return entry
+  }
+  return undefined
+}
+
+export function setEntry(manifest: FsSyncManifest, entry: ManifestEntry): void {
+  manifest.entries[entry.docId] = entry
+}
+
+export function removeEntry(manifest: FsSyncManifest, docId: string): ManifestEntry | undefined {
+  const entry = manifest.entries[docId]
+  if (entry) delete manifest.entries[docId]
+  return entry
+}
+
+// ── Build reverse lookup (path -> docId) ─────────────────────────────────────
+
+export function buildReverseLookup(manifest: FsSyncManifest): Map<string, string> {
+  const map = new Map<string, string>()
+  for (const [docId, entry] of Object.entries(manifest.entries)) {
+    map.set(entry.relativePath, docId)
+  }
+  return map
+}

package/src/file-blocks/paths.ts

@@ -0,0 +1,207 @@
+// ── Collision-safe path building for FS sync ─────────────────────────────────
+
+import type { FsSyncManifest } from './manifest.ts'
+
+export interface FsTreeEntry {
+  label: string
+  parentId: string | null
+  order: number
+  type?: string
+  meta?: any
+}
+
+/**
+ * Convert a document label to a filesystem-safe filename (without extension).
+ * e.g. "My Project!" -> "my-project"
+ */
+export function labelToFilename(label: string): string {
+  return (
+    label
+      .toLowerCase()
+      .replace(/[^a-z0-9\s-]/g, '')
+      .replace(/\s+/g, '-')
+      .replace(/-+/g, '-')
+      .replace(/^-|-$/g, '') || 'untitled'
+  )
+}
+
+/**
+ * Convert a filename back to a label (best-effort).
+ * e.g. "my-project" -> "my project", "my-project~a3f2" -> "my project"
+ */
+export function fsFilenameToLabel(filename: string): string {
+  // Strip collision suffix
+  const cleaned = filename.replace(/~[a-z0-9]{4}$/, '')
+  return cleaned.replace(/-/g, ' ')
+}
+
+/**
+ * Check if a doc has children in the tree (needs _index.md convention).
+ */
+export function hasChildren(docId: string, treeData: Record<string, FsTreeEntry>): boolean {
+  for (const entry of Object.values(treeData)) {
+    if (entry.parentId === docId) return true
+  }
+  return false
+}
+
+/**
+ * Resolve filename collisions by appending ~XXXX (first 4 chars of docId).
+ * Returns the filename (without extension) that should be used.
+ */
+function resolveCollision(
+  desiredFilename: string,
+  docId: string,
+  parentPath: string,
+  manifest: FsSyncManifest,
+  isIndex: boolean
+): string {
+  const ext = '.md'
+  const desiredRelative = isIndex
+    ? `${parentPath}${parentPath ? '/' : ''}${desiredFilename}/_index${ext}`
+    : `${parentPath}${parentPath ? '/' : ''}${desiredFilename}${ext}`
+
+  // Check if any other doc already claims this path
+  for (const [entryDocId, entry] of Object.entries(manifest.entries)) {
+    if (entryDocId === docId) continue
+    if (entry.relativePath === desiredRelative) {
+      // Collision — append disambiguator
+      return `${desiredFilename}~${docId.substring(0, 4)}`
+    }
+  }
+
+  return desiredFilename
+}
+
+/**
+ * Build the relative path for a document (from syncDir root).
+ * Handles:
+ * - Ancestor chain walking
+ * - _index.md for docs with children
+ * - Collision resolution via ~XXXX suffix
+ */
+export function buildRelativePath(
+  docId: string,
+  treeData: Record<string, FsTreeEntry>,
+  manifest: FsSyncManifest
+): string {
+  const entry = treeData[docId]
+  if (!entry) return `${docId}.md` // fallback for unknown docs
+
+  // Walk up the ancestor chain to build path segments
+  const segments: string[] = []
+  let current: FsTreeEntry | undefined = entry
+  let currentId = docId
+
+  const visited = new Set<string>()
+  while (current) {
+    if (visited.has(currentId)) break // circular reference guard
+    visited.add(currentId)
+
+    segments.unshift(labelToFilename(current.label))
+    if (!current.parentId) break
+    currentId = current.parentId
+    current = treeData[currentId]
+  }
+
+  // The last segment is the doc itself; everything before is parent dirs
+  const filename = segments.pop()!
+  const parentPath = segments.join('/')
+
+  // Check if this doc needs _index.md (has children)
+  const isIndex = hasChildren(docId, treeData)
+
+  // Resolve collisions
+  const resolvedFilename = resolveCollision(filename, docId, parentPath, manifest, isIndex)
+
+  if (isIndex) {
+    return `${parentPath}${parentPath ? '/' : ''}${resolvedFilename}/_index.md`
+  }
+  return `${parentPath}${parentPath ? '/' : ''}${resolvedFilename}.md`
+}
+
+/**
+ * Get the directory portion of a relative path for a doc.
+ * For _index.md docs: returns the directory containing _index.md
+ * For leaf docs: returns the parent directory
+ */
+export function getDocDir(relativePath: string): string {
+  if (relativePath.endsWith('/_index.md')) {
+    // e.g. "projects/my-project/_index.md" -> "projects/my-project"
+    return relativePath.replace('/_index.md', '')
+  }
+  // e.g. "projects/my-project/task.md" -> "projects/my-project"
+  const lastSlash = relativePath.lastIndexOf('/')
+  return lastSlash >= 0 ? relativePath.substring(0, lastSlash) : ''
+}
+
+/**
+ * Determine the parent docId from a filesystem relative path by walking the
+ * path segments and matching against the tree.
+ */
+export function resolveParentFromPath(
+  relativePath: string,
+  treeData: Record<string, FsTreeEntry>
+): string | null {
+  // Strip filename to get directory parts
+  const parts = relativePath.split('/')
+  parts.pop() // remove filename
+
+  // For _index.md, also remove the doc's own directory name
+  if (relativePath.endsWith('/_index.md') && parts.length > 0) {
+    parts.pop()
+  }
+
+  if (parts.length === 0) return null // root-level doc
+
+  let parentId: string | null = null
+  for (const segment of parts) {
+    const found = Object.entries(treeData).find(
+      ([, e]) => labelToFilename(e.label) === segment && e.parentId === parentId
+    )
+    if (found) {
+      parentId = found[0]
+    } else {
+      // Can't resolve further — return last known parent
+      break
+    }
+  }
+  return parentId
+}
+
+/**
+ * Simple string hash (same as current useFsSync).
+ */
+export function simpleHash(str: string): string {
+  let hash = 0
+  for (let i = 0; i < str.length; i++) {
+    hash = ((hash << 5) - hash + str.charCodeAt(i)) | 0
+  }
+  return hash.toString(36)
+}
+
+/**
+ * Get all tree data as a flat record.
+ */
+export function getTreeData(treeMap: any): Record<string, FsTreeEntry> {
+  const data: Record<string, FsTreeEntry> = {}
+  treeMap.forEach((val: any, key: string) => {
+    if (val && typeof val === 'object') {
+      data[key] = val as FsTreeEntry
+    }
+  })
+  return data
+}
+
+/**
+ * Find the next order value for a given parent (max sibling order + 1).
+ */
+export function nextOrder(treeData: Record<string, FsTreeEntry>, parentId: string | null): number {
+  let max = -1
+  for (const entry of Object.values(treeData)) {
+    if (entry.parentId === parentId && entry.order > max) {
+      max = entry.order
+    }
+  }
+  return max + 1
+}

package/src/html-to-yjs.ts

@@ -0,0 +1,322 @@
+import * as Y from 'yjs'
+
+// ── HTML → Y.js converter ───────────────────────────────────────────────────
+//
+// Uses DOMParser (browser builtin) to parse HTML, then walks the DOM tree
+// and writes TipTap-compatible Y.XmlElement nodes into the fragment.
+//
+// Follows the same attach-before-fill pattern as markdownToYjs.ts:
+// always attach nodes to the doc before inserting text into them.
+
+interface ActiveMarks {
+  bold?: true
+  italic?: true
+  code?: true
+  strike?: true
+  link?: { href: string }
+}
+
+function getTextContent(node: Node): string {
+  return node.textContent ?? ''
+}
+
+function langFromClass(el: Element): string {
+  for (const cls of Array.from(el.classList)) {
+    if (cls.startsWith('language-')) return cls.slice(9)
+  }
+  return ''
+}
+
+/**
+ * Collect inline marks from a DOM element's ancestry.
+ * Returns merged marks object accumulated from the provided stack.
+ */
+function mergeMarks(stack: ActiveMarks[]): ActiveMarks {
+  const merged: ActiveMarks = {}
+  for (const m of stack) {
+    if (m.bold) merged.bold = true
+    if (m.italic) merged.italic = true
+    if (m.code) merged.code = true
+    if (m.strike) merged.strike = true
+    if (m.link) merged.link = m.link
+  }
+  return merged
+}
+
+interface TextRun {
+  text: string
+  marks: ActiveMarks
+}
+
+/** Walk an inline subtree and collect { text, marks } runs. */
+function collectInlineRuns(node: Node, markStack: ActiveMarks[]): TextRun[] {
+  const runs: TextRun[] = []
+
+  if (node.nodeType === Node.TEXT_NODE) {
+    const text = node.textContent ?? ''
+    if (text) runs.push({ text, marks: mergeMarks(markStack) })
+    return runs
+  }
+
+  if (node.nodeType !== Node.ELEMENT_NODE) return runs
+
+  const el = node as Element
+  const tag = el.tagName.toLowerCase()
+
+  const newMarks: ActiveMarks = {}
+  if (tag === 'strong' || tag === 'b') newMarks.bold = true
+  if (tag === 'em' || tag === 'i') newMarks.italic = true
+  if (tag === 'code') newMarks.code = true
+  if (tag === 's' || tag === 'del' || tag === 'strike') newMarks.strike = true
+  if (tag === 'a') {
+    const href = el.getAttribute('href')
+    if (href) newMarks.link = { href }
+  }
+
+  const nextStack = Object.keys(newMarks).length ? [...markStack, newMarks] : markStack
+
+  for (const child of Array.from(el.childNodes)) {
+    runs.push(...collectInlineRuns(child, nextStack))
+  }
+  return runs
+}
+
+/** Fill an already-attached Y.XmlElement with inline text runs. */
+function fillInlineRuns(paraEl: Y.XmlElement, runs: TextRun[]): void {
+  if (!runs.length) return
+  const xtNodes = runs.map(() => new Y.XmlText())
+  paraEl.insert(0, xtNodes)
+  runs.forEach((run, i) => {
+    const attrs: Record<string, boolean | object> = {}
+    if (run.marks.bold) attrs['bold'] = true
+    if (run.marks.italic) attrs['italic'] = true
+    if (run.marks.code) attrs['code'] = true
+    if (run.marks.strike) attrs['strike'] = true
+    if (run.marks.link) attrs['link'] = run.marks.link
+    if (Object.keys(attrs).length) {
+      xtNodes[i]!.insert(0, run.text, attrs)
+    } else {
+      xtNodes[i]!.insert(0, run.text)
+    }
+  })
+}
+
+/** Convert a single block-level DOM element to Y.XmlElement(s) and append to `container`. */
+function convertBlockElement(el: Element, container: Y.XmlElement | Y.XmlFragment): void {
+  const tag = el.tagName.toLowerCase()
+
+  // fileBlock: DOMSerializer renders <div data-type="file-block" uploadid="..." ...>
+  // HTML lowercases attribute names; read in lowercase, store in camelCase for Y.js
+  if (tag === 'div' && el.getAttribute('data-type') === 'file-block') {
+    const fileBlockEl = new Y.XmlElement('fileBlock')
+    container.insert(container.length, [fileBlockEl])
+    const uploadId = el.getAttribute('uploadid') ?? ''
+    const docId = el.getAttribute('docid') ?? ''
+    const filename = el.getAttribute('filename') ?? ''
+    const mimeType = el.getAttribute('mimetype') ?? ''
+    if (uploadId) fileBlockEl.setAttribute('uploadId', uploadId)
+    if (docId) fileBlockEl.setAttribute('docId', docId)
+    if (filename) fileBlockEl.setAttribute('filename', filename)
+    if (mimeType) fileBlockEl.setAttribute('mimeType', mimeType)
+    return
+  }
+
+  // Headings
+  const headingMatch = tag.match(/^h([1-6])$/)
+  if (headingMatch) {
+    const level = parseInt(headingMatch[1]!)
+    const headingEl = new Y.XmlElement('heading')
+    container.insert(container.length, [headingEl])
+    headingEl.setAttribute('level', level as unknown as string)
+    fillInlineRuns(headingEl, collectInlineRuns(el, []))
+    return
+  }
+
+  if (tag === 'p') {
+    const paraEl = new Y.XmlElement('paragraph')
+    container.insert(container.length, [paraEl])
+    fillInlineRuns(paraEl, collectInlineRuns(el, []))
+    return
+  }
+
+  if (tag === 'hr') {
+    const hrEl = new Y.XmlElement('horizontalRule')
+    container.insert(container.length, [hrEl])
+    return
+  }
+
+  if (tag === 'pre') {
+    const codeEl = el.querySelector('code')
+    const codeBlock = new Y.XmlElement('codeBlock')
+    container.insert(container.length, [codeBlock])
+    const lang = codeEl ? langFromClass(codeEl) : ''
+    if (lang) codeBlock.setAttribute('language', lang)
+    const xt = new Y.XmlText()
+    codeBlock.insert(0, [xt])
+    xt.insert(0, (codeEl ?? el).textContent ?? '')
+    return
+  }
+
+  if (tag === 'blockquote') {
+    const bqEl = new Y.XmlElement('blockquote')
+    container.insert(container.length, [bqEl])
+    // Wrap text in a paragraph
+    const paraEl = new Y.XmlElement('paragraph')
+    bqEl.insert(0, [paraEl])
+    fillInlineRuns(paraEl, collectInlineRuns(el, []))
+    return
+  }
+
+  if (tag === 'ul' || tag === 'ol') {
+    // Check if any li contains a checkbox → taskList
+    const items = Array.from(el.querySelectorAll(':scope > li'))
+    const hasCheckbox = items.some(li => li.querySelector('input[type="checkbox"]'))
+
+    if (hasCheckbox) {
+      const taskListEl = new Y.XmlElement('taskList')
+      container.insert(container.length, [taskListEl])
+      const taskItemEls = items.map(() => new Y.XmlElement('taskItem'))
+      taskListEl.insert(0, taskItemEls)
+      items.forEach((li, i) => {
+        const checkbox = li.querySelector('input[type="checkbox"]') as HTMLInputElement | null
+        const checked = checkbox?.checked ?? false
+        taskItemEls[i]!.setAttribute('checked', checked as unknown as string)
+        const paraEl = new Y.XmlElement('paragraph')
+        taskItemEls[i]!.insert(0, [paraEl])
+        // Remove checkbox from text extraction
+        const clone = li.cloneNode(true) as Element
+        clone.querySelector('input')?.remove()
+        fillInlineRuns(paraEl, collectInlineRuns(clone, []))
+      })
+    } else {
+      const listType = tag === 'ul' ? 'bulletList' : 'orderedList'
+      const listEl = new Y.XmlElement(listType)
+      container.insert(container.length, [listEl])
+      const listItemEls = items.map(() => new Y.XmlElement('listItem'))
+      listEl.insert(0, listItemEls)
+      items.forEach((li, i) => {
+        const paraEl = new Y.XmlElement('paragraph')
+        listItemEls[i]!.insert(0, [paraEl])
+        fillInlineRuns(paraEl, collectInlineRuns(li, []))
+      })
+    }
+    return
+  }
+
+  if (tag === 'table') {
+    const tableEl = new Y.XmlElement('table')
+    container.insert(container.length, [tableEl])
+
+    const rows = Array.from(el.querySelectorAll('tr'))
+    const rowEls = rows.map(() => new Y.XmlElement('tableRow'))
+    tableEl.insert(0, rowEls)
+
+    rows.forEach((row, ri) => {
+      const cells = Array.from(row.querySelectorAll('th, td'))
+      const isHeader = cells.some(c => c.tagName.toLowerCase() === 'th')
+      const cellType = isHeader ? 'tableHeader' : 'tableCell'
+      const cellEls = cells.map(() => new Y.XmlElement(cellType))
+      rowEls[ri]!.insert(0, cellEls)
+      cells.forEach((cell, ci) => {
+        const paraEl = new Y.XmlElement('paragraph')
+        cellEls[ci]!.insert(0, [paraEl])
+        fillInlineRuns(paraEl, collectInlineRuns(cell, []))
+      })
+    })
+    return
+  }
+
+  // Fallback: treat as paragraph (div, section, article, etc.)
+  const text = getTextContent(el).trim()
+  if (text) {
+    const paraEl = new Y.XmlElement('paragraph')
+    container.insert(container.length, [paraEl])
+    fillInlineRuns(paraEl, collectInlineRuns(el, []))
+  }
+}
+
+// ── Public API ───────────────────────────────────────────────────────────────
+
+/**
+ * Parses an HTML string and writes the result into a Y.XmlFragment that
+ * TipTap's Collaboration extension can read.
+ *
+ * @param fragment      The target `Y.Doc.getXmlFragment('default')`
+ * @param html          Raw HTML string
+ * @param fallbackTitle Used when no <title> or <h1> is found
+ */
+export function populateYDocFromHtml(
+  fragment: Y.XmlFragment,
+  html: string,
+  fallbackTitle = 'Untitled'
+): void {
+  const ydoc = fragment.doc
+  if (!ydoc) {
+    console.warn('[htmlToYjs] fragment has no doc — skipping population')
+    return
+  }
+
+  const doc = new DOMParser().parseFromString(html, 'text/html')
+
+  // Determine title
+  let title = doc.title?.trim() || fallbackTitle
+  const firstH1 = doc.body.querySelector('h1')
+  if (firstH1) title = firstH1.textContent?.trim() || title
+
+  ydoc.transact(() => {
+    const headerEl = new Y.XmlElement('documentHeader')
+    const metaEl = new Y.XmlElement('documentMeta')
+    fragment.insert(0, [headerEl, metaEl])
+
+    const headerXt = new Y.XmlText()
+    headerEl.insert(0, [headerXt])
+    headerXt.insert(0, title)
+
+    // Walk body block children
+    const blockTags = new Set([
+      'p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
+      'ul', 'ol', 'pre', 'blockquote', 'table', 'hr',
+      'div', 'section', 'article', 'header', 'footer', 'main', 'aside'
+    ])
+
+    let hasContent = false
+    for (const child of Array.from(doc.body.children)) {
+      const tag = child.tagName.toLowerCase()
+      if (!blockTags.has(tag)) continue
+      // Skip first h1 (already used as title)
+      if (tag === 'h1' && child === firstH1) continue
+      convertBlockElement(child, fragment)
+      hasContent = true
+    }
+
+    // Ensure at least one paragraph exists
+    if (!hasContent) {
+      const paraEl = new Y.XmlElement('paragraph')
+      fragment.insert(fragment.length, [paraEl])
+    }
+  })
+}
+
+/**
+ * Appends blocks from an HTML string to an existing Y.XmlFragment.
+ * Does NOT insert documentHeader/documentMeta — for appending to an existing doc.
+ */
+export function appendHtmlToFragment(fragment: Y.XmlFragment, html: string): void {
+  const ydoc = fragment.doc
+  if (!ydoc) {
+    console.warn('[htmlToYjs] appendHtmlToFragment: fragment has no doc — skipping')
+    return
+  }
+  const doc = new DOMParser().parseFromString(html, 'text/html')
+  const blockTags = new Set([
+    'p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
+    'ul', 'ol', 'pre', 'blockquote', 'table', 'hr',
+    'div', 'section', 'article', 'header', 'footer', 'main', 'aside'
+  ])
+  ydoc.transact(() => {
+    for (const child of Array.from(doc.body.children)) {
+      if (blockTags.has(child.tagName.toLowerCase()))
+        convertBlockElement(child, fragment)
+    }
+  })
+}