@pep/term-deck 1.0.13 → 1.0.15

package/dist/bin/term-deck.js

@@ -0,0 +1,1720 @@
+#!/usr/bin/env node
+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 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 figlet from 'figlet';
+import { Command } from 'commander';
+import { execa } from 'execa';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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"() {
+    init_esm_shims();
+    HexColorSchema = z.string().regex(/^#[0-9a-fA-F]{6}$/, {
+      message: "Color must be a valid hex color (e.g., #ff0066)"
+    });
+    GradientSchema = z.array(HexColorSchema).min(2, {
+      message: "Gradient must have at least 2 colors"
+    });
+    ThemeSchema = z.object({
+      // Theme metadata
+      name: z.string().min(1, { message: "Theme name is required" }),
+      description: z.string().optional(),
+      author: z.string().optional(),
+      version: z.string().optional(),
+      // Color palette
+      colors: z.object({
+        primary: HexColorSchema,
+        secondary: HexColorSchema.optional(),
+        accent: HexColorSchema,
+        background: HexColorSchema,
+        text: HexColorSchema,
+        muted: HexColorSchema,
+        success: HexColorSchema.optional(),
+        warning: HexColorSchema.optional(),
+        error: HexColorSchema.optional()
+      }),
+      // Named gradients for bigText
+      gradients: z.record(z.string(), GradientSchema).refine(
+        (g) => Object.keys(g).length >= 1,
+        { message: "At least one gradient must be defined" }
+      ),
+      // Glyph set for matrix rain background
+      glyphs: z.string().min(10, {
+        message: "Glyph set must have at least 10 characters"
+      }),
+      // Animation settings
+      animations: z.object({
+        // Speed multiplier (1.0 = normal, 0.5 = half speed, 2.0 = double speed)
+        revealSpeed: z.number().min(0.1).max(5).default(1),
+        // Matrix rain density (number of drops)
+        matrixDensity: z.number().min(10).max(200).default(50),
+        // Glitch effect iterations
+        glitchIterations: z.number().min(1).max(20).default(5),
+        // Delay between lines during reveal (ms)
+        lineDelay: z.number().min(0).max(500).default(30),
+        // Matrix rain update interval (ms)
+        matrixInterval: z.number().min(20).max(200).default(80)
+      }),
+      // Window appearance
+      window: z.object({
+        // Border style
+        borderStyle: z.enum(["line", "double", "rounded", "none"]).default("line"),
+        // Shadow effect
+        shadow: z.boolean().default(true),
+        // Padding inside windows
+        padding: z.object({
+          top: z.number().min(0).max(5).default(1),
+          bottom: z.number().min(0).max(5).default(1),
+          left: z.number().min(0).max(10).default(2),
+          right: z.number().min(0).max(10).default(2)
+        }).optional()
+      }).optional()
+    });
+    ThemeSchema.deepPartial();
+    DEFAULT_THEME = {
+      name: "matrix",
+      description: "Default cyberpunk/matrix theme",
+      colors: {
+        primary: "#00cc66",
+        accent: "#ff6600",
+        background: "#0a0a0a",
+        text: "#ffffff",
+        muted: "#666666"
+      },
+      gradients: {
+        fire: ["#ff6600", "#ff3300", "#ff0066"],
+        cool: ["#00ccff", "#0066ff", "#6600ff"],
+        pink: ["#ff0066", "#ff0099", "#cc00ff"],
+        hf: ["#99cc00", "#00cc66", "#00cccc"]
+      },
+      glyphs: "\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\uFF9D0123456789",
+      animations: {
+        revealSpeed: 1,
+        matrixDensity: 50,
+        glitchIterations: 5,
+        lineDelay: 30,
+        matrixInterval: 80
+      },
+      window: {
+        borderStyle: "line",
+        shadow: true,
+        padding: {
+          top: 1,
+          bottom: 1,
+          left: 2,
+          right: 2
+        }
+      }
+    };
+  }
+});
+var SettingsSchema, ExportSettingsSchema, DeckConfigSchema;
+var init_config = __esm({
+  "src/schemas/config.ts"() {
+    init_esm_shims();
+    init_theme();
+    SettingsSchema = z.object({
+      // Start slide (0-indexed)
+      startSlide: z.number().min(0).default(0),
+      // Loop back to first slide after last
+      loop: z.boolean().default(false),
+      // Auto-advance slides (ms, 0 = disabled)
+      autoAdvance: z.number().min(0).default(0),
+      // Show slide numbers
+      showSlideNumbers: z.boolean().default(false),
+      // Show progress bar
+      showProgress: z.boolean().default(false)
+    });
+    ExportSettingsSchema = z.object({
+      // Output width in characters (min 80, max 400)
+      width: z.number().min(80).max(400).default(120),
+      // Output height in characters (min 24, max 100)
+      height: z.number().min(24).max(100).default(40),
+      // Frames per second for video (min 10, max 60)
+      fps: z.number().min(10).max(60).default(30)
+    });
+    DeckConfigSchema = z.object({
+      // Presentation metadata
+      title: z.string().optional(),
+      author: z.string().optional(),
+      date: z.string().optional(),
+      // Theme (already validated Theme object)
+      theme: ThemeSchema,
+      // Presentation settings
+      settings: SettingsSchema.optional(),
+      // Export settings
+      export: ExportSettingsSchema.optional()
+    });
+  }
+});
+
+// src/schemas/validation.ts
+function formatZodError(error, context) {
+  const issues = error.issues.map((issue) => {
+    const path2 = issue.path.join(".");
+    return `  - ${path2 ? `${path2}: ` : ""}${issue.message}`;
+  });
+  return `Invalid ${context}:
+${issues.join("\n")}`;
+}
+function safeParse(schema, data, context) {
+  const result = schema.safeParse(data);
+  if (!result.success) {
+    throw new ValidationError(formatZodError(result.error, context));
+  }
+  return result.data;
+}
+var ValidationError;
+var init_validation = __esm({
+  "src/schemas/validation.ts"() {
+    init_esm_shims();
+    ValidationError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "ValidationError";
+      }
+    };
+  }
+});
+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"() {
+    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"
+    };
+  }
+});
+
+// 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) {
+    return { body: content };
+  }
+  const body = content.slice(0, notesStart).trim();
+  const notesEnd = content.indexOf(NOTES_END_MARKER, notesStart);
+  let notes;
+  if (notesEnd !== -1) {
+    notes = content.slice(notesStart + NOTES_MARKER.length, notesEnd).trim();
+  } else {
+    notes = content.slice(notesStart + NOTES_MARKER.length).trim();
+  }
+  return { body, notes: notes || void 0 };
+}
+async function parseSlide(filePath, index) {
+  const content = await readFile(filePath, "utf-8");
+  const { data, content: rawBody } = matter(content);
+  const { body, notes } = extractNotes(rawBody);
+  const frontmatter = safeParse(
+    SlideFrontmatterSchema,
+    data,
+    `frontmatter in ${filePath}`
+  );
+  const slide = {
+    frontmatter,
+    body: body.trim(),
+    notes: notes?.trim(),
+    sourcePath: filePath,
+    index
+  };
+  return safeParse(SlideSchema, slide, `slide ${filePath}`);
+}
+async function findSlideFiles(dir) {
+  const pattern = join(dir, "*.md");
+  const foundFiles = await fg(pattern, { onlyFiles: true });
+  const files = [];
+  for (const filePath of foundFiles) {
+    const name = filePath.split("/").pop() || "";
+    if (name === "README.md" || name.startsWith("_")) {
+      continue;
+    }
+    files.push({
+      path: filePath,
+      name,
+      index: 0
+      // Will be set after sorting
+    });
+  }
+  files.sort((a, b) => a.name.localeCompare(b.name, void 0, { numeric: true }));
+  files.forEach((file, i) => {
+    file.index = i;
+  });
+  return files;
+}
+async function loadDeckConfig(slidesDir) {
+  const configPath = join(slidesDir, "deck.config.ts");
+  try {
+    try {
+      await access(configPath);
+    } catch {
+      return {
+        theme: DEFAULT_THEME
+      };
+    }
+    const configModule = await import(configPath + "?t=" + Date.now());
+    if (!configModule.default) {
+      throw new Error("deck.config.ts must export default config");
+    }
+    return safeParse(DeckConfigSchema, configModule.default, "deck.config.ts");
+  } catch (error) {
+    if (error.code === "MODULE_NOT_FOUND") {
+      return { theme: DEFAULT_THEME };
+    }
+    throw error;
+  }
+}
+async function loadDeck(slidesDir) {
+  const config = await loadDeckConfig(slidesDir);
+  const slideFiles = await findSlideFiles(slidesDir);
+  const slides = await Promise.all(
+    slideFiles.map((file) => parseSlide(file.path, file.index))
+  );
+  return {
+    slides,
+    config,
+    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"() {
+    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 {
+      /**
+       * @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 cause - Optional underlying error that caused this failure
+       */
+      constructor(message, slidesDir, cause) {
+        super(message);
+        this.slidesDir = slidesDir;
+        this.cause = cause;
+        this.name = "DeckLoadError";
+      }
+    };
+  }
+});
+
+// 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;
+  const width = Math.max(20, screen.width || 80);
+  const height = Math.max(10, screen.height || 24);
+  const grid = Array.from(
+    { length: height },
+    () => Array(width).fill(" ")
+  );
+  for (const drop of matrixDrops) {
+    drop.y += drop.speed;
+    if (drop.y > height + drop.trail.length) {
+      drop.y = -drop.trail.length;
+      drop.x = Math.floor(Math.random() * width);
+    }
+    for (let i = 0; i < drop.trail.length; i++) {
+      const y = Math.floor(drop.y) - i;
+      if (y >= 0 && y < height && drop.x < width) {
+        grid[y][drop.x] = drop.trail[i];
+      }
+    }
+  }
+  let output = "";
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const char = grid[y][x];
+      if (char !== " ") {
+        const brightness = Math.random() > 0.7 ? "{bold}" : "";
+        output += `${brightness}{${theme.colors.primary}-fg}${char}{/}`;
+      } else {
+        output += " ";
+      }
+    }
+    if (y < height - 1) output += "\n";
+  }
+  matrixBox.setContent(output);
+}
+function initMatrixRain(renderer) {
+  const { screen, theme } = renderer;
+  const width = screen.width || 80;
+  const height = screen.height || 24;
+  const density = theme.animations.matrixDensity;
+  renderer.matrixDrops = [];
+  for (let i = 0; i < density; i++) {
+    renderer.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();
+  }, theme.animations.matrixInterval);
+}
+function createRenderer(theme) {
+  const screen = createScreen();
+  const matrixBox = blessed.box({
+    top: 0,
+    left: 0,
+    width: "100%",
+    height: "100%",
+    tags: true
+  });
+  screen.append(matrixBox);
+  const renderer = {
+    screen,
+    matrixBox,
+    windowStack: [],
+    theme,
+    matrixDrops: [],
+    matrixInterval: null
+  };
+  initMatrixRain(renderer);
+  return renderer;
+}
+function destroyRenderer(renderer) {
+  if (renderer.matrixInterval) {
+    clearInterval(renderer.matrixInterval);
+    renderer.matrixInterval = null;
+  }
+  for (const win of renderer.windowStack) {
+    win.destroy();
+  }
+  renderer.windowStack = [];
+  renderer.screen.destroy();
+}
+function getWindowColor(index, theme) {
+  const colors = [
+    theme.colors.primary,
+    theme.colors.accent,
+    theme.colors.secondary ?? theme.colors.primary,
+    "#ff0066",
+    // pink
+    "#9966ff",
+    // purple
+    "#ffcc00"
+    // yellow
+  ];
+  return colors[index % colors.length];
+}
+function createWindow(renderer, options) {
+  const { screen, windowStack, theme } = renderer;
+  const windowIndex = windowStack.length;
+  const color = options.color ?? getWindowColor(windowIndex, theme);
+  const screenWidth = screen.width || 120;
+  const screenHeight = screen.height || 40;
+  const width = options.width ?? Math.floor(screenWidth * 0.75);
+  const height = options.height ?? Math.floor(screenHeight * 0.7);
+  const maxTop = Math.max(1, screenHeight - height - 2);
+  const maxLeft = Math.max(1, screenWidth - width - 2);
+  const top = options.top ?? Math.floor(Math.random() * maxTop);
+  const left = options.left ?? Math.floor(Math.random() * maxLeft);
+  const window = theme.window ?? { borderStyle: "line", shadow: true };
+  const padding = window.padding ?? { top: 1, bottom: 1, left: 2, right: 2 };
+  const box = blessed.box({
+    top,
+    left,
+    width,
+    height,
+    border: {
+      type: window.borderStyle === "none" ? void 0 : "line"
+    },
+    label: ` ${options.title} `,
+    style: {
+      fg: theme.colors.text,
+      bg: theme.colors.background,
+      border: { fg: color },
+      label: { fg: color, bold: true }
+    },
+    padding,
+    tags: true,
+    shadow: window.shadow
+  });
+  screen.append(box);
+  windowStack.push(box);
+  return box;
+}
+function clearWindows(renderer) {
+  for (const window of renderer.windowStack) {
+    window.destroy();
+  }
+  renderer.windowStack = [];
+}
+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));
+    });
+  });
+}
+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));
+}
+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;
+      }
+    }
+    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);
+    }
+  }
+}
+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);
+  }
+  box.setContent(content);
+  screen.render();
+}
+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);
+    }
+  }
+}
+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();
+  }
+}
+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";
+  }
+  const processedBody = await processSlideContent(body, theme);
+  content += processedBody;
+  const transition = frontmatter.transition ?? "glitch";
+  await applyTransition(window, renderer.screen, content, transition, theme);
+  return window;
+}
+var GLITCH_CHARS, PROTECTED_CHARS;
+var init_screen = __esm({
+  "src/renderer/screen.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";
+    PROTECTED_CHARS = /* @__PURE__ */ new Set([
+      " ",
+      "	",
+      "\n",
+      "{",
+      "}",
+      "-",
+      "/",
+      "#",
+      "[",
+      "]",
+      "(",
+      ")",
+      ":",
+      ";",
+      ",",
+      ".",
+      "!",
+      "?",
+      "'",
+      '"',
+      "`",
+      "_",
+      "|",
+      "\\",
+      "<",
+      ">",
+      "=",
+      "+",
+      "*",
+      "&",
+      "^",
+      "%",
+      "$",
+      "@",
+      "~",
+      // Box drawing
+      "\u250C",
+      "\u2510",
+      "\u2514",
+      "\u2518",
+      "\u2502",
+      "\u2500",
+      "\u251C",
+      "\u2524",
+      "\u252C",
+      "\u2534",
+      "\u253C",
+      "\u2550",
+      "\u2551",
+      "\u2554",
+      "\u2557",
+      "\u255A",
+      "\u255D",
+      "\u2560",
+      "\u2563",
+      "\u2566",
+      "\u2569",
+      "\u256C",
+      "\u256D",
+      "\u256E",
+      "\u256F",
+      "\u2570",
+      // Arrows
+      "\u2192",
+      "\u2190",
+      "\u2191",
+      "\u2193",
+      "\u25B6",
+      "\u25C0",
+      "\u25B2",
+      "\u25BC",
+      "\u25BA",
+      "\u25C4"
+    ]);
+  }
+});
+
+// src/presenter/main.ts
+var main_exports = {};
+__export(main_exports, {
+  jumpToSlide: () => jumpToSlide,
+  nextSlide: () => nextSlide,
+  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
+  };
+  if (options.showNotes) {
+    presenter.notesWindow = await createNotesWindow(options.notesTty);
+  }
+  if (deck.config.settings?.showProgress) {
+    presenter.progressBar = createProgressBar(presenter);
+  }
+  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) {
+    presenter.notesWindow.screen.destroy();
+  }
+  destroyRenderer(presenter.renderer);
+}
+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);
+  presenter.renderer.screen.render();
+  if (presenter.notesWindow) {
+    updateNotesWindow(presenter);
+  }
+  if (presenter.progressBar) {
+    updateProgress(presenter.progressBar, presenter.currentSlide, presenter.deck.slides.length);
+  }
+  presenter.isAnimating = false;
+}
+async function nextSlide(presenter) {
+  const nextIndex = presenter.currentSlide + 1;
+  const { slides } = presenter.deck;
+  const loop = presenter.deck.config.settings?.loop ?? false;
+  if (nextIndex >= slides.length) {
+    if (loop) {
+      await showSlide(presenter, 0);
+    }
+    return;
+  }
+  await showSlide(presenter, nextIndex);
+}
+async function prevSlide(presenter) {
+  const prevIndex = presenter.currentSlide - 1;
+  const { slides } = presenter.deck;
+  const loop = presenter.deck.config.settings?.loop ?? false;
+  if (prevIndex < 0) {
+    if (loop) {
+      clearWindows(presenter.renderer);
+      for (let i = 0; i < slides.length; i++) {
+        await renderSlide(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);
+      }
+      presenter.renderer.screen.render();
+    }
+    return;
+  }
+  clearWindows(presenter.renderer);
+  for (let i = 0; i <= prevIndex; i++) {
+    await renderSlide(presenter.renderer, slides[i]);
+  }
+  presenter.currentSlide = prevIndex;
+  if (presenter.notesWindow) {
+    updateNotesWindow(presenter);
+  }
+  if (presenter.progressBar) {
+    updateProgress(presenter.progressBar, presenter.currentSlide, presenter.deck.slides.length);
+  }
+  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;
+  if (presenter.notesWindow) {
+    updateNotesWindow(presenter);
+  }
+  if (presenter.progressBar) {
+    updateProgress(presenter.progressBar, presenter.currentSlide, presenter.deck.slides.length);
+  }
+  presenter.renderer.screen.render();
+}
+function setupControls(presenter) {
+  const { screen } = presenter.renderer;
+  screen.key(["space", "enter", "right", "n"], () => {
+    nextSlide(presenter);
+  });
+  screen.key(["left", "backspace", "p"], () => {
+    prevSlide(presenter);
+  });
+  screen.key(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"], (ch) => {
+    const index = parseInt(ch, 10);
+    jumpToSlide(presenter, index);
+  });
+  screen.key(["l"], () => {
+    showSlideList(presenter);
+  });
+  screen.key(["N"], () => {
+    if (presenter.notesWindow) {
+      toggleNotesVisibility(presenter.notesWindow);
+    }
+  });
+}
+function showSlideList(presenter) {
+  const { screen } = presenter.renderer;
+  const { slides } = presenter.deck;
+  const listContent = slides.map((slide, i) => {
+    const marker = i === presenter.currentSlide ? "\u25B6 " : "  ";
+    return `${marker}${i}: ${slide.frontmatter.title}`;
+  }).join("\n");
+  const listBox = screen.box({
+    top: "center",
+    left: "center",
+    width: 50,
+    height: Math.min(slides.length + 4, 20),
+    border: { type: "line" },
+    label: " SLIDES (press number or Esc) ",
+    style: {
+      fg: "#ffffff",
+      bg: "#0a0a0a",
+      border: { fg: "#ffcc00" }
+    },
+    padding: 1,
+    tags: true,
+    content: listContent
+  });
+  screen.append(listBox);
+  screen.render();
+  const closeList = () => {
+    listBox.destroy();
+    screen.render();
+  };
+  screen.onceKey(["escape", "l", "q"], closeList);
+  screen.onceKey(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"], (ch) => {
+    closeList();
+    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 {
+    }
+  }
+  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
+  };
+}
+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";
+  }
+  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 startAutoAdvance(presenter) {
+  const interval = presenter.deck.config.settings?.autoAdvance;
+  if (!interval || interval <= 0) {
+    return null;
+  }
+  return setInterval(() => {
+    if (!presenter.isAnimating) {
+      nextSlide(presenter);
+    }
+  }, interval);
+}
+function stopAutoAdvance(timer) {
+  if (timer) {
+    clearInterval(timer);
+  }
+}
+function createProgressBar(presenter) {
+  const { screen } = presenter.renderer;
+  const progressBar = blessed.progressbar({
+    bottom: 0,
+    left: 0,
+    width: "100%",
+    height: 1,
+    style: {
+      bg: "#333333",
+      bar: { bg: "#00cc66" }
+    },
+    filled: 0
+  });
+  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_screen();
+  }
+});
+
+// bin/term-deck.ts
+init_esm_shims();
+
+// package.json
+var version = "1.0.15";
+
+// src/cli/commands/present.ts
+init_esm_shims();
+init_main();
+
+// src/cli/errors.ts
+init_esm_shims();
+init_validation();
+init_slide2();
+init_theme2();
+function handleError(error) {
+  if (error instanceof ValidationError) {
+    console.error(`
+${error.message}`);
+    process.exit(1);
+  }
+  if (error instanceof SlideParseError) {
+    console.error(`
+Slide error in ${error.filePath}:`);
+    console.error(`  ${error.message}`);
+    if (error.cause) {
+      const causeMessage = error.cause instanceof Error ? error.cause.message : String(error.cause);
+      console.error(`  Caused by: ${causeMessage}`);
+    }
+    process.exit(1);
+  }
+  if (error instanceof DeckLoadError) {
+    console.error(`
+Failed to load deck from ${error.slidesDir}:`);
+    console.error(`  ${error.message}`);
+    process.exit(1);
+  }
+  if (error instanceof ThemeError) {
+    console.error("\nTheme error:");
+    console.error(`  ${error.message}`);
+    process.exit(1);
+  }
+  if (error instanceof Error) {
+    if (error.message.includes("ENOENT")) {
+      console.error("\nFile or directory not found.");
+      console.error(`  ${error.message}`);
+      process.exit(1);
+    }
+    if (error.message.includes("ffmpeg")) {
+      console.error("\nffmpeg error:");
+      console.error(`  ${error.message}`);
+      console.error("\nMake sure ffmpeg is installed:");
+      console.error("  macOS: brew install ffmpeg");
+      console.error("  Ubuntu: sudo apt install ffmpeg");
+      process.exit(1);
+    }
+    console.error(`
+Error: ${error.message}`);
+    if (process.env.DEBUG) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+  console.error("\nUnknown error occurred");
+  console.error(error);
+  process.exit(1);
+}
+
+// src/cli/commands/present.ts
+var presentCommand = new Command("present").description("Start a presentation").argument("<dir>", "Slides directory").option("-s, --start <n>", "Start at slide number", "0").option("-n, --notes", "Show presenter notes in separate terminal").option("--notes-tty <path>", "TTY device for notes window (e.g., /dev/ttys001)").option("-l, --loop", "Loop back to first slide after last").action(async (dir, options) => {
+  try {
+    await present(dir, {
+      startSlide: Number.parseInt(options.start, 10),
+      showNotes: options.notes,
+      notesTty: options.notesTty,
+      loop: options.loop
+    });
+  } catch (error) {
+    handleError(error);
+  }
+});
+
+// src/cli/commands/export.ts
+init_esm_shims();
+
+// src/export/recorder.ts
+init_esm_shims();
+var VirtualTerminal = class {
+  constructor(width, height) {
+    this.width = width;
+    this.height = height;
+    this.buffer = Array.from(
+      { length: height },
+      () => Array(width).fill(" ")
+    );
+    this.colors = Array.from(
+      { length: height },
+      () => Array(width).fill("#ffffff")
+    );
+  }
+  buffer;
+  colors;
+  /**
+   * Set character at position
+   */
+  setChar(x, y, char, color = "#ffffff") {
+    if (x >= 0 && x < this.width && y >= 0 && y < this.height) {
+      this.buffer[y][x] = char;
+      this.colors[y][x] = color;
+    }
+  }
+  /**
+   * Clear the buffer
+   */
+  clear() {
+    for (let y = 0; y < this.height; y++) {
+      for (let x = 0; x < this.width; x++) {
+        this.buffer[y][x] = " ";
+        this.colors[y][x] = "#ffffff";
+      }
+    }
+  }
+  /**
+   * Get buffer as string (for debugging)
+   */
+  toString() {
+    return this.buffer.map((row) => row.join("")).join("\n");
+  }
+  /**
+   * Convert buffer to PNG image data
+   */
+  async toPng() {
+    return renderTerminalToPng(this.buffer, this.colors, this.width, this.height);
+  }
+};
+var CHAR_WIDTH = 10;
+var CHAR_HEIGHT = 20;
+async function renderTerminalToPng(buffer, colors, width, height) {
+  const { createCanvas } = await import('canvas');
+  const canvas = createCanvas(width * CHAR_WIDTH, height * CHAR_HEIGHT);
+  const ctx = canvas.getContext("2d");
+  ctx.fillStyle = "#0a0a0a";
+  ctx.fillRect(0, 0, canvas.width, canvas.height);
+  ctx.font = `${CHAR_HEIGHT - 4}px monospace`;
+  ctx.textBaseline = "top";
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const char = buffer[y][x];
+      const color = colors[y][x];
+      if (char !== " ") {
+        ctx.fillStyle = color;
+        ctx.fillText(char, x * CHAR_WIDTH, y * CHAR_HEIGHT + 2);
+      }
+    }
+  }
+  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;
+}
+function ansi256ToHex(code) {
+  const standard16 = [
+    "#000000",
+    "#800000",
+    "#008000",
+    "#808000",
+    "#000080",
+    "#800080",
+    "#008080",
+    "#c0c0c0",
+    "#808080",
+    "#ff0000",
+    "#00ff00",
+    "#ffff00",
+    "#0000ff",
+    "#ff00ff",
+    "#00ffff",
+    "#ffffff"
+  ];
+  if (code < 16) {
+    return standard16[code];
+  }
+  if (code < 232) {
+    const n = code - 16;
+    const r = Math.floor(n / 36) * 51;
+    const g = Math.floor(n % 36 / 6) * 51;
+    const b = n % 6 * 51;
+    return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+  }
+  const gray = (code - 232) * 10 + 8;
+  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++;
+}
+async function cleanupSession(session) {
+  const { rm } = await import('fs/promises');
+  await rm(session.tempDir, { recursive: true, force: true });
+}
+async function checkFfmpeg() {
+  try {
+    await execa("which", ["ffmpeg"]);
+  } catch {
+    throw new Error(
+      "ffmpeg not found. Install it with:\n  macOS: brew install ffmpeg\n  Ubuntu: sudo apt install ffmpeg"
+    );
+  }
+}
+function detectFormat(output) {
+  if (output.endsWith(".gif")) return "gif";
+  if (output.endsWith(".mp4")) return "mp4";
+  throw new Error(
+    `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");
+  if (format === "mp4") {
+    await encodeMp4(inputPattern, output, session.fps, quality ?? 80);
+  } else {
+    await encodeGif(inputPattern, output, session.fps);
+  }
+}
+async function encodeMp4(input, output, fps, quality) {
+  const crf = Math.round(51 - quality / 100 * 33);
+  await execa("ffmpeg", [
+    "-y",
+    "-framerate",
+    fps.toString(),
+    "-i",
+    input,
+    "-c:v",
+    "libx264",
+    "-crf",
+    crf.toString(),
+    "-pix_fmt",
+    "yuv420p",
+    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`);
+  try {
+    await execa("ffmpeg", [
+      "-y",
+      "-framerate",
+      fps.toString(),
+      "-i",
+      input,
+      "-vf",
+      `fps=${fps},scale=-1:-1:flags=lanczos,palettegen=stats_mode=diff`,
+      paletteFile
+    ]);
+    await execa("ffmpeg", [
+      "-y",
+      "-framerate",
+      fps.toString(),
+      "-i",
+      input,
+      "-i",
+      paletteFile,
+      "-lavfi",
+      `fps=${fps},scale=-1:-1:flags=lanczos[x];[x][1:v]paletteuse=dither=bayer:bayer_scale=5:diff_mode=rectangle`,
+      output
+    ]);
+  } finally {
+    try {
+      await unlink(paletteFile);
+    } catch {
+    }
+  }
+}
+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);
+  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 slideTime = options.slideTime ?? 3;
+  const framesPerSlide = session.fps * slideTime;
+  console.log(`Exporting ${deck.slides.length} slides...`);
+  try {
+    for (let i = 0; i < deck.slides.length; i++) {
+      const slide = deck.slides[i];
+      console.log(`  Slide ${i + 1}/${deck.slides.length}: ${slide.frontmatter.title}`);
+      await renderSlide2(renderer, slide);
+      for (let f = 0; f < framesPerSlide; f++) {
+        renderer.screen.render();
+        captureScreen(renderer.screen, vt);
+        const png = await vt.toPng();
+        await saveFrame(session, png);
+      }
+    }
+    console.log("Encoding video...");
+    await encodeVideo(session, options.output, format, options.quality);
+    console.log(`Exported to ${options.output}`);
+  } finally {
+    destroyRenderer2(renderer);
+    await cleanupSession(session);
+  }
+}
+
+// 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 {
+    await exportPresentation(dir, {
+      output: options.output,
+      width: Number.parseInt(options.width, 10),
+      height: Number.parseInt(options.height, 10),
+      fps: Number.parseInt(options.fps, 10),
+      slideTime: Number.parseFloat(options.slideTime),
+      quality: Number.parseInt(options.quality, 10)
+    });
+  } catch (error) {
+    handleError(error);
+  }
+});
+
+// src/cli/commands/init.ts
+init_esm_shims();
+var initCommand = new Command("init").description("Create a new presentation deck").argument("<name>", "Deck name (will create directory)").option("-t, --theme <name>", "Theme to use", "matrix").action(async (name, options) => {
+  try {
+    await initDeck(name, options.theme);
+    console.log(`Created deck: ${name}/`);
+    console.log("\nNext steps:");
+    console.log(`  cd ${name}/slides`);
+    console.log("  term-deck present .");
+  } catch (error) {
+    handleError(error);
+  }
+});
+async function initDeck(name, theme) {
+  const deckDir = join(process.cwd(), name);
+  const slidesDir = join(deckDir, "slides");
+  await mkdir(slidesDir, { recursive: true });
+  await writeFile(join(slidesDir, ".gitkeep"), "");
+  const configContent = `import { defineConfig } from 'term-deck'
+import matrix from '@term-deck/theme-matrix'
+
+export default defineConfig({
+  title: '${name}',
+  theme: matrix,
+})
+`;
+  await writeFile(join(slidesDir, "deck.config.ts"), configContent);
+  const slide1 = `---
+title: ${name.toUpperCase()}
+bigText: ${name.toUpperCase()}
+gradient: fire
+---
+
+{GREEN}Welcome to your presentation{/}
+
+Press {CYAN}Space{/} or {CYAN}\u2192{/} to advance
+`;
+  const slide2 = `---
+title: SLIDE TWO
+bigText: HELLO
+gradient: cool
+---
+
+{WHITE}This is the second slide{/}
+
+- Point one
+- Point two
+- Point three
+
+<!-- notes -->
+Remember to explain each point clearly.
+`;
+  const slide3 = `---
+title: THE END
+bigText: FIN
+gradient: pink
+---
+
+{ORANGE}Thank you!{/}
+
+Press {CYAN}q{/} to exit
+`;
+  await writeFile(join(slidesDir, "01-intro.md"), slide1);
+  await writeFile(join(slidesDir, "02-content.md"), slide2);
+  await writeFile(join(slidesDir, "03-end.md"), slide3);
+  const readme = `# ${name}
+
+A term-deck presentation.
+
+## Usage
+
+\`\`\`bash
+cd slides
+term-deck present .
+\`\`\`
+
+## Export
+
+\`\`\`bash
+term-deck export slides/ -o ${name}.mp4
+term-deck export slides/ -o ${name}.gif
+\`\`\`
+
+## Hotkeys
+
+| Key | Action |
+|-----|--------|
+| Space / \u2192 | Next slide |
+| \u2190 | Previous slide |
+| 0-9 | Jump to slide |
+| l | Show slide list |
+| q | Quit |
+`;
+  await writeFile(join(deckDir, "README.md"), readme);
+}
+
+// bin/term-deck.ts
+var program = new Command();
+program.name("term-deck").description("Terminal presentation tool with a cyberpunk aesthetic").version(version);
+program.addCommand(presentCommand);
+program.addCommand(exportCommand);
+program.addCommand(initCommand);
+program.argument("[dir]", "Slides directory to present").action(async (dir) => {
+  if (dir) {
+    try {
+      const { present: present2 } = await Promise.resolve().then(() => (init_main(), main_exports));
+      await present2(dir, {});
+    } catch (error) {
+      handleError(error);
+    }
+  } else {
+    program.help();
+  }
+});
+program.parse();
+//# sourceMappingURL=term-deck.js.map
+//# sourceMappingURL=term-deck.js.map