@pep/term-deck 1.0.15 → 1.0.17

package/dist/bin/term-deck.js

@@ -2,16 +2,17 @@
 import { join } from 'path';
 import 'url';
 import { z } from 'zod';
-import 'yaml';
-import 'deepmerge';
-import gradient2 from 'gradient-string';
 import matter from 'gray-matter';
+import { mkdir, writeFile, rm, access, readFile, unlink } from 'fs/promises';
 import fg from 'fast-glob';
-import { mkdir, writeFile, access, readFile, unlink } from 'fs/promises';
-import { mermaidToAscii as mermaidToAscii$1 } from 'mermaid-ascii';
 import blessed from 'neo-blessed';
+import gradient2 from 'gradient-string';
+import 'yaml';
+import 'deepmerge';
+import { mermaidToAscii as mermaidToAscii$1 } from 'mermaid-ascii';
 import figlet from 'figlet';
 import { Command } from 'commander';
+import { tmpdir } from 'os';
 import { execa } from 'execa';
 
 var __defProp = Object.defineProperty;
@@ -27,52 +28,6 @@ var init_esm_shims = __esm({
   "node_modules/.pnpm/tsup@8.5.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/esm_shims.js"() {
   }
 });
-var SlideFrontmatterSchema, SlideSchema;
-var init_slide = __esm({
-  "src/schemas/slide.ts"() {
-    init_esm_shims();
-    SlideFrontmatterSchema = z.object({
-      // Required: window title
-      title: z.string().min(1, {
-        message: "Slide must have a title"
-      }),
-      // ASCII art text (figlet) - can be a single line or multiple lines
-      bigText: z.union([
-        z.string(),
-        z.array(z.string())
-      ]).optional(),
-      // Which gradient to use for bigText
-      gradient: z.string().optional(),
-      // Override theme for this slide
-      theme: z.string().optional(),
-      // Transition effect
-      transition: z.enum([
-        "glitch",
-        // Default: glitch reveal line by line
-        "fade",
-        // Fade in
-        "instant",
-        // No animation
-        "typewriter"
-        // Character by character
-      ]).default("glitch"),
-      // Custom metadata (ignored by renderer, useful for tooling)
-      meta: z.record(z.string(), z.unknown()).optional()
-    });
-    SlideSchema = z.object({
-      // Parsed frontmatter
-      frontmatter: SlideFrontmatterSchema,
-      // Markdown body content
-      body: z.string(),
-      // Presenter notes (extracted from <!-- notes --> block)
-      notes: z.string().optional(),
-      // Source file path
-      sourcePath: z.string(),
-      // Slide index in deck (0-indexed)
-      index: z.number()
-    });
-  }
-});
 var HexColorSchema, GradientSchema, ThemeSchema, DEFAULT_THEME;
 var init_theme = __esm({
   "src/schemas/theme.ts"() {
@@ -244,144 +199,52 @@ var init_validation = __esm({
     };
   }
 });
-function resolveColorToken(token, theme) {
-  switch (token) {
-    case "PRIMARY":
-      return theme.colors.primary;
-    case "SECONDARY":
-      return theme.colors.secondary ?? theme.colors.primary;
-    case "ACCENT":
-      return theme.colors.accent;
-    case "MUTED":
-      return theme.colors.muted;
-    case "TEXT":
-      return theme.colors.text;
-    case "BACKGROUND":
-      return theme.colors.background;
-  }
-  return BUILTIN_COLORS[token] ?? theme.colors.text;
-}
-function colorTokensToBlessedTags(content, theme) {
-  return content.replace(
-    /\{(GREEN|ORANGE|CYAN|PINK|WHITE|GRAY|PRIMARY|SECONDARY|ACCENT|MUTED|TEXT|BACKGROUND|\/)\}/g,
-    (_, token) => {
-      if (token === "/") {
-        return "{/}";
-      }
-      const color = resolveColorToken(token, theme);
-      return `{${color}-fg}`;
-    }
-  );
-}
-var ThemeError, BUILTIN_COLORS;
-var init_theme2 = __esm({
-  "src/core/theme.ts"() {
+var SlideFrontmatterSchema, SlideSchema;
+var init_slide = __esm({
+  "src/schemas/slide.ts"() {
     init_esm_shims();
-    init_theme();
-    init_validation();
-    ThemeError = class extends Error {
-      /**
-       * @param message - The error message
-       * @param themeName - Optional name of the theme that caused the error
-       * @param path - Optional path to the theme file or package
-       */
-      constructor(message, themeName, path2) {
-        super(message);
-        this.themeName = themeName;
-        this.path = path2;
-        this.name = "ThemeError";
-      }
-    };
-    BUILTIN_COLORS = {
-      GREEN: "#00cc66",
-      ORANGE: "#ff6600",
-      CYAN: "#00ccff",
-      PINK: "#ff0066",
-      WHITE: "#ffffff",
-      GRAY: "#666666"
-    };
+    SlideFrontmatterSchema = z.object({
+      // Required: window title
+      title: z.string().min(1, {
+        message: "Slide must have a title"
+      }),
+      // ASCII art text (figlet) - can be a single line or multiple lines
+      bigText: z.union([
+        z.string(),
+        z.array(z.string())
+      ]).optional(),
+      // Which gradient to use for bigText
+      gradient: z.string().optional(),
+      // Override theme for this slide
+      theme: z.string().optional(),
+      // Transition effect
+      transition: z.enum([
+        "glitch",
+        // Default: glitch reveal line by line
+        "fade",
+        // Fade in
+        "instant",
+        // No animation
+        "typewriter"
+        // Character by character
+      ]).default("glitch"),
+      // Custom metadata (ignored by renderer, useful for tooling)
+      meta: z.record(z.string(), z.unknown()).optional()
+    });
+    SlideSchema = z.object({
+      // Parsed frontmatter
+      frontmatter: SlideFrontmatterSchema,
+      // Markdown body content
+      body: z.string(),
+      // Presenter notes (extracted from <!-- notes --> block)
+      notes: z.string().optional(),
+      // Source file path
+      sourcePath: z.string(),
+      // Slide index in deck (0-indexed)
+      index: z.number()
+    });
   }
 });
-
-// src/core/slide.ts
-var slide_exports = {};
-__export(slide_exports, {
-  DeckLoadError: () => DeckLoadError,
-  SlideParseError: () => SlideParseError,
-  extractMermaidBlocks: () => extractMermaidBlocks,
-  extractNotes: () => extractNotes,
-  findSlideFiles: () => findSlideFiles,
-  formatMermaidError: () => formatMermaidError,
-  formatSlideError: () => formatSlideError,
-  hasMermaidDiagrams: () => hasMermaidDiagrams,
-  loadDeck: () => loadDeck,
-  loadDeckConfig: () => loadDeckConfig,
-  mermaidToAscii: () => mermaidToAscii,
-  normalizeBigText: () => normalizeBigText,
-  parseSlide: () => parseSlide,
-  processMermaidDiagrams: () => processMermaidDiagrams,
-  processSlideContent: () => processSlideContent
-});
-function hasMermaidDiagrams(content) {
-  MERMAID_BLOCK_PATTERN.lastIndex = 0;
-  return MERMAID_BLOCK_PATTERN.test(content);
-}
-function extractMermaidBlocks(content) {
-  const blocks = [];
-  let match;
-  MERMAID_BLOCK_PATTERN.lastIndex = 0;
-  while ((match = MERMAID_BLOCK_PATTERN.exec(content)) !== null) {
-    blocks.push(match[1].trim());
-  }
-  return blocks;
-}
-function formatMermaidError(code, _error) {
-  const lines = [
-    "\u250C\u2500 Diagram (parse error) \u2500\u2510",
-    "\u2502                         \u2502"
-  ];
-  const codeLines = code.split("\n").slice(0, 5);
-  for (const line of codeLines) {
-    const truncated = line.slice(0, 23).padEnd(23);
-    lines.push(`\u2502 ${truncated} \u2502`);
-  }
-  if (code.split("\n").length > 5) {
-    lines.push("\u2502 ...                     \u2502");
-  }
-  lines.push("\u2502                         \u2502");
-  lines.push("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
-  return lines.join("\n");
-}
-function mermaidToAscii(mermaidCode) {
-  try {
-    return mermaidToAscii$1(mermaidCode);
-  } catch (error) {
-    return formatMermaidError(mermaidCode);
-  }
-}
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function processMermaidDiagrams(content) {
-  if (!hasMermaidDiagrams(content)) {
-    return content;
-  }
-  let result = content;
-  const blocks = extractMermaidBlocks(content);
-  for (const block of blocks) {
-    const ascii = mermaidToAscii(block);
-    result = result.replace(
-      new RegExp("```mermaid\\n" + escapeRegex(block) + "\\n?```", "g"),
-      ascii
-    );
-  }
-  return result;
-}
-async function processSlideContent(body, theme) {
-  let processed = processMermaidDiagrams(body);
-  processed = colorTokensToBlessedTags(processed, theme);
-  return processed;
-}
 function extractNotes(content) {
   const notesStart = content.indexOf(NOTES_MARKER);
   if (notesStart === -1) {
@@ -415,6 +278,29 @@ async function parseSlide(filePath, index) {
   };
   return safeParse(SlideSchema, slide, `slide ${filePath}`);
 }
+var NOTES_MARKER, NOTES_END_MARKER, SlideParseError;
+var init_slide2 = __esm({
+  "src/core/slide.ts"() {
+    init_esm_shims();
+    init_slide();
+    init_validation();
+    NOTES_MARKER = "<!-- notes -->";
+    NOTES_END_MARKER = "<!-- /notes -->";
+    SlideParseError = class extends Error {
+      /**
+       * @param message - The error message describing what went wrong
+       * @param filePath - Path to the slide file that failed to parse
+       * @param cause - Optional underlying error that caused this failure
+       */
+      constructor(message, filePath, cause) {
+        super(message);
+        this.filePath = filePath;
+        this.cause = cause;
+        this.name = "SlideParseError";
+      }
+    };
+  }
+});
 async function findSlideFiles(dir) {
   const pattern = join(dir, "*.md");
   const foundFiles = await fg(pattern, { onlyFiles: true });
@@ -447,7 +333,9 @@ async function loadDeckConfig(slidesDir) {
         theme: DEFAULT_THEME
       };
     }
-    const configModule = await import(configPath + "?t=" + Date.now());
+    const isTest = process.env.NODE_ENV === "test" || process.env.VITEST === "true";
+    const cacheBuster = isTest ? `?t=${Date.now()}-${Math.random()}` : "";
+    const configModule = await import(configPath + cacheBuster);
     if (!configModule.default) {
       throw new Error("deck.config.ts must export default config");
     }
@@ -471,50 +359,18 @@ async function loadDeck(slidesDir) {
     basePath: slidesDir
   };
 }
-function normalizeBigText(bigText) {
-  if (!bigText) return [];
-  return Array.isArray(bigText) ? bigText : [bigText];
-}
-function formatSlideError(error) {
-  let msg = `Error parsing slide: ${error.filePath}
-`;
-  msg += `  ${error.message}
-`;
-  if (error.cause) {
-    msg += `  Caused by: ${error.cause.message}
-`;
-  }
-  return msg;
-}
-var NOTES_MARKER, NOTES_END_MARKER, MERMAID_BLOCK_PATTERN, SlideParseError, DeckLoadError;
-var init_slide2 = __esm({
-  "src/core/slide.ts"() {
+var DeckLoadError;
+var init_deck_loader = __esm({
+  "src/core/deck-loader.ts"() {
     init_esm_shims();
-    init_slide();
     init_config();
     init_validation();
     init_theme();
-    init_theme2();
-    NOTES_MARKER = "<!-- notes -->";
-    NOTES_END_MARKER = "<!-- /notes -->";
-    MERMAID_BLOCK_PATTERN = /```mermaid\n([\s\S]*?)```/g;
-    SlideParseError = class extends Error {
+    init_slide2();
+    DeckLoadError = class extends Error {
       /**
        * @param message - The error message describing what went wrong
-       * @param filePath - Path to the slide file that failed to parse
-       * @param cause - Optional underlying error that caused this failure
-       */
-      constructor(message, filePath, cause) {
-        super(message);
-        this.filePath = filePath;
-        this.cause = cause;
-        this.name = "SlideParseError";
-      }
-    };
-    DeckLoadError = class extends Error {
-      /**
-       * @param message - The error message describing what went wrong
-       * @param slidesDir - Path to the directory that was being loaded
+       * @param slidesDir - Path to the directory that was being loaded
        * @param cause - Optional underlying error that caused this failure
        */
       constructor(message, slidesDir, cause) {
@@ -526,43 +382,14 @@ var init_slide2 = __esm({
     };
   }
 });
-
-// src/renderer/screen.ts
-var screen_exports = {};
-__export(screen_exports, {
-  applyTransition: () => applyTransition,
-  clearWindows: () => clearWindows,
-  createRenderer: () => createRenderer,
-  createScreen: () => createScreen,
-  createWindow: () => createWindow,
-  destroyRenderer: () => destroyRenderer,
-  generateBigText: () => generateBigText,
-  generateMultiLineBigText: () => generateMultiLineBigText,
-  getWindowColor: () => getWindowColor,
-  glitchLine: () => glitchLine,
-  initMatrixRain: () => initMatrixRain,
-  lineByLineReveal: () => lineByLineReveal,
-  renderMatrixRain: () => renderMatrixRain,
-  renderSlide: () => renderSlide
-});
-function createScreen(title = "term-deck") {
-  const screen = blessed.screen({
-    smartCSR: true,
-    title,
-    fullUnicode: true,
-    mouse: false,
-    altScreen: true
-  });
-  return screen;
-}
 function generateTrail(glyphs, length) {
   return Array.from(
     { length },
     () => glyphs[Math.floor(Math.random() * glyphs.length)]
   );
 }
-function renderMatrixRain(renderer) {
-  const { screen, matrixBox, matrixDrops, theme } = renderer;
+function renderMatrixRain(screen, state) {
+  const { matrixBox, matrixDrops, theme } = state;
   const width = Math.max(20, screen.width || 80);
   const height = Math.max(10, screen.height || 24);
   const grid = Array.from(
@@ -597,27 +424,32 @@ function renderMatrixRain(renderer) {
   }
   matrixBox.setContent(output);
 }
-function initMatrixRain(renderer) {
-  const { screen, theme } = renderer;
+function initMatrixRain(screen, state) {
+  const { theme } = state;
   const width = screen.width || 80;
   const height = screen.height || 24;
   const density = theme.animations.matrixDensity;
-  renderer.matrixDrops = [];
+  state.matrixDrops = [];
   for (let i = 0; i < density; i++) {
-    renderer.matrixDrops.push({
+    state.matrixDrops.push({
       x: Math.floor(Math.random() * width),
       y: Math.floor(Math.random() * height),
       speed: 0.3 + Math.random() * 0.7,
       trail: generateTrail(theme.glyphs, 5 + Math.floor(Math.random() * 10))
     });
   }
-  renderer.matrixInterval = setInterval(() => {
-    renderMatrixRain(renderer);
-    renderer.screen.render();
+  state.matrixInterval = setInterval(() => {
+    renderMatrixRain(screen, state);
+    screen.render();
   }, theme.animations.matrixInterval);
 }
-function createRenderer(theme) {
-  const screen = createScreen();
+function stopMatrixRain(state) {
+  if (state.matrixInterval) {
+    clearInterval(state.matrixInterval);
+    state.matrixInterval = null;
+  }
+}
+function createMatrixBox(screen) {
   const matrixBox = blessed.box({
     top: 0,
     left: 0,
@@ -626,28 +458,13 @@ function createRenderer(theme) {
     tags: true
   });
   screen.append(matrixBox);
-  const renderer = {
-    screen,
-    matrixBox,
-    windowStack: [],
-    theme,
-    matrixDrops: [],
-    matrixInterval: null
-  };
-  initMatrixRain(renderer);
-  return renderer;
+  return matrixBox;
 }
-function destroyRenderer(renderer) {
-  if (renderer.matrixInterval) {
-    clearInterval(renderer.matrixInterval);
-    renderer.matrixInterval = null;
-  }
-  for (const win of renderer.windowStack) {
-    win.destroy();
+var init_matrix_rain = __esm({
+  "src/renderer/effects/matrix-rain.ts"() {
+    init_esm_shims();
   }
-  renderer.windowStack = [];
-  renderer.screen.destroy();
-}
+});
 function getWindowColor(index, theme) {
   const colors = [
     theme.colors.primary,
@@ -662,8 +479,7 @@ function getWindowColor(index, theme) {
   ];
   return colors[index % colors.length];
 }
-function createWindow(renderer, options) {
-  const { screen, windowStack, theme } = renderer;
+function createWindow(screen, windowStack, theme, options) {
   const windowIndex = windowStack.length;
   const color = options.color ?? getWindowColor(windowIndex, theme);
   const screenWidth = screen.width || 120;
@@ -699,144 +515,178 @@ function createWindow(renderer, options) {
   windowStack.push(box);
   return box;
 }
-function clearWindows(renderer) {
-  for (const window of renderer.windowStack) {
+function clearWindows(windowStack) {
+  for (const window of windowStack) {
     window.destroy();
   }
-  renderer.windowStack = [];
+  windowStack.length = 0;
 }
-async function generateBigText(text, gradientColors, font = "Standard") {
-  return new Promise((resolve, reject) => {
-    figlet.text(text, { font }, (err, result) => {
-      if (err || !result) {
-        reject(err ?? new Error("Failed to generate figlet text"));
-        return;
+var init_window_manager = __esm({
+  "src/renderer/window-manager.ts"() {
+    init_esm_shims();
+  }
+});
+
+// src/core/theme-errors.ts
+var ThemeError;
+var init_theme_errors = __esm({
+  "src/core/theme-errors.ts"() {
+    init_esm_shims();
+    init_validation();
+    ThemeError = class extends Error {
+      /**
+       * @param message - The error message
+       * @param themeName - Optional name of the theme that caused the error
+       * @param path - Optional path to the theme file or package
+       */
+      constructor(message, themeName, path2) {
+        super(message);
+        this.themeName = themeName;
+        this.path = path2;
+        this.name = "ThemeError";
       }
-      const gradientFn = gradient2(gradientColors);
-      resolve(gradientFn(result));
-    });
-  });
-}
-async function generateMultiLineBigText(lines, gradientColors, font = "Standard") {
-  const results = await Promise.all(
-    lines.map((line) => generateBigText(line, gradientColors, font))
-  );
-  return results.join("\n");
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+    };
+  }
+});
+function resolveColorToken(token, theme) {
+  switch (token) {
+    case "PRIMARY":
+      return theme.colors.primary;
+    case "SECONDARY":
+      return theme.colors.secondary ?? theme.colors.primary;
+    case "ACCENT":
+      return theme.colors.accent;
+    case "MUTED":
+      return theme.colors.muted;
+    case "TEXT":
+      return theme.colors.text;
+    case "BACKGROUND":
+      return theme.colors.background;
+  }
+  return BUILTIN_COLORS[token] ?? theme.colors.text;
 }
-async function glitchLine(box, screen, currentLines, newLine, iterations = 5) {
-  for (let i = iterations; i >= 0; i--) {
-    const scrambleRatio = i / iterations;
-    let scrambledLine = "";
-    for (const char of newLine) {
-      if (PROTECTED_CHARS.has(char)) {
-        scrambledLine += char;
-      } else if (Math.random() < scrambleRatio) {
-        scrambledLine += GLITCH_CHARS[Math.floor(Math.random() * GLITCH_CHARS.length)];
-      } else {
-        scrambledLine += char;
+function colorTokensToBlessedTags(content, theme) {
+  return content.replace(
+    /\{(GREEN|ORANGE|CYAN|PINK|WHITE|GRAY|PRIMARY|SECONDARY|ACCENT|MUTED|TEXT|BACKGROUND|\/)\}/g,
+    (_, token) => {
+      if (token === "/") {
+        return "{/}";
       }
+      const color = resolveColorToken(token, theme);
+      return `{${color}-fg}`;
     }
-    box.setContent([...currentLines, scrambledLine].join("\n"));
-    screen.render();
-    await sleep(20);
-  }
+  );
 }
-async function lineByLineReveal(box, screen, content, theme) {
-  const lines = content.split("\n");
-  const revealedLines = [];
-  const lineDelay = theme.animations.lineDelay;
-  const glitchIterations = theme.animations.glitchIterations;
-  for (const line of lines) {
-    await glitchLine(box, screen, revealedLines, line, glitchIterations);
-    revealedLines.push(line);
-    box.setContent(revealedLines.join("\n"));
-    screen.render();
-    if (line.trim()) {
-      await sleep(lineDelay);
-    }
+var BUILTIN_COLORS;
+var init_theme_colors = __esm({
+  "src/core/theme-colors.ts"() {
+    init_esm_shims();
+    BUILTIN_COLORS = {
+      GREEN: "#00cc66",
+      ORANGE: "#ff6600",
+      CYAN: "#00ccff",
+      PINK: "#ff0066",
+      WHITE: "#ffffff",
+      GRAY: "#666666"
+    };
+  }
+});
+var init_theme2 = __esm({
+  "src/core/theme.ts"() {
+    init_esm_shims();
+    init_theme();
+    init_validation();
+    init_theme_errors();
+    init_theme_colors();
   }
+});
+function hasMermaidDiagrams(content) {
+  MERMAID_BLOCK_PATTERN.lastIndex = 0;
+  return MERMAID_BLOCK_PATTERN.test(content);
 }
-async function fadeInReveal(box, screen, content, theme) {
-  const steps = 10;
-  const delay = theme.animations.lineDelay * 2 / steps;
-  for (let step = 0; step < steps; step++) {
-    const revealRatio = step / steps;
-    let revealed = "";
-    for (const char of content) {
-      if (char === "\n" || PROTECTED_CHARS.has(char) || Math.random() < revealRatio) {
-        revealed += char;
-      } else {
-        revealed += " ";
-      }
-    }
-    box.setContent(revealed);
-    screen.render();
-    await sleep(delay);
+function extractMermaidBlocks(content) {
+  const blocks = [];
+  let match;
+  MERMAID_BLOCK_PATTERN.lastIndex = 0;
+  while ((match = MERMAID_BLOCK_PATTERN.exec(content)) !== null) {
+    blocks.push(match[1].trim());
   }
-  box.setContent(content);
-  screen.render();
+  return blocks;
 }
-async function typewriterReveal(box, screen, content, theme) {
-  const charDelay = theme.animations.lineDelay / 5;
-  let revealed = "";
-  for (const char of content) {
-    revealed += char;
-    box.setContent(revealed);
-    screen.render();
-    if (char !== " " && char !== "\n") {
-      await sleep(charDelay);
-    }
+function formatMermaidError(code, _error) {
+  const lines = [
+    "\u250C\u2500 Diagram (parse error) \u2500\u2510",
+    "\u2502                         \u2502"
+  ];
+  const codeLines = code.split("\n").slice(0, 5);
+  for (const line of codeLines) {
+    const truncated = line.slice(0, 23).padEnd(23);
+    lines.push(`\u2502 ${truncated} \u2502`);
   }
+  if (code.split("\n").length > 5) {
+    lines.push("\u2502 ...                     \u2502");
+  }
+  lines.push("\u2502                         \u2502");
+  lines.push("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
+  return lines.join("\n");
 }
-async function applyTransition(box, screen, content, transition, theme) {
-  switch (transition) {
-    case "glitch":
-      await lineByLineReveal(box, screen, content, theme);
-      break;
-    case "fade":
-      await fadeInReveal(box, screen, content, theme);
-      break;
-    case "instant":
-      box.setContent(content);
-      screen.render();
-      break;
-    case "typewriter":
-      await typewriterReveal(box, screen, content, theme);
-      break;
-    default:
-      box.setContent(content);
-      screen.render();
+function mermaidToAscii(mermaidCode) {
+  try {
+    return mermaidToAscii$1(mermaidCode);
+  } catch (error) {
+    return formatMermaidError(mermaidCode);
   }
 }
-async function renderSlide(renderer, slide) {
-  const { theme } = renderer;
-  const { frontmatter, body } = slide;
-  const window = createWindow(renderer, {
-    title: frontmatter.title
-  });
-  let content = "";
-  const bigTextLines = normalizeBigText(frontmatter.bigText);
-  if (bigTextLines.length > 0) {
-    const gradientName = frontmatter.gradient ?? "fire";
-    const gradientColors = theme.gradients[gradientName] ?? theme.gradients.fire;
-    const bigText = await generateMultiLineBigText(bigTextLines, gradientColors);
-    content += bigText + "\n\n";
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function processMermaidDiagrams(content) {
+  if (!hasMermaidDiagrams(content)) {
+    return content;
   }
-  const processedBody = await processSlideContent(body, theme);
-  content += processedBody;
-  const transition = frontmatter.transition ?? "glitch";
-  await applyTransition(window, renderer.screen, content, transition, theme);
-  return window;
+  let result = content;
+  const blocks = extractMermaidBlocks(content);
+  for (const block of blocks) {
+    const ascii = mermaidToAscii(block);
+    result = result.replace(
+      new RegExp("```mermaid\\n" + escapeRegex(block) + "\\n?```", "g"),
+      ascii
+    );
+  }
+  return result;
 }
-var GLITCH_CHARS, PROTECTED_CHARS;
-var init_screen = __esm({
-  "src/renderer/screen.ts"() {
+var MERMAID_BLOCK_PATTERN;
+var init_mermaid = __esm({
+  "src/core/utils/mermaid.ts"() {
     init_esm_shims();
-    init_slide2();
-    GLITCH_CHARS = "\u2588\u2593\u2592\u2591\u2580\u2584\u258C\u2590\u25A0\u25A1\u25AA\u25AB\u25CF\u25CB\u25CA\u25D8\u25D9\u2666\u2663\u2660\u2665\u2605\u2606\u2302\u207F\xB2\xB3\xC6\xD8\u221E\u2248\u2260\xB1\xD7\xF7\u03B1\u03B2\u03B3\u03B4\u03B5\u03B6\u03B7\u03B8\u03BB\u03BC\u03C0\u03C3\u03C6\u03C9\u0394\u03A3\u03A9\uFF71\uFF72\uFF73\uFF74\uFF75\uFF76\uFF77\uFF78\uFF79\uFF7A\uFF7B\uFF7C\uFF7D\uFF7E\uFF7F\uFF80\uFF81\uFF82\uFF83\uFF84\uFF85\uFF86\uFF87\uFF88\uFF89\uFF8A\uFF8B\uFF8C\uFF8D\uFF8E\uFF8F\uFF90\uFF91\uFF92\uFF93\uFF94\uFF95\uFF96\uFF97\uFF98\uFF99\uFF9A\uFF9B\uFF9C\uFF9D";
+    MERMAID_BLOCK_PATTERN = /```mermaid\n([\s\S]*?)```/g;
+  }
+});
+
+// src/core/content-processor.ts
+async function processSlideContent(body, theme) {
+  let processed = processMermaidDiagrams(body);
+  processed = colorTokensToBlessedTags(processed, theme);
+  return processed;
+}
+function normalizeBigText(bigText) {
+  if (!bigText) return [];
+  return Array.isArray(bigText) ? bigText : [bigText];
+}
+var init_content_processor = __esm({
+  "src/core/content-processor.ts"() {
+    init_esm_shims();
+    init_theme2();
+    init_mermaid();
+  }
+});
+
+// src/renderer/animations/constants.ts
+var GLITCH_CHARS, PROTECTED_CHARS;
+var init_constants = __esm({
+  "src/renderer/animations/constants.ts"() {
+    init_esm_shims();
+    GLITCH_CHARS = "\u2588\u2593\u2592\u2591\u2580\u2584\u258C\u2590\u25A0\u25A1\u25AA\u25AB\u25CF\u25CB\u25CA\u25D8\u25D9\u2666\u2663\u2660\u2665\u2605\u2606\u2302\u207F\xB2\xB3\xC6\xD8\u221E\u2248\u2260\xB1\xD7\xF7\u03B1\u03B2\u03B3\u03B4\u03B5\u03B6\u03B7\u03B8\u03BB\u03BC\u03C0\u03C3\u03C6\u03C9\u0394\u03A3\u03A9\uFF71\uFF72\uFF73\uFF74\uFF75\uFF76\uFF77\uFF78\uFF79\uFF7A\uFF7B\uFF7C\uFF7D\uFF7E\uFF7F\uFF80\uFF81\uFF82\uFF83\uFF84\uFF85\uFF86\uFF87\uFF88\uFF89\uFF8A\uFF8B\uFF8C\uFF8D\uFF8E\uFF8F\uFF90\uFF91\uFF92\uFF93\uFF94\uFF95\uFF96\uFF97\uFF98\uFF99\uFF9A\uFF9B\uFF9C\uFF9D";
     PROTECTED_CHARS = /* @__PURE__ */ new Set([
       " ",
       "	",
@@ -915,65 +765,370 @@ var init_screen = __esm({
   }
 });
 
-// src/presenter/main.ts
-var main_exports = {};
-__export(main_exports, {
-  jumpToSlide: () => jumpToSlide,
-  nextSlide: () => nextSlide,
-  present: () => present,
-  prevSlide: () => prevSlide
+// src/renderer/animations/helpers/animation-utils.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function renderContent(box, screen, content) {
+  box.setContent(content);
+  screen.render();
+}
+var init_animation_utils = __esm({
+  "src/renderer/animations/helpers/animation-utils.ts"() {
+    init_esm_shims();
+  }
 });
-async function present(slidesDir, options = {}) {
-  const deck = await loadDeck(slidesDir);
-  if (deck.slides.length === 0) {
-    throw new Error(`No slides found in ${slidesDir}`);
+
+// src/renderer/animations/transitions/glitch-transition.ts
+async function glitchLine(box, screen, currentLines, newLine, iterations = 5) {
+  for (let i = iterations; i >= 0; i--) {
+    const scrambleRatio = i / iterations;
+    let scrambledLine = "";
+    for (const char of newLine) {
+      if (PROTECTED_CHARS.has(char)) {
+        scrambledLine += char;
+      } else if (Math.random() < scrambleRatio) {
+        scrambledLine += GLITCH_CHARS[Math.floor(Math.random() * GLITCH_CHARS.length)];
+      } else {
+        scrambledLine += char;
+      }
+    }
+    renderContent(box, screen, [...currentLines, scrambledLine].join("\n"));
+    await sleep(20);
   }
-  const renderer = createRenderer(deck.config.theme);
-  const presenter = {
-    deck,
-    renderer,
-    currentSlide: options.startSlide ?? deck.config.settings?.startSlide ?? 0,
-    isAnimating: false,
-    notesWindow: null,
-    autoAdvanceTimer: null,
-    progressBar: null
-  };
-  if (options.showNotes) {
-    presenter.notesWindow = await createNotesWindow(options.notesTty);
+}
+async function lineByLineReveal(box, screen, content, theme) {
+  const lines = content.split("\n");
+  const revealedLines = [];
+  const lineDelay = theme.animations.lineDelay;
+  const glitchIterations = theme.animations.glitchIterations;
+  for (const line of lines) {
+    await glitchLine(box, screen, revealedLines, line, glitchIterations);
+    revealedLines.push(line);
+    renderContent(box, screen, revealedLines.join("\n"));
+    if (line.trim()) {
+      await sleep(lineDelay);
+    }
   }
-  if (deck.config.settings?.showProgress) {
-    presenter.progressBar = createProgressBar(presenter);
+}
+var init_glitch_transition = __esm({
+  "src/renderer/animations/transitions/glitch-transition.ts"() {
+    init_esm_shims();
+    init_constants();
+    init_animation_utils();
   }
-  setupControls(presenter);
-  await showSlide(presenter, presenter.currentSlide);
-  if (presenter.progressBar) {
-    updateProgress(presenter.progressBar, presenter.currentSlide, deck.slides.length);
+});
+
+// src/renderer/animations/transitions/fade-transition.ts
+async function fadeInReveal(box, screen, content, theme) {
+  const steps = 10;
+  const delay = theme.animations.lineDelay * 2 / steps;
+  for (let step = 0; step < steps; step++) {
+    const revealRatio = step / steps;
+    let revealed = "";
+    for (const char of content) {
+      if (char === "\n" || PROTECTED_CHARS.has(char) || Math.random() < revealRatio) {
+        revealed += char;
+      } else {
+        revealed += " ";
+      }
+    }
+    renderContent(box, screen, revealed);
+    await sleep(delay);
   }
-  presenter.autoAdvanceTimer = startAutoAdvance(presenter);
-  await new Promise((resolve) => {
-    renderer.screen.key(["q", "C-c", "escape"], () => {
-      cleanup(presenter);
-      resolve();
+  renderContent(box, screen, content);
+}
+var init_fade_transition = __esm({
+  "src/renderer/animations/transitions/fade-transition.ts"() {
+    init_esm_shims();
+    init_constants();
+    init_animation_utils();
+  }
+});
+
+// src/renderer/animations/transitions/typewriter-transition.ts
+async function typewriterReveal(box, screen, content, theme) {
+  const charDelay = theme.animations.lineDelay / 5;
+  let revealed = "";
+  for (const char of content) {
+    revealed += char;
+    renderContent(box, screen, revealed);
+    if (char !== " " && char !== "\n") {
+      await sleep(charDelay);
+    }
+  }
+}
+var init_typewriter_transition = __esm({
+  "src/renderer/animations/transitions/typewriter-transition.ts"() {
+    init_esm_shims();
+    init_animation_utils();
+  }
+});
+
+// src/renderer/animations/transitions/instant-transition.ts
+function instantReveal(box, screen, content) {
+  renderContent(box, screen, content);
+}
+var init_instant_transition = __esm({
+  "src/renderer/animations/transitions/instant-transition.ts"() {
+    init_esm_shims();
+    init_animation_utils();
+  }
+});
+
+// src/renderer/animations/transition-orchestrator.ts
+async function applyTransition(box, screen, content, transition, theme) {
+  switch (transition) {
+    case "glitch":
+      await lineByLineReveal(box, screen, content, theme);
+      break;
+    case "fade":
+      await fadeInReveal(box, screen, content, theme);
+      break;
+    case "instant":
+      instantReveal(box, screen, content);
+      break;
+    case "typewriter":
+      await typewriterReveal(box, screen, content, theme);
+      break;
+    default:
+      instantReveal(box, screen, content);
+  }
+}
+var init_transition_orchestrator = __esm({
+  "src/renderer/animations/transition-orchestrator.ts"() {
+    init_esm_shims();
+    init_glitch_transition();
+    init_fade_transition();
+    init_typewriter_transition();
+    init_instant_transition();
+  }
+});
+
+// src/renderer/animations/transitions.ts
+var init_transitions = __esm({
+  "src/renderer/animations/transitions.ts"() {
+    init_esm_shims();
+    init_transition_orchestrator();
+    init_glitch_transition();
+    init_fade_transition();
+    init_typewriter_transition();
+    init_instant_transition();
+  }
+});
+async function generateBigText(text, gradientColors, font = "Standard") {
+  return new Promise((resolve, reject) => {
+    figlet.text(text, { font }, (err, result) => {
+      if (err || !result) {
+        reject(err ?? new Error("Failed to generate figlet text"));
+        return;
+      }
+      const gradientFn = gradient2(gradientColors);
+      resolve(gradientFn(result));
     });
   });
 }
-function cleanup(presenter) {
-  stopAutoAdvance(presenter.autoAdvanceTimer);
-  if (presenter.notesWindow) {
-    presenter.notesWindow.screen.destroy();
+async function generateMultiLineBigText(lines, gradientColors, font = "Standard") {
+  const results = await Promise.all(
+    lines.map((line) => generateBigText(line, gradientColors, font))
+  );
+  return results.join("\n");
+}
+var init_text_generator = __esm({
+  "src/renderer/text-generator.ts"() {
+    init_esm_shims();
   }
-  destroyRenderer(presenter.renderer);
+});
+
+// src/renderer/slide-renderer.ts
+async function renderSlide(screen, windowStack, theme, slide) {
+  const { frontmatter, body } = slide;
+  const window = createWindow(screen, windowStack, theme, {
+    title: frontmatter.title
+  });
+  let content = "";
+  const bigTextLines = normalizeBigText(frontmatter.bigText);
+  if (bigTextLines.length > 0) {
+    const gradientName = frontmatter.gradient ?? "fire";
+    const gradientColors = theme.gradients[gradientName] ?? theme.gradients.fire;
+    const bigText = await generateMultiLineBigText(bigTextLines, gradientColors);
+    content += bigText + "\n\n";
+  }
+  const processedBody = await processSlideContent(body, theme);
+  content += processedBody;
+  const transition = frontmatter.transition ?? "glitch";
+  await applyTransition(window, screen, content, transition, theme);
+  return window;
+}
+var init_slide_renderer = __esm({
+  "src/renderer/slide-renderer.ts"() {
+    init_esm_shims();
+    init_content_processor();
+    init_transitions();
+    init_text_generator();
+    init_window_manager();
+  }
+});
+function createScreen(title = "term-deck") {
+  const screen = blessed.screen({
+    smartCSR: true,
+    title,
+    fullUnicode: true,
+    mouse: false,
+    altScreen: true
+  });
+  return screen;
+}
+function createRenderer(theme) {
+  const screen = createScreen();
+  const matrixBox = createMatrixBox(screen);
+  const matrixRain = {
+    matrixBox,
+    matrixDrops: [],
+    matrixInterval: null,
+    theme
+  };
+  const renderer = {
+    screen,
+    windowStack: [],
+    theme,
+    matrixRain
+  };
+  initMatrixRain(screen, matrixRain);
+  return renderer;
+}
+function destroyRenderer(renderer) {
+  stopMatrixRain(renderer.matrixRain);
+  clearWindows(renderer.windowStack);
+  renderer.screen.destroy();
+}
+function clearWindows2(renderer) {
+  clearWindows(renderer.windowStack);
+}
+async function renderSlide2(renderer, slide) {
+  return renderSlide(renderer.screen, renderer.windowStack, renderer.theme, slide);
+}
+var init_screen = __esm({
+  "src/renderer/screen.ts"() {
+    init_esm_shims();
+    init_matrix_rain();
+    init_window_manager();
+    init_slide_renderer();
+    init_transitions();
+    init_window_manager();
+    init_text_generator();
+  }
+});
+async function findAvailableTty() {
+  const candidates = [
+    "/dev/ttys001",
+    "/dev/ttys002",
+    "/dev/ttys003",
+    "/dev/pts/1",
+    "/dev/pts/2"
+  ];
+  for (const tty of candidates) {
+    try {
+      await access(tty);
+      return tty;
+    } catch {
+    }
+  }
+  throw new Error(
+    "Could not find available TTY for notes window. Open a second terminal, run `tty`, and pass the path with --notes-tty"
+  );
 }
+async function createNotesWindow(ttyPath) {
+  const blessed5 = (await import('neo-blessed')).default;
+  const { openSync } = await import('fs');
+  const tty = ttyPath ?? await findAvailableTty();
+  const screen = blessed5.screen({
+    smartCSR: true,
+    title: "term-deck notes",
+    fullUnicode: true,
+    input: openSync(tty, "r"),
+    output: openSync(tty, "w")
+  });
+  const contentBox = blessed5.box({
+    top: 0,
+    left: 0,
+    width: "100%",
+    height: "100%",
+    tags: true,
+    padding: 2,
+    style: {
+      fg: "#ffffff",
+      bg: "#1a1a1a"
+    }
+  });
+  screen.append(contentBox);
+  screen.render();
+  return {
+    screen,
+    contentBox,
+    tty
+  };
+}
+function updateNotesWindow(notesWindow, currentSlide, nextSlide2, currentIndex, totalSlides) {
+  const { contentBox, screen } = notesWindow;
+  let content = "";
+  content += `{bold}Slide ${currentIndex + 1} of ${totalSlides}{/bold}
+`;
+  content += `{gray-fg}${currentSlide.frontmatter.title}{/}
+`;
+  content += "\n";
+  content += "\u2500".repeat(50) + "\n";
+  content += "\n";
+  if (currentSlide.notes) {
+    content += "{bold}PRESENTER NOTES:{/bold}\n\n";
+    content += currentSlide.notes + "\n";
+  } else {
+    content += "{gray-fg}No notes for this slide{/}\n";
+  }
+  content += "\n";
+  content += "\u2500".repeat(50) + "\n";
+  content += "\n";
+  if (nextSlide2) {
+    content += `{bold}NEXT:{/bold} "${nextSlide2.frontmatter.title}"
+`;
+  } else {
+    content += "{gray-fg}Last slide{/}\n";
+  }
+  contentBox.setContent(content);
+  screen.render();
+}
+function toggleNotesVisibility(notesWindow) {
+  const { contentBox, screen } = notesWindow;
+  contentBox.toggle();
+  screen.render();
+}
+function destroyNotesWindow(notesWindow) {
+  notesWindow.screen.destroy();
+}
+var init_notes_window = __esm({
+  "src/presenter/notes-window.ts"() {
+    init_esm_shims();
+  }
+});
+
+// src/presenter/navigation.ts
 async function showSlide(presenter, index) {
   if (presenter.isAnimating) return;
   if (index < 0 || index >= presenter.deck.slides.length) return;
   presenter.isAnimating = true;
   presenter.currentSlide = index;
   const slide = presenter.deck.slides[index];
-  await renderSlide(presenter.renderer, slide);
+  await renderSlide2(presenter.renderer, slide);
   presenter.renderer.screen.render();
   if (presenter.notesWindow) {
-    updateNotesWindow(presenter);
+    const nextSlide2 = presenter.deck.slides[index + 1];
+    updateNotesWindow(
+      presenter.notesWindow,
+      slide,
+      nextSlide2,
+      index,
+      presenter.deck.slides.length
+    );
   }
   if (presenter.progressBar) {
     updateProgress(presenter.progressBar, presenter.currentSlide, presenter.deck.slides.length);
@@ -998,49 +1153,64 @@ async function prevSlide(presenter) {
   const loop = presenter.deck.config.settings?.loop ?? false;
   if (prevIndex < 0) {
     if (loop) {
-      clearWindows(presenter.renderer);
+      clearWindows2(presenter.renderer);
       for (let i = 0; i < slides.length; i++) {
-        await renderSlide(presenter.renderer, slides[i]);
+        await renderSlide2(presenter.renderer, slides[i]);
       }
       presenter.currentSlide = slides.length - 1;
-      if (presenter.notesWindow) {
-        updateNotesWindow(presenter);
-      }
-      if (presenter.progressBar) {
-        updateProgress(presenter.progressBar, presenter.currentSlide, presenter.deck.slides.length);
-      }
+      updateUIComponents(presenter, slides.length - 1);
       presenter.renderer.screen.render();
     }
     return;
   }
-  clearWindows(presenter.renderer);
+  clearWindows2(presenter.renderer);
   for (let i = 0; i <= prevIndex; i++) {
-    await renderSlide(presenter.renderer, slides[i]);
+    await renderSlide2(presenter.renderer, slides[i]);
   }
   presenter.currentSlide = prevIndex;
-  if (presenter.notesWindow) {
-    updateNotesWindow(presenter);
-  }
-  if (presenter.progressBar) {
-    updateProgress(presenter.progressBar, presenter.currentSlide, presenter.deck.slides.length);
+  updateUIComponents(presenter, prevIndex);
+  presenter.renderer.screen.render();
+}
+async function jumpToSlide(presenter, index) {
+  if (index < 0 || index >= presenter.deck.slides.length) return;
+  clearWindows2(presenter.renderer);
+  for (let i = 0; i <= index; i++) {
+    await renderSlide2(presenter.renderer, presenter.deck.slides[i]);
   }
+  presenter.currentSlide = index;
+  updateUIComponents(presenter, index);
   presenter.renderer.screen.render();
 }
-async function jumpToSlide(presenter, index) {
-  if (index < 0 || index >= presenter.deck.slides.length) return;
-  clearWindows(presenter.renderer);
-  for (let i = 0; i <= index; i++) {
-    await renderSlide(presenter.renderer, presenter.deck.slides[i]);
-  }
-  presenter.currentSlide = index;
+function updateProgress(progressBar, current, total) {
+  const progress = (current + 1) / total * 100;
+  progressBar.setProgress(progress);
+}
+function updateUIComponents(presenter, currentIndex) {
+  const { slides } = presenter.deck;
+  const currentSlide = slides[currentIndex];
+  const nextSlide2 = slides[currentIndex + 1];
   if (presenter.notesWindow) {
-    updateNotesWindow(presenter);
+    updateNotesWindow(
+      presenter.notesWindow,
+      currentSlide,
+      nextSlide2,
+      currentIndex,
+      slides.length
+    );
   }
   if (presenter.progressBar) {
-    updateProgress(presenter.progressBar, presenter.currentSlide, presenter.deck.slides.length);
+    updateProgress(presenter.progressBar, currentIndex, slides.length);
   }
-  presenter.renderer.screen.render();
 }
+var init_navigation = __esm({
+  "src/presenter/navigation.ts"() {
+    init_esm_shims();
+    init_screen();
+    init_notes_window();
+  }
+});
+
+// src/presenter/keyboard-controls.ts
 function setupControls(presenter) {
   const { screen } = presenter.renderer;
   screen.key(["space", "enter", "right", "n"], () => {
@@ -1097,93 +1267,61 @@ function showSlideList(presenter) {
     jumpToSlide(presenter, parseInt(ch ?? "0", 10));
   });
 }
-function toggleNotesVisibility(notesWindow) {
-  const { contentBox, screen } = notesWindow;
-  contentBox.toggle();
-  screen.render();
-}
-async function findAvailableTty() {
-  const candidates = [
-    "/dev/ttys001",
-    "/dev/ttys002",
-    "/dev/ttys003",
-    "/dev/pts/1",
-    "/dev/pts/2"
-  ];
-  for (const tty of candidates) {
-    try {
-      await access(tty);
-      return tty;
-    } catch {
-    }
+var init_keyboard_controls = __esm({
+  "src/presenter/keyboard-controls.ts"() {
+    init_esm_shims();
+    init_navigation();
+    init_notes_window();
   }
-  throw new Error(
-    "Could not find available TTY for notes window. Open a second terminal, run `tty`, and pass the path with --notes-tty"
-  );
-}
-async function createNotesWindow(ttyPath) {
-  const blessed3 = (await import('neo-blessed')).default;
-  const { openSync } = await import('fs');
-  const tty = ttyPath ?? await findAvailableTty();
-  const screen = blessed3.screen({
-    smartCSR: true,
-    title: "term-deck notes",
-    fullUnicode: true,
-    input: openSync(tty, "r"),
-    output: openSync(tty, "w")
-  });
-  const contentBox = blessed3.box({
-    top: 0,
-    left: 0,
-    width: "100%",
-    height: "100%",
-    tags: true,
-    padding: 2,
-    style: {
-      fg: "#ffffff",
-      bg: "#1a1a1a"
-    }
-  });
-  screen.append(contentBox);
-  screen.render();
-  return {
-    screen,
-    contentBox,
-    tty
+});
+
+// src/presenter/main.ts
+var main_exports = {};
+__export(main_exports, {
+  jumpToSlide: () => jumpToSlide,
+  present: () => present,
+  prevSlide: () => prevSlide
+});
+async function present(slidesDir, options = {}) {
+  const deck = await loadDeck(slidesDir);
+  if (deck.slides.length === 0) {
+    throw new Error(`No slides found in ${slidesDir}`);
+  }
+  const renderer = createRenderer(deck.config.theme);
+  const presenter = {
+    deck,
+    renderer,
+    currentSlide: options.startSlide ?? deck.config.settings?.startSlide ?? 0,
+    isAnimating: false,
+    notesWindow: null,
+    autoAdvanceTimer: null,
+    progressBar: null
   };
-}
-function updateNotesWindow(presenter) {
-  if (!presenter.notesWindow) return;
-  const { contentBox, screen } = presenter.notesWindow;
-  const { slides } = presenter.deck;
-  const currentIndex = presenter.currentSlide;
-  const currentSlide = slides[currentIndex];
-  const nextSlide2 = slides[currentIndex + 1];
-  let content = "";
-  content += `{bold}Slide ${currentIndex + 1} of ${slides.length}{/bold}
-`;
-  content += `{gray-fg}${currentSlide.frontmatter.title}{/}
-`;
-  content += "\n";
-  content += "\u2500".repeat(50) + "\n";
-  content += "\n";
-  if (currentSlide.notes) {
-    content += "{bold}PRESENTER NOTES:{/bold}\n\n";
-    content += currentSlide.notes + "\n";
-  } else {
-    content += "{gray-fg}No notes for this slide{/}\n";
+  if (options.showNotes) {
+    presenter.notesWindow = await createNotesWindow(options.notesTty);
   }
-  content += "\n";
-  content += "\u2500".repeat(50) + "\n";
-  content += "\n";
-  if (nextSlide2) {
-    content += `{bold}NEXT:{/bold} "${nextSlide2.frontmatter.title}"
-`;
-  } else {
-    content += "{gray-fg}Last slide{/}\n";
+  if (deck.config.settings?.showProgress) {
+    presenter.progressBar = createProgressBar(presenter);
   }
-  contentBox.setContent(content);
-  screen.render();
+  setupControls(presenter);
+  await showSlide(presenter, presenter.currentSlide);
+  if (presenter.progressBar) {
+    updateProgress(presenter.progressBar, presenter.currentSlide, deck.slides.length);
+  }
+  presenter.autoAdvanceTimer = startAutoAdvance(presenter);
+  await new Promise((resolve) => {
+    renderer.screen.key(["q", "C-c", "escape"], () => {
+      cleanup(presenter);
+      resolve();
+    });
+  });
+}
+function cleanup(presenter) {
+  stopAutoAdvance(presenter.autoAdvanceTimer);
+  if (presenter.notesWindow) {
+    destroyNotesWindow(presenter.notesWindow);
+  }
+  destroyRenderer(presenter.renderer);
 }
 function startAutoAdvance(presenter) {
   const interval = presenter.deck.config.settings?.autoAdvance;
@@ -1217,15 +1355,15 @@ function createProgressBar(presenter) {
   screen.append(progressBar);
   return progressBar;
 }
-function updateProgress(progressBar, current, total) {
-  const progress = (current + 1) / total * 100;
-  progressBar.setProgress(progress);
-}
 var init_main = __esm({
   "src/presenter/main.ts"() {
     init_esm_shims();
-    init_slide2();
+    init_deck_loader();
     init_screen();
+    init_notes_window();
+    init_keyboard_controls();
+    init_navigation();
+    init_navigation();
   }
 });
 
@@ -1233,7 +1371,7 @@ var init_main = __esm({
 init_esm_shims();
 
 // package.json
-var version = "1.0.15";
+var version = "1.0.17";
 
 // src/cli/commands/present.ts
 init_esm_shims();
@@ -1243,6 +1381,7 @@ init_main();
 init_esm_shims();
 init_validation();
 init_slide2();
+init_deck_loader();
 init_theme2();
 function handleError(error) {
   if (error instanceof ValidationError) {
@@ -1316,6 +1455,44 @@ init_esm_shims();
 
 // src/export/recorder.ts
 init_esm_shims();
+
+// src/export/recording-session.ts
+init_esm_shims();
+async function createRecordingSession(options) {
+  const tempDir = join(tmpdir(), `term-deck-export-${Date.now()}`);
+  await mkdir(tempDir, { recursive: true });
+  return {
+    tempDir,
+    frameCount: 0,
+    width: options.width ?? 120,
+    height: options.height ?? 40,
+    fps: options.fps ?? 30
+  };
+}
+async function saveFrame(session, png) {
+  const frameNum = session.frameCount.toString().padStart(6, "0");
+  const framePath = join(session.tempDir, `frame_${frameNum}.png`);
+  await writeFile(framePath, png);
+  session.frameCount++;
+}
+async function cleanupSession(session) {
+  await rm(session.tempDir, { recursive: true, force: true });
+}
+
+// src/export/presentation-exporter.ts
+init_esm_shims();
+init_deck_loader();
+init_screen();
+
+// src/renderer/types/screen.ts
+init_esm_shims();
+function setScreenDimensions(screen, width, height) {
+  screen.width = width;
+  screen.height = height;
+}
+
+// src/export/utils/virtual-terminal.ts
+init_esm_shims();
 var VirtualTerminal = class {
   constructor(width, height) {
     this.width = width;
@@ -1332,7 +1509,7 @@ var VirtualTerminal = class {
   buffer;
   colors;
   /**
-   * Set character at position
+   * Set character at position with optional color
    */
   setChar(x, y, char, color = "#ffffff") {
     if (x >= 0 && x < this.width && y >= 0 && y < this.height) {
@@ -1341,7 +1518,7 @@ var VirtualTerminal = class {
     }
   }
   /**
-   * Clear the buffer
+   * Clear the buffer to blank spaces
    */
   clear() {
     for (let y = 0; y < this.height; y++) {
@@ -1352,11 +1529,23 @@ var VirtualTerminal = class {
     }
   }
   /**
-   * Get buffer as string (for debugging)
+   * Get buffer contents as plain text string
    */
   toString() {
     return this.buffer.map((row) => row.join("")).join("\n");
   }
+  /**
+   * Get the raw character buffer
+   */
+  getBuffer() {
+    return this.buffer;
+  }
+  /**
+   * Get the color buffer
+   */
+  getColors() {
+    return this.colors;
+  }
   /**
    * Convert buffer to PNG image data
    */
@@ -1386,33 +1575,12 @@ async function renderTerminalToPng(buffer, colors, width, height) {
   }
   return canvas.toBuffer("image/png");
 }
-function captureScreen(screen, vt) {
-  const lines = screen.lines || [];
-  for (let y = 0; y < Math.min(lines.length, vt.height); y++) {
-    const line = lines[y];
-    if (!line) continue;
-    for (let x = 0; x < Math.min(line.length, vt.width); x++) {
-      const cell = line[x];
-      if (!cell) continue;
-      const char = Array.isArray(cell) ? cell[0] : cell;
-      const attr = Array.isArray(cell) ? cell[1] : null;
-      const color = extractColor(attr) || "#ffffff";
-      vt.setChar(x, y, char || " ", color);
-    }
-  }
-}
-function extractColor(attr) {
-  if (!attr) return null;
-  if (typeof attr === "object" && attr.fg !== void 0) {
-    if (typeof attr.fg === "string" && attr.fg.startsWith("#")) {
-      return attr.fg;
-    }
-    if (typeof attr.fg === "number") {
-      return ansi256ToHex(attr.fg);
-    }
-  }
-  return null;
-}
+
+// src/export/capture/screen-capture.ts
+init_esm_shims();
+
+// src/export/utils/color-conversion.ts
+init_esm_shims();
 function ansi256ToHex(code) {
   const standard16 = [
     "#000000",
@@ -1446,31 +1614,38 @@ function ansi256ToHex(code) {
   const hex = gray.toString(16).padStart(2, "0");
   return `#${hex}${hex}${hex}`;
 }
-async function createRecordingSession(options) {
-  const { tmpdir } = await import('os');
-  const { join: join3 } = await import('path');
-  const { mkdir: mkdir2 } = await import('fs/promises');
-  const tempDir = join3(tmpdir(), `term-deck-export-${Date.now()}`);
-  await mkdir2(tempDir, { recursive: true });
-  return {
-    tempDir,
-    frameCount: 0,
-    width: options.width ?? 120,
-    height: options.height ?? 40,
-    fps: options.fps ?? 30
-  };
-}
-async function saveFrame(session, png) {
-  const { join: join3 } = await import('path');
-  const frameNum = session.frameCount.toString().padStart(6, "0");
-  const framePath = join3(session.tempDir, `frame_${frameNum}.png`);
-  await writeFile(framePath, png);
-  session.frameCount++;
+function extractColor(attr) {
+  if (!attr) return null;
+  if (typeof attr === "object" && attr.fg !== void 0) {
+    if (typeof attr.fg === "string" && attr.fg.startsWith("#")) {
+      return attr.fg;
+    }
+    if (typeof attr.fg === "number") {
+      return ansi256ToHex(attr.fg);
+    }
+  }
+  return null;
 }
-async function cleanupSession(session) {
-  const { rm } = await import('fs/promises');
-  await rm(session.tempDir, { recursive: true, force: true });
+
+// src/export/capture/screen-capture.ts
+function captureScreen(screen, vt) {
+  const lines = screen.lines || [];
+  for (let y = 0; y < Math.min(lines.length, vt.height); y++) {
+    const line = lines[y];
+    if (!line) continue;
+    for (let x = 0; x < Math.min(line.length, vt.width); x++) {
+      const cell = line[x];
+      if (!cell) continue;
+      const char = Array.isArray(cell) ? cell[0] : cell;
+      const attr = Array.isArray(cell) ? cell[1] : null;
+      const color = extractColor(attr) || "#ffffff";
+      vt.setChar(x, y, char || " ", color);
+    }
+  }
 }
+
+// src/export/encoding/ffmpeg-encoder.ts
+init_esm_shims();
 async function checkFfmpeg() {
   try {
     await execa("which", ["ffmpeg"]);
@@ -1487,36 +1662,38 @@ function detectFormat(output) {
     `Unknown output format for ${output}. Use .mp4 or .gif extension.`
   );
 }
-async function encodeVideo(session, output, format, quality) {
-  const { join: join3 } = await import('path');
-  const inputPattern = join3(session.tempDir, "frame_%06d.png");
+async function encodeVideo(options) {
+  const { inputPattern, output, format, fps, quality } = options;
   if (format === "mp4") {
-    await encodeMp4(inputPattern, output, session.fps, quality ?? 80);
+    await encodeMp4(inputPattern, output, fps, quality ?? 80);
   } else {
-    await encodeGif(inputPattern, output, session.fps);
+    await encodeGif(inputPattern, output, fps);
   }
 }
 async function encodeMp4(input, output, fps, quality) {
   const crf = Math.round(51 - quality / 100 * 33);
   await execa("ffmpeg", [
     "-y",
+    // Overwrite output file
     "-framerate",
     fps.toString(),
     "-i",
     input,
     "-c:v",
     "libx264",
+    // H.264 codec
     "-crf",
     crf.toString(),
     "-pix_fmt",
     "yuv420p",
+    // Pixel format for compatibility
     output
   ]);
 }
 async function encodeGif(input, output, fps) {
-  const { tmpdir } = await import('os');
-  const { join: join3 } = await import('path');
-  const paletteFile = join3(tmpdir(), `palette-${Date.now()}.png`);
+  const { tmpdir: tmpdir2 } = await import('os');
+  const { join: join5 } = await import('path');
+  const paletteFile = join5(tmpdir2(), `palette-${Date.now()}.png`);
   try {
     await execa("ffmpeg", [
       "-y",
@@ -1547,20 +1724,29 @@ async function encodeGif(input, output, fps) {
     }
   }
 }
+
+// src/export/presentation-exporter.ts
+async function encodeFramesToVideo(tempDir, output, format, fps, quality) {
+  const inputPattern = join(tempDir, "frame_%06d.png");
+  await encodeVideo({
+    inputPattern,
+    output,
+    format,
+    fps,
+    quality
+  });
+}
 async function exportPresentation(slidesDir, options) {
   await checkFfmpeg();
   const format = detectFormat(options.output);
-  const { loadDeck: loadDeck2 } = await Promise.resolve().then(() => (init_slide2(), slide_exports));
-  const deck = await loadDeck2(slidesDir);
+  const deck = await loadDeck(slidesDir);
   if (deck.slides.length === 0) {
     throw new Error(`No slides found in ${slidesDir}`);
   }
   const session = await createRecordingSession(options);
   const vt = new VirtualTerminal(session.width, session.height);
-  const { createRenderer: createRenderer2, destroyRenderer: destroyRenderer2, renderSlide: renderSlide2 } = await Promise.resolve().then(() => (init_screen(), screen_exports));
-  const renderer = createRenderer2(deck.config.theme);
-  renderer.screen.width = session.width;
-  renderer.screen.height = session.height;
+  const renderer = createRenderer(deck.config.theme);
+  setScreenDimensions(renderer.screen, session.width, session.height);
   const slideTime = options.slideTime ?? 3;
   const framesPerSlide = session.fps * slideTime;
   console.log(`Exporting ${deck.slides.length} slides...`);
@@ -1577,14 +1763,25 @@ async function exportPresentation(slidesDir, options) {
       }
     }
     console.log("Encoding video...");
-    await encodeVideo(session, options.output, format, options.quality);
+    await encodeFramesToVideo(
+      session.tempDir,
+      options.output,
+      format,
+      session.fps,
+      options.quality
+    );
     console.log(`Exported to ${options.output}`);
   } finally {
-    destroyRenderer2(renderer);
+    destroyRenderer(renderer);
     await cleanupSession(session);
   }
 }
 
+// src/export/ansi-recorder.ts
+init_esm_shims();
+init_deck_loader();
+init_screen();
+
 // src/cli/commands/export.ts
 var exportCommand = new Command("export").description("Export presentation to GIF or MP4").argument("<dir>", "Slides directory").requiredOption("-o, --output <file>", "Output file (.mp4 or .gif)").option("-w, --width <n>", "Terminal width in characters", "120").option("-h, --height <n>", "Terminal height in characters", "40").option("--fps <n>", "Frames per second", "30").option("-t, --slide-time <n>", "Seconds per slide", "3").option("-q, --quality <n>", "Quality 1-100 (video only)", "80").action(async (dir, options) => {
   try {