@tycoworks/tycoslide 0.8.0 → 0.10.0

package/dist/markdown/deckCompiler.d.ts

@@ -1,27 +1,24 @@
 import { type ImageFill } from "../engine/index.js";
 import type { ParsedDocument } from "./slideParser.js";
-import { type AssetCatalog, AssetType, type CompilerDeck, type CompilerLayout } from "./types.js";
-export declare function toImageFill(path: string, type: AssetType): ImageFill;
+import { AssetType, type CompilerConfig, type CompilerDeck } from "./types.js";
 /**
- * Reserved keys in a deck's frontmatter — global (theme, output) and per-slide
- * (layout, body). Exported so callers (e.g. cli.ts) reference the constants
- * instead of literal strings.
+ * Wrap an absolute image path as an ImageFill, expanding the resolved asset
+ * `type` into the engine's scaling constraints. Callers resolve the path (see
+ * `resolveImagePath`) and the type (from the catalog) first.
  */
-export declare const RESERVED_KEY: {
-    readonly LAYOUT: "layout";
-    readonly BODY: "body";
-    readonly OUTPUT: "output";
-    readonly THEME: "theme";
-    readonly NOTES: "notes";
-};
+export declare function toImageFill(path: string, type: AssetType): ImageFill;
 /**
- * Compile a parsed deck document against a set of layouts.
+ * Compile a parsed deck document against a theme `config`. Each slide's content
+ * is compiled straight into engine fills — prose/tables/images plus highlighted
+ * code (Shiki) and rendered mermaid (PNG) — so the returned deck is
+ * engine-shaped, ready for `buildDeck`.
  *
- * `rootDir` (optional) is the base directory for resolving relative image
- * paths declared in the deck's frontmatter or named slots. When omitted (or
- * empty), image paths are returned unchanged — callers that already produce
- * absolute paths (or callers that don't need resolution, e.g. unit tests)
- * can rely on the pass-through. When provided, relative paths are resolved
- * to absolute via `path.resolve(rootDir, path)`; absolute paths pass through.
+ * `config.rootDir` is the base directory for resolving relative image paths
+ * declared in the deck's frontmatter or named slots. When empty, image paths are
+ * returned unchanged — callers that already produce absolute paths (or don't need
+ * resolution, e.g. unit tests) rely on the pass-through. When set, relative paths
+ * are resolved to absolute via `path.resolve(rootDir, path)`; absolute paths pass
+ * through. `config.codeTheme` / `config.mermaid` / `config.mermaidVariant` /
+ * `config.outputDir` feed the code and mermaid compiles.
  */
-export declare function compileDeck(doc: ParsedDocument, layouts: CompilerLayout[], rootDir?: string, assets?: AssetCatalog): CompilerDeck;
+export declare function compileDeck(doc: ParsedDocument, config: CompilerConfig): Promise<CompilerDeck>;

package/dist/markdown/deckCompiler.js

@@ -1,86 +1,41 @@
 import { resolve } from "node:path";
-import { FILLERS, ImageFit, SlotType } from "../engine/index.js";
-import { parseGfmTable, parseStyledParagraph } from "./parsers.js";
-import { RESOLVERS } from "./resolvers/resolver.js";
+import { ImageFit, SlotType } from "../engine/index.js";
+import { parseSlotContent } from "./blocks/registry.js";
+import { validateSlideFrontmatter } from "./schema/deckSchema.js";
 import { templateKeys, templateToSegments } from "./textTemplate.js";
-import { AssetType, CompilerSlotType, FenceType, ParameterType, } from "./types.js";
-/**
- * Wrap an absolute image path as an ImageFill, expanding the resolved asset
- * `type` into the engine's scaling constraints. Callers resolve the path (see
- * `resolveImagePath`) and the type (from the catalog) first.
- */
+import { AssetType, ParameterType, RESERVED_KEY, } from "./types.js";
 /** Map each semantic asset type to the engine's object-fit directive. */
 const FIT_FOR = {
     [AssetType.Icon]: ImageFit.ScaleDown,
     [AssetType.Image]: ImageFit.Contain,
     [AssetType.Background]: ImageFit.Cover,
 };
