teamshare-bridge 0.26.25 → 0.27.0

package/dist/lib/tools/pptx-deck.js

@@ -3,14 +3,264 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PptxDeckTool = void 0;
+exports.PptxDeckTool = exports.DENSITY_CAPS = exports.FALLBACK_TOKENS = exports.KNOWN_LAYOUTS = void 0;
+exports.loadTemplateMirror = loadTemplateMirror;
+exports.resolveDeckTokens = resolveDeckTokens;
+exports.parseDeckSpec = parseDeckSpec;
+exports.planDeck = planDeck;
 /**
- * Slide Deck Generator tool.
- * Creates PowerPoint presentations from markdown outlines using pptxgenjs.
- * H1 = document title, H2 = slide title, H3 = bullet points.
+ * Slide Deck renderer (node tool `pptx-render`).
+ *
+ * Chain tool for the `pptx-deck` catalog entry: the harness authors a
+ * `deck.json` spec, and this renderer turns it into a themed .pptx via
+ * pptxgenjs plus an optional `— Speaker Notes.md` sidecar.
+ *
+ * deck.json shape (backend contract, see tools registry `briefGuide: 'deck'`):
+ *   { slides: [{ layout, title?, subtitle?, bullets?, columns?, cards?,
+ *                stats?, rows?, quote?, notes? }] }
+ *   layouts: title|agenda|section|bullets|statement|two-column|cards|
+ *            stats|timeline|quote|table|closing|sources
+ *
+ * Params: deckJson (text or object), template (id in deck-templates.json),
+ * aspect ('16:9'|'4:3'), accentColor (overrides template accent),
+ * density ('auto'|'airy'|'normal'|'compact'; 'auto' = template default),
+ * outputName (`<Task subject> (YYYY-MM-DD)`), outlineMd (legacy fallback).
  */
 const pptxgenjs_1 = __importDefault(require("pptxgenjs"));
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
 const output_name_1 = require("./output-name");
