diff --git a/docs/superpowers/plans/2026-07-23-monospace-font-embedding-and-naming.md b/docs/superpowers/plans/2026-07-23-monospace-font-embedding-and-naming.md
new file mode 100644
index 0000000..7cd880d
--- /dev/null
+++ b/docs/superpowers/plans/2026-07-23-monospace-font-embedding-and-naming.md
@@ -0,0 +1,1581 @@
+# Monospace Font Embedding + Naming Differentiation Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Port the v4.5.0 monospace font embedding feature from `master` into `react-electron`, then differentiate the dev build's identity (`Markdown Converter React` / `com.concreteinfo.markdownconverter.react`) so it coexists with the installed `markdown-converter` deb.
+
+**Architecture:** Five small, focused main-process modules (config, pdf header, docx embedder, epub embedder, export css) wired into the existing `exportWithPandoc` pipeline. Settings stored in the same JSON file via the existing `src/main/store.js`. Two new IPC channels exposed through the existing whitelisted preload bridge. Renderer toggles CSS classes on `document.body` to drive `--font-mono-active` tokens. Product rename in `package.json` `build` block plus `src/main/window/index.js` title prefix.
+
+**Tech Stack:** Node.js 20 + Electron 41 + React 19 + TypeScript 5.5 + Vite 8 + Jest 30 + Vitest 4. New deps: none (we use `archiver`/`unzipper`? — checked, none; we use only Node built-ins + `jszip` which is already a dep via `docx`).
+
+---
+
+## File Structure
+
+### New files
+- `src/main/MonospaceFontConfig.js` — TTF path resolver (`getMonoFontTtfPath`, `ligaturesEnabled`, `getActiveFamily`)
+- `src/main/PdfFontHeader.js` — writes `.tex` fontspec header for xelatex/lualatex
+- `src/main/DocxFontEmbedder.js` — post-process pandoc DOCX output to embed TTF
+- `src/main/EpubFontEmbedder.js` — `withEpubEmbedFontArgs` + `embedEpubFont`
+- `src/main/ExportCss.js` — `buildExportCss` returning CSS string with base64 woff2
+- `src/main/settings/monospaceSettings.js` — schema, family map, `safeMonospaceSettings`
+- `src/main/ipc/monospace-handlers.js` — registers `get-monospace-settings`, `set-monospace-settings`
+- `src/renderer/hooks/use-monospace-classes.ts` — applies body classes from settings
+- `tests/unit/main/monospace/MonospaceFontConfig.test.js`
+- `tests/unit/main/monospace/monospaceSettings.test.js`
+- `tests/unit/main/monospace/PdfFontHeader.test.js`
+- `tests/unit/main/monospace/DocxFontEmbedder.test.js`
+- `tests/unit/main/monospace/EpubFontEmbedder.test.js`
+- `tests/unit/main/monospace/ExportCss.test.js`
+- `tests/unit/main/monospace/monospace-handlers.test.js`
+- `tests/smoke-e2e-monospace.js` — E2E: ASCII art markdown → PDF/DOCX/EPUB/HTML, grep for font refs
+
+### Modified files
+- `src/main/index.js` — wire monospace modules into `exportWithPandoc` PDF/DOCX/EPUB/HTML branches; register IPC handlers at startup
+- `src/main/window/index.js` — title suffix `— React Dev` in dev
+- `src/preload.js` — add monospace channels to allowlist + expose on `window.electronAPI.monospace`
+- `src/renderer/types/electron.d.ts` — extend `ElectronAPI` with `monospace` namespace
+- `src/renderer/lib/ipc.ts` — type-safe wrapper for monospace
+- `src/renderer/styles/globals.css` — add `--font-mono-active` / `--font-mono-feature` declarations
+- `src/main/updater/migration-transform.js` — add `monospaceFont`, `monospaceLigatures`, `appVariant` defaults
+- `package.json` — `name`, `productName`, `appId`, `linux.executableName`; `build.asarUnpack` for `assets/fonts/**`; bundle Fira Code downloader reference in `download-tools`
+- `scripts/download-tools.js` — add `downloadFiraCode()` parallel to `downloadPandoc()`
+- `App.tsx` (or wherever the root layout mounts hooks) — call `useMonospaceClasses()` once at startup
+- `CHANGELOG.md` — 5.1.0 entry
+
+### Untracked but not new
+- `assets/fonts/JetBrainsMono-Regular.ttf` (~274 KB)
+- `assets/fonts/JetBrainsMono-Bold.ttf` (~278 KB)
+- `assets/fonts/JetBrainsMono-LICENSE.txt`
+- `assets/fonts/FiraCode-Regular.ttf` (~300 KB)
+- `assets/fonts/FiraCode-Bold.ttf` (~300 KB)
+- `assets/fonts/FiraCode-LICENSE.txt`
+
+---
+
+## Task 1: Add monospace settings schema + tests
+
+**Files:**
+- Create: `src/main/settings/monospaceSettings.js`
+- Create: `tests/unit/main/monospace/monospaceSettings.test.js`
+
+- [ ] **Step 1: Write the failing test**
+
+```js
+// tests/unit/main/monospace/monospaceSettings.test.js
+const {
+ FAMILY_BY_KEY,
+ getActiveMonoFont,
+ isLigaturesEnabled,
+ safeMonospaceSettings,
+ DEFAULT_SETTINGS,
+} = require('../../../../src/main/settings/monospaceSettings');
+
+describe('monospaceSettings', () => {
+ test('FAMILY_BY_KEY maps jetbrains-mono → "JetBrains Mono"', () => {
+ expect(FAMILY_BY_KEY['jetbrains-mono']).toBe('JetBrains Mono');
+ });
+ test('getActiveMonoFont returns family for valid key', () => {
+ expect(getActiveMonoFont({ monospaceFont: 'fira-code' })).toBe('Fira Code');
+ });
+ test('getActiveMonoFont falls back to default for unknown key', () => {
+ expect(getActiveMonoFont({ monospaceFont: 'unknown' })).toBe('JetBrains Mono');
+ });
+ test('getActiveMonoFont returns default when key missing', () => {
+ expect(getActiveMonoFont({})).toBe('JetBrains Mono');
+ });
+ test('isLigaturesEnabled is true only when explicitly true', () => {
+ expect(isLigaturesEnabled({ monospaceLigatures: true })).toBe(true);
+ expect(isLigaturesEnabled({ monospaceLigatures: false })).toBe(false);
+ expect(isLigaturesEnabled({ monospaceLigatures: 'yes' })).toBe(false);
+ expect(isLigaturesEnabled({})).toBe(false);
+ });
+ test('safeMonospaceSettings rejects unknown fonts', () => {
+ expect(safeMonospaceSettings({ monospaceFont: 'comic-sans' })).toEqual(DEFAULT_SETTINGS);
+ });
+ test('safeMonospaceSettings coerces ligatures to boolean', () => {
+ expect(safeMonospaceSettings({ monospaceLigatures: 1 })).toEqual({
+ monospaceFont: 'jetbrains-mono',
+ monospaceLigatures: true,
+ });
+ });
+ test('safeMonospaceSettings returns DEFAULT_SETTINGS for empty input', () => {
+ expect(safeMonospaceSettings({})).toEqual(DEFAULT_SETTINGS);
+ });
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `npm test -- tests/unit/main/monospace/monospaceSettings.test.js`
+Expected: FAIL — `Cannot find module '../../../../src/main/settings/monospaceSettings'`
+
+- [ ] **Step 3: Implement the module**
+
+```js
+// src/main/settings/monospaceSettings.js
+'use strict';
+
+const FAMILY_BY_KEY = {
+ 'jetbrains-mono': 'JetBrains Mono',
+ 'fira-code': 'Fira Code',
+};
+
+const ALLOWED_FONTS = Object.keys(FAMILY_BY_KEY);
+
+const DEFAULT_SETTINGS = Object.freeze({
+ monospaceFont: 'jetbrains-mono',
+ monospaceLigatures: false,
+});
+
+function getActiveMonoFont(settings) {
+ const key = settings && settings.monospaceFont;
+ if (typeof key === 'string' && Object.prototype.hasOwnProperty.call(FAMILY_BY_KEY, key)) {
+ return FAMILY_BY_KEY[key];
+ }
+ return FAMILY_BY_KEY[DEFAULT_SETTINGS.monospaceFont];
+}
+
+function isLigaturesEnabled(settings) {
+ return !!(settings && settings.monospaceLigatures === true);
+}
+
+function safeMonospaceSettings(input) {
+ const safe = { ...DEFAULT_SETTINGS };
+ if (input && typeof input === 'object') {
+ if (ALLOWED_FONTS.includes(input.monospaceFont)) {
+ safe.monospaceFont = input.monospaceFont;
+ }
+ if (typeof input.monospaceLigatures === 'boolean') {
+ safe.monospaceLigatures = input.monospaceLigatures;
+ } else if (input.monospaceLigatures === 1 || input.monospaceLigatures === 'true') {
+ safe.monospaceLigatures = true;
+ }
+ }
+ return safe;
+}
+
+module.exports = {
+ FAMILY_BY_KEY,
+ ALLOWED_FONTS,
+ DEFAULT_SETTINGS,
+ getActiveMonoFont,
+ isLigaturesEnabled,
+ safeMonospaceSettings,
+};
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `npm test -- tests/unit/main/monospace/monospaceSettings.test.js`
+Expected: PASS — 8 tests pass.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/main/settings/monospaceSettings.js tests/unit/main/monospace/monospaceSettings.test.js
+git commit -m "feat(monospace): add settings schema with safe defaults"
+```
+
+---
+
+## Task 2: MonospaceFontConfig path resolver
+
+**Files:**
+- Create: `src/main/MonospaceFontConfig.js`
+- Create: `tests/unit/main/monospace/MonospaceFontConfig.test.js`
+
+- [ ] **Step 1: Write the failing test**
+
+```js
+// tests/unit/main/monospace/MonospaceFontConfig.test.js
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+describe('MonospaceFontConfig', () => {
+ let tmpDir;
+ let originalResourcesPath;
+ let originalCwd;
+
+ beforeEach(() => {
+ tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mono-font-cfg-'));
+ originalResourcesPath = process.resourcesPath;
+ originalCwd = process.cwd();
+ process.resourcesPath = undefined;
+ });
+
+ afterEach(() => {
+ process.resourcesPath = originalResourcesPath;
+ process.chdir(originalCwd);
+ fs.rmSync(tmpDir, { recursive: true, force: true });
+ });
+
+ function loadFresh() {
+ delete require.cache[require.resolve('../../../../src/main/MonospaceFontConfig')];
+ return require('../../../../src/main/MonospaceFontConfig');
+ }
+
+ test('resolves JetBrains Mono Regular TTF from repo assets', () => {
+ const repoRoot = path.resolve(__dirname, '../../..');
+ fs.mkdirSync(path.join(repoRoot, 'assets', 'fonts'), { recursive: true });
+ const target = path.join(repoRoot, 'assets', 'fonts', 'JetBrainsMono-Regular.ttf');
+ fs.writeFileSync(target, 'fake-ttf');
+ try {
+ const cfg = loadFresh();
+ const result = cfg.getMonoFontTtfPath('jetbrains-mono', 400);
+ expect(result).toBe(target);
+ } finally {
+ fs.unlinkSync(target);
+ }
+ });
+
+ test('resolves Fira Code Bold TTF when family is fira-code and weight 700', () => {
+ const repoRoot = path.resolve(__dirname, '../../..');
+ const target = path.join(repoRoot, 'assets', 'fonts', 'FiraCode-Bold.ttf');
+ fs.mkdirSync(path.dirname(target), { recursive: true });
+ fs.writeFileSync(target, 'fake-ttf');
+ try {
+ const cfg = loadFresh();
+ const result = cfg.getMonoFontTtfPath('fira-code', 700);
+ expect(result).toBe(target);
+ } finally {
+ fs.unlinkSync(target);
+ }
+ });
+
+ test('returns null when TTF is missing', () => {
+ const cfg = loadFresh();
+ const result = cfg.getMonoFontTtfPath('jetbrains-mono', 400);
+ expect(result).toBeNull();
+ });
+
+ test('ligaturesEnabled delegates to settings', () => {
+ const { ligaturesEnabled } = require('../../../../src/main/settings/monospaceSettings');
+ const cfg = loadFresh();
+ expect(cfg.ligaturesEnabled({ monospaceLigatures: true })).toBe(true);
+ expect(cfg.ligaturesEnabled({ monospaceLigatures: false })).toBe(false);
+ expect(cfg.ligaturesEnabled({})).toBe(false);
+ });
+
+ test('getActiveFamily returns the human-readable family name', () => {
+ const cfg = loadFresh();
+ expect(cfg.getActiveFamily({ monospaceFont: 'fira-code' })).toBe('Fira Code');
+ expect(cfg.getActiveFamily({})).toBe('JetBrains Mono');
+ });
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `npm test -- tests/unit/main/monospace/MonospaceFontConfig.test.js`
+Expected: FAIL — `Cannot find module`
+
+- [ ] **Step 3: Implement the module**
+
+```js
+// src/main/MonospaceFontConfig.js
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const {
+ getActiveMonoFont,
+ isLigaturesEnabled,
+ FAMILY_BY_KEY,
+} = require('./settings/monospaceSettings');
+
+const WEIGHT_BY_KEY = { 300: 'Light', 400: 'Regular', 500: 'Medium', 600: 'SemiBold', 700: 'Bold' };
+
+function getAppRoot() {
+ if (
+ process.resourcesPath &&
+ fs.existsSync(path.join(process.resourcesPath, 'app.asar.unpacked'))
+ ) {
+ return process.resourcesPath;
+ }
+ return path.resolve(__dirname, '..', '..');
+}
+
+function getCandidatePaths(family, weight) {
+ const familyDir = family === 'Fira Code' ? 'FiraCode' : 'JetBrainsMono';
+ const weightName = WEIGHT_BY_KEY[weight] || 'Regular';
+ const filename = `${familyDir}-${weightName}.ttf`;
+ const candidates = [];
+ candidates.push(path.resolve(getAppRoot(), 'assets', 'fonts', filename));
+ const packagedRoot = process.resourcesPath || getAppRoot();
+ candidates.push(path.join(packagedRoot, 'app.asar.unpacked', 'assets', 'fonts', filename));
+ return candidates;
+}
+
+function getMonoFontTtfPath(familyKey, weight = 400) {
+ const family = FAMILY_BY_KEY[familyKey] || 'JetBrains Mono';
+ const candidates = getCandidatePaths(family, weight);
+ for (const p of candidates) {
+ if (fs.existsSync(p)) return p;
+ }
+ const filename = path.basename(candidates[candidates.length - 1]);
+ console.warn(
+ `[MonospaceFontConfig] bundled font missing: ${filename}; falling back to system monospace`
+ );
+ return null;
+}
+
+function ligaturesEnabled(settings) {
+ return isLigaturesEnabled(settings);
+}
+
+function getActiveFamily(settings) {
+ return getActiveMonoFont(settings);
+}
+
+module.exports = { getMonoFontTtfPath, ligaturesEnabled, getActiveFamily };
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `npm test -- tests/unit/main/monospace/MonospaceFontConfig.test.js`
+Expected: PASS — 5 tests pass.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/main/MonospaceFontConfig.js tests/unit/main/monospace/MonospaceFontConfig.test.js
+git commit -m "feat(monospace): add path resolver for bundled TTF assets"
+```
+
+---
+
+## Task 3: PdfFontHeader builder
+
+**Files:**
+- Create: `src/main/PdfFontHeader.js`
+- Create: `tests/unit/main/monospace/PdfFontHeader.test.js`
+
+- [ ] **Step 1: Write the failing test**
+
+```js
+// tests/unit/main/monospace/PdfFontHeader.test.js
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const { buildPdfFontHeader } = require('../../../../src/main/PdfFontHeader');
+
+describe('PdfFontHeader', () => {
+ let tmpDir;
+ beforeEach(() => { tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mono-pdfhdr-')); });
+ afterEach(() => { fs.rmSync(tmpDir, { recursive: true, force: true }); });
+
+ test('writes a fontspec header for JetBrains Mono Regular', () => {
+ const ttf = path.join(tmpDir, 'JetBrainsMono-Regular.ttf');
+ fs.writeFileSync(ttf, 'fake');
+ const out = buildPdfFontHeader({ monospaceFont: 'jetbrains-mono', monospaceLigatures: false }, ttf, 'JetBrains Mono');
+ expect(typeof out.headerPath).toBe('string');
+ expect(fs.existsSync(out.headerPath)).toBe(true);
+ const content = fs.readFileSync(out.headerPath, 'utf-8');
+ expect(content).toContain('\\setmonofont');
+ expect(content).toContain('JetBrainsMono-Regular.ttf');
+ expect(out.familyName).toBe('JetBrains Mono');
+ });
+
+ test('writes header with ligatures when enabled', () => {
+ const ttf = path.join(tmpDir, 'FiraCode-Regular.ttf');
+ fs.writeFileSync(ttf, 'fake');
+ const out = buildPdfFontHeader({ monospaceFont: 'fira-code', monospaceLigatures: true }, ttf, 'Fira Code');
+ const content = fs.readFileSync(out.headerPath, 'utf-8');
+ expect(content).toContain('Ligatures=TeX');
+ });
+
+ test('header is written under os.tmpdir', () => {
+ const ttf = path.join(tmpDir, 'JetBrainsMono-Regular.ttf');
+ fs.writeFileSync(ttf, 'fake');
+ const out = buildPdfFontHeader({ monospaceFont: 'jetbrains-mono', monospaceLigatures: false }, ttf, 'JetBrains Mono');
+ expect(out.headerPath.startsWith(os.tmpdir())).toBe(true);
+ });
+
+ test('throws if ttfPath does not exist', () => {
+ expect(() =>
+ buildPdfFontHeader({ monospaceFont: 'jetbrains-mono', monospaceLigatures: false }, '/nonexistent.ttf', 'JetBrains Mono')
+ ).toThrow(/TTF/);
+ });
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `npm test -- tests/unit/main/monospace/PdfFontHeader.test.js`
+Expected: FAIL — module not found.
+
+- [ ] **Step 3: Implement**
+
+```js
+// src/main/PdfFontHeader.js
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+function buildPdfFontHeader(settings, ttfPath, fontFamily) {
+ if (!ttfPath || !fs.existsSync(ttfPath)) {
+ throw new Error(`PdfFontHeader: TTF not found at ${ttfPath}`);
+ }
+ const ligatures = !!(settings && settings.monospaceLigatures === true);
+ const lines = [
+ `\\setmonofont[Path = ${path.dirname(ttfPath)}/,`,
+ ` Extension = .ttf,`,
+ ` UprightFont = ${path.basename(ttfPath)},`,
+ ` BoldFont = ${path.basename(ttfPath).replace('Regular', 'Bold')},`,
+ ligatures ? ' Ligatures = TeX,' : '',
+ ` Scale = 0.9]`,
+ `{${fontFamily}}`,
+ ].filter(Boolean);
+ const headerPath = path.join(os.tmpdir(), `monospace-pdf-${Date.now()}-${process.pid}.tex`);
+ fs.writeFileSync(headerPath, lines.join('\n'), 'utf-8');
+ return { headerPath, familyName: fontFamily };
+}
+
+module.exports = { buildPdfFontHeader };
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `npm test -- tests/unit/main/monospace/PdfFontHeader.test.js`
+Expected: PASS — 4 tests pass.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/main/PdfFontHeader.js tests/unit/main/monospace/PdfFontHeader.test.js
+git commit -m "feat(monospace): add xelatex fontspec header builder"
+```
+
+---
+
+## Task 4: DocxFontEmbedder
+
+**Files:**
+- Create: `src/main/DocxFontEmbedder.js`
+- Create: `tests/unit/main/monospace/DocxFontEmbedder.test.js`
+
+- [ ] **Step 1: Write failing test**
+
+```js
+// tests/unit/main/monospace/DocxFontEmbedder.test.js
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const JSZip = require('jszip');
+
+const { embedDocxFont } = require('../../../../src/main/DocxFontEmbedder');
+
+async function makeMinimalDocx(outPath) {
+ const zip = new JSZip();
+ zip.file('[Content_Types].xml', '');
+ zip.file('_rels/.rels', '');
+ zip.file('word/document.xml', '');
+ const buf = await zip.generateAsync({ type: 'nodebuffer' });
+ fs.writeFileSync(outPath, buf);
+}
+
+describe('DocxFontEmbedder', () => {
+ let tmpDir;
+ beforeEach(() => { tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mono-docx-')); });
+ afterEach(() => { fs.rmSync(tmpDir, { recursive: true, force: true }); });
+
+ test('embeds TTF into word/fonts and updates rels', async () => {
+ const input = path.join(tmpDir, 'in.docx');
+ const output = path.join(tmpDir, 'out.docx');
+ const ttf = path.join(tmpDir, 'JetBrainsMono-Regular.ttf');
+ await makeMinimalDocx(input);
+ fs.writeFileSync(ttf, Buffer.from([0x01, 0x00, 0x00, 0x00, 0x00]));
+
+ await embedDocxFont(input, output, ttf, 'JetBrainsMono');
+
+ const result = await JSZip.loadAsync(fs.readFileSync(output));
+ const fontFiles = Object.keys(result.files).filter((n) => n.startsWith('word/fonts/'));
+ expect(fontFiles.length).toBeGreaterThan(0);
+ const rels = result.file('word/_rels/fontTable.xml.rels');
+ expect(rels).toBeTruthy();
+ const relsContent = await rels.async('string');
+ expect(relsContent).toContain('.ttf');
+ });
+
+ test('returns rejected promise for invalid docx input', async () => {
+ const input = path.join(tmpDir, 'invalid.docx');
+ const output = path.join(tmpDir, 'out.docx');
+ const ttf = path.join(tmpDir, 'JetBrainsMono-Regular.ttf');
+ fs.writeFileSync(input, Buffer.from('not a docx'));
+ fs.writeFileSync(ttf, Buffer.from([0x01]));
+ await expect(embedDocxFont(input, output, ttf, 'JetBrainsMono')).rejects.toThrow();
+ });
+
+ test('throws if ttf missing', async () => {
+ const input = path.join(tmpDir, 'in.docx');
+ const output = path.join(tmpDir, 'out.docx');
+ await makeMinimalDocx(input);
+ await expect(embedDocxFont(input, output, '/nope.ttf', 'JetBrainsMono')).rejects.toThrow(/TTF/);
+ });
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `npm test -- tests/unit/main/monospace/DocxFontEmbedder.test.js`
+Expected: FAIL — module not found.
+
+- [ ] **Step 3: Implement**
+
+```js
+// src/main/DocxFontEmbedder.js
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const JSZip = require('jszip');
+
+const FONT_TABLE_PATH = 'word/fontTable.xml';
+const FONT_TABLE_RELS_PATH = 'word/_rels/fontTable.xml.rels';
+
+function fontTableXml(family) {
+ return `
+
+
+
+
+
+
+
+
+`;
+}
+
+function fontTableRels(fontFilename) {
+ return `
+
+
+`;
+}
+
+async function embedDocxFont(inputDocxPath, outputDocxPath, ttfPath, fontFamily) {
+ if (!ttfPath || !fs.existsSync(ttfPath)) {
+ throw new Error(`DocxFontEmbedder: TTF not found at ${ttfPath}`);
+ }
+ const inputBytes = fs.readFileSync(inputDocxPath);
+ const zip = await JSZip.loadAsync(inputBytes);
+ const safeFamily = String(fontFamily).replace(/[^A-Za-z0-9]/g, '');
+ const fontFilename = `${safeFamily}.ttf`;
+ const fontBytes = fs.readFileSync(ttfPath);
+ zip.file(`word/fonts/${fontFilename}`, fontBytes);
+ zip.file(FONT_TABLE_PATH, fontTableXml(safeFamily));
+ zip.file(FONT_TABLE_RELS_PATH, fontTableRels(fontFilename));
+ const out = await zip.generateAsync({ type: 'nodebuffer' });
+ fs.writeFileSync(outputDocxPath, out);
+}
+
+module.exports = { embedDocxFont };
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `npm test -- tests/unit/main/monospace/DocxFontEmbedder.test.js`
+Expected: PASS — 3 tests pass.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/main/DocxFontEmbedder.js tests/unit/main/monospace/DocxFontEmbedder.test.js
+git commit -m "feat(monospace): embed TTF into pandoc-generated DOCX"
+```
+
+---
+
+## Task 5: EpubFontEmbedder
+
+**Files:**
+- Create: `src/main/EpubFontEmbedder.js`
+- Create: `tests/unit/main/monospace/EpubFontEmbedder.test.js`
+
+- [ ] **Step 1: Write failing test**
+
+```js
+// tests/unit/main/monospace/EpubFontEmbedder.test.js
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const JSZip = require('jszip');
+
+const { withEpubEmbedFontArgs, embedEpubFont } = require('../../../../src/main/EpubFontEmbedder');
+
+async function makeMinimalEpub(outPath) {
+ const zip = new JSZip();
+ zip.file('META-INF/container.xml', '');
+ zip.file('OEBPS/content.opf', '');
+ fs.writeFileSync(outPath, await zip.generateAsync({ type: 'nodebuffer' }));
+}
+
+describe('EpubFontEmbedder', () => {
+ let tmpDir;
+ beforeEach(() => { tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mono-epub-')); });
+ afterEach(() => { fs.rmSync(tmpDir, { recursive: true, force: true }); });
+
+ test('withEpubEmbedFontArgs prepends --epub-embed-font', () => {
+ const args = withEpubEmbedFontArgs(['-o', 'out.epub', 'in.md'], '/tmp/font.ttf', 'JetBrains Mono');
+ expect(args).toContain('--epub-embed-font=/tmp/font.ttf');
+ expect(args.indexOf('--epub-embed-font=/tmp/font.ttf')).toBeLessThan(args.indexOf('-o'));
+ });
+
+ test('embedEpubFont adds font to OEBPS and updates manifest', async () => {
+ const epub = path.join(tmpDir, 'book.epub');
+ const ttf = path.join(tmpDir, 'JetBrainsMono-Regular.ttf');
+ await makeMinimalEpub(epub);
+ fs.writeFileSync(ttf, Buffer.from([0x01, 0x00]));
+
+ await embedEpubFont(epub, ttf, 'JetBrains Mono');
+
+ const zip = await JSZip.loadAsync(fs.readFileSync(epub));
+ const fontFile = zip.file('OEBPS/JetBrainsMono-Regular.ttf');
+ expect(fontFile).toBeTruthy();
+ const opf = await zip.file('OEBPS/content.opf').async('string');
+ expect(opf).toContain('JetBrainsMono-Regular.ttf');
+ });
+
+ test('embedEpubFont rejects missing TTF', async () => {
+ const epub = path.join(tmpDir, 'book.epub');
+ await makeMinimalEpub(epub);
+ await expect(embedEpubFont(epub, '/nope.ttf', 'JetBrains Mono')).rejects.toThrow(/TTF/);
+ });
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `npm test -- tests/unit/main/monospace/EpubFontEmbedder.test.js`
+Expected: FAIL — module not found.
+
+- [ ] **Step 3: Implement**
+
+```js
+// src/main/EpubFontEmbedder.js
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const JSZip = require('jszip');
+
+function withEpubEmbedFontArgs(pandocArgs, ttfPath, _fontFamily) {
+ return [`--epub-embed-font=${ttfPath}`, ...pandocArgs];
+}
+
+async function embedEpubFont(epubPath, ttfPath, fontFamily) {
+ if (!ttfPath || !fs.existsSync(ttfPath)) {
+ throw new Error(`EpubFontEmbedder: TTF not found at ${ttfPath}`);
+ }
+ const bytes = fs.readFileSync(epubPath);
+ const zip = await JSZip.loadAsync(bytes);
+ const ttfBytes = fs.readFileSync(ttfPath);
+ const fontName = path.basename(ttfPath);
+ zip.file(`OEBPS/${fontName}`, ttfBytes);
+ const opfPath = 'OEBPS/content.opf';
+ const opfFile = zip.file(opfPath);
+ if (!opfFile) {
+ fs.writeFileSync(epubPath, await zip.generateAsync({ type: 'nodebuffer' }));
+ return;
+ }
+ let opf = await opfFile.async('string');
+ const manifestEntry = `