@abraca/convert 2.3.0 → 2.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abraca/convert",
-  "version": "2.3.0",
+  "version": "2.5.0",
   "description": "Bullet-proof Markdown ↔ Yjs/TipTap round-trip — canonical converter shared by cou-sh, abracadabra-nuxt, and @abraca/mcp.",
   "license": "MIT",
   "type": "module",

package/src/file-blocks/paths.ts

@@ -1,5 +1,7 @@
 // ── Collision-safe path building for FS sync ─────────────────────────────────
 
+import * as Y from 'yjs'
+
 import type { FsSyncManifest } from './manifest.ts'
 
 export interface FsTreeEntry {
@@ -15,8 +17,12 @@ export interface FsTreeEntry {
  * e.g. "My Project!" -> "my-project"
  */
 export function labelToFilename(label: string): string {
+  // Nullish-safe: real trees (kanban cards, server-compacted entries)
+  // contain entries with no `label`; buildRelativePath() calls this for
+  // a doc AND every ancestor, so one missing label must not throw and
+  // abort fs-sync for the whole tree. Empty → 'untitled' (below).
   return (
-    label
+    String(label ?? '')
       .toLowerCase()
       .replace(/[^a-z0-9\s-]/g, '')
       .replace(/\s+/g, '-')
@@ -186,8 +192,25 @@ export function simpleHash(str: string): string {
 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
+    // A tree entry may be stored as a nested Y.Map — both from the
+    // per-key ⑦ write path (every SDK + cou-sh) and from server-side
+    // Yrs compaction. Read it as a plain object (mirror of the
+    // provider's `toPlain`); a raw Y.Map would expose
+    // label/parentId/order as `undefined` and silently corrupt the
+    // FS-sync tree (mass mis-parent / mis-label / spurious delete).
+    //
+    // Detect Y.Map by DUCK-TYPING, not `instanceof`: a host that wires
+    // @abraca/dabra (which bundles its own physical `yjs`) alongside
+    // this package would fail an instanceof across the two yjs copies
+    // and hand back the raw Y.Map → every doc "untitled". toJSON()
+    // works regardless of which yjs constructed the map.
+    const isYMap = val instanceof Y.Map
+      || (!!val && typeof val === 'object'
+        && typeof (val as any).toJSON === 'function'
+        && typeof (val as any).get === 'function')
+    const plain = isYMap ? (val as any).toJSON() : val
+    if (plain && typeof plain === 'object') {
+      data[key] = plain as FsTreeEntry
     }
   })
   return data

package/src/markdown-to-yjs.ts

@@ -166,6 +166,27 @@ interface InlineToken {
   attrs?: Record<string, unknown>
 }
 
+// Re-tokenize the inner text of a wrapping mark (bold/italic/strike) so nested
+// atoms (wikilinks, mentions, code, math) and nested marks survive instead of
+// being captured as a single literal leaf. The wrapping mark's attrs are merged
+// onto every produced child token; object-valued attrs (docLink/mention/badge)
+// are preserved alongside the boolean mark. Terminates because `inner` is
+// strictly shorter than the matched delimiter run.
+function pushNested(
+  out: InlineToken[],
+  inner: string,
+  wrap: Record<string, unknown>,
+): void {
+  const children = parseInline(inner)
+  if (children.length === 0) {
+    out.push({ text: inner, attrs: { ...wrap } })
+    return
+  }
+  for (const child of children) {
+    out.push({ text: child.text, attrs: { ...(child.attrs ?? {}), ...wrap } })
+  }
+}
+
 function parseInline(text: string): InlineToken[] {
   // Strip MDC attribute annotations on inline code: `string`{lang="ts-type"}
   const stripped = text.replace(/\{lang="[^"]*"\}/g, '')
@@ -214,13 +235,13 @@ function parseInline(text: string): InlineToken[] {
       const label = match[9] ?? docId
       tokens.push({ text: label, attrs: { docLink: { docId } } })
     } else if (match[10] !== undefined) {
-      tokens.push({ text: match[10], attrs: { strike: true } })
+      pushNested(tokens, match[10], { strike: true })
     } else if (match[11] !== undefined) {
-      tokens.push({ text: match[11], attrs: { bold: true } })
+      pushNested(tokens, match[11], { bold: true })
     } else if (match[12] !== undefined) {
-      tokens.push({ text: match[12], attrs: { italic: true } })
+      pushNested(tokens, match[12], { italic: true })
     } else if (match[13] !== undefined) {
-      tokens.push({ text: match[13], attrs: { italic: true } })
+      pushNested(tokens, match[13], { italic: true })
     } else if (match[14] !== undefined) {
       tokens.push({ text: match[14], attrs: { code: true } })
     } else if (match[15] !== undefined && match[16] !== undefined) {
@@ -807,16 +828,29 @@ function fillTextInto(el: Y.XmlElement, tokens: InlineToken[]): void {
   const filtered = tokens.filter(t => t.text.length > 0)
   if (!filtered.length) return
 
-  // Create empty text nodes and attach them to el in one batch
-  const xtNodes = filtered.map(() => new Y.XmlText())
-  el.insert(0, xtNodes)
+  // Build the child skeleton. A docLink is an inline ATOM NODE, not a text
+  // mark: it must be a Y.XmlElement so the y-prosemirror binding materializes
+  // it as a `docLink` node (its label is resolved live from the doc tree by
+  // the renderer, never stored). Every other token is a Y.XmlText run.
+  // Attach all children in one batch first (attach-before-fill), then fill.
+  const children: (Y.XmlText | Y.XmlElement)[] = filtered.map((tok) => {
+    const dl = tok.attrs?.docLink as { docId?: string } | undefined
+    return dl?.docId ? new Y.XmlElement('docLink') : new Y.XmlText()
+  })
+  el.insert(0, children)
 
-  // Fill text only after attachment — el is already attached to the doc
+  // Fill only after attachment — el is already attached to the doc.
   filtered.forEach((tok, i) => {
+    const node = children[i]!
+    if (node instanceof Y.XmlElement) {
+      const dl = tok.attrs!.docLink as { docId: string }
+      node.setAttribute('docId', dl.docId)
+      return
+    }
     if (tok.attrs) {
-      xtNodes[i]!.insert(0, tok.text, tok.attrs as Record<string, boolean | object>)
+      node.insert(0, tok.text, tok.attrs as Record<string, boolean | object>)
     } else {
-      xtNodes[i]!.insert(0, tok.text)
+      node.insert(0, tok.text)
     }
   })
 }

package/src/yjs-to-markdown.ts

@@ -1,6 +1,40 @@
 import * as Y from 'yjs'
 import type { DocPageMeta } from './types.ts'
 
+// ── Cross-yjs-copy node typing ───────────────────────────────────────────────
+//
+// The serializers must decide "is this a Y.XmlText vs Y.XmlElement"
+// without `instanceof`. A host that wires @abraca/dabra (file: dep) or
+// bundles us through Vite/esbuild dep-prebundling ends up with a SECOND
+// physical copy of yjs; nodes built by that copy are NOT `instanceof`
+// *our* Y.XmlText/Y.XmlElement, so every check silently fails and text
+// and inline atoms (docLink/mention) serialize to NOTHING. Duck-typed
+// predicates work regardless of which yjs constructed the node — the
+// same lesson as getTreeData's `instanceof Y.Map` fix. (`nodeName` is a
+// plain own-property; `toDelta` only exists on Y.XmlText.)
+// An element is anything carrying a string `nodeName` (paragraph,
+// heading, bulletList, AND inline atoms like docLink/mention — atoms
+// have no children but still have a nodeName). Mirrors the original
+// `instanceof Y.XmlElement` intent with NO extra constraint: requiring
+// `.toArray` wrongly excluded childless atom nodes → docLinks dropped.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isXElem(n: any): n is Y.XmlElement {
+  return !!n && typeof n.nodeName === 'string'
+}
+// Y.XmlText: no nodeName, has toDelta. (Y.XmlFragment has neither →
+// classified as neither, which is correct — it's only ever the root.)
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isXText(n: any): n is Y.XmlText {
+  return !!n && typeof n.nodeName !== 'string' && typeof n.toDelta === 'function'
+}
+
+// No fragment normalization is needed any more — the serializers are
+// duck-typed, so a foreign-yjs fragment serializes directly. Kept as an
+// identity so the public entry points don't need to change.
+function localizeFragment(fragment: Y.XmlFragment): Y.XmlFragment {
+  return fragment
+}
+
 // ── Inline serialization ────────────────────────────────────────────────────
 
 function serializeDelta(delta: any[]): string {
@@ -84,11 +118,17 @@ function serializeDelta(delta: any[]): string {
 function serializeInline(el: Y.XmlElement | Y.XmlFragment): string {
   const parts: string[] = []
   for (const child of el.toArray()) {
-    if (child instanceof Y.XmlText) {
+    if (isXText(child)) {
       parts.push(serializeDelta(child.toDelta()))
-    } else if (child instanceof Y.XmlElement) {
-      // Nested inline element — just get text
-      parts.push(serializeInline(child))
+    } else if (isXElem(child)) {
+      if (child.nodeName === 'docLink') {
+        // Inline doc-link atom node — bare wire form; label is tree-derived.
+        const docId = child.getAttribute('docId') ?? ''
+        parts.push(`[[${docId}]]`)
+      } else {
+        // Nested inline element — just get text
+        parts.push(serializeInline(child))
+      }
     }
   }
   return parts.join('')
@@ -97,7 +137,7 @@ function serializeInline(el: Y.XmlElement | Y.XmlFragment): string {
 // ── Block serialization ─────────────────────────────────────────────────────
 
 function serializeBlock(el: Y.XmlElement | Y.XmlText, indent = ''): string {
-  if (el instanceof Y.XmlText) {
+  if (isXText(el)) {
     return serializeDelta(el.toDelta())
   }
 
@@ -137,7 +177,7 @@ function serializeBlock(el: Y.XmlElement | Y.XmlText, indent = ''): string {
     case 'blockquote': {
       const lines: string[] = []
       for (const child of el.toArray()) {
-        if (child instanceof Y.XmlElement) {
+        if (isXElem(child)) {
           const text = serializeBlock(child)
           for (const line of text.split('\n')) {
             lines.push(`> ${line}`)
@@ -231,7 +271,7 @@ function serializeBlock(el: Y.XmlElement | Y.XmlText, indent = ''): string {
 
     case 'cardGroup': {
       const cards = el.toArray()
-        .filter((c): c is Y.XmlElement => c instanceof Y.XmlElement)
+        .filter((c): c is Y.XmlElement => isXElem(c))
         .map(c => serializeBlock(c))
         .join('\n\n')
       return `::card-group\n${cards}\n::`
@@ -239,7 +279,7 @@ function serializeBlock(el: Y.XmlElement | Y.XmlText, indent = ''): string {
 
     case 'codeCollapse': {
       const code = el.toArray()
-        .filter((c): c is Y.XmlElement => c instanceof Y.XmlElement && c.nodeName === 'codeBlock')
+        .filter((c): c is Y.XmlElement => isXElem(c) && c.nodeName === 'codeBlock')
         .map(c => serializeBlock(c))
         .join('\n\n')
       return `::code-collapse\n${code}\n::`
@@ -247,14 +287,14 @@ function serializeBlock(el: Y.XmlElement | Y.XmlText, indent = ''): string {
 
     case 'codeGroup': {
       const code = el.toArray()
-        .filter((c): c is Y.XmlElement => c instanceof Y.XmlElement && c.nodeName === 'codeBlock')
+        .filter((c): c is Y.XmlElement => isXElem(c) && c.nodeName === 'codeBlock')
         .map(c => serializeBlock(c))
         .join('\n\n')
       return `::code-group\n${code}\n::`
     }
 
     case 'codePreview': {
-      const children = el.toArray().filter((c): c is Y.XmlElement => c instanceof Y.XmlElement)
+      const children = el.toArray().filter((c): c is Y.XmlElement => isXElem(c))
       const nonCode = children.filter(c => c.nodeName !== 'codeBlock').map(c => serializeBlock(c)).join('\n\n')
       const code = children.filter(c => c.nodeName === 'codeBlock').map(c => serializeBlock(c)).join('\n\n')
       const parts = [nonCode]
@@ -284,7 +324,7 @@ function serializeBlock(el: Y.XmlElement | Y.XmlText, indent = ''): string {
 
     case 'fieldGroup': {
       const fields = el.toArray()
-        .filter((c): c is Y.XmlElement => c instanceof Y.XmlElement)
+        .filter((c): c is Y.XmlElement => isXElem(c))
         .map(c => serializeBlock(c))
         .join('\n\n')
       return `::field-group\n${fields}\n::`
@@ -299,10 +339,10 @@ function serializeBlock(el: Y.XmlElement | Y.XmlText, indent = ''): string {
 function serializeChildren(el: Y.XmlElement | Y.XmlFragment): string {
   const blocks: string[] = []
   for (const child of el.toArray()) {
-    if (child instanceof Y.XmlElement) {
+    if (isXElem(child)) {
       const text = serializeBlock(child)
       if (text) blocks.push(text)
-    } else if (child instanceof Y.XmlText) {
+    } else if (isXText(child)) {
       const text = serializeDelta(child.toDelta())
       if (text) blocks.push(text)
     }
@@ -314,12 +354,12 @@ function serializeListItems(el: Y.XmlElement, type: 'bullet' | 'ordered', indent
   const lines: string[] = []
   let counter = 1
   for (const child of el.toArray()) {
-    if (!(child instanceof Y.XmlElement) || child.nodeName !== 'listItem') continue
+    if (!(isXElem(child)) || child.nodeName !== 'listItem') continue
     const prefix = type === 'bullet' ? '- ' : `${counter++}. `
     // A listItem may contain paragraphs and nested lists
     const subParts: string[] = []
     for (const sub of child.toArray()) {
-      if (!(sub instanceof Y.XmlElement)) continue
+      if (!(isXElem(sub))) continue
       if (sub.nodeName === 'bulletList') {
         subParts.push(serializeListItems(sub, 'bullet', indent + '  '))
       } else if (sub.nodeName === 'orderedList') {
@@ -344,14 +384,14 @@ function serializeListItems(el: Y.XmlElement, type: 'bullet' | 'ordered', indent
 function serializeTaskList(el: Y.XmlElement, indent: string): string {
   const lines: string[] = []
   for (const child of el.toArray()) {
-    if (!(child instanceof Y.XmlElement) || child.nodeName !== 'taskItem') continue
+    if (!(isXElem(child)) || child.nodeName !== 'taskItem') continue
     const checked: unknown = child.getAttribute('checked')
     const marker = (checked === true || checked === 'true') ? '[x]' : '[ ]'
 
     let header = ''
     const nestedParts: string[] = []
     for (const sub of child.toArray()) {
-      if (!(sub instanceof Y.XmlElement)) continue
+      if (!(isXElem(sub))) continue
       if (sub.nodeName === 'paragraph' && header === '') {
         header = serializeInline(sub)
       }
@@ -377,7 +417,7 @@ function serializeTaskList(el: Y.XmlElement, indent: string): string {
 
 function getCodeBlockText(el: Y.XmlElement): string {
   for (const child of el.toArray()) {
-    if (child instanceof Y.XmlText) {
+    if (isXText(child)) {
       return child.toString()
     }
   }
@@ -385,17 +425,17 @@ function getCodeBlockText(el: Y.XmlElement): string {
 }
 
 function serializeTable(el: Y.XmlElement): string {
-  const rows = el.toArray().filter((c): c is Y.XmlElement => c instanceof Y.XmlElement)
+  const rows = el.toArray().filter((c): c is Y.XmlElement => isXElem(c))
   if (!rows.length) return ''
 
   const serializedRows: string[][] = []
   for (const row of rows) {
     const cells = row.toArray()
-      .filter((c): c is Y.XmlElement => c instanceof Y.XmlElement)
+      .filter((c): c is Y.XmlElement => isXElem(c))
       .map((cell) => {
         // Cell contains paragraphs — join their text
         return cell.toArray()
-          .filter((c): c is Y.XmlElement => c instanceof Y.XmlElement)
+          .filter((c): c is Y.XmlElement => isXElem(c))
           .map(c => serializeInline(c))
           .join(' ')
       })
@@ -424,7 +464,7 @@ function serializeSlottedContainer(
   childName: string,
   slotPrefix: string
 ): string {
-  const items = el.toArray().filter((c): c is Y.XmlElement => c instanceof Y.XmlElement && c.nodeName === childName)
+  const items = el.toArray().filter((c): c is Y.XmlElement => isXElem(c) && c.nodeName === childName)
   const slots = items.map((item) => {
     const label = item.getAttribute('label') ?? ''
     const icon = item.getAttribute('icon') ?? ''
@@ -493,7 +533,7 @@ function escapeYaml(s: string): string {
 // ── HTML serialization ──────────────────────────────────────────────────────
 
 function serializeBlockToHtml(el: Y.XmlElement | Y.XmlText): string {
-  if (el instanceof Y.XmlText) {
+  if (isXText(el)) {
     return serializeDeltaToHtml(el.toDelta())
   }
 
@@ -521,7 +561,9 @@ function serializeBlockToHtml(el: Y.XmlElement | Y.XmlText): string {
       return `<ul>${serializeTaskListHtml(el)}</ul>`
 
     case 'codeBlock': {
-      const lang = el.getAttribute('language') ?? ''
+      // Restrict the language to a safe identifier charset — it is interpolated
+      // into a class attribute below; an unsanitised value is a stored-XSS sink.
+      const lang = (el.getAttribute('language') ?? '').replace(/[^\w.-]/g, '')
       const code = escapeHtml(getCodeBlockText(el))
       return lang
         ? `<pre><code class="language-${lang}">${code}</code></pre>`
@@ -530,7 +572,7 @@ function serializeBlockToHtml(el: Y.XmlElement | Y.XmlText): string {
 
     case 'blockquote': {
       const inner = el.toArray()
-        .filter((c): c is Y.XmlElement => c instanceof Y.XmlElement)
+        .filter((c): c is Y.XmlElement => isXElem(c))
         .map(c => serializeBlockToHtml(c))
         .join('\n')
       return `<blockquote>\n${inner}\n</blockquote>`
@@ -558,8 +600,8 @@ function serializeBlockToHtml(el: Y.XmlElement | Y.XmlText): string {
     default: {
       // Generic wrapper for MDC blocks etc.
       const inner = el.toArray()
-        .filter((c): c is Y.XmlElement | Y.XmlText => c instanceof Y.XmlElement || c instanceof Y.XmlText)
-        .map(c => c instanceof Y.XmlElement ? serializeBlockToHtml(c) : serializeDeltaToHtml(c.toDelta()))
+        .filter((c): c is Y.XmlElement | Y.XmlText => isXElem(c) || isXText(c))
+        .map(c => isXElem(c) ? serializeBlockToHtml(c) : serializeDeltaToHtml(c.toDelta()))
         .join('\n')
       return `<div data-type="${name}">\n${inner}\n</div>`
     }
@@ -569,9 +611,9 @@ function serializeBlockToHtml(el: Y.XmlElement | Y.XmlText): string {
 function serializeInlineHtml(el: Y.XmlElement | Y.XmlFragment): string {
   const parts: string[] = []
   for (const child of el.toArray()) {
-    if (child instanceof Y.XmlText) {
+    if (isXText(child)) {
       parts.push(serializeDeltaToHtml(child.toDelta()))
-    } else if (child instanceof Y.XmlElement) {
+    } else if (isXElem(child)) {
       parts.push(serializeInlineHtml(child))
     }
   }
@@ -599,34 +641,34 @@ function serializeDeltaToHtml(delta: any[]): string {
 
 function serializeListHtml(el: Y.XmlElement): string {
   return el.toArray()
-    .filter((c): c is Y.XmlElement => c instanceof Y.XmlElement && c.nodeName === 'listItem')
-    .map(li => `<li>${li.toArray().filter((c): c is Y.XmlElement => c instanceof Y.XmlElement).map(c => serializeBlockToHtml(c)).join('')}</li>`)
+    .filter((c): c is Y.XmlElement => isXElem(c) && c.nodeName === 'listItem')
+    .map(li => `<li>${li.toArray().filter((c): c is Y.XmlElement => isXElem(c)).map(c => serializeBlockToHtml(c)).join('')}</li>`)
     .join('\n')
 }
 
 function serializeTaskListHtml(el: Y.XmlElement): string {
   return el.toArray()
-    .filter((c): c is Y.XmlElement => c instanceof Y.XmlElement && c.nodeName === 'taskItem')
+    .filter((c): c is Y.XmlElement => isXElem(c) && c.nodeName === 'taskItem')
     .map((ti) => {
       const rawChecked: unknown = ti.getAttribute('checked')
       const checked = rawChecked === true || rawChecked === 'true'
-      const text = ti.toArray().filter((c): c is Y.XmlElement => c instanceof Y.XmlElement).map(c => serializeInlineHtml(c)).join('')
+      const text = ti.toArray().filter((c): c is Y.XmlElement => isXElem(c)).map(c => serializeInlineHtml(c)).join('')
       return `<li><input type="checkbox"${checked ? ' checked' : ''} disabled> ${text}</li>`
     })
     .join('\n')
 }
 
 function serializeTableHtml(el: Y.XmlElement): string {
-  const rows = el.toArray().filter((c): c is Y.XmlElement => c instanceof Y.XmlElement)
+  const rows = el.toArray().filter((c): c is Y.XmlElement => isXElem(c))
   if (!rows.length) return ''
 
   const htmlRows = rows.map((row, ri) => {
     const tag = ri === 0 ? 'th' : 'td'
     const cells = row.toArray()
-      .filter((c): c is Y.XmlElement => c instanceof Y.XmlElement)
+      .filter((c): c is Y.XmlElement => isXElem(c))
       .map((cell) => {
         const inner = cell.toArray()
-          .filter((c): c is Y.XmlElement => c instanceof Y.XmlElement)
+          .filter((c): c is Y.XmlElement => isXElem(c))
           .map(c => serializeInlineHtml(c))
           .join('')
         return `<${tag}>${inner}</${tag}>`
@@ -650,6 +692,7 @@ export function yjsToMarkdown(
   meta?: DocPageMeta,
   type?: string
 ): string {
+  fragment = localizeFragment(fragment)
   // The title can come from three places. We honour where the parser
   // captured it so the wire form round-trips byte-stably:
   //   - 'h1'           → emit `# title` as the first body block
@@ -697,7 +740,7 @@ function readDocumentMeta(fragment: Y.XmlFragment): { meta: DocPageMeta, type?:
   const meta: DocPageMeta = {}
   let type: string | undefined
   for (const child of fragment.toArray()) {
-    if (!(child instanceof Y.XmlElement) || child.nodeName !== 'documentMeta') continue
+    if (!(isXElem(child)) || child.nodeName !== 'documentMeta') continue
     const attrs = child.getAttributes() as Record<string, unknown>
     for (const k of Object.keys(attrs)) {
       const v = attrs[k]
@@ -718,8 +761,8 @@ interface HeaderInfo { text: string, source?: 'h1' | 'frontmatter' }
 
 function readDocumentHeader(fragment: Y.XmlFragment): HeaderInfo {
   for (const child of fragment.toArray()) {
-    if (!(child instanceof Y.XmlElement) || child.nodeName !== 'documentHeader') continue
-    const text = child.toArray().find(c => c instanceof Y.XmlText) as Y.XmlText | undefined
+    if (!(isXElem(child)) || child.nodeName !== 'documentHeader') continue
+    const text = child.toArray().find(c => isXText(c)) as Y.XmlText | undefined
     const src: unknown = child.getAttribute('titleSource')
     const source = src === 'h1' || src === 'frontmatter' ? src : undefined
     return { text: text ? text.toString() : '', source }
@@ -730,7 +773,7 @@ function readDocumentHeader(fragment: Y.XmlFragment): HeaderInfo {
 function collectBodyBlocks(fragment: Y.XmlFragment): Y.XmlElement[] {
   const out: Y.XmlElement[] = []
   for (const child of fragment.toArray()) {
-    if (!(child instanceof Y.XmlElement)) continue
+    if (!(isXElem(child))) continue
     if (child.nodeName === 'documentHeader' || child.nodeName === 'documentMeta') continue
     out.push(child)
   }
@@ -770,9 +813,10 @@ function isMetaEmpty(meta: DocPageMeta | undefined): boolean {
  * accessibility tooling, search indexing, and snippet previews.
  */
 export function yjsToPlainText(fragment: Y.XmlFragment): string {
+  fragment = localizeFragment(fragment)
   const out: string[] = []
   const visit = (node: Y.XmlElement | Y.XmlText): void => {
-    if (node instanceof Y.XmlText) {
+    if (isXText(node)) {
       out.push(node.toString())
       return
     }
@@ -783,7 +827,7 @@ export function yjsToPlainText(fragment: Y.XmlFragment): string {
       return
     }
     for (const child of node.toArray()) {
-      if (child instanceof Y.XmlText || child instanceof Y.XmlElement) visit(child)
+      if (isXText(child) || isXElem(child)) visit(child)
     }
     // Insert a single newline after block-level elements so paragraphs
     // and headings produce a readable plain-text form.
@@ -791,7 +835,7 @@ export function yjsToPlainText(fragment: Y.XmlFragment): string {
     out.push('\n')
   }
   for (const child of fragment.toArray()) {
-    if (child instanceof Y.XmlText || child instanceof Y.XmlElement) visit(child)
+    if (isXText(child) || isXElem(child)) visit(child)
   }
   return out.join('').replace(/\n+$/, '').replace(/\n{3,}/g, '\n\n')
 }
@@ -800,10 +844,11 @@ export function yjsToHtml(
   fragment: Y.XmlFragment,
   label: string
 ): string {
+  fragment = localizeFragment(fragment)
   const title = escapeHtml(label)
   const bodyParts: string[] = []
   for (const child of fragment.toArray()) {
-    if (child instanceof Y.XmlElement) {
+    if (isXElem(child)) {
       const html = serializeBlockToHtml(child)
       if (html) bodyParts.push(html)
     }