@abraca/nuxt 0.3.0 → 1.5.0

package/dist/runtime/utils/docReferenceEdges.js

@@ -0,0 +1,122 @@
+import { ref, computed, watch, onUnmounted } from "vue";
+import * as Y from "yjs";
+const DOC_LINK_RE = /^\/doc\/([\w-]+)/;
+export function scanDocReferences(fragment) {
+  const refs = [];
+  function walk(el) {
+    for (const child of el.toArray()) {
+      if (child instanceof Y.XmlText) {
+        for (const delta of child.toDelta()) {
+          const href = delta.attributes?.link?.href;
+          if (href) {
+            const m = DOC_LINK_RE.exec(href);
+            if (m) refs.push(m[1]);
+          }
+        }
+      } else if (child instanceof Y.XmlElement) {
+        if (child.nodeName === "docEmbed") {
+          const docId = child.getAttribute("docId");
+          if (docId) refs.push(docId);
+        }
+        walk(child);
+      }
+    }
+  }
+  walk(fragment);
+  return refs;
+}
+export function useDocReferenceEdges(childProviderRef, allEntries) {
+  const refMap = ref(/* @__PURE__ */ new Map());
+  const observers = /* @__PURE__ */ new Map();
+  const loaded = /* @__PURE__ */ new Set();
+  const debounceTimers = /* @__PURE__ */ new Map();
+  let destroyed = false;
+  function scanAndStore(docId, fragment) {
+    const refs = scanDocReferences(fragment);
+    const prev = refMap.value.get(docId);
+    if (!prev || prev.length !== refs.length || prev.some((r, i) => r !== refs[i])) {
+      const next = new Map(refMap.value);
+      next.set(docId, refs);
+      refMap.value = next;
+    }
+  }
+  function observeFragment(docId, fragment) {
+    const handler = () => {
+      const existing = debounceTimers.get(docId);
+      if (existing) clearTimeout(existing);
+      debounceTimers.set(docId, setTimeout(() => {
+        debounceTimers.delete(docId);
+        if (!destroyed) scanAndStore(docId, fragment);
+      }, 500));
+    };
+    fragment.observeDeep(handler);
+    observers.set(docId, () => fragment.unobserveDeep(handler));
+  }
+  async function loadBatch(ids) {
+    const provider = childProviderRef.value;
+    if (!provider) return;
+    for (let i = 0; i < ids.length; i += 5) {
+      if (destroyed) return;
+      const batch = ids.slice(i, i + 5);
+      await Promise.all(batch.map(async (id) => {
+        if (loaded.has(id) || destroyed) return;
+        loaded.add(id);
+        try {
+          const childProv = await provider.loadChild(id);
+          if (destroyed) return;
+          const doc = childProv.document;
+          const fragment = doc.getXmlFragment("default");
+          scanAndStore(id, fragment);
+          observeFragment(id, fragment);
+        } catch {
+        }
+      }));
+      if (i + 5 < ids.length) {
+        await new Promise((r) => setTimeout(r, 0));
+      }
+    }
+  }
+  watch(allEntries, (entries) => {
+    const entryIds = new Set(entries.map((e) => e.id));
+    for (const [id, cleanup] of observers) {
+      if (!entryIds.has(id)) {
+        cleanup();
+        observers.delete(id);
+        loaded.delete(id);
+        const timer = debounceTimers.get(id);
+        if (timer) {
+          clearTimeout(timer);
+          debounceTimers.delete(id);
+        }
+        if (refMap.value.has(id)) {
+          const next = new Map(refMap.value);
+          next.delete(id);
+          refMap.value = next;
+        }
+      }
+    }
+    const toLoad = entries.map((e) => e.id).filter((id) => !loaded.has(id));
+    if (toLoad.length > 0) loadBatch(toLoad);
+  }, { immediate: true });
+  onUnmounted(() => {
+    destroyed = true;
+    for (const cleanup of observers.values()) cleanup();
+    observers.clear();
+    for (const timer of debounceTimers.values()) clearTimeout(timer);
+    debounceTimers.clear();
+  });
+  const edges = computed(() => {
+    const entryIds = new Set(allEntries.value.map((e) => e.id));
+    const result = [];
+    for (const [sourceId, targetIds] of refMap.value) {
+      if (!entryIds.has(sourceId)) continue;
+      for (const targetId of targetIds) {
+        if (entryIds.has(targetId) && targetId !== sourceId) {
+          result.push({ source: sourceId, target: targetId });
+        }
+      }
+    }
+    return result;
+  });
+  return edges;
+}

