@tycoworks/tycoslide 0.7.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 tycoworks LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,73 @@
+# tycoslide
+
+Generate slides from markdown using your real PowerPoint templates.
+
+> **Early release** — tycoslide is under active development.
+
+## Why tycoslide?
+
+AI can write great slide content, but it can never get things on-brand. No matter what you try, fonts, logos, and colors end up slightly wrong, and you spend hours fixing it by hand.
+
+tycoslide helps AI agents build presentations using your real slide templates, so they're always on-brand. You define a theme with your .pptx files, layouts and design assets, from which agents can quickly build new presentations using markdown.
+
+## Quick Start
+
+```bash
+npm install @tycoworks/tycoslide
+```
+
+Create `deck.md`:
+
+```markdown
+---
+theme: ./theme.json
+---
+
+---
+layout: Title
+title: Quarterly Review
+name: Jane Doe
+jobTitle: Engineering
+---
+
+---
+layout: Body
+title: Highlights
+---
+
+- Revenue up 12% quarter-over-quarter
+- Three major product launches completed
+```
+
+Build:
+
+```bash
+tycoslide build deck.md                   # → deck.pptx
+```
+
+## CLI
+
+```bash
+tycoslide build deck.md       # markdown → PPTX (theme resolved from deck frontmatter)
+tycoslide smoke               # one slide per layout → smoke-all.pptx
+tycoslide plugin              # generate AI agent plugin package
+tycoslide manifest            # print layout + asset catalog to stdout
+```
+
+## Theme Structure
+
+A theme packages a PPTX template, design assets, and a config file into one directory.
+
+```
+my-theme/
+  template/corp-template.pptx
+  assets/logos/
+  assets/icons/
+  theme.json
+  package.json
+```
+
+**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.

package/SKILL.md

