wiki-viewer 1.0.0

package/.next/standalone/src/lib/google/detect.ts

@@ -0,0 +1,107 @@
+export type GoogleKind = "sheets" | "slides" | "docs" | "forms" | "drive";
+
+export interface GoogleLink {
+	kind: GoogleKind;
+	id: string;
+	/** URL suitable for embedding in an iframe. May require "Publish to Web". */
+	embedUrl: string;
+	/** URL to open in a new tab to view/edit in Google's own UI. */
+	openUrl: string;
+	/** Raw input URL. */
+	rawUrl: string;
+}
+
+const PATTERNS: Array<{ re: RegExp; kind: GoogleKind }> = [
+	{
+		re: /^https?:\/\/docs\.google\.com\/spreadsheets\/d\/(?:e\/)?([A-Za-z0-9_-]+)/,
+		kind: "sheets",
+	},
+	{
+		re: /^https?:\/\/docs\.google\.com\/presentation\/d\/(?:e\/)?([A-Za-z0-9_-]+)/,
+		kind: "slides",
+	},
+	{
+		re: /^https?:\/\/docs\.google\.com\/document\/d\/(?:e\/)?([A-Za-z0-9_-]+)/,
+		kind: "docs",
+	},
+	{
+		re: /^https?:\/\/docs\.google\.com\/forms\/d\/(?:e\/)?([A-Za-z0-9_-]+)/,
+		kind: "forms",
+	},
+	{
+		re: /^https?:\/\/drive\.google\.com\/file\/d\/([A-Za-z0-9_-]+)/,
+		kind: "drive",
+	},
+];
+
+/**
+ * Inspect a URL and resolve it to a Google document we know how to embed.
+ * Returns null for any URL that isn't a Google Workspace link.
+ */
+export function detectGoogle(rawUrl: string): GoogleLink | null {
+	const url = rawUrl.trim();
+	if (!url) return null;
+	for (const { re, kind } of PATTERNS) {
+		const m = url.match(re);
+		if (!m) continue;
+		const id = m[1];
+		return {
+			kind,
+			id,
+			embedUrl: computeEmbedUrl(kind, id, url),
+			openUrl: computeOpenUrl(kind, id),
+			rawUrl,
+		};
+	}
+	return null;
+}
+
+function computeEmbedUrl(kind: GoogleKind, id: string, rawUrl: string): string {
+	// Preserve any `?e=` / share-link variant Google already generated
+	const hasE = /\/d\/e\//.test(rawUrl);
+	const idSeg = hasE ? `e/${id}` : id;
+	switch (kind) {
+		case "sheets":
+			// `pubhtml` renders as a scrollable table; `edit?embed=true` keeps full UI
+			// when the doc is published. Prefer `pubhtml` for minimal chrome.
+			return `https://docs.google.com/spreadsheets/d/${idSeg}/pubhtml?widget=true&headers=false`;
+		case "slides":
+			return `https://docs.google.com/presentation/d/${idSeg}/embed?start=false&loop=false&delayms=3000`;
+		case "docs":
+			return `https://docs.google.com/document/d/${idSeg}/pub?embedded=true`;
+		case "forms":
+			return `https://docs.google.com/forms/d/${idSeg}/viewform?embedded=true`;
+		case "drive":
+			return `https://drive.google.com/file/d/${id}/preview`;
+	}
+}
+
+function computeOpenUrl(kind: GoogleKind, id: string): string {
+	switch (kind) {
+		case "sheets":
+			return `https://docs.google.com/spreadsheets/d/${id}/edit`;
+		case "slides":
+			return `https://docs.google.com/presentation/d/${id}/edit`;
+		case "docs":
+			return `https://docs.google.com/document/d/${id}/edit`;
+		case "forms":
+			return `https://docs.google.com/forms/d/${id}/edit`;
+		case "drive":
+			return `https://drive.google.com/file/d/${id}/view`;
+	}
+}
+
+export function googleKindLabel(kind: GoogleKind): string {
+	switch (kind) {
+		case "sheets":
+			return "Google Sheets";
+		case "slides":
+			return "Google Slides";
+		case "docs":
+			return "Google Docs";
+		case "forms":
+			return "Google Forms";
+		case "drive":
+			return "Google Drive";
+	}
+}