package/dist/runtime/utils/docTypes.d.ts

@@ -120,7 +120,12 @@ export interface IconField {
     options: string[];
     label?: string;
 }
-export type MetaField = DatetimeRangeField | DateRangeField | TimeRangeField | DatetimeField | DateField | TimeField | SliderField | ColorPresetField | ColorPickerField | LocationField | IconField | TextareaField | NumberField | ToggleField | SelectField | MultiSelectField | UrlField | RatingField | TagsField;
+export interface MembersField {
+    type: 'members';
+    key: string;
+    label?: string;
+}
+export type MetaField = DatetimeRangeField | DateRangeField | TimeRangeField | DatetimeField | DateField | TimeField | SliderField | ColorPresetField | ColorPickerField | LocationField | IconField | TextareaField | NumberField | ToggleField | SelectField | MultiSelectField | UrlField | RatingField | TagsField | MembersField;
 export interface DocTypeDefinition {
     key: string;
     label: string;

package/dist/runtime/utils/duplicateDocContent.d.ts

@@ -0,0 +1,19 @@
+export interface DupEntry {
+    label: string;
+    parentId: string | null;
+    order: number;
+    type?: string;
+    meta?: Record<string, any>;
+}
+/**
+ * Deep-duplicate a document and all its descendants.
+ *
+ * @param provider     The provider whose `loadChild` can reach every doc being copied.
+ * @param sourceId     ID of the root document to duplicate.
+ * @param treeData     Snapshot of the flat tree map (all entries).
+ * @param setEntry     Callback to write a new entry into the CRDT map.
+ * @returns            The new ID assigned to the duplicated root document.
+ */
+export declare function duplicateDocTree(provider: any, sourceId: string, treeData: Record<string, DupEntry>, setEntry: (id: string, entry: DupEntry) => void): Promise<string>;
+/** Single-doc content copy. */
+export declare const duplicateDocContent: (parentProvider: any, sourceId: string, destId: string) => Promise<void>;

package/dist/runtime/utils/duplicateDocContent.js

@@ -0,0 +1,68 @@
+import * as Y from "yjs";
+async function copyYDoc(parentProvider, sourceId, destId) {
+  const srcProv = await parentProvider.loadChild(sourceId);
+  if (!srcProv.isSynced) {
+    await new Promise((resolve) => {
+      const done = () => {
+        srcProv.off("synced", done);
+        resolve();
+      };
+      srcProv.on("synced", done);
+      setTimeout(resolve, 6e3);
+    });
+  }
+  const state = Y.encodeStateAsUpdate(srcProv.document);
+  const dstProv = await parentProvider.loadChild(destId);
+  if (!dstProv.isSynced) {
+    await new Promise((resolve) => {
+      const done = () => {
+        dstProv.off("synced", done);
+        resolve();
+      };
+      dstProv.on("synced", done);
+      setTimeout(resolve, 6e3);
+    });
+  }
+  Y.applyUpdate(dstProv.document, state);
+}
+export async function duplicateDocTree(provider, sourceId, treeData, setEntry) {
+  const sourceEntry = treeData[sourceId];
+  if (!sourceEntry) return sourceId;
+  const allIds = [];
+  const queue = [sourceId];
+  while (queue.length) {
+    const current = queue.shift();
+    allIds.push(current);
+    for (const [id, entry] of Object.entries(treeData)) {
+      if (entry.parentId === current) queue.push(id);
+    }
+  }
+  const idMap = /* @__PURE__ */ new Map();
+  for (const id of allIds) idMap.set(id, crypto.randomUUID());
+  const newRootId = idMap.get(sourceId);
+  for (const id of allIds) {
+    const entry = treeData[id];
+    if (!entry) continue;
+    const newId = idMap.get(id);
+    const isRoot = id === sourceId;
+    const newParentId = isRoot ? entry.parentId : idMap.get(entry.parentId) ?? entry.parentId;
+    setEntry(newId, {
+      ...entry,
+      label: isRoot ? `${entry.label || "Untitled"} (copy)` : entry.label,
+      parentId: newParentId,
+      order: isRoot ? Date.now() : entry.order
+    });
+  }
+  await Promise.all(
+    allIds.map(async (id) => {
+      const newId = idMap.get(id);
+      try {
+        await copyYDoc(provider, id, newId);
+      } catch (e) {
+        console.warn(`duplicateDocTree: failed to copy YDoc ${id} \u2192 ${newId}:`, e);
+      }
+    })
+  );
+  return newRootId;
+}
+export const duplicateDocContent = (parentProvider, sourceId, destId) => copyYDoc(parentProvider, sourceId, destId);

package/dist/runtime/utils/extractFileMetadata.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Extracts metadata from image/audio/video files.
+ * EXIF for images (GPS, camera info), ID3/Vorbis for audio, dimensions for video.
+ * All peer dependencies (exifr, music-metadata) are optional — gracefully degrades.
+ *
+ * Ported from cou-sh/app/utils/extractFileMetadata.ts
+ */
+import type { DocPageMeta } from '../types.js';
+interface ExtractedMeta extends Partial<DocPageMeta> {
+    _extractedTitle?: string;
+}
+export declare function extractFileMetadata(file: File): Promise<ExtractedMeta>;
+export {};

package/dist/runtime/utils/extractFileMetadata.js

@@ -0,0 +1,94 @@
+export async function extractFileMetadata(file) {
+  const mt = file.type || "";
+  if (mt.startsWith("image/")) return extractImageMeta(file);
+  if (mt.startsWith("audio/")) return extractAudioMeta(file);
+  if (mt.startsWith("video/")) return extractVideoMeta(file);
+  return {};
+}
+async function extractImageMeta(file) {
+  const meta = {};
+  try {
+    const exifrModule = await import("exifr");
+    const exifr = exifrModule.default || exifrModule;
+    const exif = await exifr.parse(file, { gps: true, tiff: true, exif: true, ifd0: true });
+    if (exif) {
+      if (exif.latitude != null && exif.longitude != null) {
+        meta.geoLat = exif.latitude;
+        meta.geoLng = exif.longitude;
+      }
+      if (exif.DateTimeOriginal instanceof Date) {
+        meta.dateTaken = exif.DateTimeOriginal.toISOString();
+      }
+      const make = exif.Make?.trim();
+      const model = exif.Model?.trim();
+      if (make && model) meta.mediaCamera = model.startsWith(make) ? model : `${make} ${model}`;
+      else if (model) meta.mediaCamera = model;
+      if (exif.LensModel) meta.mediaLens = exif.LensModel;
+      if (exif.ISO != null) meta.mediaIso = exif.ISO;
+      if (exif.FocalLength != null) meta.mediaFocalLength = exif.FocalLength;
+      if (exif.FNumber != null) meta.mediaAperture = exif.FNumber;
+      if (exif.ExposureTime != null) {
+        meta.mediaShutterSpeed = exif.ExposureTime < 1 ? `1/${Math.round(1 / exif.ExposureTime)}` : `${exif.ExposureTime}s`;
+      }
+      if (exif.Artist) meta.mediaArtist = exif.Artist;
+      if (exif.ImageWidth) meta.mediaWidth = exif.ImageWidth;
+      if (exif.ImageHeight) meta.mediaHeight = exif.ImageHeight;
+    }
+  } catch {
+  }
+  if (!meta.mediaWidth || !meta.mediaHeight) {
+    try {
+      const bmp = await createImageBitmap(file);
+      meta.mediaWidth = bmp.width;
+      meta.mediaHeight = bmp.height;
+      bmp.close();
+    } catch {
+    }
+  }
+  return meta;
+}
+async function extractAudioMeta(file) {
+  const meta = {};
+  try {
+    const { parseBlob } = await import("music-metadata");
+    const mm = await Promise.race([
+      parseBlob(file),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("Audio metadata timeout")), 5e3)
+      )
+    ]);
+    if (mm.common.title) meta._extractedTitle = mm.common.title;
+    if (mm.common.artist) meta.mediaArtist = mm.common.artist;
+    if (mm.common.album) meta.mediaAlbum = mm.common.album;
+    if (mm.common.year) meta.mediaYear = mm.common.year;
+    if (mm.common.genre?.length) meta.mediaGenre = mm.common.genre[0];
+    if (mm.format.duration) meta.mediaDuration = Math.round(mm.format.duration);
+  } catch {
+  }
+  return meta;
+}
+async function extractVideoMeta(file) {
+  const meta = {};
+  try {
+    const url = URL.createObjectURL(file);
+    try {
+      const video = document.createElement("video");
+      video.preload = "metadata";
+      video.src = url;
+      await new Promise((resolve, reject) => {
+        video.onloadedmetadata = () => resolve();
+        video.onerror = () => reject(new Error("Failed to load video metadata"));
+        setTimeout(() => resolve(), 5e3);
+      });
+      if (video.duration && Number.isFinite(video.duration)) {
+        meta.mediaDuration = Math.round(video.duration);
+      }
+      if (video.videoWidth) meta.mediaWidth = video.videoWidth;
+      if (video.videoHeight) meta.mediaHeight = video.videoHeight;
+    } finally {
+      URL.revokeObjectURL(url);
+    }
+  } catch {
+  }
+  return meta;
+}

