npm - openwriter - Versions diffs - 0.37.1 → 0.38.0 - Mend

openwriter 0.37.1 → 0.38.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (22) hide show

package/dist/client/assets/{index-Dz0iuWDM.css → index-2miZWC8D.css} +1 -1
package/dist/client/assets/index-C_Zb7mUx.js +215 -0
package/dist/client/index.html +2 -2
package/dist/server/content-type-meta.js +1 -0
package/dist/server/helpers.js +2 -2
package/dist/server/index.js +3 -0
package/dist/server/logger.js +2 -2
package/dist/server/manuscript/assemble.js +128 -0
package/dist/server/manuscript/index.js +35 -0
package/dist/server/manuscript/load.js +65 -0
package/dist/server/manuscript/parse.js +59 -0
package/dist/server/manuscript/render/css.js +41 -0
package/dist/server/manuscript/render/docx.js +10 -0
package/dist/server/manuscript/render/epub.js +156 -0
package/dist/server/manuscript/render/html.js +91 -0
package/dist/server/manuscript/render/md.js +41 -0
package/dist/server/manuscript/resolve.js +42 -0
package/dist/server/manuscript-routes.js +78 -0
package/dist/server/mcp.js +78 -4
package/dist/server/state.js +1 -1
package/package.json +2 -1
package/dist/client/assets/index-BBEdpqBq.js +0 -215

package/dist/client/index.html CHANGED Viewed

@@ -10,8 +10,8 @@
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link href="https://fonts.googleapis.com/css2?family=Charter:ital,wght@0,400;0,700;1,400&family=Crimson+Pro:ital,wght@0,300;0,400;0,600;0,700;1,400&family=DM+Sans:ital,wght@0,400;0,500;0,600;0,700;1,400&family=DM+Serif+Display&family=IBM+Plex+Mono:wght@400;500;600&family=IBM+Plex+Sans:wght@400;500;600&family=Inter:wght@400;500;600;700&family=Libre+Baskerville:ital,wght@0,400;0,700;1,400&family=Literata:ital,opsz,wght@0,7..72,400;0,7..72,600;0,7..72,700;1,7..72,400&family=Newsreader:ital,opsz,wght@0,6..72,400;0,6..72,600;1,6..72,400&family=Playfair+Display:wght@400;600;700;900&family=Source+Serif+4:ital,opsz,wght@0,8..60,400;0,8..60,600;0,8..60,700;1,8..60,400&family=Space+Grotesk:wght@400;500;600;700&family=Space+Mono:wght@400;700&display=swap" rel="stylesheet" />
-    <script type="module" crossorigin src="/assets/index-BBEdpqBq.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-Dz0iuWDM.css">
+    <script type="module" crossorigin src="/assets/index-C_Zb7mUx.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-2miZWC8D.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/server/content-type-meta.js CHANGED Viewed

@@ -15,6 +15,7 @@ export function resolveTypeMeta(type, url) {
         case 'linkedin': return { content_type: 'linkedin', linkedinContext: { active: true } };
         case 'newsletter': return { content_type: 'newsletter', newsletterContext: { active: true } };
         case 'blog': return { content_type: 'blog', blogContext: { active: true } };
+        case 'manuscript': return { content_type: 'manuscript', manuscriptContext: { active: true } };
         default: return undefined;
     }
 }

package/dist/server/helpers.js CHANGED Viewed

