@tycoworks/tycoslide 0.10.0 → 0.11.0

package/dist/engine/generate.js

@@ -33,6 +33,7 @@ import { Automizer, modify } from "pptx-automizer";
 import { FILLERS } from "./fillers/filler.js";
 import { isImageFill } from "./fillers/image.js";
 import { applyNotesToSlide, sweepOrphanNotes } from "./notes.js";
+import { SlotType } from "./types.js";
 /**
  * Generate a PPTX file from a deck definition and a theme configuration.
  *
@@ -46,9 +47,11 @@ import { applyNotesToSlide, sweepOrphanNotes } from "./notes.js";
  *   4. Write the output PPTX.
  */
 export async function generate(deck, config, options = {}) {
-    const { layouts, rootDir, template, outputDir } = config;
-    const outFile = deck.output;
-    const outDir = outputDir ?? process.cwd();
+    const { layouts, rootDir, template } = config;
+    // deck.output is the absolute output path; automizer takes a dir + a bare
+    // filename, so split it. The CLI resolves it next to the deck file.
+    const outDir = dirname(deck.output);
+    const outFile = basename(deck.output);
     const automizer = new Automizer({
         templateDir: resolve(rootDir, "template"),
         outputDir: outDir,
@@ -98,11 +101,12 @@ export async function generate(deck, config, options = {}) {
     // onto slides. When true, no notes are written but inherited notes are still
     // stripped — the deck is guaranteed notes-free.
     const excludeNotes = options.excludeNotes ?? false;
-    for (const step of deck.steps) {
+    for (const [index, step] of deck.steps.entries()) {
         const layout = resolveLayout(step.layout);
+        const slideNumber = index + 1;
         pres.addSlide(sourceAlias, layout.baseSlide, (slide) => {
             captureFillErrors(slide);
-            fillSlide(slide, layout, step, sourceAlias);
+            fillSlide(slide, layout, step, sourceAlias, slideNumber);
             // In-band notes pass: automizer runs this during write() and hands us the
             // OUTPUT archive (parent.targetArchive) and the real output slide number
             // (parent.targetNumber), so notes map 1:1 with no slide-number mapping.
@@ -179,22 +183,39 @@ function describeValue(v) {
 /**
  * Fill one cloned slide. Per slot the step supplies a value for: resolve WHICH
  * shape realizes it (`resolveBlock`), build WHAT to write (`FILLERS[…].callbacks`),
- * and place it WHERE/HOW (`applyBlock`). Every ambiguity fails fast, naming layout
- * + slot.
+ * and place it WHERE/HOW (`applyBlock`). A slot the step leaves unfilled has its
+ * base-slide shape removed, so a layout with numbered slots renders exactly the
+ * ones supplied. Every ambiguity fails fast, naming layout + slot.
  *
  * Exported for tests; `generate()` calls it inside the `addSlide` callback.
  */
-export function fillSlide(slide, layout, step, sourceAlias) {
+export function fillSlide(slide, layout, step, sourceAlias, slideNumber) {
     assertNoUnknownSlots(step, layout);
     for (const slot of layout.slots) {
         const value = step.content?.[slot.key];
-        if (value === undefined)
-            continue; // Empty slot: leave the base slide's shape untouched.
+        if (value === undefined) {
+            // An unfilled slot places no content — remove its base-slide shape (if it
+            // has one) so the clone carries nothing there. A transplant-only slot never
+            // placed a shape on the clone, so there is nothing to remove.
+            const baseBlock = slot.accepts.find((b) => b.sourceSlide === layout.baseSlide);
+            if (baseBlock)
+                slide.removeElement(baseBlock.shapeName);
+            continue;
+        }
         const block = resolveBlock(step, slot, value);
-        const callbacks = FILLERS[block.type].callbacks(value, targetOf(block));
+        const target = targetOf(block, slotLabel(slideNumber, layout, slot));
+        const callbacks = FILLERS[block.type].callbacks(value, target);
         applyBlock(slide, sourceAlias, layout.baseSlide, slot, block, callbacks);
     }
 }
+/**
+ * The author-facing descriptor a filler prints in advisory warnings, so a
+ * message points at `slide 3, layout "Body", slot "photo"` rather than the raw
+ * PPTX shape id.
+ */
+function slotLabel(slideNumber, layout, slot) {
+    return `slide ${slideNumber}, layout "${layout.name}", slot "${slot.key}"`;
+}
 /** The SlotType a resolved `*Fill` value maps to, via the filler discriminators. */
 function fillTypeOf(value) {
     for (const type of Object.keys(FILLERS)) {
@@ -249,12 +270,25 @@ function resolveBlock(step, slot, value) {
     }
     return block;
 }
-/** The shape a filler targets, plus `startAt` when the (text) block declares it. */
-function targetOf(block) {
-    const target = { shapeName: block.shapeName };
-    if (block.startAt !== undefined)
-        target.startAt = block.startAt;
-    return target;
+/**
+ * The shape a filler targets, plus its diagnostic `label` and the intra-specimen
+ * options a block declares: `startAt` (text) and the required `bodyRows` (table).
+ * The block's `type` selects the matching target variant, so each filler's
+ * callback sees only its own options.
+ */
+function targetOf(block, label) {
+    switch (block.type) {
+        case SlotType.Template:
+            return { type: SlotType.Template, shapeName: block.shapeName, label };
+        case SlotType.Text:
+            return block.startAt !== undefined
+                ? { type: SlotType.Text, shapeName: block.shapeName, label, startAt: block.startAt }
+                : { type: SlotType.Text, shapeName: block.shapeName, label };
+        case SlotType.Table:
+            return { type: SlotType.Table, shapeName: block.shapeName, label, bodyRows: block.bodyRows };
+        case SlotType.Image:
+            return { type: SlotType.Image, shapeName: block.shapeName, label };
+    }
 }
 /**
  * WHERE/HOW: place the (already-built) fill callbacks. A base-slide block is

package/dist/engine/index.d.ts

@@ -5,5 +5,5 @@ export { fillTemplate } from "./fillers/template.js";
 export { fillText, isTextFill } from "./fillers/text.js";
 export type { GenerateOptions } from "./generate.js";
 export { generate } from "./generate.js";
-export type { Block, Config, Deck, DeckStep, Frame, ImageFill, Layout, Slot, StyledParagraph, TableFill, TemplateFill, TemplateSegment, TextFill, TextRun, ThemeConfig, } from "./types.js";
+export type { Block, BodyRows, Config, Deck, DeckStep, Frame, ImageFill, Layout, Slot, StyledParagraph, TableFill, TemplateFill, TemplateSegment, TextFill, TextRun, ThemeConfig, } from "./types.js";
 export { ImageFit, SlotType } from "./types.js";

package/dist/engine/types.d.ts

@@ -14,6 +14,15 @@ export declare const SlotType: {
     readonly Image: "image";
 };
 export type SlotType = (typeof SlotType)[keyof typeof SlotType];
+/**
+ * The contiguous range of a table specimen's rows that repeat, as `[start, end]`
+ * (0-based, inclusive). Row 0 is always the header; rows `[1, start-1]` are top
+ * fixed rows rendered once (e.g. a distinctly-styled under-header row); rows
+ * `[start, end]` are the repeatable body, cycled to fill the deck's data; rows
+ * `[end+1, R-1]` are bottom fixed rows rendered once (e.g. a decorated total row).
+ * Only the body range repeats; every row outside it is rendered once, in place.
+ */
+export type BodyRows = [number, number];
 /** A single styled span of text within a paragraph. */
 export type TextRun = {
     text: string;
@@ -102,23 +111,43 @@ export type Frame = {
 };
 /**
  * A kind of content a slot accepts, and the real template shape that realizes
- * it. `type` is the fill-strategy discriminator; `shapeName` names the shape on
- * `sourceSlide` that carries the specimen styling. When `sourceSlide` equals the
- * layout's `baseSlide` the shape is already on the cloned slide (fill in place);
- * otherwise the shape is transplanted from `sourceSlide` into the slot's frame.
- * `startAt` is a text-specimen concern (leave the first N specimen paragraphs
- * untouched) and only meaningful on a text block.
+ * it — a union discriminated by `type` (the fill-strategy selector), so each
+ * variant carries only its own specimen options. `shapeName` names the shape on
+ * `sourceSlide` that carries the specimen styling; when `sourceSlide` equals the
+ * layout's `baseSlide` the shape is already on the cloned slide (fill in place),
+ * otherwise it is transplanted from `sourceSlide` into the slot's frame. A text
+ * block may pin `startAt` (leave the first N specimen paragraphs untouched); a
+ * table block MUST declare its `bodyRows` range (the repeatable specimen rows);
+ * a template or image block carries neither. `Template` reaches the engine only
+ * via a frontmatter parameter (`paramToEngineSlot`), never as an author body block.
  *
- * Named `Block` — a kind of content (image / table / text) the way an author
- * thinks of it. Distinct from the compiler's `MarkdownBlock` (a parsed markdown
- * block); different layer, kept separate on purpose.
+ * Named `Block` — a kind of content the way an author thinks of it. Distinct
+ * from the compiler's `MarkdownBlock` (a parsed markdown block); different layer,
+ * kept separate on purpose.
  */
-export type Block = {
-    type: SlotType;
+export type TemplateBlock = {
+    type: typeof SlotType.Template;
+    sourceSlide: number;
+    shapeName: string;
+};
+export type TextBlock = {
+    type: typeof SlotType.Text;
     sourceSlide: number;
     shapeName: string;
     startAt?: number;
 };
+export type TableBlock = {
+    type: typeof SlotType.Table;
+    sourceSlide: number;
+    shapeName: string;
+    bodyRows: BodyRows;
+};
+export type ImageBlock = {
+    type: typeof SlotType.Image;
+    sourceSlide: number;
+    shapeName: string;
+};
+export type Block = TemplateBlock | TextBlock | TableBlock | ImageBlock;
 /**
  * An author-facing fill region. Not welded to one shape+type: a slot owns its
  * `frame` and `accepts` a set of `Block`s; the supplied value's shape selects
@@ -147,14 +176,13 @@ export type DeckStep = {
 };
 export type Deck = {
     theme: string;
-    /** Output filename. Required — no silent default. */
+    /** Absolute output path for the .pptx. Required — no silent default. */
     output: string;
     steps: DeckStep[];
 };
 export type ThemeConfig = {
     layouts: Layout[];
     template: string;
-    outputDir?: string;
 };
 export type Config = ThemeConfig & {
     rootDir: string;

package/dist/index.d.ts

@@ -28,13 +28,12 @@ export declare function toEngineConfig(config: CompilerConfig): Config;
  * populates it before calling `buildDeck`; a programmatic caller that forgot to
  * set it hits this error instead of a confusing engine-side failure.
  *
- * Mermaid PNGs are cached under `<outputDir>/.tycoslide-cache/mermaid/` so no
- * post-write cleanup is needed.
+ * Mermaid PNGs are cached under `<rootDir>/.tycoslide-cache/mermaid/` (the theme
+ * directory) so no post-write cleanup is needed.
  */
 export declare function buildDeck(deck: CompilerDeck, config: CompilerConfig, options?: GenerateOptions): Promise<void>;
 export type { Config, Deck, DeckStep, GenerateOptions, ImageFill, Layout, Slot, StyledParagraph, TableFill, TextFill, TextRun, ThemeConfig, } from "./engine/index.js";
 export { fillImage, fillTable, fillTemplate, fillText, generate, SlotType } from "./engine/index.js";
-export type { ManifestOptions } from "./manifest.js";
 export { generateManifest } from "./manifest.js";
-export type { AssetCatalog, AssetEntry, CompilerBlock, CompilerConfig, CompilerDeck, CompilerDeckStep, CompilerLayout, CompilerParameter, CompilerSlot, CompilerThemeConfig, EngineFill, Limit, MermaidConfig, MermaidVariant, ParsedDocument, RawSlide, } from "./markdown/index.js";
+export type { AssetCatalog, AssetEntry, CompilerBlock, CompilerConfig, CompilerDeck, CompilerDeckStep, CompilerLayout, CompilerParameter, CompilerSlot, CompilerThemeConfig, EngineFill, MermaidConfig, MermaidVariant, ParsedDocument, RawSlide, } from "./markdown/index.js";
 export { AcceptType, compileMarkdownDeck, loadThemeConfig, ParameterType, parseThemeConfig } from "./markdown/index.js";

package/dist/index.js

@@ -1,5 +1,5 @@
 import { generate, SlotType, } from "./engine/index.js";
-import { ParameterType, } from "./markdown/types.js";
+import { AcceptType, ParameterType, } from "./markdown/types.js";
 /**
  * A frontmatter parameter always fills one physical shape on the layout's own
  * slide, so it projects to a single base `Block` (`sourceSlide === baseSlide`)
@@ -8,15 +8,22 @@ import { ParameterType, } from "./markdown/types.js";
  */
 const NO_FRAME = { x: 0, y: 0, cx: 0, cy: 0 };
 function paramToEngineSlot(param, baseSlide) {
-    const block = (type) => ({ type, sourceSlide: baseSlide, shapeName: param.shapeName });
     switch (param.type) {
         case ParameterType.Template:
             // A text shape carries no top-level key — its template placeholders are the keys. The
             // compiler emits its expanded content under shapeName, so the engine slot
             // is keyed by shapeName too.
-            return { key: param.shapeName, frame: NO_FRAME, accepts: [block(SlotType.Template)] };
+            return {
+                key: param.shapeName,
+                frame: NO_FRAME,
+                accepts: [{ type: SlotType.Template, sourceSlide: baseSlide, shapeName: param.shapeName }],
+            };
         case ParameterType.Image:
-            return { key: param.key, frame: NO_FRAME, accepts: [block(SlotType.Image)] };
+            return {
+                key: param.key,
+                frame: NO_FRAME,
+                accepts: [{ type: SlotType.Image, sourceSlide: baseSlide, shapeName: param.shapeName }],
+            };
     }
 }
 /**
@@ -26,14 +33,21 @@ function paramToEngineSlot(param, baseSlide) {
  * so projection is 1:1. A slot with no declared `frame` (a base-only slot that
  * never transplants) gets `NO_FRAME`, which the engine never reads.
  */
+/** Project one CompilerBlock variant onto its matching engine `Block` variant. */
+function compilerBlockToEngineBlock(b) {
+    switch (b.type) {
+        case AcceptType.Text:
+            return b.startAt !== undefined
+                ? { type: SlotType.Text, sourceSlide: b.sourceSlide, shapeName: b.shapeName, startAt: b.startAt }
+                : { type: SlotType.Text, sourceSlide: b.sourceSlide, shapeName: b.shapeName };
+        case AcceptType.Table:
+            return { type: SlotType.Table, sourceSlide: b.sourceSlide, shapeName: b.shapeName, bodyRows: b.bodyRows };
+        case AcceptType.Image:
+            return { type: SlotType.Image, sourceSlide: b.sourceSlide, shapeName: b.shapeName };
+    }
+}
 function slotToEngineSlot(slot) {
-    const accepts = slot.accepts.map((b) => {
-        const eb = { type: b.type, sourceSlide: b.sourceSlide, shapeName: b.shapeName };
-        if (b.startAt !== undefined)
-            eb.startAt = b.startAt;
-        return eb;
-    });
-    return { key: slot.key, frame: slot.frame ?? NO_FRAME, accepts };
+    return { key: slot.key, frame: slot.frame ?? NO_FRAME, accepts: slot.accepts.map(compilerBlockToEngineBlock) };
 }
 /**
  * Compiler→engine boundary check: a slot with a transplant block (any block
@@ -74,8 +88,6 @@ export function toEngineThemeConfig(config) {
         layouts: config.layouts.map(toEngineLayout),
         template: config.template,
     };
-    if (config.outputDir !== undefined)
-        result.outputDir = config.outputDir;
     return result;
 }
 /**
@@ -102,8 +114,8 @@ export function toEngineConfig(config) {
  * populates it before calling `buildDeck`; a programmatic caller that forgot to
  * set it hits this error instead of a confusing engine-side failure.
  *
- * Mermaid PNGs are cached under `<outputDir>/.tycoslide-cache/mermaid/` so no
- * post-write cleanup is needed.
+ * Mermaid PNGs are cached under `<rootDir>/.tycoslide-cache/mermaid/` (the theme
+ * directory) so no post-write cleanup is needed.
  */
 export async function buildDeck(deck, config, options = {}) {
     if (deck.output === undefined) {
@@ -114,6 +126,7 @@ export async function buildDeck(deck, config, options = {}) {
 }
 // Engine — primitives-only public surface.
 export { fillImage, fillTable, fillTemplate, fillText, generate, SlotType } from "./engine/index.js";
+// Authoring
 export { generateManifest } from "./manifest.js";
 // Markdown / Compiler
 export { AcceptType, compileMarkdownDeck, loadThemeConfig, ParameterType, parseThemeConfig } from "./markdown/index.js";

package/dist/manifest.d.ts

@@ -1,7 +1,2 @@
 import type { CompilerConfig } from "./markdown/types.js";
-export type ManifestOptions = {
-    build: {
-        command: string;
-    };
-};
-export declare function generateManifest(config: CompilerConfig, options: ManifestOptions): string;
+export declare function generateManifest(config: CompilerConfig): string;

package/dist/manifest.js

@@ -5,11 +5,6 @@ import { ParameterType } from "./markdown/types.js";
  * A template parameter has no top-level key — its template's keys are the keys, so it
  * flattens to one entry per key (shapeName/template stay manifest-internal). An
  * image parameter is a single key.
- *
- * A template parameter's `limit` is deliberately NOT projected here: it measures the
- * expanded run text (parameter-level), so surfacing it per key would misrepresent
- * it as per-key. How to advertise a parameter-level limit is a Phase 2 decision;
- * until then it stays manifest-internal.
  */
 function stripParameter(param) {
     switch (param.type) {
@@ -32,11 +27,9 @@ function stripSlot(slot) {
     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;
     return result;
 }
-export function generateManifest(config, options) {
+export function generateManifest(config) {
     const layouts = config.layouts.map((layout) => {
         const ml = {
             name: layout.name,
@@ -46,10 +39,6 @@ export function generateManifest(config, options) {
         };
         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 = {};
@@ -61,8 +50,6 @@ export function generateManifest(config, options) {
                 type: entry.type,
                 description: entry.description,
             };
-            if (entry.whenToUse)
-                manifestEntry.whenToUse = entry.whenToUse;
             assets[category][name] = manifestEntry;
         }
     }
@@ -70,9 +57,6 @@ export function generateManifest(config, options) {
         version: 1,
         layouts,
         assets,
-        build: {
-            command: options.build.command,
-        },
     };
     return JSON.stringify(manifest, null, 2);
 }

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

@@ -6,7 +6,7 @@ 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
+ * `<rootDir>/.tycoslide-cache/mermaid/<hash>.png`, in the theme directory) 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

package/dist/markdown/blocks/mermaid.js

@@ -14,7 +14,7 @@ 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
+ * `<rootDir>/.tycoslide-cache/mermaid/<hash>.png`, in the theme directory) 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
@@ -69,7 +69,7 @@ function hashKey(definition, variantName, renderConfig, fonts) {
     return hash.digest("hex").slice(0, 16);
 }
 function ensureCacheDir(config) {
-    const base = resolve(config.outputDir ?? process.cwd(), ".tycoslide-cache", "mermaid");
+    const base = resolve(config.rootDir, ".tycoslide-cache", "mermaid");
     mkdirSync(base, { recursive: true });
     return base;
 }
@@ -198,7 +198,7 @@ ${fontFaceCss(fonts)}
 </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.
+    // whereas a file://-origin document loads them.
     const htmlPath = `${outputPath}.html`;
     const { chromium } = await import("playwright");
     let browser;

package/dist/markdown/blocks/table.js

@@ -16,7 +16,7 @@ function compileTable(node) {
     };
 }
 /** 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("")`. */
+ * downstream code always sees a run to style. */
 function cellParagraph(cell) {
     const runs = walkPhrasingChildren(cell.children, {});
     return { runs: runs.length > 0 ? runs : [{ text: "" }] };

package/dist/markdown/blocks/text.js

@@ -64,12 +64,11 @@ function listParagraphs(list, 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.
+ * Split a paragraph's runs on newlines into one `TextRun[]` per source line, so
+ * one source line becomes one StyledParagraph. 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.
  */
 function splitRunsIntoParagraphs(runs) {
     const lines = [];

package/dist/markdown/deckCompiler.d.ts

@@ -18,7 +18,7 @@ export declare function toImageFill(path: string, type: AssetType): ImageFill;
  * 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.
+ * through. `config.codeTheme` / `config.mermaid` / `config.mermaidVariant` feed
+ * the code and mermaid compiles.
  */
 export declare function compileDeck(doc: ParsedDocument, config: CompilerConfig): Promise<CompilerDeck>;

package/dist/markdown/deckCompiler.js

@@ -18,7 +18,7 @@ const FIT_FOR = {
 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]);
+const KNOWN_GLOBAL_KEYS = new Set([RESERVED_KEY.THEME]);
 // 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*)$/;
@@ -50,8 +50,8 @@ function resolveImagePath(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.
+ * `slideNumber` means 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.
@@ -123,7 +123,7 @@ function validateLayout(layout) {
 }
 async function compileStep(slide, config, assetTypeByPath, resolveAssetRef) {
     const { layouts, rootDir } = config;
-    const { frontmatter, body, slots, index } = slide;
+    const { frontmatter, slots, index } = slide;
     const layout = frontmatter[RESERVED_KEY.LAYOUT];
     if (layout === undefined) {
         throw new Error(`Slide ${index}: missing required "${RESERVED_KEY.LAYOUT}" in frontmatter`);
@@ -211,26 +211,6 @@ async function compileStep(slide, config, assetTypeByPath, resolveAssetRef) {
             lines: templateToSegments(templateParam.template, supplied, templateParam.shapeName),
         };
     }
-    // The default body region resolves against the layout's body slot.
-    if (body.trim()) {
-        const bodySlot = slotsByKey.get(RESERVED_KEY.BODY);
-        if (!bodySlot) {
-            throw new Error(`Slide ${index}: layout "${layoutName}" does not accept body content. Valid slots: ${[...slotsByKey.keys()].join(", ")}`);
-        }
-        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)) {
         const slot = slotsByKey.get(name);
@@ -281,8 +261,8 @@ async function compileStep(slide, config, assetTypeByPath, resolveAssetRef) {
  * 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.
+ * through. `config.codeTheme` / `config.mermaid` / `config.mermaidVariant` feed
+ * the code and mermaid compiles.
  */
 export async function compileDeck(doc, config) {
     const { layouts, rootDir, assets } = config;
@@ -333,10 +313,5 @@ export async function compileDeck(doc, config) {
     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);
-    }
-    return deck;
+    return { theme: String(theme), steps };
 }

package/dist/markdown/index.d.ts

@@ -9,5 +9,5 @@ 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, CompilerBlock, CompilerConfig, CompilerDeck, CompilerDeckStep, CompilerImageParameter, CompilerLayout, CompilerParameter, CompilerSlot, CompilerTemplateParameter, CompilerThemeConfig, EngineFill, Limit, } from "./types.js";
+export type { AssetCatalog, AssetEntry, CompilerBlock, CompilerConfig, CompilerDeck, CompilerDeckStep, CompilerImageParameter, CompilerLayout, CompilerParameter, CompilerSlot, CompilerTemplateParameter, CompilerThemeConfig, EngineFill, } from "./types.js";
 export { AcceptType, AssetType, ParameterType, RESERVED_KEY } from "./types.js";

package/dist/markdown/schema/deckSchema.d.ts

@@ -15,8 +15,8 @@ import type { CompilerLayout } from "../types.js";
  *   and `.optional()` (`required` is per-parameter, enforced in `compileStep`, not
  *   "all a template's keys present"). Value-typing and required-encoding are deliberate
  *   later commits.
- * The strict object IS the unknown-key check that used to be imperative in
- * `compileStep`; a stray frontmatter key throws instead of being silently ignored.
+ * The strict object IS the unknown-key check: a stray frontmatter key throws
+ * instead of being silently ignored.
  */
 export declare function deckFrontmatterSchema(layout: CompilerLayout): z.ZodObject<{
     [x: string]: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;

package/dist/markdown/schema/deckSchema.js

@@ -17,8 +17,8 @@ import { strict } from "./strict.js";
  *   and `.optional()` (`required` is per-parameter, enforced in `compileStep`, not
  *   "all a template's keys present"). Value-typing and required-encoding are deliberate
  *   later commits.
- * The strict object IS the unknown-key check that used to be imperative in
- * `compileStep`; a stray frontmatter key throws instead of being silently ignored.
+ * The strict object IS the unknown-key check: a stray frontmatter key throws
+ * instead of being silently ignored.
  */
 export function deckFrontmatterSchema(layout) {
     const shape = {};

package/dist/markdown/schema/themeConfigSchema.d.ts

@@ -5,19 +5,12 @@ export declare const ThemeConfigSchema: z.ZodObject<{
         name: z.ZodString;
         slideNumber: z.ZodNumber;
         description: z.ZodOptional<z.ZodString>;
-        whenToUse: z.ZodOptional<z.ZodString>;
-        whenNotToUse: z.ZodOptional<z.ZodString>;
         variant: z.ZodOptional<z.ZodEnum<{
             light: "light";
             dark: "dark";
         }>>;
         parameters: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
             shapeName: z.ZodString;
-            limit: z.ZodOptional<z.ZodObject<{
-                maxChars: z.ZodOptional<z.ZodNumber>;
-                maxLines: z.ZodOptional<z.ZodNumber>;
-                maxItems: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strict>>;
             required: z.ZodOptional<z.ZodBoolean>;
             type: z.ZodLiteral<"template">;
             template: z.ZodString;
@@ -29,27 +22,27 @@ export declare const ThemeConfigSchema: z.ZodObject<{
         }, z.core.$strict>], "type">>;
         slots: z.ZodArray<z.ZodObject<{
             key: z.ZodString;
-            accepts: z.ZodArray<z.ZodObject<{
-                type: z.ZodEnum<{
-                    text: "text";
-                    table: "table";
-                    image: "image";
-                }>;
+            accepts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"text">;
                 sourceSlide: z.ZodNumber;
                 shapeName: z.ZodString;
                 startAt: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"table">;
+                sourceSlide: z.ZodNumber;
+                shapeName: z.ZodString;
+                bodyRows: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"image">;
+                sourceSlide: z.ZodNumber;
+                shapeName: z.ZodString;
+            }, z.core.$strict>], "type">>;
             frame: z.ZodOptional<z.ZodObject<{
                 x: z.ZodNumber;
                 y: z.ZodNumber;
                 cx: z.ZodNumber;
                 cy: z.ZodNumber;
             }, z.core.$strict>>;
-            limit: z.ZodOptional<z.ZodObject<{
-                maxChars: z.ZodOptional<z.ZodNumber>;
-                maxLines: z.ZodOptional<z.ZodNumber>;
-                maxItems: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strict>>;
             required: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
@@ -61,10 +54,8 @@ export declare const ThemeConfigSchema: z.ZodObject<{
             background: "background";
         }>;
         description: z.ZodString;
-        whenToUse: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>>;
     template: z.ZodString;
-    outputDir: z.ZodOptional<z.ZodString>;
     mermaid: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         primary: z.ZodString;
         primaryContrast: z.ZodString;