slides-grab 1.1.2 → 1.1.3

package/README.md

@@ -69,8 +69,10 @@ slides-grab edit              # Launch visual slide editor
 slides-grab build-viewer      # Build single-file viewer.html
 slides-grab validate          # Validate slide HTML (Playwright-based)
 slides-grab convert           # Export to experimental / unstable PPTX
+slides-grab convert --resolution 2160p  # Higher-resolution raster PPTX export
 slides-grab figma             # Export an experimental / unstable Figma Slides importable PPTX
 slides-grab pdf               # Export PDF in capture mode (default)
+slides-grab pdf --resolution 2160p  # Higher-resolution image-backed PDF export
 slides-grab pdf --mode print  # Export searchable/selectable text PDF
 slides-grab list-templates    # Show available slide templates
 slides-grab list-themes       # Show available color themes
@@ -89,6 +91,8 @@ Run `slides-grab validate --slides-dir <path>` before export to catch missing lo
 
 `slides-grab pdf` now defaults to `--mode capture`, which rasterizes each rendered slide into the PDF for better visual fidelity. Use `--mode print` when searchable/selectable browser text matters more than pixel-perfect parity.
 
+`slides-grab pdf` and `slides-grab convert` now default to `2160p` / `4k` raster output for sharper exports. You can still override with `--resolution <preset>` using `720p`, `1080p`, `1440p`, `2160p`, or `4k` when you want smaller or faster artifacts.
+
 ### Multi-Deck Workflow
 
 Prerequisite: create or generate a deck in `decks/my-deck/` first.

package/bin/ppt-agent.js

@@ -106,11 +106,15 @@ program
   .description('Convert slide HTML files to experimental / unstable PPTX')
   .option('--slides-dir <path>', 'Slide directory', 'slides')
   .option('--output <path>', 'Output PPTX file')
+  .option('--resolution <preset>', 'Raster size preset: 720p, 1080p, 1440p, 2160p, or 4k (default: 2160p)')
   .action(async (options = {}) => {
     const args = ['--slides-dir', options.slidesDir];
     if (options.output) {
       args.push('--output', String(options.output));
     }
+    if (options.resolution) {
+      args.push('--resolution', String(options.resolution));
+    }
     await runCommand('convert.cjs', args);
   });
 
@@ -120,6 +124,7 @@ program
   .option('--slides-dir <path>', 'Slide directory', 'slides')
   .option('--output <path>', 'Output PDF file')
   .option('--mode <mode>', 'PDF export mode: capture for visual fidelity, print for searchable text', 'capture')