package/dist/runtime/utils/getMetaColor.d.ts

@@ -0,0 +1,6 @@
+import type { DocPageMeta } from '../types.js';
+/**
+ * Extracts a color string from document metadata.
+ * Checks `meta.color` first, then scans user-defined color fields.
+ */
+export declare function getMetaColor(meta: DocPageMeta | undefined): string | undefined;

package/dist/runtime/utils/getMetaColor.js

@@ -0,0 +1,12 @@
+export function getMetaColor(meta) {
+  if (!meta) return void 0;
+  if (typeof meta.color === "string" && meta.color) return meta.color;
+  const userColorField = meta._metaFields?.find(
+    (f) => (f.type === "colorPreset" || f.type === "colorPicker") && f.key
+  );
+  if (userColorField?.key) {
+    const val = meta[userColorField.key];
+    if (typeof val === "string" && val) return val;
+  }
+  return void 0;
+}

package/dist/runtime/utils/htmlToYjs.d.ts

@@ -0,0 +1,19 @@
+/**
+ * HTML → Y.js converter.
+ *
+ * Uses DOMParser to parse HTML, then walks the DOM tree and writes
+ * TipTap-compatible Y.XmlElement nodes into the fragment.
+ *
+ * Ported from cou-sh/app/utils/htmlToYjs.ts.
+ */
+import * as Y from 'yjs';
+/**
+ * Parses an HTML string and writes the result into a Y.XmlFragment that
+ * TipTap's Collaboration extension can read.
+ */
+export declare function populateYDocFromHtml(fragment: Y.XmlFragment, html: string, fallbackTitle?: string): void;
+/**
+ * Appends blocks from an HTML string to an existing Y.XmlFragment.
+ * Does NOT insert documentHeader/documentMeta.
+ */
+export declare function appendHtmlToFragment(fragment: Y.XmlFragment, html: string): void;

