@tycoworks/tycoslide 0.11.3 → 0.12.0

package/SKILL.md

@@ -40,7 +40,7 @@ Before writing anything, read `manifest.json`. It contains:
 - **assets** -- brand logos, client logos, illustrations, and icons (`description`)
 
 A layout's inputs split two ways (see [syntax.md](syntax.md) for details):
-- **parameters** -- one value on a frontmatter line. Types: `template`, `image`. Fill by putting a value under the parameter's key in the slide frontmatter.
+- **parameters** -- one value on a frontmatter line. Fill by putting a value under the parameter's key in the slide frontmatter.
 - **slots** -- a multi-line region in the body. Accept types: `text`, `table`, `image`. Fill as a `::key::` region, using the slot's `key` from the manifest; a fenced code block routes to a `text` slot, a fenced mermaid block to an `image` slot.
 
 A slot may accept more than one content type -- the manifest lists each slot's `accepts`, and the shape of the content you write selects which one.
@@ -89,7 +89,7 @@ A deck file has three parts:
 
 ### Slide frontmatter
 
-Every slide must have a `layout:` key. All other frontmatter keys map 1:1 to the layout's **parameters** (template and image inputs).
+Every slide must have a `layout:` key. All other frontmatter keys map 1:1 to the layout's **parameters**.
 
 ```yaml
 ---
@@ -100,13 +100,13 @@ subtitle: This Quarter
 ```
 
 - `layout` is required and consumed by the compiler (not forwarded as content).
-- All other frontmatter keys fill parameters: `title` fills the `title` template parameter, `subtitle` fills the `subtitle` parameter, `hero` fills the `hero` image parameter, etc. A multi-line text shape surfaces as several keys (e.g. `name` + `jobTitle`); fill each as its own scalar line.
+- All other frontmatter keys fill parameters: `title` fills the `title` parameter, `subtitle` fills the `subtitle` parameter, etc. A multi-line text shape surfaces as several keys (e.g. `name` + `jobTitle`); fill each as its own scalar line.
 - Slots (accepting `text`, `table`, `image`) are filled by body regions, not frontmatter -- see below.
 - A slide may also carry a `notes:` block in frontmatter -- plain-text speaker notes for the slide's notes page (see [syntax.md](syntax.md#speaker-notes)). It is slide-level metadata, not a parameter or slot.
 
 ### Body content, slots, and formatting
 
-See [syntax.md](syntax.md) for the full syntax reference: body content (paragraphs, bullets, nesting), inline formatting (bold, italic, strikethrough, underline, hyperlinks), named slots (`::key::` markers), the parameter/slot split (parameters: template, image; slots accept: text, table, image), and image parameters.
+See [syntax.md](syntax.md) for the full syntax reference: body content (paragraphs, bullets, nesting), inline formatting (bold, italic, strikethrough, underline, hyperlinks), named slots (`::key::` markers), and the parameter/slot split (slots accept: text, table, image).
 
 ### Build
 
@@ -143,7 +143,7 @@ Keep each slot's content to what its region comfortably holds. When content over
 - **Don't restyle the layout** -- the theme owns all design; you only fill slots
 - **Don't use an image that's wrong for the slot** -- a small slot wants a simple icon, not a dense illustration. If you get a `shrunk to X%` warning, look at the rendered slide: if the image is now too small to make out, use a simpler one.
 - **Don't invent layout or asset names** -- only use what exists in the manifest
-- **Don't leave required parameters or slots empty** -- and don't leave a placeholder logo or dummy text in an image parameter you care about
+- **Don't leave required parameters or slots empty** -- and don't leave a placeholder logo or dummy text in an image slot you care about
 
 ---
 
