@tycoworks/tycoslide 0.8.0 → 0.10.0

package/dist/manifest.js

@@ -1,5 +1,5 @@
 import { templateKeys } from "./markdown/textTemplate.js";
-import { CompilerSlotType, ParameterType } from "./markdown/types.js";
+import { ParameterType } from "./markdown/types.js";
 /**
  * Flatten a compiler parameter to the manifest entries advertised to AI authors.
  * A template parameter has no top-level key — its template's keys are the keys, so it
@@ -24,42 +24,34 @@ function stripParameter(param) {
             const result = { key: param.key, type: param.type };
             if (param.required)
                 result.required = true;
-            if (param.limit)
-                result.limit = param.limit;
             return [result];
         }
     }
 }
 function stripSlot(slot) {
-    const result = { key: slot.key, type: slot.type };
+    const result = { key: slot.key, accepts: slot.accepts.map((b) => b.type) };
     if (slot.required)
         result.required = true;
     if (slot.limit)
         result.limit = slot.limit;
-    switch (slot.type) {
-        case CompilerSlotType.Text:
-        case CompilerSlotType.Table:
-            // No fields beyond the shared key/type/required/limit.
-            break;
-        case CompilerSlotType.Code:
-            result.codeTheme = slot.codeTheme;
-            break;
-        case CompilerSlotType.Mermaid:
-            result.mermaidVariant = slot.mermaidVariant;
-            break;
-    }
     return result;
 }
 export function generateManifest(config, options) {
-    const layouts = config.layouts.map((layout) => ({
-        name: layout.name,
-        slideNumber: layout.slideNumber,
-        description: layout.description,
-        whenToUse: layout.whenToUse,
-        whenNotToUse: layout.whenNotToUse,
-        parameters: layout.parameters.flatMap(stripParameter),
-        slots: layout.slots.map(stripSlot),
-    }));
+    const layouts = config.layouts.map((layout) => {
+        const ml = {
+            name: layout.name,
+            slideNumber: layout.slideNumber,
+            parameters: layout.parameters.flatMap(stripParameter),
+            slots: layout.slots.map(stripSlot),
+        };
+        if (layout.description !== undefined)
+            ml.description = layout.description;
+        if (layout.whenToUse !== undefined)
+            ml.whenToUse = layout.whenToUse;
+        if (layout.whenNotToUse !== undefined)
+            ml.whenNotToUse = layout.whenNotToUse;
+        return ml;
+    });
     const assets = {};
     for (const [category, entries] of Object.entries(config.assets)) {
         assets[category] = {};

package/dist/markdown/blocks/code.d.ts

@@ -0,0 +1,17 @@
+import type { StyledParagraph } from "../../engine/index.js";
+import { type BlockHandler } from "../types.js";
+/**
+ * Recognize a fenced code block (any language except mermaid) at a region's top
+ * level, folding it to a Text fill, and compile it by Shiki-highlighting its
+ * source into a TextFill. Theme resolution is strict: the theme MUST declare a
+ * `codeTheme` — either one Shiki id (one style per theme — the design-system
+ * framing) or a `{ light, dark }` pair the layout's `variant` selects (a pair
+ * with no layout `variant` throws). A deck with code fences but no theme-level
+ * `codeTheme` throws, naming the offending slot.
+ */
+export declare const CODE: BlockHandler;
+/**
+ * Run Shiki over a code block, producing StyledParagraph[] with per-token
+ * color runs. Blank lines become paragraphs with a single empty run.
+ */
+export declare function highlightCode(code: string, language: string, theme: string): Promise<StyledParagraph[]>;

package/dist/markdown/blocks/code.js

