mdv-live 0.5.5 → 0.5.8

package/src/rendering/marpNoteWriter.js

@@ -0,0 +1,156 @@
+/**
+ * Speaker-note rewriter — pure function operating on a parsed deck.
+ *
+ * Strategy:
+ *   - At most ONE speaker note per slide is supported by auto-save (see
+ *     Multi-note Guard below). The Plan caps editing to single-note slides
+ *     so that the join-of-comments string round-trips losslessly.
+ *   - Rewriting replaces or removes the existing single note token's line
+ *     range, or appends a new comment if the slide has no note.
+ *   - Marp directives are left untouched (they are not in `classifiedNotes`,
+ *     so `pickNoteComments` filters them out).
+ */
+
+import { pickNoteComments } from './marpitAdapter.js';
+import { lineRangeToOffsets } from '../utils/lineMath.js';
+import { mkError } from '../utils/errors.js';
+
+/** Speaker notes are stored as HTML comments. Reject text that would close
+ *  or invalidate the comment on the markdown side. */
+export function validateNoteText(text) {
+  if (typeof text !== 'string') return 'note must be a string';
+  if (text.length > 64 * 1024) return 'note exceeds 64 KiB';
+  if (/\u0000/.test(text)) return 'note contains NUL';
+  if (text.includes('-->')) return 'note cannot contain "-->"';
+  if (text.includes('--!>')) return 'note cannot contain "--!>"';
+  if (/--\s*$/.test(text)) return 'note cannot end with "--"';
+  return null;
+}
+
+export function formatNoteComment(text, lineEnding) {
+  const trimmed = text.trim();
+  if (trimmed.includes('\n') || trimmed.includes('\r')) {
+    // Normalise embedded newlines to the file's line ending.
+    const normalised = trimmed.replace(/\r\n|\r|\n/g, lineEnding);
+    return '<!--' + lineEnding + normalised + lineEnding + '-->';
+  }
+  return '<!-- ' + trimmed + ' -->';
+}
+
+/**
+ * Find the line index where a new note comment should be inserted into a
+ * slide that has no existing note. Walks backwards from `endLine - 1` and
+ * returns the line *after* the last non-blank line.
+ */
+function findInsertionLine(rawSource, lineStarts, totalLines, range) {
+  let line = Math.min(range.endLine, totalLines) - 1;
+  while (line > range.startLine) {
+    const start = lineStarts[line];
+    const end = line + 1 < lineStarts.length ? lineStarts[line + 1] : rawSource.length;
+    const text = rawSource.slice(start, end);
+    if (text.replace(/\r?\n$/, '').trim().length > 0) {
+      return line + 1; // insert immediately after this content line
+    }
+    line--;
+  }
+  return range.startLine + 1; // default: just after the slide's first line
+}
+
+/**
+ * @param {string} rawSource
+ * @param {number} slideIndex
+ * @param {string} newNote  empty string == remove
+ * @param {ReturnType<import('./marpitAdapter.js').parseDeck>} parsed
+ * @param {ReturnType<import('../utils/lineMath.js').analyseSource>} lineInfo
+ * @returns {{ source: string, changed: boolean }}
+ */
+export function rewriteSlideNote(rawSource, slideIndex, newNote, parsed, lineInfo) {
+  if (slideIndex < 0 || slideIndex >= parsed.slideCount) {
+    throw mkError('OUT_OF_RANGE', `slideIndex ${slideIndex} out of range`);
+  }
+  const reason = validateNoteText(newNote);
+  if (reason) throw mkError('INVALID_NOTE', reason);
+
+  const noteStrings = parsed.classifiedNotes[slideIndex] || [];
+  const candidates = parsed.commentsBySlide[slideIndex] || [];
+  const noteComments = pickNoteComments(candidates, noteStrings);
+
+  // Multi-note Guard (defense-in-depth): even if the client misbehaves and
+  // POSTs against a slide that has multiple speaker notes, refuse — joining
+  // them into a single string is lossy round-trip.
+  if (noteComments.length > 1) {
+    throw mkError(
+      'MULTI_NOTE_READONLY',
+      'slide has multiple speaker notes; auto-save disabled'
+    );
+  }
+
+  const totalLines = parsed.slideRanges[parsed.slideCount - 1].endLine;
+  const { lineStarts } = lineInfo;
+  const lineEnding = lineInfo.lineEnding;
+  const trimmedNew = newNote.trim();
+
+  if (trimmedNew === '' && noteComments.length === 0) {
+    return { source: rawSource, changed: false };
+  }
+
+  if (trimmedNew === '') {
+    // Remove the single existing note token, including the line break that
+    // delimits it. Does NOT touch surrounding code blocks.
+    const c = noteComments[0];
+    const { startOffset, endOffset } = lineRangeToOffsets(
+      lineStarts, totalLines, rawSource.length, c.startLine, c.endLine
+    );
+    return {
+      source: rawSource.slice(0, startOffset) + rawSource.slice(endOffset),
+      changed: true
+    };
+  }
+
+  const formatted = formatNoteComment(trimmedNew, lineEnding);
+
+  if (noteComments.length === 1) {
+    // Replace the single existing comment's line range.
+    const c = noteComments[0];
+    const { startOffset, endOffset } = lineRangeToOffsets(
+      lineStarts, totalLines, rawSource.length, c.startLine, c.endLine
+    );
+    // Preserve the trailing newline of the line we replace, if any.
+    const preserveTrailingNewline = endOffset < rawSource.length
+      || /(?:\r\n|\r|\n)$/.test(rawSource.slice(startOffset, endOffset));
+    return {
+      source:
+        rawSource.slice(0, startOffset) +
+        formatted +
+        (preserveTrailingNewline ? lineEnding : '') +
+        rawSource.slice(endOffset),
+      changed: true
+    };
+  }
+
+  // Insert a new comment at the slide's last non-blank line + 1.
+  const range = parsed.slideRanges[slideIndex];
+  const insertLine = findInsertionLine(rawSource, lineStarts, totalLines, range);
+  const insertOffset = insertLine < lineStarts.length
+    ? lineStarts[insertLine]
+    : rawSource.length;
+
+  const inserted = formatted + lineEnding + lineEnding;
+  // If the slide had no trailing blank line, we need to introduce a blank
+  // line between content and our comment.
+  const needsLeadingBlank = (() => {
+    if (insertOffset === 0) return false;
+    const before = rawSource.slice(0, insertOffset);
+    return !/(?:\r\n\r\n|\n\n|\r\r)$/.test(before);
+  })();
+  const prefix = needsLeadingBlank ? lineEnding : '';
+
+  return {
+    source:
+      rawSource.slice(0, insertOffset) +
+      prefix +
+      inserted +
+      rawSource.slice(insertOffset),
+    changed: true
+  };
+}

