yumiamd 0.1.6 → 0.1.8

package/dist/bin.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   runCli
-} from "./chunk-FHM6V4JH.js";
+} from "./chunk-WUJKHJJU.js";
 
 // src/bin.ts
 var result = await runCli(process.argv);

package/dist/{chunk-FHM6V4JH.js → chunk-WUJKHJJU.js}

@@ -47,6 +47,17 @@ function createCard(elements, title, variant) {
     ...variant ? { variant } : {}
   };
 }
+function createMetric(value, label, variant, description, unit, change) {
+  return {
+    type: "metric",
+    value,
+    label,
+    ...variant ? { variant } : {},
+    ...description ? { description } : {},
+    ...unit ? { unit } : {},
+    ...change ? { change } : {}
+  };
+}
 function createCode(code, language, highlightLines) {
   return {
     type: "code",
@@ -111,13 +122,14 @@ var DefaultYumiaParser = class {
     }
     const normalized = source.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
     const { metadata, content, lineOffset } = this.extractFrontmatter(normalized);
+    if (!content.trim()) {
+      return createPresentation(metadata, []);
+    }
     const slideChunks = this.splitSlides(content, lineOffset);
     const slides = [];
     for (const chunk of slideChunks) {
       const slide = this.parseSlide(chunk.content, chunk.startLine);
-      if (slide.elements.length > 0 || slide.notes !== void 0 || slide.background !== void 0) {
-        slides.push(slide);
-      }
+      slides.push(slide);
     }
     const presentation = createPresentation(metadata, slides);
     if (this.diagnostics.length > 0) {
@@ -346,6 +358,28 @@ var DefaultYumiaParser = class {
           i++;
           continue;
         }
+        if (directiveHeader.startsWith("metric")) {
+          const valueMatch = directiveHeader.match(/value=['"](.*?)['"]/);
+          const labelMatch = directiveHeader.match(/label=['"](.*?)['"]/);
+          const variantMatch = directiveHeader.match(/variant=['"](.*?)['"]/);
+          const descMatch = directiveHeader.match(/description=['"](.*?)['"]/);
+          const unitMatch = directiveHeader.match(/unit=['"](.*?)['"]/);
+          const changeMatch = directiveHeader.match(/change=['"](.*?)['"]/);
+          const value = valueMatch ? valueMatch[1] : "0";
+          const label = labelMatch ? labelMatch[1] : "";
+          const variant = variantMatch ? variantMatch[1] : void 0;
+          const desc = descMatch ? descMatch[1] : void 0;
+          const unit = unitMatch ? unitMatch[1] : void 0;
+          const change = changeMatch ? changeMatch[1] : void 0;
+          const el = createMetric(value, label, variant, desc, unit, change);
+          el.loc = {
+            start: { line: currentLineNum, column: 1 },
+            end: { line: currentLineNum, column: rawLine.length + 1 }
+          };
+          elements.push(el);
+          i++;
+          continue;
+        }
         const [directiveName, ...args] = directiveHeader.split(" ");
         const directiveArg = args.join(" ").trim();
         const blockLines = [];
@@ -354,7 +388,8 @@ var DefaultYumiaParser = class {
         let closed = false;
         while (i < lines.length) {
           const innerLine = lines[i]?.trim() ?? "";
-          if (innerLine.startsWith(":::") && innerLine.length > 3) {
+          const isSingleLine = innerLine.startsWith(":::metric") || innerLine.startsWith(":::layout");
+          if (innerLine.startsWith(":::") && innerLine.length > 3 && !isSingleLine) {
             nestedCount++;
           } else if (innerLine === ":::") {
             nestedCount--;
@@ -382,9 +417,17 @@ var DefaultYumiaParser = class {
         if (directiveName === "notes") {
           notes = blockLines.map((l) => l.trim()).filter(Boolean).join("\n");
         } else if (directiveName === "card") {
-          const title = directiveArg.replace(/^['"](.*)['"]$/, "$1") || void 0;
+          let cardTitle;
+          let cardVariant;
+          const variantMatch = directiveArg.match(/variant=['"](.*?)['"]/);
+          if (variantMatch) {
+            cardVariant = variantMatch[1];
+            cardTitle = directiveArg.replace(/variant=['"].*?['"]/, "").trim().replace(/^['"](.*)['"]$/, "$1") || void 0;
+          } else {
+            cardTitle = directiveArg.replace(/^['"](.*)['"]$/, "$1") || void 0;
+          }
           const { elements: cardElements } = this.parseLines(blockLines, blockBaseLine);
-          const el = createCard(cardElements, title);
+          const el = createCard(cardElements, cardTitle, cardVariant);
           el.loc = {
             start: { line: directiveStartLine, column: 1 },
             end: { line: baseLine + i - 1, column: 1 }
@@ -530,7 +573,8 @@ var DefaultYumiaParser = class {
         let nestedCount = 1;
         while (i < lines.length) {
           const innerLine = lines[i]?.trim() ?? "";
-          if (innerLine.startsWith(":::") && innerLine.length > 3) {
+          const isSingleLine = innerLine.startsWith(":::metric") || innerLine.startsWith(":::layout");
+          if (innerLine.startsWith(":::") && innerLine.length > 3 && !isSingleLine) {
             nestedCount++;
           } else if (innerLine === ":::") {
             nestedCount--;
@@ -574,7 +618,7 @@ var VIEWPORT_PRESETS = {
 var DefaultLayoutEngine = class {
   computeSlide(slide, viewport = DEFAULT_VIEWPORT, options = {}) {
     const padding = options.padding ?? 64;
-    const gap = options.gap ?? 24;
+    const gap = options.gap ?? 32;
     const availableWidth = Math.max(100, viewport.width - padding * 2);
     const availableHeight = Math.max(100, viewport.height - padding * 2);
     if (slide.elements.length === 0) {
@@ -626,7 +670,7 @@ var DefaultLayoutEngine = class {
         return { element, bounds: { x, y, width, height } };
       }
       case "list": {
-        const height = this.estimateListHeight(element);
+        const height = this.estimateListHeight(element, width);
         return { element, bounds: { x, y, width, height } };
       }
       case "code": {
@@ -645,6 +689,10 @@ var DefaultLayoutEngine = class {
         const height = this.estimateImageHeight(element);
         return { element, bounds: { x, y, width, height } };
       }
+      case "metric": {
+        const height = this.estimateMetricHeight(element);
+        return { element, bounds: { x, y, width, height } };
+      }
       case "card": {
         return this.layoutCard(element, x, y, width, gap);
       }
@@ -658,13 +706,13 @@ var DefaultLayoutEngine = class {
     }
   }
   layoutCard(element, x, y, width, gap) {
-    const cardPadding = 28;
+    const cardPadding = 32;
     const innerWidth = Math.max(10, width - cardPadding * 2);
-    const titleHeight = element.title ? 56 : 0;
+    const titleHeight = element.title ? 60 : 0;
     const innerStartY = y + cardPadding + titleHeight;
-    const { nodes: children, totalHeight: innerHeight } = this.layoutElementList(element.elements, x + cardPadding, innerStartY, innerWidth, gap / 1.5);
-    const cardHeight = titleHeight + innerHeight + cardPadding * 2;
-    const bounds = { x, y, width, height: Math.max(100, cardHeight) };
+    const { nodes: children, totalHeight: innerHeight } = this.layoutElementList(element.elements, x + cardPadding, innerStartY, innerWidth, gap);
+    const cardHeight = titleHeight + innerHeight + cardPadding * 2 + 12;
+    const bounds = { x, y, width, height: Math.max(120, cardHeight) };
     return {
       element,
       bounds,
@@ -727,24 +775,31 @@ var DefaultLayoutEngine = class {
   estimateParagraphHeight(paragraph, width) {
     const charsPerLine = Math.max(20, Math.floor(width / 14));
     const lines = Math.ceil(paragraph.text.length / charsPerLine) || 1;
-    return Math.max(40, lines * 32);
+    return Math.max(40, lines * 36);
   }
-  estimateListHeight(list) {
-    return Math.max(40, list.items.length * 40);
+  estimateListHeight(list, width = 800) {
+    const charsPerLine = Math.max(15, Math.floor(width / 13));
+    let totalHeight = 0;
+    for (const item of list.items) {
+      const cleanLen = item.text.replace(/\*\*/g, "").replace(/\*/g, "").length;
+      const lines = Math.ceil(cleanLen / charsPerLine) || 1;
+      totalHeight += lines * 34 + 18;
+    }
+    return Math.max(40, totalHeight);
   }
   estimateCodeHeight(code) {
     const lines = code.code.split("\n").length || 1;
-    return lines * 26 + 32;
+    return lines * 28 + 48;
   }
   estimateQuoteHeight(quote, width) {
     const charsPerLine = Math.max(20, Math.floor(width / 14));
     const lines = Math.ceil(quote.text.length / charsPerLine) || 1;
-    return lines * 32 + 24;
+    return lines * 34 + 32;
   }
   estimateTableHeight(table) {
-    const headerHeight = table.headers && table.headers.length > 0 ? 50 : 0;
-    const rowsHeight = (table.rows ? table.rows.length : 0) * 42;
-    return Math.max(60, headerHeight + rowsHeight + 16);
+    const headerHeight = table.headers && table.headers.length > 0 ? 56 : 0;
+    const rowsHeight = (table.rows ? table.rows.length : 0) * 44;
+    return Math.max(60, headerHeight + rowsHeight + 20);
   }
   estimateImageHeight(image) {
     if (typeof image.height === "number") {
@@ -752,6 +807,9 @@ var DefaultLayoutEngine = class {
     }
     return 320;
   }
+  estimateMetricHeight(metric) {
+    return metric.change ? 140 : 120;
+  }
 };
 
 // ../theme/dist/default-theme.js
@@ -766,7 +824,11 @@ var defaultTheme = {
     text: "#0f172a",
     muted: "#64748b",
     accent: "#06b6d4",
-    border: "#e2e8f0"
+    border: "#e2e8f0",
+    success: "#10b981",
+    warning: "#f59e0b",
+    danger: "#ef4444",
+    info: "#3b82f6"
   },
   typography: {
     headingFont: "Inter, system-ui, -apple-system, sans-serif",
@@ -823,29 +885,523 @@ var defaultTheme = {
     }
   }
 };
-function createTheme(overrides) {
+var cyberpunkTheme = {
+  name: "cyberpunk",
+  description: "High-energy dark cyberpunk theme with neon pink and cyan accents",
+  colors: {
+    primary: "#FF2E88",
+    secondary: "#00F0FF",
+    background: "#0B0B12",
+    surface: "#151522",
+    text: "#FFFFFF",
+    muted: "#A7A7B5",
+    accent: "#7B61FF",
+    border: "#2E2E48",
+    success: "#00FF9F",
+    warning: "#FFE600",
+    danger: "#FF0055",
+    info: "#00F0FF"
+  },
+  typography: {
+    headingFont: "Outfit, Inter, sans-serif",
+    bodyFont: "Inter, sans-serif",
+    codeFont: "JetBrains Mono, monospace",
+    sizes: {
+      h1: 46,
+      h2: 38,
+      h3: 28,
+      h4: 22,
+      body: 18,
+      small: 14,
+      code: 16
+    }
+  },
+  spacing: {
+    unit: 8,
+    slidePadding: 48,
+    elementGap: 28
+  },
+  radius: {
+    default: 12,
+    sm: 6,
+    md: 12,
+    lg: 20,
+    full: 9999
+  },
+  components: {
+    card: {
+      background: "#151522",
+      borderColor: "#FF2E88",
+      borderRadius: 16,
+      padding: 28
+    },
+    code: {
+      background: "#07070D",
+      textColor: "#00F0FF",
+      borderRadius: 8
+    }
+  }
+};
+var minimalTheme = {
+  name: "minimal",
+  description: "Monochrome Swiss-style design with maximum clarity and contrast",
+  colors: {
+    primary: "#111111",
+    secondary: "#333333",
+    background: "#FFFFFF",
+    surface: "#F5F5F7",
+    text: "#111111",
+    muted: "#777777",
+    accent: "#000000",
+    border: "#E5E5E5",
+    success: "#10B981",
+    warning: "#F59E0B",
+    danger: "#EF4444",
+    info: "#3B82F6"
+  },
+  typography: {
+    headingFont: "Helvetica Neue, Arial, sans-serif",
+    bodyFont: "Helvetica Neue, Arial, sans-serif",
+    codeFont: "Menlo, Monaco, monospace",
+    sizes: {
+      h1: 44,
+      h2: 34,
+      h3: 26,
+      h4: 20,
+      body: 18,
+      small: 14,
+      code: 15
+    }
+  },
+  spacing: {
+    unit: 8,
+    slidePadding: 56,
+    elementGap: 24
+  },
+  radius: {
+    default: 4,
+    sm: 2,
+    md: 4,
+    lg: 8,
+    full: 9999
+  },
+  components: {
+    card: {
+      background: "#F5F5F7",
+      borderColor: "#E5E5E5",
+      borderRadius: 6,
+      padding: 24
+    }
+  }
+};
+var corporateTheme = {
+  name: "corporate",
+  description: "Executive navy blue palette tailored for business and enterprise decks",
+  colors: {
+    primary: "#0A2540",
+    secondary: "#635BFF",
+    background: "#FFFFFF",
+    surface: "#F8FAFC",
+    text: "#1A1F36",
+    muted: "#4F566B",
+    accent: "#00D4B2",
+    border: "#E3E8EE",
+    success: "#00D4B2",
+    warning: "#FFC043",
+    danger: "#DF1B41",
+    info: "#635BFF"
+  },
+  typography: {
+    headingFont: "Inter, Segoe UI, sans-serif",
+    bodyFont: "Inter, Segoe UI, sans-serif",
+    codeFont: "Consolas, monospace",
+    sizes: {
+      h1: 42,
+      h2: 34,
+      h3: 26,
+      h4: 20,
+      body: 18,
+      small: 14,
+      code: 15
+    }
+  },
+  spacing: {
+    unit: 8,
+    slidePadding: 48,
+    elementGap: 24
+  },
+  radius: {
+    default: 8,
+    sm: 4,
+    md: 8,
+    lg: 12,
+    full: 9999
+  },
+  components: {
+    card: {
+      background: "#F8FAFC",
+      borderColor: "#0A2540",
+      borderRadius: 8,
+      padding: 24
+    }
+  }
+};
+var terminalTheme = {
+  name: "terminal",
+  description: "Retro hacker green-on-dark theme with pure monospace aesthetic",
+  colors: {
+    primary: "#00FF66",
+    secondary: "#33FF88",
+    background: "#0C100C",
+    surface: "#141A14",
+    text: "#E0FFE0",
+    muted: "#4E7A4E",
+    accent: "#FFB000",
+    border: "#1F331F",
+    success: "#00FF66",
+    warning: "#FFB000",
+    danger: "#FF3333",
+    info: "#00E5FF"
+  },
+  typography: {
+    headingFont: "JetBrains Mono, Courier New, monospace",
+    bodyFont: "JetBrains Mono, Courier New, monospace",
+    codeFont: "JetBrains Mono, Courier New, monospace",
+    sizes: {
+      h1: 40,
+      h2: 32,
+      h3: 26,
+      h4: 20,
+      body: 17,
+      small: 13,
+      code: 15
+    }
+  },
+  spacing: {
+    unit: 8,
+    slidePadding: 48,
+    elementGap: 24
+  },
+  radius: {
+    default: 0,
+    sm: 0,
+    md: 0,
+    lg: 0,
+    full: 0
+  },
+  components: {
+    card: {
+      background: "#141A14",
+      borderColor: "#00FF66",
+      borderRadius: 0,
+      padding: 24
+    }
+  }
+};
+var academicTheme = {
+  name: "academic",
+  description: "Scholarly paper theme with serif typography and crimson accents",
+  colors: {
+    primary: "#8B0000",
+    secondary: "#1C3F60",
+    background: "#FCFBF7",
+    surface: "#F5F2EB",
+    text: "#2C2B29",
+    muted: "#6B6862",
+    accent: "#C29B38",
+    border: "#E0DACD",
+    success: "#2E7D32",
+    warning: "#E65100",
+    danger: "#C62828",
+    info: "#1565C0"
+  },
+  typography: {
+    headingFont: "Georgia, Times New Roman, serif",
+    bodyFont: "Georgia, Times New Roman, serif",
+    codeFont: "Courier New, monospace",
+    sizes: {
+      h1: 42,
+      h2: 34,
+      h3: 26,
+      h4: 20,
+      body: 18,
+      small: 14,
+      code: 15
+    }
+  },
+  spacing: {
+    unit: 8,
+    slidePadding: 52,
+    elementGap: 24
+  },
+  radius: {
+    default: 4,
+    sm: 2,
+    md: 4,
+    lg: 6,
+    full: 9999
+  },
+  components: {
+    card: {
+      background: "#F5F2EB",
+      borderColor: "#8B0000",
+      borderRadius: 4,
+      padding: 24
+    }
+  }
+};
+var THEME_REGISTRY = {
+  default: defaultTheme,
+  cyberpunk: cyberpunkTheme,
+  minimal: minimalTheme,
+  corporate: corporateTheme,
+  terminal: terminalTheme,
+  academic: academicTheme
+};
+function resolveTheme(themeNameOrRef, explicitOverrides) {
+  const name = typeof themeNameOrRef === "string" ? themeNameOrRef : themeNameOrRef?.name || "default";
+  const baseTheme = THEME_REGISTRY[name.toLowerCase()] || defaultTheme;
+  const refOverrides = typeof themeNameOrRef === "object" ? themeNameOrRef.overrides : void 0;
+  const mergedOverrides = {
+    ...refOverrides,
+    ...explicitOverrides,
+    colors: { ...baseTheme.colors, ...refOverrides?.colors, ...explicitOverrides?.colors },
+    typography: {
+      ...baseTheme.typography,
+      ...refOverrides?.typography,
+      ...explicitOverrides?.typography
+    },
+    components: {
+      ...baseTheme.components,
+      ...refOverrides?.components,
+      ...explicitOverrides?.components
+    }
+  };
   return {
-    ...defaultTheme,
-    ...overrides,
-    colors: { ...defaultTheme.colors, ...overrides.colors },
-    typography: { ...defaultTheme.typography, ...overrides.typography },
-    spacing: { ...defaultTheme.spacing, ...overrides.spacing },
-    radius: { ...defaultTheme.radius, ...overrides.radius },
-    shadows: { ...defaultTheme.shadows, ...overrides.shadows },
-    components: { ...defaultTheme.components, ...overrides.components }
+    ...baseTheme,
+    ...mergedOverrides
   };
 }
+function createTheme(overrides) {
+  return resolveTheme(overrides.name, overrides);
+}
+
+// ../core/dist/linter.js
+var YumiaLinter = class {
+  layoutEngine;
+  constructor(layoutEngine) {
+    this.layoutEngine = layoutEngine ?? new DefaultLayoutEngine();
+  }
+  lint(presentation, options = {}) {
+    const issues = [];
+    const layout = this.layoutEngine.computePresentation(presentation, options.viewport);
+    if (presentation.diagnostics) {
+      for (const diag of presentation.diagnostics) {
+        issues.push({
+          code: diag.code || "YUM002",
+          slide: 1,
+          message: diag.message,
+          severity: diag.severity === "error" ? "error" : "warning",
+          loc: diag.loc
+        });
+      }
+    }
+    presentation.slides.forEach((slide, index) => {
+      const slideNum = index + 1;
+      const slideLayout = layout.slides[index];
+      if (slide.elements.length === 0) {
+        issues.push({
+          code: "YUM006",
+          slide: slideNum,
+          message: "Slide contains no content elements.",
+          severity: "warning",
+          loc: slide.loc
+        });
+        return;
+      }
+      if (slideLayout && slideLayout.overflow) {
+        const overflowPx = Math.round(slideLayout.overflowAmount || 0);
+        issues.push({
+          code: "YUM001",
+          slide: slideNum,
+          message: `Content exceeds slide viewport bounds by ~${overflowPx}px. Consider reducing font size or splitting into multiple slides.`,
+          severity: options.strict ? "error" : "warning",
+          loc: slide.loc
+        });
+      }
+      const hasHeading = this.slideHasHeading(slide.elements);
+      if (!hasHeading) {
+        issues.push({
+          code: "YUM003",
+          slide: slideNum,
+          message: "Slide has no heading (h1-h4). Consider adding a descriptive title for structure.",
+          severity: "warning",
+          loc: slide.loc
+        });
+      }
+      const { listCount, wordCount } = this.calculateSlideDensity(slide.elements);
+      if (listCount > 7) {
+        issues.push({
+          code: "YUM004",
+          slide: slideNum,
+          message: `High information density: slide contains ${listCount} list items (recommended max: 7).`,
+          severity: "warning",
+          loc: slide.loc
+        });
+      } else if (wordCount > 120) {
+        issues.push({
+          code: "YUM004",
+          slide: slideNum,
+          message: `High information density: slide contains ~${wordCount} words (recommended max: 120 words).`,
+          severity: "warning",
+          loc: slide.loc
+        });
+      }
+      this.checkImages(slide.elements, slideNum, issues);
+      const maxDepth = this.getMaxNestingDepth(slide.elements, 0);
+      if (maxDepth > 2) {
+        issues.push({
+          code: "YUM008",
+          slide: slideNum,
+          message: `Excessive directive nesting depth (${maxDepth} levels). Maximum recommended depth is 2.`,
+          severity: "warning",
+          loc: slide.loc
+        });
+      }
+      if (options.includeOptionalNotesRule && (!slide.notes || slide.notes.trim() === "")) {
+        issues.push({
+          code: "YUM009",
+          slide: slideNum,
+          message: "Slide has no speaker notes (:::notes directive).",
+          severity: "info",
+          loc: slide.loc
+        });
+      }
+    });
+    const errors = issues.filter((i) => i.severity === "error");
+    const warnings = issues.filter((i) => i.severity === "warning");
+    const infos = issues.filter((i) => i.severity === "info");
+    return {
+      passed: options.strict ? errors.length === 0 && warnings.length === 0 : errors.length === 0,
+      totalSlides: presentation.slides.length,
+      issueCount: issues.length,
+      errors,
+      warnings,
+      infos
+    };
+  }
+  slideHasHeading(elements) {
+    for (const el of elements) {
+      if (el.type === "heading")
+        return true;
+      if (el.type === "card" && el.title)
+        return true;
+      if (el.type === "columns") {
+        const cols = el.columns;
+        for (const col of cols) {
+          if (this.slideHasHeading(col.elements))
+            return true;
+        }
+      }
+    }
+    return false;
+  }
+  calculateSlideDensity(elements) {
+    let listCount = 0;
+    let wordCount = 0;
+    const traverse = (els) => {
+      for (const el of els) {
+        if (el.type === "list") {
+          const list = el;
+          listCount += list.items.length;
+          for (const item of list.items) {
+            wordCount += item.text.split(/\s+/).filter(Boolean).length;
+          }
+        } else if (el.type === "paragraph") {
+          const p = el;
+          wordCount += p.text.split(/\s+/).filter(Boolean).length;
+        } else if (el.type === "card") {
+          const card = el;
+          if (card.title)
+            wordCount += card.title.split(/\s+/).filter(Boolean).length;
+          if (card.elements)
+            traverse(card.elements);
+        } else if (el.type === "columns") {
+          const cols = el;
+          for (const col of cols.columns) {
+            traverse(col.elements);
+          }
+        }
+      }
+    };
+    traverse(elements);
+    return { listCount, wordCount };
+  }
+  checkImages(elements, slideNum, issues) {
+    const traverse = (els) => {
+      for (const el of els) {
+        if (el.type === "image") {
+          const img = el;
+          if (!img.alt || img.alt.trim() === "") {
+            issues.push({
+              code: "YUM007",
+              slide: slideNum,
+              message: `Image '${img.src}' is missing descriptive alt text for accessibility.`,
+              severity: "warning",
+              loc: img.loc
+            });
+          }
+          if (!img.src || img.src.trim() === "") {
+            issues.push({
+              code: "YUM005",
+              slide: slideNum,
+              message: "Image element has empty src attribute.",
+              severity: "error",
+              loc: img.loc
+            });
+          }
+        } else if (el.type === "card" && el.elements) {
+          traverse(el.elements);
+        } else if (el.type === "columns") {
+          for (const col of el.columns) {
+            traverse(col.elements);
+          }
+        }
+      }
+    };
+    traverse(elements);
+  }
+  getMaxNestingDepth(elements, currentDepth) {
+    let max = currentDepth;
+    for (const el of elements) {
+      if (el.type === "card" && el.elements) {
+        const d = this.getMaxNestingDepth(el.elements, currentDepth + 1);
+        if (d > max)
+          max = d;
+      } else if (el.type === "columns") {
+        for (const col of el.columns) {
+          const d = this.getMaxNestingDepth(col.elements, currentDepth + 1);
+          if (d > max)
+            max = d;
+        }
+      }
+    }
+    return max;
+  }
+};
 
 // ../core/dist/compiler.js
 var YumiaCompiler = class {
   parser;
   layoutEngine;
   defaultTheme;
+  linter;
   viewport;
   constructor(config = {}) {
     this.parser = config.parser ?? new DefaultYumiaParser();
     this.layoutEngine = config.layoutEngine ?? new DefaultLayoutEngine();
     this.defaultTheme = config.defaultTheme ?? defaultTheme;
+    this.linter = new YumiaLinter(this.layoutEngine);
     if (config.viewport) {
       this.viewport = config.viewport;
     }
@@ -865,12 +1421,20 @@ var YumiaCompiler = class {
       warnings
     };
   }
+  lint(sourceOrPresentation, options) {
+    const presentation = typeof sourceOrPresentation === "string" ? this.parse(sourceOrPresentation) : sourceOrPresentation;
+    return this.linter.lint(presentation, {
+      ...this.viewport ? { viewport: this.viewport } : {},
+      ...options
+    });
+  }
   layout(presentation, viewport) {
     return this.layoutEngine.computePresentation(presentation, viewport ?? this.viewport);
   }
   async render(presentation, renderer, contextOverrides = {}) {
     const layout = contextOverrides.layout ?? this.layout(presentation);
-    const theme = contextOverrides.theme ?? this.defaultTheme;
+    const presentationTheme = presentation.metadata.theme ? resolveTheme(presentation.metadata.theme) : this.defaultTheme;
+    const theme = contextOverrides.theme ?? presentationTheme;
     const context = {
       theme,
       layout,
@@ -896,7 +1460,10 @@ var YumiaCompiler = class {
             subtitle: { type: "string" },
             author: { type: "string" },
             date: { type: "string" },
-            theme: { type: "string" },
+            theme: {
+              type: "string",
+              enum: ["default", "cyberpunk", "minimal", "corporate", "terminal", "academic"]
+            },
             aspectRatio: { enum: ["16:9", "4:3", "16:10"] }
           }
         },
@@ -908,9 +1475,13 @@ var YumiaCompiler = class {
               description: "Multi-column grid layout"
             },
             card: {
-              syntax: ":::card [Title]\\n...\\n:::",
+              syntax: ':::card [Title] [variant="primary|success|warning|danger|info"]\\n...\\n:::',
               description: "Visual container card with theme border and background"
             },
+            metric: {
+              syntax: ':::metric value="99.9%" label="Uptime" change="+0.4%" variant="success"',
+              description: "Stat callout box with prominent value, label, and trend"
+            },
             notes: {
               syntax: ":::notes\\nSpeaker notes text\\n:::",
               description: "Speaker notes attached to slide metadata"
@@ -944,6 +1515,37 @@ var CSS_NAMED_COLORS = {
   slate: "0f172a",
   transparent: "ffffff"
 };
+function parseInlineMarkdown(rawText, baseOptions) {
+  const chunks = [];
+  const regex = /(\*\*.*?\*\*|\*.*?\*|`.*?`)/g;
+  const parts = rawText.split(regex);
+  for (const part of parts) {
+    if (!part)
+      continue;
+    if (part.startsWith("**") && part.endsWith("**") && part.length >= 4) {
+      chunks.push({
+        text: part.slice(2, -2),
+        options: { ...baseOptions, bold: true }
+      });
+    } else if (part.startsWith("*") && part.endsWith("*") && part.length >= 2) {
+      chunks.push({
+        text: part.slice(1, -1),
+        options: { ...baseOptions, italic: true }
+      });
+    } else if (part.startsWith("`") && part.endsWith("`") && part.length >= 2) {
+      chunks.push({
+        text: part.slice(1, -1),
+        options: { ...baseOptions, fontFace: "Courier New" }
+      });
+    } else {
+      chunks.push({
+        text: part,
+        options: { ...baseOptions }
+      });
+    }
+  }
+  return chunks.length > 0 ? chunks : [{ text: rawText, options: baseOptions }];
+}
 var PptxRenderer = class {
   name = "PptxRenderer";
   targetFormat = "pptx";
@@ -954,7 +1556,8 @@ var PptxRenderer = class {
   async render(presentation, context = {}) {
     const PptxConstructor = pptxgen.default || pptxgen;
     const pptx = new PptxConstructor();
-    const theme = context.theme || defaultTheme;
+    const resolvedTheme = presentation.metadata.theme ? resolveTheme(presentation.metadata.theme) : defaultTheme;
+    const theme = context.theme || resolvedTheme;
     const title = presentation.metadata.title || "Yumia Presentation";
     const author = presentation.metadata.author || "YumiaMD";
     pptx.title = title;
@@ -1014,6 +1617,9 @@ var PptxRenderer = class {
       case "image":
         this.renderImage(pptxSlide, element, rect);
         break;
+      case "metric":
+        this.renderMetric(pptxSlide, pptx, node, scaleX, scaleY, theme);
+        break;
       case "card":
         this.renderCard(pptxSlide, pptx, node, scaleX, scaleY, theme);
         break;
@@ -1027,15 +1633,17 @@ var PptxRenderer = class {
   renderHeading(pptxSlide, heading, rect, theme) {
     const fontSize = this.getHeadingFontSize(heading.level, theme);
     const color = this.cleanHexColor(heading.level === 1 ? theme.colors.primary : theme.colors.text);
-    pptxSlide.addText(heading.text, {
+    const chunks = parseInlineMarkdown(heading.text, {
+      fontSize,
+      bold: true,
+      fontFace: theme.typography.headingFont.split(",")[0]?.trim() || "Arial",
+      color
+    });
+    pptxSlide.addText(chunks, {
       x: rect.x,
       y: rect.y,
       w: rect.w,
       h: rect.h,
-      fontSize,
-      bold: true,
-      fontFace: theme.typography.headingFont.split(",")[0]?.trim() || "Arial",
-      color,
       align: heading.align || "left",
       valign: "middle",
       margin: 0
@@ -1044,14 +1652,16 @@ var PptxRenderer = class {
   renderParagraph(pptxSlide, paragraph, rect, theme) {
     const fontSize = theme.typography.sizes?.body || 18;
     const color = this.cleanHexColor(theme.colors.text);
-    pptxSlide.addText(paragraph.text, {
+    const chunks = parseInlineMarkdown(paragraph.text, {
+      fontSize,
+      fontFace: theme.typography.bodyFont.split(",")[0]?.trim() || "Arial",
+      color
+    });
+    pptxSlide.addText(chunks, {
       x: rect.x,
       y: rect.y,
       w: rect.w,
       h: rect.h,
-      fontSize,
-      fontFace: theme.typography.bodyFont.split(",")[0]?.trim() || "Arial",
-      color,
       align: paragraph.align || "left",
       valign: "top",
       margin: 0
@@ -1060,18 +1670,24 @@ var PptxRenderer = class {
   renderList(pptxSlide, list, rect, theme) {
     const fontSize = theme.typography.sizes?.body || 18;
     const color = this.cleanHexColor(theme.colors.text);
-    const textItems = list.items.map((item) => ({
-      text: item.text,
-      options: {
-        bullet: list.ordered ? { type: "number" } : true,
+    const allChunks = [];
+    list.items.forEach((item) => {
+      const itemChunks = parseInlineMarkdown(item.text, {
         fontSize,
         color,
         fontFace: theme.typography.bodyFont.split(",")[0]?.trim() || "Arial",
         indentLevel: item.depth || 0,
         paraSpaceAfter: 8
+      });
+      if (itemChunks.length > 0) {
+        itemChunks[0].options = {
+          ...itemChunks[0].options,
+          bullet: list.ordered ? { type: "number" } : true
+        };
       }
-    }));
-    pptxSlide.addText(textItems, {
+      allChunks.push(...itemChunks);
+    });
+    pptxSlide.addText(allChunks, {
       x: rect.x,
       y: rect.y,
       w: rect.w,
@@ -1086,7 +1702,7 @@ var PptxRenderer = class {
     const borderColor = this.cleanHexColor(theme.colors.border || "#cbd5e1");
     if (table.headers && table.headers.length > 0) {
       tableRows.push(table.headers.map((h) => ({
-        text: h,
+        text: h.replace(/\*\*/g, ""),
         options: {
           bold: true,
           color: "ffffff",
@@ -1100,7 +1716,7 @@ var PptxRenderer = class {
       table.rows.forEach((row, rowIndex) => {
         const rowBg = rowIndex % 2 === 1 ? "f8fafc" : "ffffff";
         tableRows.push(row.map((cell) => ({
-          text: cell,
+          text: cell.replace(/\*\*/g, ""),
           options: {
             color: this.cleanHexColor(theme.colors.text),
             fill: { color: rowBg },
@@ -1149,12 +1765,79 @@ var PptxRenderer = class {
       });
     }
   }
+  renderMetric(pptxSlide, pptx, node, scaleX, scaleY, theme) {
+    const metric = node.element;
+    const rect = this.toInches(node.bounds, scaleX, scaleY);
+    const cardTheme = theme.components?.card;
+    let accentColor = theme.colors.primary;
+    if (metric.variant && theme.colors[metric.variant]) {
+      accentColor = theme.colors[metric.variant];
+    }
+    const fillColor = this.cleanHexColor(cardTheme?.background || theme.colors.surface);
+    const borderColor = this.cleanHexColor(metric.variant && theme.colors[metric.variant] ? theme.colors[metric.variant] : cardTheme?.borderColor || theme.colors.border || "#cbd5e1");
+    pptxSlide.addShape(pptx.ShapeType.roundRect, {
+      x: rect.x,
+      y: rect.y,
+      w: rect.w,
+      h: rect.h,
+      fill: { color: fillColor },
+      line: { color: borderColor, width: 1.5 },
+      rectRadius: 0.08
+    });
+    pptxSlide.addText(metric.label.toUpperCase(), {
+      x: rect.x + 0.15,
+      y: rect.y + 0.15,
+      w: rect.w - 0.3,
+      h: 0.25,
+      fontSize: 11,
+      bold: true,
+      color: this.cleanHexColor(theme.colors.muted || "#64748b"),
+      fontFace: theme.typography.headingFont.split(",")[0]?.trim() || "Arial",
+      align: "center",
+      valign: "middle"
+    });
+    const displayValue = metric.unit ? `${metric.value} ${metric.unit}` : metric.value;
+    pptxSlide.addText(displayValue, {
+      x: rect.x + 0.1,
+      y: rect.y + 0.4,
+      w: rect.w - 0.2,
+      h: 0.55,
+      fontSize: 30,
+      bold: true,
+      color: this.cleanHexColor(accentColor),
+      fontFace: theme.typography.headingFont.split(",")[0]?.trim() || "Arial",
+      align: "center",
+      valign: "middle"
+    });
+    if (metric.change) {
+      const isPositive = metric.change.startsWith("+");
+      const changeColor = isPositive ? this.cleanHexColor(theme.colors.success || "#10b981") : this.cleanHexColor(theme.colors.danger || "#ef4444");
+      pptxSlide.addText(metric.change, {
+        x: rect.x + 0.1,
+        y: rect.y + rect.h - 0.32,
+        w: rect.w - 0.2,
+        h: 0.22,
+        fontSize: 12,
+        bold: true,
+        color: changeColor,
+        fontFace: theme.typography.bodyFont.split(",")[0]?.trim() || "Arial",
+        align: "center",
+        valign: "middle"
+      });
+    }
+  }
   renderCard(pptxSlide, pptx, node, scaleX, scaleY, theme) {
     const card = node.element;
     const rect = this.toInches(node.bounds, scaleX, scaleY);
     const cardTheme = theme.components?.card;
     const fillColor = this.cleanHexColor(cardTheme?.background || theme.colors.surface);
-    const borderColor = this.cleanHexColor(cardTheme?.borderColor || theme.colors.border || "#cbd5e1");
+    let borderColor = this.cleanHexColor(cardTheme?.borderColor || theme.colors.border || "#cbd5e1");
+    let titleColor = this.cleanHexColor(theme.colors.primary);
+    if (card.variant && theme.colors[card.variant]) {
+      const variantHex = this.cleanHexColor(theme.colors[card.variant]);
+      borderColor = variantHex;
+      titleColor = variantHex;
+    }
     pptxSlide.addShape(pptx.ShapeType.roundRect, {
       x: rect.x,
       y: rect.y,
@@ -1162,17 +1845,17 @@ var PptxRenderer = class {
       h: rect.h,
       fill: { color: fillColor },
       line: { color: borderColor, width: 1.5 },
-      rectRadius: 0.1
+      rectRadius: 0.08
     });
     if (card.title) {
       pptxSlide.addText(card.title, {
-        x: rect.x + 28 * scaleX,
-        y: rect.y + 20 * scaleY,
-        w: rect.w - 56 * scaleX,
-        h: 40 * scaleY,
-        fontSize: 22,
+        x: rect.x + 0.25,
+        y: rect.y + 0.18,
+        w: rect.w - 0.5,
+        h: 0.35,
+        fontSize: 20,
         bold: true,
-        color: this.cleanHexColor(theme.colors.primary),
+        color: titleColor,
         fontFace: theme.typography.headingFont.split(",")[0]?.trim() || "Arial"
       });
     }
@@ -1225,12 +1908,13 @@ var PptxRenderer = class {
       h: rect.h,
       fill: { color: accentColor }
     });
-    pptxSlide.addText(`"${quote.text}"`, {
+    const cleanText = quote.text.replace(/^["'“”«»]+|["'“”«»]+$/g, "").trim();
+    pptxSlide.addText(`\u201C${cleanText}\u201D`, {
       x: rect.x + 0.2,
       y: rect.y,
       w: rect.w - 0.2,
       h: rect.h,
-      fontSize: 20,
+      fontSize: 18,
       italic: true,
       color: this.cleanHexColor(theme.colors.muted || theme.colors.text),
       fontFace: theme.typography.bodyFont.split(",")[0]?.trim() || "Arial",
@@ -1282,7 +1966,7 @@ var PptxRenderer = class {
 // src/cli.ts
 import { mkdirSync, readFileSync, writeFileSync } from "fs";
 import { basename, dirname, extname, join, resolve } from "path";
-var VERSION = "0.1.6";
+var VERSION = "0.1.8";
 function printHelp() {
   return `
 YumiaMD \u2014 Markdown-based presentation compiler (v${VERSION})
@@ -1301,6 +1985,7 @@ Commands:
 Options:
   --out, -o <file>   Specify output file path (default: dist/<name>.pptx)
   --format, -f <fmt> Target output format: pptx (default)
+  --strict           Enforce zero warnings in 'lint' (exits with code 1 on warning)
   --json             Output results formatted as JSON for CI/CD and AI tools
   --layout           Show computed geometric bounding boxes in 'inspect'
   -h, --help         Show this help message
@@ -1316,6 +2001,7 @@ async function runCli(argv) {
     return { exitCode: 0, output: `yumia v${VERSION}` };
   }
   const isJson = args.includes("--json");
+  const isStrict = args.includes("--strict");
   const nonFlagArgs = args.filter((a) => !a.startsWith("-"));
   const command = nonFlagArgs[0];
   const target = nonFlagArgs[1];
@@ -1452,57 +2138,46 @@ ${errorLines.join("\n")}`
     }
     try {
       const source = readFileSync(target, "utf-8");
-      const presentation = parseYumia(source);
-      const engine = new DefaultLayoutEngine();
-      const layout = engine.computePresentation(presentation);
-      const issues = [];
-      layout.slides.forEach((slideResult, index) => {
-        const slideNum = index + 1;
-        if (slideResult.overflow) {
-          issues.push({
-            slide: slideNum,
-            type: "overflow",
-            message: `Content exceeds slide height by ~${Math.round(slideResult.overflowAmount || 0)}px`
-          });
-        }
-        const slide = presentation.slides[index];
-        if (slide.elements.length === 0) {
-          issues.push({
-            slide: slideNum,
-            type: "empty",
-            message: "Slide has no content elements."
-          });
-        }
-      });
+      const compiler = new YumiaCompiler();
+      const report = compiler.lint(source, { strict: isStrict });
       if (isJson) {
         return {
-          exitCode: 0,
+          exitCode: report.passed ? 0 : 1,
           output: JSON.stringify(
             {
               target,
-              passed: issues.length === 0,
-              slideCount: presentation.slides.length,
-              issues
+              ...report
             },
             null,
             2
           )
         };
       }
-      if (issues.length === 0) {
+      if (report.issueCount === 0) {
         return {
           exitCode: 0,
-          output: `\u2713 Yumia Lint: All ${presentation.slides.length} slide(s) passed with 0 issues.`
+          output: `\u2713 Yumia Lint: All ${report.totalSlides} slide(s) passed with 0 issues.`
         };
       } else {
-        const formatted = issues.map((i) => `\u26A0 Slide ${i.slide}: ${i.message}`).join("\n");
+        const issueLines = [];
+        for (const e of report.errors) {
+          issueLines.push(`  \u2717 [${e.code}] Slide ${e.slide}: ${e.message}`);
+        }
+        for (const w of report.warnings) {
+          issueLines.push(`  \u26A0 [${w.code}] Slide ${w.slide}: ${w.message}`);
+        }
+        for (const info of report.infos) {
+          issueLines.push(`  \u2139 [${info.code}] Slide ${info.slide}: ${info.message}`);
+        }
+        const summary = `Found ${report.errors.length} error(s), ${report.warnings.length} warning(s).`;
+        const exitCode = report.passed ? 0 : 1;
         return {
-          exitCode: 0,
+          exitCode,
           output: `Yumia Lint Report for '${target}':
 
-${formatted}
+${issueLines.join("\n")}
 
-Found ${issues.length} warning(s).`
+${summary}${isStrict && report.warnings.length > 0 ? " (failed due to --strict)" : ""}`
         };
       }
     } catch (err) {
@@ -1614,6 +2289,7 @@ export {
   createList,
   createImage,
   createCard,
+  createMetric,
   createCode,
   createQuote,
   createTable,
@@ -1627,8 +2303,17 @@ export {
   VIEWPORT_PRESETS,
   DefaultLayoutEngine,
   defaultTheme,
+  cyberpunkTheme,
+  minimalTheme,
+  corporateTheme,
+  terminalTheme,
+  academicTheme,
+  THEME_REGISTRY,
+  resolveTheme,
   createTheme,
+  YumiaLinter,
   YumiaCompiler,
+  parseInlineMarkdown,
   PptxRenderer,
   VERSION,
   printHelp,

package/dist/index.d.ts

@@ -6,7 +6,7 @@ export * from '@yumiamd/layout';
 export * from '@yumiamd/renderer';
 export * from '@yumiamd/renderer-pptx';
 
-declare const VERSION = "0.1.6";
+declare const VERSION = "0.1.8";
 declare function printHelp(): string;
 declare function runCli(argv: string[]): Promise<{
     exitCode: number;

package/dist/index.js

@@ -3,9 +3,13 @@ import {
   DefaultLayoutEngine,
   DefaultYumiaParser,
   PptxRenderer,
+  THEME_REGISTRY,
   VERSION,
   VIEWPORT_PRESETS,
   YumiaCompiler,
+  YumiaLinter,
+  academicTheme,
+  corporateTheme,
   createCard,
   createCode,
   createColumn,
@@ -15,25 +19,35 @@ import {
   createImage,
   createLayoutDirective,
   createList,
+  createMetric,
   createParagraph,
   createPresentation,
   createQuote,
   createSlide,
   createTable,
   createTheme,
+  cyberpunkTheme,
   defaultTheme,
+  minimalTheme,
+  parseInlineMarkdown,
   parseYumia,
   printHelp,
-  runCli
-} from "./chunk-FHM6V4JH.js";
+  resolveTheme,
+  runCli,
+  terminalTheme
+} from "./chunk-WUJKHJJU.js";
 export {
   DEFAULT_VIEWPORT,
   DefaultLayoutEngine,
   DefaultYumiaParser,
   PptxRenderer,
+  THEME_REGISTRY,
   VERSION,
   VIEWPORT_PRESETS,
   YumiaCompiler,
+  YumiaLinter,
+  academicTheme,
+  corporateTheme,
   createCard,
   createCode,
   createColumn,
@@ -43,14 +57,20 @@ export {
   createImage,
   createLayoutDirective,
   createList,
+  createMetric,
   createParagraph,
   createPresentation,
   createQuote,
   createSlide,
   createTable,
   createTheme,
+  cyberpunkTheme,
   defaultTheme,
+  minimalTheme,
+  parseInlineMarkdown,
   parseYumia,
   printHelp,
-  runCli
+  resolveTheme,
+  runCli,
+  terminalTheme
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yumiamd",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Command line interface and compiler for YumiaMD presentations",
   "type": "module",
   "main": "./dist/index.js",
@@ -20,13 +20,13 @@
   },
   "devDependencies": {
     "tsup": "^8.5.1",
-    "@yumiamd/ast": "0.1.6",
-    "@yumiamd/parser": "0.1.6",
-    "@yumiamd/core": "0.1.6",
-    "@yumiamd/layout": "0.1.6",
-    "@yumiamd/renderer": "0.1.6",
-    "@yumiamd/renderer-pptx": "0.1.6",
-    "@yumiamd/theme": "0.1.6"
+    "@yumiamd/ast": "0.1.8",
+    "@yumiamd/parser": "0.1.8",
+    "@yumiamd/core": "0.1.8",
+    "@yumiamd/renderer": "0.1.8",
+    "@yumiamd/layout": "0.1.8",
+    "@yumiamd/renderer-pptx": "0.1.8",
+    "@yumiamd/theme": "0.1.8"
   },
   "keywords": [
     "yumia",