package/.next/standalone/src/lib/markdown/parse-frontmatter.ts

@@ -0,0 +1,84 @@
+/**
+ * Tiny client-safe frontmatter parser for wiki YAML.
+ * Handles the subset we use: scalars, inline arrays, and block arrays.
+ * Not a full YAML parser. For complex structures, fall back to server.
+ */
+
+export interface ParsedFrontmatter {
+	data: Record<string, unknown>;
+	body: string;
+}
+
+const BLOCK_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+
+function parseScalar(raw: string): unknown {
+	const v = raw.trim();
+	if (v === "") return "";
+	if (v === "true") return true;
+	if (v === "false") return false;
+	if (v === "null" || v === "~") return null;
+	if (/^-?\d+$/.test(v)) return Number(v);
+	if (/^-?\d*\.\d+$/.test(v)) return Number(v);
+	// Quoted string
+	if (
+		(v.startsWith('"') && v.endsWith('"')) ||
+		(v.startsWith("'") && v.endsWith("'"))
+	) {
+		return v.slice(1, -1);
+	}
+	// Inline array: [a, b, c]
+	if (v.startsWith("[") && v.endsWith("]")) {
+		const inner = v.slice(1, -1).trim();
+		if (inner === "") return [];
+		return inner.split(",").map((s) => parseScalar(s));
+	}
+	return v;
+}
+
+export function parseFrontmatter(text: string): ParsedFrontmatter {
+	const match = BLOCK_RE.exec(text);
+	if (!match) return { data: {}, body: text };
+
+	const block = match[1];
+	const body = text.slice(match[0].length);
+	const data: Record<string, unknown> = {};
+
+	const lines = block.split(/\r?\n/);
+	let i = 0;
+	while (i < lines.length) {
+		const line = lines[i];
+		if (!line || /^\s*#/.test(line)) {
+			i += 1;
+			continue;
+		}
+		const m = /^([A-Za-z_][\w-]*)\s*:\s*(.*)$/.exec(line);
+		if (!m) {
+			i += 1;
+			continue;
+		}
+		const key = m[1];
+		const rest = m[2];
+		if (rest.trim() === "") {
+			// Possibly a block array on following indented lines
+			const items: unknown[] = [];
+			let j = i + 1;
+			while (j < lines.length && /^\s+-\s+/.test(lines[j])) {
+				const itemMatch = /^\s+-\s+(.*)$/.exec(lines[j]);
+				if (itemMatch) items.push(parseScalar(itemMatch[1]));
+				j += 1;
+			}
+			if (items.length > 0) {
+				data[key] = items;
+				i = j;
+				continue;
+			}
+			data[key] = "";
+			i += 1;
+			continue;
+		}
+		data[key] = parseScalar(rest);
+		i += 1;
+	}
+
+	return { data, body };
+}

package/.next/standalone/src/lib/markdown/remark-wikilinks.ts

