yumiamd 0.1.7 → 0.1.9

package/dist/bin.js

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

package/dist/{chunk-GMIVPFBA.js → chunk-F3CX7UG6.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) {
@@ -201,6 +213,28 @@ var DefaultYumiaParser = class {
       result.theme = metadata["theme"];
     if (typeof metadata["aspectRatio"] === "string")
       result.aspectRatio = metadata["aspectRatio"];
+    const colors = {};
+    if (typeof metadata["background"] === "string")
+      colors.background = metadata["background"];
+    if (typeof metadata["bg"] === "string")
+      colors.background = metadata["bg"];
+    if (typeof metadata["primary"] === "string")
+      colors.primary = metadata["primary"];
+    if (typeof metadata["secondary"] === "string")
+      colors.secondary = metadata["secondary"];
+    if (typeof metadata["surface"] === "string")
+      colors.surface = metadata["surface"];
+    if (typeof metadata["text"] === "string")
+      colors.text = metadata["text"];
+    if (typeof metadata["muted"] === "string")
+      colors.muted = metadata["muted"];
+    if (typeof metadata["accent"] === "string")
+      colors.accent = metadata["accent"];
+    if (typeof metadata["border"] === "string")
+      colors.border = metadata["border"];
+    if (Object.keys(colors).length > 0) {
+      result.colors = colors;
+    }
     return result;
   }
   splitSlides(content, startLineOffset) {
@@ -346,6 +380,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 +410,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 +439,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 +595,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--;
@@ -645,6 +711,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);
       }
@@ -749,9 +819,10 @@ var DefaultLayoutEngine = class {
     return lines * 34 + 32;
   }
   estimateTableHeight(table) {
-    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);
+    const headerHeight = table.headers && table.headers.length > 0 ? 50 : 0;
+    const rowsCount = table.rows ? table.rows.length : 0;
+    const rowsHeight = rowsCount * 46;
+    return Math.max(80, headerHeight + rowsHeight + 20);
   }
   estimateImageHeight(image) {
     if (typeof image.height === "number") {
@@ -759,6 +830,9 @@ var DefaultLayoutEngine = class {
     }
     return 320;
   }
+  estimateMetricHeight(metric) {
+    return metric.change ? 160 : 130;
+  }
 };
 
 // ../theme/dist/default-theme.js
@@ -773,7 +847,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",
@@ -830,29 +908,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;
     }
@@ -872,12 +1444,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,
@@ -903,7 +1483,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"] }
           }
         },
@@ -915,9 +1498,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"
@@ -951,6 +1538,15 @@ var CSS_NAMED_COLORS = {
   slate: "0f172a",
   transparent: "ffffff"
 };
