@abraca/convert 2.3.0

package/dist/abracadabra-convert.esm.js

@@ -0,0 +1,3163 @@
+import * as Y from "yjs";
+
+//#region packages/convert/src/markdown-to-yjs.ts
+/**
+* Converts a filename (without extension) to a human-readable label.
+*
+* - `this-is-a-doc`  → `"This is a doc"`   (kebab/snake: sentence case)
+* - `ThisIsADoc`     → `"This Is A Doc"`   (PascalCase: preserves word caps)
+* - `thisIsADoc`     → `"This Is A Doc"`   (camelCase: preserves word caps)
+*/
+function filenameToLabel(raw) {
+	const clean = raw.replace(/\.[^.]+$/, "").replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[-_.]+/g, " ").replace(/\s+/g, " ").trim();
+	return clean.charAt(0).toUpperCase() + clean.slice(1);
+}
+function parseInlineArray(raw) {
+	return raw.slice(1, -1).split(",").map((s) => s.trim()).filter(Boolean);
+}
+function stripQuotes(s) {
+	if (s.length >= 2 && (s.startsWith("\"") && s.endsWith("\"") || s.startsWith("'") && s.endsWith("'"))) return s.slice(1, -1).replace(/\\"/g, "\"").replace(/\\\\/g, "\\");
+	return s;
+}
+function parseFrontmatter(markdown) {
+	const noResult = {
+		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 = {};
+	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 = [];
+			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).map(stripQuotes);
+			else raw[key] = stripQuotes(val);
+		}
+		i++;
+	}
+	const meta = {};
+	const getStr = (keys) => {
+		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"]];
+	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 !== void 0) meta.priority = {
+		low: 1,
+		medium: 2,
+		high: 3,
+		urgent: 4
+	}[priorityRaw.toLowerCase()] ?? (Number(priorityRaw) || 0);
+	const checkedRaw = raw["checked"] ?? raw["done"];
+	if (checkedRaw !== void 0) meta.checked = checkedRaw === "true" || checkedRaw === true;
+	const dateStart = getStr([
+		"dateStart",
+		"date",
+		"created"
+	]);
+	if (dateStart) meta.dateStart = dateStart;
+	const dateEnd = getStr(["dateEnd", "due"]);
+	if (dateEnd) meta.dateEnd = dateEnd;
+	const subtitle = getStr(["subtitle", "description"]);
+	if (subtitle) meta.subtitle = subtitle;
+	const url = getStr(["url"]);
+	if (url) meta.url = url;
+	const ratingRaw = getStr(["rating"]);
+	if (ratingRaw !== void 0) {
+		const n = Number(ratingRaw);
+		if (!Number.isNaN(n)) meta.rating = Math.min(5, Math.max(0, n));
+	}
+	const rawTitle = typeof raw["title"] === "string" ? raw["title"] : void 0;
+	return {
+		title: rawTitle !== void 0 ? stripQuotes(rawTitle) : void 0,
+		type: getStr(["type"]),
+		meta,
+		body
+	};
+}
+function parseInline(text) {
+	const stripped = text.replace(/\{lang="[^"]*"\}/g, "").replace(/:(?!badge|icon|kbd)(\w[\w-]*)\[([^\]]*)\](\{[^}]*\})?/g, "$2").replace(/:(?!badge|icon|kbd)(\w[\w-]*)(\{[^}]*\})/g, "");
+	const tokens = [];
+	const re = /\$([^$\n]+?)\$|@\[([^\]]+?)\]\(user:([^)]+?)\)|:badge\[([^\]]*)\](\{[^}]*\})?|:icon\{([^}]*)\}|:kbd\{([^}]*)\}|\[\[([0-9a-fA-F-]{36})(?:\|([^\]]+?))?\]\]|~~(.+?)~~|\*\*(.+?)\*\*|\*(.+?)\*|_(.+?)_|`(.+?)`|\[(.+?)\]\((.+?)\)/g;
+	let lastIndex = 0;
+	let match;
+	while ((match = re.exec(stripped)) !== null) {
+		if (match.index > lastIndex) tokens.push({ text: stripped.slice(lastIndex, match.index) });
+		if (match[1] !== void 0) tokens.push({
+			text: match[1],
+			attrs: { mathInline: { expression: match[1] } }
+		});
+		else if (match[2] !== void 0 && match[3] !== void 0) tokens.push({
+			text: match[2],
+			attrs: { mention: {
+				userId: match[3],
+				label: match[2]
+			} }
+		});
+		else if (match[4] !== void 0) {
+			const badgeProps = parseMdcProps(match[5]);
+			tokens.push({
+				text: match[4] || "Badge",
+				attrs: { badge: {
+					label: match[4] || "Badge",
+					color: badgeProps["color"] || "neutral",
+					variant: badgeProps["variant"] || "subtle"
+				} }
+			});
+		} else if (match[6] !== void 0) {
+			const iconProps = parseMdcProps(`{${match[6]}}`);
+			tokens.push({
+				text: "​",
+				attrs: { proseIcon: { name: iconProps["name"] || "i-lucide-star" } }
+			});
+		} else if (match[7] !== void 0) {
+			const kbdProps = parseMdcProps(`{${match[7]}}`);
+			tokens.push({
+				text: kbdProps["value"] || "",
+				attrs: { kbd: { value: kbdProps["value"] || "" } }
+			});
+		} else if (match[8] !== void 0) {
+			const docId = match[8];
+			const label = match[9] ?? docId;
+			tokens.push({
+				text: label,
+				attrs: { docLink: { docId } }
+			});
+		} else if (match[10] !== void 0) tokens.push({
+			text: match[10],
+			attrs: { strike: true }
+		});
+		else if (match[11] !== void 0) tokens.push({
+			text: match[11],
+			attrs: { bold: true }
+		});
+		else if (match[12] !== void 0) tokens.push({
+			text: match[12],
+			attrs: { italic: true }
+		});
+		else if (match[13] !== void 0) tokens.push({
+			text: match[13],
+			attrs: { italic: true }
+		});
+		else if (match[14] !== void 0) tokens.push({
+			text: match[14],
+			attrs: { code: true }
+		});
+		else if (match[15] !== void 0 && match[16] !== void 0) tokens.push({
+			text: match[15],
+			attrs: { link: { href: match[16] } }
+		});
+		lastIndex = match.index + match[0].length;
+	}
+	if (lastIndex < stripped.length) tokens.push({ text: stripped.slice(lastIndex) });
+	return tokens.filter((t) => t.text.length > 0);
+}
+function parseTableRow(line) {
+	const parts = line.split("|");
+	return parts.slice(1, parts.length - 1).map((c) => c.trim());
+}
+function isTableSeparator(line) {
+	return /^\|[\s|:-]+\|$/.test(line.trim());
+}
+/** Extract fenced code blocks from MDC #code slot lines. */
+function extractFencedCode(lines) {
+	const result = [];
+	let i = 0;
+	while (i < lines.length) {
+		const fenceMatch = lines[i].match(/^(`{3,})(\w*)/);
+		if (fenceMatch) {
+			const fence = fenceMatch[1];
+			const lang = fenceMatch[2] ?? "";
+			const codeLines = [];
+			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;
+}
+/** Extract key="value" pairs from MDC prop syntax `{key="value" other="x"}` */
+function parseMdcProps(propsStr) {
+	if (!propsStr) return {};
+	const result = {};
+	let s = propsStr.trim();
+	if (s.startsWith("{") && s.endsWith("}")) s = s.slice(1, -1);
+	const re = /(\w[\w-]*)(?:=(?:"([^"]*)"|([^\s"}]+)))?/g;
+	let m;
+	while ((m = re.exec(s)) !== null) {
+		const key = m[1];
+		if (m[2] !== void 0) result[key] = m[2];
+		else if (m[3] !== void 0) result[key] = m[3];
+		else result[key] = "true";
+	}
+	return result;
+}
+/** Parse named child MDC blocks from inner lines (e.g. #item for accordion, #tab for tabs) */
+function parseMdcChildren(innerLines, slotPrefix) {
+	const items = [];
+	let current = 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+(.*)/;
+/**
+* Consume a list (bullet / ordered / task) starting at `start`. Indented
+* continuation lines and nested lists are captured into each item's
+* `innerBlocks` so the parse → serialise → parse cycle preserves tree
+* structure instead of flattening nested lists onto a single line.
+*
+* `indent` is the column of the item marker for the current list. A
+* nested list starts ≥2 columns deeper. Lines with less indent than
+* `indent` belong to the outer block and stop consumption.
+*/
+function consumeList(lines, start, indent, kind) {
+	const items = [];
+	let i = start;
+	while (i < lines.length) {
+		const line = lines[i];
+		if (line.trim() === "") {
+			let j = i + 1;
+			while (j < lines.length && lines[j].trim() === "") j++;
+			if (j >= lines.length) break;
+			const lookahead = lines[j];
+			if (leadingSpaces(lookahead) < indent) break;
+			if (!matchMarker(lookahead.slice(indent), kind)) break;
+			i = j;
+			continue;
+		}
+		const leading = leadingSpaces(line);
+		if (leading < indent) break;
+		if (leading > indent) break;
+		const m = matchMarker(line.slice(indent), kind);
+		if (!m) break;
+		const item = { text: m.text };
+		if (kind === "task") item.checked = m.checked;
+		i++;
+		const contLines = [];
+		while (i < lines.length) {
+			const next = lines[i];
+			if (next.trim() === "") {
+				let k = i + 1;
+				while (k < lines.length && lines[k].trim() === "") k++;
+				if (k >= lines.length) break;
+				if (leadingSpaces(lines[k]) <= indent) break;
+				contLines.push("");
+				i++;
+				continue;
+			}
+			const nextIndent = leadingSpaces(next);
+			if (nextIndent <= indent) break;
+			const deindentBy = Math.min(nextIndent, indent + 2);
+			contLines.push(next.slice(deindentBy));
+			i++;
+		}
+		if (contLines.length > 0) item.innerBlocks = parseBlocks(contLines.join("\n"));
+		items.push(item);
+	}
+	return {
+		items,
+		next: i
+	};
+}
+function leadingSpaces(s) {
+	let n = 0;
+	while (n < s.length && s[n] === " ") n++;
+	return n;
+}
+function matchMarker(s, kind) {
+	if (kind === "task") {
+		const m = s.match(TASK_RE);
+		if (!m) return null;
+		return {
+			text: m[2],
+			checked: m[1].toLowerCase() === "x"
+		};
+	}
+	if (kind === "bullet") {
+		if (TASK_RE.test(s)) return null;
+		const m = s.match(/^[-*+]\s+(.*)$/);
+		if (!m) return null;
+		return {
+			text: m[1],
+			checked: false
+		};
+	}
+	const m = s.match(/^\d+\.\s+(.*)$/);
+	if (!m) return null;
+	return {
+		text: m[1],
+		checked: false
+	};
+}
+function parseBlocks(markdown) {
+	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 = [];
+	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 = [];
+			i++;
+			while (i < lines.length && !lines[i].startsWith(fence)) {
+				codeLines.push(lines[i]);
+				i++;
+			}
+			i++;
+			const code = codeLines.join("\n");
+			if (lang === "math") blocks.push({
+				type: "mathBlock",
+				expression: code
+			});
+			else blocks.push({
+				type: "codeBlock",
+				lang,
+				code
+			});
+			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 embedMatch = line.match(/^!\[\[([0-9a-fA-F-]{36})(?:\|([^\]]+))?\]\](\{[^}]*\})?\s*$/);
+		if (embedMatch) {
+			const docId = embedMatch[1];
+			const label = embedMatch[2] ?? "";
+			const props = parseMdcProps(embedMatch[3]);
+			blocks.push({
+				type: "docEmbed",
+				docId,
+				label,
+				props
+			});
+			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 = [];
+			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 = [];
+			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 atomMatch = line.match(/^:(\w[\w-]*)(\{[^}]*\})?\s*$/);
+		if (atomMatch && atomMatch[1] === "file") {
+			const props = parseMdcProps(atomMatch[2]);
+			const uploadId = props["upload-id"] ?? props["uploadId"] ?? "";
+			const filename = props["filename"] ?? "";
+			const mime = props["mime"] ?? "";
+			const src = props["src"] ?? (uploadId && filename ? `.abracadabra/files/${uploadId}-${filename}` : "");
+			blocks.push({
+				type: "fileBlock",
+				src,
+				mime,
+				uploadId,
+				filename
+			});
+			i++;
+			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 = [];
+			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 = [];
+			const codeSlotLines = [];
+			let currentSlot = "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);
+			if (new Set([
+				"tip",
+				"note",
+				"info",
+				"warning",
+				"caution",
+				"danger",
+				"callout",
+				"alert"
+			]).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, next } = consumeList(lines, i, 0, "task");
+			i = next;
+			blocks.push({
+				type: "taskList",
+				items
+			});
+			continue;
+		}
+		if (/^[-*+]\s+/.test(line)) {
+			const { items, next } = consumeList(lines, i, 0, "bullet");
+			if (items.length > 0) {
+				i = next;
+				blocks.push({
+					type: "bulletList",
+					items
+				});
+				continue;
+			}
+		}
+		if (/^\d+\.\s+/.test(line)) {
+			const { items, next } = consumeList(lines, i, 0, "ordered");
+			if (items.length > 0) {
+				i = next;
+				blocks.push({
+					type: "orderedList",
+					items
+				});
+				continue;
+			}
+		}
+		if (line.trim() === "") {
+			i++;
+			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])) {
+			paraLines.push(lines[i]);
+			i++;
+		}
+		if (paraLines.length) blocks.push({
+			type: "paragraph",
+			text: paraLines.join(" ")
+		});
+	}
+	return blocks;
+}
+/**
+* Insert formatted inline tokens into an already-attached Y.XmlElement.
+* Creates one Y.XmlText per token (attach first, fill second).
+*/
+function fillTextInto(el, tokens) {
+	const filtered = tokens.filter((t) => t.text.length > 0);
+	if (!filtered.length) return;
+	const xtNodes = filtered.map(() => new Y.XmlText());
+	el.insert(0, xtNodes);
+	filtered.forEach((tok, i) => {
+		if (tok.attrs) xtNodes[i].insert(0, tok.text, tok.attrs);
+		else xtNodes[i].insert(0, tok.text);
+	});
+}
+function blockElName(b) {
+	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 "mathBlock": return "mathBlock";
+		case "fileBlock": return "fileBlock";
+	}
+}
+function populateListItemChildren(itemEl, item, _itemKind) {
+	const paraEl = new Y.XmlElement("paragraph");
+	itemEl.insert(itemEl.length, [paraEl]);
+	fillTextInto(paraEl, parseInline(item.text));
+	if (!item.innerBlocks?.length) return;
+	const innerEls = item.innerBlocks.map((b) => new Y.XmlElement(blockElName(b)));
+	itemEl.insert(itemEl.length, innerEls);
+	item.innerBlocks.forEach((b, i) => fillBlock(innerEls[i], b));
+}
+function fillBlock(el, block) {
+	switch (block.type) {
+		case "heading":
+			el.setAttribute("level", block.level);
+			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((item, i) => {
+				populateListItemChildren(listItemEls[i], item, "listItem");
+			});
+			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);
+				populateListItemChildren(taskItemEls[i], item, "taskItem");
+			});
+			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);
+			const inner = block.innerBlocks.length ? block.innerBlocks : [{
+				type: "paragraph",
+				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",
+				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",
+				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",
+				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",
+				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",
+				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",
+					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",
+					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);
+			const inner = block.innerBlocks.length ? block.innerBlocks : [{
+				type: "paragraph",
+				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);
+			for (const flag of [
+				"collapsed",
+				"tall",
+				"seamless"
+			]) if (block.props[flag] === "true" || block.props[flag] === "1") el.setAttribute(flag, true);
+			break;
+		case "mathBlock":
+			el.setAttribute("expression", block.expression);
+			break;
+		case "fileBlock":
+			if (block.src) el.setAttribute("src", block.src);
+			if (block.mime) el.setAttribute("mime", block.mime);
+			if (block.uploadId) el.setAttribute("uploadId", block.uploadId);
+			if (block.filename) el.setAttribute("filename", block.filename);
+			break;
+	}
+}
+/**
+* Parses markdown text and writes the result into a Y.XmlFragment that
+* TipTap's Collaboration extension can read.
+*
+* Requires `fragment.doc` to be set (i.e. the fragment must already be
+* obtained from a live Y.Doc via `ydoc.getXmlFragment('default')`).
+*
+* @param fragment      The target `Y.Doc.getXmlFragment('default')`
+* @param markdown      Raw markdown string
+* @param fallbackTitle Used as the title when the markdown has no H1
+*/
+function populateYDocFromMarkdown(fragment, markdown, fallbackTitle = "Untitled") {
+	const ydoc = fragment.doc;
+	if (!ydoc) {
+		console.warn("[markdownToYjs] fragment has no doc — skipping population");
+		return;
+	}
+	const fm = parseFrontmatter(markdown);
+	const blocks = parseBlocks(fm.body);
+	let title = fallbackTitle;
+	let titleSource;
+	if (fm.title !== void 0) {
+		title = fm.title;
+		titleSource = "frontmatter";
+	}
+	let contentBlocks = blocks;
+	const h1 = blocks.findIndex((b) => b.type === "heading" && b.level === 1);
+	if (h1 !== -1) {
+		title = blocks[h1].text;
+		contentBlocks = blocks.filter((_, i) => i !== h1);
+		titleSource = "h1";
+	}
+	ydoc.transact(() => {
+		const headerEl = new Y.XmlElement("documentHeader");
+		const metaEl = new Y.XmlElement("documentMeta");
+		const bodyEls = 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 "mathBlock": return new Y.XmlElement("mathBlock");
+				case "fileBlock": return new Y.XmlElement("fileBlock");
+			}
+		});
+		fragment.insert(0, [
+			headerEl,
+			metaEl,
+			...bodyEls
+		]);
+		if (titleSource) headerEl.setAttribute("titleSource", titleSource);
+		const headerXt = new Y.XmlText();
+		headerEl.insert(0, [headerXt]);
+		headerXt.insert(0, title);
+		for (const k of Object.keys(fm.meta)) {
+			const v = fm.meta[k];
+			if (v === void 0 || v === null) continue;
+			metaEl.setAttribute(k, v);
+		}
+		if (fm.type) metaEl.setAttribute("type", fm.type);
+		contentBlocks.forEach((block, i) => fillBlock(bodyEls[i], block));
+	});
+}
+
+//#endregion
+//#region packages/convert/src/yjs-to-markdown.ts
+function serializeDelta(delta) {
+	let result = "";
+	for (const op of delta) {
+		if (typeof op.insert !== "string") continue;
+		let text = op.insert;
+		const attrs = op.attributes ?? {};
+		if (attrs.code) {
+			result += `\`${text}\``;
+			continue;
+		}
+		if (attrs.badge) {
+			const b = attrs.badge;
+			const props = [];
+			if (b.color && b.color !== "neutral") props.push(`color="${b.color}"`);
+			if (b.variant && b.variant !== "subtle") props.push(`variant="${b.variant}"`);
+			result += `:badge[${b.label || text}]${props.length ? `{${props.join(" ")}}` : ""}`;
+			continue;
+		}
+		if (attrs.proseIcon) {
+			const icon = attrs.proseIcon.name || "i-lucide-star";
+			result += `:icon{name="${icon}"}`;
+			continue;
+		}
+		if (attrs.kbd) {
+			const value = attrs.kbd.value || text;
+			result += `:kbd{value="${value}"}`;
+			continue;
+		}
+		if (attrs.docLink) {
+			const docId = attrs.docLink.docId;
+			if (docId) {
+				result += text === docId ? `[[${docId}]]` : `[[${docId}|${text}]]`;
+				continue;
+			}
+		}
+		if (attrs.mention) {
+			const { userId, label } = attrs.mention;
+			if (userId) {
+				result += `@[${label || text}](user:${userId})`;
+				continue;
+			}
+		}
+		if (attrs.mathInline) {
+			const expr = attrs.mathInline.expression ?? text;
+			result += `$${expr}$`;
+			continue;
+		}
+		if (attrs.bold) text = `**${text}**`;
+		if (attrs.italic) text = `*${text}*`;
+		if (attrs.strike) text = `~~${text}~~`;
+		if (attrs.link) {
+			const href = attrs.link.href ?? "";
+			text = `[${text}](${href})`;
+		}
+		result += text;
+	}
+	return result;
+}
+function serializeInline(el) {
+	const parts = [];
+	for (const child of el.toArray()) if (child instanceof Y.XmlText) parts.push(serializeDelta(child.toDelta()));
+	else if (child instanceof Y.XmlElement) parts.push(serializeInline(child));
+	return parts.join("");
+}
+function serializeBlock(el, indent = "") {
+	if (el instanceof Y.XmlText) return serializeDelta(el.toDelta());
+	switch (el.nodeName) {
+		case "documentHeader":
+		case "documentMeta": return "";
+		case "heading": {
+			const level = Number(el.getAttribute("level") ?? 2);
+			return `${"#".repeat(level)} ${serializeInline(el)}`;
+		}
+		case "paragraph": return serializeInline(el);
+		case "bulletList": return serializeListItems(el, "bullet", indent);
+		case "orderedList": return serializeListItems(el, "ordered", indent);
+		case "taskList": return serializeTaskList(el, indent);
+		case "codeBlock": {
+			const lang = el.getAttribute("language") ?? "";
+			const code = getCodeBlockText(el);
+			if (code === "") return `\`\`\`${lang}\n\`\`\``;
+			return `\`\`\`${lang}\n${code}\n\`\`\``;
+		}
+		case "blockquote": {
+			const lines = [];
+			for (const child of el.toArray()) if (child instanceof Y.XmlElement) {
+				const text = serializeBlock(child);
+				for (const line of text.split("\n")) lines.push(`> ${line}`);
+			}
+			return lines.join("\n");
+		}
+		case "table": return serializeTable(el);
+		case "horizontalRule": return "---";
+		case "image": {
+			const src = el.getAttribute("src") ?? "";
+			const alt = el.getAttribute("alt") ?? "";
+			const width = el.getAttribute("width");
+			const height = el.getAttribute("height");
+			const attrs = [];
+			if (width) attrs.push(`width=${width}`);
+			if (height) attrs.push(`height=${height}`);
+			return `![${alt}](${src})${attrs.length ? `{${attrs.join(" ")}}` : ""}`;
+		}
+		case "docEmbed": {
+			const docId = el.getAttribute("docId") ?? "";
+			const collapsed = el.getAttribute("collapsed");
+			const tall = el.getAttribute("tall");
+			const seamless = el.getAttribute("seamless");
+			const flags = [];
+			if (collapsed === true || collapsed === "true") flags.push("collapsed");
+			if (tall === true || tall === "true") flags.push("tall");
+			if (seamless === true || seamless === "true") flags.push("seamless");
+			return `![[${docId}]]${flags.length ? `{${flags.join(" ")}}` : ""}`;
+		}
+		case "mathBlock": return `\`\`\`math\n${el.getAttribute("expression") ?? ""}\n\`\`\``;
+		case "fileBlock": {
+			const uploadId = el.getAttribute("uploadId") ?? "";
+			const filename = el.getAttribute("filename") ?? "";
+			const mime = el.getAttribute("mime") ?? "";
+			const src = el.getAttribute("src") ?? (uploadId && filename ? `.abracadabra/files/${uploadId}-${filename}` : "");
+			const props = [];
+			if (src) props.push(`src="${src}"`);
+			if (mime) props.push(`mime="${mime}"`);
+			if (uploadId) props.push(`upload-id="${uploadId}"`);
+			if (filename) props.push(`filename="${filename}"`);
+			return `:file{${props.join(" ")}}`;
+		}
+		case "callout": return `::${el.getAttribute("type") ?? "note"}\n${serializeChildren(el)}\n::`;
+		case "collapsible": {
+			const label = el.getAttribute("label") ?? "Details";
+			const open = el.getAttribute("open");
+			const props = [`label="${label}"`];
+			if (open === true || open === "true") props.push("open=\"true\"");
+			return `::collapsible{${props.join(" ")}}\n${serializeChildren(el)}\n::`;
+		}
+		case "steps": return `::steps\n${serializeChildren(el)}\n::`;
+		case "card": {
+			const props = [];
+			const title = el.getAttribute("title");
+			const icon = el.getAttribute("icon");
+			const to = el.getAttribute("to");
+			if (title) props.push(`title="${title}"`);
+			if (icon) props.push(`icon="${icon}"`);
+			if (to) props.push(`to="${to}"`);
+			return `::card${props.length ? `{${props.join(" ")}}` : ""}\n${serializeChildren(el)}\n::`;
+		}
+		case "cardGroup": return `::card-group\n${el.toArray().filter((c) => c instanceof Y.XmlElement).map((c) => serializeBlock(c)).join("\n\n")}\n::`;
+		case "codeCollapse": return `::code-collapse\n${el.toArray().filter((c) => c instanceof Y.XmlElement && c.nodeName === "codeBlock").map((c) => serializeBlock(c)).join("\n\n")}\n::`;
+		case "codeGroup": return `::code-group\n${el.toArray().filter((c) => c instanceof Y.XmlElement && c.nodeName === "codeBlock").map((c) => serializeBlock(c)).join("\n\n")}\n::`;
+		case "codePreview": {
+			const children = el.toArray().filter((c) => c instanceof Y.XmlElement);
+			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];
+			if (code) parts.push(`#code\n${code}`);
+			return `::code-preview\n${parts.filter(Boolean).join("\n\n")}\n::`;
+		}
+		case "codeTree": return `::code-tree{files="${el.getAttribute("files") ?? "[]"}"}\n::`;
+		case "accordion": return serializeSlottedContainer(el, "accordion", "accordionItem", "item");
+		case "tabs": return serializeSlottedContainer(el, "tabs", "tabsItem", "tab");
+		case "field": {
+			const fieldName = el.getAttribute("name") ?? "";
+			const fieldType = el.getAttribute("type") ?? "string";
+			const required = el.getAttribute("required");
+			const props = [`name="${fieldName}"`, `type="${fieldType}"`];
+			if (required === true || required === "true") props.push("required=\"true\"");
+			return `::field{${props.join(" ")}}\n${serializeChildren(el)}\n::`;
+		}
+		case "fieldGroup": return `::field-group\n${el.toArray().filter((c) => c instanceof Y.XmlElement).map((c) => serializeBlock(c)).join("\n\n")}\n::`;
+		default: return serializeChildren(el);
+	}
+}
+function serializeChildren(el) {
+	const blocks = [];
+	for (const child of el.toArray()) if (child instanceof Y.XmlElement) {
+		const text = serializeBlock(child);
+		if (text) blocks.push(text);
+	} else if (child instanceof Y.XmlText) {
+		const text = serializeDelta(child.toDelta());
+		if (text) blocks.push(text);
+	}
+	return blocks.join("\n\n");
+}
+function serializeListItems(el, type, indent) {
+	const lines = [];
+	let counter = 1;
+	for (const child of el.toArray()) {
+		if (!(child instanceof Y.XmlElement) || child.nodeName !== "listItem") continue;
+		const prefix = type === "bullet" ? "- " : `${counter++}. `;
+		const subParts = [];
+		for (const sub of child.toArray()) {
+			if (!(sub instanceof Y.XmlElement)) continue;
+			if (sub.nodeName === "bulletList") subParts.push(serializeListItems(sub, "bullet", indent + "  "));
+			else if (sub.nodeName === "orderedList") subParts.push(serializeListItems(sub, "ordered", indent + "  "));
+			else subParts.push(serializeInline(sub));
+		}
+		if (subParts.length <= 1) lines.push(`${indent}${prefix}${subParts[0] ?? ""}`);
+		else {
+			lines.push(`${indent}${prefix}${subParts[0] ?? ""}`);
+			for (let i = 1; i < subParts.length; i++) lines.push(subParts[i]);
+		}
+	}
+	return lines.join("\n");
+}
+function serializeTaskList(el, indent) {
+	const lines = [];
+	for (const child of el.toArray()) {
+		if (!(child instanceof Y.XmlElement) || child.nodeName !== "taskItem") continue;
+		const checked = child.getAttribute("checked");
+		const marker = checked === true || checked === "true" ? "[x]" : "[ ]";
+		let header = "";
+		const nestedParts = [];
+		for (const sub of child.toArray()) {
+			if (!(sub instanceof Y.XmlElement)) continue;
+			if (sub.nodeName === "paragraph" && header === "") header = serializeInline(sub);
+			else if (sub.nodeName === "bulletList") nestedParts.push(serializeListItems(sub, "bullet", indent + "  "));
+			else if (sub.nodeName === "orderedList") nestedParts.push(serializeListItems(sub, "ordered", indent + "  "));
+			else if (sub.nodeName === "taskList") nestedParts.push(serializeTaskList(sub, indent + "  "));
+			else nestedParts.push(indent + "  " + serializeBlock(sub, indent + "  "));
+		}
+		lines.push(`${indent}- ${marker} ${header}`);
+		for (const part of nestedParts) lines.push(part);
+	}
+	return lines.join("\n");
+}
+function getCodeBlockText(el) {
+	for (const child of el.toArray()) if (child instanceof Y.XmlText) return child.toString();
+	return "";
+}
+function serializeTable(el) {
+	const rows = el.toArray().filter((c) => c instanceof Y.XmlElement);
+	if (!rows.length) return "";
+	const serializedRows = [];
+	for (const row of rows) {
+		const cells = row.toArray().filter((c) => c instanceof Y.XmlElement).map((cell) => {
+			return cell.toArray().filter((c) => c instanceof Y.XmlElement).map((c) => serializeInline(c)).join(" ");
+		});
+		serializedRows.push(cells);
+	}
+	if (!serializedRows.length) return "";
+	const colCount = Math.max(...serializedRows.map((r) => r.length));
+	const headerRow = serializedRows[0];
+	const separator = Array(colCount).fill("---");
+	const dataRows = serializedRows.slice(1);
+	const formatRow = (cells) => {
+		return `| ${Array(colCount).fill("").map((_, i) => cells[i] ?? "").join(" | ")} |`;
+	};
+	return [
+		formatRow(headerRow),
+		formatRow(separator),
+		...dataRows.map(formatRow)
+	].join("\n");
+}
+function serializeSlottedContainer(el, containerName, childName, slotPrefix) {
+	return `::${containerName}\n${el.toArray().filter((c) => c instanceof Y.XmlElement && c.nodeName === childName).map((item) => {
+		const label = item.getAttribute("label") ?? "";
+		const icon = item.getAttribute("icon") ?? "";
+		const props = [];
+		if (label) props.push(`label="${label}"`);
+		if (icon) props.push(`icon="${icon}"`);
+		const content = serializeChildren(item);
+		return `#${slotPrefix}{${props.join(" ")}}\n${content}`;
+	}).join("\n\n")}\n::`;
+}
+function generateFrontmatter(label, meta, type) {
+	const lines = [];
+	if (label !== void 0) lines.push(`title: "${escapeYaml(label)}"`);
+	if (type && type !== "doc") lines.push(`type: ${type}`);
+	if (!meta) return `---\n${lines.join("\n")}\n---`;
+	if (meta.tags?.length) lines.push(`tags: [${meta.tags.join(", ")}]`);
+	if (meta.color) lines.push(`color: ${yamlScalar(meta.color)}`);
+	if (meta.icon) lines.push(`icon: ${yamlScalar(meta.icon)}`);
+	if (meta.status) lines.push(`status: ${yamlScalar(meta.status)}`);
+	if (meta.priority !== void 0 && meta.priority !== 0) lines.push(`priority: ${{
+		1: "low",
+		2: "medium",
+		3: "high",
+		4: "urgent"
+	}[meta.priority] ?? meta.priority}`);
+	if (meta.checked !== void 0) lines.push(`checked: ${meta.checked}`);
+	if (meta.dateStart) lines.push(`dateStart: "${escapeYaml(meta.dateStart)}"`);
+	if (meta.dateEnd) lines.push(`dateEnd: "${escapeYaml(meta.dateEnd)}"`);
+	if (meta.subtitle) lines.push(`subtitle: "${escapeYaml(meta.subtitle)}"`);
+	if (meta.url) lines.push(`url: ${meta.url}`);
+	if (meta.rating !== void 0 && meta.rating !== 0) lines.push(`rating: ${meta.rating}`);
+	return `---\n${lines.join("\n")}\n---`;
+}
+/**
+* Render a YAML scalar — bare when safe, double-quoted when the value
+* needs escaping. YAML treats `#`, `:`, leading whitespace, and a few
+* other characters as syntactically significant, so anything starting
+* with one of those gets quoted to stay round-trip safe.
+*/
+function yamlScalar(s) {
+	if (s === "") return "\"\"";
+	if (/^[#&*!|>%@`]/.test(s)) return `"${escapeYaml(s)}"`;
+	if (/[:"]/.test(s)) return `"${escapeYaml(s)}"`;
+	if (/^\s|\s$/.test(s)) return `"${escapeYaml(s)}"`;
+	return s;
+}
+function escapeYaml(s) {
+	return s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+function serializeBlockToHtml(el) {
+	if (el instanceof Y.XmlText) return serializeDeltaToHtml(el.toDelta());
+	const name = el.nodeName;
+	switch (name) {
+		case "documentHeader":
+		case "documentMeta": return "";
+		case "heading": {
+			const level = Number(el.getAttribute("level") ?? 2);
+			return `<h${level}>${serializeInlineHtml(el)}</h${level}>`;
+		}
+		case "paragraph": return `<p>${serializeInlineHtml(el)}</p>`;
+		case "bulletList": return `<ul>${serializeListHtml(el)}</ul>`;
+		case "orderedList": return `<ol>${serializeListHtml(el)}</ol>`;
+		case "taskList": return `<ul>${serializeTaskListHtml(el)}</ul>`;
+		case "codeBlock": {
+			const lang = el.getAttribute("language") ?? "";
+			const code = escapeHtml(getCodeBlockText(el));
+			return lang ? `<pre><code class="language-${lang}">${code}</code></pre>` : `<pre><code>${code}</code></pre>`;
+		}
+		case "blockquote": return `<blockquote>\n${el.toArray().filter((c) => c instanceof Y.XmlElement).map((c) => serializeBlockToHtml(c)).join("\n")}\n</blockquote>`;
+		case "table": return serializeTableHtml(el);
+		case "horizontalRule": return "<hr>";
+		case "image": {
+			const src = el.getAttribute("src") ?? "";
+			const alt = el.getAttribute("alt") ?? "";
+			return `<img src="${escapeHtml(src)}" alt="${escapeHtml(alt)}">`;
+		}
+		case "fileBlock": {
+			const uploadId = el.getAttribute("uploadId") ?? "";
+			const filename = el.getAttribute("filename") ?? "file";
+			if (uploadId) return `<!--fileblock:${uploadId}:${filename}-->`;
+			return `<!-- file: ${filename} -->`;
+		}
+		default: return `<div data-type="${name}">\n${el.toArray().filter((c) => c instanceof Y.XmlElement || c instanceof Y.XmlText).map((c) => c instanceof Y.XmlElement ? serializeBlockToHtml(c) : serializeDeltaToHtml(c.toDelta())).join("\n")}\n</div>`;
+	}
+}
+function serializeInlineHtml(el) {
+	const parts = [];
+	for (const child of el.toArray()) if (child instanceof Y.XmlText) parts.push(serializeDeltaToHtml(child.toDelta()));
+	else if (child instanceof Y.XmlElement) parts.push(serializeInlineHtml(child));
+	return parts.join("");
+}
+function serializeDeltaToHtml(delta) {
+	let result = "";
+	for (const op of delta) {
+		if (typeof op.insert !== "string") continue;
+		let text = escapeHtml(op.insert);
+		const attrs = op.attributes ?? {};
+		if (attrs.code) text = `<code>${text}</code>`;
+		if (attrs.bold) text = `<strong>${text}</strong>`;
+		if (attrs.italic) text = `<em>${text}</em>`;
+		if (attrs.strike) text = `<s>${text}</s>`;
+		if (attrs.link) text = `<a href="${escapeHtml(attrs.link.href ?? "")}">${text}</a>`;
+		result += text;
+	}
+	return result;
+}
+function serializeListHtml(el) {
+	return el.toArray().filter((c) => c instanceof Y.XmlElement && c.nodeName === "listItem").map((li) => `<li>${li.toArray().filter((c) => c instanceof Y.XmlElement).map((c) => serializeBlockToHtml(c)).join("")}</li>`).join("\n");
+}
+function serializeTaskListHtml(el) {
+	return el.toArray().filter((c) => c instanceof Y.XmlElement && c.nodeName === "taskItem").map((ti) => {
+		const rawChecked = ti.getAttribute("checked");
+		const checked = rawChecked === true || rawChecked === "true";
+		const text = ti.toArray().filter((c) => c instanceof Y.XmlElement).map((c) => serializeInlineHtml(c)).join("");
+		return `<li><input type="checkbox"${checked ? " checked" : ""} disabled> ${text}</li>`;
+	}).join("\n");
+}
+function serializeTableHtml(el) {
+	const rows = el.toArray().filter((c) => c instanceof Y.XmlElement);
+	if (!rows.length) return "";
+	return `<table>\n${rows.map((row, ri) => {
+		const tag = ri === 0 ? "th" : "td";
+		return `<tr>${row.toArray().filter((c) => c instanceof Y.XmlElement).map((cell) => {
+			return `<${tag}>${cell.toArray().filter((c) => c instanceof Y.XmlElement).map((c) => serializeInlineHtml(c)).join("")}</${tag}>`;
+		}).join("")}</tr>`;
+	}).join("\n")}\n</table>`;
+}
+function escapeHtml(s) {
+	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function yjsToMarkdown(fragment, label, meta, type) {
+	const { text: headerText, source: titleSource } = readDocumentHeader(fragment);
+	const effectiveTitle = headerText || label;
+	const docMeta = readDocumentMeta(fragment);
+	const effectiveMeta = meta ?? docMeta.meta;
+	const effectiveType = type ?? docMeta.type;
+	const metaIsEmpty = isMetaEmpty(effectiveMeta);
+	const typeIsDefault = !effectiveType || effectiveType === "doc";
+	const bodyBlocks = collectBodyBlocks(fragment);
+	let body;
+	if (titleSource === "h1" && effectiveTitle) {
+		const tail = serializeBlocksClean(bodyBlocks);
+		body = tail === "" ? `# ${effectiveTitle}` : `# ${effectiveTitle}\n\n${tail}`;
+	} else body = serializeBlocksClean(bodyBlocks);
+	const wantFrontmatterTitle = titleSource === "frontmatter";
+	if (!wantFrontmatterTitle && !(!metaIsEmpty || !typeIsDefault)) return body === "" ? "" : `${body}\n`;
+	const frontmatter = generateFrontmatter(wantFrontmatterTitle ? effectiveTitle : void 0, effectiveMeta, effectiveType);
+	if (body === "") return `${frontmatter}\n`;
+	return `${frontmatter}\n\n${body}\n`;
+}
+function readDocumentMeta(fragment) {
+	const meta = {};
+	let type;
+	for (const child of fragment.toArray()) {
+		if (!(child instanceof Y.XmlElement) || child.nodeName !== "documentMeta") continue;
+		const attrs = child.getAttributes();
+		for (const k of Object.keys(attrs)) {
+			const v = attrs[k];
+			if (v === void 0 || v === null) continue;
+			if (k === "type" && typeof v === "string") {
+				type = v;
+				continue;
+			}
+			meta[k] = v;
+		}
+		break;
+	}
+	return {
+		meta,
+		type
+	};
+}
+function readDocumentHeader(fragment) {
+	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);
+		const src = child.getAttribute("titleSource");
+		const source = src === "h1" || src === "frontmatter" ? src : void 0;
+		return {
+			text: text ? text.toString() : "",
+			source
+		};
+	}
+	return { text: "" };
+}
+function collectBodyBlocks(fragment) {
+	const out = [];
+	for (const child of fragment.toArray()) {
+		if (!(child instanceof Y.XmlElement)) continue;
+		if (child.nodeName === "documentHeader" || child.nodeName === "documentMeta") continue;
+		out.push(child);
+	}
+	return out;
+}
+function serializeBlocksClean(blocks) {
+	const parts = [];
+	for (const block of blocks) {
+		if (block.nodeName === "paragraph" && block.length === 0) {
+			parts.push("");
+			continue;
+		}
+		parts.push(serializeBlock(block));
+	}
+	while (parts.length && parts[parts.length - 1] === "") parts.pop();
+	return parts.join("\n\n");
+}
+function isMetaEmpty(meta) {
+	if (!meta) return true;
+	for (const key of Object.keys(meta)) {
+		const v = meta[key];
+		if (v === void 0 || v === null) continue;
+		if (typeof v === "string" && v === "") continue;
+		if (Array.isArray(v) && v.length === 0) continue;
+		return false;
+	}
+	return true;
+}
+/**
+* Walk the Y.XmlFragment and concatenate all text content with no
+* markup or frontmatter. Block boundaries become newlines. Useful for
+* accessibility tooling, search indexing, and snippet previews.
+*/
+function yjsToPlainText(fragment) {
+	const out = [];
+	const visit = (node) => {
+		if (node instanceof Y.XmlText) {
+			out.push(node.toString());
+			return;
+		}
+		if (node.nodeName === "documentMeta") return;
+		if (node.nodeName === "image") {
+			const alt = node.getAttribute("alt") ?? "";
+			if (alt) out.push(alt);
+			return;
+		}
+		for (const child of node.toArray()) if (child instanceof Y.XmlText || child instanceof Y.XmlElement) visit(child);
+		if (node.nodeName !== "paragraph" && node.length === 0) return;
+		out.push("\n");
+	};
+	for (const child of fragment.toArray()) if (child instanceof Y.XmlText || child instanceof Y.XmlElement) visit(child);
+	return out.join("").replace(/\n+$/, "").replace(/\n{3,}/g, "\n\n");
+}
+function yjsToHtml(fragment, label) {
+	const title = escapeHtml(label);
+	const bodyParts = [];
+	for (const child of fragment.toArray()) if (child instanceof Y.XmlElement) {
+		const html = serializeBlockToHtml(child);
+		if (html) bodyParts.push(html);
+	}
+	return `<!DOCTYPE html>
+<html>
+<head><meta charset="utf-8"><title>${title}</title></head>
+<body>
+<h1>${title}</h1>
+${bodyParts.join("\n")}
+</body>
+</html>
+`;
+}
+
+//#endregion
+//#region packages/convert/src/html-to-yjs.ts
+function getTextContent(node) {
+	return node.textContent ?? "";
+}
+function langFromClass(el) {
+	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) {
+	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;
+}
+/** Walk an inline subtree and collect { text, marks } runs. */
+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 Array.from(el.childNodes)) runs.push(...collectInlineRuns(child, nextStack));
+	return runs;
+}
+/** Fill an already-attached Y.XmlElement with inline text 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);
+	});
+}
+/** Convert a single block-level DOM element to Y.XmlElement(s) and append to `container`. */
+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 = 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"));
+		if (items.some((li) => li.querySelector("input[type=\"checkbox\"]"))) {
+			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 checked = li.querySelector("input[type=\"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 cellType = cells.some((c) => c.tagName.toLowerCase() === "th") ? "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;
+	}
+	if (getTextContent(el).trim()) {
+		const paraEl = new Y.XmlElement("paragraph");
+		container.insert(container.length, [paraEl]);
+		fillInlineRuns(paraEl, collectInlineRuns(el, []));
+	}
+}
+/**
+* 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
+*/
+function populateYDocFromHtml(fragment, html, fallbackTitle = "Untitled") {
+	const ydoc = fragment.doc;
+	if (!ydoc) {
+		console.warn("[htmlToYjs] fragment has no doc — skipping population");
+		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);
+		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;
+			if (tag === "h1" && child === firstH1) continue;
+			convertBlockElement(child, fragment);
+			hasContent = true;
+		}
+		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.
+*/
+function appendHtmlToFragment(fragment, html) {
+	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);
+	});
+}
+
+//#endregion
+//#region packages/convert/src/diff.ts
+function attrsToJson(el) {
+	const out = {};
+	let count = 0;
+	for (const key of Object.keys(el.getAttributes())) {
+		out[key] = normaliseAttr(el.getAttribute(key));
+		count++;
+	}
+	if (count === 0) return void 0;
+	return sortKeys(out);
+}
+function normaliseAttr(v) {
+	if (v == null) return null;
+	if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") return v;
+	if (Array.isArray(v)) return v.map(normaliseAttr);
+	if (typeof v === "object") {
+		const out = {};
+		for (const k of Object.keys(v).sort()) out[k] = normaliseAttr(v[k]);
+		return out;
+	}
+	return null;
+}
+function sortKeys(obj) {
+	const out = {};
+	for (const k of Object.keys(obj).sort()) out[k] = obj[k];
+	return out;
+}
+function textToJson(text) {
+	const delta = text.toDelta();
+	const runs = [];
+	for (const op of delta) {
+		if (typeof op.insert !== "string") continue;
+		const run = { insert: op.insert };
+		if (op.attributes && Object.keys(op.attributes).length > 0) {
+			const normalised = {};
+			for (const k of Object.keys(op.attributes).sort()) normalised[k] = normaliseAttr(op.attributes[k]);
+			run.attributes = normalised;
+		}
+		runs.push(run);
+	}
+	return {
+		kind: "text",
+		runs
+	};
+}
+function elementToJson(el) {
+	const attrs = attrsToJson(el);
+	const children = [];
+	for (const child of el.toArray()) if (child instanceof Y.XmlElement) children.push(elementToJson(child));
+	else if (child instanceof Y.XmlText) children.push(textToJson(child));
+	const out = {
+		kind: "element",
+		tag: el.nodeName,
+		children
+	};
+	if (attrs) out.attrs = attrs;
+	return out;
+}
+function yfragmentToJson(frag) {
+	const children = [];
+	for (const child of frag.toArray()) if (child instanceof Y.XmlElement) children.push(elementToJson(child));
+	else if (child instanceof Y.XmlText) children.push(textToJson(child));
+	return {
+		kind: "element",
+		tag: "#fragment",
+		children
+	};
+}
+function populateElement(el, node) {
+	if (node.attrs) for (const k of Object.keys(node.attrs)) {
+		const v = node.attrs[k];
+		el.setAttribute(k, v);
+	}
+	for (const child of node.children) if (child.kind === "element") {
+		const sub = new Y.XmlElement(child.tag);
+		el.insert(el.length, [sub]);
+		populateElement(sub, child);
+	} else {
+		const text = new Y.XmlText();
+		el.insert(el.length, [text]);
+		populateText(text, child);
+	}
+}
+function populateText(text, node) {
+	let offset = 0;
+	for (const run of node.runs) {
+		if (run.attributes) text.insert(offset, run.insert, run.attributes);
+		else text.insert(offset, run.insert);
+		offset += run.insert.length;
+	}
+}
+/**
+* Build a Y.XmlFragment from a previously captured golden JSON. The
+* returned fragment is bound to a fresh Y.Doc so consumers can hand
+* it to serialisers immediately. All Yjs mutations happen inside a
+* single transaction.
+*/
+function jsonToYFragment(root, doc, key = "body") {
+	if (root.tag !== "#fragment") throw new Error(`jsonToYFragment expected tag="#fragment", got "${root.tag}"`);
+	const ydoc = doc ?? new Y.Doc();
+	const frag = ydoc.getXmlFragment(key);
+	ydoc.transact(() => {
+		for (const child of root.children) if (child.kind === "element") {
+			const sub = new Y.XmlElement(child.tag);
+			frag.insert(frag.length, [sub]);
+			populateElement(sub, child);
+		} else {
+			const text = new Y.XmlText();
+			frag.insert(frag.length, [text]);
+			populateText(text, child);
+		}
+	});
+	return frag;
+}
+function diffYjs(a, b) {
+	return diffNode(yfragmentToJson(a), yfragmentToJson(b), "");
+}
+function diffJson(a, b) {
+	return diffNode(a, b, "");
+}
+function diffNode(a, b, path) {
+	if (a.kind !== b.kind) return {
+		equal: false,
+		path,
+		reason: `kind mismatch: ${a.kind} vs ${b.kind}`
+	};
+	if (a.kind === "text" && b.kind === "text") {
+		const ar = a.runs;
+		const br = b.runs;
+		if (ar.length !== br.length) return {
+			equal: false,
+			path,
+			reason: `text run count: ${ar.length} vs ${br.length}`
+		};
+		for (let i = 0; i < ar.length; i++) {
+			const sub = `${path}/runs[${i}]`;
+			const ai = ar[i];
+			const bi = br[i];
+			if (ai.insert !== bi.insert) return {
+				equal: false,
+				path: sub,
+				reason: `insert: ${JSON.stringify(ai.insert)} vs ${JSON.stringify(bi.insert)}`
+			};
+			const attrDiff = diffAttrs(ai.attributes, bi.attributes, sub);
+			if (!attrDiff.equal) return attrDiff;
+		}
+		return {
+			equal: true,
+			path: "",
+			reason: ""
+		};
+	}
+	if (a.kind === "element" && b.kind === "element") {
+		if (a.tag !== b.tag) return {
+			equal: false,
+			path,
+			reason: `tag: ${a.tag} vs ${b.tag}`
+		};
+		const attrDiff = diffAttrs(a.attrs, b.attrs, path);
+		if (!attrDiff.equal) return attrDiff;
+		if (a.children.length !== b.children.length) return {
+			equal: false,
+			path,
+			reason: `child count: ${a.children.length} vs ${b.children.length}`
+		};
+		for (let i = 0; i < a.children.length; i++) {
+			const sub = path === "" ? `[${i}]` : `${path}[${i}]`;
+			const childDiff = diffNode(a.children[i], b.children[i], sub);
+			if (!childDiff.equal) return childDiff;
+		}
+		return {
+			equal: true,
+			path: "",
+			reason: ""
+		};
+	}
+	return {
+		equal: false,
+		path,
+		reason: "unreachable kind combination"
+	};
+}
+function diffAttrs(a, b, path) {
+	const ak = a ? Object.keys(a).sort() : [];
+	const bk = b ? Object.keys(b).sort() : [];
+	if (ak.length !== bk.length || ak.some((k, i) => k !== bk[i])) return {
+		equal: false,
+		path: `${path}.attrs`,
+		reason: `attr keys: [${ak.join(",")}] vs [${bk.join(",")}]`
+	};
+	for (const k of ak) {
+		const av = a[k];
+		const bv = b[k];
+		if (!attrEqual(av, bv)) return {
+			equal: false,
+			path: `${path}.attrs.${k}`,
+			reason: `attr value: ${JSON.stringify(av)} vs ${JSON.stringify(bv)}`
+		};
+	}
+	return {
+		equal: true,
+		path: "",
+		reason: ""
+	};
+}
+function attrEqual(a, b) {
+	if (a === b) return true;
+	if (a === null || b === null) return false;
+	if (typeof a !== typeof b) return false;
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) return false;
+		return a.every((v, i) => attrEqual(v, b[i]));
+	}
+	if (typeof a === "object" && typeof b === "object") {
+		const ak = Object.keys(a).sort();
+		const bk = Object.keys(b).sort();
+		if (ak.length !== bk.length || ak.some((k, i) => k !== bk[i])) return false;
+		return ak.every((k) => attrEqual(a[k], b[k]));
+	}
+	return false;
+}
+/** Stringify a YjsJsonNode with sorted keys for byte-stable golden files. */
+function stringifyJsonNode(node) {
+	return JSON.stringify(node, null, 2) + "\n";
+}
+
+//#endregion
+//#region packages/convert/src/spec/nodes.ts
+const BOOL_FALSE_DEFAULT = {
+	key: "",
+	type: "boolean",
+	default: false,
+	optional: true
+};
+const bool = (key) => ({
+	...BOOL_FALSE_DEFAULT,
+	key
+});
+const str = (key, def) => ({
+	key,
+	type: "string",
+	default: def,
+	optional: true
+});
+const num = (key) => ({
+	key,
+	type: "number",
+	optional: true
+});
+const int = (key) => ({
+	key,
+	type: "integer",
+	optional: true
+});
+const VANILLA_BLOCKS = [
+	{
+		name: "documentHeader",
+		group: "block",
+		wire: "special",
+		doc: "Holds the title; hoisted to frontmatter on serialise."
+	},
+	{
+		name: "documentMeta",
+		group: "block",
+		wire: "special",
+		doc: "Holds page-level meta; serialised into frontmatter."
+	},
+	{
+		name: "paragraph",
+		group: "block",
+		wire: "vanilla",
+		contentBearing: true
+	},
+	{
+		name: "heading",
+		group: "block",
+		wire: "vanilla",
+		attrs: [int("level")],
+		contentBearing: true
+	},
+	{
+		name: "blockquote",
+		group: "block",
+		wire: "vanilla",
+		contentBearing: true
+	},
+	{
+		name: "codeBlock",
+		group: "block",
+		wire: "fence",
+		attrs: [str("language", "")]
+	},
+	{
+		name: "bulletList",
+		group: "block",
+		wire: "vanilla"
+	},
+	{
+		name: "orderedList",
+		group: "block",
+		wire: "vanilla"
+	},
+	{
+		name: "listItem",
+		group: "block",
+		wire: "vanilla",
+		contentBearing: true
+	},
+	{
+		name: "taskList",
+		group: "block",
+		wire: "vanilla"
+	},
+	{
+		name: "taskItem",
+		group: "block",
+		wire: "vanilla",
+		attrs: [bool("checked")],
+		contentBearing: true
+	},
+	{
+		name: "table",
+		group: "block",
+		wire: "vanilla"
+	},
+	{
+		name: "tableRow",
+		group: "block",
+		wire: "vanilla"
+	},
+	{
+		name: "tableHeader",
+		group: "block",
+		wire: "vanilla",
+		contentBearing: true
+	},
+	{
+		name: "tableCell",
+		group: "block",
+		wire: "vanilla",
+		contentBearing: true
+	},
+	{
+		name: "horizontalRule",
+		group: "block",
+		wire: "vanilla"
+	},
+	{
+		name: "image",
+		group: "block",
+		wire: "special",
+		attrs: [
+			str("src"),
+			str("alt", ""),
+			int("width"),
+			int("height")
+		]
+	},
+	{
+		name: "hardBreak",
+		group: "inline",
+		wire: "vanilla"
+	}
+];
+const MDC_CONTAINERS = [
+	{
+		name: "callout",
+		group: "block",
+		wire: "mdc-container",
+		attrs: [
+			{
+				key: "type",
+				type: "string",
+				default: "note",
+				optional: true,
+				values: [
+					"note",
+					"tip",
+					"warning",
+					"danger",
+					"info",
+					"caution",
+					"alert",
+					"success",
+					"error"
+				]
+			},
+			str("title"),
+			str("icon")
+		]
+	},
+	{
+		name: "collapsible",
+		group: "block",
+		wire: "mdc-container",
+		attrs: [str("label", "Details"), bool("open")]
+	},
+	{
+		name: "accordion",
+		group: "block",
+		wire: "mdc-slotted",
+		slotChild: "accordionItem"
+	},
+	{
+		name: "accordionItem",
+		group: "block",
+		wire: "mdc-container",
+		mdcTag: "accordion-item",
+		attrs: [str("label", "Item"), str("icon")]
+	},
+	{
+		name: "tabs",
+		group: "block",
+		wire: "mdc-slotted",
+		slotChild: "tabsItem"
+	},
+	{
+		name: "tabsItem",
+		group: "block",
+		wire: "mdc-container",
+		mdcTag: "tabs-item",
+		attrs: [str("label"), str("icon")]
+	},
+	{
+		name: "steps",
+		group: "block",
+		wire: "mdc-container"
+	},
+	{
+		name: "card",
+		group: "block",
+		wire: "mdc-container",
+		attrs: [
+			str("title"),
+			str("icon"),
+			str("to")
+		]
+	},
+	{
+		name: "cardGroup",
+		group: "block",
+		wire: "mdc-slotted",
+		mdcTag: "card-group",
+		slotChild: "card"
+	},
+	{
+		name: "field",
+		group: "block",
+		wire: "mdc-container",
+		attrs: [
+			str("name"),
+			str("type", "string"),
+			bool("required")
+		]
+	},
+	{
+		name: "fieldGroup",
+		group: "block",
+		wire: "mdc-slotted",
+		mdcTag: "field-group",
+		slotChild: "field"
+	},
+	{
+		name: "codeGroup",
+		group: "block",
+		wire: "mdc-slotted",
+		mdcTag: "code-group",
+		slotChild: "codeBlock"
+	},
+	{
+		name: "codeCollapse",
+		group: "block",
+		wire: "mdc-container",
+		mdcTag: "code-collapse"
+	},
+	{
+		name: "codePreview",
+		group: "block",
+		wire: "mdc-container",
+		mdcTag: "code-preview"
+	},
+	{
+		name: "codeTree",
+		group: "block",
+		wire: "mdc-atom-block",
+		mdcTag: "code-tree",
+		attrs: [{
+			key: "files",
+			type: "json"
+		}]
+	},
+	{
+		name: "figure",
+		group: "block",
+		wire: "mdc-container",
+		attrs: [
+			str("src"),
+			str("alt", ""),
+			str("caption")
+		]
+	},
+	{
+		name: "video",
+		group: "block",
+		wire: "mdc-atom-block",
+		attrs: [
+			str("src"),
+			str("poster"),
+			bool("autoplay"),
+			bool("loop"),
+			bool("controls")
+		]
+	},
+	{
+		name: "embed",
+		group: "block",
+		wire: "mdc-atom-block",
+		attrs: [str("src"), str("title")]
+	},
+	{
+		name: "svgEmbed",
+		group: "block",
+		wire: "fence",
+		attrs: [str("title")],
+		mdcTag: "svg",
+		doc: "Serialised as a ```svg fenced block; the SVG markup is the body."
+	},
+	{
+		name: "divider",
+		group: "block",
+		wire: "mdc-atom-block",
+		attrs: [str("label"), str("icon")]
+	},
+	{
+		name: "quote",
+		group: "block",
+		wire: "mdc-container",
+		attrs: [str("cite")]
+	},
+	{
+		name: "progress",
+		group: "block",
+		wire: "mdc-atom-block",
+		attrs: [
+			num("value"),
+			num("max"),
+			str("label")
+		]
+	},
+	{
+		name: "spoiler",
+		group: "block",
+		wire: "mdc-container",
+		attrs: [str("label")]
+	},
+	{
+		name: "colorSwatch",
+		group: "block",
+		wire: "mdc-atom-block",
+		mdcTag: "color-swatch",
+		attrs: [str("color"), str("label")]
+	},
+	{
+		name: "stat",
+		group: "block",
+		wire: "mdc-container",
+		attrs: [
+			str("label"),
+			str("value"),
+			str("icon")
+		]
+	},
+	{
+		name: "statGroup",
+		group: "block",
+		wire: "mdc-slotted",
+		mdcTag: "stat-group",
+		slotChild: "stat"
+	},
+	{
+		name: "button",
+		group: "block",
+		wire: "mdc-atom-block",
+		attrs: [
+			str("label"),
+			str("to"),
+			str("icon"),
+			str("variant")
+		]
+	},
+	{
+		name: "buttonGroup",
+		group: "block",
+		wire: "mdc-slotted",
+		mdcTag: "button-group",
+		slotChild: "button"
+	},
+	{
+		name: "timeline",
+		group: "block",
+		wire: "mdc-slotted",
+		slotChild: "timelineItem"
+	},
+	{
+		name: "timelineItem",
+		group: "block",
+		wire: "mdc-container",
+		mdcTag: "timeline-item",
+		attrs: [
+			str("label"),
+			str("icon"),
+			str("date")
+		]
+	},
+	{
+		name: "diff",
+		group: "block",
+		wire: "mdc-atom-block",
+		attrs: [str("language", ""), {
+			key: "value",
+			type: "string"
+		}]
+	}
+];
+const INLINE_AND_SPECIAL = [
+	{
+		name: "docLink",
+		group: "inline",
+		wire: "special",
+		attrs: [str("docId")],
+		doc: "Wire form `[[uuid|label]]`; label regenerated on export."
+	},
+	{
+		name: "docEmbed",
+		group: "block",
+		wire: "special",
+		attrs: [
+			str("docId"),
+			bool("collapsed"),
+			bool("tall"),
+			bool("seamless")
+		],
+		doc: "Wire form `![[uuid|label]]{collapsed tall seamless}`."
+	},
+	{
+		name: "mention",
+		group: "inline",
+		wire: "special",
+		attrs: [str("userId")],
+		doc: "Wire form `@[label](user:uuid)`; label regenerated on export."
+	},
+	{
+		name: "mathInline",
+		group: "inline",
+		wire: "special",
+		attrs: [{
+			key: "expression",
+			type: "string"
+		}],
+		doc: "Wire form `$expression$`."
+	},
+	{
+		name: "mathBlock",
+		group: "block",
+		wire: "fence",
+		attrs: [{
+			key: "expression",
+			type: "string"
+		}],
+		mdcTag: "math",
+		doc: "Wire form ``` ```math\\nexpression\\n``` ```."
+	},
+	{
+		name: "fileBlock",
+		group: "block",
+		wire: "mdc-atom-block",
+		mdcTag: "file",
+		attrs: [
+			str("src"),
+			str("mime"),
+			str("uploadId"),
+			str("filename")
+		],
+		doc: "Wire form `:file{src=… mime=… upload-id=… filename=…}`; binary in sidecar."
+	},
+	{
+		name: "badge",
+		group: "inline",
+		wire: "mdc-atom-inl",
+		attrs: [
+			str("label"),
+			str("color"),
+			str("variant", "subtle")
+		],
+		doc: "Wire form `:badge[Label]{color=… variant=…}`."
+	},
+	{
+		name: "proseIcon",
+		group: "inline",
+		wire: "mdc-atom-inl",
+		mdcTag: "icon",
+		attrs: [str("name")],
+		doc: "Wire form `:icon{name=…}`."
+	},
+	{
+		name: "kbd",
+		group: "inline",
+		wire: "mdc-atom-inl",
+		attrs: [str("value")],
+		doc: "Wire form `:kbd{value=…}`."
+	}
+];
+const NODE_SPECS = [
+	...VANILLA_BLOCKS,
+	...MDC_CONTAINERS,
+	...INLINE_AND_SPECIAL
+];
+const NODE_SPEC_BY_NAME = new Map(NODE_SPECS.map((spec) => [spec.name, spec]));
+/** Derive the MDC tag for a node — `mdcTag` override or kebab-case of `name`. */
+function mdcTagOf(spec) {
+	if (spec.mdcTag) return spec.mdcTag;
+	return spec.name.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+
+//#endregion
+//#region packages/convert/src/spec/marks.ts
+const MARK_SPECS = [
+	{
+		name: "bold",
+		wire: "delimited",
+		delim: "**"
+	},
+	{
+		name: "italic",
+		wire: "delimited",
+		delim: "*"
+	},
+	{
+		name: "strike",
+		wire: "delimited",
+		delim: "~~"
+	},
+	{
+		name: "code",
+		wire: "delimited",
+		delim: "`"
+	},
+	{
+		name: "link",
+		wire: "link",
+		attrs: [{
+			key: "href",
+			type: "string"
+		}, {
+			key: "title",
+			type: "string",
+			optional: true
+		}]
+	},
+	{
+		name: "underline",
+		wire: "delimited",
+		delim: "__",
+		doc: "Disambiguated from bold by delimiter character. Two underscores = underline; two asterisks = bold."
+	},
+	{
+		name: "highlight",
+		wire: "delimited",
+		delim: "==",
+		doc: "Pandoc-style."
+	},
+	{
+		name: "subscript",
+		wire: "delimited",
+		delim: "~",
+		doc: "Single tilde; double tilde is strike."
+	},
+	{
+		name: "superscript",
+		wire: "delimited",
+		delim: "^"
+	},
+	{
+		name: "textStyle",
+		wire: "mdc-span",
+		attrs: [
+			{
+				key: "color",
+				type: "string",
+				optional: true
+			},
+			{
+				key: "backgroundColor",
+				type: "string",
+				optional: true
+			},
+			{
+				key: "fontSize",
+				type: "string",
+				optional: true
+			},
+			{
+				key: "fontFamily",
+				type: "string",
+				optional: true
+			}
+		],
+		doc: "Wire form `:span[text]{color=\"…\" font-size=\"…\"}`. Any of the attrs may be set."
+	}
+];
+const MARK_SPEC_BY_NAME = new Map(MARK_SPECS.map((spec) => [spec.name, spec]));
+const MARK_SPEC_BY_DELIM = new Map(MARK_SPECS.filter((spec) => spec.wire === "delimited" && !!spec.delim).map((spec) => [spec.delim, spec]));
+
+//#endregion
+//#region packages/convert/src/spec/universal-meta.ts
+const UNIVERSAL_META_KEYS = [
+	{
+		key: "title",
+		type: "string",
+		doc: "Display title; the first H1 is hoisted into this field on import."
+	},
+	{
+		key: "type",
+		type: "string",
+		doc: "Page type (doc, kanban, table, …). Omitted on serialise when \"doc\"."
+	},
+	{
+		key: "color",
+		type: "string",
+		doc: "Hex or CSS color name."
+	},
+	{
+		key: "icon",
+		type: "string",
+		doc: "Lucide icon name in kebab-case."
+	},
+	{
+		key: "datetimeStart",
+		type: "iso-datetime"
+	},
+	{
+		key: "datetimeEnd",
+		type: "iso-datetime"
+	},
+	{
+		key: "allDay",
+		type: "boolean"
+	},
+	{
+		key: "dateTaken",
+		type: "iso-datetime"
+	},
+	{
+		key: "dateStart",
+		type: "iso-date",
+		parseAliases: ["date", "created"]
+	},
+	{
+		key: "dateEnd",
+		type: "iso-date",
+		parseAliases: ["due"]
+	},
+	{
+		key: "timeStart",
+		type: "hh-mm"
+	},
+	{
+		key: "timeEnd",
+		type: "hh-mm"
+	},
+	{
+		key: "tags",
+		type: "string[]"
+	},
+	{
+		key: "checked",
+		type: "boolean",
+		parseAliases: ["done"]
+	},
+	{
+		key: "priority",
+		type: "integer",
+		min: 0,
+		max: 4,
+		doc: "Numeric or named (low/medium/high/urgent → 1/2/3/4)."
+	},
+	{
+		key: "status",
+		type: "string"
+	},
+	{
+		key: "rating",
+		type: "number",
+		min: 0,
+		max: 5
+	},
+	{
+		key: "url",
+		type: "string"
+	},
+	{
+		key: "email",
+		type: "string"
+	},
+	{
+		key: "phone",
+		type: "string"
+	},
+	{
+		key: "number",
+		type: "number"
+	},
+	{
+		key: "unit",
+		type: "string"
+	},
+	{
+		key: "subtitle",
+		type: "string",
+		parseAliases: ["description"]
+	},
+	{
+		key: "note",
+		type: "string"
+	},
+	{
+		key: "taskProgress",
+		type: "integer",
+		min: 0,
+		max: 100
+	},
+	{
+		key: "members",
+		type: "members"
+	},
+	{
+		key: "coverUploadId",
+		type: "string"
+	},
+	{
+		key: "coverDocId",
+		type: "string"
+	},
+	{
+		key: "coverMimeType",
+		type: "string"
+	},
+	{
+		key: "geoType",
+		type: "string-enum",
+		values: [
+			"marker",
+			"line",
+			"measure"
+		]
+	},
+	{
+		key: "geoLat",
+		type: "number"
+	},
+	{
+		key: "geoLng",
+		type: "number"
+	},
+	{
+		key: "geoDescription",
+		type: "string"
+	},
+	{
+		key: "deskX",
+		type: "number"
+	},
+	{
+		key: "deskY",
+		type: "number"
+	},
+	{
+		key: "deskZ",
+		type: "number"
+	},
+	{
+		key: "deskMode",
+		type: "string-enum",
+		values: [
+			"icon",
+			"widget-sm",
+			"widget-lg"
+		]
+	},
+	{
+		key: "mmX",
+		type: "number"
+	},
+	{
+		key: "mmY",
+		type: "number"
+	},
+	{
+		key: "graphX",
+		type: "number"
+	},
+	{
+		key: "graphY",
+		type: "number"
+	},
+	{
+		key: "graphPinned",
+		type: "boolean"
+	},
+	{
+		key: "spX",
+		type: "number"
+	},
+	{
+		key: "spY",
+		type: "number"
+	},
+	{
+		key: "spZ",
+		type: "number"
+	},
+	{
+		key: "spRX",
+		type: "number"
+	},
+	{
+		key: "spRY",
+		type: "number"
+	},
+	{
+		key: "spRZ",
+		type: "number"
+	},
+	{
+		key: "spSX",
+		type: "number"
+	},
+	{
+		key: "spSY",
+		type: "number"
+	},
+	{
+		key: "spSZ",
+		type: "number"
+	},
+	{
+		key: "spShape",
+		type: "string-enum",
+		values: [
+			"box",
+			"sphere",
+			"cylinder",
+			"cone",
+			"plane",
+			"torus",
+			"glb"
+		]
+	},
+	{
+		key: "spOpacity",
+		type: "integer",
+		min: 0,
+		max: 100
+	},
+	{
+		key: "spModelUploadId",
+		type: "string"
+	},
+	{
+		key: "spModelDocId",
+		type: "string"
+	},
+	{
+		key: "slidesTransition",
+		type: "string-enum",
+		values: [
+			"none",
+			"fade",
+			"slide"
+		]
+	},
+	{
+		key: "slidesTheme",
+		type: "string-enum",
+		values: ["dark", "light"]
+	},
+	{
+		key: "__schemaVersion",
+		type: "integer",
+		min: 0
+	}
+];
+const UNIVERSAL_META_KEY_NAMES = new Set(UNIVERSAL_META_KEYS.map((k) => k.key));
+/**
+* Build a map of every recognised input key (canonical + aliases) to
+* its canonical key. Used by the frontmatter parser.
+*/
+function buildAliasMap() {
+	const map = /* @__PURE__ */ new Map();
+	for (const entry of UNIVERSAL_META_KEYS) {
+		map.set(entry.key, entry.key);
+		for (const alias of entry.parseAliases ?? []) map.set(alias, entry.key);
+	}
+	return map;
+}
+
+//#endregion
+//#region packages/convert/src/file-blocks/manifest.ts
+let _adapter = null;
+/** Install a filesystem adapter. Call this once at boot. */
+function setFsAdapter(adapter) {
+	_adapter = adapter;
+}
+/** Read back the active adapter — useful for tests and for layered code. */
+function getFsAdapter() {
+	return _adapter;
+}
+async function loadFsApi() {
+	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.");
+}
+const MANIFEST_DIR = ".abracadabra";
+const MANIFEST_FILE = "manifest.json";
+function manifestPath(syncDir) {
+	return `${syncDir}/${MANIFEST_DIR}/${MANIFEST_FILE}`;
+}
+function manifestDir(syncDir) {
+	return `${syncDir}/${MANIFEST_DIR}`;
+}
+function trashDir(syncDir) {
+	return `${syncDir}/${MANIFEST_DIR}/trash`;
+}
+function orphansDir(syncDir) {
+	return `${syncDir}/${MANIFEST_DIR}/orphans`;
+}
+function conflictsDir(syncDir) {
+	return `${syncDir}/${MANIFEST_DIR}/conflicts`;
+}
+function createEmptyManifest(spaceId) {
+	return {
+		version: 2,
+		spaceId,
+		lastSyncAt: 0,
+		entries: {}
+	};
+}
+async function loadManifest(syncDir, spaceId) {
+	const fs = await loadFsApi();
+	try {
+		const raw = await fs.readTextFile(manifestPath(syncDir));
+		const parsed = JSON.parse(raw);
+		if (parsed.version === 2) return parsed;
+	} catch {}
+	return createEmptyManifest(spaceId);
+}
+async function saveManifest(syncDir, manifest) {
+	const fs = await loadFsApi();
+	const dir = `${syncDir}/${MANIFEST_DIR}`;
+	try {
+		await fs.mkdir(dir, { recursive: true });
+	} catch {}
+	manifest.lastSyncAt = Date.now();
+	await fs.writeTextFile(manifestPath(syncDir), JSON.stringify(manifest, null, 2));
+}
+function lookupByDocId(manifest, docId) {
+	return manifest.entries[docId];
+}
+function lookupByPath(manifest, relativePath) {
+	for (const entry of Object.values(manifest.entries)) if (entry.relativePath === relativePath) return entry;
+}
+function lookupByHash(manifest, contentHash) {
+	for (const entry of Object.values(manifest.entries)) if (entry.contentHash === contentHash) return entry;
+}
+function setEntry(manifest, entry) {
+	manifest.entries[entry.docId] = entry;
+}
+function removeEntry(manifest, docId) {
+	const entry = manifest.entries[docId];
+	if (entry) delete manifest.entries[docId];
+	return entry;
+}
+function buildReverseLookup(manifest) {
+	const map = /* @__PURE__ */ new Map();
+	for (const [docId, entry] of Object.entries(manifest.entries)) map.set(entry.relativePath, docId);
+	return map;
+}
+
+//#endregion
+//#region packages/convert/src/file-blocks/paths.ts
+/**
+* Convert a document label to a filesystem-safe filename (without extension).
+* e.g. "My Project!" -> "my-project"
+*/
+function labelToFilename(label) {
+	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"
+*/
+function fsFilenameToLabel(filename) {
+	return filename.replace(/~[a-z0-9]{4}$/, "").replace(/-/g, " ");
+}
+/**
+* Check if a doc has children in the tree (needs _index.md convention).
+*/
+function hasChildren(docId, treeData) {
+	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, docId, parentPath, manifest, isIndex) {
+	const ext = ".md";
+	const desiredRelative = isIndex ? `${parentPath}${parentPath ? "/" : ""}${desiredFilename}/_index${ext}` : `${parentPath}${parentPath ? "/" : ""}${desiredFilename}${ext}`;
+	for (const [entryDocId, entry] of Object.entries(manifest.entries)) {
+		if (entryDocId === docId) continue;
+		if (entry.relativePath === desiredRelative) 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
+*/
+function buildRelativePath(docId, treeData, manifest) {
+	const entry = treeData[docId];
+	if (!entry) return `${docId}.md`;
+	const segments = [];
+	let current = entry;
+	let currentId = docId;
+	const visited = /* @__PURE__ */ new Set();
+	while (current) {
+		if (visited.has(currentId)) break;
+		visited.add(currentId);
+		segments.unshift(labelToFilename(current.label));
+		if (!current.parentId) break;
+		currentId = current.parentId;
+		current = treeData[currentId];
+	}
+	const filename = segments.pop();
+	const parentPath = segments.join("/");
+	const isIndex = hasChildren(docId, treeData);
+	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
+*/
+function getDocDir(relativePath) {
+	if (relativePath.endsWith("/_index.md")) return relativePath.replace("/_index.md", "");
+	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.
+*/
+function resolveParentFromPath(relativePath, treeData) {
+	const parts = relativePath.split("/");
+	parts.pop();
+	if (relativePath.endsWith("/_index.md") && parts.length > 0) parts.pop();
+	if (parts.length === 0) return null;
+	let parentId = 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 break;
+	}
+	return parentId;
+}
+/**
+* Simple string hash (same as current useFsSync).
+*/
+function simpleHash(str) {
+	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.
+*/
+function getTreeData(treeMap) {
+	const data = {};
+	treeMap.forEach((val, key) => {
+		if (val && typeof val === "object") data[key] = val;
+	});
+	return data;
+}
+/**
+* Find the next order value for a given parent (max sibling order + 1).
+*/
+function nextOrder(treeData, parentId) {
+	let max = -1;
+	for (const entry of Object.values(treeData)) if (entry.parentId === parentId && entry.order > max) max = entry.order;
+	return max + 1;
+}
+
+//#endregion
+export { MARK_SPECS, MARK_SPEC_BY_DELIM, MARK_SPEC_BY_NAME, NODE_SPECS, NODE_SPEC_BY_NAME, UNIVERSAL_META_KEYS, UNIVERSAL_META_KEY_NAMES, appendHtmlToFragment, buildAliasMap, buildRelativePath, buildReverseLookup, conflictsDir, createEmptyManifest, diffJson, diffYjs, filenameToLabel, fsFilenameToLabel, getDocDir, getFsAdapter, getTreeData, hasChildren, jsonToYFragment, labelToFilename, loadManifest, lookupByDocId, lookupByHash, lookupByPath, manifestDir, mdcTagOf, nextOrder, orphansDir, parseFrontmatter, populateYDocFromHtml, populateYDocFromMarkdown, removeEntry, resolveParentFromPath, saveManifest, setEntry, setFsAdapter, simpleHash, stringifyJsonNode, trashDir, yfragmentToJson, yjsToHtml, yjsToMarkdown, yjsToPlainText };
+//# sourceMappingURL=abracadabra-convert.esm.js.map