pptx-generator

name	pptx-generator
description	Compile Markdown into a valid Microsoft PowerPoint (.pptx) file using pure JavaScript. Pipeline: Markdown → AST → Slide IR → Layout IR → OOXML → ZIP. Images embedded from local files.
when_to_use	Use when generating PowerPoint (.pptx) files from Markdown input.
tools	jsexec, read, write, bash
args	[{"name":"output_path","description":"Absolute file path for the generated .pptx file","required":true},{"name":"markdown","description":"Markdown text input. Supports headings, lists, code, tables, blockquotes, inline formatting, links, images (local paths), and --- slide breaks","required":true},{"name":"show_slide_numbers","description":"When true, renders N / M page numbers at bottom-right","required":false}]

CODE SKILL — VERBATIM REQUIRED This skill targets a formal specification (OOXML). Adaptation is prohibited per C2-A Rule 3.

CRITICAL: Execution Constraints

The code below is the SOLE IMPLEMENTATION — it MUST NOT be replaced, simplified, or reimplemented.

Prohibited deviations:

• Do NOT write your own crc32(), ZipBuilder, parseMarkdownAST(), buildSlideIR(), layoutSlide(), renderSlideXML()
• Do NOT skip any OOXML file from the 13+ core file baseline
• Do NOT use compression (method 8 / DEFLATE) — STORE mode only (method 0)
• Do NOT skip scanAndAssignLinks() — hyperlinks MUST be registered as relationships
• Do NOT use remote URLs for images — images MUST be local file paths

Correct Invocation Pattern

1. Copy the complete script from ## Runnable Entry Point below
2. Replace ONLY {{markdown}}, {{output_path}}, {{show_slide_numbers}} with actual values
3. Execute as a single jsexec call with NO modifications

Argument Details

Arg	Type	Required	Default	Description
markdown	string	yes	—	Markdown input for slide generation
output_path	string	yes	—	Output .pptx file path
show_slide_numbers	boolean	no	false	Show N / M page numbers

Runnable Entry Point (COMPLETE IIFE, DO NOT MODIFY)