package/src/rendering/marpitAdapter.js

@@ -0,0 +1,139 @@
+/**
+ * MarpitTokenAdapter — Marp/Marpit のパーサ出力を正規化する 1 箇所のラッパ。
+ *
+ * Slide 範囲・speaker note 位置の特定はすべてこのモジュール経由で行う。
+ * 直接 marp.markdown.parse() / marp.render() を別の場所から呼ばない。
+ *
+ * 契約 (tests/test-marpit-adapter.js で snapshot 凍結):
+ *  - marpit_slide_open.map === [startLine, endLine]
+ *  - marpit_comment.content は両側 trim 済み
+ *  - marpit_comment.map === [startLine, endLineExclusive]
+ *  - marpit_slide_close.map は null になり得る
+ *  - BOM 付き入力で slide_open.map[0] === 0
+ *  - render(rawSource).comments は 2D 配列で directive を除外済み
+ */
+
+import { Marp } from '@marp-team/marp-core';
+import { mkError } from '../utils/errors.js';
+
+const marp = new Marp({
+  html: true,
+  math: true,
+  markdown: { html: true, breaks: false, linkify: true }
+});
+marp.markdown.disable('code');
+
+/**
+ * Marp deck を解析し、slide 範囲・classified notes・comment 位置を返す。
+ *
+ * @param {string} rawSource
+ * @returns {{
+ *   slideCount: number,
+ *   slideRanges: Array<{startLine: number, endLine: number}>,
+ *   classifiedNotes: string[][],
+ *   commentsBySlide: Array<Array<{content: string, startLine: number, endLine: number}>>,
+ *   notesMultiplicity: number[]
+ * }}
+ * @throws {Error} code='NOT_PARSEABLE' if Marpit returns malformed tokens.
+ */
+export function parseDeck(rawSource) {
+  const env = {};
+  const tokens = marp.markdown.parse(rawSource, env);
+  const { comments: classifiedNotes } = marp.render(rawSource);
+
+  const slideOpens = tokens.filter((t) => t.type === 'marpit_slide_open');
+  for (const t of slideOpens) {
+    if (!t.map) throw mkError('NOT_PARSEABLE', 'slide_open without source map');
+  }
+  const slideStartLines = slideOpens.map((t) => t.map[0]);
+  const totalLines = countLines(rawSource);
+
+  const slideRanges = slideStartLines.map((start, i) => ({
+    startLine: start,
+    endLine: i + 1 < slideStartLines.length ? slideStartLines[i + 1] : totalLines
+  }));
+
+  const commentsBySlide = slideRanges.map(() => []);
+  let cursor = -1;
+  for (const t of tokens) {
+    if (t.type === 'marpit_slide_open') {
+      cursor = slideStartLines.indexOf(t.map[0]);
+      continue;
+    }
+    if (t.type === 'marpit_comment' && cursor >= 0) {
+      if (!t.map) throw mkError('NOT_PARSEABLE', 'marpit_comment without source map');
+      commentsBySlide[cursor].push({
+        content: t.content,
+        startLine: t.map[0],
+        endLine: t.map[1]
+      });
+    }
+  }
+
+  const notesMultiplicity = classifiedNotes.map((arr) => (arr || []).length);
+
+  return {
+    slideCount: slideRanges.length,
+    slideRanges,
+    classifiedNotes,
+    commentsBySlide,
+    notesMultiplicity
+  };
+}
+
+/**
+ * commentsBySlide[i] のうち、classifiedNotes[i] と順序 zip でマッチしたもの
+ * だけを speaker note として返す。directive コメントは classifiedNotes には
+ * 出ないので、自然に除外される。
+ *
+ * @param {Array<{content: string, startLine: number, endLine: number}>} commentsInSlide
+ * @param {string[]} noteStrings
+ * @returns {Array<{content: string, startLine: number, endLine: number}>}
+ * @throws {Error} code='NOT_PARSEABLE' if zip ends with mismatched count.
+ */
+export function pickNoteComments(commentsInSlide, noteStrings) {
+  const notes = [];
+  let cursor = 0;
+  for (const c of commentsInSlide) {
+    if (cursor < noteStrings.length && c.content === noteStrings[cursor]) {
+      notes.push(c);
+      cursor++;
+    }
+  }
+  if (cursor !== noteStrings.length) {
+    throw mkError('NOT_PARSEABLE', 'comment tokens do not match classifiedNotes');
+  }
+  return notes;
+}
+
+/**
+ * markdown-it / marpit の行カウント慣例に整合する line 数を返す。
+ * `t.map` の `endLine` と整合させるため、末尾改行ありなら改行数、なしなら +1。
+ */
+export function countLines(source) {
+  if (source.length === 0) return 0;
+  const newlines = (source.match(/\r\n|\r|\n/g) || []).length;
+  const endsWithNewline = /(?:\r\n|\r|\n)$/.test(source);
+  return endsWithNewline ? newlines : newlines + 1;
+}
+
+/**
+ * Marp 互換 marker (`marp: true` を frontmatter に含むか)。
+ */
+export function isMarp(content) {
+  return /^---\s*\n[\s\S]*?marp:\s*true[\s\S]*?\n---/.test(content);
+}
+
+/**
+ * Render の薄いラッパ（既存呼び出し元との互換用）。
+ */
+export function renderDeck(rawSource) {
+  const { html, css, comments } = marp.render(rawSource);
+  const slideCount = (html.match(/<section[^>]*>/g) || []).length;
+  const notes = (comments || []).map((arr) =>
+    Array.isArray(arr) ? arr.join('\n\n').trim() : ''
+  );
+  while (notes.length < slideCount) notes.push('');
+  const notesMultiplicity = (comments || []).map((arr) => (arr || []).length);
+  return { html, css, slideCount, notes, notesMultiplicity };
+}

