@tycoworks/tycoslide 0.7.0

package/dist/markdown/parsers.d.ts

@@ -0,0 +1,32 @@
+import type { StyledParagraph, TableFill, TextRun } from "../engine/index.js";
+/**
+ * Parse inline markdown formatting in a single line of text into TextRun arrays.
+ * Handles **bold**, *italic*, ***bold italic***, ~~strikethrough~~, ++underline++,
+ * [link](url), and `inline code`.
+ */
+export declare function parseInlineRuns(text: string): TextRun[];
+/**
+ * Parse a raw prose line into a StyledParagraph with bullet detection and inline
+ * formatting. The caller provides the raw line including leading whitespace and
+ * bullet markers.
+ */
+export declare function parseStyledParagraph(raw: string): StyledParagraph;
+/**
+ * Parse a single line of prose into its structural components.
+ *
+ * Lines beginning with `- ` or `* ` (optionally preceded by spaces) are
+ * recognized as bullet items. Every 2 spaces of leading indent on a bullet
+ * line increase its level by 1. A leading dash without a trailing space is
+ * NOT a bullet (e.g. `-foo`).
+ */
+export declare function parseProseLine(raw: string): {
+    text: string;
+    bullet: boolean;
+    level: number;
+};
+/**
+ * Parse a GFM table into TableFill (StyledParagraph[] cells). Returns null
+ * for non-table text. Cells carry rich runs so inline formatting works
+ * inside tables for free.
+ */
+export declare function parseGfmTable(text: string): TableFill | null;

package/dist/markdown/parsers.js

