mdv-live 0.5.5 → 0.5.8

package/src/api/marpNote/guards.js

@@ -0,0 +1,79 @@
+/**
+ * Common guards / preconditions for the marpNote endpoints.
+ *
+ * Each function returns an Error (with `.code`) on rejection or `null` on
+ * success. The caller then uses `sendError(res, err)` from utils/errors.js.
+ */
+
+import { mkError } from '../../utils/errors.js';
+import { validateNoteText } from '../../rendering/marpNoteWriter.js';
+
+const MAX_SLIDE_INDEX = 1000;
+
+export function buildAllowedHosts(port) {
+  return [`localhost:${port}`, `127.0.0.1:${port}`];
+}
+
+/** Origin / Sec-Fetch-Site judgement (CSRF / DNS rebinding defence). */
+export function checkOrigin(req, allowedHosts) {
+  const origin = req.get('Origin');
+  if (origin) {
+    for (const host of allowedHosts) {
+      if (origin === `http://${host}`) return null;
+    }
+    return mkError('ORIGIN_REJECTED', 'origin not allowed');
+  }
+  if (req.get('Sec-Fetch-Site') === 'same-origin') return null;
+  return mkError('ORIGIN_REJECTED', 'origin not allowed');
+}
+
+export function checkHost(req, allowedHosts) {
+  const host = req.get('Host');
+  if (host && allowedHosts.includes(host)) return null;
+  return mkError('ORIGIN_REJECTED', 'host header not allowed');
+}
+
+export function checkJsonContent(req) {
+  const ct = (req.get('Content-Type') || '').split(';')[0].trim().toLowerCase();
+  if (ct === 'application/json') return null;
+  return mkError('UNSUPPORTED_MEDIA_TYPE', 'Content-Type must be application/json');
+}
+
+export function checkIfMatch(req) {
+  if (req.get('If-Match')) return null;
+  return mkError('IF_MATCH_REQUIRED', 'If-Match header required');
+}
+
+export function parseSlideIndex(req) {
+  const n = Number(req.params.slideIndex);
+  if (!Number.isInteger(n) || n < 0 || n >= MAX_SLIDE_INDEX) {
+    return { error: mkError('OUT_OF_RANGE', 'slideIndex out of range') };
+  }
+  return { value: n };
+}
+
+export function sanitiseRelativePath(decoded) {
+  // Express already decoded :encodedPath route param; do not decode again.
+  if (typeof decoded !== 'string') return null;
+  if (decoded.length === 0 || decoded.length > 1024) return null;
+  if (decoded.includes('\0')) return null;
+  return decoded;
+}
+
+/** Pull and validate the `note` field from the request body. */
+export function extractNote(req) {
+  const body = req.body;
+  if (!body || typeof body !== 'object') {
+    return { error: mkError('INVALID_NOTE', 'body must be JSON object') };
+  }
+  if (!Object.prototype.hasOwnProperty.call(body, 'note')) {
+    return { error: mkError('INVALID_NOTE', 'note required') };
+  }
+  const note = body.note;
+  if (typeof note !== 'string') {
+    return { error: mkError('INVALID_NOTE', 'note must be string') };
+  }
+  const reason = validateNoteText(note);
+  if (reason) return { error: mkError('INVALID_NOTE', reason) };
+  return { value: note };
+}

package/src/api/marpNote/handleGet.js