@@ -0,0 +1,249 @@
+---
+name: slides
+description: >
+  Use this skill any time the user wants to create branded slides, presentations,
+  pitch decks, or sales collateral as a .pptx. Trigger whenever the user mentions "deck," "slides,"
+  "presentation," "pitch," or .pptx output. Also trigger when the user says "build me a deck,"
+  "make slides about X," or "turn this into a presentation."
+---
+
+# slides
+
+## Setup
+
+Before first use, install dependencies from the plugin root:
+
+```bash
+npm install
+```
+
+This installs the tycoslide engine and its dependencies. You only need to do this once.
+
+## Overview
+
+This skill builds on-brand decks from a markdown deck file. The theme provides slide layouts that control design. Your job: pick the right layouts, fill them with content, and build. You never restyle the layout; the engine clones the real slides, so brand, layout, fonts, and chrome come for free.
+
+For brand voice and naming guidelines, read `brand.md` if it exists alongside this skill.
+
+## Quick Reference
+
+| Task | Guide |
+|------|-------|
+| Discover layouts and assets | Read `manifest.json` |
+| Write a deck (structure, slots, assets) | See [Creating Slides](#creating-slides) below |
+| Fix build errors | See [QA](#qa-required) below |
+
+---
+
+## Layout Discovery
+
+Before writing anything, read `manifest.json`. It contains:
+
+- **layouts** -- for each: `name`, `description`, `parameters` (frontmatter inputs) and `slots` (body regions), each with `type` and optionally `required`, `fit`, `limit`, `codeTheme`, `mermaidVariant`, plus documentation (`whenToUse`, `whenNotToUse`)
+- **assets** -- brand logos, client logos, illustrations, and icons (`description`, `whenToUse`)
+
+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.
+- **slots** -- a multi-line region in the body. Types: `text`, `table`, `code`, `mermaid`. Fill as the default body region (after the closing `---`) or a `::name::` region.
+
+A single physical slide may back multiple layouts. When two manifest entries share the same `slideNumber`, they render into the same underlying PPTX shapes but declare their fill differently -- e.g. one layout exposing the fill as an `image` parameter and a sibling exposing it as a `mermaid` slot. Pick between them by naming the layout you want in frontmatter (`layout: Full bleed diagram` vs `layout: Full bleed image`); the declaration is unambiguous per layout, so the compiler always knows how to interpret the content you provide.
+
+Study each layout's `whenToUse` and `limit`s before writing any slides. These are your primary guide for matching content to layouts.
+
+---
+
+## Creating Slides
+
+Write a deck file in markdown. The file starts with a global frontmatter block declaring the theme, followed by slides separated by `---`.
+
+```markdown
+---
+theme: ./theme.json
+---
+
+---
+layout: Title
+title: Q2 Business Review
+subtitle: Engineering Division
+---
+
+---
+layout: Quote dark
+quote: Great products are built by great teams.
+attributionName: Jane Smith
+attributionTitle: CEO, Acme Corp
+logo: assets/clients/acme.png
+---
+```
+
+A text shape that holds several lines (e.g. an attribution with a name over a title) surfaces as one key per line -- fill each as its own scalar (`attributionName`, `attributionTitle` above), never as a YAML list.
+
+### File structure
+
+A deck file has three parts:
+
+1. **Global frontmatter** (required) -- the first `---`-delimited block. Must contain `theme:` pointing to the theme config file. May also contain `output:` to set the filename (defaults to `deck.md` → `deck.pptx`).
+2. **Slides** -- each begins with a `---` separator. A slide's frontmatter sits between `---` delimiters. Body content follows the closing `---`.
+3. **Slide separators** -- a `---` on its own line separates slides.
+
+### 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).
+
+```yaml
+---
+layout: Body
+title: Key Achievements
+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.
+- Slots (`text`, `table`, `code`, `mermaid`) are filled by body regions, not frontmatter -- see below.
+
+### 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 (`::name::` markers), the parameter/slot split (parameters: template, image; slots: text, table, code, mermaid), and image parameters.
+
+### Build
+
+Run the command from `manifest.json`'s `build.command`:
+
+```bash
+# e.g.: npx tycoslide build deck.md
+```
+
+The deck is written to your current working directory (not inside the skill).
+
+---
+
+## Layout Selection
+
+**Don't create boring decks.** Repeating the same layout on every slide makes a forgettable presentation. Use variety and match content shape to layout purpose.
+
+### Before Starting
+
+1. **Read the manifest thoroughly.** Each layout has `whenToUse`, `whenNotToUse`, and `limit`s. Respect all three.
+2. **Match content shape to layout purpose.** A comparison belongs in a two/three-column layout, quantified proof belongs in stat blocks, a customer voice belongs in a quote or testimonial layout. Don't force content into the wrong layout.
+3. **Plan narrative arc first.** Decide the sequence of ideas before picking layouts. Then assign each idea to its best-fit layout from the manifest. Keep one variant (all dark or all light) across the deck.
+
+### For Each Slide
+
+**Every slide communicates one idea.** If you're writing more than 5 bullets or 3 paragraphs, split into two slides.
+
+Check each layout's `limit` in the manifest for content density constraints. When content overflows, split across slides.
+
+### Avoid (Common Mistakes)
+
+- **Don't repeat the same layout** -- vary layouts for visual rhythm
+- **Don't dump all content on one slide** -- two clear slides beat one crowded slide
+- **Don't ignore layout limits** -- if a slot says max 4 stats, use 4 or fewer
+- **Don't open with a body/content layout** -- use the Title layout for impact
+- **Don't skip section dividers** -- for decks over 5 slides, use Section title layouts to group sections
+- **Don't restyle the layout** -- the theme owns all design; you only fill slots
+- **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 mix dark and light** -- keep one variant across the deck
+
+---
+
+## QA (Required)
+
+**Assume the first build will fail. Your job is to fix it.**
+
+Your first draft almost never comes out clean. Approach QA as a debugging session, not a confirmation step. If you haven't run at least one build-fix cycle, you're not done.
+
+### Build
+
+Run the command from `manifest.json`'s `build.command`:
+
+```bash
+# e.g.: npx tycoslide build deck.md
+```
+
+Read output carefully. Common errors and fixes:
+
+| Error | Fix |
+|-------|-----|
+| `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` |
+| 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 |
+| `mermaid-cli is required` | Install mermaid-cli: `npm i -D @mermaid-js/mermaid-cli` |
+| `no "mermaid" block` | The theme has no mermaid color config -- add a `mermaid` section to theme.json |
+
+### Verification Loop
+
+1. Write the deck file → Build
+2. **Read every error** -- fix all of them
+3. Rebuild
+4. **If content overflows**: reduce content or split into two slides
+5. Repeat until the build exits cleanly
+
+**Do not declare success until you've completed at least one build-fix cycle.**
+
+### Visual Check
+
+After a clean build, render the `.pptx` to PNGs and inspect them:
+
+```bash
+soffice --headless --convert-to pdf --outdir . <deck>.pptx
+pdftoppm -png -r 96 <deck>.pdf <name>
+```
+
+Read each slide image and check for:
+
+- **Word wrapping** -- text that breaks mid-word or overflows its container
+- **Cramped text** -- content too dense for the slide area
+- **Leftover placeholders** -- dummy text ("Lorem ipsum", "Firstname Lastname") or a placeholder logo that should have been swapped
+- **Cut-off content** -- text or images clipped at slide edges
+
+If you spot issues, reduce content, switch layouts, or split into multiple slides. Rebuild and re-check.
+
+### Content Review (Use Subagents)
+
+**Use subagents for review** -- even for short decks. You've been staring at the content and will see what you expect, not what's there. Subagents have fresh eyes.
+
+After a successful build, spawn a subagent:
+
+```
+Review this deck. Assume there are issues -- find them.
+
+Check for:
+- Slides that are too dense (>7 bullets, >5 paragraphs, too many stats/rows)
+- Same layout repeated multiple times with no variety
+- Content that doesn't match layout purpose (check whenToUse in manifest.json)
+- Narrative that doesn't flow logically
+- Missing opening (Title) or closing (Thank you) slide
+- Slides that are too sparse (a single bullet doesn't need its own slide)
+- Leftover placeholder logos or dummy text in the rendered images
+
+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)
+```
+
+If the subagent finds issues, fix them and rebuild.
+
+---
+
+## Full Example
+
+See [syntax.md](syntax.md#full-example) for a complete multi-slide deck example.
+
+---
+
+## Core Commands
+
+```bash
+# Build a deck (use command from manifest.json's build.command)
+# e.g.: npx tycoslide build deck.md
+
+# Render to images for visual QA
+soffice --headless --convert-to pdf --outdir . <deck>.pptx
+pdftoppm -png -r 96 <deck>.pdf <name>
+```

package/bin/tycoslide.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import("../dist/cli.js");

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -0,0 +1,197 @@
+import { copyFileSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Command } from "commander";
+import { FitMode, generate, SlotType } from "./engine/index.js";
+import { buildDeck, toEngineConfig } from "./index.js";
+import { generateManifest } from "./manifest.js";
+import { toImageFill } from "./markdown/deckCompiler.js";
+import { CompilerSlotType, compileDeck, ParameterType, parseSlideDocument, RESERVED_KEY, } from "./markdown/index.js";
+import { templateKeys, templateToSegments } from "./markdown/textTemplate.js";
+// ── Smoke content fixtures (used by the `smoke` subcommand) ──────────────────
+const line = (text) => ({ runs: [{ text }] });
+const bulletLine = (text, level = 0) => ({ runs: [{ text }], bullet: { level } });
+const SMOKE_TABLE = {
+    headers: ["Feature", "Starter", "Pro", "Business", "Enterprise"].map(line),
+    rows: [
+        ["Users", "5", "25", "100", "Unlimited"].map(line),
+        ["Storage", "1 GB", "10 GB", "100 GB", "1 TB"].map(line),
+        ["Support", "Email", "Priority", "24/7", "Dedicated"].map(line),
+    ],
+};
+const SMOKE_CODE = [
+    { runs: [{ text: "SELECT name, total", color: "FF7B72" }] },
+    { runs: [{ text: "FROM orders", color: "FF7B72" }] },
+    { runs: [{ text: "WHERE created_at > now();", color: "FF7B72" }] },
+];
+const SMOKE_PROSE = [
+    line("Sample intro line for this block."),
+    bulletLine("First point"),
+    bulletLine("Second point"),
+];
+function pickFirstAsset(config) {
+    for (const group of Object.values(config.assets)) {
+        for (const entry of Object.values(group))
+            return entry.path;
+    }
+    return undefined;
+}
+function smokeSteps(config) {
+    const firstAsset = pickFirstAsset(config);
+    const absAsset = firstAsset ? resolve(config.rootDir, firstAsset) : undefined;
+    return config.layouts.map((layout) => {
+        const content = {};
+        // Parameters (frontmatter): text → a placeholder-filled template, image → the first asset.
+        for (const p of layout.parameters) {
+            switch (p.type) {
+                case ParameterType.Image: {
+                    if (!absAsset)
+                        continue;
+                    content[p.key] = toImageFill(p, absAsset);
+                    break;
+                }
+                case ParameterType.Template: {
+                    // Text shapes carry no key — the engine slot is keyed by shapeName.
+                    const values = new Map(templateKeys(p.template).map((k) => [k, "Sample"]));
+                    content[p.shapeName] = { lines: templateToSegments(p.template, values, p.shapeName) };
+                    break;
+                }
+            }
+        }
+        // Slots (body regions): text → prose, table → table, code → code, mermaid → image.
+        for (const s of layout.slots) {
+            switch (s.type) {
+                case CompilerSlotType.Table:
+                    content[s.key] = SMOKE_TABLE;
+                    break;
+                case CompilerSlotType.Code:
+                    content[s.key] = { paragraphs: SMOKE_CODE };
+                    break;
+                case CompilerSlotType.Mermaid: {
+                    // Mermaid slots don't declare fit; smoke fills them with a fixed
+                    // contained ImageFill so the projected engine slot (Image, contain)
+                    // stays consistent with the real renderer's output.
+                    if (!absAsset)
+                        continue;
+                    content[s.key] = { type: SlotType.Image, path: absAsset, fit: FitMode.Contain };
+                    break;
+                }
+                case CompilerSlotType.Text:
+                    content[s.key] = { paragraphs: SMOKE_PROSE };
+                    break;
+            }
+        }
+        return { layout: layout.name, content };
+    });
+}
+const DEFAULT_CONFIG = "theme.json";
+const DEFAULT_SMOKE_OUTPUT = "smoke-all.pptx";
+const SKILL_DIR = "skills/slides";
+const PLUGIN_DIR = ".claude-plugin";
+const PLUGIN_FILE = "plugin.json";
+const MANIFEST_FILE = "manifest.json";
+const SKILL_FILE = "SKILL.md";
+const SYNTAX_FILE = "syntax.md";
+const BUILD_COMMAND = "npx tycoslide build";
+const sdkDir = dirname(fileURLToPath(import.meta.url));
+const skillMdPath = resolve(sdkDir, "..", SKILL_FILE);
+const syntaxMdPath = resolve(sdkDir, "..", SYNTAX_FILE);
+function loadConfig(absPath) {
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(absPath, "utf-8"));
+    }
+    catch {
+        throw new Error(`Config file not found or invalid JSON: ${absPath}`);
+    }
+    return { ...raw, rootDir: dirname(absPath) };
+}
+const pkg = JSON.parse(readFileSync(resolve(sdkDir, "..", "package.json"), "utf-8"));
+const program = new Command().name("tycoslide").description("PPTX template engine CLI").version(pkg.version);
+program
+    .command("build")
+    .description("Build a PPTX deck from a Markdown spec")
+    .argument("<deck>", "path to deck markdown file")
+    .option(`-c, --config <path>`, "override theme config path (default: read from frontmatter)")
+    .action(async (deckPath, opts) => {
+    const absDeckPath = resolve(process.cwd(), deckPath);
+    let source;
+    try {
+        source = readFileSync(absDeckPath, "utf-8");
+    }
+    catch {
+        throw new Error(`Deck file not found: ${deckPath}`);
+    }
+    const doc = parseSlideDocument(source);
+    const themePath = doc.global.theme;
+    const absConfigPath = opts.config
+        ? resolve(process.cwd(), opts.config)
+        : themePath
+            ? resolve(dirname(absDeckPath), String(themePath))
+            : undefined;
+    if (!absConfigPath) {
+        throw new Error(`${basename(deckPath)}: missing required "${RESERVED_KEY.THEME}" in global frontmatter`);
+    }
+    const config = loadConfig(absConfigPath);
+    const deck = compileDeck(doc, config.layouts, config.rootDir);
+    if (!deck.output)
+        deck.output = basename(deckPath).replace(/\.md$/, ".pptx");
+    await buildDeck(deck, config);
+});
+program
+    .command("manifest")
+    .description("Generate manifest.json from theme config")
+    .option(`-c, --config <path>`, "path to theme config file", DEFAULT_CONFIG)
+    .option(`-o, --out <file>`, "write to file instead of stdout")
+    .action(async (opts) => {
+    const config = loadConfig(resolve(process.cwd(), opts.config));
+    const json = generateManifest(config, { build: { command: BUILD_COMMAND } });
+    if (opts.out) {
+        writeFileSync(resolve(process.cwd(), opts.out), `${json}\n`);
+        console.log(`WROTE ${opts.out}`);
+    }
+    else {
+        process.stdout.write(`${json}\n`);
+    }
+});
+program
+    .command("smoke")
+    .description("Generate one smoke-test slide per layout")
+    .option(`-c, --config <path>`, "path to theme config file", DEFAULT_CONFIG)
+    .option(`-o, --out <file>`, "output PPTX filename", DEFAULT_SMOKE_OUTPUT)
+    .action(async (opts) => {
+    const config = loadConfig(resolve(process.cwd(), opts.config));
+    const steps = smokeSteps(config);
+    await generate({ theme: opts.config, output: opts.out, steps }, toEngineConfig(config));
+});
+program
+    .command("plugin")
+    .description("Generate plugin package (plugin.json, manifest.json, SKILL.md, syntax.md) for AI agents")
+    .option(`-c, --config <path>`, "path to theme config file", DEFAULT_CONFIG)
+    .action(async (opts) => {
+    const config = loadConfig(resolve(process.cwd(), opts.config));
+    const cwd = process.cwd();
+    const pkg = JSON.parse(readFileSync(resolve(cwd, "package.json"), "utf-8"));
+    const pluginMeta = {
+        name: pkg.name,
+        version: pkg.version,
+        description: pkg.description ?? "",
+        skills: "./skills",
+    };
+    if (pkg.author)
+        pluginMeta.author = pkg.author;
+    const pluginDir = resolve(cwd, PLUGIN_DIR);
+    mkdirSync(pluginDir, { recursive: true });
+    writeFileSync(resolve(pluginDir, PLUGIN_FILE), `${JSON.stringify(pluginMeta, null, 2)}\n`);
+    console.log(`WROTE ${PLUGIN_DIR}/${PLUGIN_FILE}`);
+    const skillDir = resolve(cwd, SKILL_DIR);
+    mkdirSync(skillDir, { recursive: true });
+    const json = generateManifest(config, { build: { command: BUILD_COMMAND } });
+    writeFileSync(resolve(skillDir, MANIFEST_FILE), `${json}\n`);
+    console.log(`WROTE ${SKILL_DIR}/${MANIFEST_FILE}`);
+    copyFileSync(skillMdPath, resolve(skillDir, SKILL_FILE));
+    console.log(`WROTE ${SKILL_DIR}/${SKILL_FILE}`);
+    copyFileSync(syntaxMdPath, resolve(skillDir, SYNTAX_FILE));
+    console.log(`WROTE ${SKILL_DIR}/${SYNTAX_FILE}`);
+});
+await program.parseAsync(process.argv);

package/dist/engine/dom.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Shared shape / DOM helpers used by every fill primitive.
+ *
+ * Two layers live here. First the low-level slide-XML substrate: `Tag` names the
+ * DrawingML / PresentationML elements, plus node utilities (element collection,
+ * run text access, run and paragraph builders) and hyperlink relationship
+ * management. Second, the higher-level StyledParagraph-rebuild machinery shared
+ * by fillText and fillTable: harvest specimen (pPr, rPr) buckets grouped by
+ * (bullet kind, level), detach the specimens, then build fresh paragraphs
+ * cloning the appropriate bucket. No fill strategy lives here — this is the
+ * substrate the fill modules build on.
+ */
+import type { StyledParagraph, TextRun } from "./types.js";
+/** DrawingML and PresentationML tag names used when manipulating slide XML. */
+export declare const Tag: {
+    readonly RUN: "a:r";
+    readonly TEXT: "a:t";
+    readonly PARAGRAPH: "a:p";
+    readonly RUN_PROPS: "a:rPr";
+    readonly PARA_PROPS: "a:pPr";
+    readonly BULLET_CHAR: "a:buChar";
+    readonly BULLET_AUTO: "a:buAutoNum";
+    readonly BULLET_NONE: "a:buNone";
+    readonly LINE_BREAK: "a:br";
+    readonly END_PARA_RUN_PROPS: "a:endParaRPr";
+    readonly OFFSET: "a:off";
+    readonly EXTENT: "a:ext";
+    readonly BLIP: "a:blip";
+    readonly SRC_RECT: "a:srcRect";
+    readonly BLIP_FILL: "p:blipFill";
+    readonly SPACE_BEFORE: "a:spcBef";
+    readonly HLINK_CLICK: "a:hlinkClick";
+    readonly RELATIONSHIP: "Relationship";
+    readonly TABLE: "a:tbl";
+    readonly TABLE_ROW: "a:tr";
+    readonly TABLE_CELL: "a:tc";
+    readonly TX_BODY: "a:txBody";
+    readonly SOLID_FILL: "a:solidFill";
+    readonly SRGB_CLR: "a:srgbClr";
+};
+/**
+ * OOXML attribute names and fixed attribute values. Element names live in `Tag`;
+ * this is the same discipline for the attributes and enumerated values written
+ * onto them, so no bare string literal leaks into the fill code.
+ */
+export declare const Attr: {
+    readonly BOLD: "b";
+    readonly ITALIC: "i";
+    readonly STRIKE: "strike";
+    readonly UNDERLINE: "u";
+    readonly ON: "1";
+    readonly STRIKE_SINGLE: "sngStrike";
+    readonly UNDERLINE_SINGLE: "sng";
+    readonly VALUE: "val";
+    readonly ID: "Id";
+    readonly TYPE: "Type";
+    readonly TARGET: "Target";
+    readonly TARGET_MODE: "TargetMode";
+    readonly EXTERNAL: "External";
+    readonly HLINK_ID: "r:id";
+    readonly LEVEL: "lvl";
+    readonly X: "x";
+    readonly Y: "y";
+    readonly CX: "cx";
+    readonly CY: "cy";
+    readonly LEFT: "l";
+    readonly TOP: "t";
+    readonly RIGHT: "r";
+    readonly BOTTOM: "b";
+    readonly XML_SPACE: "xml:space";
+    readonly PRESERVE: "preserve";
+};
+/** True for a non-null, non-array object — the shared prefix of every `isXFill`. */
+export declare function isPlainObject(v: unknown): v is Record<string, unknown>;
+export declare function collectElements(parent: any, tagName: string): any[];
+export declare function childrenByTag(parent: any, tagName: string): any[];
+export declare function detach(node: any): void;
+export declare function runText(run: any): string;
+export declare function setRunTextPreservingStyle(run: any, text: string): void;
+export declare function leadingDecorativePrefix(text: string): string;
+export declare function buildRun(doc: any, cloneRPr: any | null, text: string): any;
+export declare function buildParagraph(doc: any, clonePPr: any | null, run: any): any;
+export declare const HYPERLINK_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
+export declare function addRelationship(relation: any, url: string): string;
+/**
+ * Replace all runs in a paragraph with a sequence of styled runs, cloning the
+ * first existing run's rPr as the template and layering per-run marks on top.
+ *
+ * Exported for tests; not part of the public engine surface (index.ts).
+ */
+export declare function setRichRuns(para: any, runs: TextRun[], relation?: any): void;
+export declare function rebuildParagraphs(shape: any, paragraphs: StyledParagraph[], startIndex: number, relation?: any, shapeName?: string): void;