@@ -0,0 +1,233 @@
+import remarkGfm from "remark-gfm";
+import remarkIns from "remark-ins";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+/** mdast node type discriminators we handle. Backing const so switch/if cases
+ * reference named tokens rather than raw magic strings. */
+const MdastType = {
+    Text: "text",
+    InlineCode: "inlineCode",
+    Strong: "strong",
+    Emphasis: "emphasis",
+    Delete: "delete",
+    Insert: "insert",
+    Link: "link",
+    Break: "break",
+    Paragraph: "paragraph",
+    Heading: "heading",
+};
+/** The subset of MdastType values that are PhrasingContent (dispatched by walkPhrasing). */
+const PHRASING_TYPES = new Set([
+    MdastType.Text,
+    MdastType.InlineCode,
+    MdastType.Strong,
+    MdastType.Emphasis,
+    MdastType.Delete,
+    MdastType.Insert,
+    MdastType.Link,
+    MdastType.Break,
+]);
+// ══════════════════════════════════════════════════════════════════════════════
+// INLINE / PROSE PARSING
+// ══════════════════════════════════════════════════════════════════════════════
+/**
+ * Parse inline markdown formatting in a single line of text into TextRun arrays.
+ * Handles **bold**, *italic*, ***bold italic***, ~~strikethrough~~, ++underline++,
+ * [link](url), and `inline code`.
+ */
+export function parseInlineRuns(text) {
+    if (!text)
+        return [{ text: "" }];
+    // Fast path: no formatting characters means plain text.
+    if (!text.includes("*") && !text.includes("[") && !text.includes("`") && !text.includes("~") && !text.includes("+")) {
+        return [{ text }];
+    }
+    // remark-parse establishes the processor as Processor<Root>; remarkGfm and
+    // remarkIns extend the parser but don't transform the tree shape, so
+    // runSync's output is still a Root. Unified's TailTree generic defaults to
+    // undefined and widens runSync's return to the base Node, hence the narrowing
+    // cast — kept to a single hop, no double-cast.
+    const processor = unified().use(remarkParse).use(remarkGfm).use(remarkIns);
+    const tree = processor.runSync(processor.parse(text));
+    const runs = walkInlineRoot(tree, {});
+    return runs.length > 0 ? runs : [{ text: "" }];
+}
+/**
+ * Parse a raw prose line into a StyledParagraph with bullet detection and inline
+ * formatting. The caller provides the raw line including leading whitespace and
+ * bullet markers.
+ */
+export function parseStyledParagraph(raw) {
+    const { indent, bullet, text } = detectBullet(raw);
+    if (bullet) {
+        return {
+            runs: parseInlineRuns(text),
+            bullet: { level: Math.floor(indent / 2) },
+        };
+    }
+    return { runs: parseInlineRuns(text) };
+}
+/**
+ * Parse a single line of prose into its structural components.
+ *
+ * Lines beginning with `- ` or `* ` (optionally preceded by spaces) are
+ * recognized as bullet items. Every 2 spaces of leading indent on a bullet
+ * line increase its level by 1. A leading dash without a trailing space is
+ * NOT a bullet (e.g. `-foo`).
+ */
+export function parseProseLine(raw) {
+    const { indent, bullet, text } = detectBullet(raw);
+    return { text, bullet, level: bullet ? Math.floor(indent / 2) : 0 };
+}
+/**
+ * Splits a raw line into leading spaces, an optional `- `/`* ` marker, and the
+ * remaining text in one pass. Group 1 is the run of leading spaces; group 2 is
+ * the marker plus its trailing whitespace when present; group 3 is everything
+ * after. A marker only matches when whitespace follows it, so `-foo` falls
+ * through group 2 and stays plain text.
+ */
+const BULLET_LINE = /^( *)([-*]\s+)?(.*)$/;
+/** Shared bullet-detection primitive used by parseStyledParagraph + parseProseLine. */
+function detectBullet(raw) {
+    const [, leading, marker, rest] = raw.match(BULLET_LINE);
+    return { indent: leading.length, bullet: marker !== undefined, text: rest };
+}
+// ══════════════════════════════════════════════════════════════════════════════
+// GFM TABLE PARSING
+// ══════════════════════════════════════════════════════════════════════════════
+const TABLE_SEPARATOR_RE = /^\|?([\s:]*-{3,}[\s:]*\|)+[\s:]*-{3,}[\s:]*\|?$/;
+function parseTableRow(line) {
+    const trimmed = line.trim();
+    const stripped = trimmed.startsWith("|") ? trimmed.slice(1) : trimmed;
+    const chopped = stripped.endsWith("|") ? stripped.slice(0, -1) : stripped;
+    return chopped.split("|").map((c) => c.trim());
+}
+function cellToParagraph(text) {
+    return { runs: parseInlineRuns(text) };
+}
+/**
+ * Parse a GFM table into TableFill (StyledParagraph[] cells). Returns null
+ * for non-table text. Cells carry rich runs so inline formatting works
+ * inside tables for free.
+ */
+export function parseGfmTable(text) {
+    const lines = text.split(/\r?\n/).filter((l) => l.trim());
+    if (lines.length < 2)
+        return null;
+    if (!TABLE_SEPARATOR_RE.test(lines[1]))
+        return null;
+    const headers = parseTableRow(lines[0]);
+    if (headers.length === 0)
+        return null;
+    const rows = [];
+    for (let i = 2; i < lines.length; i++) {
+        rows.push(parseTableRow(lines[i]).map(cellToParagraph));
+    }
+    return { headers: headers.map(cellToParagraph), rows };
+}
+function makeRun(text, state) {
+    const run = { text };
+    if (state.bold)
+        run.bold = true;
+    if (state.italic)
+        run.italic = true;
+    if (state.strikethrough)
+        run.strikethrough = true;
+    if (state.underline)
+        run.underline = true;
+    if (state.link)
+        run.link = state.link;
+    return run;
+}
+/**
+ * Walk a `PhrasingContent` node, converting inline formatting into TextRun[].
+ *
+ * The `node.type` case strings are the mdast library's own discriminators;
+ * TypeScript narrows each case to the concrete node interface (Text, Strong,
+ * Emphasis, …) so misspellings and dropped cases are compile errors, not
+ * silent fallthroughs. `remark-ins` augments PhrasingContentMap with
+ * "insert", so that case narrows to the Insert node type.
+ */
+function walkPhrasing(node, state) {
+    switch (node.type) {
+        case MdastType.Text:
+            return [makeRun(node.value, state)];
+        case MdastType.InlineCode:
+            return [makeRun(node.value, state)];
+        case MdastType.Strong:
+            return walkPhrasingChildren(node.children, { ...state, bold: true });
+        case MdastType.Emphasis:
+            return walkPhrasingChildren(node.children, { ...state, italic: true });
+        case MdastType.Delete:
+            return walkPhrasingChildren(node.children, { ...state, strikethrough: true });
+        case MdastType.Insert:
+            return walkPhrasingChildren(node.children, { ...state, underline: true });
+        case MdastType.Link:
+            return walkPhrasingChildren(node.children, { ...state, link: node.url });
+        case MdastType.Break:
+            // A hard line break inside a single "line" is treated as a space.
+            return [makeRun(" ", state)];
+        default:
+            // Any other phrasing node with a literal `value` (footnote references,
+            // etc.) — emit its text if it has one, otherwise nothing.
+            if ("value" in node && typeof node.value === "string") {
+                return [makeRun(node.value, state)];
+            }
+            return [];
+    }
+}
+function walkPhrasingChildren(children, state) {
+    const out = [];
+    for (const child of children)
+        out.push(...walkPhrasing(child, state));
+    return out;
+}
+/** Walk the root's children, entering each block-level container's phrasing. */
+function walkInlineRoot(root, state) {
+    const out = [];
+    for (const child of root.children)
+        out.push(...walkBlock(child, state));
+    return out;
+}
+/**
+ * Enter a block-level node. remarkParse on a single line produces a `Root`
+ * whose children include block-level nodes (Paragraph, most commonly), which
+ * in turn hold phrasing content. Anything unexpected (Heading, Blockquote,
+ * List, …) recurses via its phrasing-holding children when applicable.
+ */
+function walkBlock(node, state) {
+    switch (node.type) {
+        case MdastType.Paragraph:
+            return walkPhrasingChildren(node.children, state);
+        case MdastType.Heading:
+            return walkPhrasingChildren(node.children, state);
+        default:
+            // Fall back: some block nodes carry phrasing content among their
+            // children. Recurse into typed children when the shape is known;
+            // otherwise return nothing rather than guess.
+            if ("children" in node && Array.isArray(node.children)) {
+                const out = [];
+                for (const child of node.children) {
+                    out.push(...walkUnknown(child, state));
+                }
+                return out;
+            }
+            return [];
+    }
+}
+/**
+ * Handle a child of unknown shape: dispatch to phrasing- or block-level walker
+ * based on the node's type discriminator. Preserves discriminated-union
+ * narrowing by explicitly re-checking the type against known mdast unions.
+ */
+function walkUnknown(node, state) {
+    if (typeof node !== "object" || node === null || !("type" in node))
+        return [];
+    const typed = node;
+    // Phrasing-content types we handle directly:
+    if (PHRASING_TYPES.has(typed.type))
+        return walkPhrasing(node, state);
+    // Otherwise treat as a block-content node; walkBlock will recurse or
+    // return nothing.
+    return walkBlock(node, state);
+}

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