+  .option('--resolution <preset>', 'Capture raster size preset: 720p, 1080p, 1440p, 2160p, or 4k (default: 2160p in capture mode)')
   .action(async (options = {}) => {
     const args = ['--slides-dir', options.slidesDir];
     if (options.output) {
@@ -128,6 +133,9 @@ program
     if (options.mode) {
       args.push('--mode', String(options.mode));
     }
+    if (options.resolution) {
+      args.push('--resolution', String(options.resolution));
+    }
     await runCommand('scripts/html2pdf.js', args);
   });
 

package/convert.cjs

@@ -3,10 +3,16 @@ const { chromium } = require('playwright');
 const path = require('path');
 const fs = require('fs');
 const sharp = require('sharp');
+const {
+  getResolutionChoices,
+  getResolutionSize,
+  normalizeResolutionPreset,
+} = require('./src/export-resolution.cjs');
 
 // Inline a simplified version that uses Playwright Chromium (not Chrome)
 const DEFAULT_SLIDES_DIR = 'slides';
 const DEFAULT_OUTPUT = 'output.pptx';
+const DEFAULT_RESOLUTION = '2160p';
 const DEFAULT_CAPTURE_VIEWPORT = { width: 960, height: 540 };
 const DEFAULT_CAPTURE_DEVICE_SCALE_FACTOR = 2;
 const TARGET_RASTER_DPI = 150;
@@ -19,17 +25,25 @@ function normalizeDimension(value, fallback) {
   return Math.max(1, Math.round(value));
 }
 
-function buildPageOptions() {
+function buildPageOptions(resolution = '') {
+  const targetResolution = getResolutionSize(resolution);
   return {
     viewport: {
       width: DEFAULT_CAPTURE_VIEWPORT.width,
       height: DEFAULT_CAPTURE_VIEWPORT.height,
     },
-    deviceScaleFactor: DEFAULT_CAPTURE_DEVICE_SCALE_FACTOR,
+    deviceScaleFactor: targetResolution
+      ? targetResolution.height / DEFAULT_CAPTURE_VIEWPORT.height
+      : DEFAULT_CAPTURE_DEVICE_SCALE_FACTOR,
   };
 }
 
-function getTargetRasterSize() {
+function getTargetRasterSize(resolution = '') {
+  const targetResolution = getResolutionSize(resolution);
+  if (targetResolution) {
+    return targetResolution;
+  }
+
   return {
     width: Math.round(TARGET_SLIDE_SIZE_IN.width * TARGET_RASTER_DPI),
     height: Math.round(TARGET_SLIDE_SIZE_IN.height * TARGET_RASTER_DPI),
@@ -44,6 +58,7 @@ function printUsage() {
       'Options:',
       `  --slides-dir <path>  Slide directory (default: ${DEFAULT_SLIDES_DIR})`,
       `  --output <path>      Output pptx path (default: ${DEFAULT_OUTPUT})`,
+      `  --resolution <preset> Raster size preset: ${getResolutionChoices().join('|')}|4k (default: ${DEFAULT_RESOLUTION})`,
       '  -h, --help           Show this help message',
     ].join('\n'),
   );
@@ -62,6 +77,7 @@ function parseArgs(args) {
   const options = {
     slidesDir: DEFAULT_SLIDES_DIR,
     output: DEFAULT_OUTPUT,
+    resolution: DEFAULT_RESOLUTION,
     help: false,
   };
 
@@ -94,6 +110,17 @@ function parseArgs(args) {
       continue;
     }
 
+    if (arg === '--resolution') {
+      options.resolution = normalizeResolutionPreset(readOptionValue(args, i, '--resolution'));
+      i += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--resolution=')) {
+      options.resolution = normalizeResolutionPreset(arg.slice('--resolution='.length));
+      continue;
+    }
+
     throw new Error(`Unknown option: ${arg}`);
   }
 
@@ -107,13 +134,14 @@ function parseArgs(args) {
 
   options.slidesDir = options.slidesDir.trim();
   options.output = options.output.trim();
+  options.resolution = normalizeResolutionPreset(options.resolution);
   return options;
 }
 
-async function convertSlide(htmlFile, pres, browser) {
+async function convertSlide(htmlFile, pres, browser, options = {}) {
   const filePath = path.isAbsolute(htmlFile) ? htmlFile : path.join(process.cwd(), htmlFile);
 
-  const page = await browser.newPage(buildPageOptions());
+  const page = await browser.newPage(buildPageOptions(options.resolution));
   await page.goto(`file://${filePath}`);
 
   const bodyDimensions = await page.evaluate(() => {
@@ -135,7 +163,7 @@ async function convertSlide(htmlFile, pres, browser) {
   await page.close();
 
   // Resize to exact slide dimensions (13.33" x 7.5" at 150 DPI)
-  const targetSize = getTargetRasterSize();
+  const targetSize = getTargetRasterSize(options.resolution);
 
   const resized = await sharp(screenshot)
     .resize(targetSize.width, targetSize.height, { fit: 'fill' })
@@ -184,7 +212,7 @@ async function main() {
     const filePath = path.join(slidesDir, file);
     console.log(`  Processing: ${file}`);
     try {
-      const tmpPath = await convertSlide(filePath, pres, browser);
+      const tmpPath = await convertSlide(filePath, pres, browser, { resolution: options.resolution });
       tmpFiles.push(tmpPath);
       console.log(`    ✓ ${file} done`);
     } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slides-grab",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "Agent-first presentation framework — plan, design, and visually edit HTML slides with Claude Code or Codex, then export to PDF or experimental/unstable PPTX/Figma formats",
   "license": "MIT",
   "author": "vkehfdl1",

package/scripts/html2pdf.js

@@ -1,16 +1,26 @@
 #!/usr/bin/env node
 
 import { readdir, writeFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
 import { basename, join, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { chromium } from 'playwright';
 import { PDFDocument } from 'pdf-lib';
+import sharp from 'sharp';
 
 import { ensureSlidesPassValidation } from './validate-slides.js';
 
+const require = createRequire(import.meta.url);
+const {
+  getResolutionChoices,
+  getResolutionSize,
+  normalizeResolutionPreset,
+} = require('../src/export-resolution.cjs');
+
 const DEFAULT_OUTPUT = 'slides.pdf';
 const DEFAULT_SLIDES_DIR = 'slides';
 const DEFAULT_MODE = 'capture';
+const DEFAULT_CAPTURE_RESOLUTION = '2160p';
 const PDF_MODES = new Set(['capture', 'print']);
 const SLIDE_FILE_PATTERN = /^slide-.*\.html$/i;
 const FALLBACK_SLIDE_SIZE = { width: 960, height: 540 };
@@ -29,12 +39,14 @@ function printUsage() {
       `  --output <path>      Output PDF path (default: ${DEFAULT_OUTPUT})`,
       `  --slides-dir <path>  Slide directory (default: ${DEFAULT_SLIDES_DIR})`,
       `  --mode <mode>        PDF export mode: capture|print (default: ${DEFAULT_MODE})`,
+      `  --resolution <preset> Capture raster size preset: ${getResolutionChoices().join('|')}|4k (default: ${DEFAULT_CAPTURE_RESOLUTION}; ignored in print mode)`,
       '  -h, --help           Show this help message',
       '',
       'Examples:',
       '  node scripts/html2pdf.js',
       '  node scripts/html2pdf.js --output dist/deck.pdf',
       '  node scripts/html2pdf.js --mode print --output dist/searchable.pdf',
+      '  node scripts/html2pdf.js --resolution 2160p --output dist/deck-4k.pdf',
     ].join('\n'),
   );
   process.stdout.write('\n');
@@ -76,6 +88,25 @@ function cssPixelsToPdfPoints(value) {
   return Math.round((normalizeDimension(value, 0) * PDF_POINTS_PER_INCH) / CSS_PIXELS_PER_INCH);
 }
 
+async function normalizeCaptureRasterSize(pngBytes, resolution = '') {
+  const targetSize = getResolutionSize(resolution);
+  if (!targetSize) {
+    return pngBytes;
+  }
+
+  const metadata = await sharp(pngBytes).metadata();
+  const currentWidth = normalizeDimension(metadata.width, targetSize.width);
+  const currentHeight = normalizeDimension(metadata.height, targetSize.height);
+  if (currentWidth === targetSize.width && currentHeight === targetSize.height) {
+    return pngBytes;
+  }
+
+  return sharp(pngBytes)
+    .resize(targetSize.width, targetSize.height, { fit: 'fill' })
+    .png()
+    .toBuffer();
+}
+
 function formatDiagnosticEntry(entry) {
   const prefix = entry.slideFile ? `${entry.slideFile}: ` : '';
   return `${prefix}${entry.message}`;
@@ -108,6 +139,7 @@ export function parseCliArgs(args) {
     output: DEFAULT_OUTPUT,
     slidesDir: DEFAULT_SLIDES_DIR,
     mode: DEFAULT_MODE,
+    resolution: DEFAULT_CAPTURE_RESOLUTION,
     help: false,
   };
 
@@ -152,6 +184,17 @@ export function parseCliArgs(args) {
       continue;
     }
 
+    if (arg === '--resolution') {
+      options.resolution = normalizeResolutionPreset(readOptionValue(args, i, '--resolution'));
+      i += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--resolution=')) {
+      options.resolution = normalizeResolutionPreset(arg.slice('--resolution='.length));
+      continue;
+    }
+
     throw new Error(`Unknown option: ${arg}`);
   }
 
@@ -165,6 +208,10 @@ export function parseCliArgs(args) {
   options.output = options.output.trim();
   options.slidesDir = options.slidesDir.trim();
   options.mode = normalizeMode(options.mode);
+  options.resolution = normalizeResolutionPreset(options.resolution);
+  if (options.mode === 'print') {
+    options.resolution = '';
+  }
 
   return options;
 }
@@ -188,13 +235,18 @@ export function buildPdfOptions(widthPx, heightPx) {
   };
 }
 
-export function buildPageOptions(mode = DEFAULT_MODE) {
+export function buildPageOptions(mode = DEFAULT_MODE, resolution = '') {
+  const targetResolution = normalizeMode(mode) === 'capture' ? getResolutionSize(resolution) : null;
   return {
     viewport: {
       width: FALLBACK_SLIDE_SIZE.width,
       height: FALLBACK_SLIDE_SIZE.height,
     },
-    deviceScaleFactor: normalizeMode(mode) === 'capture' ? DEFAULT_CAPTURE_DEVICE_SCALE_FACTOR : 1,
+    deviceScaleFactor: normalizeMode(mode) === 'capture'
+      ? targetResolution
+        ? targetResolution.height / FALLBACK_SLIDE_SIZE.height
+        : DEFAULT_CAPTURE_DEVICE_SCALE_FACTOR
+      : 1,
   };
 }
 
@@ -470,6 +522,7 @@ export async function renderSlideToPdf(page, slideFile, slidesDir, options = {})
   const slidePath = join(slidesDir, slideFile);
   const slideUrl = pathToFileURL(slidePath).href;
   const mode = normalizeMode(options.mode ?? DEFAULT_MODE);
+  const captureResolution = mode === 'capture' ? normalizeResolutionPreset(options.resolution ?? '') : '';
 
   await page.goto(slideUrl, { waitUntil: 'load' });
   await waitForSlideRenderReady(page, options);
@@ -495,11 +548,12 @@ export async function renderSlideToPdf(page, slideFile, slidesDir, options = {})
         height: viewportSize.height,
       },
     });
+    const normalizedPngBytes = await normalizeCaptureRasterSize(pngBytes, captureResolution);
     return {
       mode,
       width: normalizedSlideFrame.width,
       height: normalizedSlideFrame.height,
-      pngBytes,
+      pngBytes: normalizedPngBytes,
     };
   }
 
@@ -560,7 +614,7 @@ async function main() {
   }
 
   const browser = await chromium.launch({ headless: true });
-  const page = await browser.newPage(buildPageOptions(options.mode));
+  const page = await browser.newPage(buildPageOptions(options.mode, options.resolution));
   const diagnostics = createSlideDiagnostics();
   diagnostics.attach(page);
   const renderedSlides = [];
@@ -569,7 +623,10 @@ async function main() {
     for (const slideFile of slideFiles) {
       diagnostics.beginSlide(slideFile);
       try {
-        const slideResult = await renderSlideToPdf(page, slideFile, slidesDir, { mode: options.mode });
+        const slideResult = await renderSlideToPdf(page, slideFile, slidesDir, {
+          mode: options.mode,
+          resolution: options.resolution,
+        });
         renderedSlides.push(slideResult);
       } catch (error) {
         throw decorateError(error, slideFile, diagnostics.getSlideDiagnostics(slideFile));

package/src/export-resolution.cjs

@@ -0,0 +1,58 @@
+const RESOLUTION_PRESETS = Object.freeze({
+  '720p': { width: 1280, height: 720 },
+  '1080p': { width: 1920, height: 1080 },
+  '1440p': { width: 2560, height: 1440 },
+  '2160p': { width: 3840, height: 2160 },
+});
+
+const RESOLUTION_ALIASES = Object.freeze({
+  '4k': '2160p',
+  uhd: '2160p',
+});
+
+function getResolutionChoices() {
+  return Object.keys(RESOLUTION_PRESETS);
+}
+
+function normalizeResolutionPreset(value, options = {}) {
+  const { allowEmpty = true } = options;
+
+  if (typeof value !== 'string') {
+    if (allowEmpty) {
+      return '';
+    }
+    throw new Error(`--resolution must be one of: ${getResolutionChoices().join(', ')}, 4k`);
+  }
+
+  const trimmed = value.trim().toLowerCase();
+  if (trimmed === '') {
+    if (allowEmpty) {
+      return '';
+    }
+    throw new Error(`--resolution must be one of: ${getResolutionChoices().join(', ')}, 4k`);
+  }
+
+  const normalized = RESOLUTION_ALIASES[trimmed] || trimmed;
+  if (!RESOLUTION_PRESETS[normalized]) {
+    throw new Error(`Unknown resolution "${value}". Expected one of: ${getResolutionChoices().join(', ')}, 4k`);
+  }
+
+  return normalized;
+}
+
+function getResolutionSize(value) {
+  const normalized = normalizeResolutionPreset(value);
+  if (!normalized) {
+    return null;
+  }
+
+  const preset = RESOLUTION_PRESETS[normalized];
+  return { width: preset.width, height: preset.height };
+}
+
+module.exports = {
+  RESOLUTION_PRESETS,
+  getResolutionChoices,
+  getResolutionSize,
+  normalizeResolutionPreset,
+};