@@ -0,0 +1,65 @@
+/**
+ * GET /api/marp/decks/:encodedPath  — read-only deck snapshot.
+ */
+
+import { parseDeck, isMarp, renderDeck } from '../../rendering/marpitAdapter.js';
+import { analyseSource } from '../../utils/lineMath.js';
+import { mkError, sendError } from '../../utils/errors.js';
+import { makeEtag } from '../../utils/etag.js';
+import { checkHost, sanitiseRelativePath } from './guards.js';
+import { readDeckSafely } from './readDeck.js';
+
+export function makeGetHandler({ rootDir, allowedHosts }) {
+  return async function handleGet(req, res) {
+    const hostErr = checkHost(req, allowedHosts);
+    if (hostErr) return sendError(res, hostErr);
+    res.setHeader('Cache-Control', 'no-store');
+
+    const rel = sanitiseRelativePath(req.params.encodedPath);
+    if (!rel) return sendError(res, mkError('PATH_INVALID', 'invalid path'));
+
+    let deck;
+    try {
+      deck = await readDeckSafely(rootDir(), rel);
+    } catch (err) {
+      if (err.code === 'PATH_INVALID' || err.code === 'NOT_FOUND') return sendError(res, err);
+      console.error('marpNote GET read error:', err);
+      return sendError(res, mkError('READ_FAILED', 'read failed', { cause: err }));
+    }
+
+    if (!isMarp(deck.rawSource)) {
+      return sendError(res, mkError('NOT_MARP', 'not a Marp file'));
+    }
+
+    const lineInfo = analyseSource(deck.rawSource);
+    const etag = makeEtag(deck.rawSource);
+
+    let parsed;
+    try {
+      parsed = parseDeck(deck.rawSource);
+    } catch (err) {
+      // Adapter contract broken — degrade to read-only (etag null).
+      return res.json({
+        ok: true,
+        degraded: true,
+        etag: null,
+        slideCount: 0,
+        notes: [],
+        notesMultiplicity: [],
+        lineEnding: lineInfo.lineEnding,
+        hasBom: lineInfo.hasBom
+      });
+    }
+
+    const { notes } = renderDeck(deck.rawSource);
+    return res.json({
+      ok: true,
+      etag,
+      slideCount: parsed.slideCount,
+      notes,
+      notesMultiplicity: parsed.notesMultiplicity,
+      lineEnding: lineInfo.lineEnding,
+      hasBom: lineInfo.hasBom
+    });
+  };
+}

package/src/api/marpNote/handlePut.js