@@ -0,0 +1,17 @@
+import type { StyledParagraph } from "../../engine/index.js";
+import { type CodeFence } from "../types.js";
+import type { Resolver } from "./resolver.js";
+/** Discriminator for CodeFence values. Doubles as `CodeResolver.matches`. */
+export declare function isCodeBlock(v: unknown): v is CodeFence;
+/**
+ * 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[]>;
+/**
+ * Resolve one CodeFence into a TextFill by Shiki-highlighting its source.
+ * Theme resolution is strict: the fence's slot MUST declare `codeTheme`. There
+ * is no theme-wide fallback — a code-capable slot with no theme throws with the
+ * offending slot and layout names.
+ */
+export declare const CodeResolver: Resolver<CodeFence>;

package/dist/markdown/resolvers/code.js

@@ -0,0 +1,44 @@
+import { CompilerSlotType, FenceType } from "../types.js";
+/** Discriminator for CodeFence values. Doubles as `CodeResolver.matches`. */
+export function isCodeBlock(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v) && v.type === FenceType.Code;
+}
+/**
+ * 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;
+            }),
+    }));
+}
+/**
+ * Resolve one CodeFence into a TextFill by Shiki-highlighting its source.
+ * Theme resolution is strict: the fence's slot MUST declare `codeTheme`. There
+ * is no theme-wide fallback — a code-capable slot with no theme throws with the
+ * offending slot and layout names.
+ */
+export const CodeResolver = {
+    matches: isCodeBlock,
+    async resolve(fence, ctx) {
+        const theme = ctx.slot.type === CompilerSlotType.Code ? ctx.slot.codeTheme : undefined;
+        if (!theme) {
+            throw new Error(`Slide layout "${ctx.layout.name}" slot "${ctx.key}": no "codeTheme" declared on the slot. ` +
+                "Every code-capable slot must declare its own theme (CompilerContentSlot.codeTheme).");
+        }
+        const paragraphs = await highlightCode(fence.source, fence.language, theme);
+        return { paragraphs };
+    },
+};

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