// ===== Runnable Entry Point (IIFE) - DO NOT MODIFY =====
(async function() {
  const fs = require("fs");
  const pathModule = require("path");

  // -- XML Escape --
  function esc(s) {
    return String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&apos;');
  }

  // -- ID Generators --
  let shapeId = 1;
  let relId = 2; // reserve rId1 for slideLayout in slideRels
  let imageIndex = 1;
  function nextShapeId() { return shapeId++; }
  function nextRelId() { return 'rId' + relId++; }
  function nextImageName(ext = 'png') { return ; }

  
    =  ();
   ( i = ; i < ; i++) {
     c = i;
     ( j = ; j < ; j++) {
      c = (c & ) ? ( ^ (c >>> )) : (c >>> );
    }
    [i] = c;
  }
   () {
     c = ;
     ( i = ; i < buf.; i++) {
      c = [(c ^ buf[i]) & ] ^ (c >>> );
    }
     (c ^ ) >>> ;
  }

  
    {
    () {
      . = [];
      . = [];
      . = ;
      . = ;
    }
    () {
       buf =  content ===  ? .(content, ) : content;
       crc = (buf);
       nameBuf = .(path, );
       localHeader = .();
      localHeader.(, );
      localHeader.(, );
      localHeader.(, );
      localHeader.(, );
      localHeader.(, );
      localHeader.(, );
      localHeader.(crc, );
      localHeader.(buf., );
      localHeader.(buf., );
      localHeader.(nameBuf., );
      localHeader.(, );
      ..(localHeader, nameBuf, buf);
       cd = .();
      cd.(, );
      cd.(, );
      cd.(, );
      cd.(, );
      cd.(, );
      cd.(, );
      cd.(, );
      cd.(crc, );
      cd.(buf., );
      cd.(buf., );
      cd.(nameBuf., );
      cd.(, );
      cd.(, );
      cd.(, );
      cd.(, );
      cd.(, );
      cd.(., );
      ..(cd, nameBuf);
      . += localHeader. + nameBuf. + buf.;
      .++;
    }
    () {
       localBlock = .(.);
       centralBlock = .(.);
       cdSize = centralBlock.;
       cdOffset = .;
       n = .;
       eocd = .();
      eocd.(, );
      eocd.(, );
      eocd.(, );
      eocd.(n, );
      eocd.(n, );
      eocd.(cdSize, );
      eocd.(cdOffset, );
      eocd.(, );
       .([localBlock, centralBlock, eocd]);
    }
  }

  
  
  
   () {
     runs = [];
     i = ;

     (i < raw.) {
      
       (raw[i] === ) {
         end = raw.(, i + );
         (end !== -) {
          runs.({ : raw.(i + , end), :  });
          i = end + ;
          ;
        }
      }

      
       (raw[i] ===  && raw[i + ] === ) {
         end = raw.(, i + );
        
         (end === -) {
          runs.({ : raw.(i, i + ) });
          i += ;
          ;
        }
         inner = raw.(i + , end);
         innerRuns = (inner);
         ( r  innerRuns) {
          r. = ;
          runs.(r);
        }
        i = end + ;
        ;
      }

      
       (raw[i] ===  && raw[i + ] !== ) {
         end = raw.(, i + );
         (end !== -) {
           inner = raw.(i + , end);
           innerRuns = (inner);
           ( r  innerRuns) {
            r. = ;
            runs.(r);
          }
          i = end + ;
          ;
        }
      }

      
       (raw[i] === ) {
         closeBracket = raw.(, i + );
         (closeBracket !== -) {
           closeParen = raw.(, closeBracket + );
           (closeParen !== -) {
             linkText = raw.(i + , closeBracket);
             linkUrl = raw.(closeBracket + , closeParen);
             innerRuns = (linkText);
             ( r  innerRuns) {
              r. = linkUrl;
              runs.(r);
            }
            i = closeParen + ;
            ;
          }
        }
      }

      
       end = i + ;
       (end < raw. && .(raw[end]) === -) { end++; }
      runs.({ : raw.(i, end) });
      i = end;
    }

     (runs. === ) { runs.({ : raw }); }
     runs;
  }

  
   () {
     lines = md.();
     doc = { : [] };
     i = ;
     (i < lines.) {
       line = lines[i].();
       (line === ) { doc..({ :  }); i++; ; }
       (line.()) {
         level = line.()[].;
        doc..({ : , level, : line.(, ) });
        i++; ;
      }
       (line.()) {
         lang = line.(, ).();
        i++;
         code = [];
         (i < lines. && !lines[i].()) { code.(lines[i]); i++; }
        doc..({ : , lang, : code.() });
        i++; ;
      }
       (line.()) {
         items = [];
         (i < lines. && lines[i].()) { items.(lines[i].()); i++; }
        doc..({ : , items }); ;
      }
       (.(line)) {
         items = [];
         (i < lines. && .(lines[i])) { items.(lines[i].(, )); i++; }
        doc..({ : , items }); ;
      }
       (line.() && lines[i + ]?.()) {
         rows = [];
         (i < lines. && lines[i].()) {
           cells = lines[i].().( c.()).();
          
           isSeparator = cells. >  && cells.( .(c)) && rows. === ;
           (!isSeparator) { rows.(cells); }
          i++;
        }
        doc..({ : , rows }); ;
      }
       (line.()) {
         items = [];
         (i < lines. && lines[i].()) { items.(lines[i].()); i++; }
        doc..({ : , items }); ;
      }
       (line.()) {
        
         imgMatch = line.();
         (imgMatch) {
           block = { : , : imgMatch[] };
           dimStr = imgMatch[];
           (dimStr) {
             (dimStr.()) {
              block. = (dimStr);
            }  {
               wMatch = dimStr.();
               hMatch = dimStr.();
               (wMatch) block. = (wMatch[]);
               (hMatch) block. = (hMatch[]);
            }
          }
          doc..(block);
        }
        i++; ;
      }
       (line) {
         runs = (line);
        doc..({ : , : line, runs });
      }
      i++;
    }
     doc;
  }

  
    = ;
    = ;
    = ;
    = ;

  
  
  
   () {
     w = ;
     ( ch  text) {
       code = ch.();
       ((code >=  && code <= )   
       || (code >=  && code <= )   
       || (code >=  && code <= )   
       || (code >=  && code <= )   
       || (code >=  && code <= )   
       || (code >=  && code <= )   
       || (code >=  && code <= )) { 
        w += ;
      }  {
        w += ;
      }
    }
     w;
  }

   () {
     (b. ===  || b. === ) {
       h = ;
       ( item  (b. || [])) {  lines = .((item) / ) || ; h += lines * ; }
       h;
    }
     (b. === ) {
       h = ;
       ( item  (b. || [])) {  lines = .((item) / ) || ; h += lines * ; }
       h;
    }
     (b. === ) {  text = b. || ;  lines = .((text) / ) || ;  lines * ; }
     (b. === ) {  codeLines = (b. || ).().;  .(codeLines * , ); }
     (b. === ) {  rows = (b. || []). || ;  .(rows * , ); }
     ;
  }

   () {
     h = (slide. ?  : ) + (slide. ?  : );
     ( img  (slide. || [])) {
       data = (img &&  img === ) ? img : { : img };
       imgW = data. || (data. ? .( * data. / ) : ( -  * ));
       imgH = data. || (data. && !data. ? .(imgW *  / ) : .(imgW *  / ));
      h += imgH + ;
    }
     ( b  slide.) { h += (b); }
     h;
  }

   () {
     slides = [];
     current = ();
     () {  { : , : , : [], : [], :  }; }
     () {
       ((current) <= ) ;
       overflow = ();
      overflow. = ;
       h = (current. ?  : ) + (current. ?  : );
       ( img  (current. || [])) {
         data = (img &&  img === ) ? img : { : img };
         imgW = data. || (data. ? .( * data. / ) : ( -  * ));
         imgH = data. || .(imgW *  / );
        h += imgH + ;
      }
       keepBlocks = [], overflowBlocks = [];
       ( b  current.) {
         bh = (b);
         (h + bh <= ) { keepBlocks.(b); h += bh; }
         { overflowBlocks.(b); }
      }
       (overflowBlocks. > ) { current. = keepBlocks; overflow. = overflowBlocks; slides.(current); current = overflow; }
    }
     ( b  ast.) {
       (b. ===  && b. === ) {
         (current. || current.. || current..) { (); slides.(current); }
        current = (); current. = b.; ;
      }
       (b. === ) { (); slides.(current); current = (); ; }
       (b. ===  && b. === ) { current. = b.; ; }
       (b. === ) {
        
        current..({ : b., : b., : b., : b., : b. });
        ;
      }
      current..(b); ();
    }
    (); slides.(current);  slides;
  }

  
    =  / ;
   () {  { : col * , y, : span * , h }; }

   () {
     layout = [];
     (slide.) { layout.({ : , : slide., : (, , , ) }); }
     (slide.) { layout.({ : , : slide., : (, , , ) }); }
     bodyStart = slide. ? (slide. ?  : ) : (slide. ?  : );
      =  -  * ;
      = .( *  / );
     (slide. && slide.. > ) {
       ( img  slide.) {
         imgData = (img &&  img === ) ? img : { : img };
         imgW, imgH;
         (imgData. && imgData.) {
          imgW = imgData.;
          imgH = imgData.;
        }   (imgData.) {
          imgW = .( * imgData. / );
          imgH = .(imgW *  / );
        }   (imgData. && !imgData.) {
          imgW = imgData.;
          imgH = .(imgW *  / );
        }  {
          imgW = ;
          imgH = ;
        }
         imgX = .(( - imgW) / );
        layout.({ : , : imgData., : { : imgX, : bodyStart, : imgW, : imgH } });
        bodyStart += imgH + ;
      }
    }
     footerH = slide. ?  : ;
     (footerH > ) {
      layout.({ : , : , : (, ,  - footerH, ) });
    }
     y = bodyStart;
     ( b  slide.) {
       (b. === ) {  text = b. || ;  lines = .((text) / ) || ;  h = lines * ; layout.({ : , : b., : b., : (, , y, h) }); y += h; }
       (b. === ) {  ( item  b.) {  lines = .((item) / ) || ;  h = lines * ; layout.({ : , : item, : (, , y, h) }); y += h; } }
       (b. === ) {  ( idx = ; idx < b..; idx++) {  lines = .((b.[idx]) / ) || ;  h = lines * ; layout.({ : , : b.[idx], : idx + , : (, , y, h) }); y += h; } }
       (b. === ) {  ( item  b.) {  lines = .((item) / ) || ;  h = lines * ; layout.({ : , : item, : (, , y, h) }); y += h; } }
       (b. === ) {  codeLines = (b. || ).().;  h = .(codeLines * , ); layout.({ : , : b., : (, , y, h) }); y += h; }
       (b. === ) {  rows = (b. || []). || ;  h = .(rows * , ); layout.({ : , : b., : (, , y, h) }); y += h; }
    }
     layout;
  }

  
  
  
  
  
  
   () {
     ( block  ast.) {
       (block. === ) {
         filePath = block.;
         (!filePath) { block. = ; ; }
         (filePath.()) {
          .();
          ;
        }
         (filePath.() || filePath.()) {
          .();
          block. = ; ;
        }
         {
           resolvedPath = pathModule.(filePath);
          fs.(resolvedPath);
           ext = pathModule.(filePath).();
          block. = resolvedPath;
          block. = ext.(, ) || ;
        }  (e) {
          .();
          block. = ;
        }
      }
    }
    ast. = ast..( !(b. ===  && b. === ));
  }

  
   () {
     buf = fs.(imgPath);
     ext = imgExt || ;
     name = (ext);
    zip.(, buf);
     { : name, : (), ext };
  }
  
   () {
     ;
  }
   () {
     ;
  }
   () {
     ;
  }
   () {
     ;
  }
     () {
         ;
    }

   () {
     body = ;
     ( run  runs) {
       rPrAttrs = baseFontSize ?  : ;
       rPrChildren = ;
       needsClose = ;
       (run.) rPrAttrs += ;
       (run.) rPrAttrs += ;
       (run.) { rPrChildren += ; needsClose = ; }
       (run.) {
         linkRId = run. || ;
        rPrAttrs += ;
        rPrChildren += ;
        rPrChildren += ;
        needsClose = ;
      }
       rPrOpen = needsClose ?  : ;
       rPrClose = needsClose ?  : ;
       runBody = ;
      body += ;
    }
     body;
  }

   () {
    slide. = {};
     ( item  layout) {
       runs = item. || (item. ? (item.) : []);
       ( run  runs) {  (run. && !slide.[run.]) { slide.[run.] = (); } }
    }
     ( item  layout) {  (item.) {  ( run  item.) {  (run.) run. = slide.[run.]; } } }
  }

   () {
     shapes = ;
     ( item  layout) {
       (item. ===  || item. ===  || item. ===  || item. === ) {
         r = item.;
         fontSize = item. ===  ?  : ;
         runs = item. || (item.);
         isBullet = item. === ;
         bulletChar = isBullet ?  : ;
         runsXml = (runs, fontSize);
        shapes += ;
      }
       (item. === ) {
         r = item.;
        shapes += ;
      }
       (item. === ) {
         r = item.;
         runsXml = ((item.), );
        shapes += ;
      }
       (item. === ) {
         r = item.;
         runs = (item.);
        
         runsXml = (runs, );
        shapes += ;
      }
       (item. === ) {
         r = item.;
         lines = item..();
         paragraphs = ;
         ( line  lines) {
          paragraphs += ;
        }
        shapes += ;
      }
       (item. === ) {
         r = item.;
         rows = item.;
         numCols = rows[] ? rows[]. : ;
         colWidth = .(r. / numCols);
         rowHeight = .(r. / rows.);
         gridCols = ;
         ( c = ; c < numCols; c++) { gridCols += ; }
         tableRows = ;
         ( ri = ; ri < rows.; ri++) {
           cells = ;
           isHeader = ri === ;
           ( ci = ; ci < (rows[ri] ? rows[ri]. : ); ci++) {
             (isHeader) {
              cells += ;
            }  {
              cells += ;
            }
          }
          tableRows += ;
        }
        shapes += ;
      }
       (item. ===  && item.) {
         r = item.;
        shapes += ;
      }
    }
     ;
  }

  
   () {
     ;
  }

   () {
     slideList = ;
     ( i = ; i < slideCount; i++) { slideList += ; }
     ;
  }

   () {
     rels = ;
     ( i = ; i < slideCount; i++) { rels += ; }
     presRId = slideCount + ;
    rels += ;
    rels += ;
    rels += ;
    rels += ;
     ;
  }

   () {
     rels = ;
     (slide.) {  ( img  slide.) { rels += ; } }
     (slide.) {  ( [url, rId]  .(slide.)) { rels += ; } }
     ;
  }

   () {
     defaults = ;
    defaults += ;
     (imageExts && imageExts. > ) {
       ( ext  imageExts) {
        defaults += ;
      }
    }
     overrides = ;
    overrides += ;
    overrides += ;
    overrides += ;
    overrides += ;
    overrides += ;
    overrides += ;
    overrides += ;
     ( i = ; i < slideCount; i++) { overrides += ; }
    overrides += ;
    overrides += ;
     ;
  }

   () {  ; }

   () {
     ;
  }

   () {  ; }

   () {
     now =  ().().(, );
     ;
  }

   () {
     ;
  }

  
   () {
     (!options) options = {};
    shapeId = ; relId = ; imageIndex = ;

     zip =  ();
     ast = (md);

    (ast);

     slides = (ast);
     totalSlides = slides.;
     imageExts =  ();

     ( i = ; i < slides.; i++) {
       slide = slides[i];
      slide. = [];
      slide. = !!options.;
      slide. = i + ;
      slide. = totalSlides;
       (slide. && slide.. > ) {
         ( img  slide.) {
           imgData = (img &&  img === ) ? img. : img;
           (imgData &&  imgData ===  && !imgData.()) {
             ext = (img && img.) || ;
             imgInfo = (zip, imgData, ext);
            slide..(imgInfo);
             (imgInfo.) imageExts.(imgInfo.);
          }
        }
      }
    }

    zip.(, ());
    zip.(, (slides.));
    zip.(, (slides.));
    zip.(, ());
    zip.(, ());
    zip.(, ());
    zip.(, ());
    zip.(, ());
    zip.(, ());
    zip.(, ());
    zip.(, ());

    zip.(, ());
    zip.(, (slides.));

     ( i = ; i < slides.; i++) {
       slide = slides[i];
       layout = (slide);
       imgIdx = ;
       ( item  layout) {  (item. ===  && slide.[imgIdx]) { item. = slide.[imgIdx].; imgIdx++; } }
      (slide, layout);
      zip.(, (slide, layout));
      zip.(, (slide));
    }

    zip.(, (slides., imageExts));

    fs.(output_path, zip.());
     { : output_path, : slides. };
  }

  
   md = .(, ) || ;
   out = .(, ) || ;
   showNums = (.(, ) || ) === ;

   result = (md, out, { : showNums });
  .();
  .();
})();

