mosage 0.2.0 → 0.8.0

package/dist/context-BqsdSrAQ.js

@@ -0,0 +1,1084 @@
+import { a as PAGE_SIZE_NAMES, o as isOrientation, r as ORIENTATIONS, s as isPageSizeName } from "./sdk-DjpX6mCv.js";
+import { r as readCoreVersion } from "./cli/bin.js";
+import { a as resolveEntry, c as DOC_ID_RE, i as listDocIds, l as loadUserConfig, n as OpsError, o as makeContext, r as createDocument, s as validateAssetName, t as createViteConfig } from "./config-DPm1BBAb.js";
+import path from "node:path";
+import { existsSync } from "node:fs";
+import fs from "node:fs/promises";
+import "fast-glob";
+import { createServer, mergeConfig } from "vite";
+import { Buffer } from "node:buffer";
+//#region src/import/markdown.ts
+const FENCE_RE = /^(```|~~~)\s*([^\s`]*)\s*$/;
+const ATX_RE = /^(#{1,6})\s+(.*?)\s*#*\s*$/;
+const HR_RE = /^ {0,3}(?:-{3,}|\*{3,}|_{3,})\s*$/;
+const QUOTE_RE = /^ {0,3}> ?(.*)$/;
+const UL_RE = /^(\s*)([-*+])\s+(.*)$/;
+const OL_RE = /^(\s*)(\d{1,9})[.)]\s+(.*)$/;
+const SETEXT_RE = /^ {0,3}(=+|-+)\s*$/;
+const TABLE_DELIM_RE = /^\s*\|?\s*:?-{1,}:?\s*(\|\s*:?-{1,}:?\s*)*\|?\s*$/;
+function splitLines(source) {
+	return source.replace(/^/, "").replace(/\r\n?/g, "\n").split("\n");
+}
+function parseFrontmatter(lines) {
+	if (lines[0]?.trim() !== "---") return {
+		frontmatter: {},
+		rest: lines
+	};
+	const end = lines.findIndex((line, i) => i > 0 && line.trim() === "---");
+	if (end === -1) return {
+		frontmatter: {},
+		rest: lines
+	};
+	const frontmatter = {};
+	for (const line of lines.slice(1, end)) {
+		const match = line.match(/^([A-Za-z0-9_-]+)\s*:\s*(.*)$/);
+		if (!match) continue;
+		frontmatter[match[1]] = match[2].trim().replace(/^['"]|['"]$/g, "");
+	}
+	return {
+		frontmatter,
+		rest: lines.slice(end + 1)
+	};
+}
+function splitRow(line) {
+	const trimmed = line.trim().replace(/^\|/, "").replace(/\|$/, "");
+	const cells = [];
+	let current = "";
+	for (let i = 0; i < trimmed.length; i++) {
+		const char = trimmed[i];
+		if (char === "\\" && trimmed[i + 1] === "|") {
+			current += "|";
+			i++;
+			continue;
+		}
+		if (char === "|") {
+			cells.push(current.trim());
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	cells.push(current.trim());
+	return cells;
+}
+function parseAlign(line) {
+	return splitRow(line).map((cell) => {
+		const left = cell.startsWith(":");
+		const right = cell.endsWith(":");
+		if (left && right) return "center";
+		if (right) return "right";
+		if (left) return "left";
+		return null;
+	});
+}
+function indentOf(line) {
+	return line.length - line.trimStart().length;
+}
+function isBlockStart(line) {
+	return ATX_RE.test(line) || HR_RE.test(line) || QUOTE_RE.test(line) || UL_RE.test(line) || OL_RE.test(line) || FENCE_RE.test(line);
+}
+function parseMarkdown(source) {
+	const { frontmatter, rest } = parseFrontmatter(splitLines(source));
+	return {
+		frontmatter,
+		blocks: parseBlocks(rest)
+	};
+}
+function parseBlocks(lines) {
+	const blocks = [];
+	let i = 0;
+	while (i < lines.length) {
+		const line = lines[i];
+		if (line.trim() === "") {
+			i++;
+			continue;
+		}
+		const fence = line.match(FENCE_RE);
+		if (fence) {
+			const marker = fence[1];
+			const value = [];
+			i++;
+			while (i < lines.length && !lines[i].trimStart().startsWith(marker)) {
+				value.push(lines[i]);
+				i++;
+			}
+			i++;
+			blocks.push({
+				type: "code",
+				lang: fence[2] || null,
+				value: value.join("\n")
+			});
+			continue;
+		}
+		const atx = line.match(ATX_RE);
+		if (atx) {
+			blocks.push({
+				type: "heading",
+				level: atx[1].length,
+				children: parseInline(atx[2])
+			});
+			i++;
+			continue;
+		}
+		if (HR_RE.test(line)) {
+			blocks.push({ type: "hr" });
+			i++;
+			continue;
+		}
+		if (QUOTE_RE.test(line)) {
+			const inner = [];
+			while (i < lines.length && (QUOTE_RE.test(lines[i]) || lines[i].trim() !== "")) {
+				const match = lines[i].match(QUOTE_RE);
+				if (!match && lines[i].trim() === "") break;
+				inner.push(match ? match[1] : lines[i]);
+				i++;
+			}
+			blocks.push({
+				type: "quote",
+				children: parseBlocks(inner)
+			});
+			continue;
+		}
+		if (UL_RE.test(line) || OL_RE.test(line)) {
+			const { block, next } = parseList(lines, i);
+			blocks.push(block);
+			i = next;
+			continue;
+		}
+		if (line.includes("|") && lines[i + 1] !== void 0 && TABLE_DELIM_RE.test(lines[i + 1])) {
+			const head = splitRow(line).map(parseInline);
+			const align = parseAlign(lines[i + 1]);
+			const rows = [];
+			i += 2;
+			while (i < lines.length && lines[i].includes("|") && lines[i].trim() !== "") {
+				rows.push(splitRow(lines[i]).map(parseInline));
+				i++;
+			}
+			blocks.push({
+				type: "table",
+				head,
+				rows,
+				align
+			});
+			continue;
+		}
+		const paragraph = [];
+		while (i < lines.length && lines[i].trim() !== "") {
+			const next = lines[i + 1];
+			if (next !== void 0 && SETEXT_RE.test(next)) {
+				paragraph.push(lines[i]);
+				i += 2;
+				blocks.push({
+					type: "heading",
+					level: next.trim().startsWith("=") ? 1 : 2,
+					children: parseInline(paragraph.join(" "))
+				});
+				paragraph.length = 0;
+				break;
+			}
+			if (paragraph.length > 0 && isBlockStart(lines[i])) break;
+			paragraph.push(lines[i]);
+			i++;
+		}
+		if (paragraph.length > 0) {
+			const text = paragraph.join("\n");
+			const figure = asStandaloneImage(text);
+			blocks.push(figure ?? {
+				type: "paragraph",
+				children: parseInline(text)
+			});
+		}
+	}
+	return blocks;
+}
+/** An image alone in its paragraph is a figure, not a run of inline content. */
+function asStandaloneImage(text) {
+	const match = text.trim().match(/^!\[([^\]]*)\]\(([^)\s]+)(?:\s+"[^"]*")?\)$/);
+	if (!match) return null;
+	return {
+		type: "figure",
+		alt: match[1],
+		src: match[2]
+	};
+}
+function parseList(lines, start) {
+	const first = lines[start];
+	const ordered = OL_RE.test(first);
+	const startNumber = ordered ? Number(first.match(OL_RE)?.[2] ?? 1) : 1;
+	const baseIndent = indentOf(first);
+	const items = [];
+	let i = start;
+	let current = null;
+	const flush = () => {
+		if (current) items.push(parseBlocks(current));
+		current = null;
+	};
+	while (i < lines.length) {
+		const line = lines[i];
+		if (line.trim() === "") {
+			const next = lines[i + 1];
+			if (next === void 0 || next.trim() !== "" && indentOf(next) <= baseIndent && !isItem(next)) break;
+			current?.push("");
+			i++;
+			continue;
+		}
+		const match = line.match(ordered ? OL_RE : UL_RE) ?? line.match(ordered ? UL_RE : OL_RE);
+		if (match && indentOf(line) <= baseIndent) {
+			flush();
+			current = [match[3]];
+			i++;
+			continue;
+		}
+		if (indentOf(line) > baseIndent && current) {
+			current.push(line.slice(Math.min(indentOf(line), baseIndent + 2)));
+			i++;
+			continue;
+		}
+		break;
+	}
+	flush();
+	return {
+		block: {
+			type: "list",
+			ordered,
+			start: startNumber,
+			items
+		},
+		next: i
+	};
+	function isItem(line) {
+		return UL_RE.test(line) || OL_RE.test(line);
+	}
+}
+const INLINE_RE = /(!\[[^\]]*\]\([^)\s]+(?:\s+"[^"]*")?\))|(\[[^\]]*\]\([^)\s]*(?:\s+"[^"]*")?\))|(`+)([^`]*?)\3|(\*\*|__)(?=\S)([\s\S]*?\S)\5|(\*|_)(?=\S)([\s\S]*?\S)\7|(<[^>\s]+@[^>\s]+>)|(https?:\/\/[^\s<>"')\]]+)/;
+function parseInline(source) {
+	const out = [];
+	let rest = maskEscapes(source);
+	const pushText = (value) => {
+		if (value === "") return;
+		value.split(/(?: {2}|\\)\n|\n/).forEach((part, index) => {
+			if (index > 0) out.push({ type: "break" });
+			const text = unmask(part);
+			if (text !== "") out.push({
+				type: "text",
+				value: text
+			});
+		});
+	};
+	while (rest.length > 0) {
+		const match = rest.match(INLINE_RE);
+		if (!match || match.index === void 0) break;
+		pushText(rest.slice(0, match.index));
+		const token = match[0];
+		if (match[1]) {
+			const image = token.match(/^!\[([^\]]*)\]\(([^)\s]+)(?:\s+"[^"]*")?\)$/);
+			if (image) out.push({
+				type: "image",
+				alt: unmask(image[1]),
+				src: unmask(image[2])
+			});
+		} else if (match[2]) {
+			const link = token.match(/^\[([^\]]*)\]\(([^)\s]*)(?:\s+"[^"]*")?\)$/);
+			if (link) out.push({
+				type: "link",
+				href: unmask(link[2]),
+				children: parseInline(link[1])
+			});
+		} else if (match[3]) out.push({
+			type: "code",
+			value: unmask(match[4].trim())
+		});
+		else if (match[5]) out.push({
+			type: "strong",
+			children: parseInline(match[6])
+		});
+		else if (match[7]) out.push({
+			type: "em",
+			children: parseInline(match[8])
+		});
+		else if (match[9]) {
+			const address = token.slice(1, -1);
+			out.push({
+				type: "link",
+				href: `mailto:${address}`,
+				children: [{
+					type: "text",
+					value: address
+				}]
+			});
+		} else if (match[10]) {
+			const url = unmask(token);
+			out.push({
+				type: "link",
+				href: url,
+				children: [{
+					type: "text",
+					value: url
+				}]
+			});
+		}
+		rest = rest.slice(match.index + token.length);
+	}
+	pushText(rest);
+	return out;
+}
+const ESCAPE_RE = /\\([\\`*_{}[\]()#+\-.!|>~])/g;
+const MASK_RE = /\u0000(\d+)\u0000/g;
+/**
+* The inline scanner is a regex over delimiters, which cannot see a preceding
+* backslash. Escaped characters are swapped for a sentinel before scanning and
+* restored on the way out, so `\*not emphasis\*` survives as literal text.
+*/
+function maskEscapes(value) {
+	return value.replace(ESCAPE_RE, (_, char) => `\u0000${char.charCodeAt(0)}\u0000`);
+}
+function unmask(value) {
+	return value.replace(MASK_RE, (_, code) => String.fromCharCode(Number(code)));
+}
+/** Flattens inline content to plain text — for titles, alt text, and outline labels. */
+function inlineText(nodes) {
+	return nodes.map((node) => {
+		switch (node.type) {
+			case "text":
+			case "code": return node.value;
+			case "strong":
+			case "em":
+			case "link": return inlineText(node.children);
+			case "image": return node.alt;
+			case "break": return " ";
+			default: return "";
+		}
+	}).join("").replace(/\s+/g, " ").trim();
+}
+//#endregion
+//#region src/import/to-tsx.ts
+/** JSX text is written literally; only these characters have to be escaped. */
+function jsxText(text) {
+	return text.replace(/[{}<>]/g, (char) => `{'${char}'}`);
+}
+function jsString(value) {
+	return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n")}'`;
+}
+function attr(value) {
+	return `"${value.replace(/"/g, "&quot;")}"`;
+}
+function collectImageSources(blocks) {
+	const out = [];
+	const walkInline = (nodes) => {
+		for (const node of nodes) if (node.type === "image") out.push(node.src);
+		else if (node.type === "strong" || node.type === "em" || node.type === "link") walkInline(node.children);
+	};
+	const walk = (list) => {
+		for (const block of list) switch (block.type) {
+			case "figure":
+				out.push(block.src);
+				break;
+			case "heading":
+			case "paragraph":
+				walkInline(block.children);
+				break;
+			case "quote":
+				walk(block.children);
+				break;
+			case "list":
+				for (const item of block.items) walk(item);
+				break;
+			case "table":
+				for (const cell of block.head) walkInline(cell);
+				for (const row of block.rows) for (const cell of row) walkInline(cell);
+		}
+	};
+	walk(blocks);
+	return out;
+}
+function imageSrc(src, images) {
+	const known = images?.get(src);
+	return known ? `{${known.ident}}` : attr(src);
+}
+function renderInline(nodes, images) {
+	return nodes.map((node) => {
+		switch (node.type) {
+			case "text": return jsxText(node.value);
+			case "strong": return `<strong>${renderInline(node.children, images)}</strong>`;
+			case "em": return `<em>${renderInline(node.children, images)}</em>`;
+			case "code": return `<code style={codeInline}>${jsxText(node.value)}</code>`;
+			case "link": return `<a href=${attr(node.href)} style={link}>${renderInline(node.children, images)}</a>`;
+			case "image": return `<img src=${imageSrc(node.src, images)} alt=${attr(node.alt)} style={inlineImg} />`;
+			case "break": return "<br />";
+			default: return "";
+		}
+	}).join("");
+}
+const HEADING_STYLE = {
+	1: "h1",
+	2: "h2",
+	3: "h3",
+	4: "h4"
+};
+function alignStyle(align) {
+	return align && align !== "left" ? ` align={${jsString(align)}}` : "";
+}
+function renderBlock(block, images, indent) {
+	const pad = indent;
+	switch (block.type) {
+		case "heading": {
+			const level = Math.min(block.level, 4);
+			const tag = level >= 4 ? "h4" : `h${level}`;
+			return `${pad}<${tag} style={${HEADING_STYLE[level] ?? "h3"}}>${renderInline(block.children, images)}</${tag}>`;
+		}
+		case "paragraph": return `${pad}<p style={p}>${renderInline(block.children, images)}</p>`;
+		case "hr": return `${pad}<hr style={rule} />`;
+		case "code": return `${pad}<pre style={pre}>{${jsString(block.value)}}</pre>`;
+		case "quote": return [
+			`${pad}<blockquote style={quote}>`,
+			...block.children.map((child) => renderBlock(child, images, `${pad}  `)),
+			`${pad}</blockquote>`
+		].join("\n");
+		case "figure": {
+			const caption = block.alt ? `\n${pad}  <figcaption style={caption}>${jsxText(block.alt)}</figcaption>` : "";
+			return [
+				`${pad}<figure style={figure}>`,
+				`${pad}  <img src=${imageSrc(block.src, images)} alt=${attr(block.alt)} style={img} />${caption}`,
+				`${pad}</figure>`
+			].join("\n");
+		}
+		case "list": {
+			const tag = block.ordered ? "ol" : "ul";
+			const startAttr = block.ordered && block.start !== 1 ? ` start={${block.start}}` : "";
+			const items = block.items.map((item) => {
+				const inner = item.map((child, index) => child.type === "paragraph" && index === 0 ? `${renderInline(child.children, images)}` : `\n${renderBlock(child, images, `${pad}    `)}`).join("");
+				return `${pad}  <li style={li}>${inner.startsWith("\n") ? `${inner}\n${pad}  ` : inner}</li>`;
+			});
+			return [
+				`${pad}<${tag} style={${tag}}${startAttr}>`,
+				...items,
+				`${pad}</${tag}>`
+			].join("\n");
+		}
+		case "table": {
+			const head = block.head.map((cell, i) => `${pad}      <Th${alignStyle(block.align[i] ?? null)}>${renderInline(cell, images)}</Th>`).join("\n");
+			const rows = block.rows.map((row) => [
+				`${pad}    <tr>`,
+				...row.map((cell, i) => `${pad}      <Td${alignStyle(block.align[i] ?? null)}>${renderInline(cell, images)}</Td>`),
+				`${pad}    </tr>`
+			].join("\n")).join("\n");
+			return [
+				`${pad}<table style={table}>`,
+				`${pad}  <thead>`,
+				`${pad}    <tr>`,
+				head,
+				`${pad}    </tr>`,
+				`${pad}  </thead>`,
+				`${pad}  <tbody>`,
+				rows,
+				`${pad}  </tbody>`,
+				`${pad}</table>`
+			].join("\n");
+		}
+	}
+}
+function titleFrom(parsed, opts) {
+	if (opts.title) return opts.title;
+	if (parsed.frontmatter.title) return parsed.frontmatter.title;
+	const heading = parsed.blocks.find((block) => block.type === "heading" && block.level === 1);
+	if (heading && heading.type === "heading") return inlineText(heading.children);
+	return opts.docId.replace(/-/g, " ").replace(/^\w/, (c) => c.toUpperCase());
+}
+const STYLES = `const page = {
+  width: '100%',
+  height: '100%',
+  boxSizing: 'border-box' as const,
+  padding: 'var(--od-margin)',
+  background: 'var(--od-bg)',
+  color: 'var(--od-text)',
+  fontFamily: 'var(--od-font-body)',
+  fontSize: 'var(--od-size-body)',
+  lineHeight: 'var(--od-leading)',
+  position: 'relative' as const,
+};
+
+const h1 = {
+  fontFamily: 'var(--od-font-heading)',
+  fontSize: 'var(--od-size-h1)',
+  lineHeight: 1.2,
+  fontWeight: 650,
+  margin: '0 0 18px',
+};
+
+const h2 = { ...h1, fontSize: 'var(--od-size-h2)', margin: '26px 0 12px' };
+const h3 = { ...h1, fontSize: 'var(--od-size-h3)', fontWeight: 600, margin: '20px 0 8px' };
+const h4 = { ...h3, fontSize: 'var(--od-size-body)', margin: '16px 0 6px' };
+const p = { margin: '0 0 12px' };
+// The viewer's CSS reset strips list markers, so both are set back explicitly.
+const ul = { margin: '0 0 12px', paddingLeft: 22, listStyle: 'disc outside' };
+const ol = { ...ul, listStyle: 'decimal outside' };
+const li = { margin: '0 0 5px' };
+const link = { color: 'var(--od-accent)', textDecoration: 'none' };
+const rule = { border: 0, borderTop: '1px solid var(--od-rule)', margin: '20px 0' };
+
+const codeInline = {
+  fontFamily: 'var(--od-font-mono)',
+  fontSize: '0.92em',
+  background: 'var(--od-rule)',
+  borderRadius: 3,
+  padding: '1px 4px',
+};
+
+const pre = {
+  fontFamily: 'var(--od-font-mono)',
+  fontSize: 11,
+  lineHeight: 1.5,
+  background: 'var(--od-rule)',
+  borderRadius: 'var(--od-radius)',
+  padding: '10px 12px',
+  margin: '0 0 14px',
+  whiteSpace: 'pre-wrap' as const,
+  overflowWrap: 'anywhere' as const,
+};
+
+const quote = {
+  margin: '0 0 14px',
+  padding: '2px 0 2px 14px',
+  borderLeft: '2px solid var(--od-accent)',
+  color: 'var(--od-muted)',
+};
+
+const table = {
+  width: '100%',
+  borderCollapse: 'collapse' as const,
+  tableLayout: 'fixed' as const,
+  margin: '0 0 16px',
+};
+
+const figure = { margin: '0 0 16px' };
+const img = { width: '100%', display: 'block' as const };
+const inlineImg = { maxWidth: '100%', verticalAlign: 'middle' as const };
+const caption = { fontSize: 'var(--od-size-caption)', color: 'var(--od-muted)', margin: '6px 0 0' };
+
+const Th = ({ children, align = 'left' }: { children?: ReactNode; align?: 'left' | 'center' | 'right' }) => (
+  <th
+    style={{
+      textAlign: align,
+      fontFamily: 'var(--od-font-heading)',
+      fontSize: 11,
+      fontWeight: 600,
+      letterSpacing: '0.04em',
+      textTransform: 'uppercase',
+      color: 'var(--od-muted)',
+      borderBottom: '1px solid var(--od-rule)',
+      padding: '0 8px 6px',
+    }}
+  >
+    {children}
+  </th>
+);
+
+const Td = ({ children, align = 'left' }: { children?: ReactNode; align?: 'left' | 'center' | 'right' }) => (
+  <td
+    style={{
+      textAlign: align,
+      fontSize: 12,
+      padding: '7px 8px',
+      borderBottom: '1px solid var(--od-rule)',
+      fontVariantNumeric: align === 'right' ? 'tabular-nums' : undefined,
+    }}
+  >
+    {children}
+  </td>
+);
+
+const Footer = () => {
+  const n = useDocPageNumber();
+  const total = useDocPageCount();
+  return (
+    <div
+      style={{
+        position: 'absolute',
+        left: 'var(--od-margin)',
+        right: 'var(--od-margin)',
+        bottom: 40,
+        display: 'flex',
+        justifyContent: 'space-between',
+        fontSize: 'var(--od-size-caption)',
+        color: 'var(--od-muted)',
+      }}
+    >
+      <span>{DOC_TITLE}</span>
+      <span style={{ fontVariantNumeric: 'tabular-nums' }}>
+        {n} / {total}
+      </span>
+    </div>
+  );
+};`;
+const DESIGN = `export const design: DesignSystem = {
+  palette: {
+    bg: '#ffffff',
+    text: '#16181d',
+    muted: '#6b7280',
+    accent: '#2563eb',
+    rule: '#e5e7eb',
+  },
+  fonts: {
+    heading: '-apple-system, BlinkMacSystemFont, "Inter", system-ui, sans-serif',
+    body: '-apple-system, BlinkMacSystemFont, "Inter", system-ui, sans-serif',
+    mono: 'ui-monospace, "SF Mono", "JetBrains Mono", Menlo, monospace',
+  },
+  typeScale: { title: 44, h1: 28, h2: 20, h3: 16, body: 14, caption: 10 },
+  margin: 76,
+  leading: 1.55,
+  radius: 6,
+};`;
+/**
+* Turns parsed markdown into a document module. The output is ordinary authored
+* TSX — inline styles, real heading tags, plain JSX text — so the outline, the
+* inspector, and the design panel all work on an imported document exactly as
+* they do on a hand-written one.
+*/
+function generateDocumentSource(parsed, opts) {
+	const title = titleFrom(parsed, opts);
+	const subtitle = opts.subtitle ?? parsed.frontmatter.subtitle;
+	const author = opts.author ?? parsed.frontmatter.author;
+	const theme = opts.theme ?? parsed.frontmatter.theme;
+	const pageSize = opts.pageSize ?? parsed.frontmatter.pageSize;
+	const orientation = opts.orientation ?? parsed.frontmatter.orientation;
+	const cover = opts.cover !== false;
+	let blocks = parsed.blocks;
+	const first = blocks[0];
+	if (cover && first?.type === "heading" && first.level === 1 && inlineText(first.children) === title) blocks = blocks.slice(1);
+	const images = opts.images;
+	const imports = images ? [...images.values()] : [];
+	const head = [
+		`import type { ReactNode } from 'react';`,
+		`import {\n${[
+			"type DesignSystem",
+			"type DocEntry",
+			"type DocMeta",
+			...cover || opts.contents ? ["type DocPage"] : [],
+			...opts.contents ? ["TableOfContents"] : [],
+			"flow",
+			"useDocPageCount",
+			"useDocPageNumber"
+		].map((name) => `  ${name},`).join("\n")}\n} from 'mosage';`,
+		...imports.map((image) => `import ${image.ident} from './assets/${image.filename}';`)
+	].join("\n");
+	const styles = STYLES.replace("{DOC_TITLE}", jsxText(title));
+	const coverPage = cover ? `const Cover: DocPage = () => (
+  <div style={{ ...page, display: 'flex', flexDirection: 'column', justifyContent: 'flex-end' }}>
+${subtitle ? `    <p style={{ fontSize: 12, letterSpacing: '0.16em', textTransform: 'uppercase', color: 'var(--od-accent)', margin: 0 }}>
+      ${jsxText(subtitle)}
+    </p>\n` : ""}    <h1 style={{ ...h1, fontSize: 'var(--od-size-title)', margin: '16px 0 12px' }} data-od-outline="skip">
+      ${jsxText(title)}
+    </h1>
+${author ? `    <p style={{ color: 'var(--od-muted)', margin: 0 }}>${jsxText(author)}</p>\n` : ""}  </div>
+);` : "";
+	const contentsPage = opts.contents ? `const Contents: DocPage = () => (
+  <div style={page}>
+    <h1 style={h1} data-od-outline="skip">
+      Contents
+    </h1>
+    <TableOfContents maxLevel={2} />
+  </div>
+);` : "";
+	const body = `const Body = flow(
+  <>
+${blocks.map((block) => renderBlock(block, images, "    ")).join("\n")}
+  </>,
+  { footer: Footer },
+);`;
+	const metaFields = [
+		`  title: ${jsString(title)},`,
+		...subtitle ? [`  subtitle: ${jsString(subtitle)},`] : [],
+		...author ? [`  author: ${jsString(author)},`] : [],
+		...pageSize ? [`  pageSize: ${jsString(pageSize)},`] : [],
+		...orientation ? [`  orientation: ${jsString(orientation)},`] : [],
+		...theme ? [`  theme: ${jsString(theme)},`] : [],
+		`  createdAt: ${jsString(opts.createdAt)},`
+	];
+	const entries = [
+		...cover ? ["Cover"] : [],
+		...opts.contents ? ["Contents"] : [],
+		"Body"
+	];
+	return {
+		source: [
+			head,
+			"",
+			DESIGN,
+			"",
+			styles,
+			"",
+			...coverPage ? [coverPage, ""] : [],
+			...contentsPage ? [contentsPage, ""] : [],
+			body,
+			"",
+			`export const meta: DocMeta = {\n${metaFields.join("\n")}\n};`,
+			`export default [${entries.join(", ")}] satisfies DocEntry[];`,
+			""
+		].join("\n"),
+		title,
+		blockCount: blocks.length
+	};
+}
+//#endregion
+//#region src/ops/import.ts
+const REMOTE_RE = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+function slugify(value, fallback = "document") {
+	const slug = value.normalize("NFKD").toLowerCase().replace(/['"]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+	return DOC_ID_RE.test(slug) ? slug : fallback;
+}
+function uniqueId(base, taken) {
+	if (!taken.has(base)) return base;
+	for (let n = 2; n < 1e3; n++) {
+		const candidate = `${base}-${n}`;
+		if (!taken.has(candidate)) return candidate;
+	}
+	throw new OpsError(409, `could not find a free id for ${base}`);
+}
+function identFor(index) {
+	return `figure${index + 1}`;
+}
+/**
+* Reads markdown and writes a real MoSage document: `flow()` body, inline
+* styles, a cover, and any local images copied into the document's own assets
+* folder. Nothing about the result is special-cased — it is the same shape an
+* agent would have written by hand, and every editing surface works on it.
+*/
+async function importMarkdown(ctx, opts) {
+	const sourceFile = opts.file ? path.resolve(ctx.userCwd, opts.file) : null;
+	if (sourceFile && !sourceFile.startsWith(ctx.userCwd + path.sep)) throw new OpsError(400, `file must sit inside the workspace: ${opts.file}`);
+	let markdown = opts.markdown;
+	if (markdown === void 0) {
+		if (!sourceFile) throw new OpsError(400, "pass either `markdown` or `file`");
+		try {
+			markdown = await fs.readFile(sourceFile, "utf8");
+		} catch {
+			throw new OpsError(404, `file not found: ${opts.file}`);
+		}
+	}
+	if (markdown.trim() === "") throw new OpsError(422, "the markdown is empty");
+	const parsed = parseMarkdown(markdown);
+	const pageSize = opts.pageSize ?? parsed.frontmatter.pageSize;
+	if (pageSize !== void 0 && !isPageSizeName(pageSize)) throw new OpsError(422, `unsupported pageSize \`${pageSize}\` — use ${PAGE_SIZE_NAMES.join(", ")}`);
+	const orientation = opts.orientation ?? parsed.frontmatter.orientation;
+	if (orientation !== void 0 && !isOrientation(orientation)) throw new OpsError(422, `unsupported orientation \`${orientation}\` — use ${ORIENTATIONS.join(", ")}`);
+	const fallbackName = sourceFile ? path.basename(sourceFile).replace(/\.mdx?$/i, "") : "document";
+	const requestedId = opts.docId ?? slugify(opts.title ?? parsed.frontmatter.title ?? fallbackName);
+	if (opts.docId && !DOC_ID_RE.test(opts.docId)) throw new OpsError(400, `invalid document id: ${opts.docId}`);
+	const docId = opts.docId ?? uniqueId(requestedId, new Set(await listDocIds(ctx)));
+	const baseDir = sourceFile ? path.dirname(sourceFile) : ctx.userCwd;
+	const images = /* @__PURE__ */ new Map();
+	const missing = [];
+	const staged = [];
+	const usedNames = /* @__PURE__ */ new Set();
+	for (const src of new Set(collectImageSources(parsed.blocks))) {
+		if (REMOTE_RE.test(src)) continue;
+		const from = path.resolve(baseDir, src.split(/[?#]/)[0]);
+		if (!from.startsWith(ctx.userCwd + path.sep) || !existsSync(from)) {
+			missing.push(src);
+			continue;
+		}
+		const safe = validateAssetName(path.basename(from));
+		if (!safe) {
+			missing.push(src);
+			continue;
+		}
+		const filename = usedNames.has(safe) ? `${images.size + 1}-${safe}` : safe;
+		usedNames.add(filename);
+		images.set(src, {
+			source: src,
+			ident: identFor(images.size),
+			filename
+		});
+		staged.push({
+			from,
+			filename
+		});
+	}
+	const generated = generateDocumentSource(parsed, {
+		docId,
+		...opts.title !== void 0 ? { title: opts.title } : {},
+		...opts.subtitle !== void 0 ? { subtitle: opts.subtitle } : {},
+		...opts.author !== void 0 ? { author: opts.author } : {},
+		...opts.theme !== void 0 ? { theme: opts.theme } : {},
+		...opts.pageSize !== void 0 ? { pageSize: opts.pageSize } : {},
+		...opts.orientation !== void 0 ? { orientation: opts.orientation } : {},
+		...opts.cover !== void 0 ? { cover: opts.cover } : {},
+		...opts.contents !== void 0 ? { contents: opts.contents } : {},
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		images
+	});
+	const created = await createDocument(ctx, docId, generated.source);
+	if (staged.length > 0) {
+		const assetsDir = path.join(ctx.docsRoot, docId, "assets");
+		await fs.mkdir(assetsDir, { recursive: true });
+		for (const { from, filename } of staged) await fs.copyFile(from, path.join(assetsDir, filename));
+	}
+	return {
+		id: created.id,
+		entry: created.entry,
+		title: generated.title,
+		blocks: generated.blockCount,
+		assets: staged.map((asset) => asset.filename),
+		missingAssets: missing
+	};
+}
+//#endregion
+//#region src/render/session.ts
+var RenderUnavailableError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "RenderUnavailableError";
+	}
+};
+const INSTALL_HINT = "Headless rendering needs Playwright. Install it in this workspace:\n  pnpm add -D playwright && pnpm exec playwright install chromium";
+async function loadPlaywright() {
+	try {
+		return await import("playwright");
+	} catch {
+		throw new RenderUnavailableError(INSTALL_HINT);
+	}
+}
+const DEFAULT_TIMEOUT = 6e4;
+const PRINT_PAGE_SELECTOR = "#od-print-root .od-print-page";
+async function bootServer(userCwd) {
+	const base = await createViteConfig({
+		userCwd,
+		headless: true
+	});
+	const config = mergeConfig(base, {
+		logLevel: "silent",
+		server: {
+			port: 0,
+			strictPort: false,
+			open: false
+		}
+	});
+	const server = await createServer(config);
+	await server.listen();
+	const origin = server.resolvedUrls?.local?.[0]?.replace(/\/$/, "");
+	if (!origin) {
+		await server.close();
+		throw new Error("Could not determine the dev server URL");
+	}
+	return {
+		server,
+		origin
+	};
+}
+async function createRenderSession(opts) {
+	const { chromium } = await loadPlaywright();
+	const timeout = opts.timeoutMs ?? DEFAULT_TIMEOUT;
+	let server = null;
+	let origin = opts.origin?.replace(/\/$/, "") ?? "";
+	if (!origin) {
+		const booted = await bootServer(opts.userCwd);
+		server = booted.server;
+		origin = booted.origin;
+	}
+	let browser;
+	try {
+		browser = await chromium.launch({ headless: true });
+	} catch (err) {
+		await server?.close();
+		throw new RenderUnavailableError(`${INSTALL_HINT}\n\nChromium failed to launch: ${err.message}`);
+	}
+	return {
+		origin,
+		async open(docId) {
+			const page = await browser.newPage({
+				viewport: {
+					width: 1280,
+					height: 1024
+				},
+				...opts.deviceScaleFactor !== void 0 ? { deviceScaleFactor: opts.deviceScaleFactor } : {}
+			});
+			const errors = [];
+			page.on("pageerror", (err) => errors.push(String(err?.message ?? err)));
+			await page.goto(`${origin}/d/${encodeURIComponent(docId)}`, {
+				waitUntil: "load",
+				timeout
+			});
+			try {
+				await page.waitForFunction("globalThis.__mosage ? globalThis.__mosage.status().ready : false", void 0, { timeout });
+			} catch {
+				await page.close();
+				const detail = errors.length ? `\n${errors.join("\n")}` : "";
+				throw new Error(`Document "${docId}" never finished rendering.${detail}`);
+			}
+			const status = await page.evaluate("globalThis.__mosage.status()");
+			return {
+				status,
+				diagnose: () => page.evaluate("globalThis.__mosage.diagnose()"),
+				async pdf() {
+					await page.evaluate("globalThis.__mosage.preparePrint()");
+					try {
+						return await page.pdf({
+							printBackground: true,
+							preferCSSPageSize: true
+						});
+					} finally {
+						await page.evaluate("globalThis.__mosage.releasePrint()");
+					}
+				},
+				async screenshot(pageNumber) {
+					if (pageNumber < 1 || pageNumber > status.pageCount) throw new Error(`page ${pageNumber} is out of range — "${docId}" has ${status.pageCount}`);
+					await page.evaluate("globalThis.__mosage.preparePrint()");
+					await page.emulateMedia({ media: "print" });
+					try {
+						const sheet = await page.$(`${PRINT_PAGE_SELECTOR}:nth-child(${pageNumber})`);
+						if (!sheet) throw new Error(`page ${pageNumber} did not render`);
+						return await sheet.screenshot({ type: "png" });
+					} finally {
+						await page.emulateMedia({ media: null });
+						await page.evaluate("globalThis.__mosage.releasePrint()");
+					}
+				},
+				html: () => page.evaluate("globalThis.__mosage.htmlBundle()"),
+				docx: () => page.evaluate("globalThis.__mosage.docxBundle()"),
+				close: () => page.close()
+			};
+		},
+		async close() {
+			await browser.close();
+			await server?.close();
+		}
+	};
+}
+//#endregion
+//#region src/ops/layout.ts
+/**
+* Chromium and a Vite server are expensive to start, and an agent checking its
+* work calls these back to back. One session is kept warm and closed once
+* nobody has asked for a while.
+*/
+const IDLE_MS = 12e4;
+let shared = null;
+let pending = null;
+let idleTimer = null;
+let leases = 0;
+function armIdleClose() {
+	if (idleTimer) clearTimeout(idleTimer);
+	idleTimer = setTimeout(() => {
+		if (leases > 0) return;
+		const current = shared;
+		shared = null;
+		idleTimer = null;
+		current?.session.close().catch(() => {});
+	}, IDLE_MS);
+	idleTimer.unref?.();
+}
+async function acquire(ctx) {
+	if (shared && shared.origin === ctx.serverOrigin) return shared.session;
+	if (!pending) {
+		const origin = ctx.serverOrigin;
+		pending = createRenderSession({
+			userCwd: ctx.userCwd,
+			origin,
+			deviceScaleFactor: 2
+		}).then((session) => {
+			shared = {
+				session,
+				origin
+			};
+			return session;
+		}).finally(() => {
+			pending = null;
+		});
+	}
+	return pending;
+}
+async function withDoc(ctx, docId, fn) {
+	if (!resolveEntry(ctx, docId)) throw new OpsError(404, `document not found: ${docId}`);
+	let session;
+	try {
+		session = await acquire(ctx);
+	} catch (err) {
+		if (err instanceof RenderUnavailableError) throw new OpsError(501, err.message);
+		throw new OpsError(500, err.message);
+	}
+	leases++;
+	let renderer = null;
+	try {
+		renderer = await session.open(docId);
+		return await fn(renderer);
+	} catch (err) {
+		if (err instanceof OpsError) throw err;
+		throw new OpsError(422, err.message);
+	} finally {
+		await renderer?.close().catch(() => {});
+		leases--;
+		armIdleClose();
+	}
+}
+/** Closes the warm browser. Call before the process exits so nothing lingers. */
+async function closeRenderSession() {
+	if (idleTimer) clearTimeout(idleTimer);
+	idleTimer = null;
+	const current = shared;
+	shared = null;
+	await current?.session.close().catch(() => {});
+}
+/**
+* Renders the document headlessly at true page size and reports what is wrong
+* with the layout — the part of a document an agent writing React cannot see.
+*/
+async function checkLayout(ctx, docId) {
+	return withDoc(ctx, docId, async (renderer) => {
+		const report = await renderer.diagnose();
+		return {
+			docId: report.docId || docId,
+			title: report.title,
+			pageCount: report.pageCount,
+			errors: report.findings.filter((f) => f.severity === "error").length,
+			warnings: report.findings.filter((f) => f.severity === "warn").length,
+			findings: report.findings
+		};
+	});
+}
+function resolveOutDir(ctx, outDir) {
+	const resolved = path.resolve(ctx.userCwd, outDir);
+	if (resolved !== ctx.userCwd && !resolved.startsWith(ctx.userCwd + path.sep)) throw new OpsError(400, `outDir must stay inside the workspace: ${outDir}`);
+	return resolved;
+}
+async function exportDocument(ctx, docId, opts = {}) {
+	const format = opts.format ?? "pdf";
+	const dir = resolveOutDir(ctx, opts.outDir ?? "out");
+	return withDoc(ctx, docId, async (renderer) => {
+		await fs.mkdir(dir, { recursive: true });
+		const written = [];
+		const write = async (name, bytes) => {
+			const file = path.join(dir, name);
+			await fs.writeFile(file, bytes);
+			written.push(path.relative(ctx.userCwd, file));
+		};
+		if (format === "pdf") await write(`${docId}.pdf`, await renderer.pdf());
+		else if (format === "html" || format === "docx") {
+			const bundle = await renderer[format]();
+			if (!bundle) throw new OpsError(422, `document has no pages: ${docId}`);
+			await write(bundle.filename, Buffer.from(bundle.base64, "base64"));
+		} else {
+			const width = String(renderer.status.pageCount).length;
+			for (let page = 1; page <= renderer.status.pageCount; page++) await write(`${docId}-${String(page).padStart(width, "0")}.png`, await renderer.screenshot(page));
+		}
+		return {
+			docId,
+			format,
+			pageCount: renderer.status.pageCount,
+			files: written
+		};
+	});
+}
+//#endregion
+//#region src/cli/context.ts
+/** The same context the dev API runs on, for commands that call `ops/`. */
+async function cliContext(userCwd = process.cwd()) {
+	const config = await loadUserConfig(userCwd);
+	return makeContext({
+		userCwd,
+		docsDir: config.docsDir ?? "docs",
+		assetsDir: config.assetsDir ?? "assets",
+		coreVersion: await readCoreVersion()
+	});
+}
+//#endregion
+export { importMarkdown as a, exportDocument as i, checkLayout as n, closeRenderSession as r, cliContext as t };