@sutrata/editor 0.1.0

package/dist/file/workflow-reports.js

@@ -0,0 +1,719 @@
+import { Document, Packer, Paragraph, TextRun, Table, TableRow, TableCell, WidthType, } from 'docx';
+import { resolveStyle } from '../styles/registry';
+import { styleToPrintCss } from '../styles/print-adapter';
+import { embedFontFacesFor } from '../styles/embed-fonts';
+import { SCRIPT_UNICODE_RANGES } from '../styles/script-ranges';
+import { printPaginatorScript } from './print-paginator';
+// CSS absolute units are fixed at 96px/in, print included — so a page box sized in px
+// from the paper's inches lands exactly on one sheet.
+const CSS_PX_PER_IN = 96;
+import { DEFAULT_COVER_LAYOUT } from '../styles/types';
+// CSV Escape Helper
+function esc(val) {
+    const str = val ? String(val) : '';
+    return `"${str.replace(/"/g, '""')}"`;
+}
+/** Extract all relevant workflow data from AST */
+export function extractWorkflowData(ast) {
+    const scenes = [];
+    const charMap = new Map();
+    // Resolve character registry from frontmatter
+    const fmCharacters = ast.frontmatter?.data?.['characters'];
+    let sceneCount = 0;
+    for (const node of ast.children) {
+        if (node.type === 'scene-heading') {
+            sceneCount++;
+            const rawHeading = node.text.toUpperCase();
+            // Find metadata keys
+            const numMeta = node.metadata.find(m => m.key === 'number')?.value;
+            const sceneNum = numMeta || node.id || String(sceneCount);
+            const synopsis = node.metadata.find(m => m.key === 'synopsis')?.value ?? '';
+            const actors = node.metadata.find(m => m.key === 'actors')?.value ?? '';
+            const status = node.metadata.find(m => m.key === 'status')?.value ?? '';
+            const estDuration = node.metadata.find(m => m.key === 'est-duration')?.value ?? '';
+            // Collect all shot metadata lines
+            const shotLines = node.metadata.filter(m => m.key === 'shots').map(m => m.value);
+            scenes.push({
+                number: sceneNum,
+                heading: rawHeading,
+                synopsis,
+                actors,
+                status,
+                estDuration,
+                shots: shotLines,
+            });
+            // Walk this scene's children to find characters
+            const sceneLabel = `${sceneNum}: ${rawHeading}`;
+            const seenChars = new Set();
+            const checkChar = (charName) => {
+                const name = charName.trim().toUpperCase();
+                if (!name)
+                    return;
+                if (seenChars.has(name))
+                    return;
+                seenChars.add(name);
+                if (!charMap.has(name)) {
+                    charMap.set(name, { sceneCount: 0, scenes: [] });
+                }
+                const stats = charMap.get(name);
+                stats.sceneCount++;
+                stats.scenes.push(sceneLabel);
+            };
+            for (const sc of node.children) {
+                if (sc.type === 'character') {
+                    checkChar(sc.name);
+                }
+                else if (sc.type === 'dual-dialogue') {
+                    checkChar(sc.left.name);
+                    checkChar(sc.right.name);
+                }
+            }
+        }
+    }
+    // Build character list
+    const characters = [];
+    for (const [name, stats] of charMap.entries()) {
+        const actor = fmCharacters?.[name] || fmCharacters?.[name.toLowerCase()] || '';
+        characters.push({
+            name,
+            actor,
+            sceneCount: stats.sceneCount,
+            scenes: stats.scenes,
+        });
+    }
+    // Sort characters by occurrence count descending
+    characters.sort((a, b) => b.sceneCount - a.sceneCount);
+    return { scenes, characters };
+}
+// ---------------------------------------------------------
+// CSV Exporters
+// ---------------------------------------------------------
+export function exportOneLinerCsv(scenes) {
+    const header = 'Scene #,Heading,Synopsis,Actors,Status,Est-Duration\n';
+    const rows = scenes
+        .map(s => `${esc(s.number)},${esc(s.heading)},${esc(s.synopsis)},${esc(s.actors)},${esc(s.status)},${esc(s.estDuration)}`)
+        .join('\n');
+    return header + rows;
+}
+export function exportShotListCsv(scenes) {
+    const header = 'Scene #,Heading,Actors,Shot Details\n';
+    const rows = [];
+    for (const s of scenes) {
+        if (s.shots.length === 0) {
+            rows.push(`${esc(s.number)},${esc(s.heading)},${esc(s.actors)},""`);
+        }
+        else {
+            for (const shot of s.shots) {
+                rows.push(`${esc(s.number)},${esc(s.heading)},${esc(s.actors)},${esc(shot)}`);
+            }
+        }
+    }
+    return header + rows.join('\n');
+}
+export function exportCastReportCsv(characters) {
+    const header = 'Character,Actor Name,Scene Occurrences,Scenes List\n';
+    const rows = characters
+        .map(c => `${esc(c.name)},${esc(c.actor)},${c.sceneCount},${esc(c.scenes.join('; '))}`)
+        .join('\n');
+    return header + rows;
+}
+// ---------------------------------------------------------
+// DOCX Table Exporters
+// ---------------------------------------------------------
+function makeCell(text, bold = false, widthPercent = 0) {
+    return new TableCell({
+        width: widthPercent > 0 ? { size: widthPercent, type: WidthType.PERCENTAGE } : undefined,
+        children: [
+            new Paragraph({
+                children: [
+                    new TextRun({
+                        text,
+                        bold,
+                        font: 'Courier Prime',
+                        size: '10pt',
+                    }),
+                ],
+            }),
+        ],
+    });
+}
+export async function exportOneLinerDocx(scenes) {
+    const headerRow = new TableRow({
+        children: [
+            makeCell('Scene #', true, 10),
+            makeCell('Heading', true, 25),
+            makeCell('Synopsis', true, 35),
+            makeCell('Actors', true, 15),
+            makeCell('Status', true, 10),
+            makeCell('Duration', true, 5),
+        ],
+    });
+    const rows = [headerRow];
+    for (const s of scenes) {
+        rows.push(new TableRow({
+            children: [
+                makeCell(s.number, false, 10),
+                makeCell(s.heading, false, 25),
+                makeCell(s.synopsis, false, 35),
+                makeCell(s.actors, false, 15),
+                makeCell(s.status, false, 10),
+                makeCell(s.estDuration, false, 5),
+            ],
+        }));
+    }
+    const table = new Table({
+        width: { size: 100, type: WidthType.PERCENTAGE },
+        rows,
+    });
+    const doc = new Document({
+        sections: [
+            {
+                properties: {},
+                children: [
+                    new Paragraph({
+                        children: [
+                            new TextRun({
+                                text: 'ONE-LINER SCHEDULE / SCENE BREAKDOWN',
+                                bold: true,
+                                font: 'Courier Prime',
+                                size: '14pt',
+                            }),
+                        ],
+                        spacing: { after: 288 },
+                    }),
+                    table,
+                ],
+            },
+        ],
+    });
+    return Packer.toBlob(doc);
+}
+export async function exportShotListDocx(scenes) {
+    const headerRow = new TableRow({
+        children: [
+            makeCell('Scene #', true, 10),
+            makeCell('Heading', true, 25),
+            makeCell('Actors', true, 20),
+            makeCell('Shot Details', true, 45),
+        ],
+    });
+    const rows = [headerRow];
+    for (const s of scenes) {
+        const shotDetails = s.shots.join('\n');
+        rows.push(new TableRow({
+            children: [
+                makeCell(s.number, false, 10),
+                makeCell(s.heading, false, 25),
+                makeCell(s.actors, false, 20),
+                makeCell(shotDetails || 'No shots specified', false, 45),
+            ],
+        }));
+    }
+    const table = new Table({
+        width: { size: 100, type: WidthType.PERCENTAGE },
+        rows,
+    });
+    const doc = new Document({
+        sections: [
+            {
+                properties: {},
+                children: [
+                    new Paragraph({
+                        children: [
+                            new TextRun({
+                                text: 'SHOT LIST REPORT',
+                                bold: true,
+                                font: 'Courier Prime',
+                                size: '14pt',
+                            }),
+                        ],
+                        spacing: { after: 288 },
+                    }),
+                    table,
+                ],
+            },
+        ],
+    });
+    return Packer.toBlob(doc);
+}
+export async function exportCastReportDocx(characters) {
+    const headerRow = new TableRow({
+        children: [
+            makeCell('Character', true, 25),
+            makeCell('Actor Name', true, 25),
+            makeCell('Occurrences', true, 15),
+            makeCell('Scenes List', true, 35),
+        ],
+    });
+    const rows = [headerRow];
+    for (const c of characters) {
+        rows.push(new TableRow({
+            children: [
+                makeCell(c.name, false, 25),
+                makeCell(c.actor || 'TBD', false, 25),
+                makeCell(String(c.sceneCount), false, 15),
+                makeCell(c.scenes.join(', '), false, 35),
+            ],
+        }));
+    }
+    const table = new Table({
+        width: { size: 100, type: WidthType.PERCENTAGE },
+        rows,
+    });
+    const doc = new Document({
+        sections: [
+            {
+                properties: {},
+                children: [
+                    new Paragraph({
+                        children: [
+                            new TextRun({
+                                text: 'CHARACTER OCCURRENCE / CAST REPORT',
+                                bold: true,
+                                font: 'Courier Prime',
+                                size: '14pt',
+                            }),
+                        ],
+                        spacing: { after: 288 },
+                    }),
+                    table,
+                ],
+            },
+        ],
+    });
+    return Packer.toBlob(doc);
+}
+// ---------------------------------------------------------
+// Print Preview Page Generator (HTML)
+// ---------------------------------------------------------
+export async function openPrintPreview(scenes, title = 'One-Liner Schedule') {
+    // Open synchronously (inside the click) so popup blockers allow it, then embed fonts.
+    const win = window.open('', '_blank');
+    if (!win)
+        return;
+    // Noto Sans carries every ISO 15919 letter and mark, for romanized reports; the new
+    // window has no stylesheet of its own.
+    const fontFaceCss = await embedFontFacesFor(['Noto Sans']);
+    const rowsHtml = scenes
+        .map(s => `
+    <tr>
+      <td>${s.number}</td>
+      <td><strong>${s.heading}</strong></td>
+      <td>${s.synopsis || '<span class="empty">No synopsis</span>'}</td>
+      <td>${s.actors || '-'}</td>
+      <td><span class="status-badge status-${s.status.toLowerCase().replace(/\s+/g, '-') || 'none'}">${s.status || '-'}</span></td>
+      <td>${s.estDuration || '-'}</td>
+    </tr>
+  `)
+        .join('');
+    win.document.write(`
+    <!DOCTYPE html>
+    <html>
+      <head>
+        <title>${title}</title>
+        <style>
+          ${fontFaceCss}
+          body {
+            font-family: 'Noto Sans', 'Courier Prime', sans-serif;
+            margin: 40px;
+            color: #333;
+          }
+          h1 {
+            font-family: 'Courier Prime', sans-serif;
+            text-align: center;
+            font-size: 20px;
+            margin-bottom: 30px;
+            text-transform: uppercase;
+            letter-spacing: 1px;
+          }
+          table {
+            width: 100%;
+            border-collapse: collapse;
+            font-size: 13px;
+          }
+          th, td {
+            border: 1px solid #ccc;
+            padding: 10px 12px;
+            text-align: left;
+            vertical-align: top;
+          }
+          th {
+            background-color: #f7f7f5;
+            font-weight: 600;
+          }
+          .empty {
+            color: #999;
+            font-style: italic;
+          }
+          .status-badge {
+            display: inline-block;
+            padding: 2px 6px;
+            border-radius: 4px;
+            font-size: 11px;
+            font-weight: 600;
+            background: #f0f0f0;
+            border: 1px solid #ddd;
+          }
+          .status-done, .status-revised { background: #e6f4ea; color: #137333; border-color: #ceead6; }
+          .status-wip { background: #fef7e0; color: #b06000; border-color: #feebc8; }
+          .status-draft { background: #fce8e6; color: #c5221f; border-color: #fad2cf; }
+
+          @media print {
+            body { margin: 20px; }
+            button { display: none !important; }
+            th { background-color: #f0f0f0 !important; -webkit-print-color-adjust: exact; }
+          }
+
+          .print-btn-bar {
+            text-align: right;
+            margin-bottom: 20px;
+          }
+          .print-btn {
+            background: #1976d2;
+            color: white;
+            border: none;
+            padding: 8px 16px;
+            font-size: 13px;
+            border-radius: 4px;
+            cursor: pointer;
+            font-weight: 600;
+          }
+          .print-btn:hover { background: #1565c0; }
+        </style>
+      </head>
+      <body>
+        <div class="print-btn-bar">
+          <button class="print-btn" onclick="window.print()">Print Schedule</button>
+        </div>
+        <h1>${title}</h1>
+        <table>
+          <thead>
+            <tr>
+              <th style="width: 8%">Scene #</th>
+              <th style="width: 25%">Heading</th>
+              <th style="width: 35%">Synopsis</th>
+              <th style="width: 15%">Actors</th>
+              <th style="width: 12%">Status</th>
+              <th style="width: 5%">Duration</th>
+            </tr>
+          </thead>
+          <tbody>
+            ${rowsHtml}
+          </tbody>
+        </table>
+      </body>
+    </html>
+  `);
+    win.document.close();
+}
+/** Print Screenplay Preview in formatted style. `styleOverride` picks a style id for
+ *  this export only (without touching the document); otherwise the document's
+ *  frontmatter `style:` field is used, falling back to the default style. `skipNotes`
+ *  omits both block-level and inline `[[ ]]` notes from the exported document. */
+export async function openScreenplayPrintPreview(ast, title = 'Screenplay', styleOverride, customStyles = [], skipNotes = false) {
+    const html = await buildScreenplayPrintHtml(ast, title, styleOverride, customStyles, skipNotes);
+    // Desktop shell: generate a real vector-text PDF via the platform's browser
+    // engine (WebView2 PrintToPdf on Windows) instead of the OS print dialog,
+    // which avoids the rasterized/bloated output some print-to-PDF drivers produce.
+    const api = window.desktopAPI;
+    if (api?.exportScreenplayToPdf && api?.showSavePdfDialog) {
+        const defaultName = `${title.replace(/[\\/:*?"<>|]/g, '_')}.pdf`;
+        const path = await api.showSavePdfDialog(defaultName);
+        if (!path)
+            return;
+        await api.exportScreenplayToPdf(html, path);
+        return;
+    }
+    const win = window.open('', '_blank');
+    if (!win)
+        return;
+    win.document.write(html);
+    win.document.close();
+}
+async function buildScreenplayPrintHtml(ast, title, styleOverride, customStyles = [], skipNotes = false) {
+    const frontmatter = ast.frontmatter?.data;
+    const defaultLang = frontmatter?.['lang'] ?? 'en';
+    const style = resolveStyle(styleOverride ?? frontmatter?.['style'], customStyles);
+    // Noto Sans is the Latin fallback in the print font stack (print-adapter.ts), so embed it
+    // too: the desktop's hidden print webview cannot load /fonts/ paths on its own.
+    const embeddedFontFaceCss = await embedFontFacesFor([...new Set([
+            style.fontFamily,
+            ...Object.values(style.complexScriptFontOverrides ?? {}),
+            'Noto Sans',
+        ])]);
+    // Paper the export prints on — frontmatter's `page:`, the same field docx-exporter.ts
+    // reads. print-paginator.ts needs it in CSS px to size its page boxes.
+    const pageFormat = frontmatter?.['page']?.toLowerCase() === 'a4' ? 'a4' : 'letter';
+    const pageHeightIn = pageFormat === 'a4' ? 11.69 : 11;
+    const watermarkValue = typeof frontmatter?.['watermark'] === 'string' ? frontmatter['watermark'].trim() : '';
+    const watermarkHtml = watermarkValue ? `<div class="print-watermark">${escapeHtml(watermarkValue)}</div>` : '';
+    // Render cover page
+    let coverPageHtml = '';
+    if (frontmatter && (frontmatter['title'] || frontmatter['author'])) {
+        const titleText = String(frontmatter['title'] || 'Untitled');
+        const authorText = String(frontmatter['author'] || '');
+        const loglineText = String(frontmatter['logline'] || '');
+        const dateText = String(frontmatter['date'] || '');
+        const contactText = String(frontmatter['contact'] || '');
+        // Both cover layouts share this markup — the two blocks are what 'corners' pushes
+        // into opposite corners and 'centered' just stacks (see print-adapter.ts). The
+        // byline differs: 'corners' prints one "by <author>" line, 'centered' keeps the
+        // classic "by" / author on separate lines.
+        const corners = (style.coverLayout ?? DEFAULT_COVER_LAYOUT) === 'corners';
+        const bylineHtml = corners
+            ? `<div class="print-cover-author">by ${textHtml(authorText)}</div>`
+            : `<div class="print-cover-by">by</div>
+         <div class="print-cover-author">${textHtml(authorText)}</div>`;
+        coverPageHtml = `
+      <div class="print-cover-page print-cover-${corners ? 'corners' : 'centered'}">
+        <div class="print-cover-top">
+          <div class="print-cover-title">${textHtml(titleText)}</div>
+          ${bylineHtml}
+          ${loglineText ? `<div class="print-cover-logline">${textHtml(loglineText)}</div>` : ''}
+        </div>
+        <div class="print-cover-bottom">
+          ${dateText ? `<div class="print-cover-date">${escapeHtml(dateText)}</div>` : ''}
+          ${contactText ? `<div class="print-cover-contact">${escapeHtml(contactText)}</div>` : ''}
+        </div>
+      </div>
+    `;
+    }
+    // Render screenplay nodes
+    let bodyHtml = '';
+    function renderSpans(spans) {
+        return spans.map(s => {
+            if (s.type === 'text')
+                return textHtml(s.text);
+            if (s.type === 'bold')
+                return `<strong>${renderSpans(s.spans)}</strong>`;
+            if (s.type === 'italic')
+                return `<em>${renderSpans(s.spans)}</em>`;
+            if (s.type === 'underline')
+                return `<u>${renderSpans(s.spans)}</u>`;
+            if (s.type === 'note')
+                return skipNotes ? '' : `<span class="print-note">[[ ${textHtml(s.text)} ]]</span>`;
+            return '';
+        }).join('');
+    }
+    function escapeHtml(text) {
+        return text
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&#039;');
+    }
+    /** Whether `text` contains a script this style forces italic by default
+     *  (`italicScripts`, e.g. Traditional's Tamil) — mirrors docx-exporter.ts's
+     *  createRuns forced-italic behavior, which the live editor and DOCX export
+     *  already have but the print/PDF HTML never did (no per-span language tagging
+     *  there), so Tamil rendered upright in exported PDFs even under Traditional. */
+    function forceItalic(text) {
+        if (!style.italicScripts?.length)
+            return false;
+        return style.italicScripts.some(code => SCRIPT_UNICODE_RANGES[code]?.test(text));
+    }
+    /** escapeHtml, plus <i>-wrapping when forceItalic(text) — italic always,
+     *  even inside otherwise-bold/underlined elements like Traditional's scene
+     *  headings and character cues, matching the confirmed docx-exporter.ts behavior. */
+    function textHtml(text) {
+        const escaped = escapeHtml(text);
+        return forceItalic(text) ? `<i>${escaped}</i>` : escaped;
+    }
+    function renderContentNode(n) {
+        if (n.type === 'action') {
+            return `<div class="print-action">${renderSpans(n.spans)}</div>`;
+        }
+        if (n.type === 'character') {
+            const ext = n.extension ? ` ${n.extension.toUpperCase()}` : '';
+            const childHtml = n.children.map(c => {
+                if (c.type === 'parenthetical') {
+                    return `<div class="print-parenthetical">(${textHtml(c.text)})</div>`;
+                }
+                else {
+                    return `<div class="print-dialogue">${renderSpans(c.spans)}</div>`;
+                }
+            }).join('');
+            return `
+        <div class="print-character-block">
+          <div class="print-character">${textHtml(n.name.toUpperCase())}${textHtml(ext)}</div>
+          ${childHtml}
+        </div>
+      `;
+        }
+        if (n.type === 'transition') {
+            return `<div class="print-transition">${textHtml(n.text.toUpperCase())}</div>`;
+        }
+        if (n.type === 'centered') {
+            return `<div class="print-centered">${textHtml(n.text)}</div>`;
+        }
+        if (n.type === 'lyrics') {
+            return `<div class="print-lyrics">${renderSpans(n.spans)}</div>`;
+        }
+        if (n.type === 'note') {
+            return skipNotes ? '' : `<div class="print-note">${textHtml(n.text)}</div>`;
+        }
+        if (n.type === 'comment') {
+            return `<div class="print-comment">&lt;!-- ${textHtml(n.text)} --&gt;</div>`;
+        }
+        if (n.type === 'page-break') {
+            return `<div class="print-page-break"></div>`;
+        }
+        if (n.type === 'dual-dialogue') {
+            const leftChar = n.left;
+            const leftExt = leftChar.extension ? ` ${leftChar.extension.toUpperCase()}` : '';
+            const leftChildHtml = leftChar.children.map(c => {
+                if (c.type === 'parenthetical') {
+                    return `<div class="print-parenthetical">(${textHtml(c.text)})</div>`;
+                }
+                else {
+                    return `<div class="print-dialogue">${renderSpans(c.spans)}</div>`;
+                }
+            }).join('');
+            const rightChar = n.right;
+            const rightExt = rightChar.extension ? ` ${rightChar.extension.toUpperCase()}` : '';
+            const rightChildHtml = rightChar.children.map(c => {
+                if (c.type === 'parenthetical') {
+                    return `<div class="print-parenthetical">(${textHtml(c.text)})</div>`;
+                }
+                else {
+                    return `<div class="print-dialogue">${renderSpans(c.spans)}</div>`;
+                }
+            }).join('');
+            return `
+        <div class="print-dual-dialogue">
+          <div class="print-dual-column print-left-column">
+            <div class="print-character">${textHtml(leftChar.name.toUpperCase())}${textHtml(leftExt)}</div>
+            ${leftChildHtml}
+          </div>
+          <div class="print-dual-column print-right-column">
+            <div class="print-character">${textHtml(rightChar.name.toUpperCase())}${textHtml(rightExt)}</div>
+            ${rightChildHtml}
+          </div>
+        </div>
+      `;
+        }
+        return '';
+    }
+    /** Stamps the scene a block belongs to onto its outermost element, which is how
+     *  print-paginator.ts decides whether a page opens mid-scene (-> "8 CONTINUED:") or on
+     *  a fresh one. The label is the scene's own number when it has one, else its position
+     *  in the script — the same thing the heading prints on the right. */
+    function tagScene(html, label, isHeading = false) {
+        const attrs = ` data-scene="${escapeHtml(label)}"${isHeading ? ` data-scene-start="${escapeHtml(label)}"` : ''}`;
+        return html.replace('<div', `<div${attrs}`);
+    }
+    let sceneOrdinal = 0;
+    for (const node of ast.children) {
+        if (node.type === 'section') {
+            bodyHtml += `<div class="print-section print-sect-${node.level}">${textHtml(node.text)}</div>`;
+            for (const sub of node.children) {
+                bodyHtml += renderContentNode(sub);
+            }
+        }
+        else if (node.type === 'scene-heading') {
+            sceneOrdinal++;
+            const sceneLabel = node.id || String(sceneOrdinal);
+            bodyHtml += tagScene(`
+        <div class="print-scene-heading">
+          <span class="print-scene-title">${textHtml(node.text.toUpperCase())}</span>
+          ${node.id ? `<span class="print-scene-num">${escapeHtml(node.id)}</span>` : ''}
+        </div>
+      `, sceneLabel, true);
+            for (const sub of node.children) {
+                bodyHtml += tagScene(renderContentNode(sub), sceneLabel);
+            }
+        }
+        else {
+            bodyHtml += renderContentNode(node);
+        }
+    }
+    return `
+    <!DOCTYPE html>
+    <html>
+      <head>
+        <title>${escapeHtml(title)}</title>
+        <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=Noto+Sans:ital,wght@0,100..900;1,100..900&family=Noto+Sans+Devanagari&family=Noto+Sans+Tamil&family=Noto+Sans+Telugu&family=Noto+Sans+Kannada&family=Noto+Sans+Malayalam&family=Noto+Sans+Bengali&family=Noto+Sans+Gujarati&family=Noto+Sans+Gurmukhi&family=Noto+Sans+Oriya&family=Noto+Serif:ital,wght@0,400;0,700;1,400&family=Noto+Serif+Devanagari&family=Noto+Serif+Tamil:ital@0;1&family=Noto+Serif+Telugu&family=Noto+Serif+Kannada&family=Noto+Serif+Malayalam&family=Noto+Serif+Bengali&family=Noto+Serif+Gujarati&family=Noto+Serif+Gurmukhi&family=Noto+Serif+Oriya&display=swap" rel="stylesheet">
+        <style>
+          /* Statically-instanced (non-variable) copies of this export's own fonts, embedded
+             as data: URIs — see embed-fonts.ts for why: Chromium's print/PDF-to-file font
+             subsetter has known bugs mishandling GPOS/GSUB (glyph positioning/substitution —
+             required for correct Indic conjunct/vowel-sign shaping) on *variable* fonts
+             specifically, even though the same font shapes perfectly on-screen. The Google
+             Fonts <link> above only serves variable Indic-script families, so without this,
+             a style that needs one (e.g. Traditional's Noto Serif Tamil) renders correctly in
+             the on-screen preview but comes out garbled the moment it's actually printed/
+             exported to PDF. Declared after the <link> so these take cascade precedence for
+             the same family/weight/style. */
+          ${embeddedFontFaceCss}
+        </style>
+        <style>
+          /* Layout-neutral part only — the two cover layouts (.print-cover-centered /
+             .print-cover-corners) come from the style, so they live in print-adapter.ts. */
+          .print-cover-page {
+            page-break-after: always;
+            box-sizing: border-box;
+          }
+          ${styleToPrintCss(style, pageFormat)}
+
+          /* Interface / buttons */
+          .print-btn-bar {
+            text-align: right;
+            margin-bottom: 20px;
+          }
+          .print-btn {
+            background: #0a5c6a;
+            color: white;
+            border: none;
+            padding: 8px 16px;
+            font-size: 13px;
+            border-radius: 4px;
+            cursor: pointer;
+            font-weight: 600;
+          }
+          .print-btn:hover {
+            background: #084954;
+          }
+
+          /* Watermark, from frontmatter's watermark: field. position: fixed repeats
+             it on every printed page in Chromium's print/print-to-pdf engine (including
+             WebView2, used for the native Windows PDF export) -- the same trick the live
+             editor's .cs-watermark uses to stay visible while scrolling. */
+          .print-watermark {
+            position: fixed;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%) rotate(-45deg);
+            font-size: 60pt;
+            font-weight: 700;
+            color: rgba(0, 0, 0, 0.08);
+            white-space: nowrap;
+            pointer-events: none;
+            z-index: -1;
+          }
+
+          @media print {
+            .print-btn-bar { display: none !important; }
+            body { padding: 0; }
+          }
+        </style>
+      </head>
+      <body>
+        <div class="print-btn-bar">
+          <button class="print-btn" onclick="window.print()">Export to PDF / Print</button>
+        </div>
+        ${watermarkHtml}
+        ${coverPageHtml}
+        <div id="print-pages"></div>
+        <div id="print-flow">${bodyHtml}</div>
+        ${printPaginatorScript({
+        contentHeightPx: Math.round((pageHeightIn - style.page.marginTopIn - style.page.marginBottomIn) * CSS_PX_PER_IN),
+        pageNumberPrefix: 'p',
+        continuedSuffix: 'CONTINUED:',
+    })}
+      </body>
+    </html>
+  `;
+}