@@ -0,0 +1,100 @@
+import type { Link, Parent, PhrasingContent, Root, Text } from "mdast";
+import type { Plugin } from "unified";
+
+const WIKILINK_RE = /\[\[([a-z0-9-]+)(?:\|([^\]#|]+)|#([a-z0-9-]+))?\]\]/g;
+
+/**
+ * Remark plugin that converts [[slug]], [[slug|alias]], and [[slug#anchor]]
+ * occurrences in text nodes into link nodes targeting `#wiki:slug` (with
+ * `#anchor` appended when present). The link's data attributes carry the
+ * slug, optional alias, and optional anchor so renderers can branch on
+ * wiki-links specifically.
+ */
+const remarkWikilinks: Plugin<[], Root> = () => {
+	return (tree) => {
+		visit(tree, (node, index, parent) => {
+			if (!parent || index === undefined) return;
+			if (node.type !== "text") return;
+			const text = (node as Text).value;
+			if (!text?.includes("[[")) return;
+
+			const replacements: PhrasingContent[] = [];
+			let lastIndex = 0;
+			WIKILINK_RE.lastIndex = 0;
+			let match: RegExpExecArray | null = WIKILINK_RE.exec(text);
+			while (match !== null) {
+				const [full, slug, alias, anchor] = match;
+				if (match.index > lastIndex) {
+					replacements.push({
+						type: "text",
+						value: text.slice(lastIndex, match.index),
+					} as Text);
+				}
+				const visible = alias ?? (anchor ? `${slug}#${anchor}` : slug);
+				const url = anchor ? `#wiki:${slug}#${anchor}` : `#wiki:${slug}`;
+				const link: Link = {
+					type: "link",
+					url,
+					title: null,
+					children: [{ type: "text", value: visible } as Text],
+					data: {
+						hProperties: {
+							"data-wiki-link": "true",
+							"data-slug": slug,
+							...(alias ? { "data-alias": alias } : {}),
+							...(anchor ? { "data-anchor": anchor } : {}),
+							className: ["wiki-link"],
+						},
+					},
+				};
+				replacements.push(link);
+				lastIndex = match.index + full.length;
+				match = WIKILINK_RE.exec(text);
+			}
+
+			if (replacements.length === 0) return;
+			if (lastIndex < text.length) {
+				replacements.push({
+					type: "text",
+					value: text.slice(lastIndex),
+				} as Text);
+			}
+
+			(parent as Parent).children.splice(index, 1, ...replacements);
+			return index + replacements.length;
+		});
+	};
+};
+
+type Visitor = (
+	node: Root | PhrasingContent | Parent,
+	index: number | undefined,
+	parent: Parent | null,
+) => number | undefined;
+
+function visit(
+	node: Root | Parent,
+	fn: Visitor,
+	parent: Parent | null = null,
+): void {
+	if ("children" in node && Array.isArray(node.children)) {
+		let i = 0;
+		while (i < node.children.length) {
+			const child = node.children[i];
+			const next = fn(child as PhrasingContent, i, node);
+			if (typeof next === "number") {
+				i = next;
+				continue;
+			}
+			if (child && typeof child === "object" && "children" in child) {
+				visit(child as Parent, fn, node);
+			}
+			i += 1;
+		}
+	}
+	if (parent === null) {
+		fn(node, undefined, null);
+	}
+}
+
+export default remarkWikilinks;

package/.next/standalone/src/lib/markdown/to-html.ts

@@ -0,0 +1,168 @@
+import rehypeStringify from "rehype-stringify";
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+import { unified } from "unified";
+import { detectEmbed } from "@/lib/embeds/detect";
+
+// Canonical wiki-link regex (llm-wiki-pm ground truth).
+// Groups: 1=slug  2=alias  3=anchor
+const WIKI_LINK_RE = /\[\[([^\]|#]+)(?:\|([^\]]*)|#([^\]]*))?\]\]/g;
+const SLUG_VALID_RE = /^[a-z0-9-]+$/;
+
+/**
+ * Pre-process markdown to convert wiki-links to HTML anchors
+ * before the remark pipeline (which treats [[ as plain text).
+ *
+ * Handles three forms:
+ *   [[slug]]          - bare
+ *   [[slug|alias]]    - aliased
+ *   [[slug#anchor]]   - anchored
+ *
+ * Slugs that fail ^[a-z0-9-]+$ validation are left as plain text.
+ */
+function convertWikiLinks(markdown: string): string {
+	return markdown.replace(
+		WIKI_LINK_RE,
+		(
+			_match: string,
+			rawSlug: string,
+			alias: string | undefined,
+			anchor: string | undefined,
+		): string => {
+			const slug = rawSlug.trim();
+			if (!SLUG_VALID_RE.test(slug)) return _match;
+			const visibleText = alias ?? (anchor ? `${slug}#${anchor}` : slug);
+			const href = anchor ? `#wiki:${slug}#${anchor}` : `#wiki:${slug}`;
+			const aliasAttr = alias !== undefined ? ` data-alias="${alias}"` : "";
+			const anchorAttr = anchor !== undefined ? ` data-anchor="${anchor}"` : "";
+			return `<a data-wiki-link="true" data-slug="${slug}"${aliasAttr}${anchorAttr} href="${href}" class="wiki-link">${visibleText}</a>`;
+		},
+	);
+}
+
+/**
+ * Post-process HTML to fix task list structure for Tiptap compatibility.
+ * remark-gfm outputs: <li><input type="checkbox" ...> text</li>
+ * Tiptap expects:     <li data-type="taskItem" data-checked="..."><label><input ...></label><div><p>text</p></div></li>
+ * And the parent <ul> needs class="task-list" and data-type="taskList".
+ */
+function fixTaskListHtml(html: string): string {
+	// Convert task list <ul> with contains-task-list class
+	html = html.replace(
+		/<ul class="contains-task-list">/g,
+		'<ul data-type="taskList" class="task-list">',
+	);
+
+	// Convert each task list item to Tiptap's expected structure
+	html = html.replace(
+		/<li class="task-list-item">\s*<input type="checkbox"([^>]*)>\s*([\s\S]*?)(?=<\/li>)/g,
+		(_match, attrs: string, content: string) => {
+			const checked = attrs.includes("checked");
+			const cleanContent = content.trim();
+			return `<li data-type="taskItem" data-checked="${checked}"><label><input type="checkbox"${checked ? " checked" : ""}></label><div><p>${cleanContent}</p></div>`;
+		},
+	);
+
+	return html;
+}
+
+/**
+ * Upgrade broken `<video src="https://youtu.be/...">` (or any non-file video URL
+ * that points at a known embed provider) into a real iframe embed block.
+ *
+ * This heals content written before we had proper embed support, and also any
+ * time the TipTap schema round-trip collapsed an iframe into a video tag.
+ */
+function upgradeProviderVideos(html: string): string {
+	return html.replace(
+		/<video\b([^>]*)\bsrc="([^"]+)"([^>]*)><\/video>/gi,
+		(match, _before: string, src: string, _after: string) => {
+			const detected = detectEmbed(src);
+			if (!detected || detected.provider === "video") return match;
+
+			const aspect = detected.aspectRatio
+				? ` data-aspect-ratio="${detected.aspectRatio}"`
+				: "";
+			return (
+				`<div data-embed="true" data-provider="${detected.provider}"` +
+				` data-src="${detected.embedUrl}"` +
+				` data-original-url="${detected.originalUrl}"${aspect}>` +
+				`<iframe src="${detected.embedUrl}"` +
+				` data-embed-provider="${detected.provider}"` +
+				` allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share; fullscreen"` +
+				` allowfullscreen loading="lazy" frameborder="0"></iframe>` +
+				`</div>`
+			);
+		},
+	);
+}
+
+/**
+ * Rewrite relative URLs (./file.pdf, ./image.png) to /api/assets/{pagePath}/file
+ * and convert PDF links to inline embedded viewers.
+ * Applies to href, src, and data-src attributes (the last is used by embed blocks).
+ */
+function resolveRelativeUrls(html: string, pagePath: string): string {
+	const dirPath = pagePath;
+
+	html = html.replace(
+		/href="\.\/([^"]+)"/g,
+		(_match, file: string) => `href="/api/assets/${dirPath}/${file}"`,
+	);
+
+	html = html.replace(
+		/src="\.\/([^"]+)"/g,
+		(_match, file: string) => `src="/api/assets/${dirPath}/${file}"`,
+	);
+
+	html = html.replace(
+		/data-src="\.\/([^"]+)"/g,
+		(_match, file: string) => `data-src="/api/assets/${dirPath}/${file}"`,
+	);
+
+	// Mark PDF links with a data attribute so the editor can handle them
+	html = html.replace(
+		/<a([^>]*?)href="(\/api\/assets\/[^"]+\.pdf)"([^>]*?)>/gi,
+		(_match, before: string, url: string, after: string) => {
+			return `<a${before}href="${url}"${after} data-pdf-link="true">`;
+		},
+	);
+
+	return html;
+}
+
+// Unified's plugin resolution + processor freeze runs on every `unified()`
+// call. Reuse a single frozen pipeline across every page render so
+// navigation doesn't pay that cost on the hot path.
+const processor = unified()
+	.use(remarkParse)
+	.use(remarkGfm)
+	.use(remarkRehype, { allowDangerousHtml: true })
+	.use(rehypeStringify, { allowDangerousHtml: true })
+	.freeze();
+
+export async function markdownToHtml(
+	markdown: string,
+	pagePath?: string,
+): Promise<string> {
+	// Pre-process wiki-links before remark (which would treat [[ as text)
+	const preprocessed = convertWikiLinks(markdown);
+
+	const result = await processor.process(preprocessed);
+
+	let html = String(result);
+
+	// Post-process task lists for Tiptap compatibility
+	html = fixTaskListHtml(html);
+
+	// Heal <video src="youtube-url"> into real iframe embeds
+	html = upgradeProviderVideos(html);
+
+	// Resolve relative URLs if page path is provided
+	if (pagePath) {
+		html = resolveRelativeUrls(html, pagePath);
+	}
+
+	return html;
+}