@@ -0,0 +1,162 @@
+/**
+ * PUT /api/marp/decks/:encodedPath/slides/:slideIndex/note
+ *
+ * Optimistic locking via If-Match (sha256 etag) + per-path async mutex
+ * for read-check-write atomicity within this process.
+ */
+
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+
+import { parseDeck, isMarp, renderDeck } from '../../rendering/marpitAdapter.js';
+import { rewriteSlideNote } from '../../rendering/marpNoteWriter.js';
+import { analyseSource } from '../../utils/lineMath.js';
+import { atomicWrite } from '../../utils/atomicWrite.js';
+import { mkError, sendError } from '../../utils/errors.js';
+import { makeEtag } from '../../utils/etag.js';
+import { withLock } from '../../concurrency/pathLock.js';
+import {
+  checkHost, checkOrigin, checkJsonContent, checkIfMatch,
+  parseSlideIndex, sanitiseRelativePath, extractNote
+} from './guards.js';
+import { readDeckSafely } from './readDeck.js';
+
+export function makePutHandler({ rootDir, allowedHosts }) {
+  return async function handlePut(req, res) {
+    const guards = [
+      checkHost(req, allowedHosts),
+      checkOrigin(req, allowedHosts),
+      checkJsonContent(req),
+      checkIfMatch(req)
+    ];
+    for (const err of guards) if (err) return sendError(res, err);
+
+    const idx = parseSlideIndex(req);
+    if (idx.error) return sendError(res, idx.error);
+    const rel = sanitiseRelativePath(req.params.encodedPath);
+    if (!rel) return sendError(res, mkError('PATH_INVALID', 'invalid path'));
+    const noteIn = extractNote(req);
+    if (noteIn.error) return sendError(res, noteIn.error);
+
+    const ifMatch = req.get('If-Match');
+
+    // Resolve realpath BEFORE acquiring the lock so requests against the
+    // same file (via different relative paths) share the same lock key.
+    let earlyDeck;
+    try {
+      earlyDeck = await readDeckSafely(rootDir(), rel);
+    } catch (err) {
+      if (err.code === 'PATH_INVALID' || err.code === 'NOT_FOUND') return sendError(res, err);
+      console.error('marpNote PUT read error:', err);
+      return sendError(res, mkError('READ_FAILED', 'read failed', { cause: err }));
+    }
+
+    // Trampoline: handle the realpath-retarget retry OUTSIDE of any
+    // existing lock. If we re-acquired a new lock while still holding the
+    // old one, two opposite retargets could deadlock. Instead we let the
+    // first attempt return a sentinel, release the old lock by exiting
+    // its withLock callback, then re-acquire on the new realpath.
+    let attemptDeck = earlyDeck;
+    for (let i = 0; i < 2; i++) {
+      const result = await withLock(attemptDeck.realPath, () =>
+        performNoteUpdate({
+          req, res, rootDir, rel,
+          slideIndex: idx.value,
+          note: noteIn.value,
+          ifMatch,
+          earlyDeck: attemptDeck
+        })
+      );
+      if (!result || !result.retargetTo) return result;
+      attemptDeck = result.retargetTo;
+    }
+    return sendError(res, mkError('PATH_INVALID', 'realpath unstable across retries'));
+  };
+}
+
+async function performNoteUpdate({ req, res, rootDir, rel, slideIndex, note, ifMatch, earlyDeck }) {
+  // Re-read inside the lock so the etag check sees writes by predecessors.
+  let deck;
+  try {
+    deck = await readDeckSafely(rootDir(), rel);
+  } catch (err) {
+    if (err.code === 'PATH_INVALID' || err.code === 'NOT_FOUND') return sendError(res, err);
+    console.error('marpNote PUT re-read error:', err);
+    return sendError(res, mkError('READ_FAILED', 'read failed', { cause: err }));
+  }
+
+  if (!isMarp(deck.rawSource)) {
+    return sendError(res, mkError('NOT_MARP', 'not a Marp file'));
+  }
+
+  // If the symlink target changed between pre-lock and in-lock reads, the
+  // mutex we hold doesn't cover the deck we'd write. Return a sentinel so
+  // the caller can release THIS lock first and re-acquire on the new
+  // realpath (preventing nested-lock deadlocks under opposite retargets).
+  if (deck.realPath !== earlyDeck.realPath) {
+    return { retargetTo: deck };
+  }
+
+  const currentEtag = makeEtag(deck.rawSource);
+  if (ifMatch !== currentEtag) {
+    return res.status(412).json({ ok: false, code: 'STALE', currentEtag });
+  }
+
+  let parsed;
+  try {
+    parsed = parseDeck(deck.rawSource);
+  } catch (err) {
+    return sendError(res, mkError('NOT_PARSEABLE', 'failed to parse Marp deck', { cause: err }));
+  }
+
+  const lineInfo = analyseSource(deck.rawSource);
+  let result;
+  try {
+    result = rewriteSlideNote(deck.rawSource, slideIndex, note, parsed, lineInfo);
+  } catch (err) {
+    return sendError(res, err.code ? err : mkError('WRITE_FAILED', err.message, { cause: err }));
+  }
+
+  // Defensive realpath re-resolve (TOCTOU best-effort).
+  // Compare against the realpath observed by the IN-LOCK re-read (`deck`),
+  // NOT the pre-lock read (`earlyDeck`). Otherwise a swap that happens
+  // between the pre-lock and in-lock reads, then reverts before this
+  // check, would slip past — and we'd write contents parsed from the
+  // wrong file into the original path.
+  let realAtWrite;
+  try {
+    realAtWrite = await fs.realpath(path.resolve(rootDir(), rel));
+  } catch (err) {
+    console.error('marpNote PUT realpath at write:', err);
+    return sendError(res, mkError('WRITE_FAILED', 'realpath failed', { cause: err }));
+  }
+  if (realAtWrite !== deck.realPath) {
+    return sendError(res, mkError('PATH_INVALID', 'path resolution changed during request'));
+  }
+
+  try {
+    await atomicWrite(realAtWrite, result.source, deck.stat);
+  } catch (err) {
+    return sendError(res, err.code ? err : mkError('WRITE_FAILED', err.message, { cause: err }));
+  }
+
+  // Re-parse so the client refreshes notes / notesMultiplicity / etag in
+  // one round-trip (no need to wait for the watcher event).
+  let newParsed;
+  try {
+    newParsed = parseDeck(result.source);
+  } catch (err) {
+    return sendError(res, mkError('NOT_PARSEABLE', 'failed to re-parse after rewrite', { cause: err }));
+  }
+  const rendered = renderDeck(result.source);
+
+  return res.json({
+    ok: true,
+    etag: makeEtag(result.source),
+    normalizedNote: note,
+    slideCount: newParsed.slideCount,
+    notes: rendered.notes,
+    notesMultiplicity: newParsed.notesMultiplicity,
+    source: result.source
+  });
+}

package/src/api/marpNote/readDeck.js