-export function toImageFill(path, type) {
-    return { type: SlotType.Image, path, fit: FIT_FOR[type] };
-}
 /**
- * Reserved keys in a deck's frontmatter — global (theme, output) and per-slide
- * (layout, body). Exported so callers (e.g. cli.ts) reference the constants
- * instead of literal strings.
+ * Wrap an absolute image path as an ImageFill, expanding the resolved asset
+ * `type` into the engine's scaling constraints. Callers resolve the path (see
+ * `resolveImagePath`) and the type (from the catalog) first.
  */
-export const RESERVED_KEY = {
-    LAYOUT: "layout",
-    BODY: "body",
-    OUTPUT: "output",
-    THEME: "theme",
-    NOTES: "notes",
-};
-const CODE_FENCE_RE = /^```(\w+)\n([\s\S]*?)```\s*$/;
-function toTextFill(text) {
-    const paragraphs = text
-        .split(/\r?\n/)
-        .filter((line) => line.trim() !== "")
-        .map(parseStyledParagraph);
-    return { paragraphs };
-}
-function parseSlotContent(text) {
-    const fence = CODE_FENCE_RE.exec(text.trim());
-    if (fence) {
-        if (fence[1] === FenceType.Mermaid) {
-            const block = { type: FenceType.Mermaid, definition: fence[2].replace(/\n$/, "") };
-            return block;
-        }
-        const block = { type: FenceType.Code, language: fence[1], source: fence[2].replace(/\n$/, "") };
-        return block;
-    }
-    const table = parseGfmTable(text);
-    if (table)
-        return table;
-    return toTextFill(text);
+export function toImageFill(path, type) {
+    return { type: SlotType.Image, path, fit: FIT_FOR[type] };
 }
+const KNOWN_GLOBAL_KEYS = new Set([RESERVED_KEY.THEME, RESERVED_KEY.OUTPUT]);
+// Anchored whole-field reference: the entire value is `$category.name` or it is
+// not a reference at all. Anchored ⇒ no escaping concerns.
+const ASSET_REF_RE = /^\$([a-zA-Z]\w*)\.([a-zA-Z]\w*)$/;
 /**
- * Matcher for each CompilerSlotType, composed from the engine's `FILLERS` (text,
- * table) and the compiler's `RESOLVERS` (code, mermaid) — no raw guards imported
- * here, so a slot's expected shape always tracks whatever those registries say a
- * fill/fence looks like.
- */
-const REGION_MATCHERS = {
-    [CompilerSlotType.Text]: FILLERS[SlotType.Text].matches,
-    [CompilerSlotType.Table]: FILLERS[SlotType.Table].matches,
-    [CompilerSlotType.Code]: RESOLVERS[FenceType.Code].matches,
-    [CompilerSlotType.Mermaid]: RESOLVERS[FenceType.Mermaid].matches,
-};
-/**
- * Assert that a region's parsed block matches the slot's declared type. Called
- * after `parseSlotContent` narrows a body/`::name::` region into a MarkdownBlock.
- * Keys off the CompilerSlotType discriminator via `REGION_MATCHERS`.
+ * Assert that a region's parsed block folds to a type the slot `accepts`. The
+ * folded type comes straight from `parseSlotContent` (which returns it beside
+ * the block — no re-probe). A slot may accept several types (text/table/image);
+ * the author's markdown shape selects one. A type the slot does not accept fails
+ * fast, naming the layout, slot, the type it got, and the types the slot accepts.
  */
-function assertSlotRegion(slot, block, slideIdx, source) {
-    if (!REGION_MATCHERS[slot.type](block)) {
-        throw new Error(`Slide ${slideIdx}: slot "${slot.key}" (type "${slot.type}") got wrong content shape from ${source}.`);
+function assertSlotRegion(slot, got, layoutName, slideIdx, source) {
+    if (!slot.accepts.some((b) => b.type === got)) {
+        const accepted = slot.accepts.map((b) => b.type).join(", ");
+        throw new Error(`Slide ${slideIdx}: layout "${layoutName}" slot "${slot.key}" does not accept ${got} content ` +
+            `(from ${source}); it accepts: ${accepted}.`);
     }
 }
-function isImageParameter(param) {
-    return param.type === ParameterType.Image;
-}
-function isTemplateParameter(param) {
-    return param.type === ParameterType.Template;
-}
 /**
  * Resolve a user-supplied image path against the deck's root directory.
  * When `rootDir` is empty, the path is returned unchanged so callers that
@@ -92,6 +47,26 @@ function resolveImagePath(rootDir, path) {
         return path;
     return resolve(rootDir, path);
 }
+/**
+ * Assert no two layouts sample the same base slide. In the sampled-composition
+ * model one layout is one sampled base slide's region-arrangement, so a shared
+ * `slideNumber` means the old single-content-type welding leaked through — two
+ * layouts on one physical slide that should be one multi-`accepts` layout.
+ * `sourceSlide` inside a slot's `accepts` block is a distinct concept (a
+ * specimen source for one content type) and is legitimately reused across
+ * layouts, so it is deliberately not checked here.
+ */
+function assertUniqueSlideNumbers(layouts) {
+    const layoutNameBySlideNumber = new Map();
+    for (const layout of layouts) {
+        const existing = layoutNameBySlideNumber.get(layout.slideNumber);
+        if (existing !== undefined) {
+            throw new Error(`Layouts "${existing}" and "${layout.name}" share slideNumber ${layout.slideNumber}; ` +
+                "each layout must sample a distinct base slide (one layout = one slide, with slots that accept multiple content types).");
+        }
+        layoutNameBySlideNumber.set(layout.slideNumber, layout.name);
+    }
+}
 /**
  * Validate a layout's key spaces once, independent of any slide, so every later
  * frontmatter lookup and content-map write is unambiguous. Two spaces must each
@@ -125,25 +100,29 @@ function validateLayout(layout) {
         contentKeys.add(key);
     };
     for (const param of layout.parameters) {
-        if (isImageParameter(param)) {
-            claimAuthorKey(param.key, "image parameter");
-            claimContentKey(param.key, "image parameter");
-        }
-        else {
-            const keys = templateKeys(param.template);
-            if (param.required && keys.length === 0) {
-                throw new Error(`Layout "${layout.name}": template parameter "${param.shapeName}" is marked required but its template has no keys to fill.`);
+        switch (param.type) {
+            case ParameterType.Image:
+                claimAuthorKey(param.key, "image parameter");
+                claimContentKey(param.key, "image parameter");
+                break;
+            case ParameterType.Template: {
+                const keys = templateKeys(param.template);
+                if (param.required && keys.length === 0) {
+                    throw new Error(`Layout "${layout.name}": template parameter "${param.shapeName}" is marked required but its template has no keys to fill.`);
+                }
+                for (const key of keys)
+                    claimAuthorKey(key, `template parameter "${param.shapeName}"`);
+                claimContentKey(param.shapeName, "template parameter");
+                break;
             }
-            for (const key of keys)
-                claimAuthorKey(key, `template parameter "${param.shapeName}"`);
-            claimContentKey(param.shapeName, "template parameter");
         }
     }
     for (const slot of layout.slots) {
         claimContentKey(slot.key, "slot");
     }
 }
-function compileStep(slide, layouts, rootDir, assetTypeByPath) {
+async function compileStep(slide, config, assetTypeByPath, resolveAssetRef) {
+    const { layouts, rootDir } = config;
     const { frontmatter, body, slots, index } = slide;
     const layout = frontmatter[RESERVED_KEY.LAYOUT];
     if (layout === undefined) {
@@ -161,20 +140,27 @@ function compileStep(slide, layouts, rootDir, assetTypeByPath) {
         const known = layouts.map((l) => l.name).join(", ");
         throw new Error(`Slide ${index}: unknown layout "${layoutName}". Available layouts: ${known}`);
     }
+    // Reject any frontmatter key not declared by this layout's parameters (reserved
+    // layout/notes stripped first). The per-layout strict schema IS the unknown-key
+    // check — it fires before the resolution loop, so that loop only sees valid keys.
+    validateSlideFrontmatter(frontmatter, layoutDef, index);
     // Map each author-facing key to its owning parameter: template keys → the template
     // parameter that declares them, image keys → the image parameter. validateLayout
     // (run once per layout in compileDeck) has already proven these key spaces are
     // collision-free, so a later lookup is unambiguous.
-    const templateParams = layoutDef.parameters.filter(isTemplateParameter);
+    const templateParams = [];
     const imageByKey = new Map();
     const templateParamByKey = new Map();
     for (const param of layoutDef.parameters) {
-        if (isImageParameter(param)) {
-            imageByKey.set(param.key, param);
-        }
-        else {
-            for (const key of templateKeys(param.template))
-                templateParamByKey.set(key, param);
+        switch (param.type) {
+            case ParameterType.Image:
+                imageByKey.set(param.key, param);
+                break;
+            case ParameterType.Template:
+                templateParams.push(param);
+                for (const key of templateKeys(param.template))
+                    templateParamByKey.set(key, param);
+                break;
         }
     }
     const slotsByKey = new Map(layoutDef.slots.map((s) => [s.key, s]));
@@ -204,10 +190,9 @@ function compileStep(slide, layouts, rootDir, assetTypeByPath) {
                 valuesByTemplateParam.set(templateParam, bucket);
             }
             bucket.set(key, String(value));
-            continue;
         }
-        const validKeys = [...templateParamByKey.keys(), ...imageByKey.keys()].join(", ");
-        throw new Error(`Slide ${index}: unknown key "${key}" in layout "${layoutName}". Valid parameters: ${validKeys}`);
+        // Unreachable: validateSlideFrontmatter (above) already rejected any key that is
+        // neither an image key nor a template key, so every key here routes to a parameter.
     }
     // Expand each template parameter whose keys were supplied. Filling any key fills the
     // parameter as a whole — a missing key throws (fail-fast in templateToSegments). A
@@ -232,9 +217,19 @@ function compileStep(slide, layouts, rootDir, assetTypeByPath) {
         if (!bodySlot) {
             throw new Error(`Slide ${index}: layout "${layoutName}" does not accept body content. Valid slots: ${[...slotsByKey.keys()].join(", ")}`);
         }
-        const parsedBody = parseSlotContent(body);
-        assertSlotRegion(bodySlot, parsedBody, index, "body content");
-        content[RESERVED_KEY.BODY] = parsedBody;
+        const parsedBody = parseSlotContent(body, {
+            resolveAssetRef,
+            layoutName,
+            slideIdx: index,
+            source: "body content",
+            config,
+            layoutVariant: layoutDef.variant,
+        });
+        // Validate the slot accepts this region's type BEFORE running the (possibly
+        // expensive — Shiki, Playwright) fill: a mismatched region fails fast without
+        // spinning up a renderer.
+        assertSlotRegion(bodySlot, parsedBody.acceptType, layoutName, index, "body content");
+        content[RESERVED_KEY.BODY] = await parsedBody.fill();
     }
     // `::name::` regions resolve against the layout's slots.
     for (const [name, text] of Object.entries(slots)) {
@@ -243,9 +238,17 @@ function compileStep(slide, layouts, rootDir, assetTypeByPath) {
             throw new Error(`Slide ${index}: unknown slot "::${name}::" in layout "${layoutName}". ` +
                 `Valid slots: ${[...slotsByKey.keys()].join(", ")}`);
         }
-        const block = parseSlotContent(text);
-        assertSlotRegion(slot, block, index, `::${name}::`);
-        content[name] = block;
+        const source = `::${name}::`;
+        const parsed = parseSlotContent(text, {
+            resolveAssetRef,
+            layoutName,
+            slideIdx: index,
+            source,
+            config,
+            layoutVariant: layoutDef.variant,
+        });
+        assertSlotRegion(slot, parsed.acceptType, layoutName, index, source);
+        content[name] = await parsed.fill();
     }
     // Required image parameters (missing frontmatter key) and required slots
     // (missing region) throw with layout + key context. Required template parameters are
@@ -260,26 +263,29 @@ function compileStep(slide, layouts, rootDir, assetTypeByPath) {
             throw new Error(`Slide ${index}: layout "${layoutName}" requires slot "${slot.key}"; none provided`);
         }
     }
-    // CompilerDeckStep.content values are MarkdownBlock — CodeFence and
-    // MermaidFence are legal in transit until the resolvers narrow them into
-    // StyledParagraph[] / ImageFill before the engine sees the deck.
+    // Content values are already engine fills — code fences highlighted to TextFill
+    // and mermaid fences rendered to ImageFill by their handler's `compile`.
     const step = { layout: layoutName, content };
     if (notes !== undefined)
         step.notes = notes;
     return step;
 }
-const KNOWN_GLOBAL_KEYS = new Set([RESERVED_KEY.THEME, RESERVED_KEY.OUTPUT]);
 /**
- * Compile a parsed deck document against a set of layouts.
+ * Compile a parsed deck document against a theme `config`. Each slide's content
+ * is compiled straight into engine fills — prose/tables/images plus highlighted
+ * code (Shiki) and rendered mermaid (PNG) — so the returned deck is
+ * engine-shaped, ready for `buildDeck`.
  *
- * `rootDir` (optional) is the base directory for resolving relative image
- * paths declared in the deck's frontmatter or named slots. When omitted (or
- * empty), image paths are returned unchanged — callers that already produce
- * absolute paths (or callers that don't need resolution, e.g. unit tests)
- * can rely on the pass-through. When provided, relative paths are resolved
- * to absolute via `path.resolve(rootDir, path)`; absolute paths pass through.
+ * `config.rootDir` is the base directory for resolving relative image paths
+ * declared in the deck's frontmatter or named slots. When empty, image paths are
+ * returned unchanged — callers that already produce absolute paths (or don't need
+ * resolution, e.g. unit tests) rely on the pass-through. When set, relative paths
+ * are resolved to absolute via `path.resolve(rootDir, path)`; absolute paths pass
+ * through. `config.codeTheme` / `config.mermaid` / `config.mermaidVariant` /
+ * `config.outputDir` feed the code and mermaid compiles.
  */
-export function compileDeck(doc, layouts, rootDir = "", assets = {}) {
+export async function compileDeck(doc, config) {
+    const { layouts, rootDir, assets } = config;
     const theme = doc.global[RESERVED_KEY.THEME];
     if (theme === undefined) {
         throw new Error(`Missing required "${RESERVED_KEY.THEME}" in global frontmatter`);
@@ -288,8 +294,10 @@ export function compileDeck(doc, layouts, rootDir = "", assets = {}) {
     if (unknownGlobal.length > 0) {
         throw new Error(`Unknown key(s) in global frontmatter: ${unknownGlobal.join(", ")}. Valid keys: ${[...KNOWN_GLOBAL_KEYS].join(", ")}`);
     }
-    // Validate every layout's key spaces up front (once per layout), so a broken
-    // theme fails fast regardless of which layouts this deck's slides use.
+    // Validate the layout list as a whole (one pass), then each layout's key
+    // spaces up front (once per layout), so a broken theme fails fast regardless
+    // of which layouts this deck's slides use.
+    assertUniqueSlideNumbers(layouts);
     for (const layout of layouts)
         validateLayout(layout);
     // Index each catalog asset's resolved path → its declared type, so an image
@@ -300,10 +308,32 @@ export function compileDeck(doc, layouts, rootDir = "", assets = {}) {
             assetTypeByPath.set(resolveImagePath(rootDir, entry.path), entry.type);
         }
     }
-    const deck = {
-        theme: String(theme),
-        steps: doc.slides.map((slide) => compileStep(slide, layouts, rootDir, assetTypeByPath)),
+    // Resolve a body/`::name::` `$category.name` reference against the theme's
+    // curated asset catalog. Anchored ⇒ the whole ref is the reference or it is
+    // nothing; a found entry wraps through the same path→ImageFit mapping as a
+    // frontmatter image (`toImageFill`), so a body image has no second fit story.
+    const resolveAssetRef = (ref) => {
+        const match = ASSET_REF_RE.exec(ref);
+        if (!match) {
+            throw new Error(`Asset reference "${ref}" must be in the form $category.name (e.g. $logos.primary).`);
+        }
+        const [, category, name] = match;
+        const entry = assets[category]?.[name];
+        if (!entry) {
+            const available = Object.entries(assets)
+                .flatMap(([cat, group]) => Object.keys(group).map((n) => `$${cat}.${n}`))
+                .join(", ");
+            throw new Error(`Unknown asset reference "${ref}". Available: ${available}`);
+        }
+        return toImageFill(resolveImagePath(rootDir, entry.path), entry.type);
     };
+    // Slides compile in order: a slide's structural errors (unknown layout/key,
+    // bad asset ref, accept-type mismatch) fire before its own content is rendered.
+    const steps = [];
+    for (const slide of doc.slides) {
+        steps.push(await compileStep(slide, config, assetTypeByPath, resolveAssetRef));
+    }
+    const deck = { theme: String(theme), steps };
     const output = doc.global[RESERVED_KEY.OUTPUT];
     if (output !== undefined) {
         deck.output = String(output);

package/dist/markdown/index.d.ts

@@ -1,13 +1,13 @@
-import type { AssetCatalog, CompilerDeck, CompilerLayout } from "./types.js";
-export declare function compileMarkdownDeck(source: string, layouts: CompilerLayout[], rootDir?: string, assets?: AssetCatalog): CompilerDeck;
-export { compileDeck, RESERVED_KEY } from "./deckCompiler.js";
-export { parseGfmTable, parseInlineRuns, parseProseLine, parseStyledParagraph } from "./parsers.js";
-export { CodeResolver, highlightCode, isCodeBlock } from "./resolvers/code.js";
-export { isMermaidBlock, MermaidResolver } from "./resolvers/mermaid.js";
-export type { MermaidConfig, MermaidVariant } from "./resolvers/mermaidTheme.js";
-export type { ResolveContext, Resolver } from "./resolvers/resolver.js";
-export { isFence, RESOLVERS, resolveFences } from "./resolvers/resolver.js";
+import type { CompilerConfig, CompilerDeck } from "./types.js";
+export declare function compileMarkdownDeck(source: string, config: CompilerConfig): Promise<CompilerDeck>;
+export { highlightCode } from "./blocks/code.js";
+export type { MermaidConfig, MermaidVariant } from "./blocks/mermaidTheme.js";
+export { type BlockContext, type BlockHandler, parseSlotContent } from "./blocks/registry.js";
+export { compileDeck } from "./deckCompiler.js";
+export { parseInlineRuns } from "./inline.js";
+export { parseRegion } from "./mdast.js";
+export { loadThemeConfig, parseThemeConfig, ThemeConfigSchema } from "./schema/themeConfigSchema.js";
 export type { ParsedDocument, RawSlide } from "./slideParser.js";
 export { parseSlideDocument } from "./slideParser.js";
-export type { AssetCatalog, AssetEntry, CodeFence, CompilerCodeSlot, CompilerConfig, CompilerDeck, CompilerDeckStep, CompilerImageParameter, CompilerLayout, CompilerMermaidSlot, CompilerParameter, CompilerSlot, CompilerTableSlot, CompilerTemplateParameter, CompilerTextSlot, CompilerThemeConfig, MarkdownBlock, MermaidFence, ResolvedCompilerDeck, ResolvedCompilerDeckStep, } from "./types.js";
-export { AssetType, CompilerSlotType, FenceType, ParameterType } from "./types.js";
+export type { AssetCatalog, AssetEntry, CompilerBlock, CompilerConfig, CompilerDeck, CompilerDeckStep, CompilerImageParameter, CompilerLayout, CompilerParameter, CompilerSlot, CompilerTemplateParameter, CompilerThemeConfig, EngineFill, Limit, } from "./types.js";
+export { AcceptType, AssetType, ParameterType, RESERVED_KEY } from "./types.js";

package/dist/markdown/index.js

@@ -1,13 +1,14 @@
 import { compileDeck } from "./deckCompiler.js";
 import { parseSlideDocument } from "./slideParser.js";
-export function compileMarkdownDeck(source, layouts, rootDir = "", assets = {}) {
+export function compileMarkdownDeck(source, config) {
     const doc = parseSlideDocument(source);
-    return compileDeck(doc, layouts, rootDir, assets);
+    return compileDeck(doc, config);
 }
-export { compileDeck, RESERVED_KEY } from "./deckCompiler.js";
-export { parseGfmTable, parseInlineRuns, parseProseLine, parseStyledParagraph } from "./parsers.js";
-export { CodeResolver, highlightCode, isCodeBlock } from "./resolvers/code.js";
-export { isMermaidBlock, MermaidResolver } from "./resolvers/mermaid.js";
-export { isFence, RESOLVERS, resolveFences } from "./resolvers/resolver.js";
+export { highlightCode } from "./blocks/code.js";
+export { parseSlotContent } from "./blocks/registry.js";
+export { compileDeck } from "./deckCompiler.js";
+export { parseInlineRuns } from "./inline.js";
+export { parseRegion } from "./mdast.js";
+export { loadThemeConfig, parseThemeConfig, ThemeConfigSchema } from "./schema/themeConfigSchema.js";
 export { parseSlideDocument } from "./slideParser.js";
-export { AssetType, CompilerSlotType, FenceType, ParameterType } from "./types.js";
+export { AcceptType, AssetType, ParameterType, RESERVED_KEY } from "./types.js";

package/dist/markdown/inline.d.ts

@@ -0,0 +1,26 @@
+import type { PhrasingContent } from "mdast";
+import type { TextRun } from "../engine/index.js";
+/** The subset of MdastType values that are PhrasingContent (dispatched by walkPhrasing). */
+export declare const PHRASING_TYPES: ReadonlySet<string>;
+/**
+ * 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[];
+/**
+ * Inline formatting carried down the phrasing walk. `breakAsNewline` is the one
+ * block-vs-inline knob: in block aggregation a markdown hard `break` node must
+ * split the paragraph, so the walk emits it as a `"\n"` run (which the block
+ * text splitter then breaks on); the single-line `parseInlineRuns` path leaves
+ * it unset, so a hard break stays a space.
+ */
+export interface InlineState {
+    bold?: boolean;
+    italic?: boolean;
+    strikethrough?: boolean;
+    underline?: boolean;
+    link?: string;
+    breakAsNewline?: boolean;
+}
+export declare function walkPhrasingChildren(children: PhrasingContent[], state: InlineState): TextRun[];

package/dist/markdown/inline.js

@@ -0,0 +1,136 @@
+import { MdastType, parseInline } from "./mdast.js";
+/** The subset of MdastType values that are PhrasingContent (dispatched by walkPhrasing). */
+export const PHRASING_TYPES = new Set([
+    MdastType.Text,
+    MdastType.InlineCode,
+    MdastType.Strong,
+    MdastType.Emphasis,
+    MdastType.Delete,
+    MdastType.Insert,
+    MdastType.Link,
+    MdastType.Break,
+]);
+/**
+ * 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 }];
+    }
+    const tree = parseInline(text);
+    const runs = walkInlineRoot(tree, {});
+    return runs.length > 0 ? runs : [{ text: "" }];
+}
+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 markdown hard break. In block aggregation it splits the paragraph
+            // (emit a "\n" run the splitter breaks on); on the single-line inline
+            // path it collapses to a space.
+            return [makeRun(state.breakAsNewline ? "\n" : " ", 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 [];
+    }
+}
+export 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);
+}