markdownfly 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { resolve as resolve3 } from "path";
 
 // src/parser/index.ts
@@ -11,9 +11,13 @@ import remarkGfm from "remark-gfm";
 // src/parser/frontmatter.ts
 import { parse as parseYaml } from "yaml";
 
+// src/models/theme-preset.ts
+var DEFAULT_THEME_NAME = "blue";
+var DEFAULT_PRESET_NAME = DEFAULT_THEME_NAME;
+
 // src/config/defaults.ts
 var DEFAULT_CONFIG = {
-  theme: "clean"
+  theme: DEFAULT_THEME_NAME
 };
 
 // src/utils/progress.ts
@@ -34,7 +38,7 @@ function extractFrontmatter(tree) {
   }
   try {
     const parsed = parseYaml(yamlNode.value);
-    const { resource_dir, ...parsedOnly } = parsed;
+    const { resource_dir, color_scheme, text_scheme, layout_scheme, ...parsedOnly } = parsed;
     const merged = {
       ...DEFAULT_CONFIG,
       ...parsedOnly
@@ -42,6 +46,15 @@ function extractFrontmatter(tree) {
     if (resource_dir && !merged.resourceDir) {
       merged.resourceDir = resource_dir;
     }
+    if (color_scheme && !merged.colorScheme) {
+      merged.colorScheme = color_scheme;
+    }
+    if (text_scheme && !merged.textScheme) {
+      merged.textScheme = text_scheme;
+    }
+    if (layout_scheme && !merged.layoutScheme) {
+      merged.layoutScheme = layout_scheme;
+    }
     return merged;
   } catch {
     log.warn("Failed to parse frontmatter YAML, using defaults");
@@ -49,8 +62,22 @@ function extractFrontmatter(tree) {
   }
 }
 
+// src/diagrams/languages.ts
+var ALIASES = {
+  graphviz: "dot",
+  puml: "plantuml"
+};
+var CANONICAL = /* @__PURE__ */ new Set(["mermaid", "dot", "echarts", "plantuml"]);
+function normalizeDiagramLanguage(language) {
+  const lang = language.toLowerCase();
+  const canonical = ALIASES[lang] ?? lang;
+  return CANONICAL.has(canonical) ? canonical : void 0;
+}
+function isDiagramLanguage(language) {
+  return normalizeDiagramLanguage(language) !== void 0;
+}
+
 // src/parser/splitter.ts
-var DIAGRAM_LANGUAGES = /* @__PURE__ */ new Set(["mermaid", "dot", "graphviz", "echarts"]);
 var CALLOUT_VARIANTS = /* @__PURE__ */ new Set([
   "note",
   "info",
@@ -234,10 +261,11 @@ function nodeToElement(node) {
     }
     case "code": {
       const lang = node.lang?.toLowerCase() ?? "";
-      if (DIAGRAM_LANGUAGES.has(lang)) {
+      const diagramType = normalizeDiagramLanguage(lang);
+      if (diagramType) {
         return {
           type: "diagram",
-          diagramType: lang === "graphviz" ? "dot" : lang,
+          diagramType,
           content: node.value
         };
       }
@@ -304,6 +332,19 @@ function detectLayout(title, elements, isFirstSlide, headingLevel) {
   if (nonEmptyElements.length > 0 && nonEmptyElements.every((e) => e.type === "blockquote")) {
     return "quote";
   }
+  if (nonEmptyElements.length > 0) {
+    const images = nonEmptyElements.filter((e) => e.type === "image");
+    const others = nonEmptyElements.filter(
+      (e) => e.type !== "image" && e.type !== "text"
+    );
+    const texts = nonEmptyElements.filter((e) => e.type === "text");
+    const substantialText = texts.some((e) => e.type === "text" && e.content.trim().length > 40);
+    if (others.length === 0 && !substantialText && images.length >= 1 && images.length <= 3) {
+      if (images.length === 1) return "image-single";
+      if (images.length === 2) return "image-double";
+      return "image-triple";
+    }
+  }
   return "content";
 }
 function splitIntoSlides(tree, defaultLayout) {
@@ -314,6 +355,8 @@ function splitIntoSlides(tree, defaultLayout) {
   let currentDirectives = {};
   let currentHeadingLevel = 0;
   let isFirstSlide = true;
+  let currentAuthor;
+  let currentDate;
   function flushSlide() {
     if (!currentTitle && currentElements.length === 0 && Object.keys(currentDirectives).length === 0) {
       return;
@@ -334,19 +377,23 @@ function splitIntoSlides(tree, defaultLayout) {
       currentHeadingLevel
     );
     const layout = currentDirectives.layout ?? (autoLayout === "content" ? defaultLayout : autoLayout) ?? "content";
+    const metadata = currentAuthor || currentDate ? { author: currentAuthor, date: currentDate } : void 0;
     slides.push({
       layout,
       title: currentTitle,
       subtitle: currentSubtitle,
       elements: currentElements,
       notes: currentDirectives.notes,
-      directives: toDirectives(currentDirectives)
+      directives: toDirectives(currentDirectives),
+      ...metadata ? { metadata } : {}
     });
     currentTitle = void 0;
     currentSubtitle = void 0;
     currentElements = [];
     currentDirectives = {};
     currentHeadingLevel = 0;
+    currentAuthor = void 0;
+    currentDate = void 0;
     isFirstSlide = false;
   }
   for (const node of tree.children) {
@@ -372,6 +419,31 @@ function splitIntoSlides(tree, defaultLayout) {
       }
       continue;
     }
+    if (node.type === "paragraph" && isFirstSlide && slides.length === 0) {
+      const lines = node.children.map(extractText).join("").trim().split("\n");
+      let metaAuthor;
+      let metaDate;
+      const metaOnly = lines.every((raw) => {
+        const line = raw.trim();
+        if (!line) return true;
+        const authorMatch = line.match(/^作者\s*[:：]\s*(.+)$/);
+        if (authorMatch) {
+          metaAuthor = authorMatch[1].trim();
+          return true;
+        }
+        const dateMatch = line.match(/^日期\s*[:：]\s*(.+)$/);
+        if (dateMatch) {
+          metaDate = dateMatch[1].trim();
+          return true;
+        }
+        return false;
+      });
+      if (metaOnly && (metaAuthor || metaDate)) {
+        if (metaAuthor) currentAuthor = metaAuthor;
+        if (metaDate) currentDate = metaDate;
+        continue;
+      }
+    }
     const element = nodeToElement(node);
     if (element) {
       currentElements.push(element);
@@ -440,8 +512,69 @@ function parseMarkdown(markdown) {
 // src/renderer/pptx-renderer.ts
 import PptxGenJS from "pptxgenjs";
 
+// src/renderer/layouts/layout-spec.ts
+function layoutSpec(theme, key) {
+  return theme.layouts?.[key] ?? {};
+}
+function specNumber(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function specAlign(value, fallback) {
+  return value ?? fallback;
+}
+function extraNumber(spec, key, fallback) {
+  const v = spec.extra?.[key];
+  return typeof v === "number" && Number.isFinite(v) ? v : fallback;
+}
+function extraBoolean(spec, key, fallback) {
+  const v = spec.extra?.[key];
+  return typeof v === "boolean" ? v : fallback;
+}
+function extraString(spec, key, fallback) {
+  const v = spec.extra?.[key];
+  return typeof v === "string" && v ? v : fallback;
+}
+function resolveSideMargins(spec, fallback) {
+  const base = specNumber(spec.margin, fallback);
+  return {
+    left: specNumber(spec.extra?.marginLeft, base),
+    right: specNumber(spec.extra?.marginRight, base)
+  };
+}
+function titleRuleHeight(spec, fallback) {
+  return extraNumber(spec, "titleRuleHeight", fallback);
+}
+function titleRuleRole(spec) {
+  const v = spec.extra?.titleRuleColor;
+  return v === "secondary" || v === "divider" ? v : "primary";
+}
+function ruleColor(theme, role) {
+  if (role === "secondary") return theme.colors.secondary;
+  if (role === "divider") return theme.colors.divider ?? theme.colors.secondary;
+  return theme.colors.primary;
+}
+function addHRuler(slide, opts) {
+  slide.addShape("rect", {
+    x: opts.x,
+    y: opts.y,
+    w: opts.w,
+    h: opts.h,
+    fill: { color: opts.color }
+  });
+}
+
 // src/renderer/layouts/title.ts
 function renderTitleSlide(slide, node, theme) {
+  const spec = layoutSpec(theme, "title");
+  if (extraBoolean(spec, "minimalTitle", false)) {
+    renderMinimalTitle(slide, node, theme);
+    return;
+  }
+  const align = specAlign(spec.titleAlign, "center");
+  const { left, right } = resolveSideMargins(spec, 0.8);
+  const spineW = extraNumber(spec, "spineWidth", 0);
+  const boxX = left + spineW;
+  const contentW = Math.max(2, 13.33 - boxX - right);
   const textColor = theme.colors.titleText ?? "FFFFFF";
   const subtitleColor = textColor === "FFFFFF" ? "FFFFFFCC" : theme.colors.secondary;
   const metaColor = textColor === "FFFFFF" ? "FFFFFF99" : theme.colors.secondary;
@@ -449,65 +582,358 @@ function renderTitleSlide(slide, node, theme) {
   if (bgColor) {
     slide.background = { color: bgColor };
   }
+  if (spineW > 0) {
+    slide.addShape("rect", {
+      x: 0,
+      y: 0,
+      w: spineW,
+      h: 7.5,
+      fill: { color: theme.colors.primary }
+    });
+  }
+  const titleY = extraNumber(spec, "titleY", 2);
+  const subtitleY = extraNumber(spec, "subtitleY", 3.8);
+  const metaBottom = extraBoolean(spec, "metaBottom", false);
+  const metaY = extraNumber(spec, "metaY", metaBottom ? 6.55 : 5.5);
   if (node.title) {
+    const titleScale = extraNumber(spec, "titleFontSizeScale", 1);
     slide.addText(node.title, {
-      x: 0.8,
-      y: 2,
-      w: 11.7,
+      x: boxX,
+      y: titleY,
+      w: contentW,
       h: 1.5,
-      fontSize: theme.fontSize.title,
+      fontSize: Math.round(theme.fontSize.title * titleScale),
       fontFace: theme.fonts.heading,
       color: textColor,
       bold: true,
-      align: "center",
+      align,
       valign: "middle"
     });
+    if (extraBoolean(spec, "titleRule", false)) {
+      const ruleH = extraNumber(spec, "titleRuleHeight", 0.03);
+      const ruleY = extraNumber(spec, "titleRuleY", titleY + 1.55);
+      const ruleW = extraNumber(spec, "titleRuleWidth", Math.min(contentW, 4.2));
+      let ruleX = boxX;
+      if (align === "center") ruleX = boxX + (contentW - ruleW) / 2;
+      else if (align === "right") ruleX = boxX + contentW - ruleW;
+      addHRuler(slide, { x: ruleX, y: ruleY, w: ruleW, h: ruleH, color: ruleColor(theme, titleRuleRole(spec)) });
+    }
   }
   if (node.subtitle) {
     slide.addText(node.subtitle, {
-      x: 0.8,
-      y: 3.8,
-      w: 11.7,
+      x: boxX,
+      y: subtitleY,
+      w: contentW,
       h: 0.8,
       fontSize: theme.fontSize.body,
       fontFace: theme.fonts.body,
       color: subtitleColor,
-      align: "center",
+      align,
       valign: "middle"
     });
   }
+  const meta = node.metadata ?? {};
+  const author = typeof meta.author === "string" ? meta.author : void 0;
+  const date = typeof meta.date === "string" ? meta.date : void 0;
   const textElements = node.elements.filter((e) => e.type === "text");
-  if (textElements.length > 0) {
+  if (author || date) {
+    const lineH = 0.31;
+    if (author) {
+      slide.addText(author, {
+        x: boxX,
+        y: metaY,
+        w: contentW,
+        h: lineH,
+        fontSize: theme.fontSize.small,
+        fontFace: theme.fonts.body,
+        color: metaColor,
+        align,
+        valign: "middle"
+      });
+    }
+    if (date) {
+      slide.addText(date, {
+        x: boxX,
+        y: metaY + lineH + 0.03,
+        w: contentW,
+        h: lineH,
+        fontSize: theme.fontSize.small,
+        fontFace: theme.fonts.body,
+        color: metaColor,
+        align,
+        valign: "middle"
+      });
+    }
+  } else if (textElements.length > 0) {
     const metaText = textElements.map((e) => e.content).join(" \xB7 ");
     slide.addText(metaText, {
-      x: 0.8,
-      y: 5.5,
-      w: 11.7,
+      x: boxX,
+      y: metaY,
+      w: contentW,
       h: 0.6,
       fontSize: theme.fontSize.small,
       fontFace: theme.fonts.body,
       color: metaColor,
-      align: "center"
+      align
+    });
+  }
+}
+function renderMinimalTitle(slide, node, theme) {
+  const spec = layoutSpec(theme, "title");
+  const bgColor = theme.colors.backgroundGradient ? void 0 : theme.colors.titleBackground ?? theme.colors.primary;
+  if (bgColor) {
+    slide.background = { color: bgColor };
+  }
+  const textColor = theme.colors.titleText ?? "FFFFFF";
+  const softColor = textColor === "FFFFFF" ? "FFFFFFCC" : theme.colors.secondary;
+  const lineX = extraNumber(spec, "minimalLineX", 0.83);
+  const lineY1 = extraNumber(spec, "minimalLineY1", 2.64);
+  const lineH = extraNumber(spec, "minimalLineH", 1.94);
+  const lineW = extraNumber(spec, "minimalLineW", 0.04);
+  slide.addShape("rect", {
+    x: lineX,
+    y: lineY1,
+    w: lineW,
+    h: lineH,
+    fill: { color: textColor }
+  });
+  const boxX = extraNumber(spec, "minimalBoxX", 1.11);
+  const contentW = extraNumber(spec, "minimalBoxW", 8.89);
+  if (node.title) {
+    slide.addText(node.title, {
+      x: boxX,
+      y: extraNumber(spec, "minimalTitleY", 2.64),
+      w: contentW,
+      h: 0.89,
+      fontSize: theme.fontSize.title,
+      fontFace: theme.fonts.heading,
+      color: textColor,
+      bold: true,
+      align: "left",
+      valign: "middle"
+    });
+  }
+  if (node.subtitle) {
+    slide.addText(node.subtitle, {
+      x: boxX,
+      y: extraNumber(spec, "minimalSubtitleY", 3.64),
+      w: contentW,
+      h: 0.44,
+      fontSize: theme.fontSize.body,
+      fontFace: theme.fonts.body,
+      color: softColor,
+      align: "left",
+      valign: "middle"
+    });
+  }
+  const meta = node.metadata ?? {};
+  const author = typeof meta.author === "string" ? meta.author : void 0;
+  const date = typeof meta.date === "string" ? meta.date : void 0;
+  const metaX = boxX;
+  const metaW = extraNumber(spec, "minimalMetaW", 4.17);
+  const metaH = 0.31;
+  if (author) {
+    slide.addText(author, {
+      x: metaX,
+      y: extraNumber(spec, "minimalAuthorY", 5.28),
+      w: metaW,
+      h: metaH,
+      fontSize: theme.fontSize.small,
+      fontFace: theme.fonts.body,
+      color: softColor,
+      align: "left",
+      valign: "middle"
+    });
+  }
+  if (date) {
+    slide.addText(date, {
+      x: metaX,
+      y: extraNumber(spec, "minimalDateY", 5.64),
+      w: metaW,
+      h: metaH,
+      fontSize: theme.fontSize.small,
+      fontFace: theme.fonts.body,
+      color: softColor,
+      align: "left",
+      valign: "middle"
     });
   }
 }
 
 // src/renderer/layouts/section.ts
-function renderSectionSlide(slide, node, theme) {
+function formatSectionNumber(n) {
+  return String(n).padStart(2, "0");
+}
+function renderSectionSlide(slide, node, theme, ctx) {
+  const spec = layoutSpec(theme, "section");
+  if (extraBoolean(spec, "minimalNumber", false)) {
+    renderMinimalSection(slide, node, theme, ctx);
+    return;
+  }
+  const barW = theme.styles?.sectionBarWidth ?? extraNumber(spec, "sectionBarWidth", 0.15);
+  const accentBar = spec.accentBar ?? "left";
+  const titleAlign = specAlign(spec.titleAlign, "left");
+  const { left, right } = resolveSideMargins(spec, accentBar === "left" ? 1 : 0.9);
+  if (accentBar !== "none") {
+    if (accentBar === "left") {
+      slide.addShape("rect", {
+        x: 0,
+        y: 0,
+        w: barW,
+        h: 7.5,
+        fill: { color: theme.colors.accent }
+      });
+    } else if (accentBar === "top") {
+      slide.addShape("rect", {
+        x: 0,
+        y: 0,
+        w: 13.33,
+        h: barW,
+        fill: { color: theme.colors.accent }
+      });
+    } else if (accentBar === "bottom") {
+      slide.addShape("rect", {
+        x: 0,
+        y: 7.5 - barW,
+        w: 13.33,
+        h: barW,
+        fill: { color: theme.colors.accent }
+      });
+    }
+  }
+  const leftPad = accentBar === "left" ? Math.max(left, barW + 0.85) : left;
+  const textW = Math.max(3, 13.33 - leftPad - right);
+  if (extraBoolean(spec, "doubleRules", false)) {
+    const weight = extraNumber(spec, "ruleWeight", 0.035);
+    const bandY = extraNumber(spec, "bandY", 2.35);
+    const bandH = extraNumber(spec, "bandH", 1.7);
+    const color = ruleColor(theme, titleRuleRole(spec) === "primary" ? "primary" : titleRuleRole(spec));
+    const ruleX = leftPad;
+    const ruleW = textW;
+    addHRuler(slide, { x: ruleX, y: bandY, w: ruleW, h: weight, color });
+    addHRuler(slide, { x: ruleX, y: bandY + bandH, w: ruleW, h: weight, color });
+    if (node.title) {
+      slide.addText(node.title, {
+        x: leftPad,
+        y: bandY + weight + 0.08,
+        w: textW,
+        h: bandH - weight * 2 - 0.16,
+        fontSize: theme.fontSize.heading + 6,
+        fontFace: theme.fonts.heading,
+        color: theme.colors.text,
+        bold: true,
+        align: titleAlign,
+        valign: "middle"
+      });
+    }
+    const sub = node.subtitle?.trim();
+    if (sub) {
+      slide.addText(sub, {
+        x: leftPad,
+        y: bandY + bandH + 0.35,
+        w: textW,
+        h: 0.45,
+        fontSize: theme.fontSize.small,
+        fontFace: theme.fonts.body,
+        color: theme.colors.secondary,
+        align: titleAlign
+      });
+    }
+    return;
+  }
+  if (extraBoolean(spec, "sectionRule", false)) {
+    const secRuleY = extraNumber(spec, "sectionRuleY", 4.64);
+    const secRuleW = extraNumber(spec, "sectionRuleWidth", 5);
+    const secRuleH = extraNumber(spec, "sectionRuleHeight", 0.04);
+    const secRuleX = extraNumber(
+      spec,
+      "sectionRuleX",
+      titleAlign === "right" ? 13.33 - right - secRuleW : leftPad
+    );
+    addHRuler(slide, {
+      x: secRuleX,
+      y: secRuleY,
+      w: secRuleW,
+      h: secRuleH,
+      color: ruleColor(
+        theme,
+        extraString(spec, "sectionRuleColor", "primary")
+      )
+    });
+  }
+  if (node.subtitle) {
+    const subY = extraNumber(spec, "subtitleY", 0.85);
+    const subH = extraNumber(spec, "subtitleH", 0.45);
+    slide.addText(node.subtitle, {
+      x: leftPad,
+      y: subY,
+      w: textW,
+      h: subH,
+      fontSize: theme.fontSize.body,
+      fontFace: theme.fonts.body,
+      color: theme.colors.secondary,
+      align: titleAlign,
+      valign: "middle"
+    });
+  }
+  if (node.title) {
+    const tY = extraNumber(spec, "titleY", 2.5);
+    const tH = extraNumber(spec, "titleH", 2);
+    slide.addText(node.title, {
+      x: leftPad,
+      y: tY,
+      w: textW,
+      h: tH,
+      fontSize: theme.fontSize.heading + 4,
+      fontFace: theme.fonts.heading,
+      color: theme.colors.text,
+      bold: true,
+      align: titleAlign,
+      valign: "middle"
+    });
+  }
+}
+function renderMinimalSection(slide, node, theme, ctx) {
+  const spec = layoutSpec(theme, "section");
+  const num = formatSectionNumber(ctx?.sectionNumber ?? 1);
+  const nX = extraNumber(spec, "minimalNumberX", 1.11);
+  const nY = extraNumber(spec, "minimalNumberY", 2.43);
+  const nW = extraNumber(spec, "minimalNumberW", 2.5);
+  const nH = extraNumber(spec, "minimalNumberH", 1.53);
+  slide.addText(num, {
+    x: nX,
+    y: nY,
+    w: nW,
+    h: nH,
+    fontSize: theme.fontSize.title,
+    fontFace: theme.fonts.heading,
+    color: theme.colors.primary,
+    bold: true,
+    align: "left",
+    valign: "middle"
+  });
+  const rX = extraNumber(spec, "minimalRuleX", 3.89);
+  const rY1 = extraNumber(spec, "minimalRuleY1", 2.71);
+  const rH = extraNumber(spec, "minimalRuleH", 1.11);
+  const rW = extraNumber(spec, "minimalRuleW", 0.03);
   slide.addShape("rect", {
-    x: 0,
-    y: 0,
-    w: 0.15,
-    h: 7.5,
-    fill: { color: theme.colors.accent }
+    x: rX,
+    y: rY1,
+    w: rW,
+    h: rH,
+    fill: { color: theme.colors.divider ?? theme.colors.secondary }
   });
   if (node.title) {
+    const tX = extraNumber(spec, "minimalTitleX", 4.31);
+    const tY = extraNumber(spec, "minimalTitleY", rY1);
+    const tW = extraNumber(spec, "minimalTitleW", 6.94);
+    const tH = extraNumber(spec, "minimalTitleH", 0.69);
     slide.addText(node.title, {
-      x: 1,
-      y: 2.5,
-      w: 11.3,
-      h: 2,
-      fontSize: theme.fontSize.heading + 4,
+      x: tX,
+      y: tY,
+      w: tW,
+      h: tH,
+      fontSize: theme.fontSize.heading,
       fontFace: theme.fonts.heading,
       color: theme.colors.text,
       bold: true,
@@ -517,15 +943,135 @@ function renderSectionSlide(slide, node, theme) {
   }
 }
 
-// src/utils/png-size.ts
-function getPngSize(data) {
-  if (data.length < 24) return null;
-  if (data.readUInt32BE(0) !== 2303741511) return null;
-  const width = data.readUInt32BE(16);
-  const height = data.readUInt32BE(20);
+// src/utils/image-size.ts
+function positive(width, height) {
   if (!(width > 0 && height > 0)) return null;
   return { width, height };
 }
+function pngSize(data) {
+  if (data.length < 24) return null;
+  if (data.readUInt32BE(0) !== 2303741511) return null;
+  return positive(data.readUInt32BE(16), data.readUInt32BE(20));
+}
+function isFrameMarker(marker) {
+  return marker >= 192 && marker <= 207 && marker !== 196 && // DHT
+  marker !== 200 && // JPG
+  marker !== 204;
+}
+function jpegSize(data) {
+  if (data.length < 4 || data[0] !== 255 || data[1] !== 216) return null;
+  let offset = 2;
+  while (offset + 3 < data.length) {
+    if (data[offset] !== 255) {
+      offset++;
+      continue;
+    }
+    let marker = data[offset + 1];
+    while (marker === 255 && offset + 2 < data.length) {
+      offset++;
+      marker = data[offset + 1];
+    }
+    offset += 2;
+    if (marker === 1 || marker >= 208 && marker <= 216) continue;
+    if (marker === 218 || marker === 217) return null;
+    if (offset + 2 > data.length) return null;
+    const length = data.readUInt16BE(offset);
+    if (length < 2) return null;
+    if (isFrameMarker(marker)) {
+      if (offset + 7 > data.length) return null;
+      return positive(data.readUInt16BE(offset + 5), data.readUInt16BE(offset + 3));
+    }
+    offset += length;
+  }
+  return null;
+}
+function gifSize(data) {
+  if (data.length < 10) return null;
+  const signature = data.toString("latin1", 0, 6);
+  if (signature !== "GIF87a" && signature !== "GIF89a") return null;
+  return positive(data.readUInt16LE(6), data.readUInt16LE(8));
+}
+function webpSize(data) {
+  if (data.length < 30) return null;
+  if (data.toString("latin1", 0, 4) !== "RIFF") return null;
+  if (data.toString("latin1", 8, 12) !== "WEBP") return null;
+  const chunk = data.toString("latin1", 12, 16);
+  if (chunk === "VP8X") {
+    return positive(data.readUIntLE(24, 3) + 1, data.readUIntLE(27, 3) + 1);
+  }
+  if (chunk === "VP8 ") {
+    if (data[23] !== 157 || data[24] !== 1 || data[25] !== 42) return null;
+    return positive(data.readUInt16LE(26) & 16383, data.readUInt16LE(28) & 16383);
+  }
+  if (chunk === "VP8L") {
+    if (data[20] !== 47) return null;
+    const bits = data.readUInt32LE(21);
+    return positive((bits & 16383) + 1, (bits >>> 14 & 16383) + 1);
+  }
+  return null;
+}
+function bmpSize(data) {
+  if (data.length < 26) return null;
+  if (data[0] !== 66 || data[1] !== 77) return null;
+  const headerSize = data.readUInt32LE(14);
+  if (headerSize === 12) {
+    return positive(data.readUInt16LE(18), data.readUInt16LE(20));
+  }
+  if (headerSize >= 40) {
+    return positive(Math.abs(data.readInt32LE(18)), Math.abs(data.readInt32LE(22)));
+  }
+  return null;
+}
+var SVG_UNITS = {
+  px: 1,
+  pt: 96 / 72,
+  pc: 16,
+  mm: 96 / 25.4,
+  cm: 96 / 2.54,
+  in: 96,
+  q: 96 / 101.6
+};
+function parseSvgLength(value) {
+  if (!value) return void 0;
+  const match = value.match(/^([\d.]+)\s*([a-z%]*)$/i);
+  if (!match) return void 0;
+  const n = parseFloat(match[1]);
+  if (!(n > 0)) return void 0;
+  const unit = match[2].toLowerCase();
+  if (unit === "%") return void 0;
+  const scale = SVG_UNITS[unit || "px"];
+  return scale === void 0 ? void 0 : n * scale;
+}
+function findSvgRoot(data) {
+  const head = data.toString("utf8", 0, Math.min(data.length, 4096));
+  return head.match(/<svg\b[^>]*>/i);
+}
+function isSvgImage(data) {
+  return findSvgRoot(data) !== null;
+}
+function svgSize(data) {
+  const root = findSvgRoot(data);
+  if (!root) return null;
+  const attribute = (name) => {
+    const match = root[0].match(new RegExp(`\\b${name}\\s*=\\s*["']([^"']*)["']`, "i"));
+    return match?.[1]?.trim();
+  };
+  const viewBox = attribute("viewBox");
+  if (viewBox) {
+    const parts = viewBox.split(/[\s,]+/).map(Number);
+    if (parts.length === 4 && parts[2] > 0 && parts[3] > 0) {
+      return { width: parts[2], height: parts[3] };
+    }
+  }
+  const width = parseSvgLength(attribute("width"));
+  const height = parseSvgLength(attribute("height"));
+  if (width === void 0 || height === void 0) return null;
+  return positive(width, height);
+}
+function getImageSize(data) {
+  if (data.length < 10) return null;
+  return pngSize(data) ?? jpegSize(data) ?? gifSize(data) ?? webpSize(data) ?? bmpSize(data) ?? svgSize(data);
+}
 
 // src/utils/image-fit.ts
 function fitInBox(img, maxWidth, maxHeight) {
@@ -618,11 +1164,31 @@ function tableToChartOption(table, type) {
 import { readFileSync } from "fs";
 var SLIDE_W = 13.33;
 var SLIDE_H = 7.5;
-var MARGIN = 0.6;
-var CONTENT_W = SLIDE_W - MARGIN * 2;
-var TITLE_H = 0.9;
-var BOTTOM_MARGIN = 0.45;
-var GRID_GAP = 0.25;
+var DEFAULT_MARGIN = 0.6;
+var DEFAULT_TITLE_H = 0.9;
+var DEFAULT_BOTTOM_MARGIN = 0.45;
+var DEFAULT_GRID_GAP = 0.25;
+function contentMetrics(theme) {
+  const spec = layoutSpec(theme, "content");
+  const { left, right } = resolveSideMargins(spec, DEFAULT_MARGIN);
+  const titleH = specNumber(spec.titleHeight, DEFAULT_TITLE_H);
+  const contentPadding = specNumber(spec.contentPadding, 0);
+  const contentW = Math.max(2, SLIDE_W - left - right);
+  return {
+    marginLeft: left,
+    marginRight: right,
+    titleH,
+    titleY: extraNumber(spec, "titleY", 0.3),
+    contentW,
+    bottom: DEFAULT_BOTTOM_MARGIN,
+    gridGap: DEFAULT_GRID_GAP,
+    contentPadding,
+    titleRule: extraBoolean(spec, "titleRule", true),
+    titleRuleH: titleRuleHeight(spec, 0.04),
+    titleRuleWidth: extraNumber(spec, "titleRuleWidth", contentW),
+    titleRuleColor: titleRuleRole(spec)
+  };
+}
 var IMAGE_MIME = {
   png: "image/png",
   jpg: "image/jpeg",
@@ -632,10 +1198,10 @@ var IMAGE_MIME = {
   bmp: "image/bmp",
   svg: "image/svg+xml"
 };
-function contentAreaInsets(node) {
+function contentAreaInsets(node, metrics) {
   return {
-    top: node.title ? 0.3 + TITLE_H + 0.2 : 0.3,
-    bottom: BOTTOM_MARGIN
+    top: node.title ? metrics.titleY + metrics.titleH + 0.2 : metrics.titleY,
+    bottom: metrics.bottom
   };
 }
 function splitGrid(elements) {
@@ -666,20 +1232,32 @@ function splitGrid(elements) {
   });
 }
 async function renderContentSlide(slide, node, theme, ctx) {
-  const { top } = contentAreaInsets(node);
+  const spec = layoutSpec(theme, "content");
+  if (extraBoolean(spec, "minimalBox", false)) {
+    await renderMinimalContent(slide, node, theme, ctx);
+    return;
+  }
+  const metrics = contentMetrics(theme);
+  const { marginLeft, titleH, titleY, contentW, gridGap, contentPadding, titleRuleWidth } = metrics;
+  const { top } = contentAreaInsets(node, metrics);
+  const pad = contentPadding > 0 ? contentPadding : 0;
+  const drawX = marginLeft + pad;
+  const drawW = contentW - pad * 2;
   if (node.title) {
-    slide.addShape("rect", {
-      x: MARGIN,
-      y: 0.3 + TITLE_H - 0.05,
-      w: CONTENT_W,
-      h: 0.04,
-      fill: { color: theme.colors.primary }
-    });
+    if (metrics.titleRule && metrics.titleRuleH > 0) {
+      addHRuler(slide, {
+        x: marginLeft,
+        y: titleY + titleH - metrics.titleRuleH - 0.01,
+        w: titleRuleWidth,
+        h: metrics.titleRuleH,
+        color: ruleColor(theme, metrics.titleRuleColor)
+      });
+    }
     slide.addText(node.title, {
-      x: MARGIN,
-      y: 0.3,
-      w: CONTENT_W,
-      h: TITLE_H,
+      x: marginLeft,
+      y: titleY,
+      w: contentW,
+      h: titleH,
       fontSize: theme.fontSize.heading,
       fontFace: theme.fonts.heading,
       color: theme.colors.primary,
@@ -689,11 +1267,11 @@ async function renderContentSlide(slide, node, theme, ctx) {
   }
   const grid = splitGrid(prepareElements(node));
   const rows = grid.length;
-  const availH = SLIDE_H - top - BOTTOM_MARGIN - GRID_GAP * (rows - 1);
+  const availH = SLIDE_H - top - metrics.bottom - gridGap * (rows - 1);
   const ests = grid.map(
     (columns) => Math.max(
       0.8,
-      ...columns.map((c) => estimateColumnHeight(c, (CONTENT_W - GRID_GAP * (columns.length - 1)) / columns.length))
+      ...columns.map((c) => estimateColumnHeight(c, (drawW - gridGap * (columns.length - 1)) / columns.length, theme))
     )
   );
   const totalEst = ests.reduce((a, b) => a + b, 0);
@@ -702,19 +1280,19 @@ async function renderContentSlide(slide, node, theme, ctx) {
   for (let r = 0; r < rows; r++) {
     const columns = grid[r];
     const cols = columns.length;
-    const colW = (CONTENT_W - GRID_GAP * (cols - 1)) / cols;
+    const colW = (drawW - gridGap * (cols - 1)) / cols;
     const rowH = ests[r] * scale;
     for (let c = 0; c < cols; c++) {
       await renderColumn(
         slide,
         columns[c],
-        { x: MARGIN + c * (colW + GRID_GAP), y, w: colW, h: rowH },
+        { x: drawX + c * (colW + gridGap), y, w: colW, h: rowH },
         node,
         theme,
         ctx
       );
     }
-    y += rowH + GRID_GAP;
+    y += rowH + gridGap;
   }
 }
 function prepareElements(node) {
@@ -734,16 +1312,30 @@ function prepareElements(node) {
   }
   return elements;
 }
-function estimateTextLines(content, w) {
-  const charsPerLine = Math.max(20, Math.floor(w * 60));
-  return Math.max(1, Math.ceil(content.length / charsPerLine));
+var CODE_INSET_IN = 16 / 72;
+var CODE_LINE_FACTOR = 1.3;
+function codeBlockHeight(lines, fontSizePt) {
+  return Math.max(1, lines * fontSizePt * CODE_LINE_FACTOR / 72 + CODE_INSET_IN);
+}
+function displayWidth(text) {
+  let units = 0;
+  for (const char of text) {
+    units += (char.codePointAt(0) ?? 0) > 11904 ? 2 : 1;
+  }
+  return units;
+}
+function charsPerLine(widthIn, fontSizePt) {
+  return Math.max(8, Math.floor(widthIn * 72 / (fontSizePt * 0.5)));
+}
+function estimateTextLines(content, w, fontSizePt) {
+  return Math.max(1, Math.ceil(displayWidth(content) / charsPerLine(w, fontSizePt)));
 }
-function estimateColumnHeight(elements, w) {
+function estimateColumnHeight(elements, w, theme) {
   let h = 0;
   for (const el of elements) {
     switch (el.type) {
       case "text":
-        h += Math.max(0.5, Math.ceil(el.content.length / Math.max(20, Math.floor(w * 60))) * 0.35);
+        h += Math.max(0.5, estimateTextLines(el.content, w, theme.fontSize.body) * 0.35);
         break;
       case "heading":
         h += 0.7;
@@ -752,7 +1344,7 @@ function estimateColumnHeight(elements, w) {
         h += el.items.length * 0.5;
         break;
       case "code":
-        h += Math.max(1, el.content.split("\n").length * 0.25);
+        h += codeBlockHeight(el.content.split("\n").length, theme.fontSize.code);
         break;
       case "diagram":
       case "image":
@@ -768,7 +1360,7 @@ function estimateColumnHeight(elements, w) {
         h += (el.rows.length + 1) * 0.4;
         break;
       case "callout":
-        h += Math.min(4.5, 0.72 + estimateTextLines(el.content, w) * 0.3);
+        h += Math.min(4.5, 0.72 + estimateTextLines(el.content, w, theme.fontSize.body) * 0.3);
         break;
       case "blockquote":
         h += 1;
@@ -782,7 +1374,7 @@ function estimateColumnHeight(elements, w) {
   return h;
 }
 async function renderColumn(slide, elements, box, node, theme, ctx) {
-  const est = estimateColumnHeight(elements, box.w);
+  const est = estimateColumnHeight(elements, box.w, theme);
   const yPos = box.h > est ? box.y + (box.h - est) / 2 : box.y;
   let cursor = yPos;
   for (const element of elements) {
@@ -796,11 +1388,13 @@ async function renderElement(slide, element, yPos, box, node, theme, ctx) {
   switch (element.type) {
     case "text": {
       if (!element.content.trim()) return 0;
+      const lines = estimateTextLines(element.content, w, theme.fontSize.body);
+      const height = Math.max(0.5, lines * 0.35);
       slide.addText(element.content, {
         x,
         y: yPos,
         w,
-        h: 0.6,
+        h: height,
         fontSize: theme.fontSize.body,
         fontFace: theme.fonts.body,
         color: theme.colors.text,
@@ -809,9 +1403,7 @@ async function renderElement(slide, element, yPos, box, node, theme, ctx) {
         valign: "top",
         wrap: true
       });
-      const charsPerLine = Math.max(20, Math.floor(w * 60));
-      const lines = Math.ceil(element.content.length / charsPerLine);
-      return Math.max(0.5, lines * 0.35);
+      return height;
     }
     case "heading": {
       slide.addText(element.content, {
@@ -865,7 +1457,7 @@ async function renderElement(slide, element, yPos, box, node, theme, ctx) {
         element.highlightLines
       );
       const lines = element.content.split("\n").length;
-      const height = Math.min(maxH, Math.max(1, lines * 0.25));
+      const height = Math.min(maxH, codeBlockHeight(lines, theme.fontSize.code));
       slide.addText(runs, {
         x,
         y: yPos,
@@ -883,12 +1475,16 @@ async function renderElement(slide, element, yPos, box, node, theme, ctx) {
     case "diagram": {
       try {
         const pngBuffer = await ctx.renderDiagram(element.diagramType, element.content);
-        const imgSize = getPngSize(pngBuffer) ?? { width: 8, height: 3.5 };
+        const imgSize = getImageSize(pngBuffer) ?? { width: 8, height: 3.5 };
         const boxH = Math.max(1.2, maxH);
         const fitted = fitInBox(imgSize, w, boxH);
         const base64 = pngBuffer.toString("base64");
         slide.addImage({
           data: `image/png;base64,${base64}`,
+          // A diagram has no alt text of its own, so the slide title describes
+          // it best; without one, name the notation at least. Passing nothing
+          // would leave pptxgenjs' internal placeholder filename as the alt text.
+          altText: node.title || `${element.diagramType} diagram`,
           x: x + (w - fitted.width) / 2,
           y: yPos,
           w: fitted.width,
@@ -896,7 +1492,10 @@ async function renderElement(slide, element, yPos, box, node, theme, ctx) {
         });
         return fitted.height + 0.2;
       } catch (err) {
-        slide.addText(`[Diagram render error: ${err instanceof Error ? err.message : "unknown"}]`, {
+        const reason = err instanceof Error ? err.message : "unknown";
+        const message = `[Diagram render error: ${reason}]`;
+        log.warn(`[${node.title ?? "slide"}] ${message}`);
+        slide.addText(message, {
           x,
           y: yPos,
           w,
@@ -915,7 +1514,8 @@ async function renderElement(slide, element, yPos, box, node, theme, ctx) {
           log.warn(`[${node.title ?? "slide"}] ${resolved.error}`);
           return 0;
         }
-        const imgSize = getPngSize(readFileSync(resolved.path)) ?? { width: 6, height: 3 };
+        const fileData = readFileSync(resolved.path);
+        const imgSize = getImageSize(fileData) ?? { width: 6, height: 3 };
         const boxH = Math.max(1.2, maxH);
         const placed = fitImageWithOptions(
           imgSize,
@@ -924,10 +1524,19 @@ async function renderElement(slide, element, yPos, box, node, theme, ctx) {
         );
         const ext = resolved.path.split(".").pop()?.toLowerCase() ?? "png";
         const mime = IMAGE_MIME[ext] ?? "image/png";
-        const data = `${mime};base64,${readFileSync(resolved.path).toString("base64")}`;
+        const data = `${mime};base64,${fileData.toString("base64")}`;
+        if (ext === "webp") {
+          log.warn(
+            `[${node.title ?? "slide"}] WebP does not render in PowerPoint for the web or Office 2019 and earlier \u2014 some recipients may see a broken image (${element.src})`
+          );
+        }
         slide.addImage({
           data,
           path: "preencoded.png",
+          // The author's alt text when they wrote one; otherwise the source they
+          // referenced, which at least beats pptxgenjs' internal placeholder name.
+          // Falsy, not nullish: `![](...)` parses to an empty alt string.
+          altText: element.alt || element.src,
           x: x + placed.x,
           y: yPos,
           w: placed.width,
@@ -1012,7 +1621,7 @@ async function renderElement(slide, element, yPos, box, node, theme, ctx) {
       };
       const color = palette[element.variant] ?? theme.colors.primary;
       const label = element.title ?? element.variant.toUpperCase();
-      const textLines = estimateTextLines(element.content, w);
+      const textLines = estimateTextLines(element.content, w, theme.fontSize.body);
       const cardH = Math.min(maxH, 0.72 + textLines * 0.3);
       const textH = cardH - 0.44;
       slide.addShape("roundRect", {
@@ -1058,22 +1667,120 @@ async function renderElement(slide, element, yPos, box, node, theme, ctx) {
       return 0;
   }
 }
+async function renderMinimalContent(slide, node, theme, ctx) {
+  const spec = layoutSpec(theme, "content");
+  const margin = specNumber(spec.margin, 0.83);
+  const boxX = extraNumber(spec, "minimalBoxX", margin);
+  const boxY = extraNumber(spec, "minimalBoxY", 1.33);
+  const boxW = extraNumber(spec, "minimalBoxW", SLIDE_W - margin * 2);
+  const boxH = extraNumber(spec, "minimalBoxH", 5.28);
+  const lineColor = theme.colors.divider ?? theme.colors.secondary;
+  if (node.title) {
+    slide.addText(node.title, {
+      x: boxX,
+      y: extraNumber(spec, "minimalTitleY", 0.5),
+      w: boxW,
+      h: 0.44,
+      fontSize: theme.fontSize.heading,
+      fontFace: theme.fonts.heading,
+      color: theme.colors.primary,
+      bold: true,
+      align: "left",
+      valign: "middle"
+    });
+    addHRuler(slide, {
+      x: boxX,
+      y: extraNumber(spec, "minimalTitleRuleY", 1.03),
+      w: extraNumber(spec, "minimalTitleRuleW", 0.56),
+      h: extraNumber(spec, "minimalTitleRuleH", 0.03),
+      color: lineColor
+    });
+  }
+  slide.addShape("rect", {
+    x: boxX,
+    y: boxY,
+    w: boxW,
+    h: boxH,
+    fill: { transparency: 100 },
+    line: { color: lineColor, width: 0.01 }
+  });
+  const gap = 0.25;
+  const pad = 0.3;
+  const inner = { x: boxX + pad, y: boxY + pad, w: boxW - pad * 2, h: boxH - pad * 2 };
+  const innerBox = {
+    x: inner.x,
+    y: inner.y,
+    w: inner.w,
+    h: inner.h
+  };
+  const grid = splitGrid(prepareElements(node));
+  const rows = grid.length;
+  const availH = innerBox.h - gap * (rows - 1);
+  const ests = grid.map(
+    (columns) => Math.max(
+      0.8,
+      ...columns.map((c) => estimateColumnHeight(c, (innerBox.w - gap * (columns.length - 1)) / columns.length, theme))
+    )
+  );
+  const totalEst = ests.reduce((a, b) => a + b, 0);
+  const scale = totalEst > availH ? availH / totalEst : 1;
+  let y = innerBox.y;
+  for (let r = 0; r < rows; r++) {
+    const columns = grid[r];
+    const cols = columns.length;
+    const colW = (innerBox.w - gap * (cols - 1)) / cols;
+    const rowH = ests[r] * scale;
+    for (let c = 0; c < cols; c++) {
+      await renderColumn(
+        slide,
+        columns[c],
+        { x: innerBox.x + c * (colW + gap), y, w: colW, h: rowH },
+        node,
+        theme,
+        ctx
+      );
+    }
+    y += rowH + gap;
+  }
+}
 
 // src/renderer/layouts/code.ts
 async function renderCodeSlide(slide, node, theme, ctx) {
-  let yPos = 0.3;
+  const spec = layoutSpec(theme, "code");
+  if (extraBoolean(spec, "minimalCard", false)) {
+    await renderMinimalCode(slide, node, theme, ctx);
+    return;
+  }
+  const { left, right } = resolveSideMargins(spec, 0.5);
+  const titleH = specNumber(spec.titleHeight, 0.7);
+  const titleAlign = specAlign(spec.titleAlign, "left");
+  const contentW = Math.max(3, 13.33 - left - right);
+  const titleGap = 0.2;
+  let yPos = extraNumber(spec, "titleY", 0.3);
   if (node.title) {
     slide.addText(node.title, {
-      x: 0.5,
+      x: left,
       y: yPos,
-      w: 12.3,
-      h: 0.7,
+      w: contentW,
+      h: titleH,
       fontSize: theme.fontSize.heading,
       fontFace: theme.fonts.heading,
       color: theme.colors.primary,
-      bold: true
+      bold: true,
+      align: titleAlign === "center" ? "center" : "left"
     });
-    yPos += 0.9;
+    if (extraBoolean(spec, "titleRule", false)) {
+      const rh = titleRuleHeight(spec, 0.03);
+      const ruleW = extraNumber(spec, "titleRuleWidth", contentW);
+      addHRuler(slide, {
+        x: left,
+        y: yPos + titleH + 0.02,
+        w: ruleW,
+        h: rh,
+        color: ruleColor(theme, titleRuleRole(spec))
+      });
+    }
+    yPos += titleH + titleGap;
   }
   for (const element of node.elements) {
     if (element.type === "code") {
@@ -1083,10 +1790,10 @@ async function renderCodeSlide(slide, node, theme, ctx) {
         element.highlightLines
       );
       slide.addText(runs, {
-        x: 0.5,
+        x: left,
         y: yPos,
-        w: 12.3,
-        h: 7.5 - yPos - 0.5,
+        w: contentW,
+        h: 7.5 - yPos - 0.45,
         fill: { color: theme.colors.codeBackground },
         color: theme.colors.codeText,
         fontFace: theme.fonts.code,
@@ -1099,52 +1806,519 @@ async function renderCodeSlide(slide, node, theme, ctx) {
     }
   }
 }
-
-// src/renderer/layouts/quote.ts
-function renderQuoteSlide(slide, node, theme) {
-  slide.addText("\u201C", {
-    x: 1.5,
-    y: 1,
-    w: 2,
-    h: 1.5,
-    fontSize: 72,
-    fontFace: "Georgia",
-    color: theme.colors.accent,
-    bold: true
-  });
-  const quoteElement = node.elements.find((e) => e.type === "blockquote");
-  if (quoteElement && quoteElement.type === "blockquote") {
-    let quoteText = quoteElement.content;
-    let attribution = "";
-    const attrMatch = quoteText.match(/\n?\s*[—\u2014-]\s*(.+)$/);
-    if (attrMatch) {
-      attribution = attrMatch[1].trim();
-      quoteText = quoteText.slice(0, attrMatch.index).trim();
-    }
-    slide.addText(quoteText, {
-      x: 1.8,
-      y: 2.5,
-      w: 9.7,
-      h: 2.5,
+async function renderMinimalCode(slide, node, theme, ctx) {
+  const spec = layoutSpec(theme, "code");
+  const margin = specNumber(spec.margin, 0.83);
+  const boxX = extraNumber(spec, "minimalCardX", margin);
+  const boxY = extraNumber(spec, "minimalCardY", 1.33);
+  const boxW = extraNumber(spec, "minimalCardW", 13.33 - margin * 2);
+  const boxH = extraNumber(spec, "minimalCardH", 5.28);
+  const lineColor = theme.colors.divider ?? theme.colors.secondary;
+  const radius = extraNumber(spec, "minimalCardRadius", 0.08);
+  if (node.title) {
+    slide.addText(node.title, {
+      x: boxX,
+      y: extraNumber(spec, "minimalTitleY", 0.5),
+      w: boxW,
+      h: 0.44,
       fontSize: theme.fontSize.heading,
-      fontFace: theme.fonts.body,
-      color: theme.colors.text,
-      italic: true,
-      align: "center",
+      fontFace: theme.fonts.heading,
+      color: theme.colors.primary,
+      bold: true,
+      align: "left",
       valign: "middle"
     });
-    if (attribution) {
-      slide.addText(`\u2014 ${attribution}`, {
-        x: 1.8,
-        y: 5.2,
-        w: 9.7,
-        h: 0.6,
-        fontSize: theme.fontSize.body,
-        fontFace: theme.fonts.body,
-        color: theme.colors.secondary,
-        align: "right"
-      });
-    }
+    addHRuler(slide, {
+      x: boxX,
+      y: extraNumber(spec, "minimalTitleRuleY", 1.03),
+      w: extraNumber(spec, "minimalTitleRuleW", 0.56),
+      h: extraNumber(spec, "minimalTitleRuleH", 0.03),
+      color: lineColor
+    });
+  }
+  slide.addShape("roundRect", {
+    x: boxX,
+    y: boxY,
+    w: boxW,
+    h: boxH,
+    rectRadius: radius,
+    fill: { color: theme.colors.codeBackground },
+    line: { color: lineColor, width: 0.01 }
+  });
+  const pad = 0.3;
+  for (const element of node.elements) {
+    if (element.type !== "code") continue;
+    const runs = await ctx.highlightCode(
+      element.content,
+      element.language ?? "text",
+      element.highlightLines
+    );
+    slide.addText(runs, {
+      x: boxX + pad,
+      y: boxY + pad,
+      w: boxW - pad * 2,
+      h: boxH - pad * 2,
+      fill: { color: theme.colors.codeBackground },
+      color: theme.colors.codeText,
+      fontFace: theme.fonts.code,
+      fontSize: theme.fontSize.code,
+      valign: "top",
+      paraSpaceAfter: 2,
+      margin: [8, 12, 8, 12]
+    });
+    break;
+  }
+}
+
+// src/renderer/layouts/quote.ts
+function renderQuoteSlide(slide, node, theme) {
+  const spec = layoutSpec(theme, "quote");
+  if (extraBoolean(spec, "minimalQuote", false)) {
+    renderMinimalQuote(slide, node, theme);
+    return;
+  }
+  const showMark = extraBoolean(spec, "quoteMark", true);
+  const markSize = extraNumber(spec, "quoteMarkSize", 72);
+  const align = specAlign(spec.titleAlign, "center");
+  const { left, right } = resolveSideMargins(spec, 1.5);
+  const quoteBar = extraBoolean(spec, "quoteBar", false);
+  const barW = extraNumber(spec, "quoteBarWidth", 0.09);
+  const attrAlign = extraString(spec, "attributionAlign", "right");
+  if (showMark && !quoteBar) {
+    slide.addText("\u201C", {
+      x: left,
+      y: 1,
+      w: 2,
+      h: 1.5,
+      fontSize: markSize,
+      fontFace: "Georgia",
+      color: theme.colors.accent,
+      bold: true
+    });
+  }
+  const quoteElement = node.elements.find((e) => e.type === "blockquote");
+  if (!quoteElement || quoteElement.type !== "blockquote") return;
+  let quoteText = quoteElement.content;
+  let attribution = "";
+  const attrMatch = quoteText.match(/\n?\s*[—–-]\s*(.+)$/);
+  if (attrMatch) {
+    attribution = attrMatch[1].trim();
+    quoteText = quoteText.slice(0, attrMatch.index).trim();
+  }
+  const textX = quoteBar ? left + barW + 0.35 : Math.max(left, showMark && !quoteBar ? 1.8 : left);
+  const textW = Math.max(4, 13.33 - textX - right);
+  const textY = extraNumber(spec, "textY", quoteBar ? 2.2 : 2.5);
+  const textH = extraNumber(spec, "textH", quoteBar ? 2.8 : 2.5);
+  if (quoteBar) {
+    addHRuler(slide, {
+      // vertical bar via tall thin rect
+      x: left,
+      y: textY,
+      w: barW,
+      h: textH,
+      color: theme.colors.accent
+    });
+  }
+  const quoteRule = extraBoolean(spec, "quoteRule", false);
+  if (quoteRule) {
+    const qRuleY = extraNumber(spec, "quoteRuleY", 2.19);
+    const qRuleW = extraNumber(spec, "quoteRuleWidth", 1.33);
+    const qRuleH = extraNumber(spec, "quoteRuleHeight", 0.04);
+    const qRuleColor = ruleColor(
+      theme,
+      extraString(spec, "quoteRuleColor", "primary")
+    );
+    const qRuleX = (13.33 - qRuleW) / 2;
+    addHRuler(slide, {
+      x: qRuleX,
+      y: qRuleY,
+      w: qRuleW,
+      h: qRuleH,
+      color: qRuleColor
+    });
+  }
+  slide.addText(quoteText, {
+    x: textX,
+    y: textY,
+    w: textW,
+    h: textH,
+    fontSize: theme.fontSize.heading,
+    fontFace: theme.fonts.body,
+    color: theme.colors.text,
+    italic: true,
+    align,
+    valign: "middle"
+  });
+  if (attribution) {
+    slide.addText(`\u2014 ${attribution}`, {
+      x: textX,
+      y: textY + textH + 0.25,
+      w: textW,
+      h: 0.55,
+      fontSize: theme.fontSize.body,
+      fontFace: theme.fonts.body,
+      color: theme.colors.secondary,
+      align: attrAlign === "left" ? "left" : attrAlign === "center" ? "center" : "right"
+    });
+  }
+}
+function renderMinimalQuote(slide, node, theme) {
+  const spec = layoutSpec(theme, "quote");
+  const lineX = extraNumber(spec, "minimalRuleX", 1.67);
+  const lineY = extraNumber(spec, "minimalRuleY", 2.78);
+  const lineH = extraNumber(spec, "minimalRuleH", 1.39);
+  const lineW = extraNumber(spec, "minimalRuleW", 0.04);
+  const color = theme.colors.divider ?? theme.colors.secondary;
+  const textX = extraNumber(spec, "minimalTextX", 2.08);
+  const textY = lineY;
+  const textW = extraNumber(spec, "minimalTextW", 9.58);
+  const textH = extraNumber(spec, "minimalTextH", 1.39);
+  const quoteElement = node.elements.find((e) => e.type === "blockquote");
+  if (!quoteElement || quoteElement.type !== "blockquote") return;
+  let quoteText = quoteElement.content;
+  let attribution = "";
+  const attrMatch = quoteText.match(/\n?\s*[—–-]\s*(.+)$/);
+  if (attrMatch) {
+    attribution = attrMatch[1].trim();
+    quoteText = quoteText.slice(0, attrMatch.index).trim();
+  }
+  slide.addShape("rect", {
+    x: lineX,
+    y: lineY,
+    w: lineW,
+    h: lineH,
+    fill: { color }
+  });
+  slide.addText(quoteText, {
+    x: textX,
+    y: textY,
+    w: textW,
+    h: textH,
+    fontSize: theme.fontSize.heading,
+    fontFace: theme.fonts.body,
+    color: theme.colors.text,
+    italic: true,
+    align: "left",
+    valign: "middle",
+    wrap: true
+  });
+  if (attribution) {
+    slide.addText(`\u2014 ${attribution}`, {
+      x: textX,
+      y: textY + textH + 0.3,
+      w: textW,
+      h: 0.4,
+      fontSize: theme.fontSize.body,
+      fontFace: theme.fonts.body,
+      color: theme.colors.secondary,
+      align: "left"
+    });
+  }
+}
+
+// src/renderer/layouts/closing.ts
+function renderClosingSlide(slide, node, theme) {
+  const spec = layoutSpec(theme, "closing");
+  if (extraBoolean(spec, "minimalClosing", false)) {
+    renderMinimalClosing(slide, node, theme);
+    return;
+  }
+  const align = specAlign(spec.titleAlign, "center");
+  const { left, right } = resolveSideMargins(spec, 0.8);
+  const contentW = Math.max(3, 13.33 - left - right);
+  const thankText = extraString(spec, "thankText", "Thank you");
+  const primary = node.title?.trim() || thankText;
+  const textY = extraNumber(spec, "textY", 2.7);
+  const showRules = extraBoolean(spec, "titleRule", false);
+  const color = ruleColor(theme, titleRuleRole(spec) === "primary" ? "primary" : titleRuleRole(spec));
+  const ruleW = extraNumber(spec, "ruleWidth", Math.min(contentW, 3.2));
+  const closingRule = extraString(spec, "closingRule", "both");
+  const ruleH = extraNumber(spec, "ruleHeight", 0.03);
+  const ruleY = extraNumber(spec, "ruleY", textY + 1.5);
+  const ruleX = align === "center" ? left + (contentW - ruleW) / 2 : align === "right" ? left + contentW - ruleW : left;
+  const drawAbove = showRules && (closingRule === "both" || closingRule === "above");
+  const drawBelow = showRules && (closingRule === "both" || closingRule === "below");
+  if (drawAbove) {
+    addHRuler(slide, { x: ruleX, y: textY - 0.35, w: ruleW, h: ruleH, color });
+  }
+  slide.addText(primary, {
+    x: left,
+    y: textY,
+    w: contentW,
+    h: 1.3,
+    fontSize: theme.fontSize.title,
+    fontFace: theme.fonts.heading,
+    color: theme.colors.primary,
+    bold: true,
+    align,
+    valign: "middle"
+  });
+  if (drawBelow) {
+    addHRuler(slide, { x: ruleX, y: ruleY, w: ruleW, h: ruleH, color });
+  }
+  const secondary = node.subtitle?.trim();
+  if (secondary) {
+    slide.addText(secondary, {
+      x: left,
+      y: textY + 1.7,
+      w: contentW,
+      h: 0.6,
+      fontSize: theme.fontSize.body,
+      fontFace: theme.fonts.body,
+      color: theme.colors.secondary,
+      align,
+      valign: "middle"
+    });
+  }
+}
+function renderMinimalClosing(slide, node, theme) {
+  const spec = layoutSpec(theme, "closing");
+  const color = theme.colors.divider ?? theme.colors.secondary;
+  const thankText = extraString(spec, "thankText", "Thank you");
+  const primary = node.title?.trim() || thankText;
+  const ruleW = extraNumber(spec, "minimalRuleW", 1.11);
+  const ruleH = extraNumber(spec, "minimalRuleH", 0.03);
+  const ruleY = extraNumber(spec, "minimalRuleY", 2.78);
+  addHRuler(slide, {
+    x: (13.33 - ruleW) / 2,
+    y: ruleY,
+    w: ruleW,
+    h: ruleH,
+    color
+  });
+  slide.addText(primary, {
+    x: extraNumber(spec, "minimalThankX", 2.5),
+    y: extraNumber(spec, "minimalThankY", 3.06),
+    w: extraNumber(spec, "minimalThankW", 8.33),
+    h: 0.83,
+    fontSize: theme.fontSize.title,
+    fontFace: theme.fonts.heading,
+    color: theme.colors.primary,
+    bold: true,
+    align: "center",
+    valign: "middle"
+  });
+  const contact = node.subtitle?.trim() ?? "";
+  if (contact) {
+    slide.addText(contact, {
+      x: extraNumber(spec, "minimalContactX", 3.89),
+      y: extraNumber(spec, "minimalContactY", 4.31),
+      w: extraNumber(spec, "minimalContactW", 5.56),
+      h: 0.33,
+      fontSize: theme.fontSize.body,
+      fontFace: theme.fonts.body,
+      color: theme.colors.secondary,
+      align: "center",
+      valign: "middle"
+    });
+  }
+}
+
+// src/renderer/layouts/image-pages.ts
+import { readFileSync as readFileSync2 } from "fs";
+var SLIDE_W2 = 13.33;
+var SLIDE_H2 = 7.5;
+var IMAGE_MIME2 = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  bmp: "image/bmp",
+  svg: "image/svg+xml"
+};
+function specFor(theme, slots) {
+  if (slots === 1) return layoutSpec(theme, "imageSingle");
+  if (slots === 2) return layoutSpec(theme, "imageDouble");
+  return layoutSpec(theme, "imageTriple");
+}
+function pickImages(node, slots) {
+  const images = node.elements.filter((e) => e.type === "image").slice(0, slots);
+  const captions = node.elements.filter((e) => e.type === "text").map((e) => e.type === "text" ? e.content.trim() : "").filter((t) => t.length > 0 && t.length <= 40);
+  return { images, captions };
+}
+async function placeImage(slide, element, box, node, ctx) {
+  try {
+    const resolved = await ctx.resolveImage(element.src);
+    if (!resolved.ok) {
+      log.warn(`[${node.title ?? "slide"}] ${resolved.error}`);
+      return;
+    }
+    const fileData = readFileSync2(resolved.path);
+    const imgSize = getImageSize(fileData) ?? { width: 6, height: 3 };
+    const fitted = fitInBox(imgSize, box.w, box.h);
+    const ext = resolved.path.split(".").pop()?.toLowerCase() ?? "png";
+    const mime = IMAGE_MIME2[ext] ?? "image/png";
+    const data = `${mime};base64,${fileData.toString("base64")}`;
+    if (ext === "webp") {
+      log.warn(
+        `[${node.title ?? "slide"}] WebP does not render in PowerPoint for the web or Office 2019 and earlier \u2014 some recipients may see a broken image (${element.src})`
+      );
+    }
+    const x = box.x + (box.w - fitted.width) / 2;
+    const y = box.y + (box.h - fitted.height) / 2;
+    slide.addImage({
+      data,
+      altText: element.alt || element.src,
+      x,
+      y,
+      w: fitted.width,
+      h: fitted.height
+    });
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : "unknown";
+    log.warn(`[${node.title ?? "slide"}] image error: ${reason}`);
+    slide.addText(`[Image error: ${reason}]`, {
+      x: box.x,
+      y: box.y,
+      w: box.w,
+      h: 0.4,
+      fontSize: 12,
+      color: "FF0000"
+    });
+  }
+}
+async function renderImageSlide(slide, node, theme, ctx, slots) {
+  const spec = specFor(theme, slots);
+  if (extraBoolean(spec, "minimalImage", false)) {
+    await renderMinimalImage(slide, node, theme, ctx, slots, spec);
+    return;
+  }
+  const { left, right } = resolveSideMargins(spec, 0.6);
+  const titleH = specNumber(spec.titleHeight, 0.9);
+  const titleAlign = specAlign(spec.titleAlign, "left");
+  const contentW = Math.max(2, SLIDE_W2 - left - right);
+  let top = extraNumber(spec, "titleY", 0.3);
+  if (node.title) {
+    if (extraBoolean(spec, "titleRule", true)) {
+      const rh = titleRuleHeight(spec, 0.04);
+      const ruleW = extraNumber(spec, "titleRuleWidth", contentW);
+      addHRuler(slide, {
+        x: left,
+        y: top + titleH - rh - 0.01,
+        w: ruleW,
+        h: rh,
+        color: ruleColor(theme, titleRuleRole(spec))
+      });
+    }
+    slide.addText(node.title, {
+      x: left,
+      y: top,
+      w: contentW,
+      h: titleH,
+      fontSize: theme.fontSize.heading,
+      fontFace: theme.fonts.heading,
+      color: theme.colors.primary,
+      bold: true,
+      align: titleAlign === "center" ? "center" : "left",
+      valign: "bottom"
+    });
+    top = top + titleH + 0.2;
+  }
+  const bottom = 0.45;
+  const zoneH = SLIDE_H2 - top - bottom;
+  const { images, captions } = pickImages(node, slots);
+  if (images.length === 0) {
+    const fallback = captions[0] ?? node.title ?? "No image";
+    slide.addText(fallback, {
+      x: left,
+      y: top,
+      w: contentW,
+      h: zoneH,
+      fontSize: theme.fontSize.body,
+      fontFace: theme.fonts.body,
+      color: theme.colors.secondary,
+      align: "center",
+      valign: "middle"
+    });
+    return;
+  }
+  const gap = 0.25;
+  const captionH = 0.35;
+  const cellW = (contentW - gap * (slots - 1)) / slots;
+  const cellH = zoneH - captionH;
+  for (let i = 0; i < images.length; i++) {
+    const x = left + i * (cellW + gap);
+    await placeImage(
+      slide,
+      images[i],
+      { x, y: top, w: cellW, h: cellH },
+      node,
+      ctx
+    );
+    const caption = images[i].alt?.trim() || captions[i];
+    if (caption) {
+      slide.addText(caption, {
+        x,
+        y: top + cellH + 0.05,
+        w: cellW,
+        h: captionH,
+        fontSize: theme.fontSize.small,
+        fontFace: theme.fonts.body,
+        color: theme.colors.secondary,
+        align: "center",
+        valign: "top"
+      });
+    }
+  }
+}
+async function renderMinimalImage(slide, node, theme, ctx, slots, spec) {
+  const margin = specNumber(spec.margin, 0.83);
+  const boxX = margin;
+  const boxY = extraNumber(spec, "minimalImageY", 1.33);
+  const boxH = extraNumber(spec, "minimalImageH", 5.28);
+  const contentW = 13.33 - margin * 2;
+  const lineColor = theme.colors.divider ?? theme.colors.secondary;
+  if (node.title) {
+    slide.addText(node.title, {
+      x: boxX,
+      y: extraNumber(spec, "minimalTitleY", 0.5),
+      w: contentW,
+      h: 0.44,
+      fontSize: theme.fontSize.heading,
+      fontFace: theme.fonts.heading,
+      color: theme.colors.primary,
+      bold: true,
+      align: "left",
+      valign: "middle"
+    });
+    addHRuler(slide, {
+      x: boxX,
+      y: extraNumber(spec, "minimalTitleRuleY", 1.03),
+      w: extraNumber(spec, "minimalTitleRuleW", 0.56),
+      h: extraNumber(spec, "minimalTitleRuleH", 0.03),
+      color: lineColor
+    });
+  }
+  const gaps = { 1: 0, 2: 0.28, 3: 0.21 };
+  const gap = gaps[slots];
+  const cellW = (contentW - gap * (slots - 1)) / slots;
+  const { images } = pickImages(node, slots);
+  for (let i = 0; i < slots; i++) {
+    const x = boxX + i * (cellW + gap);
+    slide.addShape("rect", {
+      x,
+      y: boxY,
+      w: cellW,
+      h: boxH,
+      fill: { transparency: 100 },
+      line: { color: lineColor, width: 0.01, dashType: "dash" }
+    });
+    if (images[i]) {
+      await placeImage(slide, images[i], { x, y: boxY, w: cellW, h: boxH }, node, ctx);
+    } else {
+      slide.addText("Image", {
+        x: x + (cellW - 2.22) / 2,
+        y: boxY + (boxH - 0.56) / 2,
+        w: 2.22,
+        h: 0.56,
+        fontSize: theme.fontSize.small,
+        fontFace: theme.fonts.body,
+        color: lineColor,
+        align: "center",
+        valign: "middle"
+      });
+    }
   }
 }
 
@@ -1165,7 +2339,7 @@ async function renderSlideLayout(slide, node, theme, ctx) {
       renderTitleSlide(slide, node, theme);
       break;
     case "section":
-      renderSectionSlide(slide, node, theme);
+      renderSectionSlide(slide, node, theme, ctx);
       break;
     case "code":
       await renderCodeSlide(slide, node, theme, ctx);
@@ -1173,6 +2347,18 @@ async function renderSlideLayout(slide, node, theme, ctx) {
     case "quote":
       renderQuoteSlide(slide, node, theme);
       break;
+    case "closing":
+      renderClosingSlide(slide, node, theme);
+      break;
+    case "image-single":
+      await renderImageSlide(slide, node, theme, ctx, 1);
+      break;
+    case "image-double":
+      await renderImageSlide(slide, node, theme, ctx, 2);
+      break;
+    case "image-triple":
+      await renderImageSlide(slide, node, theme, ctx, 3);
+      break;
     case "content":
     default:
       await renderContentSlide(slide, node, theme, ctx);
@@ -1181,18 +2367,45 @@ async function renderSlideLayout(slide, node, theme, ctx) {
   if (node.notes) {
     slide.addNotes(node.notes);
   }
-  if (node.layout !== "title" && node.layout !== "closing" && node.layout !== "blank") {
+  const sectionSpec = layoutSpec(theme, "section");
+  const sectionNoFooter = extraString(sectionSpec, "footer", "on") === "off";
+  if (node.layout !== "title" && node.layout !== "closing" && node.layout !== "blank" && !(node.layout === "section" && sectionNoFooter)) {
     const footerText = renderFooter(node, theme, ctx);
+    const footerSpec = layoutSpec(theme, "footer");
+    const sides = resolveSideMargins(
+      footerSpec,
+      specNumber(theme.layouts?.content?.margin, 0.6)
+    );
+    const marginLeft = footerSpec.extra?.marginLeft !== void 0 ? sides.left : specNumber(
+      theme.layouts?.content?.extra?.marginLeft,
+      specNumber(theme.layouts?.content?.margin, sides.left)
+    );
+    const marginRight = footerSpec.extra?.marginRight !== void 0 ? sides.right : specNumber(
+      theme.layouts?.content?.extra?.marginRight,
+      specNumber(theme.layouts?.content?.margin, sides.right)
+    );
+    const contentW = Math.max(2, 13.33 - marginLeft - marginRight);
+    const showDivider = theme.styles?.footerDivider ?? footerSpec.footerDivider ?? false;
+    const footerAlign = extraString(footerSpec, "footerAlign", "right");
+    if (showDivider) {
+      slide.addShape("rect", {
+        x: marginLeft,
+        y: extraNumber(footerSpec, "dividerY", 7.08),
+        w: contentW,
+        h: 0.015,
+        fill: { color: theme.colors.divider ?? theme.colors.secondary }
+      });
+    }
     if (footerText) {
       slide.addText(footerText, {
-        x: 0.6,
-        y: 7.16,
-        w: 12.13,
+        x: marginLeft,
+        y: extraNumber(footerSpec, "footerY", 7.16),
+        w: contentW,
         h: 0.28,
         fontSize: theme.fontSize.small - 1,
         fontFace: theme.fonts.body,
         color: theme.colors.secondary,
-        align: "right",
+        align: footerAlign,
         valign: "middle"
       });
     }
@@ -1206,6 +2419,93 @@ function renderFooter(node, theme, ctx) {
 
 // src/renderer/code-highlighter.ts
 import { createHighlighter } from "shiki";
+
+// src/utils/gradient.ts
+import { deflateSync } from "zlib";
+var CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) {
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    }
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+function crc32(bytes) {
+  let crc = 4294967295;
+  for (let i = 0; i < bytes.length; i++) {
+    crc = CRC_TABLE[(crc ^ bytes[i]) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function pngChunk(type, data) {
+  const length = Buffer.alloc(4);
+  length.writeUInt32BE(data.length);
+  const payload = Buffer.concat([Buffer.from(type, "latin1"), Buffer.from(data)]);
+  const crc = Buffer.alloc(4);
+  crc.writeUInt32BE(crc32(payload));
+  return Buffer.concat([length, payload, crc]);
+}
+function encodePngRgb(width, height, pixelAt) {
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(width, 0);
+  ihdr.writeUInt32BE(height, 4);
+  ihdr[8] = 8;
+  ihdr[9] = 2;
+  const raw = Buffer.alloc(height * (1 + width * 3));
+  let offset = 0;
+  for (let y = 0; y < height; y++) {
+    raw[offset++] = 0;
+    for (let x = 0; x < width; x++) {
+      const [r, g, b] = pixelAt(x, y);
+      raw[offset++] = r;
+      raw[offset++] = g;
+      raw[offset++] = b;
+    }
+  }
+  const idat = deflateSync(raw, { level: 9 });
+  return Buffer.concat([
+    Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]),
+    pngChunk("IHDR", ihdr),
+    pngChunk("IDAT", new Uint8Array(idat)),
+    pngChunk("IEND", new Uint8Array(0))
+  ]);
+}
+function hexToRgb(hex) {
+  let s = hex.replace(/^#/, "");
+  if (s.length === 3) s = s.split("").map((ch) => ch + ch).join("");
+  if (!/^[0-9a-fA-F]{6}$/.test(s)) throw new Error(`Invalid hex color: ${hex}`);
+  return [
+    parseInt(s.slice(0, 2), 16),
+    parseInt(s.slice(2, 4), 16),
+    parseInt(s.slice(4, 6), 16)
+  ];
+}
+function createLinearGradientPng(from, to, angleDeg = 180, options = {}) {
+  const width = options.width ?? 192;
+  const height = options.height ?? 108;
+  const angle = angleDeg * Math.PI / 180;
+  const dx = Math.sin(angle);
+  const dy = -Math.cos(angle);
+  const extent = (Math.abs(dx) + Math.abs(dy)) / 2;
+  const c1 = hexToRgb(from);
+  const c2 = hexToRgb(to);
+  return encodePngRgb(width, height, (x, y) => {
+    const px = x / (width - 1) - 0.5;
+    const py = y / (height - 1) - 0.5;
+    let t = 0.5 + (px * dx + py * dy) / (2 * extent);
+    t = t < 0 ? 0 : t > 1 ? 1 : t;
+    return [
+      Math.round(c1[0] + (c2[0] - c1[0]) * t),
+      Math.round(c1[1] + (c2[1] - c1[1]) * t),
+      Math.round(c1[2] + (c2[2] - c1[2]) * t)
+    ];
+  });
+}
+
+// src/renderer/code-highlighter.ts
 var highlighterInstance = null;
 async function getHighlighter() {
   if (!highlighterInstance) {
@@ -1244,11 +2544,21 @@ function cleanColor(color) {
   if (!color) return "E2E8F0";
   return color.replace(/^#/, "");
 }
+function tint(hex, amount) {
+  const mix = (channel) => Math.round(channel + (255 - channel) * amount).toString(16).padStart(2, "0");
+  const [r, g, b] = hexToRgb(hex);
+  return `${mix(r)}${mix(g)}${mix(b)}`;
+}
+function highlightBackgroundFor(theme) {
+  const explicit = theme.colors.highlightBackground;
+  if (explicit) return explicit;
+  return tint(theme.colors.codeBackground, 0.25);
+}
 async function highlightCode(code, language, theme, highlightLines = []) {
   const highlighter = await getHighlighter();
   const runs = [];
   const shikiThemeName = theme.shikiTheme ?? "github-dark";
-  const highlightColor = theme.colors.highlightBackground ?? "FFF3C4";
+  const highlightColor = highlightBackgroundFor(theme);
   try {
     const loadedLangs = highlighter.getLoadedLanguages();
     if (!loadedLangs.includes(language)) {
@@ -1318,27 +2628,113 @@ async function highlightCode(code, language, theme, highlightLines = []) {
 }
 
 // src/renderer/image-handler.ts
-import { existsSync, writeFileSync } from "fs";
+import { existsSync, readFileSync as readFileSync3, writeFileSync } from "fs";
 import { resolve } from "path";
 import { tmpdir } from "os";
 import { join } from "path";
 import { randomUUID } from "crypto";
-var REMOTE_FETCH_TIMEOUT_MS = 1e4;
-async function resolveImage(src, basePath) {
-  try {
-    if (src.startsWith("data:")) {
-      const match = src.match(/^data:image\/(\w+);base64,(.+)/);
-      if (match) {
-        const ext = match[1];
-        const base64 = match[2];
-        const tmpPath = join(tmpdir(), `mfly-${randomUUID().slice(0, 8)}.${ext}`);
-        writeFileSync(tmpPath, Buffer.from(base64, "base64"));
-        return { ok: true, path: tmpPath };
-      }
-      return { ok: false, error: `Unsupported data URI: ${src.slice(0, 48)}` };
+
+// src/diagrams/svg-to-png.ts
+function ensureSvgNamespace(svg) {
+  if (svg.includes("xmlns=")) return svg;
+  return svg.replace(/<svg\b([^>]*)>/i, '<svg xmlns="http://www.w3.org/2000/svg" $1>');
+}
+function normalizeSvg(svg) {
+  let clean = ensureSvgNamespace(svg.trim());
+  clean = clean.replace(/(<svg\b[^>]*)\s+width=["'][^"']*["']/gi, "$1");
+  clean = clean.replace(/(<svg\b[^>]*)\s+height=["'][^"']*["']/gi, "$1");
+  const viewBoxMatch = clean.match(/viewBox\s*=\s*["']([^"']+)["']/i);
+  let frameUsable = true;
+  if (viewBoxMatch) {
+    const parts = viewBoxMatch[1].trim().split(/[\s,]+/).map(Number);
+    if (parts.length === 4 && parts[2] > 0 && parts[3] > 0) {
+      const w = parts[2];
+      const h = parts[3];
+      clean = clean.replace(/<svg\b([^>]*)>/i, `<svg width="${w}" height="${h}" $1>`);
+    } else {
+      frameUsable = false;
     }
-    if (src.startsWith("http://") || src.startsWith("https://")) {
-      let response;
+  } else {
+    clean = clean.replace(/<svg\b([^>]*)>/i, `<svg width="800" height="600" viewBox="0 0 800 600" $1>`);
+  }
+  return { svg: clean, frameUsable };
+}
+async function svgToPng(svg, width = 800) {
+  const { svg: normalized, frameUsable } = normalizeSvg(svg);
+  const { Resvg } = await import("@resvg/resvg-js");
+  const resvg = new Resvg(normalized, {
+    fitTo: { mode: "width", value: width }
+  });
+  if (frameUsable) reframeToContent(resvg);
+  const pngData = resvg.render();
+  return Buffer.from(pngData.asPng());
+}
+var SVG_EMBED_WIDTH = 1200;
+async function rasterizeSvg(svg, width) {
+  const { Resvg } = await import("@resvg/resvg-js");
+  const resvg = new Resvg(ensureSvgNamespace(svg.trim()), {
+    fitTo: { mode: "width", value: width }
+  });
+  return Buffer.from(resvg.render().asPng());
+}
+var CONTENT_PADDING = 4;
+var MAX_ASPECT_SHIFT = 3;
+function reframeToContent(resvg, padding = CONTENT_PADDING) {
+  const bbox = resvg.getBBox();
+  if (!bbox || !(bbox.width > 0) || !(bbox.height > 0)) return;
+  const frameAspect = resvg.width / resvg.height;
+  if (!Number.isFinite(frameAspect) || frameAspect <= 0) return;
+  const contentAspect = bbox.width / bbox.height;
+  const shift = Math.max(contentAspect / frameAspect, frameAspect / contentAspect);
+  if (shift > MAX_ASPECT_SHIFT) return;
+  try {
+    bbox.x -= padding;
+    bbox.y -= padding;
+    bbox.width += padding * 2;
+    bbox.height += padding * 2;
+  } catch {
+  }
+  resvg.cropByBBox(bbox);
+}
+
+// src/renderer/image-handler.ts
+var REMOTE_FETCH_TIMEOUT_MS = 1e4;
+async function resolveImage(src, basePath) {
+  const located = await locateImage(src, basePath);
+  if (!located.ok) return located;
+  return rasterizeIfSvg(located);
+}
+async function rasterizeIfSvg(resolved) {
+  if (!resolved.ok) return resolved;
+  try {
+    const data = readFileSync3(resolved.path);
+    if (!isSvgImage(data)) return resolved;
+    const png = await rasterizeSvg(data.toString("utf8"), SVG_EMBED_WIDTH);
+    const tmpPath = join(tmpdir(), `mfly-${randomUUID().slice(0, 8)}.png`);
+    writeFileSync(tmpPath, png);
+    return { ok: true, path: tmpPath };
+  } catch (err) {
+    log.warn(
+      `Could not rasterize ${resolved.path}: ${err instanceof Error ? err.message : String(err)} \u2014 embedding the SVG as-is`
+    );
+    return resolved;
+  }
+}
+async function locateImage(src, basePath) {
+  try {
+    if (src.startsWith("data:")) {
+      const match = src.match(/^data:image\/([\w.+-]+);base64,(.+)/);
+      if (match) {
+        const ext = match[1].split("+")[0];
+        const base64 = match[2];
+        const tmpPath = join(tmpdir(), `mfly-${randomUUID().slice(0, 8)}.${ext}`);
+        writeFileSync(tmpPath, Buffer.from(base64, "base64"));
+        return { ok: true, path: tmpPath };
+      }
+      return { ok: false, error: `Unsupported data URI: ${src.slice(0, 48)}` };
+    }
+    if (src.startsWith("http://") || src.startsWith("https://")) {
+      let response;
       try {
         response = await fetch(src, { signal: AbortSignal.timeout(REMOTE_FETCH_TIMEOUT_MS) });
       } catch (err) {
@@ -1368,39 +2764,6 @@ async function resolveImage(src, basePath) {
   }
 }
 
-// src/diagrams/svg-to-png.ts
-function normalizeSvg(svg) {
-  let clean = svg.trim();
-  if (!clean.includes("xmlns=")) {
-    clean = clean.replace(/<svg\b([^>]*)>/i, '<svg xmlns="http://www.w3.org/2000/svg" $1>');
-  }
-  clean = clean.replace(/(<svg\b[^>]*)\s+width=["'][^"']*["']/gi, "$1");
-  clean = clean.replace(/(<svg\b[^>]*)\s+height=["'][^"']*["']/gi, "$1");
-  clean = clean.replace(/<marker\b[\s\S]*?<\/marker>/gi, "");
-  clean = clean.replace(/\s+marker-(end|start|mid)=["'][^"']*["']/gi, "");
-  const viewBoxMatch = clean.match(/viewBox\s*=\s*["']([^"']+)["']/i);
-  if (viewBoxMatch) {
-    const parts = viewBoxMatch[1].trim().split(/[\s,]+/).map(Number);
-    if (parts.length === 4 && parts[2] > 0 && parts[3] > 0) {
-      const w = parts[2];
-      const h = parts[3];
-      clean = clean.replace(/<svg\b([^>]*)>/i, `<svg width="${w}" height="${h}" $1>`);
-    }
-  } else {
-    clean = clean.replace(/<svg\b([^>]*)>/i, `<svg width="800" height="600" viewBox="0 0 800 600" $1>`);
-  }
-  return clean;
-}
-async function svgToPng(svg, width = 800) {
-  const normalized = normalizeSvg(svg);
-  const { Resvg } = await import("@resvg/resvg-js");
-  const resvg = new Resvg(normalized, {
-    fitTo: { mode: "width", value: width }
-  });
-  const pngData = resvg.render();
-  return Buffer.from(pngData.asPng());
-}
-
 // src/diagrams/theme.ts
 function isDarkColor(hex) {
   const clean = hex.replace(/^#/, "");
@@ -1737,25 +3100,55 @@ function contentBBox(root) {
   if (!Number.isFinite(minX)) return null;
   return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
 }
+var browserGlobals = [];
+function installBrowserGlobals() {
+  const saved = browserGlobals.map(
+    ([key]) => [key, Object.getOwnPropertyDescriptor(globalThis, key)]
+  );
+  for (const [key, value] of browserGlobals) {
+    try {
+      Object.defineProperty(globalThis, key, {
+        value,
+        configurable: true,
+        writable: true
+      });
+    } catch {
+      globalThis[key] = value;
+    }
+  }
+  return () => {
+    for (const [key, descriptor] of saved) {
+      if (descriptor) {
+        Object.defineProperty(globalThis, key, descriptor);
+      } else {
+        delete globalThis[key];
+      }
+    }
+  };
+}
 var MermaidDiagramRenderer = class {
   type = "mermaid";
   renderCounter = 0;
   async initialize() {
     if (initialized) return;
+    browserGlobals = [];
     const { JSDOM } = await import("jsdom");
     const dom = new JSDOM("<!DOCTYPE html><html><body></body></html>", {
       pretendToBeVisual: true
     });
+    const jsdomGetComputedStyle = dom.window.getComputedStyle.bind(dom.window);
+    dom.window.getComputedStyle = ((element, pseudo) => {
+      const style = jsdomGetComputedStyle(element, pseudo);
+      const read = style.getPropertyValue.bind(style);
+      style.getPropertyValue = (property) => {
+        const value = read(property);
+        if (value !== "" && value != null) return value;
+        return property.startsWith("padding") ? "0px" : value;
+      };
+      return style;
+    });
     const assignGlobal = (key, value) => {
-      try {
-        Object.defineProperty(globalThis, key, {
-          value,
-          configurable: true,
-          writable: true
-        });
-      } catch {
-        globalThis[key] = value;
-      }
+      browserGlobals.push([key, value]);
     };
     assignGlobal("window", dom.window);
     assignGlobal("document", dom.window.document);
@@ -1813,25 +3206,36 @@ var MermaidDiagramRenderer = class {
       y: b.y,
       width: b.width,
       height: b.height,
+      toJSON: () => ({})
+    });
+    const toDomRect = (b) => ({
+      ...toRect(b),
       top: b.y,
       right: b.x + b.width,
       bottom: b.y + b.height,
-      left: b.x,
-      toJSON: () => ({})
+      left: b.x
     });
+    const isMeasuredNode = (el) => {
+      const parent = el.parentElement;
+      if (!parent) return false;
+      return (parent.getAttribute("class") ?? "").split(/\s+/).includes("nodes");
+    };
     const polyfillBBox = function() {
       const tag = this.tagName ? this.tagName.toLowerCase() : "";
       if (tag === "style" || tag === "script" || tag === "defs" || tag === "clippath" || tag === "marker") {
         return toRect({ x: 0, y: 0, width: 0, height: 0 });
       }
-      if (tag === "svg") {
+      if (tag === "svg" || isMeasuredNode(this)) {
         const box = contentBBox(this);
         if (box) return toRect(box);
       }
       const text = getDirectText(this);
       const width = text ? Math.max(30, text.length * 9 + 20) : 80;
       const height = text ? 28 : 40;
-      return toRect({ x: 0, y: 0, width, height });
+      const isText = tag === "text" || tag === "tspan";
+      const anchor = parseFloat(this.getAttribute("x") ?? "");
+      const x = isText ? (Number.isFinite(anchor) ? anchor : 0) - width / 2 : 0;
+      return toRect({ x, y: 0, width, height });
     };
     if (!dom.window.SVGElement.prototype.getBBox) {
       dom.window.SVGElement.prototype.getBBox = polyfillBBox;
@@ -1840,7 +3244,10 @@ var MermaidDiagramRenderer = class {
       dom.window.Element.prototype.getBBox = polyfillBBox;
     }
     if (!dom.window.Element.prototype.getBoundingClientRect) {
-      dom.window.Element.prototype.getBoundingClientRect = polyfillBBox;
+      dom.window.Element.prototype.getBoundingClientRect = (function() {
+        const box = polyfillBBox.call(this);
+        return toDomRect(box);
+      });
     }
     const computeTextLength = function() {
       const text = getDirectText(this);
@@ -1944,8 +3351,13 @@ var MermaidDiagramRenderer = class {
         dispatchEvent: () => false
       });
     }
-    const mermaid = (await import("mermaid")).default;
-    mermaid.initialize(this.buildConfig());
+    const restore = installBrowserGlobals();
+    try {
+      const mermaid = (await import("mermaid")).default;
+      mermaid.initialize(this.buildConfig());
+    } finally {
+      restore();
+    }
     initialized = true;
   }
   buildConfig(theme) {
@@ -1963,22 +3375,30 @@ var MermaidDiagramRenderer = class {
         background: "transparent"
       },
       flowchart: { htmlLabels: false, curve: "basis", useMaxWidth: false },
-      sequence: { useMaxWidth: false }
+      sequence: { useMaxWidth: false },
+      // jsdom has no layout engine: offsetWidth is 0 rather than undefined, so
+      // mermaid's own "no parent width" fallback never fires and the gantt chart
+      // ends up with a zero-width viewBox. Pin the viewport width instead.
+      gantt: { useWidth: 1200 }
     };
   }
   async render(code, theme) {
     await this.initialize();
     const mermaid = (await import("mermaid")).default;
     const id = `mfly-mermaid-${Date.now()}-${this.renderCounter++}`;
-    mermaid.initialize(this.buildConfig(theme));
+    let svg;
+    const restore = installBrowserGlobals();
     try {
-      const { svg } = await mermaid.render(id, code.trim());
-      return svgToPng(svg, 1200);
+      mermaid.initialize(this.buildConfig(theme));
+      ({ svg } = await mermaid.render(id, code.trim()));
     } catch (err) {
       throw new Error(
         `Mermaid render failed: ${err instanceof Error ? err.message : String(err)}`
       );
+    } finally {
+      restore();
     }
+    return svgToPng(svg, 1200);
   }
 };
 
@@ -2058,28 +3478,213 @@ var EChartsDiagramRenderer = class {
   }
 };
 
+// src/diagrams/plantuml-renderer.ts
+var RENDER_WIDTH = 1200;
+var RENDER_TIMEOUT_MS = 3e4;
+function originalLine(reported, prepared) {
+  if (reported === void 0) return void 0;
+  return reported > prepared.shiftAfter ? reported - prepared.lineShift : reported;
+}
+async function withEngineLogsMuted(fn) {
+  const originals = { log: console.log, info: console.info, debug: console.debug };
+  const sink = process.env.MFLY_DEBUG ? (...args) => console.error(...args) : () => {
+  };
+  console.log = sink;
+  console.info = sink;
+  console.debug = sink;
+  try {
+    return await fn();
+  } finally {
+    console.log = originals.log;
+    console.info = originals.info;
+    console.debug = originals.debug;
+  }
+}
+function fontValue(theme) {
+  return `"${theme.fonts.cjk.replace(/"/g, "")}"`;
+}
+var LINE_STROKE = "stroke:#181818;stroke-width:0.5;";
+var LIFELINE_STROKE = `${LINE_STROKE}stroke-dasharray:5,5;`;
+function restoreLineStrokes(svg, diagramType) {
+  const dashed = /sequence/i.test(diagramType ?? "");
+  return svg.replace(
+    /<line\b([^>]*?)\/>/g,
+    (match, attributes) => /\b(stroke|style)=/.test(attributes) ? match : `<line${attributes} style="${dashed ? LIFELINE_STROKE : LINE_STROKE}"/>`
+  );
+}
+var PlantUmlDiagramRenderer = class {
+  type = "plantuml";
+  engine = null;
+  async initialize() {
+    if (this.engine) return;
+    this.engine = await withEngineLogsMuted(async () => {
+      const globalWithViz = globalThis;
+      if (!globalWithViz.Viz) {
+        const vizModule = await import("@viz-js/viz");
+        let instancePromise = null;
+        globalWithViz.Viz = {
+          instance: () => instancePromise ??= vizModule.instance()
+        };
+      }
+      return import("@plantuml/mcp-js/engine.js");
+    });
+  }
+  /**
+   * PlantUML has no dark-mode switch in this build, so the palette is injected
+   * as skinparams — the same shape as the DOT renderer's attribute prelude.
+   * Anything the author writes after the prelude still wins.
+   *
+   * `backgroundColor transparent` is stated explicitly rather than left to the
+   * default: PlantUML otherwise writes `background:#FFFFFF` into the SVG style,
+   * which only stays invisible because the rasterizer happens to ignore it.
+   */
+  skinparams(theme) {
+    const lines = ["skinparam backgroundColor transparent"];
+    if (theme) {
+      lines.push(`skinparam defaultFontName ${fontValue(theme)}`);
+    }
+    if (!isDarkTheme(theme)) {
+      lines.push("skinparam defaultFontColor #1F2328");
+      return lines.join("\n");
+    }
+    lines.push(
+      "skinparam defaultFontColor #C9D1D9",
+      "skinparam shadowing false",
+      // Boxes are light by default, so the fills have to move with the text or
+      // labels end up dark-on-dark.
+      "skinparam classBackgroundColor #1F2937",
+      "skinparam classBorderColor #6B7280",
+      "skinparam classFontColor #E5E7EB",
+      "skinparam classAttributeFontColor #CBD5E1",
+      "skinparam participantBackgroundColor #1F2937",
+      "skinparam participantBorderColor #6B7280",
+      "skinparam actorBackgroundColor #1F2937",
+      "skinparam actorBorderColor #6B7280",
+      "skinparam sequenceArrowColor #9CA3AF",
+      "skinparam sequenceLifeLineBorderColor #6B7280",
+      "skinparam noteBackgroundColor #374151",
+      "skinparam noteBorderColor #6B7280",
+      "skinparam activityBackgroundColor #1F2937",
+      "skinparam activityBorderColor #6B7280",
+      "skinparam activityDiamondBackgroundColor #1F2937",
+      "skinparam activityDiamondBorderColor #6B7280",
+      "skinparam stateBackgroundColor #1F2937",
+      "skinparam stateBorderColor #6B7280",
+      "skinparam componentBackgroundColor #1F2937",
+      "skinparam componentBorderColor #6B7280",
+      "skinparam componentFontColor #E5E7EB"
+    );
+    return lines.join("\n");
+  }
+  /**
+   * Drop `!theme` directives and inject the theme prelude.
+   *
+   * `!theme` needs themes.js, which the headless build does not ship — the
+   * directive is ignored with a warning anyway. Dropping it up front also avoids
+   * the theme loader entirely, which is what can leave renderSvg without ever
+   * calling back (a second *distinct* theme in one process is enough).
+   */
+  prepare(code, theme) {
+    const warnings = [];
+    const kept = [];
+    for (const line of code.trim().split("\n")) {
+      if (/^\s*!theme\b/i.test(line)) {
+        warnings.push(
+          `"${line.trim()}" ignored \u2014 the bundled PlantUML engine ships no themes; use skinparam instead`
+        );
+        continue;
+      }
+      kept.push(line);
+    }
+    const prelude = this.skinparams(theme);
+    const preludeLines = prelude.split("\n").length;
+    const startIndex = kept.findIndex((line) => /^\s*@start\w+/i.test(line));
+    if (startIndex === -1) {
+      return {
+        source: `@startuml
+${prelude}
+${kept.join("\n")}
+@enduml`,
+        warnings,
+        lineShift: preludeLines + 1,
+        shiftAfter: 1
+      };
+    }
+    kept.splice(startIndex + 1, 0, prelude);
+    if (!kept.some((line) => /^\s*@end\w+/i.test(line))) {
+      const kind = kept[startIndex].match(/^\s*@start(\w+)/i)?.[1] ?? "uml";
+      kept.push(`@end${kind}`);
+    }
+    return {
+      source: kept.join("\n"),
+      warnings,
+      lineShift: preludeLines,
+      shiftAfter: startIndex + 1
+    };
+  }
+  async render(code, theme) {
+    await this.initialize();
+    const prepared = this.prepare(code, theme);
+    for (const warning of prepared.warnings) log.warn(`[PlantUML] ${warning}`);
+    try {
+      const result = await this.renderToSvg(prepared.source);
+      if (!result.valid || !result.svg) {
+        const line = originalLine(result.errorLineNumber, prepared);
+        const at = line ? ` (line ${line})` : "";
+        throw new Error(`${result.errorMessage ?? "invalid diagram"}${at}`);
+      }
+      return svgToPng(restoreLineStrokes(result.svg, result.diagramType), RENDER_WIDTH);
+    } catch (err) {
+      throw new Error(
+        `PlantUML render failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  async renderToSvg(source) {
+    const engine = this.engine;
+    const json = await withEngineLogsMuted(
+      () => new Promise((resolve4, reject) => {
+        let settled = false;
+        const timer = setTimeout(() => {
+          if (settled) return;
+          settled = true;
+          reject(new Error(`timed out after ${RENDER_TIMEOUT_MS / 1e3}s`));
+        }, RENDER_TIMEOUT_MS);
+        engine.renderSvg(source, (result) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          resolve4(result);
+        });
+      })
+    );
+    try {
+      return JSON.parse(json);
+    } catch {
+      throw new Error("engine returned malformed JSON");
+    }
+  }
+};
+
 // src/diagrams/index.ts
-var DIAGRAM_LANGUAGES2 = {
+var RENDERERS = {
   mermaid: () => new MermaidDiagramRenderer(),
   dot: () => new GraphvizDiagramRenderer(),
-  graphviz: () => new GraphvizDiagramRenderer(),
-  echarts: () => new EChartsDiagramRenderer()
+  echarts: () => new EChartsDiagramRenderer(),
+  plantuml: () => new PlantUmlDiagramRenderer()
 };
 var instances = /* @__PURE__ */ new Map();
 function getOrCreate(language) {
-  const key = language === "graphviz" ? "dot" : language;
-  if (instances.has(key)) return instances.get(key);
-  const factory = DIAGRAM_LANGUAGES2[language];
-  if (!factory) return void 0;
-  const renderer = factory();
-  instances.set(key, renderer);
+  const canonical = normalizeDiagramLanguage(language);
+  if (!canonical) return void 0;
+  const cached = instances.get(canonical);
+  if (cached) return cached;
+  const renderer = RENDERERS[canonical]();
+  instances.set(canonical, renderer);
   return renderer;
 }
-function isDiagramLanguage(language) {
-  return language.toLowerCase() in DIAGRAM_LANGUAGES2;
-}
 async function renderDiagram(language, code, theme) {
-  const renderer = getOrCreate(language.toLowerCase());
+  const renderer = getOrCreate(language);
   if (!renderer) {
     throw new Error(`No diagram renderer for language: ${language}`);
   }
@@ -2087,91 +3692,6 @@ async function renderDiagram(language, code, theme) {
   return renderer.render(code, theme);
 }
 
-// src/utils/gradient.ts
-import { deflateSync } from "zlib";
-var CRC_TABLE = (() => {
-  const table = new Uint32Array(256);
-  for (let n = 0; n < 256; n++) {
-    let c = n;
-    for (let k = 0; k < 8; k++) {
-      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
-    }
-    table[n] = c >>> 0;
-  }
-  return table;
-})();
-function crc32(bytes) {
-  let crc = 4294967295;
-  for (let i = 0; i < bytes.length; i++) {
-    crc = CRC_TABLE[(crc ^ bytes[i]) & 255] ^ crc >>> 8;
-  }
-  return (crc ^ 4294967295) >>> 0;
-}
-function pngChunk(type, data) {
-  const length = Buffer.alloc(4);
-  length.writeUInt32BE(data.length);
-  const payload = Buffer.concat([Buffer.from(type, "latin1"), Buffer.from(data)]);
-  const crc = Buffer.alloc(4);
-  crc.writeUInt32BE(crc32(payload));
-  return Buffer.concat([length, payload, crc]);
-}
-function encodePngRgb(width, height, pixelAt) {
-  const ihdr = Buffer.alloc(13);
-  ihdr.writeUInt32BE(width, 0);
-  ihdr.writeUInt32BE(height, 4);
-  ihdr[8] = 8;
-  ihdr[9] = 2;
-  const raw = Buffer.alloc(height * (1 + width * 3));
-  let offset = 0;
-  for (let y = 0; y < height; y++) {
-    raw[offset++] = 0;
-    for (let x = 0; x < width; x++) {
-      const [r, g, b] = pixelAt(x, y);
-      raw[offset++] = r;
-      raw[offset++] = g;
-      raw[offset++] = b;
-    }
-  }
-  const idat = deflateSync(raw, { level: 9 });
-  return Buffer.concat([
-    Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]),
-    pngChunk("IHDR", ihdr),
-    pngChunk("IDAT", new Uint8Array(idat)),
-    pngChunk("IEND", new Uint8Array(0))
-  ]);
-}
-function hexToRgb(hex) {
-  let s = hex.replace(/^#/, "");
-  if (s.length === 3) s = s.split("").map((ch) => ch + ch).join("");
-  if (!/^[0-9a-fA-F]{6}$/.test(s)) throw new Error(`Invalid hex color: ${hex}`);
-  return [
-    parseInt(s.slice(0, 2), 16),
-    parseInt(s.slice(2, 4), 16),
-    parseInt(s.slice(4, 6), 16)
-  ];
-}
-function createLinearGradientPng(from, to, angleDeg = 180, options = {}) {
-  const width = options.width ?? 192;
-  const height = options.height ?? 108;
-  const angle = angleDeg * Math.PI / 180;
-  const dx = Math.sin(angle);
-  const dy = -Math.cos(angle);
-  const extent = (Math.abs(dx) + Math.abs(dy)) / 2;
-  const c1 = hexToRgb(from);
-  const c2 = hexToRgb(to);
-  return encodePngRgb(width, height, (x, y) => {
-    const px = x / (width - 1) - 0.5;
-    const py = y / (height - 1) - 0.5;
-    let t = 0.5 + (px * dx + py * dy) / (2 * extent);
-    t = t < 0 ? 0 : t > 1 ? 1 : t;
-    return [
-      Math.round(c1[0] + (c2[0] - c1[0]) * t),
-      Math.round(c1[1] + (c2[1] - c1[1]) * t),
-      Math.round(c1[2] + (c2[2] - c1[2]) * t)
-    ];
-  });
-}
-
 // src/renderer/background.ts
 var cache = /* @__PURE__ */ new Map();
 function slideBackground(theme) {
@@ -2214,15 +3734,17 @@ async function renderPresentation(presentation, theme, outputPath, inputPath = "
     footerTemplate: presentation.config.footer,
     pageNumber: 0,
     totalSlides: presentation.slides.length,
-    currentSection: ""
+    currentSection: "",
+    sectionNumber: 0
   };
   for (let i = 0; i < presentation.slides.length; i++) {
     const node = presentation.slides[i];
     const slide = pptx.addSlide();
     slide.background = backgroundProps;
     ctx.pageNumber = i + 1;
-    if (node.layout === "section" && node.title) {
-      ctx.currentSection = node.title;
+    if (node.layout === "section") {
+      if (node.title) ctx.currentSection = node.title;
+      ctx.sectionNumber = (ctx.sectionNumber ?? 0) + 1;
     }
     await renderSlideLayout(slide, node, theme, ctx);
   }
@@ -2230,381 +3752,1054 @@ async function renderPresentation(presentation, theme, outputPath, inputPath = "
   writeFileSync2(outputPath, Buffer.from(buffer));
 }
 
-// src/themes/clean.ts
-var cleanTheme = {
-  name: "clean",
-  colors: {
-    primary: "2563EB",
-    secondary: "4B5563",
-    background: "FFFFFF",
-    text: "1F2937",
-    accent: "10B981",
-    codeBackground: "1E293B",
-    codeText: "E2E8F0",
-    titleBackground: "2563EB",
-    titleText: "FFFFFF"
-  },
-  fonts: {
-    heading: "Segoe UI",
-    body: "Segoe UI",
-    code: "Consolas",
-    cjk: "\u5FAE\u8F6F\u96C5\u9ED1"
-  },
-  fontSize: {
-    title: 36,
-    heading: 28,
-    body: 18,
-    code: 14,
-    small: 12
-  },
-  shikiTheme: "github-dark"
+// src/utils/color-mix.ts
+var HEX6 = /^([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/;
+function parseHex(hex) {
+  const raw = hex.startsWith("#") ? hex.slice(1) : hex;
+  const m = HEX6.exec(raw);
+  if (!m) {
+    throw new Error(`Invalid hex color (expected RRGGBB): ${hex}`);
+  }
+  return [parseInt(m[1], 16), parseInt(m[2], 16), parseInt(m[3], 16)];
+}
+function toHex(r, g, b) {
+  const c = (n) => Math.max(0, Math.min(255, Math.round(n))).toString(16).padStart(2, "0").toUpperCase();
+  return `${c(r)}${c(g)}${c(b)}`;
+}
+function mixHex(a, b, t) {
+  const [ar, ag, ab] = parseHex(a);
+  const [br, bg, bb] = parseHex(b);
+  const k = Math.max(0, Math.min(1, t));
+  return toHex(ar + (br - ar) * k, ag + (bg - ag) * k, ab + (bb - ab) * k);
+}
+function relativeLuminance(hex) {
+  const [r, g, b] = parseHex(hex).map((v) => {
+    const s = v / 255;
+    return s <= 0.03928 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4);
+  });
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+function isDarkColor2(hex) {
+  return relativeLuminance(hex) < 0.4;
+}
+
+// src/models/color-scheme.ts
+var CHROMATIC_SLOTS = ["primary", "secondary"];
+function resolveSchemeMode(scheme) {
+  if (scheme.mode) return scheme.mode;
+  return isDarkColor2(scheme.paper) ? "dark" : "light";
+}
+
+// src/themes/color-schemes/ocean.ts
+var oceanScheme = {
+  name: "ocean",
+  mode: "light",
+  ink: "1E4A6F",
+  paper: "F0F8FF",
+  primary: "4F9FD9",
+  secondary: "2D6A9F"
 };
 
-// src/themes/academic.ts
-var academicTheme = {
-  name: "academic",
-  colors: {
-    primary: "003366",
-    secondary: "4A5568",
-    background: "FFFFFF",
-    text: "111827",
-    accent: "991B1B",
-    codeBackground: "1E293B",
-    codeText: "E2E8F0",
-    titleBackground: "003366",
-    titleText: "FFFFFF"
-  },
-  fonts: {
-    heading: "Times New Roman",
-    body: "Segoe UI",
-    code: "Consolas",
-    cjk: "\u5B8B\u4F53"
-  },
-  fontSize: {
-    title: 36,
-    heading: 28,
-    body: 18,
-    code: 14,
-    small: 12
-  },
-  shikiTheme: "github-dark"
+// src/themes/color-schemes/ocean-dark.ts
+var oceanDarkScheme = {
+  name: "ocean-dark",
+  mode: "dark",
+  ink: "D6E7F5",
+  paper: "0B1C2E",
+  primary: "5BAAE8",
+  secondary: "8BBCDD"
 };
 
-// src/themes/dark.ts
-var darkTheme = {
-  name: "dark",
-  colors: {
-    primary: "38BDF8",
-    secondary: "94A3B8",
-    background: "0F172A",
-    text: "F8FAFC",
-    accent: "A855F7",
-    codeBackground: "020617",
-    codeText: "38BDF8",
-    titleBackground: "0F172A",
-    titleText: "38BDF8",
-    highlightBackground: "334155",
-    backgroundGradient: { from: "0F172A", to: "1E293B", angle: 135 }
-  },
-  fonts: {
-    heading: "Segoe UI",
-    body: "Segoe UI",
-    code: "Consolas",
-    cjk: "\u5FAE\u8F6F\u96C5\u9ED1"
-  },
-  fontSize: {
-    title: 36,
-    heading: 28,
-    body: 18,
-    code: 14,
-    small: 12
-  },
-  shikiTheme: "dracula"
+// src/themes/color-schemes/forest.ts
+var forestScheme = {
+  name: "forest",
+  mode: "light",
+  ink: "2A4A3F",
+  paper: "F0FFF5",
+  primary: "5F9A8A",
+  secondary: "3F6A5A"
 };
 
-// src/themes/business.ts
-var businessTheme = {
-  name: "business",
-  colors: {
-    primary: "1E3A8A",
-    secondary: "64748B",
-    background: "F8FAFC",
-    text: "0F172A",
-    accent: "D97706",
-    codeBackground: "0F172A",
-    codeText: "E2E8F0",
-    titleBackground: "1E3A8A",
-    titleText: "FFFFFF"
-  },
-  fonts: {
-    heading: "Segoe UI",
-    body: "Segoe UI",
-    code: "Consolas",
-    cjk: "\u5FAE\u8F6F\u96C5\u9ED1"
-  },
-  fontSize: {
-    title: 36,
-    heading: 28,
-    body: 18,
-    code: 14,
-    small: 12
-  },
-  shikiTheme: "github-dark"
+// src/themes/color-schemes/champagne.ts
+var champagneScheme = {
+  name: "champagne",
+  mode: "light",
+  ink: "CFB53B",
+  paper: "FFFCE6",
+  primary: "E5CD5F",
+  secondary: "F5E08A"
 };
 
-// src/themes/warm.ts
-var warmTheme = {
-  name: "warm",
-  colors: {
-    primary: "065F46",
-    secondary: "78716C",
-    background: "FDFBF7",
-    text: "292524",
-    accent: "C2410C",
-    codeBackground: "292524",
-    codeText: "FDFBF7",
-    titleBackground: "065F46",
-    titleText: "292524",
-    backgroundGradient: { from: "FDFBF7", to: "F5EEDF", angle: 180 }
-  },
-  fonts: {
-    heading: "Georgia",
-    body: "Segoe UI",
-    code: "Consolas",
-    cjk: "\u5FAE\u8F6F\u96C5\u9ED1"
-  },
-  fontSize: {
-    title: 36,
-    heading: 28,
-    body: 18,
-    code: 14,
-    small: 12
-  },
-  shikiTheme: "github-dark"
+// src/themes/color-schemes/graphite.ts
+var graphiteScheme = {
+  name: "graphite",
+  mode: "light",
+  ink: "4D4D4D",
+  paper: "F8F8F8",
+  primary: "D9D9D9",
+  secondary: "A6A6A6"
 };
 
-// src/themes/aurora.ts
-var auroraTheme = {
-  name: "aurora",
-  colors: {
-    primary: "7AA2FF",
-    secondary: "8FA3C9",
-    background: "06091C",
-    text: "E8F0FF",
-    accent: "5EF2C6",
-    codeBackground: "0B1128",
-    codeText: "AECAF5",
-    titleText: "F4F8FF",
-    highlightBackground: "233152",
-    backgroundGradient: { from: "101A3A", to: "05060F", angle: 135 }
-  },
-  fonts: {
-    heading: "Segoe UI",
-    body: "Segoe UI",
-    code: "Consolas",
-    cjk: "\u5FAE\u8F6F\u96C5\u9ED1"
-  },
-  fontSize: {
-    title: 36,
-    heading: 28,
-    body: 18,
-    code: 14,
-    small: 12
-  },
-  shikiTheme: "dracula"
+// src/themes/color-schemes/index.ts
+var builtInSchemes = [
+  oceanScheme,
+  oceanDarkScheme,
+  forestScheme,
+  champagneScheme,
+  graphiteScheme
+];
+var colorSchemes = Object.fromEntries(
+  builtInSchemes.map((s) => [s.name.toLowerCase(), s])
+);
+function getColorScheme(name) {
+  if (!name) return void 0;
+  return colorSchemes[name.toLowerCase()];
+}
+function listColorSchemes() {
+  return Object.values(colorSchemes);
+}
+function registerColorScheme(scheme) {
+  colorSchemes[scheme.name.toLowerCase()] = scheme;
+}
+
+// src/models/text-set.ts
+var TEXT_SCHEME_POSITION_KEYS = [
+  "coverTitle",
+  "slideTitle",
+  "body",
+  "quote",
+  "code",
+  "small"
+];
+var DEFAULT_TEXT_SCHEME_NAME = "system";
+var DEFAULT_UNIFORM_SIZES = {
+  coverTitle: 36,
+  slideTitle: 28,
+  body: 18,
+  quote: 20,
+  code: 14,
+  small: 12
 };
+function defineUniformTextScheme(options) {
+  const sizes = { ...DEFAULT_UNIFORM_SIZES, ...options.sizes };
+  const boldOn = {
+    coverTitle: true,
+    slideTitle: true,
+    ...options.bold
+  };
+  const italicOn = {
+    quote: true,
+    ...options.italic
+  };
+  const make = (key, face) => {
+    const entry = { face, size: sizes[key] };
+    if (boldOn[key]) entry.bold = true;
+    if (italicOn[key]) entry.italic = true;
+    return entry;
+  };
+  return {
+    name: options.name,
+    note: options.note ?? `Uniform typeface: ${options.face}`,
+    positions: {
+      coverTitle: make("coverTitle", options.face),
+      slideTitle: make("slideTitle", options.face),
+      body: make("body", options.face),
+      quote: make("quote", options.face),
+      code: options.codeEntry ?? make("code", options.codeFace ?? "Consolas"),
+      small: make("small", options.face)
+    }
+  };
+}
 
-// src/themes/neon.ts
-var neonTheme = {
-  name: "neon",
-  colors: {
-    primary: "00E5FF",
-    secondary: "9AA4B5",
-    background: "121212",
-    text: "FFFFFF",
-    accent: "FF4081",
-    codeBackground: "0C0C0C",
-    codeText: "85E7F7",
-    titleBackground: "121212",
-    titleText: "00E5FF",
-    highlightBackground: "2A2A32"
-  },
-  fonts: {
-    heading: "Segoe UI",
-    body: "Segoe UI",
-    code: "Consolas",
-    cjk: "\u5FAE\u8F6F\u96C5\u9ED1"
-  },
-  fontSize: {
-    title: 36,
-    heading: 28,
-    body: 18,
-    code: 14,
-    small: 12
-  },
-  shikiTheme: "dracula"
+// src/themes/resolve-scheme.ts
+function resolveColorScheme(scheme) {
+  const { primary, secondary, ink, paper } = scheme;
+  const dark = resolveSchemeMode(scheme) === "dark";
+  const background = paper;
+  const text = ink;
+  const accent = mixHex(primary, ink, 0.45);
+  const codeBackground = dark ? mixHex(paper, ink, 0.35) : "FFFFFF";
+  const codeText = dark ? mixHex(ink, paper, 0.15) : ink;
+  const titleBackground = mixHex(paper, primary, 0.12);
+  const titleText = ink;
+  const highlightBackground = mixHex(codeBackground, primary, 0.28);
+  const secondaryText = mixHex(secondary, ink, 0.25);
+  return {
+    primary,
+    secondary: secondaryText,
+    background,
+    text,
+    accent,
+    codeBackground,
+    codeText,
+    titleBackground,
+    titleText,
+    highlightBackground,
+    accents: [primary, secondary],
+    subtitle: secondaryText,
+    divider: mixHex(ink, paper, 0.45),
+    muted: mixHex(ink, paper, 0.35),
+    tableHeader: mixHex(paper, primary, 0.12),
+    tableZebra: mixHex(paper, ink, 0.04)
+  };
+}
+
+// src/themes/layout-schemes/folio/title.ts
+var titleLayout = {
+  titleAlign: "left",
+  margin: 0.9,
+  extra: {
+    spineWidth: 0.2,
+    marginLeft: 0.55,
+    marginRight: 0.7,
+    titleY: 2.35,
+    subtitleY: 4.05,
+    titleRule: true,
+    titleRuleHeight: 0.035,
+    titleRuleWidth: 3.6,
+    titleRuleColor: "primary",
+    metaBottom: true
+  }
 };
 
-// src/themes/nord.ts
-var nordTheme = {
-  name: "nord",
-  colors: {
-    primary: "88C0D0",
-    secondary: "81A1C1",
-    background: "2E3440",
-    text: "D8DEE9",
-    accent: "EBCB8B",
-    codeBackground: "272C36",
-    codeText: "A9BBD3",
-    titleBackground: "2E3440",
-    titleText: "88C0D0",
-    highlightBackground: "3B4252"
-  },
-  fonts: {
-    heading: "Segoe UI",
-    body: "Segoe UI",
-    code: "Consolas",
-    cjk: "\u5FAE\u8F6F\u96C5\u9ED1"
-  },
-  fontSize: {
-    title: 36,
-    heading: 28,
-    body: 18,
-    code: 14,
-    small: 12
-  },
-  shikiTheme: "nord"
+// src/themes/layout-schemes/folio/section.ts
+var sectionLayout = {
+  accentBar: "none",
+  titleAlign: "left",
+  margin: 1,
+  extra: {
+    doubleRules: true,
+    ruleWeight: 0.04,
+    bandY: 2.55,
+    bandH: 1.55,
+    titleRuleColor: "primary",
+    marginLeft: 1,
+    marginRight: 0.7
+  }
 };
 
-// src/themes/dracula.ts
-var draculaTheme = {
-  name: "dracula",
-  colors: {
-    primary: "BD93F9",
-    secondary: "6272A4",
-    background: "282A36",
-    text: "F8F8F2",
-    accent: "FF79C6",
-    codeBackground: "21222C",
-    codeText: "F8F8F2",
-    titleBackground: "282A36",
-    titleText: "BD93F9",
-    highlightBackground: "44475A"
-  },
-  fonts: {
-    heading: "Segoe UI",
-    body: "Segoe UI",
-    code: "Consolas",
-    cjk: "\u5FAE\u8F6F\u96C5\u9ED1"
-  },
-  fontSize: {
-    title: 36,
-    heading: 28,
-    body: 18,
-    code: 14,
-    small: 12
-  },
-  shikiTheme: "dracula"
+// src/themes/layout-schemes/folio/content.ts
+var contentLayout = {
+  titleAlign: "left",
+  margin: 0.55,
+  titleHeight: 0.82,
+  contentPadding: 0,
+  extra: {
+    marginLeft: 0.72,
+    marginRight: 0.38,
+    titleRule: true,
+    titleRuleHeight: 0.07,
+    titleRuleColor: "secondary"
+  }
 };
 
-// src/themes/beige.ts
-var beigeTheme = {
-  name: "beige",
-  colors: {
-    primary: "8B6F3D",
-    secondary: "6B6455",
-    background: "F7F3DE",
-    text: "2F2A1F",
-    accent: "C0563C",
-    codeBackground: "3A352B",
-    codeText: "E8E0CC",
-    titleBackground: "8B6F3D",
-    titleText: "2F2A1F",
-    highlightBackground: "F0E2B8",
-    backgroundGradient: { from: "F7F3DE", to: "F1E8D2", angle: 180 }
-  },
-  fonts: {
-    heading: "Georgia",
-    body: "Segoe UI",
-    code: "Consolas",
-    cjk: "\u5FAE\u8F6F\u96C5\u9ED1"
-  },
-  fontSize: {
-    title: 36,
-    heading: 28,
-    body: 18,
-    code: 14,
-    small: 12
+// src/themes/layout-schemes/folio/code.ts
+var codeLayout = {
+  titleAlign: "left",
+  margin: 0.35,
+  titleHeight: 0.55,
+  extra: {
+    marginLeft: 0.4,
+    marginRight: 0.4,
+    titleRule: true,
+    titleRuleHeight: 0.025,
+    titleRuleColor: "secondary"
+  }
+};
+
+// src/themes/layout-schemes/folio/quote.ts
+var quoteLayout = {
+  titleAlign: "left",
+  accentBar: "none",
+  margin: 0.9,
+  extra: {
+    quoteMark: false,
+    quoteBar: true,
+    quoteBarWidth: 0.1,
+    marginLeft: 0.9,
+    marginRight: 0.7,
+    attributionAlign: "left"
+  }
+};
+
+// src/themes/layout-schemes/folio/closing.ts
+var closingLayout = {
+  titleAlign: "center",
+  margin: 0.7,
+  extra: {
+    thankText: "Thank you",
+    titleRule: true,
+    ruleWidth: 2.8,
+    textY: 2.85
+  }
+};
+
+// src/themes/layout-schemes/folio/images.ts
+var imageBase = {
+  titleAlign: "left",
+  margin: 0.55,
+  titleHeight: 0.75,
+  extra: {
+    marginLeft: 0.72,
+    marginRight: 0.38,
+    titleRule: true,
+    titleRuleHeight: 0.055,
+    titleRuleColor: "secondary"
+  }
+};
+var imageSingleLayout = { ...imageBase };
+var imageDoubleLayout = { ...imageBase };
+var imageTripleLayout = { ...imageBase };
+
+// src/themes/layout-schemes/folio/footer.ts
+var footerLayout = {
+  margin: 0.55,
+  footerDivider: true,
+  extra: {
+    footerAlign: "center"
+  }
+};
+
+// src/themes/layout-schemes/folio/styles.ts
+var folioLayoutStyles = {
+  sectionBarWidth: 0.04,
+  footerDivider: true,
+  coverBadge: false
+};
+
+// src/themes/layout-schemes/folio/index.ts
+var folioLayoutScheme = {
+  name: "folio",
+  layouts: {
+    title: titleLayout,
+    section: sectionLayout,
+    content: contentLayout,
+    code: codeLayout,
+    quote: quoteLayout,
+    closing: closingLayout,
+    imageSingle: imageSingleLayout,
+    imageDouble: imageDoubleLayout,
+    imageTriple: imageTripleLayout,
+    footer: footerLayout
   },
-  shikiTheme: "github-dark"
+  styles: folioLayoutStyles,
+  note: "\u7F16\u8F91\u518C\u9875\uFF1A\u4E66\u810A\u5C01\u9762\u3001\u53CC\u7EBF\u7AE0\u8282\u3001\u4E0D\u5BF9\u79F0\u6B63\u6587\u3001pull-quote\u3001\u9875\u811A\u5C45\u4E2D\u3002"
+};
+
+// src/themes/layout-schemes/legacy/title.ts
+var titleLayout2 = {
+  titleAlign: "center",
+  margin: 0.8
+};
+
+// src/themes/layout-schemes/legacy/section.ts
+var sectionLayout2 = {
+  accentBar: "left",
+  titleAlign: "left",
+  margin: 1
+};
+
+// src/themes/layout-schemes/legacy/content.ts
+var contentLayout2 = {
+  titleAlign: "left",
+  margin: 0.6,
+  titleHeight: 0.9,
+  contentPadding: 0
+};
+
+// src/themes/layout-schemes/legacy/code.ts
+var codeLayout2 = {
+  titleAlign: "left",
+  margin: 0.5,
+  titleHeight: 0.7
+};
+
+// src/themes/layout-schemes/legacy/quote.ts
+var quoteLayout2 = {
+  titleAlign: "center",
+  accentBar: "none",
+  extra: {
+    quoteMark: true,
+    quoteMarkSize: 72
+  }
 };
 
-// src/themes/ink.ts
-var inkTheme = {
-  name: "ink",
-  colors: {
-    primary: "2F3530",
-    secondary: "6F6A5E",
-    background: "F7F4EC",
-    text: "262626",
-    accent: "C0272D",
-    codeBackground: "2B2924",
-    codeText: "D8D2C0",
-    titleBackground: "30352F",
-    titleText: "262626",
-    highlightBackground: "EBDDCD",
-    backgroundGradient: { from: "F7F4EC", to: "EFE8DA", angle: 180 }
+// src/themes/layout-schemes/legacy/footer.ts
+var footerLayout2 = {
+  margin: 0.6,
+  footerDivider: false
+};
+
+// src/themes/layout-schemes/legacy/styles.ts
+var legacyLayoutStyles = {
+  sectionBarWidth: 0.15,
+  footerDivider: false,
+  coverBadge: false
+};
+
+// src/themes/layout-schemes/legacy/index.ts
+var legacyLayoutScheme = {
+  name: "legacy",
+  layouts: {
+    title: titleLayout2,
+    section: sectionLayout2,
+    content: contentLayout2,
+    code: codeLayout2,
+    quote: quoteLayout2,
+    footer: footerLayout2
   },
-  fonts: {
-    heading: "KaiTi",
-    body: "KaiTi",
-    code: "Consolas",
-    cjk: "KaiTi"
+  styles: legacyLayoutStyles,
+  note: "\u65E7\u7248\u7248\u5F0F\uFF1A\u73B0\u7F51\u4E94\u79CD\u57FA\u7840\u9875 + \u9875\u811A\uFF1B\u65E0\u7ED3\u5C3E/\u56FE\u6587\u6761\u76EE\u3002"
+};
+
+// src/themes/layout-schemes/golden/title.ts
+var titleLayout3 = {
+  titleAlign: "right",
+  margin: 0.83,
+  extra: {
+    marginLeft: 6.94,
+    marginRight: 0.83,
+    titleY: 3,
+    subtitleY: 4,
+    titleRule: true,
+    titleRuleHeight: 0.04,
+    titleRuleWidth: 8.22,
+    titleRuleY: 4.64,
+    titleRuleColor: "primary",
+    metaBottom: true,
+    metaY: 5
+  }
+};
+
+// src/themes/layout-schemes/golden/section.ts
+var sectionLayout3 = {
+  accentBar: "none",
+  titleAlign: "right",
+  margin: 0.83,
+  extra: {
+    marginLeft: 6.67,
+    marginRight: 0.83,
+    // 章节序号占位（node.subtitle）+ 标题
+    subtitleY: 3.03,
+    subtitleH: 0.36,
+    titleY: 3.5,
+    titleH: 0.89,
+    // 黄金分割横线
+    sectionRule: true,
+    sectionRuleY: 4.64,
+    sectionRuleWidth: 8.22,
+    sectionRuleHeight: 0.04,
+    sectionRuleColor: "primary"
+  }
+};
+
+// src/themes/layout-schemes/golden/content.ts
+var contentLayout3 = {
+  titleAlign: "left",
+  margin: 1.11,
+  titleHeight: 1.3,
+  contentPadding: 0,
+  extra: {
+    marginLeft: 1.11,
+    marginRight: 1.11,
+    titleY: 0.72,
+    titleRule: true,
+    titleRuleWidth: 0.89,
+    titleRuleHeight: 0.04,
+    titleRuleColor: "primary"
+  }
+};
+
+// src/themes/layout-schemes/golden/code.ts
+var codeLayout3 = {
+  titleAlign: "left",
+  margin: 1.11,
+  titleHeight: 0.6,
+  extra: {
+    marginLeft: 1.11,
+    marginRight: 1.11,
+    titleY: 0.72,
+    titleRule: true,
+    titleRuleWidth: 0.89,
+    titleRuleHeight: 0.04,
+    titleRuleColor: "primary"
+  }
+};
+
+// src/themes/layout-schemes/golden/quote.ts
+var quoteLayout3 = {
+  titleAlign: "center",
+  accentBar: "none",
+  margin: 2.22,
+  extra: {
+    quoteMark: false,
+    quoteBar: false,
+    marginLeft: 2.22,
+    marginRight: 2.22,
+    quoteRule: true,
+    quoteRuleY: 2.19,
+    quoteRuleWidth: 1.33,
+    quoteRuleHeight: 0.04,
+    quoteRuleColor: "primary",
+    textY: 2.58,
+    textH: 1.94,
+    attributionAlign: "center"
+  }
+};
+
+// src/themes/layout-schemes/golden/closing.ts
+var closingLayout2 = {
+  titleAlign: "right",
+  margin: 0.83,
+  extra: {
+    thankText: "Thank you",
+    marginLeft: 5.83,
+    marginRight: 0.83,
+    textY: 3.22,
+    titleRule: true,
+    closingRule: "below",
+    ruleWidth: 8.22,
+    ruleHeight: 0.04,
+    ruleY: 4.64
+  }
+};
+
+// src/themes/layout-schemes/golden/images.ts
+var imageBase2 = {
+  titleAlign: "left",
+  margin: 1.11,
+  titleHeight: 1.3,
+  extra: {
+    marginLeft: 1.11,
+    marginRight: 1.11,
+    titleY: 0.72,
+    titleRule: true,
+    titleRuleWidth: 0.89,
+    titleRuleHeight: 0.04,
+    titleRuleColor: "primary"
+  }
+};
+var imageSingleLayout2 = { ...imageBase2 };
+var imageDoubleLayout2 = { ...imageBase2 };
+var imageTripleLayout2 = { ...imageBase2 };
+
+// src/themes/layout-schemes/golden/footer.ts
+var footerLayout3 = {
+  margin: 1.11,
+  footerDivider: true,
+  extra: {
+    footerAlign: "left",
+    marginLeft: 1.11,
+    marginRight: 1.11
+  }
+};
+
+// src/themes/layout-schemes/golden/styles.ts
+var goldenLayoutStyles = {
+  sectionBarWidth: 0.04,
+  footerDivider: true,
+  coverBadge: false,
+  codeRadius: 16
+};
+
+// src/themes/layout-schemes/golden/index.ts
+var goldenLayoutScheme = {
+  name: "golden",
+  layouts: {
+    title: titleLayout3,
+    section: sectionLayout3,
+    content: contentLayout3,
+    code: codeLayout3,
+    quote: quoteLayout3,
+    closing: closingLayout2,
+    imageSingle: imageSingleLayout2,
+    imageDouble: imageDoubleLayout2,
+    imageTriple: imageTripleLayout2,
+    footer: footerLayout3
   },
-  fontSize: {
-    title: 36,
-    heading: 28,
-    body: 18,
-    code: 14,
-    small: 12
+  styles: goldenLayoutStyles,
+  note: "\u9EC4\u91D1\u6BD4\u4F8B\uFF1A\u53F3\u5BF9\u9F50\u7559\u767D\u5C01\u9762/\u7AE0\u8282/\u7ED3\u5C3E + \u9EC4\u91D1\u5206\u5272\u6A2A\u7EBF\uFF0C\u6B63\u6587/\u4EE3\u7801/\u5F15\u7528/\u56FE\u6587\u5171\u7528\u9AA8\u67B6\u8BED\u8A00\u3002"
+};
+
+// src/themes/layout-schemes/minimal/title.ts
+var titleLayout4 = {
+  titleAlign: "left",
+  margin: 0.83,
+  extra: {
+    minimalTitle: true,
+    minimalLineX: 0.83,
+    minimalLineY1: 2.64,
+    minimalLineH: 1.94,
+    minimalLineW: 0.04,
+    minimalBoxX: 1.11,
+    minimalBoxW: 8.89,
+    minimalTitleY: 2.64,
+    minimalSubtitleY: 3.64,
+    minimalAuthorY: 5.28,
+    minimalDateY: 5.64,
+    minimalMetaW: 4.17
+  }
+};
+
+// src/themes/layout-schemes/minimal/section.ts
+var sectionLayout4 = {
+  titleAlign: "left",
+  margin: 0.83,
+  extra: {
+    minimalNumber: true,
+    footer: "off",
+    minimalNumberX: 1.11,
+    minimalNumberY: 2.43,
+    minimalNumberW: 2.5,
+    minimalNumberH: 1.53,
+    minimalRuleX: 3.89,
+    minimalRuleY1: 2.71,
+    minimalRuleW: 0.03,
+    minimalRuleH: 1.11,
+    minimalTitleX: 4.31,
+    minimalTitleY: 2.71,
+    minimalTitleW: 6.94,
+    minimalTitleH: 0.69
+  }
+};
+
+// src/themes/layout-schemes/minimal/content.ts
+var contentLayout4 = {
+  titleAlign: "left",
+  margin: 0.83,
+  titleHeight: 0.44,
+  extra: {
+    minimalBox: true,
+    minimalBoxX: 0.83,
+    minimalBoxY: 1.33,
+    minimalBoxW: 11.67,
+    minimalBoxH: 5.28,
+    minimalTitleY: 0.5,
+    minimalTitleRuleY: 1.03,
+    minimalTitleRuleW: 0.56,
+    minimalTitleRuleH: 0.03
+  }
+};
+
+// src/themes/layout-schemes/minimal/code.ts
+var codeLayout4 = {
+  titleAlign: "left",
+  margin: 0.83,
+  extra: {
+    minimalCard: true,
+    minimalCardX: 0.83,
+    minimalCardY: 1.33,
+    minimalCardW: 11.67,
+    minimalCardH: 5.28,
+    minimalCardRadius: 0.08,
+    minimalTitleY: 0.5,
+    minimalTitleRuleY: 1.03,
+    minimalTitleRuleW: 0.56,
+    minimalTitleRuleH: 0.03
+  }
+};
+
+// src/themes/layout-schemes/minimal/quote.ts
+var quoteLayout4 = {
+  titleAlign: "left",
+  margin: 0.83,
+  extra: {
+    minimalQuote: true,
+    minimalRuleX: 1.67,
+    minimalRuleY: 2.78,
+    minimalRuleH: 1.39,
+    minimalRuleW: 0.04,
+    minimalTextX: 2.08,
+    minimalTextW: 9.58,
+    minimalTextH: 1.39
+  }
+};
+
+// src/themes/layout-schemes/minimal/closing.ts
+var closingLayout3 = {
+  titleAlign: "center",
+  margin: 0.83,
+  extra: {
+    minimalClosing: true,
+    thankText: "Thank you",
+    minimalRuleW: 1.11,
+    minimalRuleH: 0.03,
+    minimalRuleY: 2.78,
+    minimalThankX: 2.5,
+    minimalThankY: 3.06,
+    minimalThankW: 8.33,
+    minimalContactX: 3.89,
+    minimalContactY: 4.31,
+    minimalContactW: 5.56
+  }
+};
+
+// src/themes/layout-schemes/minimal/images.ts
+var imageBase3 = {
+  titleAlign: "left",
+  margin: 0.83,
+  extra: {
+    minimalImage: true,
+    minimalImageY: 1.33,
+    minimalImageH: 5.28,
+    minimalTitleY: 0.5,
+    minimalTitleRuleY: 1.03,
+    minimalTitleRuleW: 0.56,
+    minimalTitleRuleH: 0.03
+  }
+};
+var imageSingleLayout3 = { ...imageBase3 };
+var imageDoubleLayout3 = { ...imageBase3 };
+var imageTripleLayout3 = { ...imageBase3 };
+
+// src/themes/layout-schemes/minimal/footer.ts
+var footerLayout4 = {
+  margin: 0.83,
+  footerDivider: true,
+  extra: {
+    footerAlign: "left",
+    dividerY: 6.94,
+    footerY: 7.03
+  }
+};
+
+// src/themes/layout-schemes/minimal/styles.ts
+var minimalLayoutStyles = {
+  footerDivider: true,
+  coverBadge: false
+};
+
+// src/themes/layout-schemes/minimal/index.ts
+var minimalLayoutScheme = {
+  name: "minimal",
+  layouts: {
+    title: titleLayout4,
+    section: sectionLayout4,
+    content: contentLayout4,
+    code: codeLayout4,
+    quote: quoteLayout4,
+    closing: closingLayout3,
+    imageSingle: imageSingleLayout3,
+    imageDouble: imageDoubleLayout3,
+    imageTriple: imageTripleLayout3,
+    footer: footerLayout4
   },
-  shikiTheme: "github-dark"
+  styles: minimalLayoutStyles,
+  note: "\u6781\u7B80\u6863\u6848\uFF1A\u7EDF\u4E000.83\u8FB9\u8DDD\u3001\u6A2A/\u7AD6\u7EBF\u6027\u88C5\u9970\u3001\u8D85\u5927\u7AE0\u5E8F\u53F7\u3001\u5706\u89D2\u4EE3\u7801\u5361\u7247\u3001\u865A\u7EBF\u56FE\u7247\u5360\u4F4D\u3002"
 };
 
-// src/themes/default.ts
-var defaultTheme = {
-  ...cleanTheme,
-  name: "default"
+// src/themes/layout-schemes/index.ts
+var builtInLayoutSchemes = [
+  folioLayoutScheme,
+  legacyLayoutScheme,
+  goldenLayoutScheme,
+  minimalLayoutScheme
+];
+var layoutSchemes = Object.fromEntries(
+  builtInLayoutSchemes.map((s) => [s.name.toLowerCase(), s])
+);
+function getLayoutScheme(name) {
+  if (!name) return void 0;
+  return layoutSchemes[name.toLowerCase()];
+}
+function listLayoutSchemes() {
+  return Object.values(layoutSchemes);
+}
+function registerLayoutScheme(scheme) {
+  layoutSchemes[scheme.name.toLowerCase()] = scheme;
+}
+
+// src/themes/presets/blue.ts
+var bluePreset = {
+  name: "blue",
+  colorScheme: "ocean",
+  textScheme: "academic",
+  layoutScheme: "legacy"
 };
 
-// src/themes/index.ts
-var themes = {
-  clean: cleanTheme,
-  academic: academicTheme,
-  dark: darkTheme,
-  business: businessTheme,
-  warm: warmTheme,
-  aurora: auroraTheme,
-  neon: neonTheme,
-  nord: nordTheme,
-  dracula: draculaTheme,
-  beige: beigeTheme,
-  ink: inkTheme,
-  default: defaultTheme
+// src/themes/presets/emerald.ts
+var emeraldPreset = {
+  name: "emerald",
+  colorScheme: "forest",
+  textScheme: "system",
+  layoutScheme: "folio"
+};
+
+// src/themes/presets/gold.ts
+var goldPreset = {
+  name: "gold",
+  colorScheme: "champagne",
+  textScheme: "kai",
+  layoutScheme: "golden"
+};
+
+// src/themes/presets/slate.ts
+var slatePreset = {
+  name: "slate",
+  colorScheme: "graphite",
+  textScheme: "source-han-serif",
+  layoutScheme: "minimal"
+};
+
+// src/themes/presets/index.ts
+var builtInThemePresets = [
+  bluePreset,
+  emeraldPreset,
+  goldPreset,
+  slatePreset
+];
+var themePresets = Object.fromEntries(
+  builtInThemePresets.map((p) => [p.name.toLowerCase(), p])
+);
+function getThemePreset(name) {
+  if (!name) return void 0;
+  return themePresets[name.toLowerCase()];
+}
+function listThemePresets() {
+  return Object.values(themePresets);
+}
+function registerThemePreset(preset) {
+  themePresets[preset.name.toLowerCase()] = preset;
+}
+function themePresetNames() {
+  return listThemePresets().map((p) => p.name);
+}
+function hasThemePreset(name) {
+  return Boolean(name && getThemePreset(name));
+}
+
+// src/themes/text-entries.ts
+var sharedCode = {
+  face: "Consolas",
+  cjkFace: "Consolas",
+  size: 14
 };
-function getTheme(name) {
-  if (!name) {
-    return cleanTheme;
+
+// src/themes/text-schemes/academic.ts
+var academicTextScheme = defineUniformTextScheme({
+  name: "academic",
+  face: "\u5B8B\u4F53",
+  codeEntry: sharedCode,
+  sizes: {
+    coverTitle: 42,
+    slideTitle: 32
+  },
+  note: "\u5B66\u672F\uFF1A\u6B63\u6587/\u6807\u9898\u7EDF\u4E00\u5B8B\u4F53\uFF0C\u4EE3\u7801 Consolas\uFF1B\u6807\u9898\u52A0\u5927\uFF08\u5C01\u9762 42 / \u9875\u6807\u9898 32\uFF09\u3002"
+});
+
+// src/themes/text-schemes/system.ts
+var systemTextScheme = defineUniformTextScheme({
+  name: "system",
+  face: "\u5FAE\u8F6F\u96C5\u9ED1",
+  codeEntry: sharedCode,
+  note: "\u7CFB\u7EDF\u9ED8\u8BA4\uFF1A\u6B63\u6587/\u6807\u9898\u7EDF\u4E00\u5FAE\u8F6F\u96C5\u9ED1\uFF0C\u4EE3\u7801 Consolas\u3002"
+});
+
+// src/themes/text-schemes/kai.ts
+var kaiTextScheme = defineUniformTextScheme({
+  name: "kai",
+  face: "KaiTi",
+  codeEntry: sharedCode,
+  note: "\u6977\u4F53\uFF1A\u6B63\u6587/\u6807\u9898\u7EDF\u4E00 KaiTi\uFF0C\u4EE3\u7801 Consolas\u3002"
+});
+
+// src/themes/text-schemes/source-han-serif.ts
+var sourceHanSerifTextScheme = defineUniformTextScheme({
+  name: "source-han-serif",
+  face: "\u601D\u6E90\u5B8B\u4F53",
+  codeEntry: sharedCode,
+  note: "\u601D\u6E90\u5B8B\u4F53\uFF1A\u6B63\u6587/\u6807\u9898\u7EDF\u4E00\u601D\u6E90\u5B8B\u4F53\uFF0C\u4EE3\u7801 Consolas\u3002"
+});
+
+// src/themes/text-schemes/text-index.ts
+var builtInTextSchemes = [
+  systemTextScheme,
+  academicTextScheme,
+  kaiTextScheme,
+  sourceHanSerifTextScheme
+];
+var textSchemes = Object.fromEntries(
+  builtInTextSchemes.map((s) => [s.name.toLowerCase(), s])
+);
+function getTextScheme(name) {
+  if (!name) return void 0;
+  return textSchemes[name.toLowerCase()];
+}
+function listTextSchemes() {
+  return Object.values(textSchemes);
+}
+function registerTextScheme(scheme) {
+  textSchemes[scheme.name.toLowerCase()] = scheme;
+}
+
+// src/themes/from-scheme.ts
+function resolveThemePresetOption(input) {
+  if (input === void 0 || input === null) return void 0;
+  if (typeof input === "object") return input;
+  const name = input.trim();
+  if (!name) return void 0;
+  const preset = getThemePreset(name);
+  if (!preset) {
+    console.warn(`Theme preset "${name}" not found; using scheme defaults only`);
+    return void 0;
+  }
+  return preset;
+}
+function resolveColorSchemeOption(input) {
+  if (input && typeof input === "object") return input;
+  if (typeof input !== "string" || !input.trim()) return void 0;
+  const name = input.trim();
+  const scheme = getColorScheme(name);
+  if (!scheme) {
+    console.warn(`Color scheme "${name}" not found`);
+    return void 0;
   }
-  if (typeof name !== "string") {
+  return scheme;
+}
+function resolveTextSchemeOption(input) {
+  if (input && typeof input === "object") return input;
+  const name = typeof input === "string" && input.trim() ? input.trim() : DEFAULT_TEXT_SCHEME_NAME;
+  const scheme = getTextScheme(name);
+  if (!scheme) {
+    if (typeof input === "string" && input.trim()) {
+      console.warn(`Text scheme "${name}" not found, using "${DEFAULT_TEXT_SCHEME_NAME}"`);
+    }
+    const fallback = getTextScheme(DEFAULT_TEXT_SCHEME_NAME);
+    if (!fallback) {
+      throw new Error(`Default text scheme "${DEFAULT_TEXT_SCHEME_NAME}" is not registered`);
+    }
+    return fallback;
+  }
+  return scheme;
+}
+function bridgeFontsFromTextScheme(scheme) {
+  const p = scheme.positions;
+  const body = p.body;
+  const headingSource = p.slideTitle ?? p.coverTitle;
+  return {
+    body: body.face,
+    cjk: body.cjkFace ?? body.face,
+    heading: headingSource.face ?? body.face,
+    code: p.code.face
+  };
+}
+function bridgeFontSizesFromTextScheme(scheme) {
+  const p = scheme.positions;
+  return {
+    title: p.coverTitle.size,
+    heading: p.slideTitle.size,
+    body: p.body.size,
+    code: p.code.size,
+    small: p.small.size
+  };
+}
+function textStylesFromScheme(scheme) {
+  return { ...scheme.positions };
+}
+function resolveLayoutSchemeOption(input) {
+  if (input === void 0) return {};
+  if (typeof input === "object" && input !== null) {
+    return {
+      layouts: input.layouts,
+      styles: input.styles,
+      layoutSet: input.name,
+      scheme: input
+    };
+  }
+  const name = input.trim();
+  if (!name) return {};
+  const scheme = getLayoutScheme(name);
+  if (!scheme) {
+    console.warn(`Layout scheme "${name}" not found, using built-in layout defaults`);
+    return {};
+  }
+  return {
+    layouts: scheme.layouts,
+    styles: scheme.styles,
+    layoutSet: scheme.name,
+    scheme
+  };
+}
+function createThemeFromScheme(scheme, options = {}) {
+  const colorScheme = resolveColorSchemeOption(options.colorScheme) ?? scheme;
+  const textScheme = resolveTextSchemeOption(options.textScheme);
+  const fonts = options.fonts ?? bridgeFontsFromTextScheme(textScheme);
+  const fontSize = options.fontSize ?? bridgeFontSizesFromTextScheme(textScheme);
+  const fromLayout = resolveLayoutSchemeOption(options.layoutScheme);
+  return {
+    name: scheme.name,
+    colors: resolveColorScheme(colorScheme),
+    fonts,
+    fontSize,
+    shikiTheme: options.shikiTheme ?? (resolveSchemeMode(colorScheme) === "dark" ? "github-dark" : "github-light"),
+    layouts: options.layouts ?? fromLayout.layouts,
+    styles: options.styles ?? fromLayout.styles,
+    typography: options.typography,
+    avoid: options.avoid,
+    textSet: textScheme.name,
+    textScheme,
+    textStyles: textStylesFromScheme(textScheme),
+    layoutSet: fromLayout.layoutSet,
+    presetSet: options.presetSet
+  };
+}
+
+// src/models/layout-scheme.ts
+var DEFAULT_LAYOUT_SCHEME_NAME = "folio";
+
+// src/themes/index.ts
+var DEFAULT_SCHEME_NAME = "ocean";
+function resolveThemeName(name) {
+  const trimmed = typeof name === "string" ? name.trim() : "";
+  const key = trimmed || DEFAULT_THEME_NAME;
+  const preset = getThemePreset(key);
+  if (preset) return { kind: "preset", preset };
+  if (getColorScheme(key)) return { kind: "color", colorName: key };
+  return { kind: "default" };
+}
+function getTheme(name, options = {}) {
+  if (name !== void 0 && name !== null && typeof name !== "string") {
     throw new Error(`Invalid theme value: expected a string, got ${typeof name}`);
   }
-  const theme = themes[name.toLowerCase()];
-  if (!theme) {
-    console.warn(`Theme "${name}" not found, using "clean"`);
-    return cleanTheme;
+  const explicitPreset = resolveThemePresetOption(options.preset);
+  const resolved = resolveThemeName(name);
+  if (resolved.kind === "preset" || resolved.kind === "default" && !explicitPreset) {
+    const preset = resolved.kind === "preset" ? resolved.preset : getThemePreset(DEFAULT_THEME_NAME);
+    if (resolved.kind === "default" && name?.trim()) {
+      console.warn(`Theme "${name}" not found, using "${preset.name}"`);
+    }
+    return createThemeFromScheme(getColorScheme(preset.colorScheme), {
+      colorScheme: options.colorScheme,
+      textScheme: options.textScheme ?? preset.textScheme,
+      layoutScheme: options.layoutScheme ?? preset.layoutScheme,
+      presetSet: preset.name
+    });
+  }
+  if (resolved.kind === "default" && explicitPreset) {
+    console.warn(`Theme "${name}" not found, using preset "${explicitPreset.name}"`);
+    return createThemeFromScheme(getColorScheme(explicitPreset.colorScheme), {
+      colorScheme: options.colorScheme,
+      textScheme: options.textScheme ?? explicitPreset.textScheme,
+      layoutScheme: options.layoutScheme ?? explicitPreset.layoutScheme,
+      presetSet: explicitPreset.name
+    });
   }
-  return theme;
+  const colorName = resolved.kind === "color" ? resolved.colorName : explicitPreset.colorScheme;
+  return createThemeFromScheme(getColorScheme(colorName), {
+    colorScheme: options.colorScheme,
+    textScheme: options.textScheme ?? explicitPreset?.textScheme,
+    layoutScheme: options.layoutScheme ?? explicitPreset?.layoutScheme,
+    presetSet: explicitPreset?.name
+  });
+}
+function themeNames() {
+  const presets = listThemePresets().map((p) => p.name.toLowerCase());
+  const colors = listColorSchemes().map((s) => s.name.toLowerCase());
+  return [...presets, ...colors.filter((c) => !presets.includes(c))];
+}
+function hasTheme(name) {
+  if (!name) return false;
+  return Boolean(getThemePreset(name) || getColorScheme(name));
 }
 
 // src/utils/output-namer.ts
@@ -2628,26 +4823,63 @@ function getOutputPath(inputPath, specifiedOutput) {
 // src/index.ts
 async function convert(inputPath, options = {}) {
   const absInput = resolve3(inputPath);
-  const markdown = readFileSync2(absInput, "utf-8");
+  const markdown = readFileSync4(absInput, "utf-8");
   const presentation = parseMarkdown(markdown);
-  if (options.theme) presentation.config.theme = options.theme;
-  const theme = getTheme(presentation.config.theme);
+  const baseTheme = options.theme ?? presentation.config.theme;
+  const colorScheme = options.colorScheme ?? presentation.config.colorScheme;
+  const textScheme = options.textScheme ?? presentation.config.textScheme;
+  const layoutScheme = options.layoutScheme ?? presentation.config.layoutScheme;
+  const theme = getTheme(baseTheme, { colorScheme, textScheme, layoutScheme });
   const outputPath = resolve3(getOutputPath(absInput, options.output));
   await renderPresentation(presentation, theme, outputPath, absInput);
   return outputPath;
 }
 export {
-  academicTheme,
-  businessTheme,
-  cleanTheme,
+  CHROMATIC_SLOTS,
+  DEFAULT_LAYOUT_SCHEME_NAME,
+  DEFAULT_PRESET_NAME,
+  DEFAULT_SCHEME_NAME,
+  DEFAULT_TEXT_SCHEME_NAME,
+  DEFAULT_THEME_NAME,
+  TEXT_SCHEME_POSITION_KEYS,
+  academicTextScheme,
+  bluePreset,
   convert,
-  darkTheme,
-  defaultTheme,
+  createThemeFromScheme,
+  defineUniformTextScheme,
+  folioLayoutScheme,
+  getColorScheme,
+  getLayoutScheme,
+  getTextScheme,
   getTheme,
+  getThemePreset,
+  hasTheme,
+  hasThemePreset,
   isDiagramLanguage,
+  kaiTextScheme,
+  layoutSchemes,
+  legacyLayoutScheme,
+  listColorSchemes,
+  listLayoutSchemes,
+  listTextSchemes,
+  listThemePresets,
+  oceanDarkScheme,
+  oceanScheme,
   parseMarkdown,
+  registerColorScheme,
+  registerLayoutScheme,
+  registerTextScheme,
+  registerThemePreset,
   renderDiagram,
-  themes,
-  warmTheme
+  renderPresentation,
+  resolveColorScheme,
+  resolveSchemeMode,
+  resolveThemePresetOption,
+  sourceHanSerifTextScheme,
+  systemTextScheme,
+  textSchemes,
+  themeNames,
+  themePresetNames,
+  themePresets
 };
 //# sourceMappingURL=index.js.map