package/dist/runtime/utils/htmlToYjs.js

@@ -0,0 +1,235 @@
+import * as Y from "yjs";
+function langFromClass(el) {
+  for (const cls of el.classList) {
+    if (cls.startsWith("language-")) return cls.slice(9);
+  }
+  return "";
+}
+function mergeMarks(stack) {
+  const merged = {};
+  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;
+}
+function collectInlineRuns(node, markStack) {
+  const runs = [];
+  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;
+  const tag = el.tagName.toLowerCase();
+  const newMarks = {};
+  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 el.childNodes) {
+    runs.push(...collectInlineRuns(child, nextStack));
+  }
+  return runs;
+}
+function fillInlineRuns(paraEl, runs) {
+  if (!runs.length) return;
+  const xtNodes = runs.map(() => new Y.XmlText());
+  paraEl.insert(0, xtNodes);
+  runs.forEach((run, i) => {
+    const attrs = {};
+    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);
+    }
+  });
+}
+function convertBlockElement(el, container) {
+  const tag = el.tagName.toLowerCase();
+  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;
+  }
+  const headingMatch = tag.match(/^h([1-6])$/);
+  if (headingMatch) {
+    const level = Number.parseInt(headingMatch[1]);
+    const headingEl = new Y.XmlElement("heading");
+    container.insert(container.length, [headingEl]);
+    headingEl.setAttribute("level", level);
+    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]);
+    const paraEl = new Y.XmlElement("paragraph");
+    bqEl.insert(0, [paraEl]);
+    fillInlineRuns(paraEl, collectInlineRuns(el, []));
+    return;
+  }
+  if (tag === "ul" || tag === "ol") {
+    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"]');
+        const checked = checkbox?.checked ?? false;
+        taskItemEls[i].setAttribute("checked", checked);
+        const paraEl = new Y.XmlElement("paragraph");
+        taskItemEls[i].insert(0, [paraEl]);
+        const clone = li.cloneNode(true);
+        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;
+  }
+  const text = (el.textContent ?? "").trim();
+  if (text) {
+    const paraEl = new Y.XmlElement("paragraph");
+    container.insert(container.length, [paraEl]);
+    fillInlineRuns(paraEl, collectInlineRuns(el, []));
+  }
+}
+const BLOCK_TAGS = /* @__PURE__ */ new Set([
+  "p",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "ul",
+  "ol",
+  "pre",
+  "blockquote",
+  "table",
+  "hr",
+  "div",
+  "section",
+  "article",
+  "header",
+  "footer",
+  "main",
+  "aside"
+]);
+export function populateYDocFromHtml(fragment, html, fallbackTitle = "Untitled") {
+  const ydoc = fragment.doc;
+  if (!ydoc) return;
+  const doc = new DOMParser().parseFromString(html, "text/html");
+  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);
+    let hasContent = false;
+    for (const child of doc.body.children) {
+      const tag = child.tagName.toLowerCase();
+      if (!BLOCK_TAGS.has(tag)) continue;
+      if (tag === "h1" && child === firstH1) continue;
+      convertBlockElement(child, fragment);
+      hasContent = true;
+    }
+    if (!hasContent) {
+      const paraEl = new Y.XmlElement("paragraph");
+      fragment.insert(fragment.length, [paraEl]);
+    }
+  });
+}
+export function appendHtmlToFragment(fragment, html) {
+  const ydoc = fragment.doc;
+  if (!ydoc) return;
+  const doc = new DOMParser().parseFromString(html, "text/html");
+  ydoc.transact(() => {
+    for (const child of doc.body.children) {
+      if (BLOCK_TAGS.has(child.tagName.toLowerCase()))
+        convertBlockElement(child, fragment);
+    }
+  });
+}

