@tycoworks/tycoslide 0.11.4 → 0.13.0

package/README.md

@@ -54,7 +54,7 @@ npx tycoslide build deck.md               # → deck.pptx
 ```bash
 npx tycoslide build deck.md       # markdown → PPTX (theme resolved from deck frontmatter)
 npx tycoslide build deck.md --no-notes   # omit speaker notes from the output
-npx tycoslide package             # regenerate skill.md/syntax.md/manifest.json + zip the theme into a self-contained <package-name>.zip
+npx tycoslide package             # regenerate the skill files + zip the theme into a self-contained <package-name>.zip
 ```
 
 ## Theme Structure
@@ -70,14 +70,16 @@ my-theme/
   package.json
   skill.md          # generated by `tycoslide package`
   syntax.md         # generated by `tycoslide package`
-  manifest.json     # generated by `tycoslide package`
+  manifest.json     # generated by `tycoslide package` -- the theme's layouts
+  assets.json       # generated by `tycoslide package` -- the theme's picture catalog
   <package-name>.zip  # uploadable Agent Skill bundle
 ```
 
 **Template** — the PPTX file with named shapes that tycoslide fills.
 **Layout** — a slide pattern in the template (Title, Body, Quote, etc.).
 **Theme** — the directory that bundles a template, assets, and config.
-**Manifest** — a machine-readable catalog of layouts and assets for AI agents.
+**Manifest** — the machine-readable list of layouts, for an AI agent to read.
+**Catalog** — the machine-readable list of assets, for an AI agent to search.
 
 ## Diagrams
 

package/SKILL.md

@@ -26,7 +26,8 @@ This skill builds on-brand decks from a markdown deck file. The theme provides s
 
 | Task | Guide |
 |------|-------|
-| Discover layouts and assets | Read `manifest.json` |
+| Discover layouts | Read `manifest.json` |
+| Find a logo, illustration or icon | Search `assets.json` |
 | Write a deck (structure, slots, assets) | See [Creating Slides](#creating-slides) below |
 | Fix build errors | See [QA](#qa-required) below |
 
@@ -34,13 +35,12 @@ This skill builds on-brand decks from a markdown deck file. The theme provides s
 
 ## Layout Discovery
 
-Before writing anything, read `manifest.json`. It contains:
+Before writing anything, read `manifest.json`. It lists the theme's **layouts** -- for each: `name`, `description`, `parameters` (frontmatter inputs) and `slots` (body regions). A layout is identified by its `name`; every parameter and slot by its `key`. Parameters carry a `type`, slots carry `accepts`, and either may be `required`.
 
-- **layouts** -- for each: `name`, `description`, `parameters` (frontmatter inputs) and `slots` (body regions). A layout is identified by its `name`; every parameter and slot by its `key`. Parameters carry a `type`, slots carry `accepts`, and either may be `required`
-- **assets** -- brand logos, client logos, illustrations, and icons (`description`)
+Pictures live in `assets.json`: every logo, illustration and icon the theme offers, keyed by category and name. **Search it, do not read it whole** -- an icon set alone can run to thousands of entries. Grep for the concept you want (`grep -i "arrow" assets.json`) and use the `$category.name` you find.
 
 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
 
@@ -142,8 +142,8 @@ Keep each slot's content to what its region comfortably holds. When content over
 - **Don't overstuff a slot** -- keep content to what its region comfortably holds; split across slides when there's too much
 - **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 invent layout or asset names** -- only use layouts from `manifest.json` and assets from `assets.json`
+- **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 `assets.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 |
@@ -211,7 +211,7 @@ Check for:
 For each issue, suggest a specific fix.
 
 Read: /path/to/deck.md and the rendered PNGs in the working directory