package/src/server.js

@@ -10,11 +10,13 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 
 import { setupFileRoutes } from './api/file.js';
+import { setupMarpNoteRoutes } from './api/marpNote.js';
 import { setupPdfRoutes } from './api/pdf.js';
 import { setupTreeRoutes } from './api/tree.js';
 import { setupUploadRoutes } from './api/upload.js';
 import { setupWatcher } from './watcher.js';
 import { setupWebSocket } from './websocket.js';
+import { sweepStaleTemps } from './utils/atomicWrite.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const STATIC_DIR = path.join(__dirname, 'static');
@@ -26,11 +28,12 @@ const { version: VERSION } = JSON.parse(
  * Setup API routes for the Express app
  * @param {express.Application} app - Express application instance
  */
-function setupApiRoutes(app) {
+function setupApiRoutes(app, options) {
   setupTreeRoutes(app);
   setupFileRoutes(app);
   setupUploadRoutes(app);
   setupPdfRoutes(app);
+  setupMarpNoteRoutes(app, { port: options.port });
 
   app.get('/api/info', (req, res) => {
     res.json({
@@ -61,11 +64,31 @@ export function createMdvServer(options) {
 
   app.locals.rootDir = path.resolve(rootDir);
 
-  app.use(express.json());
-  app.use(express.urlencoded({ extended: true }));
+  app.use(express.json({ limit: '128kb' }));
+  app.use(express.urlencoded({ extended: true, limit: '128kb' }));
   app.use('/static', express.static(STATIC_DIR));
 
-  setupApiRoutes(app);
+  setupApiRoutes(app, { port });
+
+  // Body-parser error handler (size limit, malformed JSON) must come AFTER
+  // the routes so route-level errors fall through to the default handler.
+  app.use((err, req, res, next) => {
+    if (err && err.type === 'entity.too.large') {
+      return res.status(413).json({
+        ok: false,
+        code: 'PAYLOAD_TOO_LARGE',
+        error: 'request body exceeds limit'
+      });
+    }
+    if (err && err.type === 'entity.parse.failed') {
+      return res.status(400).json({
+        ok: false,
+        code: 'INVALID_NOTE',
+        error: 'malformed JSON'
+      });
+    }
+    next(err);
+  });
 
   // Catch-all: serve index.html for SPA (path-based routing)
   // Express matches routes in order, so API/static routes above take priority
@@ -80,6 +103,8 @@ export function createMdvServer(options) {
   app.locals.wss = wss;
 
   function start() {
+    // Best-effort sweep of stale temp files left by a previous crashed write.
+    sweepStaleTemps(app.locals.rootDir).catch(() => {});
     return new Promise((resolve) => {
       server.listen(port, () => {
         console.log(`MDV server running at http://localhost:${port}`);