@@ -0,0 +1,14 @@
+import { type MermaidFence } from "../types.js";
+import type { Resolver } from "./resolver.js";
+/** Discriminator for MermaidFence values. Doubles as `MermaidResolver.matches`. */
+export declare function isMermaidBlock(v: unknown): v is MermaidFence;
+/**
+ * Resolve one MermaidFence into an ImageFill by rendering it to a PNG (cached
+ * under `<outputDir>/.tycoslide-cache/mermaid/<hash>.png`). Fit is always `contain` —
+ * mermaid diagrams are shown in their entirety.
+ *
+ * Resolution is strict: the deck's theme MUST carry a `mermaid` block, the
+ * fence's slot MUST declare `mermaidVariant`, and that variant MUST exist in
+ * the theme — each missing piece throws by name.
+ */
+export declare const MermaidResolver: Resolver<MermaidFence>;

package/dist/markdown/resolvers/mermaid.js

@@ -0,0 +1,89 @@
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { FitMode, SlotType } from "../../engine/index.js";
+import { CompilerSlotType, FenceType } from "../types.js";
+import { buildMermaidRenderConfig, injectClassDefs, validateMermaidDefinition, } from "./mermaidTheme.js";
+/** Discriminator for MermaidFence values. Doubles as `MermaidResolver.matches`. */
+export function isMermaidBlock(v) {
+    return (typeof v === "object" && v !== null && !Array.isArray(v) && v.type === FenceType.Mermaid);
+}
+function findMmdc() {
+    try {
+        const resolved = execFileSync("npx", ["--no-install", "which", "mmdc"], {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+        if (resolved)
+            return resolved;
+    }
+    catch {
+        // fall through
+    }
+    throw new Error("mermaid-cli is required for mermaid diagrams. Install it: npm i -D @mermaid-js/mermaid-cli");
+}
+function hashKey(definition, variantName) {
+    return createHash("sha256").update(variantName).update("\n").update(definition).digest("hex").slice(0, 16);
+}
+function ensureCacheDir(config) {
+    const base = resolve(config.outputDir ?? process.cwd(), ".tycoslide-cache", "mermaid");
+    mkdirSync(base, { recursive: true });
+    return base;
+}
+function renderOne(definition, variantName, variant, cacheDir, mmdcPath) {
+    const validated = validateMermaidDefinition(definition);
+    const processed = injectClassDefs(validated, variant.accents, variant.accentOpacity, variant.accentTextColor, variant.surface, variant.groupCornerRadius);
+    const key = hashKey(processed, variantName);
+    const outputPath = join(cacheDir, `${key}.png`);
+    if (existsSync(outputPath))
+        return outputPath;
+    const config = buildMermaidRenderConfig(variant);
+    const scratch = tmpdir();
+    const configPath = join(scratch, `tycoslide-mermaid-config-${key}.json`);
+    const inputPath = join(scratch, `tycoslide-mermaid-${key}.mmd`);
+    writeFileSync(configPath, JSON.stringify(config));
+    writeFileSync(inputPath, processed);
+    try {
+        execFileSync(mmdcPath, ["-i", inputPath, "-o", outputPath, "--configFile", configPath, "-b", "transparent", "-s", "2"], { stdio: ["pipe", "pipe", "pipe"], timeout: 30_000 });
+    }
+    catch (e) {
+        const stderr = e.stderr?.toString() ?? e.message;
+        throw new Error(`Mermaid render failed:\n${stderr}`);
+    }
+    return outputPath;
+}
+/**
+ * Resolve one MermaidFence into an ImageFill by rendering it to a PNG (cached
+ * under `<outputDir>/.tycoslide-cache/mermaid/<hash>.png`). Fit is always `contain` —
+ * mermaid diagrams are shown in their entirety.
+ *
+ * Resolution is strict: the deck's theme MUST carry a `mermaid` block, the
+ * fence's slot MUST declare `mermaidVariant`, and that variant MUST exist in
+ * the theme — each missing piece throws by name.
+ */
+export const MermaidResolver = {
+    matches: isMermaidBlock,
+    async resolve(fence, ctx) {
+        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 = ctx.slot.type === CompilerSlotType.Mermaid ? ctx.slot.mermaidVariant : undefined;
+        if (variantName === undefined) {
+            throw new Error(`Layout "${ctx.layout.name}": mermaid slot "${ctx.key}" has no "mermaidVariant" declared. ` +
+                "Every slot with type=mermaid must declare its variant explicitly.");
+        }
+        const variant = config.mermaid[variantName];
+        if (!variant) {
+            throw new Error(`Slide layout "${ctx.layout.name}": mermaid variant "${variantName}" not found in theme. ` +
+                `Available variants: ${Object.keys(config.mermaid).join(", ")}`);
+        }
+        const mmdcPath = findMmdc();
+        const cacheDir = ensureCacheDir(config);
+        const pngPath = renderOne(fence.definition, variantName, variant, cacheDir, mmdcPath);
+        return { type: SlotType.Image, path: pngPath, fit: FitMode.Contain };
+    },
+};

package/dist/markdown/resolvers/mermaidTheme.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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
+ * them to build --configFile input for `mmdc`.
+ */
+export type MermaidVariant = {
+    primary: string;
+    primaryContrast: string;
+    text: string;
+    line: string;
+    surface: string;
+    surfaceBorder: string;
+    fontFamily: string;
+    accents: string[];
+    accentOpacity: number;
+    accentTextColor: string;
+    groupCornerRadius: number;
+};
+export type MermaidConfig = Record<string, MermaidVariant>;
+export declare function validateMermaidDefinition(definition: string): string;
+export declare function extractGroups(definition: string): string[];
+export declare function buildClassDefs(groups: string[], accents: string[], accentOpacity: number, accentTextColor: string): string;
+export declare function buildSubgraphStyles(definition: string, groupColor: string, accentOpacity: number, groupCornerRadius: number): string;
+export declare function buildMermaidRenderConfig(variant: MermaidVariant): object;
+export declare function injectClassDefs(definition: string, accents: string[], accentOpacity: number, accentTextColor: string, groupColor: string, groupCornerRadius: number): string;

package/dist/markdown/resolvers/mermaidTheme.js

@@ -0,0 +1,113 @@
+/**
+ * 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
+ * them to build --configFile input for `mmdc`.
+ */
+const FORBIDDEN_PATTERNS = [/^\s*style\s+\S+\s+/, /^\s*linkStyle\s+/, /^\s*classDef\s+/, /^\s*%%\{init/];
+export function validateMermaidDefinition(definition) {
+    const forbidden = [];
+    for (const line of definition.split("\n")) {
+        if (FORBIDDEN_PATTERNS.some((p) => p.test(line))) {
+            forbidden.push(line.trim());
+        }
+    }
+    if (forbidden.length > 0) {
+        throw new Error(`Mermaid: found ${forbidden.length} forbidden style directive(s). ` +
+            `Use theme classes instead (e.g. "class NodeId backend"):\n` +
+            forbidden.map((s) => `  - ${s}`).join("\n"));
+    }
+    return definition;
+}
+export function extractGroups(definition) {
+    const seen = new Set();
+    const groups = [];
+    const classPattern = /^\s*class\s+[\w,]+\s+(\w+)/gm;
+    let match = null;
+    while ((match = classPattern.exec(definition)) !== null) {
+        const name = match[1];
+        if (!seen.has(name)) {
+            seen.add(name);
+            groups.push(name);
+        }
+    }
+    const inlinePattern = /:::(\w+)/g;
+    while ((match = inlinePattern.exec(definition)) !== null) {
+        const name = match[1];
+        if (!seen.has(name)) {
+            seen.add(name);
+            groups.push(name);
+        }
+    }
+    return groups;
+}
+export function buildClassDefs(groups, accents, accentOpacity, accentTextColor) {
+    if (groups.length === 0 || accents.length === 0)
+        return "";
+    const alpha = Math.round((accentOpacity / 100) * 255)
+        .toString(16)
+        .padStart(2, "0");
+    return groups
+        .map((name, i) => {
+        const color = accents[i % accents.length];
+        return `classDef ${name} fill:${color}${alpha},stroke:${color},color:${accentTextColor}`;
+    })
+        .join("\n");
+}
+export function buildSubgraphStyles(definition, groupColor, accentOpacity, groupCornerRadius) {
+    const alpha = Math.round((accentOpacity / 100) * 255)
+        .toString(16)
+        .padStart(2, "0");
+    const fillColor = `${groupColor}${alpha}`;
+    const subgraphPattern = /subgraph\s+(\w+)/g;
+    const ids = [];
+    let match = null;
+    while ((match = subgraphPattern.exec(definition)) !== null) {
+        ids.push(match[1]);
+    }
+    if (ids.length === 0)
+        return "";
+    const radiusPx = Math.round(groupCornerRadius);
+    const radiusPart = radiusPx > 0 ? `,rx:${radiusPx},ry:${radiusPx}` : "";
+    return ids.map((id) => `style ${id} fill:${fillColor}${radiusPart}`).join("\n");
+}
+export function buildMermaidRenderConfig(variant) {
+    return {
+        startOnLoad: false,
+        securityLevel: "loose",
+        theme: "base",
+        themeVariables: {
+            fontFamily: variant.fontFamily,
+            background: "transparent",
+            primaryColor: variant.primary,
+            primaryTextColor: variant.primaryContrast,
+            primaryBorderColor: variant.surfaceBorder,
+            lineColor: variant.line,
+            secondaryColor: variant.surface,
+            tertiaryColor: variant.surface,
+            textColor: variant.text,
+            titleColor: variant.text,
+            nodeTextColor: variant.text,
+            clusterBkg: variant.surface,
+            clusterBorder: variant.surfaceBorder,
+            edgeLabelBackground: variant.surface,
+        },
+    };
+}
+export function injectClassDefs(definition, accents, accentOpacity, accentTextColor, groupColor, groupCornerRadius) {
+    const flowchartPattern = /^(\s*(?:flowchart|graph)\s+\w*\s*\n)/m;
+    const match = definition.match(flowchartPattern);
+    if (!match) {
+        return definition;
+    }
+    const groups = extractGroups(definition);
+    const classDefs = buildClassDefs(groups, accents, accentOpacity, accentTextColor);
+    const subgraphStyles = buildSubgraphStyles(definition, groupColor, accentOpacity, groupCornerRadius);
+    const [fullMatch] = match;
+    let result = classDefs ? definition.replace(fullMatch, `${fullMatch}${classDefs}\n`) : definition;
+    if (subgraphStyles) {
+        result = `${result.trimEnd()}\n${subgraphStyles}`;
+    }
+    return result;
+}

package/dist/markdown/resolvers/resolver.d.ts

@@ -0,0 +1,42 @@
+import type { ImageFill, TextFill } from "../../engine/index.js";
+import { type CodeFence, type CompilerConfig, type CompilerDeck, type CompilerLayout, type CompilerSlot, FenceType, type MarkdownBlock, type MermaidFence } from "../types.js";
+/**
+ * Everything a resolver needs to turn one fence into a fill: the step's layout
+ * (its name feeds diagnostics), the slot the fence fills (carries the per-slot
+ * config a resolver reads — `codeTheme` / `mermaidVariant`), the slot key (error
+ * messages), and the theme-level config (mermaid variants, output dir).
+ */
+export type ResolveContext = {
+    layout: CompilerLayout;
+    slot: CompilerSlot;
+    key: string;
+    config: CompilerConfig;
+};
+/**
+ * A compiler-side strategy that turns ONE unresolved fence into the engine fill
+ * it becomes. Mirrors the engine's `Filler` in shape only — it shares no code,
+ * interface, or registry with the engine layer. A resolver owns solely its
+ * transform: it reads only its own slot field and never walks the deck.
+ */
+export interface Resolver<F extends CodeFence | MermaidFence> {
+    matches(v: MarkdownBlock): v is F;
+    /** Transform one fence into the engine fill it resolves to. */
+    resolve(fence: F, ctx: ResolveContext): Promise<TextFill | ImageFill>;
+}
+/**
+ * Registry keyed by the fence discriminator (`FenceType`). A missing entry for
+ * a fence's `type` throws at lookup — every fence kind must register a resolver.
+ * Mirrors the engine's `FILLERS`; `any` widens the value type exactly as
+ * `Filler<any>` does, since each entry already narrows its own fence.
+ */
+export declare const RESOLVERS: Record<FenceType, Resolver<any>>;
+/** A content value is a fence when it carries a `type` that names a FenceType. */
+export declare function isFence(v: MarkdownBlock): v is CodeFence | MermaidFence;
+/**
+ * The single walk that replaces the two bespoke fence walkers. For each step,
+ * resolve every fence in `step.content` in place: dispatch on the fence's `type`
+ * to its resolver, hand it the fence plus its slot config, and swap the resolved
+ * fill back into `step.content[key]`. Traversal lives here; each resolver owns
+ * only its transform.
+ */
+export declare function resolveFences(deck: CompilerDeck, config: CompilerConfig): Promise<void>;

package/dist/markdown/resolvers/resolver.js

@@ -0,0 +1,52 @@
+import { FenceType, } from "../types.js";
+import { CodeResolver } from "./code.js";
+import { MermaidResolver } from "./mermaid.js";
+/**
+ * Registry keyed by the fence discriminator (`FenceType`). A missing entry for
+ * a fence's `type` throws at lookup — every fence kind must register a resolver.
+ * Mirrors the engine's `FILLERS`; `any` widens the value type exactly as
+ * `Filler<any>` does, since each entry already narrows its own fence.
+ */
+export const RESOLVERS = {
+    [FenceType.Code]: CodeResolver,
+    [FenceType.Mermaid]: MermaidResolver,
+};
+/** A content value is a fence when it carries a `type` that names a FenceType. */
+export function isFence(v) {
+    return "type" in v && Object.values(FenceType).includes(v.type);
+}
+/** Find a layout by name; throws if absent (deckCompiler guarantees presence). */
+function layoutByName(config, name) {
+    const layout = config.layouts.find((l) => l.name === name);
+    if (!layout)
+        throw new Error(`resolveFences: unknown layout "${name}".`);
+    return layout;
+}
+/** Find a slot by key within a layout; throws if absent (a fence always has one). */
+function slotByKey(layout, key) {
+    const slot = layout.slots.find((s) => s.key === key);
+    if (!slot)
+        throw new Error(`resolveFences: layout "${layout.name}" has no slot "${key}".`);
+    return slot;
+}
+/**
+ * The single walk that replaces the two bespoke fence walkers. For each step,
+ * resolve every fence in `step.content` in place: dispatch on the fence's `type`
+ * to its resolver, hand it the fence plus its slot config, and swap the resolved
+ * fill back into `step.content[key]`. Traversal lives here; each resolver owns
+ * only its transform.
+ */
+export async function resolveFences(deck, config) {
+    for (const step of deck.steps) {
+        if (!step.content)
+            continue;
+        const layout = layoutByName(config, step.layout);
+        for (const [key, value] of Object.entries(step.content)) {
+            if (!isFence(value))
+                continue;
+            const resolver = RESOLVERS[value.type];
+            const slot = slotByKey(layout, key);
+            step.content[key] = await resolver.resolve(value, { layout, slot, key, config });
+        }
+    }
+}