package/dist/runtime/utils/markdownToYjs.js

@@ -179,7 +179,7 @@ function parseBlocks(markdown) {
   let i = 0;
   while (i < lines.length) {
     const line = lines[i];
-    const fenceBlockMatch = line.match(/^(`{3,})(.*)$/);
+    const fenceBlockMatch = line.match(/^(`{3,})([^`]*)$/);
     if (fenceBlockMatch) {
       const fence = fenceBlockMatch[1];
       const lang = fenceBlockMatch[2].trim().replace(/\{[^}]*\}$/, "").replace(/\s*\[.*\]$/, "").trim();
@@ -237,7 +237,7 @@ function parseBlocks(markdown) {
       }
       continue;
     }
-    const MDC_OPEN = /^\s*(:{2,})(\w[\w-]*)(\{[^}]*\})?\s*$/;
+    const MDC_OPEN = /^\s*:{2,}\w[\w-]*(?:\{[^}]*\})?\s*$/;
     if (MDC_OPEN.test(line)) {
       const colons = line.match(/^\s*(:+)/)?.[1]?.length ?? 2;
       i++;
@@ -286,7 +286,7 @@ function parseBlocks(markdown) {
       continue;
     }
     const paraLines = [];
-    while (i < lines.length && lines[i].trim() !== "" && !/^(#{1,6}\s|[-*+]\s|\d+\.\s|>|`{3,}|\s*\||[-*_]{3,}\s*$|\s*:{2,}\w)/.test(lines[i])) {
+    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++;
     }

package/dist/runtime/utils/metaFieldDefinitions.js

@@ -178,5 +178,14 @@ export const META_FIELD_DEFINITIONS = [
       const t = Date.now();
       return { fieldType: "icon", fieldLabel: "Icon", userDefined: true, metaKey: `_icon_${t}` };
     }
+  },
+  {
+    label: "Members",
+    icon: "i-lucide-users",
+    kind: "metaFieldMembers",
+    buildAttrs: () => {
+      const t = Date.now();
+      return { fieldType: "members", fieldLabel: "Members", userDefined: true, metaKey: `_members_${t}` };
+    }
   }
 ];

package/dist/runtime/utils/notificationRenderers.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Notification rendering utilities.
+ *
+ * Converts notification payloads into VNodes for toast descriptions,
+ * handling doc-quote, doc-link, and rich text with @mentions and URLs.
+ *
+ * Ported from cou-sh/app/utils/notificationRenderers.ts.
+ */
+import { type VNode } from 'vue';
+/**
+ * Render a rich notification description as a VNode for toast `description` fields.
+ */
+export declare function renderNotificationDescription(body: string): VNode | string;