slides-grab 1.2.1 → 1.2.3

package/scripts/editor-server.js

@@ -2,12 +2,13 @@
 
 import { readdir, readFile, writeFile, mkdtemp, rm, mkdir } from 'node:fs/promises';
 import { watch as fsWatch } from 'node:fs';
+import net from 'node:net';
+import { createRequire } from 'node:module';
 import { basename, dirname, join, resolve, relative, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { tmpdir } from 'node:os';
 
 import {
-  SLIDE_SIZE,
   buildCodexEditPrompt,
   buildCodexExecArgs,
   buildClaudeExecArgs,
@@ -23,6 +24,14 @@ import {
 } from '../src/editor/edit-subprocess.js';
 import { buildSlideRuntimeHtml } from '../src/image-contract.js';
 
+const require = createRequire(import.meta.url);
+const {
+  DEFAULT_SLIDE_MODE,
+  getSlideModeChoices,
+  getSlideModeConfig,
+  normalizeSlideMode,
+} = require('../src/slide-mode.cjs');
+
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const PACKAGE_ROOT = process.env.PPT_AGENT_PACKAGE_ROOT || resolve(__dirname, '..');
@@ -45,6 +54,8 @@ const CODEX_MODELS = ['gpt-5.4', 'gpt-5.3-codex', 'gpt-5.3-codex-spark'];
 const ALL_MODELS = [...CODEX_MODELS, ...CLAUDE_MODELS];
 const DEFAULT_CODEX_MODEL = CODEX_MODELS[0];
 const SLIDE_FILE_PATTERN = /^slide-.*\.html$/i;
+const PORT_PROBE_HOSTS = ['::', '127.0.0.1'];
+const PORT_PROBE_IGNORED_CODES = new Set(['EAFNOSUPPORT', 'EADDRNOTAVAIL']);
 
 const MAX_RUNS = 200;
 const MAX_LOG_CHARS = 800_000;
@@ -55,6 +66,7 @@ function printUsage() {
   process.stdout.write(`Options:\n`);
   process.stdout.write(`  --port <number>           Server port (default: ${DEFAULT_PORT})\n`);
   process.stdout.write(`  --slides-dir <path>       Slide directory (default: ${DEFAULT_SLIDES_DIR})\n`);
+  process.stdout.write(`  --mode <mode>             Slide mode: ${getSlideModeChoices().join(', ')} (default: ${DEFAULT_SLIDE_MODE})\n`);
   process.stdout.write(`  Model is selected in editor UI dropdown.\n`);
   process.stdout.write(`  -h, --help                Show this help message\n`);
 }
@@ -63,6 +75,7 @@ function parseArgs(argv) {
   const opts = {
     port: DEFAULT_PORT,
     slidesDir: DEFAULT_SLIDES_DIR,
+    mode: DEFAULT_SLIDE_MODE,
     help: false,
   };
 
@@ -95,6 +108,17 @@ function parseArgs(argv) {
       continue;
     }
 
+    if (arg === '--mode') {
+      opts.mode = normalizeSlideMode(argv[i + 1]);
+      i += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--mode=')) {
+      opts.mode = normalizeSlideMode(arg.slice('--mode='.length));
+      continue;
+    }
+
     if (arg === '--codex-model') {
       // Backward compatibility: ignore legacy CLI option.
       i += 1;
@@ -113,10 +137,67 @@ function parseArgs(argv) {
   }
 
   opts.slidesDir = opts.slidesDir.trim();
+  opts.mode = normalizeSlideMode(opts.mode);
 
   return opts;
 }
 
+function buildPortInUseError(port) {
+  return new Error(`Editor port ${port} is already in use. Choose another port with \`--port <number>\` and try again.`);
+}
+
+async function assertHostPortAvailable(port, host) {
+  const probe = net.createServer();
+  try {
+    await new Promise((resolve, reject) => {
+      probe.once('error', reject);
+      probe.listen({ port, host, exclusive: true }, resolve);
+    });
+  } catch (error) {
+    if (error?.code === 'EADDRINUSE') {
+      throw buildPortInUseError(port);
+    }
+
+    if (PORT_PROBE_IGNORED_CODES.has(error?.code)) {
+      return;
+    }
+
+    throw error;
+  } finally {
+    if (probe.listening) {
+      await new Promise((resolve, reject) => {
+        probe.close((error) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve();
+        });
+      });
+    }
+  }
+}
+
+async function assertPortUsable(port) {
+  for (const host of PORT_PROBE_HOSTS) {
+    await assertHostPortAvailable(port, host);
+  }
+}
+
+async function listenOnPort(app, port) {
+  return new Promise((resolve, reject) => {
+    const server = app.listen(port, () => resolve(server));
+    server.once('error', (error) => {
+      if (error?.code === 'EADDRINUSE') {
+        reject(buildPortInUseError(port));
+        return;
+      }
+
+      reject(error);
+    });
+  });
+}
+
 const sseClients = new Set();
 
 function broadcastSSE(event, data) {
@@ -143,9 +224,9 @@ async function closeBrowser() {
   }
 }
 
-async function withScreenshotPage(callback) {
+async function withScreenshotPage(callback, screenshotSize) {
   const { browser } = await getScreenshotBrowser();
-  const { context, page } = await screenshotMod.createScreenshotPage(browser);
+  const { context, page } = await screenshotMod.createScreenshotPage(browser, screenshotSize);
   try {
     return await callback(page);
   } finally {
@@ -205,7 +286,7 @@ function sanitizeTargets(rawTargets) {
     .filter((target) => target.xpath);
 }
 
-function normalizeSelections(rawSelections) {
+function normalizeSelections(rawSelections, slideSize) {
   if (!Array.isArray(rawSelections) || rawSelections.length === 0) {
     throw new Error('At least one selection is required.');
   }
@@ -215,7 +296,7 @@ function normalizeSelections(rawSelections) {
       ? selection.bbox
       : selection;
 
-    const bbox = normalizeSelection(selectionSource, SLIDE_SIZE);
+    const bbox = normalizeSelection(selectionSource, slideSize);
     const targets = sanitizeTargets(selection?.targets);
 
     return { bbox, targets };
@@ -392,6 +473,7 @@ function createRunStore() {
 }
 
 async function startServer(opts) {
+  await assertPortUsable(opts.port);
   await loadDeps();
   const slidesDirectory = resolve(process.cwd(), opts.slidesDir);
   await mkdir(slidesDirectory, { recursive: true });
@@ -502,6 +584,18 @@ async function startServer(opts) {
     }
   });
 
+  app.get('/api/config', (_req, res) => {
+    const cfg = getSlideModeConfig(opts.mode);
+    res.json({
+      slideMode: opts.mode,
+      framePx: { width: cfg.framePx.width, height: cfg.framePx.height },
+      screenshotPx: { width: cfg.screenshotPx.width, height: cfg.screenshotPx.height },
+      sizeLabel: cfg.sizeLabel,
+      aspectRatioLabel: cfg.aspectRatioLabel,
+      coordinateSpaceLabel: cfg.coordinateSpaceLabel,
+    });
+  });
+
   app.get('/api/models', (_req, res) => {
     res.json({
       models: ALL_MODELS,
@@ -570,7 +664,7 @@ async function startServer(opts) {
 
     let normalizedSelections;
     try {
-      normalizedSelections = normalizeSelections(selections);
+      normalizedSelections = normalizeSelections(selections, getSlideModeConfig(opts.mode).framePx);
     } catch (error) {
       return res.status(400).json({ error: error.message });
     }
@@ -605,15 +699,15 @@ async function startServer(opts) {
           slide,
           screenshotPath,
           `http://localhost:${opts.port}/slides`,
-          { useHttp: true },
+          { useHttp: true, screenshotSize: getSlideModeConfig(opts.mode).screenshotPx },
         );
-      });
+      }, getSlideModeConfig(opts.mode).screenshotPx);
 
       const scaledBoxes = normalizedSelections.map((selection) =>
         scaleSelectionToScreenshot(
           selection.bbox,
-          SLIDE_SIZE,
-          screenshotMod.SCREENSHOT_SIZE,
+          getSlideModeConfig(opts.mode).framePx,
+          getSlideModeConfig(opts.mode).screenshotPx,
         ),
       );
 
@@ -623,6 +717,7 @@ async function startServer(opts) {
         slideFile: slide,
         slidePath: toSlidePathLabel(slidesDirectory, slide),
         userPrompt: prompt,
+        slideMode: opts.mode,
         selections: normalizedSelections,
       });
 
@@ -708,14 +803,14 @@ async function startServer(opts) {
     }, 300);
   });
 
-  const server = app.listen(opts.port, () => {
-    process.stdout.write('\n  slides-grab editor\n');
-    process.stdout.write('  ─────────────────────────────────────\n');
-    process.stdout.write(`  Local:       http://localhost:${opts.port}\n`);
-    process.stdout.write(`  Models:      ${ALL_MODELS.join(', ')}\n`);
-    process.stdout.write(`  Slides:      ${slidesDirectory}\n`);
-    process.stdout.write('  ─────────────────────────────────────\n\n');
-  });
+  const server = await listenOnPort(app, opts.port);
+
+  process.stdout.write('\n  slides-grab editor\n');
+  process.stdout.write('  ─────────────────────────────────────\n');
+  process.stdout.write(`  Local:       http://localhost:${opts.port}\n`);
+  process.stdout.write(`  Models:      ${ALL_MODELS.join(', ')}\n`);
+  process.stdout.write(`  Slides:      ${slidesDirectory}\n`);
+  process.stdout.write('  ─────────────────────────────────────\n\n');
 
   async function shutdown() {
     process.stdout.write('\n[editor] Shutting down...\n');

package/scripts/figma-export.js

@@ -17,6 +17,7 @@ import {
 
 const require = createRequire(import.meta.url);
 const html2pptx = require('../src/html2pptx.cjs');
+const { DEFAULT_SLIDE_MODE, getSlideModeChoices, normalizeSlideMode } = require('../src/slide-mode.cjs');
 
 const DEFAULT_SLIDES_DIR = 'slides';
 
@@ -28,6 +29,7 @@ function printUsage() {
       'Options:',
       `  --slides-dir <path>  Slide directory (default: ${DEFAULT_SLIDES_DIR})`,
       '  --output <path>      Output PPTX file (default: <slides-dir>-figma.pptx)',
+      `  --mode <mode>        Slide mode: ${getSlideModeChoices().join('|')} (default: ${DEFAULT_SLIDE_MODE})`,
       '  -h, --help           Show this help message',
       '',
       'Exports an experimental / unstable Figma Slides importable PPTX using the existing html2pptx pipeline.',
@@ -49,6 +51,7 @@ function parseArgs(args) {
   const options = {
     slidesDir: DEFAULT_SLIDES_DIR,
     output: '',
+    mode: DEFAULT_SLIDE_MODE,
     help: false,
   };
 
@@ -81,6 +84,17 @@ function parseArgs(args) {
       continue;
     }
 
+    if (arg === '--mode') {
+      options.mode = normalizeSlideMode(readOptionValue(args, i, '--mode'));
+      i += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--mode=')) {
+      options.mode = normalizeSlideMode(arg.slice('--mode='.length));
+      continue;
+    }
+
     throw new Error(`Unknown option: ${arg}`);
   }
 
@@ -89,6 +103,7 @@ function parseArgs(args) {
   }
 
   options.slidesDir = options.slidesDir.trim();
+  options.mode = normalizeSlideMode(options.mode);
   options.output = normalizeFigmaOutput(options.slidesDir, options.output);
   return options;
 }
@@ -121,7 +136,7 @@ async function main() {
   const files = getHtmlSlides(slidesDir);
 
   const pres = new PptxGenJS();
-  configureFigmaExportPresentation(pres);
+  configureFigmaExportPresentation(pres, options.mode);
 
   console.log(`Exporting ${files.length} slide(s) for Figma from ${slidesDir}`);
 

package/scripts/html2pdf.js

@@ -16,6 +16,12 @@ const {
   getResolutionSize,
   normalizeResolutionPreset,
 } = require('../src/export-resolution.cjs');
+const {
+  DEFAULT_SLIDE_MODE,
+  getSlideModeChoices,
+  getSlideModeConfig,
+  normalizeSlideMode,
+} = require('../src/slide-mode.cjs');
 
 const DEFAULT_OUTPUT = 'slides.pdf';
 const DEFAULT_SLIDES_DIR = 'slides';
@@ -23,9 +29,7 @@ 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 };
 const DEFAULT_CAPTURE_DEVICE_SCALE_FACTOR = 2;
-const TARGET_ASPECT_RATIO = 16 / 9;
 const RENDER_SETTLE_MS = 120;
 const CSS_PIXELS_PER_INCH = 96;
 const PDF_POINTS_PER_INCH = 72;
@@ -40,6 +44,7 @@ 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})`,
+      `  --slide-mode <mode>  Slide mode: ${getSlideModeChoices().join('|')} (default: ${DEFAULT_SLIDE_MODE})`,
       `  --resolution <preset> Capture raster size preset: ${getResolutionChoices().join('|')}|4k (default: ${DEFAULT_CAPTURE_RESOLUTION}; ignored in print mode)`,
       '  -h, --help           Show this help message',
       '',
@@ -89,8 +94,8 @@ 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);
+async function normalizeCaptureRasterSize(pngBytes, resolution = '', slideMode = DEFAULT_SLIDE_MODE) {
+  const targetSize = getResolutionSize(resolution, slideMode);
   if (!targetSize) {
     return pngBytes;
   }
@@ -140,6 +145,7 @@ export function parseCliArgs(args) {
     output: DEFAULT_OUTPUT,
     slidesDir: DEFAULT_SLIDES_DIR,
     mode: DEFAULT_MODE,
+    slideMode: DEFAULT_SLIDE_MODE,
     resolution: DEFAULT_CAPTURE_RESOLUTION,
     help: false,
   };
@@ -185,6 +191,17 @@ export function parseCliArgs(args) {
       continue;
     }
 
+    if (arg === '--slide-mode') {
+      options.slideMode = normalizeSlideMode(readOptionValue(args, i, '--slide-mode'), { optionName: '--slide-mode' });
+      i += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--slide-mode=')) {
+      options.slideMode = normalizeSlideMode(arg.slice('--slide-mode='.length), { optionName: '--slide-mode' });
+      continue;
+    }
+
     if (arg === '--resolution') {
       options.resolution = normalizeResolutionPreset(readOptionValue(args, i, '--resolution'));
       i += 1;
@@ -209,6 +226,7 @@ export function parseCliArgs(args) {
   options.output = options.output.trim();
   options.slidesDir = options.slidesDir.trim();
   options.mode = normalizeMode(options.mode);
+  options.slideMode = normalizeSlideMode(options.slideMode, { optionName: '--slide-mode' });
   options.resolution = normalizeResolutionPreset(options.resolution);
   if (options.mode === 'print') {
     options.resolution = '';
@@ -226,9 +244,10 @@ export async function findSlideFiles(slidesDir = resolve(process.cwd(), DEFAULT_
 }
 
 export function buildPdfOptions(widthPx, heightPx) {
+  const fallbackSize = getSlideModeConfig(DEFAULT_SLIDE_MODE).framePx;
   return {
-    width: `${normalizeDimension(widthPx, FALLBACK_SLIDE_SIZE.width)}px`,
-    height: `${normalizeDimension(heightPx, FALLBACK_SLIDE_SIZE.height)}px`,
+    width: `${normalizeDimension(widthPx, fallbackSize.width)}px`,
+    height: `${normalizeDimension(heightPx, fallbackSize.height)}px`,
     printBackground: true,
     pageRanges: '1',
     margin: { top: '0px', right: '0px', bottom: '0px', left: '0px' },
@@ -236,22 +255,25 @@ export function buildPdfOptions(widthPx, heightPx) {
   };
 }
 
-export function buildPageOptions(mode = DEFAULT_MODE, resolution = '') {
-  const targetResolution = normalizeMode(mode) === 'capture' ? getResolutionSize(resolution) : null;
+export function buildPageOptions(mode = DEFAULT_MODE, resolution = '', slideMode = DEFAULT_SLIDE_MODE) {
+  const { framePx } = getSlideModeConfig(slideMode);
+  const targetResolution = normalizeMode(mode) === 'capture' ? getResolutionSize(resolution, slideMode) : null;
   return {
     viewport: {
-      width: FALLBACK_SLIDE_SIZE.width,
-      height: FALLBACK_SLIDE_SIZE.height,
+      width: framePx.width,
+      height: framePx.height,
     },
     deviceScaleFactor: normalizeMode(mode) === 'capture'
       ? targetResolution
-        ? targetResolution.height / FALLBACK_SLIDE_SIZE.height
+        ? targetResolution.height / framePx.height
         : DEFAULT_CAPTURE_DEVICE_SCALE_FACTOR
       : 1,
   };
 }
 
-function chooseSlideFrame(metrics) {
+function chooseSlideFrame(metrics, slideMode = DEFAULT_SLIDE_MODE) {
+  const { framePx } = getSlideModeConfig(slideMode);
+  const targetAspectRatio = framePx.width / framePx.height;
   const viewportArea = Math.max(1, metrics.viewport.width * metrics.viewport.height);
   const bodyArea = Math.max(1, metrics.body.width * metrics.body.height);
   const bodyScrollArea = Math.max(1, metrics.body.scrollWidth * metrics.body.scrollHeight);
@@ -269,7 +291,7 @@ function chooseSlideFrame(metrics) {
     .map((candidate) => ({
       ...candidate,
       area: candidate.width * candidate.height,
-      aspectDelta: Math.abs(candidate.width / candidate.height - TARGET_ASPECT_RATIO),
+      aspectDelta: Math.abs(candidate.width / candidate.height - targetAspectRatio),
       coverage: (candidate.width * candidate.height) / viewportArea,
     }))
     .sort((left, right) => right.area - left.area);
@@ -359,7 +381,7 @@ export async function waitForSlideRenderReady(page, options = {}) {
   }, { settleMs, runReadySignal: shouldRunReadySignal });
 }
 
-export async function detectSlideFrame(page) {
+export async function detectSlideFrame(page, slideMode = DEFAULT_SLIDE_MODE) {
   const metrics = await page.evaluate(() => {
     function toBox(element) {
       const rect = element.getBoundingClientRect();
@@ -398,12 +420,13 @@ export async function detectSlideFrame(page) {
     };
   });
 
-  const frame = chooseSlideFrame(metrics);
+  const frame = chooseSlideFrame(metrics, slideMode);
+  const fallbackSize = getSlideModeConfig(slideMode).framePx;
   return {
     x: normalizeDimension(frame.x, 0),
     y: normalizeDimension(frame.y, 0),
-    width: normalizeDimension(frame.width, FALLBACK_SLIDE_SIZE.width),
-    height: normalizeDimension(frame.height, FALLBACK_SLIDE_SIZE.height),
+    width: normalizeDimension(frame.width, fallbackSize.width),
+    height: normalizeDimension(frame.height, fallbackSize.height),
     candidateIndex: Number.isInteger(frame.candidateIndex) ? frame.candidateIndex : null,
     source: frame.source,
   };
@@ -641,20 +664,22 @@ 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 slideMode = normalizeSlideMode(options.slideMode ?? DEFAULT_SLIDE_MODE, { optionName: '--slide-mode' });
   const captureResolution = mode === 'capture' ? normalizeResolutionPreset(options.resolution ?? '') : '';
 
   await page.goto(slideUrl, { waitUntil: 'load' });
   await waitForSlideRenderReady(page, options);
 
-  const slideFrame = await detectSlideFrame(page);
+  const slideFrame = await detectSlideFrame(page, slideMode);
   const normalizedSlideFrame = await isolateSlideFrame(page, slideFrame);
   await normalizeBodyToSlideFrame(page, normalizedSlideFrame);
   await waitForSlideRenderReady(page, { ...options, runReadySignal: false });
 
   if (mode === 'capture') {
+    const fallbackSize = getSlideModeConfig(slideMode).framePx;
     const viewportSize = {
-      width: normalizeDimension(normalizedSlideFrame.width, FALLBACK_SLIDE_SIZE.width),
-      height: normalizeDimension(normalizedSlideFrame.height, FALLBACK_SLIDE_SIZE.height),
+      width: normalizeDimension(normalizedSlideFrame.width, fallbackSize.width),
+      height: normalizeDimension(normalizedSlideFrame.height, fallbackSize.height),
     };
     await page.setViewportSize(viewportSize);
     await waitForSlideRenderReady(page, { ...options, runReadySignal: false });
@@ -679,9 +704,10 @@ export async function renderSlideToPdf(page, slideFile, slidesDir, options = {})
         height: viewportSize.height,
       },
     });
-    const normalizedPngBytes = await normalizeCaptureRasterSize(pngBytes, captureResolution);
+    const normalizedPngBytes = await normalizeCaptureRasterSize(pngBytes, captureResolution, slideMode);
     return {
       mode,
+      slideMode,
       width: normalizedSlideFrame.width,
       height: normalizedSlideFrame.height,
       pngBytes: normalizedPngBytes,
@@ -692,6 +718,7 @@ export async function renderSlideToPdf(page, slideFile, slidesDir, options = {})
 
   return {
     mode,
+    slideMode,
     width: normalizedSlideFrame.width,
     height: normalizedSlideFrame.height,
     pdfBytes: await page.pdf(buildPdfOptions(normalizedSlideFrame.width, normalizedSlideFrame.height)),
@@ -740,14 +767,14 @@ async function main() {
   }
 
   const slidesDir = resolve(process.cwd(), options.slidesDir);
-  await ensureSlidesPassValidation(slidesDir, { exportLabel: 'PDF export' });
+  await ensureSlidesPassValidation(slidesDir, { exportLabel: 'PDF export', slideMode: options.slideMode });
   const slideFiles = await findSlideFiles(slidesDir);
   if (slideFiles.length === 0) {
     throw new Error(`No slide-*.html files found in: ${slidesDir}`);
   }
 
   const browser = await chromium.launch({ headless: true });
-  const page = await browser.newPage(buildPageOptions(options.mode, options.resolution));
+  const page = await browser.newPage(buildPageOptions(options.mode, options.resolution, options.slideMode));
   const diagnostics = createSlideDiagnostics();
   diagnostics.attach(page);
   const renderedSlides = [];
@@ -758,6 +785,7 @@ async function main() {
       try {
         const slideResult = await renderSlideToPdf(page, slideFile, slidesDir, {
           mode: options.mode,
+          slideMode: options.slideMode,
           resolution: options.resolution,
         });
         renderedSlides.push(slideResult);

package/scripts/html2pptx.js

@@ -10,6 +10,7 @@ import { ensureOutputDirectory, SLIDE_FILE_PATTERN, sortFigmaSlideFiles } from '
 
 const require = createRequire(import.meta.url);
 const html2pptx = require('../src/html2pptx.cjs');
+const { DEFAULT_SLIDE_MODE, getSlideModeChoices, getSlideModeConfig, normalizeSlideMode } = require('../src/slide-mode.cjs');
 
 const DEFAULT_SLIDES_DIR = 'slides';
 const DEFAULT_OUTPUT = 'output.pptx';
@@ -22,6 +23,7 @@ function printUsage() {
       'Options:',
       `  --slides-dir <path>  Slide directory (default: ${DEFAULT_SLIDES_DIR})`,
       `  --output <path>      Output PPTX file (default: ${DEFAULT_OUTPUT})`,
+      `  --mode <mode>        Slide mode: ${getSlideModeChoices().join('|')} (default: ${DEFAULT_SLIDE_MODE})`,
       '  -h, --help           Show this help message',
       '',
       'Experimental / unstable PPTX export. Treat output as best-effort only.',
@@ -42,6 +44,7 @@ function parseArgs(args) {
   const options = {
     slidesDir: DEFAULT_SLIDES_DIR,
     output: DEFAULT_OUTPUT,
+    mode: DEFAULT_SLIDE_MODE,
     help: false,
   };
 
@@ -74,6 +77,17 @@ function parseArgs(args) {
       continue;
     }
 
+    if (arg === '--mode') {
+      options.mode = normalizeSlideMode(readOptionValue(args, i, '--mode'));
+      i += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--mode=')) {
+      options.mode = normalizeSlideMode(arg.slice('--mode='.length));
+      continue;
+    }
+
     throw new Error(`Unknown option: ${arg}`);
   }
 
@@ -87,6 +101,7 @@ function parseArgs(args) {
 
   options.slidesDir = options.slidesDir.trim();
   options.output = options.output.trim();
+  options.mode = normalizeSlideMode(options.mode);
   return options;
 }
 
@@ -118,7 +133,13 @@ async function main() {
   const files = getHtmlSlides(slidesDir);
 
   const pres = new PptxGenJS();
-  pres.layout = 'LAYOUT_WIDE';
+  const { pptxSizeIn } = getSlideModeConfig(options.mode);
+  pres.defineLayout({
+    name: 'SLIDES_GRAB_HTML2PPTX',
+    width: pptxSizeIn.width,
+    height: pptxSizeIn.height,
+  });
+  pres.layout = 'SLIDES_GRAB_HTML2PPTX';
 
   for (const file of files) {
     await html2pptx(resolve(slidesDir, file), pres);

package/scripts/validate-slides.js

@@ -2,6 +2,7 @@
 
 import { resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
 import { chromium } from 'playwright';
 
 import {
@@ -20,6 +21,9 @@ import {
   selectSlideFiles,
 } from '../src/validation/core.js';
 
+const require = createRequire(import.meta.url);
+const { DEFAULT_SLIDE_MODE } = require('../src/slide-mode.cjs');
+
 export {
   DEFAULT_SLIDES_DIR,
   ensureSlidesPassValidation,
@@ -160,7 +164,7 @@ function peekValidateFormat(args = []) {
   return DEFAULT_VALIDATE_FORMAT;
 }
 
-export async function validateSlides(slidesDir, { selectedSlides = [] } = {}) {
+export async function validateSlides(slidesDir, { mode = DEFAULT_SLIDE_MODE, selectedSlides = [] } = {}) {
   const slideFiles = selectSlideFiles(await findSlideFiles(slidesDir), selectedSlides, slidesDir);
   if (slideFiles.length === 0) {
     throw new Error(`No slide-*.html files found in: ${slidesDir}`);
@@ -171,13 +175,26 @@ export async function validateSlides(slidesDir, { selectedSlides = [] } = {}) {
   const page = await context.newPage();
 
   try {
-    const slides = await scanSlides(page, slidesDir, slideFiles);
-    return createValidationResult(slides);
+    const slides = await scanSlides(page, slidesDir, slideFiles, mode);
+    return createValidationResult(slides, mode);
   } finally {
     await browser.close();
   }
 }
 
+function peekValidateMode(args = []) {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === '--mode') {
+      return args[i + 1] || DEFAULT_SLIDE_MODE;
+    }
+    if (arg.startsWith('--mode=')) {
+      return arg.slice('--mode='.length) || DEFAULT_SLIDE_MODE;
+    }
+  }
+  return DEFAULT_SLIDE_MODE;
+}
+
 export async function main(args = process.argv.slice(2)) {
   const options = parseValidateCliArgs(args);
   if (options.help) {
@@ -186,7 +203,7 @@ export async function main(args = process.argv.slice(2)) {
   }
 
   const slidesDir = resolve(process.cwd(), options.slidesDir);
-  const result = await validateSlides(slidesDir, { selectedSlides: options.slides });
+  const result = await validateSlides(slidesDir, { mode: options.mode, selectedSlides: options.slides });
   process.stdout.write(formatValidationResult(result, options.format));
   if (result.summary.failedSlides > 0) {
     process.exitCode = 1;
@@ -197,7 +214,7 @@ const isMain = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(imp
 
 if (isMain) {
   main().catch((error) => {
-    const failure = createValidationFailure(error);
+    const failure = createValidationFailure(error, peekValidateMode(process.argv.slice(2)));
     process.stdout.write(formatValidationResult(failure, peekValidateFormat(process.argv.slice(2))));
     process.exit(1);
   });