-Also read: manifest.json (for layout documentation)
+Also read: manifest.json (for layout documentation); search assets.json for pictures
 ```
 
 If the subagent finds issues, fix them and rebuild.

package/dist/cli.js

@@ -3,9 +3,9 @@ import { basename, dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
 import { buildDeck } from "./index.js";
-import { generateManifest } from "./manifest.js";
+import { ASSETS_FILE, generateAssetCatalog, generateManifest } from "./manifest.js";
 import { compileDeck, loadThemeConfig, parseSlideDocument, RESERVED_KEY } from "./markdown/index.js";
-import { renameSkill, zipDir } from "./skillZip.js";
+import { renameSkill, skillPackageJson, zipDir } from "./skillZip.js";
 const DEFAULT_CONFIG = "theme.json";
 const MANIFEST_FILE = "manifest.json";
 // The theme skill is written as lowercase skill.md (copied from tycoslide's own
@@ -60,11 +60,12 @@ program
     if (!themePkg.name) {
         throw new Error('Cannot name the skill: the theme\'s package.json has no "name" field.');
     }
-    // basename drops any npm scope, e.g. "@acme/mz-slides" -> "mz-slides".
+    // basename drops any npm scope, e.g. "@acme/acme-slides" -> "acme-slides".
     const skillName = basename(themePkg.name);
-    const manifestJson = `${generateManifest(config)}\n`;
-    writeFileSync(resolve(process.cwd(), MANIFEST_FILE), manifestJson);
+    writeFileSync(resolve(process.cwd(), MANIFEST_FILE), `${generateManifest(config)}\n`);
     console.log(`WROTE ${MANIFEST_FILE}`);
+    writeFileSync(resolve(process.cwd(), ASSETS_FILE), `${generateAssetCatalog(config)}\n`);
+    console.log(`WROTE ${ASSETS_FILE}`);
     let skillMd;
     try {
         skillMd = renameSkill(readFileSync(skillMdPath, "utf-8"), skillName);
@@ -80,8 +81,9 @@ program
     // Bundle the WHOLE theme so the skill is self-contained: unzip ->
     // `npm install` (pulls the engine + its deps) -> `npx tycoslide build`.
     const zipFile = `${skillName}.zip`;
-    const generated = [opts.config, MANIFEST_FILE, SKILL_FILE, SYNTAX_FILE];
-    writeFileSync(resolve(process.cwd(), zipFile), await zipDir(process.cwd(), skillName, config, generated));
+    const generated = [opts.config, MANIFEST_FILE, ASSETS_FILE, SKILL_FILE, SYNTAX_FILE];
+    const skillPkg = skillPackageJson(themePkg, { name: pkg.name, version: pkg.version });
+    writeFileSync(resolve(process.cwd(), zipFile), await zipDir(process.cwd(), skillName, config, generated, skillPkg));
     console.log(`WROTE ${zipFile}`);
 });
 // Everything below the CLI throws plain Errors carrying a written-for-humans

package/dist/index.d.ts

@@ -34,6 +34,6 @@ export declare function toEngineConfig(config: CompilerConfig): Config;
 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 { generateManifest } from "./manifest.js";
+export { ASSETS_FILE, generateAssetCatalog, 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`
@@ -127,6 +118,6 @@ 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";
+export { ASSETS_FILE, generateAssetCatalog, 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.d.ts

@@ -1,2 +1,7 @@
 import type { CompilerConfig } from "./markdown/types.js";
+/** Filename of the searchable asset catalog, named by the manifest that points at it. */
+export declare const ASSETS_FILE = "assets.json";
+/** The layouts document: read whole, so it carries no open-ended list. */
 export declare function generateManifest(config: CompilerConfig): string;
+/** The catalog document: searched by name, never read whole. */
+export declare function generateAssetCatalog(config: CompilerConfig): string;

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) };
@@ -29,6 +18,9 @@ function stripSlot(slot) {
         result.required = true;
     return result;
 }