+exports.KNOWN_LAYOUTS = [
+    'title',
+    'agenda',
+    'section',
+    'bullets',
+    'statement',
+    'two-column',
+    'cards',
+    'stats',
+    'timeline',
+    'quote',
+    'table',
+    'closing',
+    'sources',
+];
+/** Built-in corporate-equivalent defaults (used only when the mirror file is unreadable). */
+exports.FALLBACK_TOKENS = {
+    accent: '1E3A5F',
+    background: 'FFFFFF',
+    surface: 'F1F5F9',
+    textColor: '0F172A',
+    bodyFont: 'Calibri',
+    headingFont: 'Calibri',
+    coverStyle: 'banner',
+    titleStyle: 'rule',
+    footerStyle: 'rule',
+    cornerStyle: 'square',
+    density: 'normal',
+};
+const COVER_STYLES = [
+    'banner',
+    'centered',
+    'split',
+    'minimal',
+    'frame',
+    'band',
+];
+const TITLE_STYLES = ['rule', 'bar', 'band', 'hairline', 'numbered', 'plain'];
+const FOOTER_STYLES = ['rule', 'dots', 'number', 'plain'];
+const CORNER_STYLES = ['square', 'rounded', 'pill'];
+const DENSITIES = ['airy', 'normal', 'compact'];
+/** Per-density content budgets. Exported for tests. */
+exports.DENSITY_CAPS = {
+    airy: { maxBullets: 4, maxWords: 8 },
+    normal: { maxBullets: 5, maxWords: 10 },
+    compact: { maxBullets: 6, maxWords: 12 },
+};
+function stripMd(raw) {
+    return raw
+        .replace(/\*\*([^*]+)\*\*/g, '$1')
+        .replace(/\*([^*]+)\*/g, '$1')
+        .replace(/`([^`]+)`/g, '$1')
+        .trim();
+}
+function asStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((v) => (typeof v === 'string' ? stripMd(v) : ''))
+        .filter((s) => s.length > 0);
+}
+function normalizeHex(raw, fallback) {
+    if (typeof raw !== 'string' || !raw.trim())
+        return { color: fallback, changed: false };
+    const cleaned = raw.trim().replace(/^#/, '');
+    if (/^[0-9a-fA-F]{6}$/.test(cleaned))
+        return { color: cleaned.toUpperCase(), changed: true };
+    return { color: fallback, changed: false };
+}
+/**
+ * Load the template mirror at runtime (never statically imported: tsc does
+ * not emit JSON assets into dist, so a static import would break at runtime).
+ * Returns null when the file cannot be found or parsed.
+ */
+function loadTemplateMirror() {
+    const candidates = [
+        (0, node_path_1.join)(__dirname, 'deck-templates.json'),
+        (0, node_path_1.join)(process.cwd(), 'src', 'lib', 'tools', 'deck-templates.json'),
+        (0, node_path_1.join)((0, node_path_1.dirname)(__dirname), '..', '..', 'src', 'lib', 'tools', 'deck-templates.json'),
+    ];
+    for (const path of candidates) {
+        try {
+            if (!(0, node_fs_1.existsSync)(path))
+                continue;
+            const parsed = JSON.parse((0, node_fs_1.readFileSync)(path, 'utf8'));
+            if (parsed &&
+                Array.isArray(parsed.templates) &&
+                parsed.templates.length > 0) {
+                return { templates: parsed.templates };
+            }
+        }
+        catch {
+            /* try next candidate */
+        }
+    }
+    return null;
+}
+function coerceDensity(raw, fallback) {
+    if (typeof raw === 'string' && DENSITIES.includes(raw)) {
+        return { density: raw, changed: raw !== fallback };
+    }
+    return { density: fallback, changed: false };
+}
+/** Resolve template tokens: mirror lookup + accentColor/density overrides. */
+function resolveDeckTokens(params) {
+    const warnings = [];
+    const requestedId = typeof params.template === 'string' ? params.template : 'corporate';
+    const mirror = loadTemplateMirror();
+    const entry = mirror?.templates.find((t) => t.id === requestedId);
+    if (requestedId && !entry) {
+        warnings.push(`unknown template "${requestedId}", fell back to corporate defaults`);
+    }
+    const preview = entry?.preview ?? {};
+    const base = {
+        accent: normalizeHex(preview.accent, exports.FALLBACK_TOKENS.accent).color,
+        background: normalizeHex(preview.background, exports.FALLBACK_TOKENS.background)
+            .color,
+        surface: normalizeHex(preview.surface, exports.FALLBACK_TOKENS.surface).color,
+        textColor: normalizeHex(preview.textColor, exports.FALLBACK_TOKENS.textColor).color,
+        bodyFont: typeof preview.bodyFont === 'string' && preview.bodyFont
+            ? preview.bodyFont
+            : exports.FALLBACK_TOKENS.bodyFont,
+        headingFont: typeof preview.headingFont === 'string' && preview.headingFont
+            ? preview.headingFont
+            : exports.FALLBACK_TOKENS.headingFont,
+        coverStyle: typeof preview.coverStyle === 'string' &&
+            COVER_STYLES.includes(preview.coverStyle)
+            ? preview.coverStyle
+            : exports.FALLBACK_TOKENS.coverStyle,
+        titleStyle: typeof preview.titleStyle === 'string' &&
+            TITLE_STYLES.includes(preview.titleStyle)
+            ? preview.titleStyle
+            : exports.FALLBACK_TOKENS.titleStyle,
+        footerStyle: typeof preview.footerStyle === 'string' &&
+            FOOTER_STYLES.includes(preview.footerStyle)
+            ? preview.footerStyle
+            : exports.FALLBACK_TOKENS.footerStyle,
+        cornerStyle: typeof preview.cornerStyle === 'string' &&
+            CORNER_STYLES.includes(preview.cornerStyle)
+            ? preview.cornerStyle
+            : exports.FALLBACK_TOKENS.cornerStyle,
+        density: typeof preview.density === 'string' &&
+            DENSITIES.includes(preview.density)
+            ? preview.density
+            : exports.FALLBACK_TOKENS.density,
+    };
+    const accent = normalizeHex(params.accentColor, base.accent);
+    if (typeof params.accentColor === 'string' &&
+        params.accentColor &&
+        !accent.changed) {
+        warnings.push(`ignored invalid accentColor "${params.accentColor}"`);
+    }
+    base.accent = accent.color;
+    const densityRaw = params.density;
+    if (typeof densityRaw === 'string' && densityRaw !== 'auto') {
+        base.density = coerceDensity(densityRaw, base.density).density;
+    }
+    return { tokens: base, templateId: entry?.id ?? 'corporate', warnings };
+}
+/** Parse deckJson (text or object). Throws on invalid/empty specs. */
+function parseDeckSpec(raw) {
+    let parsed = raw;
+    if (typeof raw === 'string') {
+        const trimmed = raw.trim();
+        if (!trimmed)
+            throw new Error('deckJson is empty');
+        // Harness may wrap the handoff in a code fence.
+        const fenced = trimmed.match(/^```(?:json)?\s*([\s\S]*?)```$/);
+        parsed = JSON.parse(fenced ? fenced[1] : trimmed);
+    }
+    if (!parsed || typeof parsed !== 'object')
+        throw new Error('deckJson must be an object with a slides array');
+    const slides = parsed.slides;
+    if (!Array.isArray(slides) || slides.length === 0) {
+        throw new Error('deckJson must contain a non-empty slides array');
+    }
+    const title = parsed.title;
+    return {
+        title: typeof title === 'string' ? title : undefined,
+        slides: slides,
+    };
+}
+function trimBullets(bullets, density) {
+    const cap = exports.DENSITY_CAPS[density];
+    return bullets.slice(0, cap.maxBullets).map((b) => {
+        const words = b.split(/\s+/);
+        if (words.length <= cap.maxWords)
+            return b;
+        return `${words.slice(0, cap.maxWords).join(' ')}…`;
+    });
+}
+/**
+ * Pure layout planner: per-slide sizes/spacing/columns from density + aspect.
+ * No pptxgenjs calls — safe to unit-test.
+ */
+function planDeck(spec, opts) {
+    const base = opts.density === 'airy'
+        ? { title: 32, body: 18 }
+        : opts.density === 'compact'
+            ? { title: 24, body: 14 }
+            : { title: 28, body: 16 };
+    const shrink = opts.aspect === '4:3' ? 2 : 0;
+    return spec.slides.map((slide, index) => {
+        const rawLayout = typeof slide.layout === 'string' ? slide.layout : 'bullets';
+        const known = exports.KNOWN_LAYOUTS.includes(rawLayout);
+        const layout = (known ? rawLayout : 'bullets');
+        const bullets = trimBullets(asStringArray(slide.bullets), opts.density);
+        let columns = 1;
+        if (layout === 'two-column' && Array.isArray(slide.columns))
+            columns = Math.min(Math.max(slide.columns.length, 1), 2);
+        else if (layout === 'cards' && Array.isArray(slide.cards))
+            columns = Math.min(Math.max(slide.cards.length, 1), 4);
+        else if (layout === 'stats' && Array.isArray(slide.stats))
+            columns = Math.min(Math.max(slide.stats.length, 1), 4);
+        const statementBump = layout === 'statement' ||
+            layout === 'quote' ||
+            layout === 'title' ||
+            layout === 'closing'
+            ? 6
+            : 0;
+        return {
+            index,
+            layout,
+            ...(known ? {} : { degradedFrom: rawLayout }),
+            titleSize: base.title + statementBump - shrink,
+            bodySize: base.body - (shrink > 0 ? 1 : 0),
+            columns,
+            bullets,
+        };
+    });
+}
 function parseOutline(markdown) {
     const lines = markdown.split(/\r?\n/);
     let docTitle = 'Presentation';
@@ -26,192 +276,1097 @@ function parseOutline(markdown) {
         const bullet = trimmed.match(/^[-*+]\s+(.*)$/);
         const numbered = trimmed.match(/^\d+[.)]\s+(.*)$/);
         if (h1) {
-            docTitle = h1[1].replace(/\*\*/g, '');
+            docTitle = stripMd(h1[1]);
         }
         else if (h2) {
             if (current)
                 slides.push(current);
-            current = {
-                title: h2[1].replace(/\*\*/g, ''),
-                bullets: [],
-            };
+            current = { title: stripMd(h2[1]), bullets: [] };
         }
         else if (h3) {
-            if (!current) {
+            if (!current)
                 current = { title: '', bullets: [] };
-            }
-            current.notes = h3[1];
+            current.notes = stripMd(h3[1]);
         }
         else if ((bullet || numbered) && current) {
-            const text = (bullet ? bullet[1] : numbered[1])
-                .replace(/\*\*([^*]+)\*\*/g, '$1')
-                .replace(/\*([^*]+)\*/g, '$1');
-            current.bullets.push(text);
+            current.bullets.push(stripMd(bullet ? bullet[1] : numbered[1]));
         }
         else if (current && !current.title) {
-            current.title = trimmed.replace(/\*\*/g, '');
+            current.title = stripMd(trimmed);
         }
     }
     if (current)
         slides.push(current);
     return { docTitle, slides };
 }
-const THEMES = {
-    default: {
-        bg: 'FFFFFF',
-        color: '374151',
-        accent: '16a34a',
-        titleColor: '111827',
-    },
-    dark: {
-        bg: '1f2937',
-        color: 'e5e7eb',
-        accent: '3b82f6',
-        titleColor: 'f9fafb',
-    },
-    ocean: {
-        bg: 'F0F9FF',
-        color: '1e3a5f',
-        accent: '0284c7',
-        titleColor: '0c4a6e',
-    },
-    forest: {
-        bg: 'F0FDF4',
-        color: '14532d',
-        accent: '16a34a',
-        titleColor: '166534',
-    },
-    sunset: {
-        bg: 'FFF7ED',
-        color: '7c2d12',
-        accent: 'ea580c',
-        titleColor: '9a3412',
-    },
-};
+function shapeFor(tokens, pptx) {
+    if (tokens.cornerStyle === 'square')
+        return pptx.ShapeType.rect;
+    return pptx.ShapeType.roundRect;
+}
+function addTitleBlock(slide, pptx, tokens, title, slideNo, plan) {
+    const accent = tokens.accent;
+    const heading = tokens.headingFont;
+    switch (tokens.titleStyle) {
+        case 'bar':
+            slide.addShape(pptx.ShapeType.rect, {
+                x: '7%',
+                y: '7%',
+                w: '1.2%',
+                h: '12%',
+                fill: { color: accent },
+            });
+            slide.addText(title, {
+                x: '10%',
+                y: '7%',
+                w: '82%',
+                h: '12%',
+                fontSize: plan.titleSize,
+                fontFace: heading,
+                color: tokens.textColor,
+                bold: true,
+            });
+            break;
+        case 'band':
+            slide.addShape(pptx.ShapeType.rect, {
+                x: '0%',
+                y: '5%',
+                w: '100%',
+                h: '16%',
+                fill: { color: tokens.surface },
+            });
+            slide.addText(title, {
+                x: '8%',
+                y: '6%',
+                w: '84%',
+                h: '14%',
+                fontSize: plan.titleSize,
+                fontFace: heading,
+                color: accent,
+                bold: true,
+            });
+            break;
+        case 'hairline':
+            slide.addText(title, {
+                x: '8%',
+                y: '7%',
+                w: '84%',
+                h: '12%',
+                fontSize: plan.titleSize,
+                fontFace: heading,
+                color: tokens.textColor,
+                bold: false,
+            });
+            slide.addShape(pptx.ShapeType.rect, {
+                x: '8%',
+                y: '20%',
+                w: '84%',
+                h: '0.3%',
+                fill: { color: accent, transparency: 60 },
+            });
+            break;
+        case 'numbered':
+            slide.addText(`${slideNo}`, {
+                x: '8%',
+                y: '6%',
+                w: '10%',
+                h: '14%',
+                fontSize: plan.titleSize + 6,
+                fontFace: heading,
+                color: accent,
+                bold: true,
+            });
+            slide.addText(title, {
+                x: '16%',
+                y: '6%',
+                w: '76%',
+                h: '14%',
+                fontSize: plan.titleSize,
+                fontFace: heading,
+                color: tokens.textColor,
+                bold: true,
+            });
+            break;
+        case 'plain':
+            slide.addText(title, {
+                x: '8%',
+                y: '7%',
+                w: '84%',
+                h: '12%',
+                fontSize: plan.titleSize,
+                fontFace: heading,
+                color: tokens.textColor,
+                bold: true,
+            });
+            break;
+        case 'rule':
+        default:
+            slide.addText(title, {
+                x: '8%',
+                y: '7%',
+                w: '84%',
+                h: '12%',
+                fontSize: plan.titleSize,
+                fontFace: heading,
+                color: tokens.textColor,
+                bold: true,
+            });
+            slide.addShape(pptx.ShapeType.rect, {
+                x: '8%',
+                y: '20%',
+                w: '15%',
+                h: '0.6%',
+                fill: { color: accent },
+            });
+            break;
+    }
+}
+function addFooter(slide, pptx, tokens, slideNo) {
+    const accent = tokens.accent;
+    switch (tokens.footerStyle) {
+        case 'rule':
+            slide.addShape(pptx.ShapeType.rect, {
+                x: '8%',
+                y: '92%',
+                w: '84%',
+                h: '0.3%',
+                fill: { color: tokens.textColor, transparency: 80 },
+            });
+            slide.addText(`${slideNo}`, {
+                x: '88%',
+                y: '93%',
+                w: '4%',
+                h: '4%',
+                fontSize: 9,
+                fontFace: tokens.bodyFont,
+                color: tokens.textColor,
+                transparency: 50,
+                align: 'right',
+            });
+            break;
+        case 'dots':
+            slide.addShape(pptx.ShapeType.ellipse, {
+                x: '8%',
+                y: '93.5%',
+                w: '1%',
+                h: '1.6%',
+                fill: { color: accent },
+            });
+            slide.addShape(pptx.ShapeType.ellipse, {
+                x: '9.6%',
+                y: '93.5%',
+                w: '1%',
+                h: '1.6%',
+                fill: { color: accent, transparency: 65 },
+            });
+            slide.addText(`${slideNo}`, {
+                x: '88%',
+                y: '93%',
+                w: '4%',
+                h: '4%',
+                fontSize: 9,
+                fontFace: tokens.bodyFont,
+                color: tokens.textColor,
+                transparency: 50,
+                align: 'right',
+            });
+            break;
+        case 'number':
+            slide.addText(`${slideNo}`, {
+                x: '88%',
+                y: '93%',
+                w: '4%',
+                h: '4%',
+                fontSize: 10,
+                fontFace: tokens.bodyFont,
+                color: accent,
+                bold: true,
+                align: 'right',
+            });
+            break;
+        case 'plain':
+        default:
+            break;
+    }
+}
+function bulletRuns(bullets, tokens, fontSize) {
+    return bullets.map((b) => ({
+        text: b,
+        options: {
+            fontSize,
+            fontFace: tokens.bodyFont,
+            color: tokens.textColor,
+            bullet: { code: '2022' },
+            paraSpaceAfter: 8,
+        },
+    }));
+}
+function addBullets(slide, tokens, bullets, plan, opts) {
+    if (bullets.length === 0)
+        return;
+    slide.addText(bulletRuns(bullets, tokens, opts?.fontSize ?? plan.bodySize), {
+        x: opts?.x ?? '8%',
+        y: opts?.y ?? '26%',
+        w: opts?.w ?? '84%',
+        h: opts?.h ?? '62%',
+        valign: 'top',
+        lineSpacingMultiple: 1.2,
+    });
+}
+function renderCover(slide, pptx, tokens, title, subtitle, notes) {
+    const accent = tokens.accent;
+    const heading = tokens.headingFont;
+    const body = tokens.bodyFont;
+    const onAccent = 'FFFFFF';
+    switch (tokens.coverStyle) {
+        case 'split':
+            slide.addShape(pptx.ShapeType.rect, {
+                x: '0%',
+                y: '0%',
+                w: '42%',
+                h: '100%',
+                fill: { color: accent },
+            });
+            slide.addText(title, {
+                x: '5%',
+                y: '30%',
+                w: '33%',
+                h: '35%',
+                fontSize: 34,
+                fontFace: heading,
+                color: onAccent,
+                bold: true,
+                valign: 'middle',
+            });
+            if (subtitle) {
+                slide.addText(subtitle, {
+                    x: '48%',
+                    y: '35%',
+                    w: '46%',
+                    h: '30%',
+                    fontSize: 18,
+                    fontFace: body,
+                    color: tokens.textColor,
+                    valign: 'middle',
+                });
+            }
+            else if (notes) {
+                slide.addText(notes, {
+                    x: '48%',
+                    y: '35%',
+                    w: '46%',
+                    h: '30%',
+                    fontSize: 14,
+                    fontFace: body,
+                    color: tokens.textColor,
+                    transparency: 30,
+                    valign: 'middle',
+                });
+            }
+            break;
+        case 'centered':
+            slide.addText(title, {
+                x: '10%',
+                y: '30%',
+                w: '80%',
+                h: '25%',
+                fontSize: 38,
+                fontFace: heading,
+                color: tokens.textColor,
+                bold: true,
+                align: 'center',
+                valign: 'middle',
+            });
+            slide.addShape(pptx.ShapeType.rect, {
+                x: '45%',
+                y: '57%',
+                w: '10%',
+                h: '0.8%',
+                fill: { color: accent },
+            });
+            if (subtitle) {
+                slide.addText(subtitle, {
+                    x: '15%',
+                    y: '60%',
+                    w: '70%',
+                    h: '15%',
+                    fontSize: 18,
+                    fontFace: body,
+                    color: tokens.textColor,
+                    transparency: 30,
+                    align: 'center',
+                });
+            }
+            break;
+        case 'minimal':
+            slide.addText(title, {
+                x: '12%',
+                y: '38%',
+                w: '76%',
+                h: '20%',
+                fontSize: 34,
+                fontFace: heading,
+                color: tokens.textColor,
+                bold: false,
+            });
+            if (subtitle) {
+                slide.addText(subtitle, {
+                    x: '12%',
+                    y: '58%',
+                    w: '76%',
+                    h: '12%',
+                    fontSize: 16,
+                    fontFace: body,
+                    color: tokens.textColor,
+                    transparency: 40,
+                });
+            }
+            break;
+        case 'frame':
+            slide.addShape(pptx.ShapeType.rect, {
+                x: '5%',
+                y: '8%',
+                w: '90%',
+                h: '84%',
+                fill: { color: tokens.background },
+                line: { color: accent, width: 3 },
+            });
+            slide.addText(title, {
+                x: '12%',
+                y: '32%',
+                w: '76%',
+                h: '25%',
+                fontSize: 34,
+                fontFace: heading,
+                color: tokens.textColor,
+                bold: true,
+                align: 'center',
+                valign: 'middle',
+            });
+            if (subtitle) {
+                slide.addText(subtitle, {
+                    x: '15%',
+                    y: '58%',
+                    w: '70%',
+                    h: '15%',
+                    fontSize: 16,
+                    fontFace: body,
+                    color: tokens.textColor,
+                    transparency: 30,
+                    align: 'center',
+                });
+            }
+            break;
+        case 'band':
+            slide.addShape(pptx.ShapeType.rect, {
+                x: '0%',
+                y: '0%',
+                w: '100%',
+                h: '14%',
+                fill: { color: accent },
+            });
+            slide.addText(title, {
+                x: '8%',
+                y: '28%',
+                w: '84%',
+                h: '30%',
+                fontSize: 36,
+                fontFace: heading,
+                color: tokens.textColor,
+                bold: true,
+                valign: 'middle',
+            });
+            if (subtitle) {
+                slide.addText(subtitle, {
+                    x: '8%',
+                    y: '58%',
+                    w: '84%',
+                    h: '15%',
+                    fontSize: 18,
+                    fontFace: body,
+                    color: tokens.textColor,
+                    transparency: 30,
+                });
+            }
+            break;
+        case 'banner':
+        default:
+            slide.background = { color: accent };
+            slide.addText(title, {
+                x: '10%',
+                y: '28%',
+                w: '80%',
+                h: '30%',
+                fontSize: 36,
+                fontFace: heading,
+                color: onAccent,
+                bold: true,
+                align: 'center',
+                valign: 'middle',
+            });
+            if (subtitle) {
+                slide.addText(subtitle, {
+                    x: '12%',
+                    y: '58%',
+                    w: '76%',
+                    h: '15%',
+                    fontSize: 18,
+                    fontFace: body,
+                    color: onAccent,
+                    transparency: 20,
+                    align: 'center',
+                });
+            }
+            break;
+    }
+}
+function renderDivider(slide, pptx, tokens, title, subtitle, plan) {
+    slide.background = { color: tokens.accent };
+    slide.addText(title, {
+        x: '10%',
+        y: '34%',
+        w: '80%',
+        h: '20%',
+        fontSize: plan.titleSize + 4,
+        fontFace: tokens.headingFont,
+        color: 'FFFFFF',
+        bold: true,
+        align: 'center',
+        valign: 'middle',
+    });
+    if (subtitle) {
+        slide.addText(subtitle, {
+            x: '15%',
+            y: '56%',
+            w: '70%',
+            h: '12%',
+            fontSize: plan.bodySize + 2,
+            fontFace: tokens.bodyFont,
+            color: 'FFFFFF',
+            transparency: 20,
+            align: 'center',
+        });
+    }
+}
+function renderCards(slide, pptx, tokens, cards, plan) {
+    const count = Math.min(Math.max(cards.length, 1), 4);
+    const gap = 3;
+    const left = 8;
+    const width = (84 - gap * (count - 1)) / count;
+    const shape = shapeFor(tokens, pptx);
+    cards.slice(0, 4).forEach((card, i) => {
+        const x = left + i * (width + gap);
+        slide.addShape(shape, {
+            x: `${x}%`,
+            y: '27%',
+            w: `${width}%`,
+            h: '60%',
+            fill: { color: tokens.surface },
+            ...(shape === pptx.ShapeType.roundRect
+                ? { rectRadius: 0.08 }
+                : {}),
+        });
+        if (card.title) {
+            slide.addText(stripMd(String(card.title)), {
+                x: `${x + 1.5}%`,
+                y: '31%',
+                w: `${width - 3}%`,
+                h: '14%',
+                fontSize: plan.bodySize + 1,
+                fontFace: tokens.headingFont,
+                color: tokens.accent,
+                bold: true,
+            });
+        }
+        if (card.text) {
+            slide.addText(stripMd(String(card.text)), {
+                x: `${x + 1.5}%`,
+                y: card.title ? '45%' : '31%',
+                w: `${width - 3}%`,
+                h: '36%',
+                fontSize: plan.bodySize - 1,
+                fontFace: tokens.bodyFont,
+                color: tokens.textColor,
+                valign: 'top',
+                lineSpacingMultiple: 1.25,
+            });
+        }
+    });
+}
+function renderStats(slide, pptx, tokens, stats, plan) {
+    const count = Math.min(Math.max(stats.length, 1), 4);
+    const gap = 4;
+    const left = 8;
+    const width = (84 - gap * (count - 1)) / count;
+    const shape = shapeFor(tokens, pptx);
+    stats.slice(0, 4).forEach((stat, i) => {
+        const x = left + i * (width + gap);
+        slide.addShape(shape, {
+            x: `${x}%`,
+            y: '30%',
+            w: `${width}%`,
+            h: '52%',
+            fill: { color: tokens.surface },
+            ...(shape === pptx.ShapeType.roundRect
+                ? { rectRadius: 0.1 }
+                : {}),
+        });
+        slide.addText(stripMd(String(stat.value ?? '')), {
+            x: `${x}%`,
+            y: '36%',
+            w: `${width}%`,
+            h: '20%',
+            fontSize: plan.titleSize + 4,
+            fontFace: tokens.headingFont,
+            color: tokens.accent,
+            bold: true,
+            align: 'center',
+        });
+        if (stat.label) {
+            slide.addText(stripMd(String(stat.label)), {
+                x: `${x}%`,
+                y: '56%',
+                w: `${width}%`,
+                h: '20%',
+                fontSize: plan.bodySize,
+                fontFace: tokens.bodyFont,
+                color: tokens.textColor,
+                align: 'center',
+                valign: 'top',
+            });
+        }
+    });
+}
+function renderTable(slide, tokens, rows, plan) {
+    const clean = rows
+        .map((r) => Array.isArray(r) ? r.map((c) => stripMd(String(c ?? ''))) : [])
+        .filter((r) => r.length > 0);
+    if (clean.length === 0)
+        return false;
+    const colCount = Math.max(...clean.map((r) => r.length));
+    const tableRows = clean.map((cells, rowIdx) => Array.from({ length: colCount }, (_, c) => ({
+        text: cells[c] ?? '',
+        options: {
+            fontSize: rowIdx === 0 ? plan.bodySize : plan.bodySize - 1,
+            fontFace: rowIdx === 0 ? tokens.headingFont : tokens.bodyFont,
+            bold: rowIdx === 0,
+            color: rowIdx === 0 ? 'FFFFFF' : tokens.textColor,
+            fill: {
+                color: rowIdx === 0
+                    ? tokens.accent
+                    : rowIdx % 2 === 0
+                        ? tokens.surface
+                        : tokens.background,
+            },
+            valign: 'middle',
+            margin: 4,
+        },
+    })));
+    slide.addTable(tableRows, {
+        x: '8%',
+        y: '26%',
+        w: '84%',
+        border: { color: tokens.textColor, pt: 0.5 },
+    });
+    return true;
+}
 class PptxDeckTool {
     key = 'pptx-render';
     async run(params) {
-        const outlineMd = String(params.outlineMd ?? '');
-        const themeName = String(params.theme ?? 'default');
-        const aspect = String(params.aspect ?? '16:9');
-        if (!outlineMd.trim()) {
-            return { outputs: [], error: 'No outline provided' };
+        const aspect = params.aspect === '4:3' ? '4:3' : '16:9';
+        const deckJsonRaw = params.deckJson ?? params.deck_spec ?? params.spec;
+        const outlineMd = typeof params.outlineMd === 'string' ? params.outlineMd : '';
+        const { tokens, templateId, warnings } = resolveDeckTokens(params);
+        const fallbacks = [...warnings];
+        const log = [];
+        // -- legacy path: markdown outline, no deck.json -------------------------
+        if (deckJsonRaw === undefined ||
+            deckJsonRaw === null ||
+            deckJsonRaw === '') {
+            if (!outlineMd.trim()) {
+                return {
+                    outputs: [],
+                    error: 'No deck provided (deckJson or legacy outlineMd)',
+                };
+            }
+            return this.runLegacy(params, outlineMd, tokens, templateId, aspect, fallbacks, log);
         }
-        const theme = THEMES[themeName] ?? THEMES.default;
-        const { docTitle, slides: slideData } = parseOutline(outlineMd);
-        if (slideData.length === 0) {
+        let spec;
+        try {
+            spec = parseDeckSpec(deckJsonRaw);
+        }
+        catch (err) {
             return {
                 outputs: [],
-                error: 'No slides found in outline (use ## for slide titles)',
+                error: err instanceof Error ? err.message : String(err),
             };
         }
+        const plan = planDeck(spec, { density: tokens.density, aspect });
+        const layoutsUsed = [];
+        for (const p of plan) {
+            layoutsUsed.push(p.layout);
+            if (p.degradedFrom)
+                fallbacks.push(`slide ${p.index + 1}: unknown layout "${p.degradedFrom}" degraded to bullets`);
+        }
         const pptx = new pptxgenjs_1.default();
         pptx.layout = aspect === '4:3' ? 'LAYOUT_4x3' : 'LAYOUT_16x9';
         pptx.author = 'TeamShare';
+        const docTitle = (typeof spec.title === 'string' && spec.title) ||
+            this.inferTitle(spec) ||
+            'Presentation';
         pptx.title = docTitle;
-        // Title slide
-        const titleSlide = pptx.addSlide();
-        titleSlide.background = { color: theme.accent };
-        titleSlide.addText(docTitle, {
-            x: '10%',
-            y: '30%',
-            w: '80%',
-            h: '30%',
-            fontSize: 36,
-            fontFace: 'Arial',
-            color: 'FFFFFF',
-            bold: true,
-            align: 'center',
-            valign: 'middle',
-        });
-        titleSlide.addText(`Generated by TeamShare`, {
-            x: '10%',
-            y: '65%',
-            w: '80%',
-            h: '10%',
-            fontSize: 14,
-            fontFace: 'Arial',
-            color: 'FFFFFFCC',
-            align: 'center',
-        });
-        // Content slides
-        for (const slide of slideData) {
+        spec.slides.forEach((slide, idx) => {
+            const p = plan[idx];
             const s = pptx.addSlide();
-            s.background = { color: theme.bg };
-            // Slide number
-            s.addText(`${slideData.indexOf(slide) + 1}`, {
-                x: '92%',
-                y: '92%',
-                w: '6%',
-                h: '5%',
-                fontSize: 10,
-                color: theme.color + '80',
-                align: 'center',
-            });
-            // Title
-            s.addText(slide.title, {
-                x: '8%',
-                y: '8%',
-                w: '84%',
-                h: '15%',
-                fontSize: 28,
-                fontFace: 'Arial',
-                color: theme.titleColor,
-                bold: true,
+            s.background = { color: tokens.background };
+            const title = typeof slide.title === 'string' ? stripMd(slide.title) : '';
+            const subtitle = typeof slide.subtitle === 'string'
+                ? stripMd(slide.subtitle)
+                : undefined;
+            const notes = typeof slide.notes === 'string' && slide.notes.trim()
+                ? slide.notes.trim()
+                : undefined;
+            const slideNo = idx + 1;
+            switch (p.layout) {
+                case 'title':
+                    renderCover(s, pptx, tokens, title || docTitle, subtitle ?? this.firstBullets(slide), notes);
+                    break;
+                case 'section':
+                    renderDivider(s, pptx, tokens, title || `Section ${slideNo}`, subtitle, p);
+                    break;
+                case 'closing':
+                    renderCover(s, pptx, tokens, title || 'Thank you', subtitle, notes);
+                    break;
+                case 'agenda':
+                    addTitleBlock(s, pptx, tokens, title || 'Agenda', slideNo, p);
+                    addBullets(s, tokens, p.bullets.length > 0 ? p.bullets : asStringArray(slide.bullets), p);
+                    addFooter(s, pptx, tokens, slideNo);
+                    break;
+                case 'statement':
+                    s.addText(title || this.firstBullets(slide) || docTitle, {
+                        x: '10%',
+                        y: '32%',
+                        w: '80%',
+                        h: '30%',
+                        fontSize: p.titleSize,
+                        fontFace: tokens.headingFont,
+                        color: tokens.textColor,
+                        bold: true,
+                        align: 'center',
+                        valign: 'middle',
+                    });
+                    if (subtitle) {
+                        s.addText(subtitle, {
+                            x: '15%',
+                            y: '62%',
+                            w: '70%',
+                            h: '12%',
+                            fontSize: p.bodySize,
+                            fontFace: tokens.bodyFont,
+                            color: tokens.textColor,
+                            transparency: 30,
+                            align: 'center',
+                        });
+                    }
+                    addFooter(s, pptx, tokens, slideNo);
+                    break;
+                case 'two-column': {
+                    addTitleBlock(s, pptx, tokens, title || `Slide ${slideNo}`, slideNo, p);
+                    const cols = this.coerceColumns(slide.columns);
+                    const left = cols[0];
+                    const right = cols[1];
+                    if (left) {
+                        if (left.heading) {
+                            s.addText(left.heading, {
+                                x: '8%',
+                                y: '27%',
+                                w: '38%',
+                                h: '10%',
+                                fontSize: p.bodySize + 1,
+                                fontFace: tokens.headingFont,
+                                color: tokens.accent,
+                                bold: true,
+                            });
+                        }
+                        addBullets(s, tokens, trimBullets(left.bullets, tokens.density), p, {
+                            x: '8%',
+                            y: left.heading ? '37%' : '27%',
+                            w: '38%',
+                            h: '55%',
+                        });
+                    }
+                    if (right) {
+                        if (right.heading) {
+                            s.addText(right.heading, {
+                                x: '54%',
+                                y: '27%',
+                                w: '38%',
+                                h: '10%',
+                                fontSize: p.bodySize + 1,
+                                fontFace: tokens.headingFont,
+                                color: tokens.accent,
+                                bold: true,
+                            });
+                        }
+                        addBullets(s, tokens, trimBullets(right.bullets, tokens.density), p, {
+                            x: '54%',
+                            y: right.heading ? '37%' : '27%',
+                            w: '38%',
+                            h: '55%',
+                        });
+                    }
+                    if (!left && !right)
+                        addBullets(s, tokens, p.bullets, p);
+                    addFooter(s, pptx, tokens, slideNo);
+                    break;
+                }
+                case 'cards': {
+                    addTitleBlock(s, pptx, tokens, title || `Slide ${slideNo}`, slideNo, p);
+                    const cards = this.coerceCards(slide.cards);
+                    if (cards.length > 0)
+                        renderCards(s, pptx, tokens, cards, p);
+                    else
+                        addBullets(s, tokens, p.bullets, p);
+                    addFooter(s, pptx, tokens, slideNo);
+                    break;
+                }
+                case 'stats': {
+                    addTitleBlock(s, pptx, tokens, title || `Slide ${slideNo}`, slideNo, p);
+                    const stats = this.coerceStats(slide.stats);
+                    if (stats.length > 0)
+                        renderStats(s, pptx, tokens, stats, p);
+                    else
+                        addBullets(s, tokens, p.bullets, p);
+                    addFooter(s, pptx, tokens, slideNo);
+                    break;
+                }
+                case 'timeline': {
+                    addTitleBlock(s, pptx, tokens, title || 'Timeline', slideNo, p);
+                    const entries = this.coerceTimeline(slide.rows);
+                    if (entries.length > 0) {
+                        const rowH = Math.min(14, Math.floor(58 / Math.max(entries.length, 1)));
+                        entries.slice(0, 6).forEach((entry, i) => {
+                            const y = 28 + i * (rowH + 2);
+                            s.addShape(pptx.ShapeType.ellipse, {
+                                x: '8%',
+                                y: `${y + 1}%`,
+                                w: '1.6%',
+                                h: '2.6%',
+                                fill: { color: tokens.accent },
+                            });
+                            if (i < entries.length - 1) {
+                                s.addShape(pptx.ShapeType.rect, {
+                                    x: '8.7%',
+                                    y: `${y + 3.6}%`,
+                                    w: '0.2%',
+                                    h: `${rowH - 1}%`,
+                                    fill: { color: tokens.accent, transparency: 65 },
+                                });
+                            }
+                            const head = [entry.date, entry.title]
+                                .filter(Boolean)
+                                .join(' — ');
+                            s.addText(head, {
+                                x: '11%',
+                                y: `${y}%`,
+                                w: '81%',
+                                h: '5%',
+                                fontSize: p.bodySize,
+                                fontFace: tokens.headingFont,
+                                color: tokens.accent,
+                                bold: true,
+                            });
+                            if (entry.text) {
+                                s.addText(entry.text, {
+                                    x: '11%',
+                                    y: `${y + 5}%`,
+                                    w: '81%',
+                                    h: `${Math.max(rowH - 5, 4)}%`,
+                                    fontSize: p.bodySize - 1,
+                                    fontFace: tokens.bodyFont,
+                                    color: tokens.textColor,
+                                    valign: 'top',
+                                });
+                            }
+                        });
+                    }
+                    else {
+                        addBullets(s, tokens, p.bullets, p);
+                    }
+                    addFooter(s, pptx, tokens, slideNo);
+                    break;
+                }
+                case 'quote': {
+                    const q = this.coerceQuote(slide.quote) ?? { text: title || this.firstBullets(slide) || docTitle };
+                    s.addText(`“${q.text}”`, {
+                        x: '12%',
+                        y: '30%',
+                        w: '76%',
+                        h: '32%',
+                        fontSize: p.titleSize - 4,
+                        fontFace: tokens.headingFont,
+                        color: tokens.textColor,
+                        italic: true,
+                        align: 'center',
+                        valign: 'middle',
+                    });
+                    if (q.attribution) {
+                        s.addText(`— ${q.attribution}`, {
+                            x: '12%',
+                            y: '62%',
+                            w: '76%',
+                            h: '10%',
+                            fontSize: p.bodySize,
+                            fontFace: tokens.bodyFont,
+                            color: tokens.accent,
+                            align: 'center',
+                        });
+                    }
+                    addFooter(s, pptx, tokens, slideNo);
+                    break;
+                }
+                case 'table': {
+                    addTitleBlock(s, pptx, tokens, title || `Slide ${slideNo}`, slideNo, p);
+                    const rows = this.coerceTableRows(slide.rows);
+                    if (!renderTable(s, tokens, rows, p)) {
+                        fallbacks.push(`slide ${slideNo}: table has no rows, rendered bullets instead`);
+                        addBullets(s, tokens, p.bullets, p);
+                    }
+                    addFooter(s, pptx, tokens, slideNo);
+                    break;
+                }
+                case 'sources':
+                    addTitleBlock(s, pptx, tokens, title || 'Sources', slideNo, p);
+                    addBullets(s, tokens, p.bullets, p, {
+                        fontSize: Math.max(planBodyFloor(p.bodySize) - 2, 10),
+                    });
+                    addFooter(s, pptx, tokens, slideNo);
+                    break;
+                case 'bullets':
+                default:
+                    addTitleBlock(s, pptx, tokens, title || `Slide ${slideNo}`, slideNo, p);
+                    addBullets(s, tokens, p.bullets, p);
+                    addFooter(s, pptx, tokens, slideNo);
+                    break;
+            }
+            if (notes)
+                s.addNotes(notes);
+        });
+        const buffer = (await pptx.write({ outputType: 'nodebuffer' }));
+        const base = (0, output_name_1.outputBaseName)(params);
+        const safeName = docTitle.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64);
+        const pptxName = base ? `${base} — Deck.pptx` : `${safeName}.pptx`;
+        const outputs = [
+            {
+                buffer,
+                fileName: pptxName,
+                mime: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+            },
+        ];
+        const notesMd = this.buildSpeakerNotes(spec, docTitle);
+        if (notesMd) {
+            outputs.push({
+                buffer: Buffer.from(notesMd, 'utf8'),
+                fileName: base
+                    ? `${base} — Speaker Notes.md`
+                    : `${safeName} — Speaker Notes.md`,
+                mime: 'text/markdown',
             });
-            // Accent bar under title
-            s.addShape(pptx.ShapeType.rect, {
-                x: '8%',
-                y: '23%',
-                w: '15%',
-                h: '0.5%',
-                fill: { color: theme.accent },
-            });
-            // Bullets
-            if (slide.bullets.length > 0) {
-                const bulletText = slide.bullets.map((b) => ({
-                    text: b,
-                    options: {
-                        fontSize: 16,
-                        fontFace: 'Arial',
-                        color: theme.color,
-                        bullet: { code: '2022' },
-                        paraSpaceAfter: 8,
-                    },
-                }));
-                s.addText(bulletText, {
-                    x: '8%',
-                    y: '28%',
-                    w: '84%',
-                    h: '60%',
-                    valign: 'top',
-                    lineSpacingMultiple: 1.2,
-                });
+        }
+        log.push(`Template: ${templateId}`, `Slides: ${spec.slides.length}`, `Density: ${tokens.density}, Aspect: ${aspect}`, `Layouts: ${layoutsUsed.join(', ')}`, ...fallbacks.map((f) => `Fallback: ${f}`), `Generated PPTX: ${pptxName} (${buffer.length} bytes)`);
+        return { outputs, log };
+    }
+    inferTitle(spec) {
+        const first = spec.slides[0];
+        if (first && typeof first.title === 'string' && first.title.trim()) {
+            return stripMd(first.title);
+        }
+        return undefined;
+    }
+    firstBullets(slide) {
+        const bullets = asStringArray(slide.bullets);
+        return bullets[0];
+    }
+    coerceColumns(value) {
+        if (!Array.isArray(value))
+            return [];
+        return value.slice(0, 2).map((col) => {
+            if (typeof col === 'string')
+                return { bullets: [stripMd(col)] };
+            if (col && typeof col === 'object') {
+                const c = col;
+                const heading = typeof c.heading === 'string' ? stripMd(c.heading) : undefined;
+                const bullets = asStringArray(c.bullets ?? c.body ?? c.text);
+                const single = typeof c.body === 'string' && !Array.isArray(c.bullets)
+                    ? [stripMd(c.body)]
+                    : bullets;
+                return { heading, bullets: single };
             }
-            // Speaker notes
-            if (slide.notes) {
-                s.addNotes(slide.notes);
+            return { bullets: [] };
+        });
+    }
+    coerceCards(value) {
+        if (!Array.isArray(value))
+            return [];
+        return value.slice(0, 4).map((card) => {
+            if (typeof card === 'string')
+                return { text: stripMd(card) };
+            if (card && typeof card === 'object') {
+                const c = card;
+                return {
+                    title: typeof c.title === 'string' ? stripMd(c.title) : undefined,
+                    text: typeof c.text === 'string' ? stripMd(c.text) : undefined,
+                };
+            }
+            return {};
+        });
+    }
+    coerceStats(value) {
+        if (!Array.isArray(value))
+            return [];
+        return value.slice(0, 4).map((stat) => {
+            if (typeof stat === 'string')
+                return { value: stripMd(stat) };
+            if (stat && typeof stat === 'object') {
+                const c = stat;
+                return {
+                    value: typeof c.value === 'string' ? stripMd(c.value) : undefined,
+                    label: typeof c.label === 'string' ? stripMd(c.label) : undefined,
+                };
+            }
+            return {};
+        });
+    }
+    coerceTimeline(value) {
+        if (!Array.isArray(value))
+            return [];
+        return value.slice(0, 6).map((row) => {
+            if (typeof row === 'string')
+                return { title: stripMd(row) };
+            if (Array.isArray(row)) {
+                const [date, title, text] = row.map((c) => typeof c === 'string' ? stripMd(c) : '');
+                return {
+                    date: date || undefined,
+                    title: title || undefined,
+                    text: text || undefined,
+                };
+            }
+            if (row && typeof row === 'object') {
+                const c = row;
+                return {
+                    date: typeof c.date === 'string' ? stripMd(c.date) : undefined,
+                    title: typeof c.title === 'string' ? stripMd(c.title) : undefined,
+                    text: typeof c.text === 'string' ? stripMd(c.text) : undefined,
+                };
+            }
+            return {};
+        });
+    }
+    coerceQuote(value) {
+        if (typeof value === 'string' && value.trim())
+            return { text: stripMd(value) };
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            const c = value;
+            if (typeof c.text === 'string' && c.text.trim()) {
+                return {
+                    text: stripMd(c.text),
+                    attribution: typeof c.attribution === 'string'
+                        ? stripMd(c.attribution)
+                        : undefined,
+                };
             }
         }
-        const buffer = await pptx.write({ outputType: 'nodebuffer' });
-        const safeName = docTitle.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64);
+        return null;
+    }
+    coerceTableRows(value) {
+        if (!Array.isArray(value))
+            return [];
+        return value.map((row) => {
+            if (Array.isArray(row))
+                return row.map((c) => (typeof c === 'string' ? c : String(c ?? '')));
+            if (row && typeof row === 'object')
+                return Object.values(row).map((c) => typeof c === 'string'
+                    ? c
+                    : typeof c === 'number' || typeof c === 'boolean'
+                        ? String(c)
+                        : '');
+            return [typeof row === 'string' ? row : String(row ?? '')];
+        });
+    }
+    buildSpeakerNotes(spec, docTitle) {
+        const withNotes = spec.slides
+            .map((slide, idx) => ({ slide, idx }))
+            .filter(({ slide }) => typeof slide.notes === 'string' && slide.notes.trim());
+        if (withNotes.length === 0)
+            return null;
+        const lines = [`# ${docTitle}`, ''];
+        for (const { slide, idx } of withNotes) {
+            const title = typeof slide.title === 'string' && slide.title.trim()
+                ? stripMd(slide.title)
+                : `Slide ${idx + 1}`;
+            lines.push(`## Slide ${idx + 1}: ${title}`, String(slide.notes).trim(), '');
+        }
+        return lines.join('\n');
+    }
+    async runLegacy(params, outlineMd, tokens, templateId, aspect, fallbacks, log) {
+        const { docTitle, slides: slideData } = parseOutline(outlineMd);
+        if (slideData.length === 0) {
+            return {
+                outputs: [],
+                error: 'No slides found in outline (use ## for slide titles)',
+            };
+        }
+        fallbacks.push('legacy outline');
+        const pptx = new pptxgenjs_1.default();
+        pptx.layout = aspect === '4:3' ? 'LAYOUT_4x3' : 'LAYOUT_16x9';
+        pptx.author = 'TeamShare';
+        pptx.title = docTitle;
+        const cover = pptx.addSlide();
+        renderCover(cover, pptx, tokens, docTitle, undefined, undefined);
+        slideData.forEach((slide, i) => {
+            const s = pptx.addSlide();
+            s.background = { color: tokens.background };
+            const plan = {
+                index: i,
+                layout: 'bullets',
+                titleSize: tokens.density === 'airy'
+                    ? 32
+                    : tokens.density === 'compact'
+                        ? 24
+                        : 28,
+                bodySize: tokens.density === 'airy'
+                    ? 18
+                    : tokens.density === 'compact'
+                        ? 14
+                        : 16,
+                columns: 1,
+                bullets: trimBullets(slide.bullets, tokens.density),
+            };
+            addTitleBlock(s, pptx, tokens, slide.title || `Slide ${i + 1}`, i + 2, plan);
+            addBullets(s, tokens, plan.bullets, plan);
+            if (slide.notes)
+                s.addNotes(slide.notes);
+            addFooter(s, pptx, tokens, i + 2);
+        });
+        const buffer = (await pptx.write({ outputType: 'nodebuffer' }));
         const base = (0, output_name_1.outputBaseName)(params);
+        const safeName = docTitle.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64);
+        const pptxName = base ? `${base} — Deck.pptx` : `${safeName}.pptx`;
+        log.push(`Template: ${templateId}`, `Slides: ${slideData.length + 1} (1 title + ${slideData.length} content)`, `Density: ${tokens.density}, Aspect: ${aspect}`, 'Layouts: title, bullets', ...fallbacks.map((f) => `Fallback: ${f}`), `Generated PPTX: ${pptxName} (${buffer.length} bytes)`);
         return {
             outputs: [
                 {
-                    buffer: buffer,
-                    fileName: base ? `${base} — Deck.pptx` : `${safeName}.pptx`,
+                    buffer,
+                    fileName: pptxName,
                     mime: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
                 },
             ],
-            log: [
-                `Generated PPTX: ${safeName}.pptx`,
-                `Title: ${docTitle}`,
-                `Slides: ${slideData.length + 1} (1 title + ${slideData.length} content)`,
-                `Theme: ${themeName}, Aspect: ${aspect}`,
-            ],
+            log,
         };
     }
 }
 exports.PptxDeckTool = PptxDeckTool;
+function planBodyFloor(bodySize) {
+    return Math.max(Math.min(bodySize, 18), 12);
+}
 //# sourceMappingURL=pptx-deck.js.map