@@ -128,9 +128,9 @@ export function canonicalizeIdentifier(id) {
  * Canonicalizes both sides of the comparison so that mixed separators,
  * drive-letter case, and symlink-resolved variants of the same file all
  * classify consistently. The pre-canonicalization version compared raw
- * strings via `startsWith`, which let `C:/Users/.../data-dir/foo.md`
+ * strings via `startsWith`, which let `C:/Users/me/data-dir/foo.md`
  * be classified as external on Windows because `getDataDir()` returns
- * `C:\Users\...\data-dir` (different separators).
+ * `C:\Users\me\data-dir` (different separators).
  *
  * adr: adr/path-canonicalization.md
  */

package/dist/server/index.js CHANGED Viewed

@@ -27,6 +27,7 @@ import { removeDocFromAllWorkspaces } from './workspaces.js';
 import { resolveDocPath, getActiveProfile, setActiveProfile, listProfiles, createProfile, deleteProfile, listTrashedProfiles, restoreProfile, saveConfig, readConfig } from './helpers.js';
 import { createImageRouter } from './image-upload.js';
 import { createExportRouter } from './export-routes.js';
+import { createManuscriptRouter } from './manuscript-routes.js';
 import { createConnectionRouter } from './connection-routes.js';
 import { createSchedulerRouter } from './scheduler-routes.js';
 import { createBillingRouter } from './billing-routes.js';
@@ -234,6 +235,8 @@ export async function startHttpServer(options = {}) {
     // if installed). SyncButton + SyncSetupModal hit /api/sync/* unchanged.
     // Mount export routes
     app.use(createExportRouter());
+    // Mount manuscript compile/render routes (book binding -> epub/docx/html/md)
+    app.use(createManuscriptRouter());
     // Mount connection CRUD + profile binding routes
     app.use(createConnectionRouter());
     // Mount scheduler proxy routes

package/dist/server/logger.js CHANGED Viewed

@@ -5,7 +5,7 @@
  *   - One JSON-per-line file at `~/.openwriter/profiles/<profile>/events.log`.
  *     One file (not per-category) so grep/jq covers everything in one place.
  *   - Levels: error < warn < info < debug < trace. Default `error` — safe
- *     for public installs. Travis's machine overrides to `trace` via
+ *     for public installs. The operator's machine overrides to `trace` via
  *     `~/.openwriter/log-config.json`.
  *   - Document text is redacted unless `includeText: true` is set in the
  *     config file. Public users never have text content land in logs.
@@ -18,7 +18,7 @@
  *     restart. The current `diagnostic.log` proved this works.
  *
  * Public users see: errors only, no text, small file, share freely for
- * bug reports without privacy concern. Travis sees: everything, with text.
+ * bug reports without privacy concern. The operator sees: everything, with text.
  *
  * adr: adr/logging-system.md
  */

package/dist/server/manuscript/assemble.js ADDED Viewed

@@ -0,0 +1,128 @@
+/** Book heading level for a manifest heading. The manifest owns the book's whole
+ *  heading hierarchy: `## chapter` → book h1, `### section` → h2, `#### ` → h3,
+ *  etc. (level − 1, clamped ≥1). `## = chapter` keeps the existing convention, so
+ *  any current `##`-only manifest renders byte-identically; deeper levels are
+ *  purely additive. A `#` and a `##` both map to h1 (clamp). */
+function bookLevel(manifestLevel) {
+    return Math.max(1, manifestLevel - 1);
+}
+export function assemble(manifest, bodyMap) {
+    const warnings = [];
+    // Chapters-only navigation: TOC + tick-rail list book-h1 headings (manifest
+    // level ≤ 2), in document order, so they align with md.ts's `#ch-N` anchors.
+    // Sub-section headers still render in the book (and the EPUB's own nav), just
+    // not in the chapter contents list.
+    const tocEntries = manifest.sections
+        .filter((s) => s.heading && bookLevel(s.level) === 1)
+        .map((s) => s.heading);
+    let ordinal = 0; // per-doc footnote namespace counter
+    const out = [];
+    for (const section of manifest.sections) {
+        // Emit EVERY manifest heading at its mapped book level — including a
+        // structural divider with no beats under it (a "Part" line, a section title
+        // between beats). The book's heading structure is whatever the manifest says.
+        if (section.heading) {
+            const lvl = bookLevel(section.level);
+            out.push(`${'#'.repeat(lvl)} ${section.heading}`, '');
+        }
+        for (const item of section.items) {
+            if (item.kind === 'toc') {
+                const toc = renderToc(tocEntries);
+                if (toc)
+                    out.push(toc, '');
+                continue;
+            }
+            const resolved = item.docId ? bodyMap.get(item.docId) : undefined;
+            if (!resolved) {
+                warnings.push(`Unresolved docId ${item.docId} (${item.text ?? ''}) — not in workspace?`);
+                out.push(`> **[unresolved: ${item.text ?? item.docId}]**`, '');
+                continue;
+            }
+            ordinal += 1;
+            let body = resolved.body.trim();
+            body = namespaceFootnotes(body, ordinal);
+            // Nest a beat's own headings just below its enclosing manifest heading:
+            // under a book-h{N} section, the beat's internal h1 becomes h{N+1}.
+            // Pre-heading / front-matter beats (no enclosing heading) keep their structure.
+            if (section.heading)
+                body = demoteHeadings(body, bookLevel(section.level));
+            out.push(body, '');
+        }
+    }
+    const markdown = out.join('\n').replace(/\n{3,}/g, '\n\n').trim() + '\n';
+    return { markdown, warnings };
+}
+function renderToc(entries) {
+    if (entries.length === 0)
+        return '';
+    // Link each entry to its chapter anchor (#ch-N). md.ts stamps the matching id
+    // on the Nth h1, in the same order chapters are emitted here, so they align.
+    return ['## Contents', '', ...entries.map((e, i) => `- [${e}](#ch-${i + 1})`)].join('\n');
+}
+/**
+ * Make a doc's footnote labels globally unique by namespacing them with an
+ * ordinal. Handles both references `[^x]` and definitions `[^x]:`, numeric or
+ * mnemonic. Only labels that are actually DEFINED in this doc are remapped, so
+ * stray `[^...]`-looking text isn't touched. Fenced code blocks are skipped.
+ */
+function namespaceFootnotes(body, ordinal) {
+    const defRe = /^\s*\[\^([^\]]+)\]:/;
+    const labels = new Set();
+    forEachLineOutsideFence(body, (line) => {
+        const m = line.match(defRe);
+        if (m)
+            labels.add(m[1]);
+    });
+    if (labels.size === 0)
+        return body;
+    return mapLinesOutsideFence(body, (line) => line.replace(/\[\^([^\]]+)\]/g, (full, label) => labels.has(label) ? `[^fn${ordinal}-${label}]` : full));
+}
+/** Shift ATX heading levels down by `by`, clamped at h6, skipping code fences. */
+function demoteHeadings(body, by) {
+    if (by <= 0)
+        return body;
+    return mapLinesOutsideFence(body, (line) => {
+        const h = line.match(/^(#{1,6})(\s+)(.*)$/);
+        if (!h)
+            return line;
+        const newLevel = Math.min(6, h[1].length + by);
+        return '#'.repeat(newLevel) + h[2] + h[3];
+    });
+}
+// ── fenced-code-aware line helpers ──────────────────────────────────────────
+function isFenceLine(line) {
+    const m = line.match(/^\s*(```+|~~~+)/);
+    return m ? m[1][0] : null;
+}
+function forEachLineOutsideFence(body, fn) {
+    let fence = null;
+    for (const line of body.split('\n')) {
+        const f = isFenceLine(line);
+        if (f) {
+            if (fence === null)
+                fence = f;
+            else if (fence === f)
+                fence = null;
+            continue;
+        }
+        if (fence === null)
+            fn(line);
+    }
+}
+function mapLinesOutsideFence(body, fn) {
+    let fence = null;
+    const lines = body.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const f = isFenceLine(lines[i]);
+        if (f) {
+            if (fence === null)
+                fence = f;
+            else if (fence === f)
+                fence = null;
+            continue;
+        }
+        if (fence === null)
+            lines[i] = fn(lines[i]);
+    }
+    return lines.join('\n');
+}

package/dist/server/manuscript/index.js ADDED Viewed

@@ -0,0 +1,35 @@
+/**
+ * Manuscript compiler — orchestrator.
+ *
+ * compileManuscript(manifestBody) → one assembled master markdown document +
+ * any warnings (unresolved pointers, unrecognized manifest lines). Rendering to
+ * EPUB / DOCX / PDF / HTML is a separate adapter layer (later phase); every
+ * render target consumes this single master markdown, so preview and export are
+ * the same pipeline differing only in the final step.
+ *
+ * adr: adr/manuscript-engine.md
+ */
+import { parseManifest } from './parse.js';
+import { resolveManifestDocs } from './resolve.js';
+import { assemble } from './assemble.js';
+export function compileManuscript(manifestBody, meta = {}) {
+    const manifest = parseManifest(manifestBody);
+    const { bodyMap, warnings: resolveWarnings } = resolveManifestDocs(manifest);
+    const { markdown, warnings: assembleWarnings } = assemble(manifest, bodyMap);
+    return {
+        markdown,
+        // Caller meta (from the doc's frontmatter / manuscriptContext) wins; the body
+        // no longer carries a meta block (round-trip-fragile).
+        meta: { ...manifest.meta, ...meta },
+        warnings: [...manifest.warnings, ...resolveWarnings, ...assembleWarnings],
+    };
+}
+export { parseManifest } from './parse.js';
+export { assemble } from './assemble.js';
+// Render adapters — every target consumes the one master markdown compileManuscript
+// produces, so preview (html) and export (epub/docx) are the same pipeline.
+export { bookCss } from './render/css.js';
+export { renderBodyHtml } from './render/md.js';
+export { renderBookHtml } from './render/html.js';
+export { renderEpub } from './render/epub.js';
+export { renderDocx } from './render/docx.js';

package/dist/server/manuscript/load.js ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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, '&amp;')
+        .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 ADDED Viewed

@@ -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>`;
+}