package/.next/standalone/src/lib/markdown/to-markdown.ts

@@ -0,0 +1,238 @@
+import TurndownService from "turndown";
+// @ts-expect-error — no types available for this package
+import { gfm } from "turndown-plugin-gfm";
+import { detectEmbed } from "@/lib/embeds/detect";
+
+const turndown = new TurndownService({
+	headingStyle: "atx",
+	hr: "---",
+	bulletListMarker: "-",
+	codeBlockStyle: "fenced",
+	fence: "```",
+	emDelimiter: "*",
+	strongDelimiter: "**",
+});
+
+// Add GFM support (tables, strikethrough, task lists)
+turndown.use(gfm);
+
+// Preserve line breaks in code blocks
+turndown.addRule("codeBlock", {
+	filter: (node) => {
+		return (
+			node.nodeName === "PRE" &&
+			node.firstChild !== null &&
+			node.firstChild.nodeName === "CODE"
+		);
+	},
+	replacement: (_content, node) => {
+		const code = node.firstChild as HTMLElement;
+		const lang = code.getAttribute("class")?.replace("language-", "") || "";
+		const text = code.textContent || "";
+		return `\n\`\`\`${lang}\n${text}\n\`\`\`\n`;
+	},
+});
+
+// Serialize wiki-links back to llm-wiki-pm syntax.
+// Round-trip is lossless: slug/alias/anchor attrs map 1-to-1 to each form.
+turndown.addRule("wikiLink", {
+	filter: (node) =>
+		node.nodeName === "A" && node.getAttribute("data-wiki-link") === "true",
+	replacement: (_content, node) => {
+		const el = node as HTMLElement;
+		const slug = el.getAttribute("data-slug") ?? "";
+		const alias = el.getAttribute("data-alias");
+		const anchor = el.getAttribute("data-anchor");
+		if (alias) return `[[${slug}|${alias}]]`;
+		if (anchor) return `[[${slug}#${anchor}]]`;
+		return `[[${slug}]]`;
+	},
+});
+
+// Preserve inline styled spans (text color, background color, font weight, etc.)
+// so colors and highlights survive markdown roundtrip.
+turndown.addRule("styledSpan", {
+	filter: (node) =>
+		node.nodeName === "SPAN" && !!(node as HTMLElement).getAttribute("style"),
+	replacement: (content, node) => {
+		const style = (node as HTMLElement).getAttribute("style") ?? "";
+		return `<span style="${style}">${content}</span>`;
+	},
+});
+
+// Lucide icon node — serialize as a clean `<span data-lucide="…" data-color="…">`
+// stub. The editor's IconExtension rebuilds the colored SVG on load.
+turndown.addRule("lucideIcon", {
+	filter: (node) =>
+		node.nodeName === "SPAN" &&
+		(node as HTMLElement).hasAttribute("data-lucide"),
+	replacement: (_content, node) => {
+		const el = node as HTMLElement;
+		const name = el.getAttribute("data-lucide") ?? "file";
+		const color = el.getAttribute("data-color") ?? "gray";
+		return `<span data-lucide="${name}" data-color="${color}">&nbsp;</span>`;
+	},
+});
+
+// Preserve <mark> with any attributes (highlight extension writes data-color + style).
+turndown.addRule("mark", {
+	filter: "mark" as never,
+	replacement: (content, node) => {
+		const el = node as HTMLElement;
+		const attrs: string[] = [];
+		for (const attr of Array.from(el.attributes)) {
+			attrs.push(`${attr.name}="${attr.value.replace(/"/g, "&quot;")}"`);
+		}
+		return `<mark${attrs.length ? ` ${attrs.join(" ")}` : ""}>${content}</mark>`;
+	},
+});
+
+// Preserve <u>, <sub>, <sup> (underline, subscript, superscript).
+for (const tag of ["u", "sub", "sup"] as const) {
+	turndown.addRule(tag, {
+		filter: tag as never,
+		replacement: (content) => `<${tag}>${content}</${tag}>`,
+	});
+}
+
+// Preserve <video> tags with all attrs (file-uploaded videos).
+// If the src points at a known embed provider (YouTube, Vimeo, Loom, …),
+// upgrade it to a proper embed block instead of preserving a tag that
+// browsers can't render.
+turndown.addRule("video", {
+	filter: "video" as never,
+	replacement: (_content, node) => {
+		const el = node as HTMLElement;
+		const src = el.getAttribute("src") ?? "";
+		const detected = src ? detectEmbed(src) : null;
+		if (detected && detected.provider !== "video") {
+			const aspect = detected.aspectRatio
+				? ` data-aspect-ratio="${detected.aspectRatio}"`
+				: "";
+			return (
+				`\n<div data-embed="true" data-provider="${detected.provider}"` +
+				` data-src="${detected.embedUrl}"` +
+				` data-original-url="${detected.originalUrl}"${aspect}>` +
+				`<iframe src="${detected.embedUrl}"` +
+				` data-embed-provider="${detected.provider}"` +
+				` allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share; fullscreen"` +
+				` allowfullscreen loading="lazy" frameborder="0"></iframe>` +
+				`</div>\n`
+			);
+		}
+
+		const attrs: string[] = [];
+		for (const attr of Array.from(el.attributes)) {
+			attrs.push(`${attr.name}="${attr.value.replace(/"/g, "&quot;")}"`);
+		}
+		return `<video${attrs.length ? ` ${attrs.join(" ")}` : ""}></video>`;
+	},
+});
+
+// Preserve embed blocks (YouTube/Vimeo/Loom/X/Facebook/Instagram/etc.) as HTML.
+turndown.addRule("embedBlock", {
+	filter: (node) =>
+		node.nodeName === "DIV" &&
+		(node as HTMLElement).getAttribute("data-embed") === "true",
+	replacement: (_content, node) => {
+		const el = node as HTMLElement;
+		const provider = el.getAttribute("data-provider") ?? "iframe";
+		const src = el.getAttribute("data-src") ?? "";
+		const originalUrl = el.getAttribute("data-original-url") ?? "";
+		const aspect = el.getAttribute("data-aspect-ratio") ?? "";
+
+		if (provider === "video") {
+			return `\n<video src="${src}" controls></video>\n`;
+		}
+
+		const attrs = [
+			`data-embed="true"`,
+			`data-provider="${provider}"`,
+			`data-src="${src}"`,
+			originalUrl ? `data-original-url="${originalUrl}"` : "",
+			aspect ? `data-aspect-ratio="${aspect}"` : "",
+		]
+			.filter(Boolean)
+			.join(" ");
+
+		return `\n<div ${attrs}><iframe src="${src}" data-embed-provider="${provider}" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share; fullscreen" allowfullscreen loading="lazy" frameborder="0"></iframe></div>\n`;
+	},
+});
+
+// Preserve Twitter/X embeds as <blockquote class="twitter-tweet">…
+turndown.addRule("twitterEmbed", {
+	filter: (node) =>
+		node.nodeName === "BLOCKQUOTE" &&
+		(node as HTMLElement).classList.contains("twitter-tweet"),
+	replacement: (_content, node) => {
+		const el = node as HTMLElement;
+		const a = el.querySelector("a");
+		const href = a?.getAttribute("href") ?? "";
+		return `\n<blockquote class="twitter-tweet" data-theme="auto"><a href="${href}">${href}</a></blockquote>\n`;
+	},
+});
+
+// Preserve images that have inline width/align data. Turndown's default image
+// rule emits `![]()`, losing size info — so when the <img> has width, align, or
+// wraps in a resizable-image div we emit the raw HTML instead.
+turndown.addRule("sizedImage", {
+	filter: (node) => {
+		if (node.nodeName !== "IMG") return false;
+		const el = node as HTMLElement;
+		const width = el.getAttribute("width") ?? el.style.width;
+		const align = el.getAttribute("data-align");
+		return !!(width || align);
+	},
+	replacement: (_content, node) => {
+		const el = node as HTMLElement;
+		const attrs: string[] = [];
+		for (const attr of Array.from(el.attributes)) {
+			attrs.push(`${attr.name}="${attr.value.replace(/"/g, "&quot;")}"`);
+		}
+		return `<img ${attrs.join(" ")} />`;
+	},
+});
+
+// Preserve the resizable-image wrapper so align info survives.
+turndown.addRule("resizableImageWrapper", {
+	filter: (node) =>
+		node.nodeName === "DIV" &&
+		(node as HTMLElement).classList.contains("resizable-image"),
+	replacement: (content) => content,
+});
+
+// Math extension renders <span data-type="inlineMath" data-latex="..."> etc.
+turndown.addRule("inlineMath", {
+	filter: (node) => {
+		const el = node as HTMLElement;
+		if (el.nodeName !== "SPAN") return false;
+		const dataType = el.getAttribute("data-type");
+		return dataType === "inline-math" || dataType === "inlineMath";
+	},
+	replacement: (_content, node) => {
+		const latex = (node as HTMLElement).getAttribute("data-latex") ?? "";
+		return `$${latex}$`;
+	},
+});
+
+// Preserve aligned blocks (paragraphs/headings with inline text-align style).
+// Default turndown serializers lose the style attr; we emit raw HTML when a
+// block has non-default alignment.
+turndown.addRule("alignedBlock", {
+	filter: (node) => {
+		if (!["P", "H1", "H2", "H3", "H4", "H5", "H6"].includes(node.nodeName))
+			return false;
+		const style = (node as HTMLElement).getAttribute("style") ?? "";
+		return /text-align:\s*(center|right|justify)/.test(style);
+	},
+	replacement: (content, node) => {
+		const el = node as HTMLElement;
+		const tag = el.nodeName.toLowerCase();
+		const style = el.getAttribute("style") ?? "";
+		return `\n<${tag} style="${style}">${content}</${tag}>\n`;
+	},
+});
+
+export function htmlToMarkdown(html: string): string {
+	return turndown.turndown(html);
+}