@@ -159,7 +159,7 @@ Build the deck again ([Build](#build)) and read the output carefully. Common err
 |-------|-----|
 | `unknown layout "xyz"` | Check layout names in `manifest.json` |
 | A parameter or slot didn't fill | Use the key names the layout declares -- parameters in frontmatter, slots as body regions |
-| An image didn't swap / placeholder remains | Use the image parameter's key name in frontmatter, and an asset path that exists in `manifest.json` |
+| An image didn't swap / placeholder remains | Write a `::key::` region using the image slot's key, containing `![]($category.name)` from `manifest.json` |
 | YAML parse error | Fix the YAML syntax in the slide's frontmatter |
 | `Skipped setting relation target` | The asset image couldn't be placed; check the path and file |
 | `forbidden style directive` | Remove `style`, `classDef`, `linkStyle`, or `%%{init}` from your mermaid block -- use `class` for grouping instead |

package/dist/index.d.ts

@@ -36,4 +36,4 @@ export type { Config, Deck, DeckStep, GenerateOptions, ImageFill, Layout, Slot,
 export { fillImage, fillTable, fillTemplate, fillText, generate, SlotType } from "./engine/index.js";
 export { generateManifest } from "./manifest.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";
+export { AcceptType, compileMarkdownDeck, loadThemeConfig, parseThemeConfig } from "./markdown/index.js";

package/dist/index.js

@@ -1,5 +1,5 @@
 import { generate, SlotType, } from "./engine/index.js";
-import { AcceptType, ParameterType, } from "./markdown/types.js";
+import { AcceptType, } 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`)
@@ -7,24 +7,15 @@ import { AcceptType, ParameterType, } from "./markdown/types.js";
  * placeholder; only body slots with a transplant block carry a real frame.
  */
 const NO_FRAME = { x: 0, y: 0, cx: 0, cy: 0 };
+// 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.
 function paramToEngineSlot(param, baseSlide) {
-    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: [{ type: SlotType.Template, sourceSlide: baseSlide, shapeName: param.shapeName }],
-            };
-        case ParameterType.Image:
-            return {
-                key: param.key,
-                frame: NO_FRAME,
-                accepts: [{ type: SlotType.Image, sourceSlide: baseSlide, shapeName: param.shapeName }],
-            };
-    }
+    return {
+        key: param.shapeName,
+        frame: NO_FRAME,
+        accepts: [{ type: SlotType.Template, sourceSlide: baseSlide, shapeName: param.shapeName }],
+    };
 }
 /**
  * Project a body slot's real `accepts` to engine `Block[]` and pass its `frame`
@@ -129,4 +120,4 @@ export { fillImage, fillTable, fillTemplate, fillText, generate, SlotType } from
 // Authoring
 export { generateManifest } from "./manifest.js";
 // Markdown / Compiler
-export { AcceptType, compileMarkdownDeck, loadThemeConfig, ParameterType, parseThemeConfig } from "./markdown/index.js";
+export { AcceptType, compileMarkdownDeck, loadThemeConfig, parseThemeConfig } from "./markdown/index.js";

package/dist/manifest.js

@@ -1,27 +1,16 @@
 import { templateKeys } from "./markdown/textTemplate.js";
-import { ParameterType } from "./markdown/types.js";
 /**
  * Flatten a compiler parameter to the manifest entries advertised to AI authors.
- * A template parameter has no top-level key — its template's keys are the keys, so it
- * flattens to one entry per key (shapeName/template stay manifest-internal). An
- * image parameter is a single key.
+ * A parameter has no top-level key — its template's placeholders are the keys, so
+ * it flattens to one entry per key (shapeName/template stay manifest-internal).
  */
 function stripParameter(param) {
-    switch (param.type) {
-        case ParameterType.Template:
-            return templateKeys(param.template).map((key) => {
-                const result = { key, type: param.type };
-                if (param.required)
-                    result.required = true;
-                return result;
-            });
-        case ParameterType.Image: {
-            const result = { key: param.key, type: param.type };
-            if (param.required)
-                result.required = true;
-            return [result];
-        }
-    }
+    return templateKeys(param.template).map((key) => {
+        const result = { key };
+        if (param.required)
+            result.required = true;
+        return result;
+    });
 }
 function stripSlot(slot) {
     const result = { key: slot.key, accepts: slot.accepts.map((b) => b.type) };
@@ -53,10 +42,6 @@ export function generateManifest(config) {
             assets[category][name] = manifestEntry;
         }
     }
-    const manifest = {
-        version: 1,
-        layouts,
-        assets,
-    };
+    const manifest = { layouts, assets };
     return JSON.stringify(manifest, null, 2);
 }

package/dist/markdown/deckCompiler.d.ts

@@ -13,12 +13,11 @@ export declare function toImageFill(path: string, type: AssetType): ImageFill;
  * code (Shiki) and rendered mermaid (PNG) — so the returned deck is
  * engine-shaped, ready for `buildDeck`.
  *
- * `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` feed
- * the code and mermaid compiles.
+ * `config.rootDir` is the base directory for resolving the asset catalog's
+ * relative image paths. 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` feed the code and mermaid compiles.
  */
 export declare function compileDeck(doc: ParsedDocument, config: CompilerConfig): Promise<CompilerDeck>;

package/dist/markdown/deckCompiler.js

@@ -3,7 +3,7 @@ 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, ParameterType, RESERVED_KEY, } from "./types.js";
+import { AssetType, RESERVED_KEY, } from "./types.js";
 /** Map each semantic asset type to the engine's object-fit directive. */
 const FIT_FOR = {
     [AssetType.Icon]: ImageFit.ScaleDown,
@@ -37,7 +37,7 @@ function assertSlotRegion(slot, got, layoutName, slideNo, source) {
     }
 }
 /**
- * Resolve a user-supplied image path against the deck's root directory.
+ * Resolve a catalog image path against the deck's root directory.
  * When `rootDir` is empty, the path is returned unchanged so callers that
  * already produce absolute paths (or callers that don't care about
  * resolution) can opt out. Absolute paths always pass through.
@@ -73,12 +73,11 @@ function assertUniqueSlideNumbers(layouts) {
  * be collision-free — otherwise a fill silently clobbers or throws a misleading
  * error:
  *
- * - **Author keys** — what a frontmatter line addresses: every template-parameter key
- *   and every image-parameter key must be distinct, so a line routes to exactly
- *   one parameter.
- * - **Content keys** — what `step.content` is addressed by: every image key, every
- *   template parameter's `shapeName`, and every slot key must be distinct, so no two
- *   overwrite each other in the content map.
+ * - **Author keys** — what a frontmatter line addresses: every parameter's placeholder
+ *   keys must be distinct across the layout, so a line routes to exactly one parameter.
+ * - **Content keys** — what `step.content` is addressed by: every parameter's
+ *   `shapeName` and every slot key must be distinct, so no two overwrite each other in
+ *   the content map.
  *
  * Also rejects a required template parameter whose template has no keys — it declares
  * no way to be filled, so `required` on it is unsatisfiable.
@@ -95,34 +94,25 @@ function validateLayout(layout) {
     const claimContentKey = (key, owner) => {
         if (contentKeys.has(key)) {
             throw new Error(`Layout "${layout.name}": name "${key}" (${owner}) collides with another parameter or slot; ` +
-                "each template parameter's shape, image key, and slot key must be distinct.");
+                "each parameter's shape and each slot key must be distinct.");
         }
         contentKeys.add(key);
     };
     for (const param of layout.parameters) {
-        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;
-            }
+        const keys = templateKeys(param.template);
+        if (param.required && keys.length === 0) {
+            throw new Error(`Layout "${layout.name}": parameter "${param.shapeName}" is marked required but its template has no keys to fill.`);
         }
+        for (const key of keys)
+            claimAuthorKey(key, `parameter "${param.shapeName}"`);
+        claimContentKey(param.shapeName, "parameter");
     }
     for (const slot of layout.slots) {
         claimContentKey(slot.key, "slot");
     }
 }
-async function compileStep(slide, config, assetTypeByPath, resolveAssetRef) {
-    const { layouts, rootDir } = config;
+async function compileStep(slide, config, resolveAssetRef) {
+    const { layouts } = config;
     const { frontmatter, slots, index } = slide;
     // Slide numbers in errors are 1-based, matching how an author counts slides in
     // the deck file. Derive it once: every message below, and the parse-time errors
@@ -148,44 +138,22 @@ async function compileStep(slide, config, assetTypeByPath, resolveAssetRef) {
     // 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, slideNo);
-    // 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
+    // Map each author-facing key to the parameter that declares it. validateLayout
+    // (run once per layout in compileDeck) has already proven these keys are
     // collision-free, so a later lookup is unambiguous.
-    const templateParams = [];
-    const imageByKey = new Map();
     const templateParamByKey = new Map();
     for (const param of layoutDef.parameters) {
-        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;
-        }
+        for (const key of templateKeys(param.template))
+            templateParamByKey.set(key, param);
     }
     const slotsByKey = new Map(layoutDef.slots.map((s) => [s.key, s]));
     const content = {};
-    // Frontmatter lines fill image parameters (by key) or template-parameter keys
-    // (gathered per parameter, expanded together once every line is read).
+    // Frontmatter lines fill template-parameter keys, gathered per parameter and
+    // expanded together once every line is read.
     const valuesByTemplateParam = new Map();
     for (const [key, value] of Object.entries(frontmatter)) {
         if (key === RESERVED_KEY.LAYOUT || key === RESERVED_KEY.NOTES)
             continue;
-        const image = imageByKey.get(key);
-        if (image) {
-            const imgPath = resolveImagePath(rootDir, String(value));
-            const assetType = assetTypeByPath.get(imgPath);
-            if (assetType === undefined) {
-                throw new Error(`Slide image "${image.key}": "${value}" has no asset-catalog entry, so no type. ` +
-                    `Add it to the theme's assets with a type (icon | image | background).`);
-            }
-            content[image.key] = toImageFill(imgPath, assetType);
-            continue;
-        }
         const templateParam = templateParamByKey.get(key);
         if (templateParam) {
             let bucket = valuesByTemplateParam.get(templateParam);
@@ -196,17 +164,17 @@ async function compileStep(slide, config, assetTypeByPath, resolveAssetRef) {
             bucket.set(key, String(value));
         }
         // 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.
+        // not a reserved 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
     // parameter with no supplied keys stays designer-sample unless required. Content
     // is keyed by shapeName: one parameter → one entry, regardless of key count.
-    for (const templateParam of templateParams) {
+    for (const templateParam of layoutDef.parameters) {
         const supplied = valuesByTemplateParam.get(templateParam);
         if (!supplied) {
             if (templateParam.required) {
-                throw new Error(`Slide ${slideNo}: layout "${layoutName}" requires template parameter "${templateParam.shapeName}" ` +
+                throw new Error(`Slide ${slideNo}: layout "${layoutName}" requires parameter "${templateParam.shapeName}" ` +
                     `(keys: ${templateKeys(templateParam.template).join(", ")}); none provided`);
             }
             continue;
@@ -231,17 +199,11 @@ async function compileStep(slide, config, assetTypeByPath, resolveAssetRef) {
             config,
             layoutVariant: layoutDef.variant,
         });
-        assertSlotRegion(slot, parsed.acceptType, layoutName, index, source);
+        assertSlotRegion(slot, parsed.acceptType, layoutName, slideNo, 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
-    // enforced during expansion above.
-    for (const image of imageByKey.values()) {
-        if (image.required && content[image.key] === undefined) {
-            throw new Error(`Slide ${slideNo}: layout "${layoutName}" requires parameter "${image.key}"; none provided`);
-        }
-    }
+    // A required slot with no region throws with layout + key context. Required
+    // parameters are enforced during template expansion above.
     for (const slot of layoutDef.slots) {
         if (slot.required && content[slot.key] === undefined) {
             throw new Error(`Slide ${slideNo}: layout "${layoutName}" requires slot "${slot.key}"; none provided`);
@@ -260,13 +222,12 @@ async function compileStep(slide, config, assetTypeByPath, resolveAssetRef) {
  * code (Shiki) and rendered mermaid (PNG) — so the returned deck is
  * engine-shaped, ready for `buildDeck`.
  *
- * `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` feed
- * the code and mermaid compiles.
+ * `config.rootDir` is the base directory for resolving the asset catalog's
+ * relative image paths. 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` feed the code and mermaid compiles.
  */
 export async function compileDeck(doc, config) {
     const { layouts, rootDir, assets } = config;
@@ -284,18 +245,10 @@ export async function compileDeck(doc, config) {
     assertUniqueSlideNumbers(layouts);
     for (const layout of layouts)
         validateLayout(layout);
-    // Index each catalog asset's resolved path → its declared type, so an image
-    // filled by path inherits the scaling tolerance intrinsic to its pixels.
-    const assetTypeByPath = new Map();
-    for (const group of Object.values(assets)) {
-        for (const entry of Object.values(group)) {
-            assetTypeByPath.set(resolveImagePath(rootDir, entry.path), entry.type);
-        }
-    }
-    // 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.
+    // Resolve a `$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 `toImageFill`, which maps the asset's declared type to
+    // its ImageFit.
     const resolveAssetRef = (ref) => {
         const match = ASSET_REF_RE.exec(ref);
         if (!match) {
@@ -304,9 +257,17 @@ export async function compileDeck(doc, config) {
         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(", ");
+            // Every asset in the catalog is far too many to read (mz-slides has 126).
+            // A known category narrows it to that category's names, which is what the
+            // author is choosing between; an unknown one lists the categories instead.
+            const group = assets[category];
+            const available = group
+                ? Object.keys(group)
+                    .map((n) => `$${category}.${n}`)
+                    .join(", ")
+                : Object.keys(assets)
+                    .map((c) => `$${c}.*`)
+                    .join(", ");
             throw new Error(`Unknown asset reference "${ref}". Available: ${available}`);
         }
         return toImageFill(resolveImagePath(rootDir, entry.path), entry.type);
@@ -315,7 +276,7 @@ export async function compileDeck(doc, config) {
     // 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));
+        steps.push(await compileStep(slide, config, resolveAssetRef));
     }
     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, } from "./types.js";
-export { AcceptType, AssetType, ParameterType, RESERVED_KEY } from "./types.js";
+export type { AssetCatalog, AssetEntry, CompilerBlock, CompilerConfig, CompilerDeck, CompilerDeckStep, CompilerLayout, CompilerParameter, CompilerSlot, CompilerThemeConfig, EngineFill, } from "./types.js";
+export { AcceptType, AssetType, RESERVED_KEY } from "./types.js";

package/dist/markdown/index.js

@@ -11,4 +11,4 @@ export { parseInlineRuns } from "./inline.js";
 export { parseRegion } from "./mdast.js";
 export { loadThemeConfig, parseThemeConfig, ThemeConfigSchema } from "./schema/themeConfigSchema.js";
 export { parseSlideDocument } from "./slideParser.js";
-export { AcceptType, AssetType, ParameterType, RESERVED_KEY } from "./types.js";
+export { AcceptType, AssetType, RESERVED_KEY } from "./types.js";

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

@@ -1,22 +1,17 @@
 import * as z from "zod";
 import type { CompilerLayout } from "../types.js";
 /**
- * Per-layout frontmatter validation for a deck `.md`. The old tycoslide validated
- * every slide's frontmatter against a Zod schema carried by the layout program;
- * current layouts are JSON DATA, so the schema is BUILT dynamically from a layout's
- * declared `parameters` using the same key-derivation the compiler already uses
- * (`deckCompiler.ts`): an image parameter contributes its `key`; a template
- * parameter contributes one field per `{key}` placeholder in its template (NOT its
- * `shapeName`, which addresses `step.content`, not frontmatter).
+ * Per-layout frontmatter validation for a deck `.md`. Layouts are JSON data, so
+ * the schema is built dynamically from a layout's `parameters` using the same
+ * key-derivation the compiler uses (`deckCompiler.ts`): a parameter contributes
+ * one field per `{key}` placeholder in its template, never its `shapeName`,
+ * which addresses `step.content` rather than frontmatter.
  *
- * Commit-1 scope is unknown-key detection ONLY — zero behavior change:
- * - Every field is `z.coerce.string()` (values are `String()`-coerced today, so a
- *   YAML number like `year: 2026` must still pass — plain `z.string()` would regress)
- *   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: a stray frontmatter key throws
- * instead of being silently ignored.
+ * Every field is `z.coerce.string()` so a YAML number like `year: 2026` passes
+ * (values are `String()`-coerced downstream), and `.optional()` because
+ * `required` is per-parameter and enforced in `compileStep`, not "all a
+ * template's keys present". The strict object is the point: 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

@@ -1,37 +1,25 @@
 import * as z from "zod";
 import { templateKeys } from "../textTemplate.js";
-import { ParameterType, RESERVED_KEY } from "../types.js";
+import { RESERVED_KEY } from "../types.js";
 import { strict } from "./strict.js";
 /**
- * Per-layout frontmatter validation for a deck `.md`. The old tycoslide validated
- * every slide's frontmatter against a Zod schema carried by the layout program;
- * current layouts are JSON DATA, so the schema is BUILT dynamically from a layout's
- * declared `parameters` using the same key-derivation the compiler already uses
- * (`deckCompiler.ts`): an image parameter contributes its `key`; a template
- * parameter contributes one field per `{key}` placeholder in its template (NOT its
- * `shapeName`, which addresses `step.content`, not frontmatter).
+ * Per-layout frontmatter validation for a deck `.md`. Layouts are JSON data, so
+ * the schema is built dynamically from a layout's `parameters` using the same
+ * key-derivation the compiler uses (`deckCompiler.ts`): a parameter contributes
+ * one field per `{key}` placeholder in its template, never its `shapeName`,
+ * which addresses `step.content` rather than frontmatter.
  *
- * Commit-1 scope is unknown-key detection ONLY — zero behavior change:
- * - Every field is `z.coerce.string()` (values are `String()`-coerced today, so a
- *   YAML number like `year: 2026` must still pass — plain `z.string()` would regress)
- *   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: a stray frontmatter key throws
- * instead of being silently ignored.
+ * Every field is `z.coerce.string()` so a YAML number like `year: 2026` passes
+ * (values are `String()`-coerced downstream), and `.optional()` because
+ * `required` is per-parameter and enforced in `compileStep`, not "all a
+ * template's keys present". The strict object is the point: a stray frontmatter
+ * key throws instead of being silently ignored.
  */
 export function deckFrontmatterSchema(layout) {
     const shape = {};
     for (const param of layout.parameters) {
-        switch (param.type) {
-            case ParameterType.Image:
-                shape[param.key] = z.coerce.string().optional();
-                break;
-            case ParameterType.Template:
-                for (const key of templateKeys(param.template)) {
-                    shape[key] = z.coerce.string().optional();
-                }
-                break;
+        for (const key of templateKeys(param.template)) {
+            shape[key] = z.coerce.string().optional();
         }
     }
     return strict(shape);

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

@@ -9,17 +9,11 @@ export declare const ThemeConfigSchema: z.ZodObject<{
             light: "light";
             dark: "dark";
         }>>;
-        parameters: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        parameters: z.ZodArray<z.ZodObject<{
             shapeName: z.ZodString;
             required: z.ZodOptional<z.ZodBoolean>;
-            type: z.ZodLiteral<"template">;
             template: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            shapeName: z.ZodString;
-            required: z.ZodOptional<z.ZodBoolean>;
-            key: z.ZodString;
-            type: z.ZodLiteral<"image">;
-        }, z.core.$strict>], "type">>;
+        }, z.core.$strict>>;
         slots: z.ZodArray<z.ZodObject<{
             key: z.ZodString;
             accepts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{

package/dist/markdown/schema/themeConfigSchema.js

@@ -1,7 +1,7 @@
 import { readFileSync } from "node:fs";
 import { basename, dirname } from "node:path";
 import * as z from "zod";
-import { AcceptType, AssetType, ParameterType, Variant, } from "../types.js";
+import { AcceptType, AssetType, Variant } from "../types.js";
 import { strict } from "./strict.js";
 /**
  * Fail-fast runtime validation for a `theme.json`. The hand-written types in
@@ -63,19 +63,11 @@ const ThemeFontSchema = strict({
     path: z.string(),
     weight: z.number().optional(),
 });
-const TemplateParamSchema = strict({
+const ParameterSchema = strict({
     shapeName: z.string(),
     required: z.boolean().optional(),
-    type: z.literal(ParameterType.Template),
     template: z.string(),
 });
-const ImageParamSchema = strict({
-    shapeName: z.string(),
-    required: z.boolean().optional(),
-    key: z.string(),
-    type: z.literal(ParameterType.Image),
-});
-const ParameterSchema = z.discriminatedUnion("type", [TemplateParamSchema, ImageParamSchema]);
 // One arm per accept type, discriminated by `type`, mirroring `CompilerBlock`:
 // `startAt` lives only on the text arm, and `bodyRows` only on the table arm (a
 // table block MUST declare its repeatable-row range; text/image arms have no

package/dist/markdown/types.d.ts

@@ -27,18 +27,6 @@ export type AssetEntry = {
 };
 /** Two-level catalog: `{ category: { name: AssetEntry } }`. */
 export type AssetCatalog = Record<string, Record<string, AssetEntry>>;
-/**
- * Discriminator for a layout's frontmatter *parameters* — inputs the author
- * writes as a single `key: value` line. Two kinds: `Template` (fills a styled
- * shape's runs via fillTemplate) and `Image` (a filesystem path filled via
- * fillImage). Both share their value with the engine's `SlotType`, since a
- * parameter maps straight to an engine slot with no resolution step.
- */
-export declare const ParameterType: {
-    readonly Template: "template";
-    readonly Image: "image";
-};
-export type ParameterType = (typeof ParameterType)[keyof typeof ParameterType];
 /**
  * The engine content types a slot may `accept`. A subset of the engine's
  * `SlotType`: `Template` is parameter-only, never a body block. There is no
@@ -143,14 +131,14 @@ export type CompilerDeck = {
     steps: CompilerDeckStep[];
 };
 /**
- * Template parameter: a styled text shape filled by expanding a `template` into the
+ * Parameter: a styled text shape filled by expanding a `template` into the
  * shape's paragraphs via fillTemplate. The template is one string with `{key}`
  * placeholders and newlines for line breaks (`"{lastname}, {firstname} -
  * {company}"`, or `"{name}\n{jobTitle}"`); a shape's fillable keys are the
  * placeholders in its template. The shape carries no top-level `key`; its
  * placeholders are the keys the author fills in frontmatter.
  */
-export type CompilerTemplateParameter = {
+export type CompilerParameter = {
     shapeName: string;
     /**
      * Whether the parameter may be omitted from a slide. Optional (defaults to
@@ -159,29 +147,9 @@ export type CompilerTemplateParameter = {
      * from the slide.
      */
     required?: boolean;
-    type: typeof ParameterType.Template;
     /** The shape's text as one template with `{key}` placeholders; newlines are line breaks. */
     template: string;
 };
-/** Image parameter: one frontmatter path filled by fillImage. Sizing/crop
- * behaviour comes from the resolved asset's `type`, not the slot. */
-export type CompilerImageParameter = {
-    shapeName: string;
-    /**
-     * Whether the parameter may be omitted from a slide. Optional (defaults to
-     * false): a required one with no value causes the compiler to throw with
-     * layout + key names; an optional one left unfilled has its shape removed
-     * from the slide.
-     */
-    required?: boolean;
-    key: string;
-    type: typeof ParameterType.Image;
-};
-/**
- * Compiler-facing parameter. A layout's frontmatter inputs — each written as a
- * single `key: value` line, resolved against the layout's `parameters` list.
- */
-export type CompilerParameter = CompilerTemplateParameter | CompilerImageParameter;
 /**
  * Reserved keys in a deck's frontmatter — global (theme) and per-slide
  * (layout). Exported so callers (e.g. cli.ts) reference the constants

package/dist/markdown/types.js

@@ -10,18 +10,6 @@ export const AssetType = {
     Image: "image",
     Background: "background",
 };
-// ── ParameterType discriminator (frontmatter, one value) ──────────────────────
-/**
- * Discriminator for a layout's frontmatter *parameters* — inputs the author
- * writes as a single `key: value` line. Two kinds: `Template` (fills a styled
- * shape's runs via fillTemplate) and `Image` (a filesystem path filled via
- * fillImage). Both share their value with the engine's `SlotType`, since a
- * parameter maps straight to an engine slot with no resolution step.
- */
-export const ParameterType = {
-    Template: SlotType.Template,
-    Image: SlotType.Image,
-};
 // ── AcceptType discriminator (what a slot accepts) ────────────────────────────
 /**
  * The engine content types a slot may `accept`. A subset of the engine's

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tycoworks/tycoslide",
-  "version": "0.11.3",
+  "version": "0.12.0",
   "description": "Create editable, on-brand PowerPoint slides from markdown.",
   "type": "module",
   "main": "dist/index.js",
@@ -16,8 +16,8 @@
   ],
   "scripts": {
     "build": "tsc --build",
-    "test": "tsc --build && node --test --experimental-transform-types test/**/*.test.ts",
-    "typecheck": "tsc --noEmit",
+    "test": "tsc --build && tsc -p tsconfig.test.json && node --test --experimental-transform-types test/**/*.test.ts",
+    "typecheck": "tsc --build && tsc -p tsconfig.test.json",
     "lint": "biome check .",
     "lint:fix": "biome check --write .",
     "format": "biome format --write ."

package/syntax.md

@@ -118,11 +118,6 @@ Fill a parameter by putting a value under its key in the slide's frontmatter.
   jobTitle: CEO, Acme Corp
   ```
   The engine substitutes each value into the run that carries its style, so if the designer made the name bold and the job title grey, the filled name stays bold and the filled title stays grey.
-- **`image`** -- a picture placeholder. Set it in frontmatter with the image path (from an asset catalog entry, or an absolute path). How it is scaled and cropped is set by the **asset's `type`** in the catalog (`icon` never enlarges past native and never crops; `image` fits the whole picture without cropping; `background` fills the frame and center-crops).
-  ```yaml
-  hero: assets/diagrams/architecture.png
-  ```
-
 ### Body content shapes
 
 Fill a slot by writing a `::key::` region in the body; the marker maps to the slot with that `key`. A slot's manifest entry lists which content types it `accepts` (`text`, `table`, `image`) -- write content whose shape matches one of them:
@@ -139,7 +134,13 @@ Fill a slot by writing a `::key::` region in the body; the marker maps to the sl
   ````
   The language tag (e.g. `sql`, `python`, `typescript`) is required -- it drives syntax highlighting, using the theme's `codeTheme` (set once in `theme.json`, not per slot). Colors are applied as native text runs in the output, not images.
 - **table** (slots that accept `table`) -- a GFM table. Write it in the slot region between `|`-delimited headers and rows; cells inherit inline formatting (bold, italic, links).
-- **image** (slots that accept `image`) -- a picture. A fenced `mermaid` block renders to a themed PNG and fills it (see below).
+- **image** (slots that accept `image`) -- a picture from the theme's asset catalog, written as `![]($category.name)`:
+  ```markdown
+  ::logo::
+
+  ![]($brand.primaryDarkWordmark)
+  ```
+  The categories and names are listed in `manifest.json`. How the picture is scaled and cropped comes from the **asset's `type`** in the catalog: `icon` never enlarges past native and never crops, `image` fits the whole picture without cropping, `background` fills the frame and center-crops. A fenced `mermaid` block also fills an image slot, rendering to a themed PNG (see below).
 
 ---
 
@@ -200,20 +201,9 @@ The theme owns all styling. These directives are rejected at build time:
 
 ---
 
-## Image parameters
-
-An image is a **parameter** -- one value (a path) on a frontmatter line. Reference it using the parameter key directly:
-
-```yaml
----
-layout: ImageSlide
-title: Architecture Diagram
-hero: assets/diagrams/architecture.png
----
-```
+## Layout declarations
 
 Each parameter or slot in the layout definition may declare:
-- **`type`** (parameters, required) -- `template` or `image`.
 - **`accepts`** (slots, required) -- an array of `text`, `table`, `image`.
 - **`required: true`** -- the slide has no usable default and the build fails if the parameter/slot has no value (e.g. team-member photos, icon-grid icons, the quote logo). If you don't have a suitable image, ask the user for one.
 - **optional (the default)** -- a parameter or slot you leave unfilled is dropped from the slide (its shape is removed), so a layout with numbered slots (e.g. up to six sections, up to four stats) renders only the ones you fill.
@@ -309,6 +299,9 @@ Infrastructure:
 ---
 layout: ImageSlide
 title: Office Map
-hero: assets/images/office-floor-plan.png
 ---
+
+::hero::
+
+![]($images.officeFloorPlan)
 ```