+function cleanFontFace(fontString) {
+  if (!fontString)
+    return "Segoe UI";
+  const first = fontString.split(",")[0]?.trim().replace(/^['"]|['"]$/g, "") || "";
+  if (!first || first === "system-ui" || first === "-apple-system" || first === "sans-serif" || first === "monospace" || first === "serif") {
+    return "Segoe UI";
+  }
+  return first;
+}
 function parseInlineMarkdown(rawText, baseOptions) {
   const chunks = [];
   const regex = /(\*\*.*?\*\*|\*.*?\*|`.*?`)/g;
@@ -992,7 +1588,9 @@ var PptxRenderer = class {
   async render(presentation, context = {}) {
     const PptxConstructor = pptxgen.default || pptxgen;
     const pptx = new PptxConstructor();
-    const theme = context.theme || defaultTheme;
+    const colorOverrides = presentation.metadata.colors ? { colors: presentation.metadata.colors } : void 0;
+    const resolvedTheme = resolveTheme(presentation.metadata.theme, colorOverrides);
+    const theme = context.theme || resolvedTheme;
     const title = presentation.metadata.title || "Yumia Presentation";
     const author = presentation.metadata.author || "YumiaMD";
     pptx.title = title;
@@ -1052,6 +1650,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;
@@ -1068,7 +1669,7 @@ var PptxRenderer = class {
     const chunks = parseInlineMarkdown(heading.text, {
       fontSize,
       bold: true,
-      fontFace: theme.typography.headingFont.split(",")[0]?.trim() || "Arial",
+      fontFace: cleanFontFace(theme.typography.headingFont),
       color
     });
     pptxSlide.addText(chunks, {
@@ -1086,7 +1687,7 @@ var PptxRenderer = class {
     const color = this.cleanHexColor(theme.colors.text);
     const chunks = parseInlineMarkdown(paragraph.text, {
       fontSize,
-      fontFace: theme.typography.bodyFont.split(",")[0]?.trim() || "Arial",
+      fontFace: cleanFontFace(theme.typography.bodyFont),
       color
     });
     pptxSlide.addText(chunks, {
@@ -1103,11 +1704,11 @@ var PptxRenderer = class {
     const fontSize = theme.typography.sizes?.body || 18;
     const color = this.cleanHexColor(theme.colors.text);
     const allChunks = [];
-    list.items.forEach((item) => {
+    list.items.forEach((item, itemIdx) => {
       const itemChunks = parseInlineMarkdown(item.text, {
         fontSize,
         color,
-        fontFace: theme.typography.bodyFont.split(",")[0]?.trim() || "Arial",
+        fontFace: cleanFontFace(theme.typography.bodyFont),
         indentLevel: item.depth || 0,
         paraSpaceAfter: 8
       });
@@ -1116,6 +1717,12 @@ var PptxRenderer = class {
           ...itemChunks[0].options,
           bullet: list.ordered ? { type: "number" } : true
         };
+        if (itemIdx < list.items.length - 1) {
+          itemChunks[itemChunks.length - 1].options = {
+            ...itemChunks[itemChunks.length - 1].options,
+            breakLine: true
+          };
+        }
       }
       allChunks.push(...itemChunks);
     });
@@ -1132,6 +1739,10 @@ var PptxRenderer = class {
     const tableRows = [];
     const headerBg = this.cleanHexColor(theme.colors.primary);
     const borderColor = this.cleanHexColor(theme.colors.border || "#cbd5e1");
+    const isDark = this.isDarkColor(theme.colors.background);
+    const rowBg1 = this.cleanHexColor(theme.components?.table?.rowAlternateBackground || (isDark ? theme.colors.surface : "ffffff"));
+    const rowBg2 = this.cleanHexColor(isDark ? "#1a1a2e" : "f8fafc");
+    const cellTextColor = this.cleanHexColor(theme.colors.text);
     if (table.headers && table.headers.length > 0) {
       tableRows.push(table.headers.map((h) => ({
         text: h.replace(/\*\*/g, ""),
@@ -1140,19 +1751,21 @@ var PptxRenderer = class {
           color: "ffffff",
           fill: { color: headerBg },
           fontSize: 14,
+          fontFace: cleanFontFace(theme.typography.headingFont),
           align: "center"
         }
       })));
     }
     if (table.rows) {
       table.rows.forEach((row, rowIndex) => {
-        const rowBg = rowIndex % 2 === 1 ? "f8fafc" : "ffffff";
+        const rowBg = rowIndex % 2 === 1 ? rowBg2 : rowBg1;
         tableRows.push(row.map((cell) => ({
           text: cell.replace(/\*\*/g, ""),
           options: {
-            color: this.cleanHexColor(theme.colors.text),
+            color: cellTextColor,
             fill: { color: rowBg },
-            fontSize: 13
+            fontSize: 13,
+            fontFace: cleanFontFace(theme.typography.bodyFont)
           }
         })));
       });
@@ -1163,7 +1776,7 @@ var PptxRenderer = class {
         y: rect.y,
         w: rect.w,
         border: { type: "solid", pt: 1, color: borderColor },
-        margin: [4, 8, 4, 8]
+        margin: [6, 10, 6, 10]
       });
     }
   }
@@ -1197,12 +1810,80 @@ 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
+    });
+    const hasChange = Boolean(metric.change);
+    pptxSlide.addText(metric.label.toUpperCase(), {
+      x: rect.x + 0.1,
+      y: rect.y + 0.1,
+      w: rect.w - 0.2,
+      h: 0.22,
+      fontSize: 10,
+      bold: true,
+      color: this.cleanHexColor(theme.colors.muted || "#64748b"),
+      fontFace: cleanFontFace(theme.typography.headingFont),
+      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.34,
+      w: rect.w - 0.2,
+      h: 0.44,
+      fontSize: 26,
+      bold: true,
+      color: this.cleanHexColor(accentColor),
+      fontFace: cleanFontFace(theme.typography.headingFont),
+      align: "center",
+      valign: "middle"
+    });
+    if (hasChange && 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 + 0.8,
+        w: rect.w - 0.2,
+        h: 0.22,
+        fontSize: 11,
+        bold: true,
+        color: changeColor,
+        fontFace: cleanFontFace(theme.typography.bodyFont),
+        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,
@@ -1220,8 +1901,8 @@ var PptxRenderer = class {
         h: 0.35,
         fontSize: 20,
         bold: true,
-        color: this.cleanHexColor(theme.colors.primary),
-        fontFace: theme.typography.headingFont.split(",")[0]?.trim() || "Arial"
+        color: titleColor,
+        fontFace: cleanFontFace(theme.typography.headingFont)
       });
     }
     if (node.children) {
@@ -1282,7 +1963,7 @@ var PptxRenderer = class {
       fontSize: 18,
       italic: true,
       color: this.cleanHexColor(theme.colors.muted || theme.colors.text),
-      fontFace: theme.typography.bodyFont.split(",")[0]?.trim() || "Arial",
+      fontFace: cleanFontFace(theme.typography.bodyFont),
       valign: "middle"
     });
   }
@@ -1309,6 +1990,14 @@ var PptxRenderer = class {
         return 18;
     }
   }
+  isDarkColor(rawHex) {
+    const hex = this.cleanHexColor(rawHex);
+    const r = parseInt(hex.substring(0, 2), 16) || 0;
+    const g = parseInt(hex.substring(2, 4), 16) || 0;
+    const b = parseInt(hex.substring(4, 6), 16) || 0;
+    const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+    return luminance < 0.5;
+  }
   cleanHexColor(raw) {
     if (!raw)
       return "000000";
@@ -1331,7 +2020,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.7";
+var VERSION = "0.1.9";
 function printHelp() {
   return `
 YumiaMD \u2014 Markdown-based presentation compiler (v${VERSION})
@@ -1347,15 +2036,39 @@ Commands:
   schema             Output machine-readable JSON schema for AI agents
   build <file>       Compile a presentation to editable PowerPoint (.pptx)
 
-Options:
+Theming & Color Options:
+  --theme, -t <name> Base theme: default | cyberpunk | minimal | corporate | terminal | academic
+  --bg, --background Hex background color (e.g. "#0B0B12" or "#FFFFFF")
+  --primary, -p      Hex primary accent color (e.g. "#FF2E88" or "#2563EB")
+  --secondary        Hex secondary color (e.g. "#00F0FF")
+  --text             Hex text color (e.g. "#FFFFFF" or "#0F172A")
+  --accent           Hex accent bar & highlight color
+
+Compiler & Output 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
   -v, --version      Show CLI version
 `.trim();
 }
+function getFlagValue(args, flagNames) {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg) continue;
+    for (const flag of flagNames) {
+      if (arg === flag && args[i + 1] && !args[i + 1].startsWith("-")) {
+        return args[i + 1];
+      }
+      if (arg.startsWith(`${flag}=`)) {
+        return arg.slice(flag.length + 1);
+      }
+    }
+  }
+  return void 0;
+}
 async function runCli(argv) {
   const args = argv.slice(2);
   if (args.length === 0 || args.includes("-h") || args.includes("--help")) {
@@ -1365,9 +2078,16 @@ 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];
+  const cliTheme = getFlagValue(args, ["--theme", "-t"]);
+  const cliBg = getFlagValue(args, ["--bg", "--background"]);
+  const cliPrimary = getFlagValue(args, ["--primary", "-p"]);
+  const cliSecondary = getFlagValue(args, ["--secondary"]);
+  const cliText = getFlagValue(args, ["--text"]);
+  const cliAccent = getFlagValue(args, ["--accent"]);
   if (command === "schema") {
     const compiler = new YumiaCompiler();
     return {
@@ -1382,10 +2102,19 @@ async function runCli(argv) {
       mkdirSync(projectDir, { recursive: true });
       mkdirSync(join(projectDir, "assets"), { recursive: true });
       mkdirSync(join(projectDir, "themes"), { recursive: true });
+      const chosenTheme = cliTheme || "default";
+      const colorLines = [];
+      if (cliBg) colorLines.push(`background: "${cliBg}"`);
+      if (cliPrimary) colorLines.push(`primary: "${cliPrimary}"`);
+      if (cliSecondary) colorLines.push(`secondary: "${cliSecondary}"`);
+      if (cliText) colorLines.push(`text: "${cliText}"`);
+      if (cliAccent) colorLines.push(`accent: "${cliAccent}"`);
+      const colorsYaml = colorLines.length > 0 ? `
+${colorLines.join("\n")}` : "";
       const sampleContent = `---
 title: ${projectName}
-theme: default
-aspectRatio: "16:9"
+theme: ${chosenTheme}
+aspectRatio: "16:9"${colorsYaml}
 ---
 
 # ${projectName}
@@ -1402,7 +2131,7 @@ Opening slide introducing the presentation deck.
 :::columns ratios="50:50"
 
 :::column
-:::card Core Pipeline
+:::card Core Pipeline variant="primary"
 - Semantic AST model
 - Markdown + Directive parser
 - 100% Deterministic layout
@@ -1410,7 +2139,7 @@ Opening slide introducing the presentation deck.
 :::
 
 :::column
-:::card Native Output
+:::card Native Output variant="warning"
 - Fully editable PowerPoint objects
 - Vector PDF documents
 - Interactive HTML decks
@@ -1428,7 +2157,8 @@ Opening slide introducing the presentation deck.
               success: true,
               project: projectName,
               path: projectDir,
-              entry: join(projectDir, "presentation.yumia.md")
+              entry: join(projectDir, "presentation.yumia.md"),
+              theme: chosenTheme
             },
             null,
             2
@@ -1438,6 +2168,7 @@ Opening slide introducing the presentation deck.
       return {
         exitCode: 0,
         output: `\u2713 Created presentation project '${projectName}' at ./${projectName}
+  Theme: ${chosenTheme}${colorsYaml ? ` (with custom colors)` : ""}
   Edit ./${projectName}/presentation.yumia.md to get started!
   Then compile with: yumia build ./${projectName}/presentation.yumia.md`
       };
@@ -1501,57 +2232,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) {
@@ -1615,7 +2335,18 @@ Found ${issues.length} warning(s).`
       mkdirSync(dirname(outputPath), { recursive: true });
       const compiler = new YumiaCompiler();
       const renderer = new PptxRenderer();
-      const result = await compiler.compile(source, renderer);
+      const cliColorOverrides = {};
+      if (cliBg) cliColorOverrides.background = cliBg;
+      if (cliPrimary) cliColorOverrides.primary = cliPrimary;
+      if (cliSecondary) cliColorOverrides.secondary = cliSecondary;
+      if (cliText) cliColorOverrides.text = cliText;
+      if (cliAccent) cliColorOverrides.accent = cliAccent;
+      const renderTheme = cliTheme || Object.keys(cliColorOverrides).length > 0 ? resolveTheme(cliTheme || "default", {
+        ...Object.keys(cliColorOverrides).length > 0 ? { colors: cliColorOverrides } : {}
+      }) : void 0;
+      const result = await compiler.compile(source, renderer, {
+        ...renderTheme ? { renderContext: { theme: renderTheme } } : {}
+      });
       const buffer = result.data instanceof Uint8Array ? Buffer.from(result.data) : Buffer.from(new Uint8Array(result.data));
       writeFileSync(outputPath, buffer);
       if (isJson) {
@@ -1663,6 +2394,7 @@ export {
   createList,
   createImage,
   createCard,
+  createMetric,
   createCode,
   createQuote,
   createTable,
@@ -1676,8 +2408,17 @@ export {
   VIEWPORT_PRESETS,
   DefaultLayoutEngine,
   defaultTheme,
+  cyberpunkTheme,
+  minimalTheme,
+  corporateTheme,
+  terminalTheme,
+  academicTheme,
+  THEME_REGISTRY,
+  resolveTheme,
   createTheme,
+  YumiaLinter,
   YumiaCompiler,
+  cleanFontFace,
   parseInlineMarkdown,
   PptxRenderer,
   VERSION,

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.7";
+declare const VERSION = "0.1.9";
 declare function printHelp(): string;
 declare function runCli(argv: string[]): Promise<{
     exitCode: number;

package/dist/index.js

@@ -3,9 +3,14 @@ import {
   DefaultLayoutEngine,
   DefaultYumiaParser,
   PptxRenderer,
+  THEME_REGISTRY,
   VERSION,
   VIEWPORT_PRESETS,
   YumiaCompiler,
+  YumiaLinter,
+  academicTheme,
+  cleanFontFace,
+  corporateTheme,
   createCard,
   createCode,
   createColumn,
@@ -15,26 +20,36 @@ import {
   createImage,
   createLayoutDirective,
   createList,
+  createMetric,
   createParagraph,
   createPresentation,
   createQuote,
   createSlide,
   createTable,
   createTheme,
+  cyberpunkTheme,
   defaultTheme,
+  minimalTheme,
   parseInlineMarkdown,
   parseYumia,
   printHelp,
-  runCli
-} from "./chunk-GMIVPFBA.js";
+  resolveTheme,
+  runCli,
+  terminalTheme
+} from "./chunk-F3CX7UG6.js";
 export {
   DEFAULT_VIEWPORT,
   DefaultLayoutEngine,
   DefaultYumiaParser,
   PptxRenderer,
+  THEME_REGISTRY,
   VERSION,
   VIEWPORT_PRESETS,
   YumiaCompiler,
+  YumiaLinter,
+  academicTheme,
+  cleanFontFace,
+  corporateTheme,
   createCard,
   createCode,
   createColumn,
@@ -44,15 +59,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.7",
+  "version": "0.1.9",
   "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.7",
-    "@yumiamd/parser": "0.1.7",
-    "@yumiamd/renderer": "0.1.7",
-    "@yumiamd/core": "0.1.7",
-    "@yumiamd/renderer-pptx": "0.1.7",
-    "@yumiamd/layout": "0.1.7",
-    "@yumiamd/theme": "0.1.7"
+    "@yumiamd/core": "0.1.9",
+    "@yumiamd/ast": "0.1.9",
+    "@yumiamd/parser": "0.1.9",
+    "@yumiamd/renderer": "0.1.9",
+    "@yumiamd/layout": "0.1.9",
+    "@yumiamd/renderer-pptx": "0.1.9",
+    "@yumiamd/theme": "0.1.9"
   },
   "keywords": [
     "yumia",