claude-presentation-master 8.1.0 → 8.3.0

package/dist/index.mjs

@@ -1,30 +1,98 @@
 // src/types/index.ts
-var ValidationError = class extends Error {
+var ValidationError = class _ValidationError extends Error {
   constructor(errors, message = "Validation failed") {
-    super(message);
+    const errorList = errors.map((e) => `  \u2022 ${e}`).join("\n");
+    const suggestions = _ValidationError.getSuggestions(errors);
+    const suggestionList = suggestions.length > 0 ? "\n\nHow to fix:\n" + suggestions.map((s) => `  \u2192 ${s}`).join("\n") : "";
+    super(`${message}
+
+Issues found:
+${errorList}${suggestionList}`);
     this.errors = errors;
     this.name = "ValidationError";
+    this.suggestions = suggestions;
+  }
+  suggestions;
+  static getSuggestions(errors) {
+    const suggestions = [];
+    for (const error of errors) {
+      if (error.includes("Content is required")) {
+        suggestions.push("Provide markdown content with at least one ## section header");
+      }
+      if (error.includes("Mode must be")) {
+        suggestions.push('Use mode: "keynote" for TED-style or mode: "business" for corporate');
+      }
+      if (error.includes("Title is required")) {
+        suggestions.push('Add a title: "Your Presentation Title" to your config');
+      }
+      if (error.includes("output format")) {
+        suggestions.push('Specify format: ["html"] or format: ["html", "pdf"]');
+      }
+    }
+    return [...new Set(suggestions)];
   }
 };
-var QAFailureError = class extends Error {
-  constructor(score, threshold, qaResults, message = `QA score ${score} below threshold ${threshold}`) {
-    super(message);
+var QAFailureError = class _QAFailureError extends Error {
+  constructor(score, threshold, qaResults, message) {
+    const topIssues = _QAFailureError.getTopIssues(qaResults);
+    const issueList = topIssues.map((i) => `  \u2022 ${i}`).join("\n");
+    const helpText = `
+
+Score: ${score}/100 (threshold: ${threshold})
+
+Top issues to fix:
+${issueList}
+
+How to improve:
+  \u2192 Ensure each slide has meaningful content (not just a title)
+  \u2192 Keep text concise - aim for <40 words per slide
+  \u2192 Use timeline/process slides for step-by-step content
+  \u2192 Add visuals for data-heavy slides`;
+    super(message || `QA score ${score} below threshold ${threshold}${helpText}`);
     this.score = score;
     this.threshold = threshold;
     this.qaResults = qaResults;
     this.name = "QAFailureError";
+    this.topIssues = topIssues;
   }
+  topIssues;
   getIssues() {
     return this.qaResults.issues.map((issue) => issue.message);
   }
+  static getTopIssues(qaResults) {
+    const issues = [];
+    if (qaResults.slideScores) {
+      for (const slide of qaResults.slideScores) {
+        if (slide.criticalIssues) {
+          issues.push(...slide.criticalIssues);
+        }
+      }
+    }
+    if (qaResults.issues) {
+      issues.push(...qaResults.issues.map((i) => i.message));
+    }
+    return [...new Set(issues)].slice(0, 5);
+  }
 };
 var TemplateNotFoundError = class extends Error {
-  constructor(templatePath, message = `Template not found: ${templatePath}`) {
-    super(message);
+  constructor(templatePath, message) {
+    super(message || `Template not found: ${templatePath}
+
+Available templates: title, content, timeline, process, metrics, quote, cta, thank-you`);
     this.templatePath = templatePath;
     this.name = "TemplateNotFoundError";
   }
 };
+var KnowledgeBaseError = class extends Error {
+  constructor(field, context, message) {
+    super(message || `Knowledge base configuration error: Missing "${field}" in ${context}
+
+Check assets/presentation-knowledge.yaml for the correct structure.`);
+    this.field = field;
+    this.context = context;
+    this.name = "KnowledgeBaseError";
+  }
+};
 
 // src/core/PresentationEngine.ts
 import * as fs2 from "fs";
@@ -33,8 +101,7 @@ import * as os from "os";
 
 // src/kb/KnowledgeGateway.ts
 import { readFileSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
+import { join } from "path";
 import * as yaml from "yaml";
 
 // src/utils/Logger.ts
@@ -106,9 +173,6 @@ var logger = new Logger({
 
 // src/kb/KnowledgeGateway.ts
 function getModuleDir() {
-  if (typeof import.meta !== "undefined" && import.meta.url) {
-    return dirname(fileURLToPath(import.meta.url));
-  }
   if (typeof __dirname !== "undefined") {
     return __dirname;
   }
@@ -1053,7 +1117,7 @@ var ContentAnalyzer = class {
     logger.step(`Detected type: ${detectedType}`);
     const sections = this.extractSections(text);
     logger.step(`Found ${sections.length} sections`);
-    const scqa = this.extractSCQA(text);
+    const scqa = this.extractSCQA(text, subtitle);
     const sparkline = this.extractSparkline(text);
     const keyMessages = this.extractKeyMessages(text);
     const dataPoints = this.extractDataPoints(text);
@@ -1320,15 +1384,24 @@ var ContentAnalyzer = class {
   /**
    * Extract SCQA structure (Barbara Minto)
    * CRITICAL: Answer must be clean prose, NOT bullet points
+   * @param text - The content text to analyze
+   * @param subtitle - Optional subtitle to exclude (prevents redundancy with title slide)
    */
-  extractSCQA(text) {
+  extractSCQA(text, subtitle) {
     const paragraphs = text.split(/\n\n+/).filter((p) => p.trim());
+    const normalizedSubtitle = (subtitle || "").toLowerCase().trim();
+    const isSubtitle = (para) => {
+      if (!normalizedSubtitle) return false;
+      const normalized = para.toLowerCase().trim();
+      return normalized === normalizedSubtitle || normalized.includes(normalizedSubtitle) || normalizedSubtitle.includes(normalized);
+    };
     let situation = "";
     let complication = "";
     let question = "";
     let answer = "";
     for (const para of paragraphs.slice(0, 5)) {
       if (para.startsWith("-") || para.startsWith("#") || para.startsWith("|")) continue;
+      if (isSubtitle(para)) continue;
       if (this.containsSignals(para.toLowerCase(), this.situationSignals)) {
         situation = this.extractFirstSentence(para);
         break;
@@ -1356,6 +1429,7 @@ var ContentAnalyzer = class {
     if (!situation && paragraphs.length > 0) {
       for (const para of paragraphs.slice(0, 5)) {
         if (!para.startsWith("-") && !para.startsWith("#") && para.length > 50) {
+          if (isSubtitle(para)) continue;
           situation = this.extractFirstSentence(para);
           break;
         }
@@ -1802,7 +1876,8 @@ var ContentPatternClassifier = class {
     if (!match || !match[1]) return null;
     const value = match[1];
     const afterNumber = content.slice(content.indexOf(value) + value.length);
-    const context = afterNumber.trim().slice(0, 60).split(/[.!?]/)[0]?.trim() ?? "";
+    const contextRaw = afterNumber.trim().split(/[\n\r]|-\s|[.!?]|(?=\d+%)|(?=\$\d)/)[0] || "";
+    const context = contextRaw.trim().slice(0, 60);
     return { value, context };
   }
   /**
@@ -2499,6 +2574,16 @@ var SlideFactory = class {
         continue;
       }
       this.usedContent.add(contentKey);
+      const normalizedHeader = section.header.toLowerCase().replace(/[^a-z0-9]/g, "");
+      const normalizedTitle = analysis.title.toLowerCase().replace(/[^a-z0-9]/g, "");
+      const normalizedSubtitle = (analysis.subtitle || "").toLowerCase().replace(/[^a-z0-9]/g, "");
+      const normalizedContent = (section.content || "").toLowerCase().replace(/[^a-z0-9]/g, "");
+      const headerMatchesTitle = normalizedHeader === normalizedTitle || normalizedTitle.includes(normalizedHeader) || normalizedHeader.includes(normalizedTitle);
+      const contentMatchesSubtitle = normalizedContent && (normalizedContent === normalizedSubtitle || normalizedSubtitle.includes(normalizedContent) || normalizedContent.includes(normalizedSubtitle));
+      if (headerMatchesTitle && (contentMatchesSubtitle || !section.content || section.content.length < 30)) {
+        logger.warn(`Section "${section.header}" skipped - duplicates title slide`);
+        continue;
+      }
       const headerLower = section.header.toLowerCase();
       const isCTASection = headerLower.includes("call to action") || headerLower.includes("next step") || headerLower.includes("take action") || headerLower.includes("get started") || headerLower.includes("start today");
       if (isCTASection) {
@@ -2678,47 +2763,69 @@ var SlideFactory = class {
     const scqa = analysis.scqa;
     const titles = this.config.scqaTitles;
     const minBodyLength = 20;
+    const normalizedTitle = analysis.title.toLowerCase().replace(/[^a-z0-9]/g, "");
+    const normalizedSubtitle = (analysis.subtitle || "").toLowerCase().replace(/[^a-z0-9]/g, "");
+    const duplicatesHeadline = (body) => {
+      if (!body) return true;
+      const normalizedBody = body.toLowerCase().replace(/[^a-z0-9]/g, "");
+      if (!normalizedBody || normalizedBody.length < 10) return false;
+      const titleMatch = normalizedTitle.length > 5 && (normalizedBody === normalizedTitle || normalizedTitle.includes(normalizedBody) || normalizedBody.includes(normalizedTitle));
+      const subtitleMatch = normalizedSubtitle.length > 5 && (normalizedBody === normalizedSubtitle || normalizedSubtitle.includes(normalizedBody) || normalizedBody.includes(normalizedSubtitle));
+      return titleMatch || subtitleMatch;
+    };
     const situationBody = scqa?.situation ? this.truncateText(scqa.situation, this.config.rules.wordsPerSlide.max) : "";
     if (situationBody.length >= minBodyLength && !this.usedContent.has("scqa-situation")) {
-      this.usedContent.add("scqa-situation");
-      slides.push({
-        index: slides.length,
-        type: "single-statement",
-        data: {
-          title: titles.situation,
-          // FROM KB - not hardcoded 'Current Situation'
-          body: situationBody
-        },
-        classes: ["situation-slide"]
-      });
+      if (duplicatesHeadline(situationBody)) {
+        logger.warn(`SCQA Situation skipped - duplicates title/subtitle: "${situationBody.slice(0, 50)}..."`);
+      } else {
+        this.usedContent.add("scqa-situation");
+        slides.push({
+          index: slides.length,
+          type: "single-statement",
+          data: {
+            title: titles.situation,
+            // FROM KB - not hardcoded 'Current Situation'
+            body: situationBody
+          },
+          classes: ["situation-slide"]
+        });
+      }
     }
     const complicationBody = scqa?.complication ? this.truncateText(scqa.complication, this.config.rules.wordsPerSlide.max) : "";
     if (complicationBody.length >= minBodyLength && !this.usedContent.has("scqa-complication")) {
-      this.usedContent.add("scqa-complication");
-      slides.push({
-        index: slides.length,
-        type: "single-statement",
-        data: {
-          title: titles.complication,
-          // FROM KB - not hardcoded 'The Challenge'
-          body: complicationBody
-        },
-        classes: ["complication-slide"]
-      });
+      if (duplicatesHeadline(complicationBody)) {
+        logger.warn(`SCQA Complication skipped - duplicates title/subtitle`);
+      } else {
+        this.usedContent.add("scqa-complication");
+        slides.push({
+          index: slides.length,
+          type: "single-statement",
+          data: {
+            title: titles.complication,
+            // FROM KB - not hardcoded 'The Challenge'
+            body: complicationBody
+          },
+          classes: ["complication-slide"]
+        });
+      }
     }
     const questionBody = scqa?.question ? this.truncateText(scqa.question, this.config.rules.wordsPerSlide.max) : "";
     if (questionBody.length >= minBodyLength && !this.usedContent.has("scqa-question")) {
-      this.usedContent.add("scqa-question");
-      slides.push({
-        index: slides.length,
-        type: "single-statement",
-        data: {
-          title: titles.question,
-          // FROM KB - not hardcoded 'The Question'
-          body: questionBody
-        },
-        classes: ["question-slide"]
-      });
+      if (duplicatesHeadline(questionBody)) {
+        logger.warn(`SCQA Question skipped - duplicates title/subtitle`);
+      } else {
+        this.usedContent.add("scqa-question");
+        slides.push({
+          index: slides.length,
+          type: "single-statement",
+          data: {
+            title: titles.question,
+            // FROM KB - not hardcoded 'The Question'
+            body: questionBody
+          },
+          classes: ["question-slide"]
+        });
+      }
     }
   }
   addSparklineSlides(slides, analysis) {
@@ -2771,14 +2878,41 @@ var SlideFactory = class {
   // CONTENT SLIDES - ALL values from KB
   // ===========================================================================
   createBigNumberSlide(index, section, pattern) {
-    const fullContent = `${section.header} ${section.content} ${section.bullets.join(" ")}`;
-    const bigNumber = this.classifier.extractBigNumber(fullContent);
+    let bigNumber = null;
+    let sourceBullet = null;
+    for (const bullet of section.bullets) {
+      const extracted = this.classifier.extractBigNumber(bullet);
+      if (extracted) {
+        bigNumber = extracted;
+        sourceBullet = bullet;
+        break;
+      }
+    }
+    if (!bigNumber) {
+      bigNumber = this.classifier.extractBigNumber(section.header);
+    }
+    if (!bigNumber && section.content) {
+      bigNumber = this.classifier.extractBigNumber(section.content);
+    }
     const actualValue = bigNumber?.value || pattern.bigNumberValue;
     if (!actualValue) {
       logger.warn(`No number found for big-number slide, falling back to single-statement`);
       return this.createSingleStatementSlide(index, section);
     }
-    const contextContent = bigNumber?.context || section.content;
+    let contextContent = bigNumber?.context || "";
+    if (sourceBullet && !contextContent) {
+      contextContent = sourceBullet.replace(actualValue, "").trim();
+    }
+    if (!contextContent) {
+      contextContent = section.content || section.header;
+    }
+    let cleanTitle = section.header;
+    if (actualValue && cleanTitle.includes(actualValue.replace(/[,$%]/g, ""))) {
+      cleanTitle = cleanTitle.replace(new RegExp(`\\$?${actualValue.replace(/[,$%]/g, "").replace(/\./g, "\\.?")}[KMBkmb]?`, "gi"), "").replace(/\s+/g, " ").trim();
+    }
+    if (!cleanTitle || cleanTitle.length < 5) {
+      cleanTitle = bigNumber?.context?.split(/[.!?]/)[0] || section.header;
+    }
     const craftedContext = this.craftExpertContent(
       contextContent,
       "big_number",
@@ -2788,7 +2922,7 @@ var SlideFactory = class {
       index,
       type: "big-number",
       data: {
-        title: this.createTitle(section.header, section),
+        title: cleanTitle,
         keyMessage: actualValue,
         body: craftedContext
       },
@@ -2798,25 +2932,43 @@ var SlideFactory = class {
   createComparisonSlide(index, section) {
     const comparison = this.classifier.extractComparison(section);
     const labels = this.config.defaults.comparison;
+    const title = this.createTitle(section.header, section);
+    const normalizedTitle = title.toLowerCase().replace(/[^a-z0-9]/g, "");
     const leftFallback = labels.optionLabels[0] ?? "Option A";
     const rightFallback = labels.optionLabels[1] ?? "Option B";
-    const leftColumn = comparison?.left || section.bullets[0] || leftFallback;
-    const rightColumn = comparison?.right || section.bullets[1] || rightFallback;
+    let leftColumn = comparison?.left || section.bullets[0] || "";
+    let rightColumn = comparison?.right || section.bullets[1] || "";
+    const normalizedLeft = leftColumn.toLowerCase().replace(/[^a-z0-9]/g, "");
+    const normalizedRight = rightColumn.toLowerCase().replace(/[^a-z0-9]/g, "");
+    const leftIsDuplicate = normalizedLeft === normalizedTitle || normalizedTitle.includes(normalizedLeft);
+    const rightIsDuplicate = normalizedRight === normalizedTitle || normalizedTitle.includes(normalizedRight);
+    if (leftIsDuplicate || rightIsDuplicate || !leftColumn && !rightColumn) {
+      if (section.bullets.length >= 2) {
+        logger.warn(`Comparison slide "${title}" has duplicate content, using bullet points instead`);
+        return this.createBulletSlide(index, section);
+      }
+      if (leftIsDuplicate && rightIsDuplicate) {
+        logger.warn(`Skipping comparison slide "${title}" - content duplicates title`);
+        return null;
+      }
+      if (leftIsDuplicate) leftColumn = leftFallback;
+      if (rightIsDuplicate) rightColumn = rightFallback;
+    }
     return {
       index,
       type: "comparison",
       data: {
-        title: this.createTitle(section.header, section),
+        title,
         columns: [
           {
             title: labels.leftLabel,
             // FROM KB - not hardcoded 'Before'
-            content: this.truncateText(leftColumn, this.config.rules.wordsPerSlide.max)
+            content: this.truncateText(leftColumn || leftFallback, this.config.rules.wordsPerSlide.max)
           },
           {
             title: labels.rightLabel,
             // FROM KB - not hardcoded 'After'
-            content: this.truncateText(rightColumn, this.config.rules.wordsPerSlide.max)
+            content: this.truncateText(rightColumn || rightFallback, this.config.rules.wordsPerSlide.max)
           }
         ]
       },
@@ -3087,10 +3239,21 @@ var SlideFactory = class {
    * Used for section headers with strong conclusions.
    */
   createTitleImpactSlide(index, section) {
+    const title = this.cleanText(section.header);
     const supportingText = section.content || section.bullets.slice(0, 2).join(". ");
     const truncatedSupport = this.truncateText(supportingText, this.config.defaults.context.maxWords);
+    const normalizedTitle = title.toLowerCase().replace(/[^a-z0-9]/g, "");
+    const normalizedBody = truncatedSupport.toLowerCase().replace(/[^a-z0-9]/g, "");
+    const bodyIsDuplicate = normalizedBody === normalizedTitle || normalizedTitle.includes(normalizedBody) || normalizedBody.includes(normalizedTitle) || truncatedSupport.length < 10;
+    if (bodyIsDuplicate) {
+      if (section.bullets.length >= 2 && this.config.mode === "business") {
+        return this.createBulletSlide(index, section);
+      }
+      logger.warn(`Skipping title-impact slide "${title}" - no distinct body content`);
+      return null;
+    }
     const data = {
-      title: this.cleanText(section.header)
+      title
     };
     if (truncatedSupport) {
       data.body = truncatedSupport;
@@ -5506,12 +5669,15 @@ var VisualQualityEvaluator = class {
       glanceTest += 1;
       glanceNotes.push("Clean, minimal text - passes glance test easily");
     }
-    if (slideData.bullets.length > 5) {
+    const isAgendaSlide = slideType === "agenda" || (slideData.classes || []).includes("agenda-slide");
+    const bulletLimit = isAgendaSlide ? 8 : 5;
+    const bulletWarning = isAgendaSlide ? 6 : 3;
+    if (slideData.bullets.length > bulletLimit) {
       glanceTest -= 4;
       glanceNotes.push("Too many bullets - cannot scan in 3 seconds");
-    } else if (slideData.bullets.length > 3) {
-      glanceTest -= 2;
-      glanceNotes.push("Multiple bullets - needs careful structuring");
+    } else if (slideData.bullets.length > bulletWarning) {
+      glanceTest -= isAgendaSlide ? 1 : 2;
+      glanceNotes.push(isAgendaSlide ? "Agenda with many items" : "Multiple bullets - needs careful structuring");
     }
     if (slideData.hasImage || slideData.hasChart) {
       glanceTest += 1;
@@ -7606,13 +7772,63 @@ var PowerPointGenerator = class {
 
 // src/generators/PDFGenerator.ts
 import puppeteer from "puppeteer";
+var cachedBrowser = null;
+var browserIdleTimeout = null;
+var BROWSER_IDLE_MS = 3e4;
 var PDFGenerator = class {
   defaultOptions = {
     orientation: "landscape",
     printBackground: true,
     format: "Slide",
-    scale: 1
+    scale: 1,
+    reuseBrowser: true
   };
+  /**
+   * Get or create a browser instance
+   */
+  async getBrowser(reuse) {
+    if (browserIdleTimeout) {
+      clearTimeout(browserIdleTimeout);
+      browserIdleTimeout = null;
+    }
+    if (reuse && cachedBrowser && cachedBrowser.connected) {
+      logger.progress("Using cached browser instance");
+      return cachedBrowser;
+    }
+    if (cachedBrowser && !cachedBrowser.connected) {
+      cachedBrowser = null;
+    }
+    logger.progress("Launching new browser instance...");
+    const browser = await puppeteer.launch({
+      headless: true,
+      args: [
+        "--no-sandbox",
+        "--disable-setuid-sandbox",
+        "--disable-dev-shm-usage",
+        "--disable-gpu"
+      ]
+    });
+    if (reuse) {
+      cachedBrowser = browser;
+    }
+    return browser;
+  }
+  /**
+   * Schedule browser cleanup after idle period
+   */
+  scheduleBrowserCleanup() {
+    if (browserIdleTimeout) {
+      clearTimeout(browserIdleTimeout);
+    }
+    browserIdleTimeout = setTimeout(async () => {
+      if (cachedBrowser) {
+        logger.progress("Closing idle browser instance");
+        await cachedBrowser.close().catch(() => {
+        });
+        cachedBrowser = null;
+      }
+    }, BROWSER_IDLE_MS);
+  }
   /**
    * Generate PDF from HTML presentation
    * @param html - The HTML content of the presentation
@@ -7621,18 +7837,14 @@ var PDFGenerator = class {
    */
   async generate(html, options = {}) {
     const opts = { ...this.defaultOptions, ...options };
+    const reuseBrowser = opts.reuseBrowser ?? true;
     logger.progress("\u{1F4C4} Generating PDF...");
-    let browser;
+    let browser = null;
+    let shouldCloseBrowser = !reuseBrowser;
+    let page = null;
     try {
-      browser = await puppeteer.launch({
-        headless: true,
-        args: [
-          "--no-sandbox",
-          "--disable-setuid-sandbox",
-          "--disable-dev-shm-usage"
-        ]
-      });
-      const page = await browser.newPage();
+      browser = await this.getBrowser(reuseBrowser);
+      page = await browser.newPage();
       const printHtml = this.preparePrintHtml(html);
       await page.setViewport({
         width: 1920,
@@ -7668,13 +7880,38 @@ var PDFGenerator = class {
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       logger.error(`PDF generation failed: ${errorMessage}`);
+      shouldCloseBrowser = true;
       throw new Error(`PDF generation failed: ${errorMessage}`);
     } finally {
-      if (browser) {
-        await browser.close();
+      if (page) {
+        await page.close().catch(() => {
+        });
+      }
+      if (shouldCloseBrowser && browser) {
+        await browser.close().catch(() => {
+        });
+        if (browser === cachedBrowser) {
+          cachedBrowser = null;
+        }
+      } else if (reuseBrowser) {
+        this.scheduleBrowserCleanup();
       }
     }
   }
+  /**
+   * Manually close the cached browser (call before process exit)
+   */
+  static async closeBrowser() {
+    if (browserIdleTimeout) {
+      clearTimeout(browserIdleTimeout);
+      browserIdleTimeout = null;
+    }
+    if (cachedBrowser) {
+      await cachedBrowser.close().catch(() => {
+      });
+      cachedBrowser = null;
+    }
+  }
   /**
    * Prepare HTML for print/PDF output
    * Modifies the HTML to work better as a printed document
@@ -7688,12 +7925,24 @@ var PDFGenerator = class {
           margin: 0;
         }
 
+        /* Font rendering optimization for print */
+        * {
+          -webkit-font-smoothing: antialiased;
+          -moz-osx-font-smoothing: grayscale;
+          text-rendering: optimizeLegibility;
+          font-feature-settings: "liga" 1, "kern" 1;
+        }
+
         @media print {
           html, body {
             margin: 0;
             padding: 0;
             width: 1920px;
             height: 1080px;
+            /* Print color optimization */
+            color-adjust: exact;
+            -webkit-print-color-adjust: exact;
+            print-color-adjust: exact;
           }
 
           .reveal .slides {
@@ -7710,7 +7959,8 @@ var PDFGenerator = class {
             width: 1920px !important;
             height: 1080px !important;
             margin: 0 !important;
-            padding: 60px !important;
+            /* Professional safe margins: 80px (4.2%) */
+            padding: 80px !important;
             box-sizing: border-box;
             position: relative !important;
             top: auto !important;
@@ -7734,7 +7984,7 @@ var PDFGenerator = class {
           }
 
           /* Disable animations for print */
-          * {
+          *, *::before, *::after {
             animation: none !important;
             transition: none !important;
           }
@@ -7750,6 +8000,30 @@ var PDFGenerator = class {
           .reveal .navigate-down {
             display: none !important;
           }
+
+          /* Typography refinements for print */
+          h1, h2, h3, h4 {
+            orphans: 3;
+            widows: 3;
+            page-break-after: avoid;
+          }
+
+          p, li {
+            orphans: 2;
+            widows: 2;
+          }
+
+          /* Ensure links are readable in print */
+          a {
+            text-decoration: none;
+          }
+
+          /* Prevent image overflow */
+          img {
+            max-width: 100%;
+            height: auto;
+            page-break-inside: avoid;
+          }
         }
 
         /* Force print mode in Puppeteer */
@@ -7757,6 +8031,11 @@ var PDFGenerator = class {
           page-break-after: always;
           page-break-inside: avoid;
         }
+
+        /* High contrast mode for business presentations */
+        .reveal section {
+          color-scheme: light;
+        }
       </style>
     `;
     if (html.includes("</head>")) {
@@ -8349,6 +8628,7 @@ export {
   CompositeImageProvider,
   ContentAnalyzer,
   ContentPatternClassifier,
+  KnowledgeBaseError,
   KnowledgeGateway,
   LocalImageProvider,
   MermaidProvider,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-presentation-master",
-  "version": "8.1.0",
+  "version": "8.3.0",
   "description": "Generate world-class presentations using expert methodologies from Duarte, Reynolds, Gallo, and Anderson. Enforces rigorous quality standards through real visual validation.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",