+/** Filename of the searchable asset catalog, named by the manifest that points at it. */
+export const ASSETS_FILE = "assets.json";
+/** The layouts document: read whole, so it carries no open-ended list. */
 export function generateManifest(config) {
     const layouts = config.layouts.map((layout) => {
         const ml = {
@@ -41,22 +33,17 @@ export function generateManifest(config) {
             ml.description = layout.description;
         return ml;
     });
+    const manifest = { layouts, assets: ASSETS_FILE };
+    return JSON.stringify(manifest, null, 2);
+}
+/** The catalog document: searched by name, never read whole. */
+export function generateAssetCatalog(config) {
     const assets = {};
     for (const [category, entries] of Object.entries(config.assets)) {
         assets[category] = {};
         for (const [name, entry] of Object.entries(entries)) {
-            const manifestEntry = {
-                path: entry.path,
-                type: entry.type,
-                description: entry.description,
-            };
-            assets[category][name] = manifestEntry;
+            assets[category][name] = { path: entry.path, type: entry.type, description: entry.description };
         }
     }
-    const manifest = {
-        version: 1,
-        layouts,
-        assets,
-    };
-    return JSON.stringify(manifest, null, 2);
+    return JSON.stringify(assets, 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,18 @@ 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: a theme's icon set
+            // alone can run to thousands.
+            // 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 +277,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<{
@@ -49,8 +43,8 @@ export declare const ThemeConfigSchema: z.ZodObject<{
     assets: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
         path: z.ZodString;
         type: z.ZodEnum<{
-            icon: "icon";
             image: "image";
+            icon: "icon";
             background: "background";
         }>;
         description: z.ZodString;

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/dist/skillZip.d.ts

@@ -6,11 +6,30 @@ import type { CompilerThemeConfig } from "./markdown/types.js";
  * Throws if there is no frontmatter or no `name:` line — the caller names the file.
  */
 export declare function renameSkill(md: string, name: string): string;
+/**
+ * The `package.json` a packaged skill installs from — deliberately NOT the theme's
+ * own. A theme repo's manifest is a development document: it carries the script
+ * that regenerates the skill, and lists the engine as a devDependency because the
+ * repo builds with it rather than shipping it.
+ *
+ * Copying that verbatim breaks the consumer twice. The build script runs as a
+ * postinstall inside their container, so anything it touches that is read-only
+ * fails their whole `npm install`. And under `--omit=dev` the engine is never
+ * installed, so neither the postinstall nor `npx tycoslide build` can find it.
+ *
+ * What ships instead declares only what the skill needs to RUN: the theme's own
+ * dependencies plus the engine, as runtime dependencies, and no scripts at all.
+ */
+export declare function skillPackageJson(theme: Record<string, unknown>, engine: {
+    name: string;
+    version: string;
+}): string;
 /**
  * Zip a theme into an uploadable Agent Skill archive whose entries all live
- * under a single root folder (e.g. `mz-slides/theme.json`), matching Anthropic's
+ * under a single root folder (e.g. `acme-slides/theme.json`), matching Anthropic's
  * custom-skill format. `generated` names the files the caller just wrote (the
- * config, manifest, skill.md, syntax.md). Optional support files are skipped
- * when absent; anything the config declares but that is missing is an error.
+ * config, manifest, skill.md, syntax.md); `packageJson` is the authored manifest
+ * from `skillPackageJson`. Optional support files are skipped when absent;
+ * anything the config declares but that is missing is an error.
  */
-export declare function zipDir(rootDir: string, folderName: string, config: CompilerThemeConfig, generated: string[]): Promise<Buffer>;
+export declare function zipDir(rootDir: string, folderName: string, config: CompilerThemeConfig, generated: string[], packageJson: string): Promise<Buffer>;

package/dist/skillZip.js

@@ -18,13 +18,42 @@ export function renameSkill(md, name) {
         throw new Error('skill.md frontmatter has no "name:" line');
     return md.replace(block[0], block[0].replace(NAME_LINE, `name: ${name}`));
 }
+/** The manifest a packaged skill installs from, authored rather than copied. */
+const PACKAGE_JSON = "package.json";
 /**
- * Files a packaged skill needs beyond the theme's own declarations. `package.json`
- * matters most: the unzip flow is `npm install` -> `npx tycoslide build`, so it
- * restores the engine and any npm-resolved brand fonts. The lockfile is taken
- * when present so that install is reproducible.
+ * Files a packaged skill needs beyond the theme's own declarations. Only the
+ * lockfile: `package.json` is authored by `skillPackageJson` rather than taken
+ * from the theme directory.
  */
-const SUPPORT_FILES = ["package.json", "package-lock.json"];
+const SUPPORT_FILES = ["package-lock.json"];
+/**
+ * The `package.json` a packaged skill installs from — deliberately NOT the theme's
+ * own. A theme repo's manifest is a development document: it carries the script
+ * that regenerates the skill, and lists the engine as a devDependency because the
+ * repo builds with it rather than shipping it.
+ *
+ * Copying that verbatim breaks the consumer twice. The build script runs as a
+ * postinstall inside their container, so anything it touches that is read-only
+ * fails their whole `npm install`. And under `--omit=dev` the engine is never
+ * installed, so neither the postinstall nor `npx tycoslide build` can find it.
+ *
+ * What ships instead declares only what the skill needs to RUN: the theme's own
+ * dependencies plus the engine, as runtime dependencies, and no scripts at all.
+ */
+export function skillPackageJson(theme, engine) {
+    const dependencies = {
+        ...(theme.dependencies ?? {}),
+        [engine.name]: `^${engine.version}`,
+    };
+    const skill = {
+        name: theme.name,
+        version: theme.version,
+        description: theme.description,
+        private: true,
+        dependencies: Object.fromEntries(Object.entries(dependencies).sort(([a], [b]) => a.localeCompare(b))),
+    };
+    return `${JSON.stringify(skill, null, 2)}\n`;
+}
 /**
  * Every path a packaged theme needs, relative to `rootDir` and POSIX-separated.
  *
@@ -40,18 +69,20 @@ function skillPaths(config, generated) {
 }
 /**
  * Zip a theme into an uploadable Agent Skill archive whose entries all live
- * under a single root folder (e.g. `mz-slides/theme.json`), matching Anthropic's
+ * under a single root folder (e.g. `acme-slides/theme.json`), matching Anthropic's
  * custom-skill format. `generated` names the files the caller just wrote (the
- * config, manifest, skill.md, syntax.md). Optional support files are skipped
- * when absent; anything the config declares but that is missing is an error.
+ * config, manifest, skill.md, syntax.md); `packageJson` is the authored manifest
+ * from `skillPackageJson`. Optional support files are skipped when absent;
+ * anything the config declares but that is missing is an error.
  */
-export async function zipDir(rootDir, folderName, config, generated) {
+export async function zipDir(rootDir, folderName, config, generated, packageJson) {
     const zip = new JSZip();
     const folder = zip.folder(folderName);
     if (!folder)
         throw new Error(`Failed to create zip folder: ${folderName}`);
+    folder.file(PACKAGE_JSON, packageJson);
     const optional = new Set(SUPPORT_FILES);
-    let count = 0;
+    let count = 1;
     for (const rel of skillPaths(config, generated)) {
         const abs = join(rootDir, ...rel.split("/"));
         if (!existsSync(abs)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tycoworks/tycoslide",
-  "version": "0.11.4",
+  "version": "0.13.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 catalogued in `assets.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)
 ```