@@ -0,0 +1,42 @@
+/**
+ * Resolve and read a deck file safely (path-traversal + symlink-following
+ * defenses). Returns { rawSource, stat, realPath }. Throws coded errors:
+ *   PATH_INVALID / NOT_FOUND.
+ */
+
+import * as fs from 'node:fs/promises';
+import { constants as fsConstants } from 'node:fs';
+import * as path from 'node:path';
+import { validatePath, validatePathReal } from '../../utils/path.js';
+import { mkError } from '../../utils/errors.js';
+
+export async function readDeckSafely(rootDir, relativePath) {
+  if (!validatePath(relativePath, rootDir)) throw mkError('PATH_INVALID');
+  const ok = await validatePathReal(relativePath, rootDir);
+  if (!ok) throw mkError('PATH_INVALID');
+
+  const fullPath = path.resolve(rootDir, relativePath);
+  let realPath;
+  try {
+    realPath = await fs.realpath(fullPath);
+  } catch (err) {
+    if (err.code === 'ENOENT') throw mkError('NOT_FOUND');
+    throw err;
+  }
+
+  let fd;
+  try {
+    fd = await fs.open(realPath, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
+  } catch (err) {
+    if (err.code === 'ELOOP') throw mkError('PATH_INVALID', 'symlink at terminal');
+    if (err.code === 'ENOENT') throw mkError('NOT_FOUND');
+    throw err;
+  }
+  try {
+    const stat = await fd.stat();
+    const rawSource = await fd.readFile('utf-8');
+    return { rawSource, stat, realPath };
+  } finally {
+    await fd.close();
+  }
+}

package/src/api/marpNote.js

@@ -0,0 +1,40 @@
+/**
+ * /api/marp/decks/:encodedPath endpoint family — orchestration only.
+ *
+ * Routing:
+ *   GET    /api/marp/decks/:encodedPath              → handleGet
+ *   PUT    /api/marp/decks/:encodedPath/slides/:N/note  → handlePut
+ *   OPTIONS  ...                                     → CORS preflight (same-origin only)
+ */
+
+import { sendError } from '../utils/errors.js';
+import { buildAllowedHosts, checkHost, checkOrigin } from './marpNote/guards.js';
+import { makeGetHandler } from './marpNote/handleGet.js';
+import { makePutHandler } from './marpNote/handlePut.js';
+
+function makeOptionsHandler(allowedHosts) {
+  return function handleOptions(req, res) {
+    const hostErr = checkHost(req, allowedHosts);
+    if (hostErr) return sendError(res, hostErr);
+    const originErr = checkOrigin(req, allowedHosts);
+    if (originErr) return sendError(res, originErr);
+    res.setHeader('Access-Control-Allow-Methods', 'GET, PUT, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, If-Match');
+    // Note: deliberately NOT setting Allow-Private-Network; PNA is rejected.
+    return res.status(204).end();
+  };
+}
+
+export function setupMarpNoteRoutes(app, options = {}) {
+  const port = options.port || 8080;
+  const allowedHosts = buildAllowedHosts(port);
+  const rootDir = () => app.locals.rootDir;
+
+  const handleOptions = makeOptionsHandler(allowedHosts);
+  app.options('/api/marp/decks/:encodedPath/slides/:slideIndex/note', handleOptions);
+  app.options('/api/marp/decks/:encodedPath', handleOptions);
+
+  app.get('/api/marp/decks/:encodedPath', makeGetHandler({ rootDir, allowedHosts }));
+  app.put('/api/marp/decks/:encodedPath/slides/:slideIndex/note',
+    makePutHandler({ rootDir, allowedHosts }));
+}

package/src/api/pdf.js

@@ -1,17 +1,17 @@
-/**
- * PDF Export API
- * Uses marp-cli for Marp presentations
- */
-
 import { execFile } from 'child_process';
 import { promisify } from 'util';
 import fs from 'fs/promises';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import os from 'os';
-import { validatePath } from '../utils/path.js';
+import { createRequire } from 'module';
+import { isMarp } from '../rendering/markdown.js';
+import { validatePath, validatePathReal } from '../utils/path.js';
+import { resolvePdfOptions } from '../styles/index.js';
 
 const execFileAsync = promisify(execFile);
+const require = createRequire(import.meta.url);
+const highlightStylesheet = path.resolve(path.dirname(require.resolve('highlight.js')), '..', 'styles', 'atom-one-dark.css');
 const marpBin = path.join(
   path.dirname(fileURLToPath(import.meta.url)),
   '..',
@@ -20,6 +20,53 @@ const marpBin = path.join(
   '.bin',
   'marp'
 );
+const PDF_EXPORT_TIMEOUT_MS = 180000;
+
+/**
+ * Resolve an optional user-selected file path under the server root.
+ * @param {string | undefined} relativePath - Path supplied by the web UI.
+ * @param {string} rootDir - Server root directory.
+ * @returns {Promise<string | null>} Absolute path or null.
+ */
+async function resolveOptionalUserFile(relativePath, rootDir) {
+  if (!relativePath) return null;
+  if (!await validatePathReal(relativePath, rootDir)) {
+    throw new Error(`Access denied: ${relativePath}`);
+  }
+  const fullPath = path.join(rootDir, relativePath);
+  const stat = await fs.stat(fullPath);
+  if (!stat.isFile()) {
+    throw new Error(`Not a file: ${relativePath}`);
+  }
+  return fullPath;
+}
+
+/**
+ * Export a regular markdown document with md-to-pdf.
+ * @param {string} inputPath - Source markdown file.
+ * @param {string} outputPath - Temporary output path.
+ * @param {string | null} stylesheetPath - Optional custom CSS file.
+ * @param {string | null} pdfOptionsPath - Optional PDF options JSON file.
+ * @returns {Promise<void>}
+ */
+async function exportMarkdownPdf(inputPath, outputPath, stylesheetPath, pdfOptionsPath) {
+  const pdfOptions = await resolvePdfOptions(pdfOptionsPath || undefined);
+  const args = ['md-to-pdf', inputPath, '--pdf-options', JSON.stringify(pdfOptions)];
+
+  if (stylesheetPath) {
+    args.push('--stylesheet', highlightStylesheet);
+    args.push('--stylesheet', stylesheetPath);
+    args.push('--highlight-style', 'atom-one-dark');
+  }
+
+  await execFileAsync('npx', args, {
+    cwd: path.dirname(inputPath),
+    timeout: PDF_EXPORT_TIMEOUT_MS,
+  });
+
+  const generatedPdf = inputPath.replace(/\.(md|markdown)$/i, '.pdf');
+  await fs.rename(generatedPdf, outputPath);
+}
 
 /**
  * Setup PDF export routes
@@ -30,7 +77,7 @@ export function setupPdfRoutes(app) {
   const { rootDir } = app.locals;
 
   app.post('/api/pdf/export', async (req, res) => {
-    const { filePath } = req.body;
+    const { filePath, stylePath, pdfOptionsPath } = req.body;
 
     if (!filePath) {
       return res.status(400).json({ error: 'filePath is required' });
@@ -53,7 +100,17 @@ export function setupPdfRoutes(app) {
     const outputFileName = `${baseName}.pdf`;
 
     try {
-      await execFileAsync(marpBin, [fullPath, '-o', outputPath, '--html', '--allow-local-files', '--no-stdin'], { timeout: 60000 });
+      const content = await fs.readFile(fullPath, 'utf-8');
+      if (isMarp(content)) {
+        await execFileAsync(marpBin, [fullPath, '-o', outputPath, '--html', '--allow-local-files', '--no-stdin'], { timeout: PDF_EXPORT_TIMEOUT_MS });
+      } else {
+        const [stylesheetPath, resolvedPdfOptionsPath] = await Promise.all([
+          resolveOptionalUserFile(stylePath, rootDir),
+          resolveOptionalUserFile(pdfOptionsPath, rootDir),
+        ]);
+        await exportMarkdownPdf(fullPath, outputPath, stylesheetPath, resolvedPdfOptionsPath);
+      }
+
       res.download(outputPath, outputFileName, async (err) => {
         if (err) {
           console.error('Download error:', err);

package/src/concurrency/pathLock.js

@@ -0,0 +1,39 @@
+/**
+ * Promise-chain mutex keyed by an arbitrary string.
+ *
+ * Replaces the naive Map-based implementation in api/marpNote.js, which the
+ * concurrency audit identified as susceptible to a thundering-herd race:
+ * with two or more waiters, all of them could observe an empty map after
+ * the previous holder cleared it and then proceed in parallel.
+ *
+ * This implementation chains every new request onto the tail of the
+ * existing promise chain for the key, guaranteeing strict FIFO order.
+ */
+
+const tails = new Map(); // key → Promise (tail of the chain)
+
+export async function withLock(key, fn) {
+  const previous = tails.get(key) || Promise.resolve();
+
+  // Create the next tail BEFORE starting fn so subsequent callers chain after us.
+  let release;
+  const next = new Promise((resolve) => { release = resolve; });
+  tails.set(key, next);
+
+  try {
+    // Wait for the previous chain to settle (success OR failure).
+    await previous.catch(() => {});
+    return await fn();
+  } finally {
+    release();
+    // If we are still the tail, drop the entry so the map doesn't grow
+    // unboundedly. If a subsequent caller has already replaced us as the
+    // tail, leave their entry intact.
+    if (tails.get(key) === next) tails.delete(key);
+  }
+}
+
+/** Test helper. */
+export function _activeKeyCount() {
+  return tails.size;
+}

package/src/rendering/index.js

@@ -7,6 +7,8 @@ import path from 'path';
 import { getFileType } from '../utils/fileTypes.js';
 import { renderMarkdown, isMarp } from './markdown.js';
 import { renderMarp } from './marp.js';
+import { analyseSource } from '../utils/lineMath.js';
+import { makeEtag } from '../utils/etag.js';
 
 /**
  * Escape HTML entities
@@ -99,10 +101,16 @@ export async function renderFile(filePath, relativeDir) {
  */
 function renderMarkdownFile(content, relativeDir) {
   if (isMarp(content)) {
-    const { html, css } = renderMarp(content);
+    const { html, css, notes, notesMultiplicity } = renderMarp(content);
+    const lineInfo = analyseSource(content);
     return {
       content: rewriteMediaPaths(html, relativeDir),
       css,
+      notes,
+      notesMultiplicity,
+      etag: makeEtag(content),
+      lineEnding: lineInfo.lineEnding,
+      hasBom: lineInfo.hasBom,
       raw: content,
       fileType: 'markdown',
       isMarp: true

package/src/rendering/markdown.js

@@ -90,23 +90,16 @@ md.enable('strikethrough');
 // Enable task lists (checkboxes)
 md.use(taskLists);
 
-// Pattern to detect Marp frontmatter (must be at very start of file, not using 'm' flag)
-const MARP_PATTERN = /^---\s*\n[\s\S]*?marp:\s*true[\s\S]*?\n---/;
-
 // Pattern to detect YAML frontmatter at start of file
 const FRONTMATTER_PATTERN = /^---\s*\n([\s\S]*?)\n---\s*(\n|$)/;
 
 // Pattern for Mermaid code blocks
 const MERMAID_PATTERN = /```mermaid\s*\n([\s\S]*?)\n```/g;
 
-/**
- * Check if content is a Marp presentation
- * @param {string} content - Markdown content
- * @returns {boolean}
- */
-export function isMarp(content) {
-  return MARP_PATTERN.test(content);
-}
+// Re-export the SSOT version of isMarp so callers don't import a separate
+// (and previously slightly different) regex from this module.
+import { isMarp } from './marpitAdapter.js';
+export { isMarp };
 
 /**
  * Convert YAML frontmatter to code block for display

package/src/rendering/marp.js

@@ -1,49 +1,28 @@
 /**
- * Marp rendering using @marp-team/marp-core
+ * Marp rendering — thin compat layer over `marpitAdapter.renderDeck`.
+ *
+ * Historically this file owned its own Marp instance. The audit flagged
+ * that as a SOLID/DRY violation: the adapter already owns the canonical
+ * instance, and having two of them risked subtle directive-state drift
+ * between code paths. We now delegate to the adapter.
  *
  * IMPORTANT: Do not modify Marp's HTML output structure.
  * The CSS depends on the exact structure: div.marpit > svg > foreignObject > section
  */
 
-import { Marp } from '@marp-team/marp-core';
-
-// Initialize Marp with full HTML support
-const marp = new Marp({
-  html: true,
-  math: true,
-  markdown: {
-    html: true,
-    breaks: false,
-    linkify: true,
-  }
-});
-
-// Disable indented code blocks (4-space indent → code)
-// This allows HTML with indentation to render properly
-marp.markdown.disable('code');
+import { renderDeck } from './marpitAdapter.js';
 
 /**
- * Render Marp presentation to HTML
+ * Render Marp presentation to HTML.
  * @param {string} content - Markdown content with Marp frontmatter
- * @returns {{ html: string, css: string, slideCount: number }}
+ * @returns {{ html: string, css: string, slideCount: number, notes: string[], notesMultiplicity: number[] }}
  */
 export function renderMarp(content) {
-  const { html, css } = marp.render(content);
-
-  // Count slides by counting <section> tags
-  const slideCount = (html.match(/<section[^>]*>/g) || []).length;
-
-  // Return Marp's HTML output AS-IS to preserve CSS selector compatibility
-  return {
-    html,
-    css,
-    slideCount
-  };
+  return renderDeck(content);
 }
 
 /**
- * Get available Marp themes
- * @returns {string[]} Theme names
+ * Get available Marp themes.
  */
 export function getThemes() {
   return ['default', 'gaia', 'uncover'];