@@ -0,0 +1,65 @@
+import { MdastType } from "../mdast.js";
+import { AcceptType } from "../types.js";
+import { MERMAID_LANG } from "./mermaid.js";
+/**
+ * Recognize a fenced code block (any language except mermaid) at a region's top
+ * level, folding it to a Text fill, and compile it by Shiki-highlighting its
+ * source into a TextFill. Theme resolution is strict: the theme MUST declare a
+ * `codeTheme` — either one Shiki id (one style per theme — the design-system
+ * framing) or a `{ light, dark }` pair the layout's `variant` selects (a pair
+ * with no layout `variant` throws). A deck with code fences but no theme-level
+ * `codeTheme` throws, naming the offending slot.
+ */
+export const CODE = {
+    match: (node) => node.type === MdastType.Code && node.lang !== MERMAID_LANG,
+    acceptType: AcceptType.Text,
+    compile: async (node, ctx) => {
+        const code = node;
+        // A fence with no language can't be highlighted (no Shiki grammar to pick),
+        // so fail fast naming the slot rather than attempt a language-less highlight.
+        if (!code.lang) {
+            throw new Error(`Slide ${ctx.slideIdx}: layout "${ctx.layoutName}" slot content (from ${ctx.source}) has a code fence ` +
+                "with no language; add one after the opening ``` (e.g. ```sql).");
+        }
+        const codeTheme = ctx.config.codeTheme;
+        if (!codeTheme) {
+            throw new Error(`Layout "${ctx.layoutName}" slot content (from ${ctx.source}): deck contains a code fence but the theme ` +
+                'declares no "codeTheme". Add a theme-level "codeTheme" (a Shiki theme id) to theme.json.');
+        }
+        // A single string is one style for every code layout; a `{ light, dark }`
+        // pair requires the layout to declare which via `variant` — no default.
+        let theme;
+        if (typeof codeTheme === "string") {
+            theme = codeTheme;
+        }
+        else if (ctx.layoutVariant) {
+            theme = codeTheme[ctx.layoutVariant];
+        }
+        else {
+            throw new Error(`Layout "${ctx.layoutName}" slot content (from ${ctx.source}): the theme's "codeTheme" is a ` +
+                '{ light, dark } pair, but this layout declares no "variant". Add variant: "light" or "dark" to the layout.');
+        }
+        return { paragraphs: await highlightCode(code.value, code.lang, theme) };
+    },
+};
+/**
+ * Run Shiki over a code block, producing StyledParagraph[] with per-token
+ * color runs. Blank lines become paragraphs with a single empty run.
+ */
+export async function highlightCode(code, language, theme) {
+    const { createHighlighter } = await import("shiki");
+    const lang = language;
+    const thm = theme;
+    const highlighter = await createHighlighter({ themes: [thm], langs: [lang] });
+    const { tokens } = highlighter.codeToTokens(code, { lang, theme: thm });
+    return tokens.map((line) => ({
+        runs: line.length === 0
+            ? [{ text: "" }]
+            : line.map((token) => {
+                const run = { text: token.content };
+                if (token.color)
+                    run.color = token.color.replace(/^#/, "");
+                return run;
+            }),
+    }));
+}

package/dist/markdown/blocks/image.d.ts

@@ -0,0 +1,2 @@
+import { type BlockHandler } from "../types.js";
+export declare const IMAGE: BlockHandler;

package/dist/markdown/blocks/image.js

@@ -0,0 +1,9 @@
+import { MdastType } from "../mdast.js";
+import { AcceptType } from "../types.js";
+export const IMAGE = {
+    match: (node) => node.type === MdastType.Image,
+    acceptType: AcceptType.Image,
+    // `node.url` is the raw `$category.name` ref; `resolveAssetRef` validates and
+    // resolves it (fail-fast on a malformed or unknown reference). `alt` is ignored.
+    compile: async (node, ctx) => ctx.resolveAssetRef(node.url),
+};

package/dist/markdown/blocks/mermaid.d.ts

@@ -0,0 +1,15 @@
+import { type BlockHandler } from "../types.js";
+/** The markdown code-fence *language* that selects mermaid rendering. The CODE
+ * handler reuses this to exclude mermaid so the two fence kinds match disjointly
+ * on `lang`. */
+export declare const MERMAID_LANG = "mermaid";
+/**
+ * Recognize a ```mermaid fenced block at a region's top level, folding it to an
+ * Image fill, and compile it by rendering the definition to a PNG (cached under
+ * `<outputDir>/.tycoslide-cache/mermaid/<hash>.png`) and wrapping it as an
+ * ImageFill. Fit is always `contain` — mermaid diagrams are shown in their
+ * entirety. Resolution is strict: the theme MUST carry a `mermaid` block, MUST
+ * declare a `mermaidVariant`, and that variant MUST exist — each missing piece
+ * throws by name.
+ */
+export declare const MERMAID: BlockHandler;

package/dist/markdown/blocks/mermaid.js

@@ -0,0 +1,227 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { extname, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { ImageFit, SlotType } from "../../engine/index.js";
+import { MdastType } from "../mdast.js";
+import { AcceptType } from "../types.js";
+import { buildMermaidRenderConfig, injectClassDefs, validateMermaidDefinition, } from "./mermaidTheme.js";
+/** The markdown code-fence *language* that selects mermaid rendering. The CODE
+ * handler reuses this to exclude mermaid so the two fence kinds match disjointly
+ * on `lang`. */
+export const MERMAID_LANG = "mermaid";
+/**
+ * Recognize a ```mermaid fenced block at a region's top level, folding it to an
+ * Image fill, and compile it by rendering the definition to a PNG (cached under
+ * `<outputDir>/.tycoslide-cache/mermaid/<hash>.png`) and wrapping it as an
+ * ImageFill. Fit is always `contain` — mermaid diagrams are shown in their
+ * entirety. Resolution is strict: the theme MUST carry a `mermaid` block, MUST
+ * declare a `mermaidVariant`, and that variant MUST exist — each missing piece
+ * throws by name.
+ */
+export const MERMAID = {
+    match: (node) => node.type === MdastType.Code && node.lang === MERMAID_LANG,
+    acceptType: AcceptType.Image,
+    compile: async (node, ctx) => {
+        const definition = node.value;
+        const { config } = ctx;
+        if (!config.mermaid) {
+            throw new Error('Deck contains mermaid diagrams, but theme has no "mermaid" block. ' +
+                "Add mermaid color configuration to theme.json.");
+        }
+        const variantName = config.mermaidVariant;
+        if (variantName === undefined) {
+            throw new Error(`Layout "${ctx.layoutName}" slot content (from ${ctx.source}): deck contains a mermaid diagram but the theme ` +
+                'declares no "mermaidVariant". Add a theme-level "mermaidVariant" naming a "mermaid" entry to theme.json.');
+        }
+        const variant = config.mermaid[variantName];
+        if (!variant) {
+            throw new Error(`Slide layout "${ctx.layoutName}": mermaid variant "${variantName}" not found in theme. ` +
+                `Available variants: ${Object.keys(config.mermaid).join(", ")}`);
+        }
+        const cacheDir = ensureCacheDir(config);
+        const pngPath = await renderOne(definition, variantName, variant, cacheDir, config);
+        return { type: SlotType.Image, path: pngPath, fit: ImageFit.Contain };
+    },
+};
+const FONT_FORMATS = {
+    ".woff2": "woff2",
+    ".woff": "woff",
+    ".ttf": "truetype",
+    ".otf": "opentype",
+};
+/** The `#output` div's DOM contract, shared by the in-page script and the
+ * Playwright poller — one const so a rename can't drift the two sides into a
+ * silent 30s timeout. */
+const RENDER_SIGNAL_ATTR = "data-render-signal";
+const RENDER_ERROR_ATTR = "data-render-error";
+const RenderSignal = { Pending: "pending", Done: "done" };
+function hashKey(definition, variantName, renderConfig, fonts) {
+    const hash = createHash("sha256")
+        .update(variantName)
+        .update("\n")
+        .update(definition)
+        .update("\n")
+        .update(JSON.stringify(renderConfig));
+    for (const f of fonts)
+        hash.update("\n").update(`${f.family}:${f.weight}:${f.url}`);
+    return hash.digest("hex").slice(0, 16);
+}
+function ensureCacheDir(config) {
+    const base = resolve(config.outputDir ?? process.cwd(), ".tycoslide-cache", "mermaid");
+    mkdirSync(base, { recursive: true });
+    return base;
+}
+/**
+ * Resolve each theme font's `path` to an absolute `file://` URL. A bare specifier
+ * (`@fontsource/inter/files/...`) resolves through the theme's node_modules; a
+ * `./`- or `/`-prefixed path resolves against `rootDir`. A missing file fails fast
+ * naming the family + path — never a silent skip.
+ */
+function resolveFonts(rootDir, fonts) {
+    const require = createRequire(join(rootDir, "package.json"));
+    return fonts.map((font) => {
+        const isFsPath = font.path.startsWith(".") || font.path.startsWith("/");
+        let absPath;
+        if (isFsPath) {
+            absPath = resolve(rootDir, font.path);
+        }
+        else {
+            try {
+                absPath = require.resolve(font.path);
+            }
+            catch {
+                throw new Error(`Theme font "${font.family}": could not resolve "${font.path}" from ${rootDir}. ` +
+                    "Install the package, or use a ./- or /-prefixed file path.");
+            }
+        }
+        if (!existsSync(absPath)) {
+            throw new Error(`Theme font "${font.family}": file not found at ${absPath} (from "${font.path}").`);
+        }
+        const format = FONT_FORMATS[extname(absPath).toLowerCase()];
+        if (!format) {
+            throw new Error(`Theme font "${font.family}": unsupported format "${extname(absPath)}". ` +
+                `Supported: ${Object.keys(FONT_FORMATS).join(", ")}.`);
+        }
+        return { family: font.family, url: pathToFileURL(absPath).href, weight: font.weight ?? 400, format };
+    });
+}
+async function renderOne(definition, variantName, variant, cacheDir, compilerConfig) {
+    const validated = validateMermaidDefinition(definition);
+    const processed = injectClassDefs(validated, variant.accents, variant.accentOpacity, variant.accentTextColor, variant.surface, variant.groupCornerRadius);
+    const fonts = resolveFonts(compilerConfig.rootDir, compilerConfig.fonts ?? []);
+    // The variant asks mermaid for `fontFamily` by name; if the theme declared
+    // fonts but none provide that family, Chromium substitutes silently — the exact
+    // failure this feature exists to prevent — so surface the likely typo. Not fatal:
+    // a theme may intentionally target an OS-installed font and declare no faces.
+    if (fonts.length > 0 && !fonts.some((f) => f.family === variant.fontFamily)) {
+        console.warn(`Mermaid variant "${variantName}": fontFamily "${variant.fontFamily}" matches none of the ` +
+            `declared theme fonts (${[...new Set(fonts.map((f) => f.family))].join(", ")}); ` +
+            "the diagram will fall back to a substitute font.");
+    }
+    const renderConfig = buildMermaidRenderConfig(variant);
+    const key = hashKey(processed, variantName, renderConfig, fonts);
+    const outputPath = join(cacheDir, `${key}.png`);
+    if (existsSync(outputPath))
+        return outputPath;
+    await renderMermaidToPng(processed, renderConfig, fonts, outputPath);
+    return outputPath;
+}
+let bundleCache = null;
+/** The mermaid browser bundle, read once and reused across renders. */
+function getMermaidBundle() {
+    if (bundleCache === null) {
+        const require = createRequire(import.meta.url);
+        bundleCache = readFileSync(require.resolve("mermaid/dist/mermaid.min.js"), "utf-8");
+    }
+    return bundleCache;
+}
+function fontFaceCss(fonts) {
+    return fonts
+        .map((f) => `@font-face { font-family: '${f.family}'; src: url('${f.url}') format('${f.format}'); font-weight: ${f.weight}; font-style: normal; }`)
+        .join("\n");
+}
+/**
+ * Render a mermaid definition to a transparent PNG via a headless Chromium
+ * (Playwright — the proven old driver, stronger headless font fidelity). The
+ * theme fonts are injected as `@font-face` and every registered face is awaited
+ * (`document.fonts.load()`) BEFORE `mermaid.render()` measures text — the only
+ * cross-platform, zero-install way to make Chromium lay out labels in the brand
+ * font instead of a substitute. mmdc's `--cssFile` injects too late (after layout)
+ * to affect metrics, which is why this replaces its programmatic API.
+ */
+async function renderMermaidToPng(processed, renderConfig, fonts, outputPath) {
+    const bundle = getMermaidBundle();
+    // JSON script blocks pass data without escaping issues; escape `</` so a value
+    // can't close the surrounding <script>.
+    const defJson = JSON.stringify(processed).replace(/<\//g, "<\\/");
+    const configJson = JSON.stringify(renderConfig).replace(/<\//g, "<\\/");
+    const html = `<!DOCTYPE html>
+<html><head>
+<style>
+body { margin: 0; background: transparent; }
+${fontFaceCss(fonts)}
+</style>
+</head>
+<body>
+  <div id="output" ${RENDER_SIGNAL_ATTR}="${RenderSignal.Pending}"></div>
+  <script id="mermaid-def" type="application/json">${defJson}</script>
+  <script id="mermaid-config" type="application/json">${configJson}</script>
+  <script>${bundle}</script>
+  <script>
+    (async () => {
+      const out = document.getElementById('output');
+      try {
+        const def = JSON.parse(document.getElementById('mermaid-def').textContent);
+        const config = JSON.parse(document.getElementById('mermaid-config').textContent);
+        const container = document.createElement('div');
+        container.style.position = 'absolute';
+        container.style.top = '-9999px';
+        document.body.appendChild(container);
+        // document.fonts.ready alone resolves early (nothing references the face
+        // yet); iterating and .load()-ing each forces the fetch before mermaid
+        // measures text.
+        await Promise.all([...document.fonts].map(f => f.load()));
+        await document.fonts.ready;
+        mermaid.initialize(config);
+        const { svg } = await mermaid.render('mermaid-0', def, container);
+        container.remove();
+        out.innerHTML = svg;
+        out.setAttribute('${RENDER_SIGNAL_ATTR}', '${RenderSignal.Done}');
+      } catch (e) {
+        out.setAttribute('${RENDER_ERROR_ATTR}', (e && e.message) || String(e));
+        out.setAttribute('${RENDER_SIGNAL_ATTR}', '${RenderSignal.Done}');
+      }
+    })();
+  </script>
+</body></html>`;
+    // Serve the page from a real file:// URL, not setContent — an about:blank
+    // origin can't fetch the file:// font resources (@font-face silently fails),
+    // whereas a file://-origin document loads them. Mirrors the old harness.
+    const htmlPath = `${outputPath}.html`;
+    const { chromium } = await import("playwright");
+    let browser;
+    try {
+        // Written inside the try so the finally always cleans it up, even if launch throws.
+        writeFileSync(htmlPath, html);
+        browser = await chromium.launch({ headless: true, args: ["--no-sandbox"] });
+        const page = await browser.newPage({ viewport: { width: 800, height: 600 }, deviceScaleFactor: 2 });
+        await page.goto(pathToFileURL(htmlPath).href, { waitUntil: "load" });
+        await page.waitForSelector(`#output[${RENDER_SIGNAL_ATTR}="${RenderSignal.Done}"]`, { timeout: 30000 });
+        const error = await page.getAttribute("#output", RENDER_ERROR_ATTR);
+        if (error)
+            throw new Error(error);
+        const svg = page.locator("#output svg");
+        if ((await svg.count()) === 0)
+            throw new Error("mermaid produced no SVG");
+        await svg.screenshot({ path: outputPath, omitBackground: true });
+    }
+    catch (e) {
+        throw new Error(`Mermaid render failed:\n${e instanceof Error ? e.message : String(e)}`);
+    }
+    finally {
+        await browser?.close();
+        rmSync(htmlPath, { force: true });
+    }
+}

package/dist/markdown/{resolvers → blocks}/mermaidTheme.d.ts

@@ -2,7 +2,7 @@
  * Mermaid theme types and definition-processing utilities.
  *
  * Owner of MermaidVariant / MermaidConfig — these types are compiler-facing
- * (the engine has no idea mermaid exists). `resolvers/mermaid.ts` consumes
+ * (the engine has no idea mermaid exists). `blocks/mermaid.ts` consumes
  * them to build --configFile input for `mmdc`.
  */
 export type MermaidVariant = {

package/dist/markdown/{resolvers → blocks}/mermaidTheme.js

@@ -2,7 +2,7 @@
  * Mermaid theme types and definition-processing utilities.
  *
  * Owner of MermaidVariant / MermaidConfig — these types are compiler-facing
- * (the engine has no idea mermaid exists). `resolvers/mermaid.ts` consumes
+ * (the engine has no idea mermaid exists). `blocks/mermaid.ts` consumes
  * them to build --configFile input for `mmdc`.
  */
 const FORBIDDEN_PATTERNS = [/^\s*style\s+\S+\s+/, /^\s*linkStyle\s+/, /^\s*classDef\s+/, /^\s*%%\{init/];

package/dist/markdown/blocks/registry.d.ts

@@ -0,0 +1,16 @@
+import { AcceptType, type BlockContext, type BlockFill, type BlockHandler } from "../types.js";
+export type { BlockContext, BlockHandler };
+/**
+ * Recognize a body/`::name::` region's content and return the engine
+ * `AcceptType` it folds to, plus a lazy `fill` that compiles it to the engine
+ * fill. The split is deliberate: `acceptType` is available synchronously so the
+ * caller can validate a region against its slot BEFORE running the (possibly
+ * expensive — Shiki, Playwright) `fill`. A region that is exactly one
+ * `mermaid`/`code`/`image`/`table` node folds to that kind; anything else
+ * aggregates to one TextFill (prose + lists + headings). The paragraph-unwrap
+ * mirrors remark wrapping a lone `![alt](src)` in a paragraph.
+ */
+export declare function parseSlotContent(text: string, ctx: BlockContext): {
+    acceptType: AcceptType;
+    fill: () => Promise<BlockFill>;
+};

package/dist/markdown/blocks/registry.js

@@ -0,0 +1,44 @@
+import { MdastType, parseRegion } from "../mdast.js";
+import { AcceptType } from "../types.js";
+import { CODE } from "./code.js";
+import { IMAGE } from "./image.js";
+import { MERMAID } from "./mermaid.js";
+import { TABLE } from "./table.js";
+import { compileTextAggregate } from "./text.js";
+// ── The one registry: every content kind is one row ───────────────────────────
+// One descriptor per content kind, carrying recognition (`match`/`acceptType`)
+// and the single `compile` that folds the node straight into an engine fill. A
+// region that is exactly one of these nodes folds to that kind. MERMAID precedes
+// CODE, but their matches are already disjoint on `lang`.
+const BLOCKS = [MERMAID, CODE, IMAGE, TABLE];
+/**
+ * Recognize a body/`::name::` region's content and return the engine
+ * `AcceptType` it folds to, plus a lazy `fill` that compiles it to the engine
+ * fill. The split is deliberate: `acceptType` is available synchronously so the
+ * caller can validate a region against its slot BEFORE running the (possibly
+ * expensive — Shiki, Playwright) `fill`. A region that is exactly one
+ * `mermaid`/`code`/`image`/`table` node folds to that kind; anything else
+ * aggregates to one TextFill (prose + lists + headings). The paragraph-unwrap
+ * mirrors remark wrapping a lone `![alt](src)` in a paragraph.
+ */
+export function parseSlotContent(text, ctx) {
+    const nodes = parseRegion(text).children.map(unwrapLoneImage);
+    if (nodes.length === 1) {
+        const handler = BLOCKS.find((h) => h.match(nodes[0]));
+        if (handler)
+            return { acceptType: handler.acceptType, fill: () => handler.compile(nodes[0], ctx) };
+    }
+    // TEXT is the aggregate fallback (prose + lists + headings), not a registry
+    // row — it's what a region folds to when no single-block handler claims it.
+    // Wrapped in an async thunk so its fail-fast (a standalone kind mixed into
+    // prose) surfaces from `fill`, after the caller's acceptType check.
+    return { acceptType: AcceptType.Text, fill: async () => compileTextAggregate(nodes, ctx) };
+}
+/** remark wraps a lone `![alt](src)` in a paragraph; unwrap it so a standalone
+ * image is dispatched as an `image` node, not walked as prose. */
+function unwrapLoneImage(node) {
+    if (node.type === MdastType.Paragraph && node.children.length === 1 && node.children[0].type === MdastType.Image) {
+        return node.children[0];
+    }
+    return node;
+}

package/dist/markdown/blocks/table.d.ts

@@ -0,0 +1,2 @@
+import { type BlockHandler } from "../types.js";
+export declare const TABLE: BlockHandler;

package/dist/markdown/blocks/table.js

@@ -0,0 +1,23 @@
+import { walkPhrasingChildren } from "../inline.js";
+import { MdastType } from "../mdast.js";
+import { AcceptType } from "../types.js";
+export const TABLE = {
+    match: (node) => node.type === MdastType.Table,
+    acceptType: AcceptType.Table,
+    compile: async (node) => compileTable(node),
+};
+/** A GFM `table` → TableFill: first row is headers, the rest are body rows; each
+ * cell's phrasing children become `TextRun[]` via the shared inline walk. */
+function compileTable(node) {
+    const [head, ...body] = node.children;
+    return {
+        headers: head ? head.children.map(cellParagraph) : [],
+        rows: body.map((row) => row.children.map(cellParagraph)),
+    };
+}
+/** One table cell → a StyledParagraph. An empty cell keeps a single empty run so
+ * downstream code sees a run to style, matching the old `parseInlineRuns("")`. */
+function cellParagraph(cell) {
+    const runs = walkPhrasingChildren(cell.children, {});
+    return { runs: runs.length > 0 ? runs : [{ text: "" }] };
+}

package/dist/markdown/blocks/text.d.ts

@@ -0,0 +1,12 @@
+import type { RootContent } from "mdast";
+import type { TextFill } from "../../engine/index.js";
+import type { BlockContext } from "../types.js";
+/**
+ * Aggregate a region's prose blocks into one TextFill. Paragraphs, headings, and
+ * lists become `StyledParagraph[]` in document order; list nesting sets bullet
+ * levels. A region reaching here whose only node is an unsupported standalone
+ * block (a lone `blockquote`, `thematicBreak`, …) — or one that mixes a
+ * standalone kind (table/image/code) into prose — is illegal, so fail fast
+ * naming the layout/slide/slot and the node type.
+ */
+export declare function compileTextAggregate(nodes: RootContent[], ctx: BlockContext): TextFill;

package/dist/markdown/blocks/text.js

@@ -0,0 +1,90 @@
+import { walkPhrasingChildren } from "../inline.js";
+import { MdastType } from "../mdast.js";
+/**
+ * Aggregate a region's prose blocks into one TextFill. Paragraphs, headings, and
+ * lists become `StyledParagraph[]` in document order; list nesting sets bullet
+ * levels. A region reaching here whose only node is an unsupported standalone
+ * block (a lone `blockquote`, `thematicBreak`, …) — or one that mixes a
+ * standalone kind (table/image/code) into prose — is illegal, so fail fast
+ * naming the layout/slide/slot and the node type.
+ */
+export function compileTextAggregate(nodes, ctx) {
+    const paragraphs = [];
+    for (const node of nodes) {
+        switch (node.type) {
+            case MdastType.Paragraph:
+            case MdastType.Heading:
+                for (const runs of splitRunsIntoParagraphs(walkPhrasingChildren(node.children, { breakAsNewline: true }))) {
+                    paragraphs.push({ runs });
+                }
+                break;
+            case MdastType.List:
+                paragraphs.push(...listParagraphs(node, 0));
+                break;
+            default:
+                throw new Error(reject(nodes.length, node.type, ctx));
+        }
+    }
+    return { paragraphs };
+}
+/**
+ * Word the rejection for a node that prose aggregation can't take. A region that
+ * is a single unsupported block asks to be a standalone content kind that
+ * doesn't exist; a node reaching here beside others is a standalone kind
+ * (table/image/code) mixed into prose — both name the layout/slide/slot + type.
+ */
+function reject(nodeCount, nodeType, ctx) {
+    const where = `Slide ${ctx.slideIdx}: layout "${ctx.layoutName}" slot content (from ${ctx.source})`;
+    if (nodeCount === 1) {
+        return `${where} is a standalone "${nodeType}" block, which is not a supported content kind.`;
+    }
+    return (`${where} mixes a "${nodeType}" block with other content; ` +
+        "a table, image, or code block must be the region's only content.");
+}
+/**
+ * A `list` → bulleted `StyledParagraph[]`. Each item's paragraph/heading runs
+ * become a bullet at `level` (top-level list = 0); a nested `list` recurses at
+ * `level + 1`. Ordered and unordered both yield plain bullets — the engine has
+ * no ordered flag.
+ */
+function listParagraphs(list, level) {
+    const out = [];
+    for (const item of list.children) {
+        for (const child of item.children) {
+            if (child.type === MdastType.List) {
+                out.push(...listParagraphs(child, level + 1));
+            }
+            else if (child.type === MdastType.Paragraph || child.type === MdastType.Heading) {
+                for (const runs of splitRunsIntoParagraphs(walkPhrasingChildren(child.children, { breakAsNewline: true }))) {
+                    out.push({ runs, bullet: { level } });
+                }
+            }
+        }
+    }
+    return out;
+}
+/**
+ * Split a paragraph's runs on newlines into one `TextRun[]` per source line —
+ * preserving the pre-mdast "one source line = one StyledParagraph" behavior.
+ * Both a soft break (`\n` inside a text run) and a markdown hard break (a
+ * `break` node the inline walk emits as a `"\n"` run in block context) split
+ * here. Empty segments (a style boundary landing on a line edge) are dropped,
+ * and empty lines produce no paragraph, matching the old blank-line filter.
+ */
+function splitRunsIntoParagraphs(runs) {
+    const lines = [];
+    let current = [];
+    for (const run of runs) {
+        const parts = run.text.split("\n");
+        for (let i = 0; i < parts.length; i++) {
+            if (i > 0) {
+                lines.push(current);
+                current = [];
+            }
+            if (parts[i] !== "")
+                current.push({ ...run, text: parts[i] });
+        }
+    }
+    lines.push(current);
+    return lines.filter((line) => line.length > 0);
+}