openwriter 0.37.0 → 0.38.0

package/dist/server/manuscript/load.js

@@ -0,0 +1,65 @@
+/**
+ * Manifest loaders — shared by the HTTP routes (preview/export) and the MCP
+ * tools (compile_manuscript / export_manuscript). Resolving a manuscript doc by
+ * stable docId, listing manuscripts in the profile, and the export filename
+ * helper all live here so both surfaces read identical data.
+ *
+ * adr: adr/manuscript-engine.md
+ */
+import { readdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+import matter from 'gray-matter';
+import { filenameByDocId } from '../documents.js';
+import { readFrontmatter } from '../backlinks.js';
+import { getDataDir } from '../helpers.js';
+/** Every manuscript doc in the active profile (content_type === 'manuscript',
+ *  not archived). Powers the always-on Manuscripts launcher + MCP listing. */
+export function listManuscripts() {
+    const dir = getDataDir();
+    const out = [];
+    for (const f of readdirSync(dir)) {
+        if (!f.endsWith('.md') || f.startsWith('_'))
+            continue;
+        try {
+            const { data } = matter(readFileSync(join(dir, f), 'utf-8'));
+            if (data.content_type === 'manuscript' && !data.archivedAt) {
+                out.push({ docId: data.docId, title: data.title || f.replace(/\.md$/, ''), filename: f });
+            }
+        }
+        catch { /* skip unreadable */ }
+    }
+    return out.sort((a, b) => a.title.localeCompare(b.title));
+}
+/** Load a manifest doc by docId: its body (ordered pointer list) + render meta.
+ *  Meta comes from the doc's frontmatter (round-trip-safe): the book title
+ *  defaults to the doc title minus a trailing "— Manuscript"; author/output/trim
+ *  come from manuscriptContext (set via the Settings panel, later). */
+export function loadManifest(docId) {
+    if (!docId)
+        return null;
+    const filename = filenameByDocId(docId);
+    if (!filename)
+        return null;
+    const fm = readFrontmatter(filename);
+    if (!fm)
+        return null;
+    const ctx = (fm.data.manuscriptContext || {});
+    const title = (typeof ctx.title === 'string' && ctx.title) ||
+        String(fm.data.title || '').replace(/\s*[—–-]\s*manuscript\s*$/i, '') ||
+        'Untitled';
+    return {
+        body: fm.content,
+        meta: {
+            title,
+            author: typeof ctx.author === 'string' ? ctx.author : undefined,
+            output: typeof ctx.output === 'string' ? ctx.output : undefined,
+            trim: typeof ctx.trim === 'string' ? ctx.trim : undefined,
+            // Render-time book style; defaults to 'spaced' downstream in bookCss().
+            paragraphStyle: ctx.paragraphStyle === 'indented' ? 'indented' : 'spaced',
+        },
+    };
+}
+/** Filesystem-safe filename stem from a book title. */
+export function safeName(title) {
+    return (title || 'manuscript').replace(/[<>:"/\\|?*]/g, '_').replace(/\s+/g, '_').slice(0, 100);
+}

package/dist/server/manuscript/parse.js

@@ -0,0 +1,59 @@
+/**
+ * Manuscript manifest parser — pure.
+ *
+ * The engine knows nothing about books. A "manuscript" is just a doc whose body
+ * is an ordered set of `doc:` pointers grouped under markdown headings, plus an
+ * optional `{{toc}}` directive. This module turns that body into a structured
+ * model the assembler walks. All book meaning (beats, welds, chapters-as-idea)
+ * is /book-writer skill convention, never here — here it is only docs + pointers.
+ *
+ * IMPORTANT — parse what the editor actually STORES, not idealized markdown.
+ * OpenWriter round-trips the manifest body through TipTap, which:
+ *   - wraps a `doc:` href in angle brackets → `[text](<doc:ID>)`
+ *   - collapses consecutive non-blank lines into one paragraph, so several
+ *     pointers end up on a single line
+ * So pointers are extracted GLOBALLY within each heading's section (any number
+ * per line, angle-bracket tolerant), never anchored one-per-line. Title/author
+ * come from the doc's frontmatter (round-trip-safe), not a body block.
+ *
+ * adr: adr/manuscript-engine.md
+ */
+const HEADING_RE = /^(#{1,6})\s+(.*\S)\s*$/;
+// A pointer (`[text](doc:ID)`) OR the `{{toc}}` directive, matched anywhere.
+// Tolerates the editor's angle-bracketed href and an optional #node/?query suffix.
+const TOKEN_RE = /\[([^\]]+)\]\(\s*<?doc:([0-9a-f]{8})[^)>]*>?\s*\)|\{\{\s*toc\s*\}\}/gi;
+// A legacy `::: meta … :::` block — stripped so it never renders as stray prose.
+const META_BLOCK_RE = /:::\s*meta[\s\S]*?:::/gi;
+export function parseManifest(body) {
+    const cleaned = body.replace(META_BLOCK_RE, '');
+    const lines = cleaned.split('\n');
+    // Headings are reliably block-level (their own line), so they define section
+    // boundaries; everything between two headings is that section's raw text.
+    const raw = [
+        { heading: null, level: 0, text: '' },
+    ];
+    for (const line of lines) {
+        const h = line.match(HEADING_RE);
+        if (h)
+            raw.push({ heading: h[2].trim(), level: h[1].length, text: '' });
+        else
+            raw[raw.length - 1].text += line + '\n';
+    }
+    const sections = [];
+    for (const s of raw) {
+        const items = [];
+        TOKEN_RE.lastIndex = 0;
+        let m;
+        while ((m = TOKEN_RE.exec(s.text)) !== null) {
+            if (m[2])
+                items.push({ kind: 'doc', text: m[1].trim(), docId: m[2].toLowerCase() });
+            else
+                items.push({ kind: 'toc' });
+        }
+        if (s.heading !== null || items.length > 0) {
+            sections.push({ heading: s.heading, level: s.level, items });
+        }
+    }
+    // Meta is supplied by the caller from frontmatter (see compileManuscript).
+    return { meta: {}, sections, warnings: [] };
+}

package/dist/server/manuscript/render/css.js

@@ -0,0 +1,41 @@
+function paragraphRules(style) {
+    if (style === 'indented') {
+        // Indented = first-line indent on EVERY paragraph (including the first) AND
+        // keep the inter-paragraph gap. Both cues, always separated — never a wall.
+        return `p { margin: 0 0 1.1em; text-indent: 1.5em; }
+blockquote p, li p { text-indent: 0; }`;
+    }
+    // 'spaced' — the default: gap between paragraphs, no indent anywhere.
+    return `p { margin: 0 0 1.1em; text-indent: 0; }`;
+}
+export function bookCss(paragraphStyle = 'spaced') {
+    return `
+body {
+  font-family: Georgia, 'Times New Roman', serif;
+  font-size: 1em;
+  line-height: 1.6;
+  color: #1a1a1a;
+}
+/* Headings never inherit/carry a text-indent — that belongs to body prose only. */
+h1, h2, h3, h4, h5, h6 { font-weight: 600; line-height: 1.25; text-indent: 0; }
+h1 { font-size: 1.7em; margin: 0 0 1em; page-break-before: always; break-before: page; }
+h2 { font-size: 1.35em; margin: 1.6em 0 0.5em; }
+h3 { font-size: 1.15em; margin: 1.3em 0 0.4em; }
+${paragraphRules(paragraphStyle)}
+blockquote p, li p { margin-bottom: 0.5em; }
+blockquote { margin: 1em 1.6em; font-style: italic; color: #444; }
+ul, ol { margin: 1em 0; padding-left: 1.6em; }
+li { margin: 0.2em 0; }
+hr { border: none; border-top: 1px solid #bbb; width: 28%; margin: 2em auto; }
+a { color: inherit; text-decoration: none; }
+img { max-width: 100%; height: auto; }
+code { font-family: Consolas, Menlo, monospace; font-size: 0.9em; }
+pre { background: #f5f5f5; padding: 0.8em 1em; overflow-x: auto; font-size: 0.85em; }
+sup.footnote-ref { font-size: 0.7em; }
+.footnotes {
+  font-size: 0.85em; color: #444;
+  border-top: 1px solid #ccc; margin-top: 2.5em; padding-top: 0.5em;
+}
+.footnotes ol { padding-left: 1.4em; }
+`;
+}

package/dist/server/manuscript/render/docx.js

@@ -0,0 +1,10 @@
+import { renderBodyHtml } from './md.js';
+export async function renderDocx(markdown, meta) {
+    const bodyHtml = renderBodyHtml(markdown, false);
+    const { default: HtmlToDocx } = await import('@turbodocx/html-to-docx');
+    const docx = await HtmlToDocx(bodyHtml, undefined, {
+        title: meta.title || 'Untitled',
+        margins: { top: 1440, right: 1440, bottom: 1440, left: 1440 },
+    });
+    return Buffer.from(docx);
+}

package/dist/server/manuscript/render/epub.js

@@ -0,0 +1,156 @@
+/**
+ * EPUB3 render — pure-JS, no external binary (OpenWriter ships via npx and can't
+ * assume pandoc/calibre are installed). The master markdown is split by `# `
+ * chapter into per-chapter XHTML documents and packaged into a valid EPUB3
+ * container with jszip. Per-chapter splitting means footnotes resolve at the end
+ * of each chapter (standard ebook placement); labels were already namespaced at
+ * assembly so nothing collides. adr: adr/manuscript-engine.md
+ */
+import JSZip from 'jszip';
+import { renderBodyHtml } from './md.js';
+import { bookCss } from './css.js';
+function escapeXml(s) {
+    return s
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+/** Split master markdown into chapters at top-level `# ` headings (fence-aware). */
+function splitChapters(markdown) {
+    const lines = markdown.split('\n');
+    const chunks = [];
+    let cur = null;
+    let fence = null;
+    const firstHeading = (ls) => {
+        for (const l of ls) {
+            const m = l.match(/^#{1,6}\s+(.*\S)\s*$/);
+            if (m)
+                return m[1].trim();
+        }
+        return '';
+    };
+    for (const line of lines) {
+        const f = line.match(/^\s*(```+|~~~+)/);
+        if (f) {
+            const mark = f[1][0];
+            if (fence === null)
+                fence = mark;
+            else if (fence === mark)
+                fence = null;
+        }
+        const isChapterHeading = fence === null && /^# .+/.test(line);
+        if (isChapterHeading) {
+            if (cur)
+                chunks.push(cur);
+            cur = { title: line.replace(/^#\s+/, '').trim(), lines: [line] };
+        }
+        else {
+            if (!cur)
+                cur = { title: '', lines: [] };
+            cur.lines.push(line);
+        }
+    }
+    if (cur)
+        chunks.push(cur);
+    return chunks
+        .filter((c) => c.lines.some((l) => l.trim() !== ''))
+        .map((c) => ({ title: c.title || firstHeading(c.lines) || 'Front Matter', md: c.lines.join('\n') }));
+}
+function chapterXhtml(title, bodyHtml) {
+    return `<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml" xmlns:epub="http://www.idpf.org/2007/ops" lang="en">
+<head>
+<meta charset="utf-8"/>
+<title>${escapeXml(title)}</title>
+<link rel="stylesheet" type="text/css" href="style.css"/>
+</head>
+<body>
+${bodyHtml}
+</body>
+</html>`;
+}
+export async function renderEpub(markdown, meta) {
+    const title = meta.title || 'Untitled';
+    const author = meta.author || '';
+    const lang = meta.language || 'en';
+    const modified = new Date().toISOString().replace(/\.\d{3}Z$/, 'Z');
+    const bookId = 'urn:uuid:' + deterministicUuid(title + '|' + author);
+    const chapters = splitChapters(markdown).map((c, i) => {
+        const n = String(i + 1).padStart(3, '0');
+        return {
+            id: `ch${n}`,
+            href: `ch${n}.xhtml`,
+            title: c.title,
+            xhtml: chapterXhtml(c.title, renderBodyHtml(c.md, true)),
+        };
+    });
+    const manifestItems = [
+        '<item id="nav" href="nav.xhtml" media-type="application/xhtml+xml" properties="nav"/>',
+        '<item id="css" href="style.css" media-type="text/css"/>',
+        ...chapters.map((c) => `<item id="${c.id}" href="${c.href}" media-type="application/xhtml+xml"/>`),
+    ].join('\n    ');
+    const spineItems = chapters.map((c) => `<itemref idref="${c.id}"/>`).join('\n    ');
+    const opf = `<?xml version="1.0" encoding="utf-8"?>
+<package xmlns="http://www.idpf.org/2007/opf" version="3.0" unique-identifier="bookid">
+  <metadata xmlns:dc="http://purl.org/dc/elements/1.1/">
+    <dc:identifier id="bookid">${escapeXml(bookId)}</dc:identifier>
+    <dc:title>${escapeXml(title)}</dc:title>
+    <dc:language>${escapeXml(lang)}</dc:language>
+    ${author ? `<dc:creator>${escapeXml(author)}</dc:creator>` : ''}
+    <meta property="dcterms:modified">${modified}</meta>
+  </metadata>
+  <manifest>
+    ${manifestItems}
+  </manifest>
+  <spine>
+    ${spineItems}
+  </spine>
+</package>`;
+    const navList = chapters.map((c) => `<li><a href="${c.href}">${escapeXml(c.title)}</a></li>`).join('\n      ');
+    const nav = `<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml" xmlns:epub="http://www.idpf.org/2007/ops" lang="en">
+<head><meta charset="utf-8"/><title>Contents</title></head>
+<body>
+<nav epub:type="toc" id="toc">
+  <h1>Contents</h1>
+  <ol>
+      ${navList}
+  </ol>
+</nav>
+</body>
+</html>`;
+    const containerXml = `<?xml version="1.0" encoding="utf-8"?>
+<container version="1.0" xmlns="urn:oasis:names:tc:opendocument:xmlns:container">
+  <rootfiles>
+    <rootfile full-path="OEBPS/content.opf" media-type="application/oebps-package+xml"/>
+  </rootfiles>
+</container>`;
+    const zip = new JSZip();
+    // EPUB requires `mimetype` to be the first entry and stored (uncompressed).
+    zip.file('mimetype', 'application/epub+zip', { compression: 'STORE' });
+    zip.file('META-INF/container.xml', containerXml);
+    zip.file('OEBPS/content.opf', opf);
+    zip.file('OEBPS/nav.xhtml', nav);
+    zip.file('OEBPS/style.css', bookCss(meta.paragraphStyle));
+    for (const c of chapters)
+        zip.file(`OEBPS/${c.href}`, c.xhtml);
+    return zip.generateAsync({ type: 'nodebuffer', mimeType: 'application/epub+zip', compression: 'DEFLATE' });
+}
+/** Stable uuid-shaped string from a seed (no randomness, so identical input → identical id). */
+function deterministicUuid(seed) {
+    let h = 0x811c9dc5;
+    const bytes = [];
+    for (let i = 0; i < 16; i++) {
+        for (let j = 0; j < seed.length; j++) {
+            h ^= seed.charCodeAt(j) + i * 131;
+            h = Math.imul(h, 0x01000193) >>> 0;
+        }
+        bytes.push(h & 0xff);
+    }
+    const hex = bytes.map((b) => b.toString(16).padStart(2, '0'));
+    return `${hex.slice(0, 4).join('')}-${hex.slice(4, 6).join('')}-${hex.slice(6, 8).join('')}-${hex.slice(8, 10).join('')}-${hex.slice(10, 16).join('')}`;
+}

package/dist/server/manuscript/render/html.js

@@ -0,0 +1,91 @@
+import { renderBodyHtml } from './md.js';
+import { bookCss } from './css.js';
+function escapeHtml(s) {
+    return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+/** Screen palette for the preview surface. Light = cream paper; dark reuses the
+ *  app's neutral dark tokens (never blue). Only the in-app preview uses dark. */
+function palette(mode) {
+    if (mode === 'dark') {
+        return {
+            bg: '#1a1a1a', // app --bg-primary (dark)
+            text: '#d4d2cb',
+            heading: '#f0f0f0',
+            byline: '#9b9b95',
+            blockquote: '#b3b1a8',
+            hr: '#3a3a3a',
+            pre: '#242424',
+            footnote: '#a9a79f',
+            footnoteBorder: '#3a3a3a',
+            // App scrollbar tokens (data-mode="dark") — colors-base.css.
+            scrollThumb: 'rgba(255, 255, 255, 0.15)',
+            scrollThumbHover: 'rgba(255, 255, 255, 0.25)',
+        };
+    }
+    return {
+        bg: '#faf9f6',
+        text: '#1a1a1a',
+        heading: '#1a1a1a',
+        byline: '#666',
+        blockquote: '#444',
+        hr: '#bbb',
+        pre: '#f5f5f5',
+        footnote: '#444',
+        footnoteBorder: '#ccc',
+        // App scrollbar tokens (light) — colors-base.css.
+        scrollThumb: 'rgba(0, 0, 0, 0.2)',
+        scrollThumbHover: 'rgba(0, 0, 0, 0.35)',
+    };
+}
+/** Full standalone HTML document for the whole manuscript (preview / PDF). */
+export function renderBookHtml(markdown, meta, mode = 'light') {
+    const body = renderBodyHtml(markdown, false);
+    const title = meta.title || 'Untitled';
+    const byline = meta.author ? `<p class="book-byline">${escapeHtml(meta.author)}</p>` : '';
+    const c = palette(mode);
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>${escapeHtml(title)}</title>
+<style>
+*, *::before, *::after { box-sizing: border-box; }
+html, body { margin: 0; padding: 0; }
+body { background: ${c.bg}; color: ${c.text}; }
+/* Match the app's scrollbar convention (App.css) — thin, 8px, token-colored.
+   Track is the page bg (not transparent) so the iframe element behind it never
+   shows through as a white sliver. */
+* { scrollbar-width: thin; scrollbar-color: ${c.scrollThumb} ${c.bg}; }
+::-webkit-scrollbar { width: 8px; height: 8px; }
+::-webkit-scrollbar-track { background: ${c.bg}; }
+::-webkit-scrollbar-thumb { background: ${c.scrollThumb}; border-radius: 4px; }
+::-webkit-scrollbar-thumb:hover { background: ${c.scrollThumbHover}; }
+.book-page {
+  max-width: 38em; margin: 0 auto; padding: 3em 1.5em 6em;
+}
+.book-title { text-align: center; font-size: 2em; margin: 1em 0 0.3em; page-break-before: avoid; color: ${c.heading}; }
+.book-byline { text-align: center; color: ${c.byline}; font-style: italic; margin: 0 0 3.5em; }
+/* Title page → first chapter needs real separation. The byline (when present)
+   supplies the bottom gap; with no byline the title sits right on the chapter
+   heading, so give that first heading its own top air. */
+.book-title + h1 { margin-top: 3em; }
+${bookCss(meta.paragraphStyle)}
+body { color: ${c.text}; }
+h1, h2, h3, h4, h5, h6 { color: ${c.heading}; }
+blockquote { color: ${c.blockquote}; }
+hr { border-top-color: ${c.hr}; }
+pre { background: ${c.pre}; }
+.footnotes { color: ${c.footnote}; border-top-color: ${c.footnoteBorder}; }
+.book-page h1:first-of-type { page-break-before: avoid; }
+</style>
+</head>
+<body>
+<div class="book-page">
+<h1 class="book-title">${escapeHtml(title)}</h1>
+${byline}
+${body}
+</div>
+</body>
+</html>`;
+}

package/dist/server/manuscript/render/md.js

@@ -0,0 +1,41 @@
+/**
+ * Shared markdown-it instance for manuscript rendering — matches the
+ * configuration in export-routes.ts (the single-doc export path) so manuscript
+ * output is consistent with OpenWriter's existing exports: same flavor, same
+ * footnote plugin. `xhtml` mode self-closes void elements for EPUB's XHTML.
+ *
+ * adr: adr/manuscript-engine.md
+ */
+import MarkdownIt from 'markdown-it';
+import markdownItIns from 'markdown-it-ins';
+import markdownItMark from 'markdown-it-mark';
+import markdownItSub from 'markdown-it-sub';
+import markdownItSup from 'markdown-it-sup';
+import markdownItFootnote from 'markdown-it-footnote';
+export function createMd(xhtml = false) {
+    const md = new MarkdownIt({ linkify: false, html: true, xhtmlOut: xhtml });
+    md.enable('strikethrough');
+    md.use(markdownItIns);
+    md.use(markdownItMark);
+    md.use(markdownItSub);
+    md.use(markdownItSup);
+    md.use(markdownItFootnote);
+    // Chapter anchors: every top-level heading (h1 = a chapter; beats are demoted
+    // to h2+) gets a stable sequential id `ch-N`. The assembler's {{toc}} links to
+    // these (#ch-N) and the preview's chapter tick-rail also keys off them, so the
+    // contents page and the side navigator point at the same targets.
+    md.core.ruler.push('chapter_ids', (state) => {
+        let n = 0;
+        for (const tok of state.tokens) {
+            if (tok.type === 'heading_open' && tok.tag === 'h1') {
+                n += 1;
+                tok.attrSet('id', `ch-${n}`);
+            }
+        }
+    });
+    return md;
+}
+/** Render a markdown string to an HTML fragment. */
+export function renderBodyHtml(markdown, xhtml = false) {
+    return createMd(xhtml).render(markdown);
+}

package/dist/server/manuscript/resolve.js

@@ -0,0 +1,42 @@
+/**
+ * Manuscript doc resolution — disk I/O.
+ *
+ * Maps each manifest doc-pointer (docId) to its current on-disk body. Resolution
+ * is by stable docId (rename-safe): filenameByDocId → readFrontmatter().content.
+ * The body read from disk is the canonical, ACCEPTED text — pending agent
+ * suggestions live in the `_pending/<docId>.json` sidecar, never in the .md body
+ * — so a compiled manuscript never ships an un-accepted edit. A docId resolves
+ * regardless of which workspace/container the doc lives in (location-independent),
+ * which is why a transition doc written "in some random folder" links fine.
+ *
+ * adr: adr/manuscript-engine.md
+ */
+import { filenameByDocId } from '../documents.js';
+import { readFrontmatter } from '../backlinks.js';
+export function resolveManifestDocs(manifest) {
+    const bodyMap = new Map();
+    const warnings = [];
+    for (const section of manifest.sections) {
+        for (const item of section.items) {
+            if (item.kind !== 'doc' || !item.docId)
+                continue;
+            if (bodyMap.has(item.docId))
+                continue;
+            const filename = filenameByDocId(item.docId);
+            if (!filename) {
+                warnings.push(`docId ${item.docId} not found (${item.text ?? ''})`);
+                continue;
+            }
+            const fm = readFrontmatter(filename);
+            if (!fm) {
+                warnings.push(`Could not read ${filename} for docId ${item.docId}`);
+                continue;
+            }
+            bodyMap.set(item.docId, {
+                title: fm.data.title || item.text || 'Untitled',
+                body: fm.content,
+            });
+        }
+    }
+    return { bodyMap, warnings };
+}

package/dist/server/manuscript-routes.js

@@ -0,0 +1,78 @@
+/**
+ * Manuscript routes: compile + render a manuscript doc to a file or preview.
+ *
+ *   GET /api/manuscript/preview?docId=<id>            -> book HTML (iframe source)
+ *   GET /api/manuscript/export?docId=<id>&format=epub -> epub | docx | html | md
+ *
+ * Both resolve the manifest doc by stable docId, compile it (resolve pointers +
+ * assemble), then render. Preview and export share the same compile() path, so
+ * the preview can never disagree with the exported book. adr: adr/manuscript-engine.md
+ */
+import { Router } from 'express';
+import { compileManuscript, renderBookHtml, renderEpub, renderDocx, } from './manuscript/index.js';
+import { listManuscripts, loadManifest, safeName } from './manuscript/load.js';
+export function createManuscriptRouter() {
+    const router = Router();
+    // Always-on launcher list for the right rail — every manuscript in the profile.
+    router.get('/api/manuscripts', (_req, res) => {
+        res.json({ manuscripts: listManuscripts() });
+    });
+    router.get('/api/manuscript/preview', (req, res) => {
+        const ms = loadManifest(String(req.query.docId || ''));
+        if (!ms)
+            return res.status(404).json({ error: 'manuscript doc not found' });
+        const { markdown, meta } = compileManuscript(ms.body, ms.meta);
+        // The manuscript compose view frames this preview SAME-ORIGIN. The global
+        // security gate sends X-Frame-Options: DENY + frame-ancestors 'none', which
+        // blocks the iframe entirely. Relax BOTH to same-origin for this route only —
+        // a self-contained book page, framed by the app itself, nothing external.
+        res.setHeader('X-Frame-Options', 'SAMEORIGIN');
+        res.setHeader('Content-Security-Policy', "default-src 'self'; img-src 'self' data: blob: https:; style-src 'self' 'unsafe-inline'; font-src 'self' data:; frame-ancestors 'self'");
+        res.setHeader('Content-Type', 'text/html; charset=utf-8');
+        // Screen light/dark follows the app's Appearance setting, passed by the
+        // compose view. Export (below) never does — the book ships print-light.
+        const mode = req.query.mode === 'dark' ? 'dark' : 'light';
+        res.send(renderBookHtml(markdown, meta, mode));
+    });
+    router.get('/api/manuscript/export', async (req, res) => {
+        const ms = loadManifest(String(req.query.docId || ''));
+        if (!ms)
+            return res.status(404).json({ error: 'manuscript doc not found' });
+        const format = String(req.query.format || 'epub').toLowerCase();
+        const result = compileManuscript(ms.body, ms.meta);
+        const name = safeName(result.meta.title || '');
+        try {
+            switch (format) {
+                case 'epub': {
+                    const buf = await renderEpub(result.markdown, result.meta);
+                    res.setHeader('Content-Type', 'application/epub+zip');
+                    res.setHeader('Content-Disposition', `attachment; filename="${name}.epub"`);
+                    return res.send(buf);
+                }
+                case 'docx': {
+                    const buf = await renderDocx(result.markdown, result.meta);
+                    res.setHeader('Content-Type', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document');
+                    res.setHeader('Content-Disposition', `attachment; filename="${name}.docx"`);
+                    return res.send(buf);
+                }
+                case 'html': {
+                    res.setHeader('Content-Type', 'text/html; charset=utf-8');
+                    res.setHeader('Content-Disposition', `attachment; filename="${name}.html"`);
+                    return res.send(renderBookHtml(result.markdown, result.meta));
+                }
+                case 'md': {
+                    res.setHeader('Content-Type', 'text/markdown; charset=utf-8');
+                    res.setHeader('Content-Disposition', `attachment; filename="${name}.md"`);
+                    return res.send(result.markdown);
+                }
+                default:
+                    return res.status(400).json({ error: `Unknown format: ${format}. Use epub, docx, html, or md.` });
+            }
+        }
+        catch (err) {
+            console.error('[Manuscript] export error:', err?.message);
+            return res.status(500).json({ error: 'Manuscript export failed' });
+        }
+    });
+    return router;
+}