Usage Notes

Markdown → Slide Mapping Rules

Markdown Element	Slide Behavior
# H1	Starts a new slide (title slide)
## H2	Slide subtitle (below the H1 title)
###–###### H3–H6	Regular text on current slide (bold format only, no special style)
--- (horizontal rule)	Explicit slide break (force new slide)
- bullet list	Unordered bullet points (●)
1. numbered list	Auto-numbered (1. 2. 3. …)
```code```	Code block — gray background (#F5F5F5), dark text, 12pt
| table |	Data table — blue header row (#4472C4), white text
> blockquote	Quoted text — blue left border (#4472C4), 16pt
[text](url)	Hyperlink — blue underlined, registered as OOXML relationship
	Image — centered, auto-sized, embedded as raw binary (direct from file)
Plain paragraph	Body text — 18pt, full width

Slide Layout Dimensions

• Slide size: 9144000 × 6858000 EMU (≈ 10″ × 7.5″), 4:3 aspect ratio
• 12-column grid: each column = SLIDE_W / 12
• Title: grid(0, 12, 0, 1000000) — full width, 1M EMU height
• Subtitle: grid(0, 12, 1000000, 800000) — centered below title
• Body: starts at y=1800000 (if both title+subtitle), 1000000 (if only title), or 0 (no heading)

Image Handling

• Direct binary pass-through: Images are read from disk as raw bytes and written straight into the ZIP — no intermediate base64 encoding. This avoids ~33% bloat and significant performance penalties.
• Only local file paths supported (no remote URLs)
• Supported formats: PNG, JPG, GIF, BMP, WebP
• SVG is NOT supported — convert to PNG first (e.g. via plotter with output_format: "png")
• Dimensions read from file headers; auto-scaled to fit slide width (max fallback: 600px wide)
• Image bytes are read only once, at the moment of ZIP assembly (addImageToZip)

Auto-Overflow Splitting

When content exceeds the slide height, blocks are split into a new overflow slide (no title).

OOXML File Baseline (per presentation)

File	Purpose
_rels/.rels	Root relationships
ppt/presentation.xml	Slide list + slide size + default text style
ppt/_rels/presentation.xml.rels	Presentation-level relationships
ppt/presProps.xml	Presentation properties (extLst)
ppt/viewProps.xml	View settings (guide, grid, zoom)
ppt/tableStyles.xml	Table style defaults
ppt/slideMasters/slideMaster1.xml	Master slide (txStyles)
ppt/slideMasters/_rels/slideMaster1.xml.rels	Master relationships
ppt/slideLayouts/slideLayout1.xml	Layout (empty spTree)
ppt/slideLayouts/_rels/slideLayout1.xml.rels	Layout relationships
ppt/theme/theme1.xml	Color/font/fill scheme
docProps/core.xml	Creator, revision, modified date
docProps/app.xml	Slide count, app metadata
ppt/slides/slideN.xml	Per-slide shapes
ppt/slides/_rels/slideN.xml.rels	Per-slide relationships (links, images)
ppt/media/imageN.ext	Embedded images (if any, one per image)
[Content_Types].xml	MIME type declarations for all parts

Common Pitfalls

⚠️ Image performance: ZipBuilder uses delayed-concat optimization — individual file headers and binary data are stored as separate chunk references, with only 3 Buffer.concat calls during final assembly (vs O(2n+3) previously). Combined with direct binary pass-through (no base64 bloat), image-heavy presentations perform efficiently even in Wasm environments.

⚠️ SVG images cannot be embedded: SVG files are not supported by the OOXML picture shape used in PPTX. Always convert SVGs to PNG before referencing them in Markdown. Use the plotter tool with output_format: "png" to render charts as PNG.

⚠️ Template literal backtick escaping: The entry point wraps markdown in a JavaScript template literal:

const md = `{{markdown}}`.replace(...);

If your markdown contains backticks (\``) — from code blocks or inline code — they will prematurely terminate the template literal, causing a syntax error. **Workaround**: Escape all backticks in the markdown with `(backslash-backtick). Similarly,${must be escaped as${`.

⚠️ No remote image URLs: resolveImages() explicitly skips URLs starting with http:// or https://. All images must be local files accessible via fs.readFileSync(). If an image cannot be read, it is silently dropped from the AST.

⚠️ Hyperlinks require scanAndAssignLinks(): The pipeline must call scanAndAssignLinks() before rendering each slide. Without it, [text](url) syntax will render as plain text (no hyperlink relationship). The Runnable Entry Point handles this automatically.

⚠️ STORE mode only: The ZipBuilder uses method 0 (no compression). Using DEFLATE (method 8) would produce a technically valid ZIP but may cause issues with some OOXML validators that expect uncompressed entries.

⚠️ Single master + single layout: All slides share one slide master and one slide layout. There is no concept of "different slide layouts" or "master slides per section."

⚠️ Schema-constrained XML templates — NEVER simplify: The theme() slideMaster() presProps() viewProps() presentation() functions generate OOXML Schema-constrained XML. Removing or simplifying ANY element (even if it appears "boilerplate") will cause validation failures.

C3 Verification

Check Item	Constraint	Common Omission	Method
ZIP Integrity	EOCD + CD signatures valid	Corrupted ZIP	unzip -t <file>
ppt/viewProps.xml	restoredLeft/restoredTop/cSldViewPr	Self-closing tags → "file corrupted"	Verify minOccurs=1 elements
ppt/presProps.xml	extLst with 3 ext	Empty presentationPr	Count ext children
ppt/slideMasters/slideMaster1.xml	txStyles (titleStyle+bodyStyle+otherStyle)	Missing styles	Verify 3 style sections
ppt/presentation.xml	defaultTextStyle + sldSz	Wrong dimensions	Verify 4:3
ppt/theme/theme1.xml	fmtScheme ≥3 children per list	Schema violation	Count fillStyleLst/lnStyleLst children
Slides	One slideN.xml per slide	Missing slides	Check file count
Hyperlinks	scanAndAssignLinks() run	Links broken	Check slide rels
Images	ppt/media/ present if images used; binary CRC intact	Missing or corrupted images	Cross-check file count + CRC of each media entry
Compression	Method 0 (STORE) only	Accidental DEFLATE	Check ZIP method
theme1.xml Schema	folHlink, cs×2, effectStyleLst	Missing schema-required elements	Count: 1 folHlink + 2 cs + 1 effectStyleLst