figmatk 0.0.6

package/.claude-plugin/marketplace.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
+  "name": "figmatk",
+  "description": "FigmaTK — Inspect and modify Figma Slides .deck files",
+  "metadata": {
+    "description": "FigmaTK — Inspect and modify Figma Slides .deck files natively"
+  },
+  "owner": {
+    "name": "FigmaTK Contributors",
+    "email": "shove-tank-malt@duck.com"
+  },
+  "plugins": [
+    {
+      "name": "figmatk",
+      "description": "Inspect and modify Figma Slides .deck files natively",
+      "version": "0.0.5",
+      "author": {
+        "name": "FigmaTK Contributors"
+      },
+      "source": "./",
+      "category": "development"
+    }
+  ]
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,11 @@
+{
+  "name": "figmatk",
+  "version": "0.0.3",
+  "description": "Inspect and modify Figma Slides .deck files natively — no lossy .pptx conversion",
+  "author": {
+    "name": "FigmaTK Contributors"
+  },
+  "repository": "https://github.com/rcoenen/figmatk",
+  "license": "MIT",
+  "keywords": ["figma", "deck", "slides", "presentation"]
+}

package/.mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "figmatk": {
+      "command": "node",
+      "args": ["${CLAUDE_PLUGIN_ROOT}/mcp-server.mjs"]
+    }
+  }
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 FigmaTK Contributors
+
+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,308 @@
+# FigmaTK — Figma Toolkit (v0.0.6)
+
+Swiss-army knife CLI for Figma `.deck` and `.fig` files. Parse, inspect, modify, and rebuild Figma Slides decks programmatically — no Figma API required.
+
+## Figma File Formats
+
+Each Figma product has its own native file format:
+
+| Product | Extension |
+|---------|-----------|
+| Figma Design | `.fig` |
+| Figma Slides | `.deck` |
+| Figma Jam (whiteboard) | `.jam` |
+| Figma Buzz | `.buzz` |
+| Figma Sites | `.site` |
+| Figma Make | `.make` |
+
+The `.deck` format borrows heavily from `.fig` — a `.deck` is essentially a ZIP containing a `.fig`-encoded canvas plus metadata and images. FigmaTK focuses on `.deck` files. We'll evaluate expanding to other formats as we go.
+
+## Why native `.deck`?
+
+Figma Slides lets you download presentations as `.deck` files — and re-upload them. This is the **native** round-trip format. The alternative, exporting to `.pptx`, is lossy: vectors get rasterized to bitmaps, fonts fall back to system defaults, and precise layout breaks. By staying in `.deck`, you preserve everything — fonts, vector shapes, component overrides, styles — exactly as Figma renders them.
+
+**FigmaTK** makes this round-trip programmable. Download a `.deck`, modify it with these utilities, re-upload to Figma. Everything stays native.
+
+Plug in [Claude Code](https://claude.ai/code), [Codex](https://openai.com/index/openai-codex/), or any coding agent and you have an AI that can read and edit Figma presentations end-to-end — without ever opening the Figma UI.
+
+## Use Cases
+
+- **AI agent for presentations** — let an LLM read slide content, rewrite copy, insert images, and produce a ready-to-upload `.deck` without ever touching the Figma UI
+- **Batch-produce branded decks** — start from a company template, feed in data per client/project, get pixel-perfect slides out
+- **Inspect and audit** — understand the internal structure of any `.deck` or `.fig` file
+- **Automate** text and image placement across dozens of slides in seconds
+- **Validate** your pipeline with lossless roundtrip encode/decode
+
+## Install
+
+```bash
+npm install -g figmatk
+```
+
+No build step. Pure ESM (`.mjs`). Node 18+.
+
+## Quick Start
+
+```bash
+# See what's inside a deck
+figmatk inspect my-presentation.deck
+
+# List every text field and image in every slide
+figmatk list-text my-presentation.deck
+
+# Discover all override keys (what you can edit)
+figmatk list-overrides my-presentation.deck
+```
+
+## Commands
+
+### `inspect` — Document structure
+
+```bash
+figmatk inspect file.deck [--depth N] [--type TYPE] [--json]
+```
+
+Prints the full node hierarchy tree:
+
+```
+Nodes: 1314  Slides: 10 active / 10 total  Blobs: 465
+
+DOCUMENT "Document" (0:0)
+  CANVAS "Page 1" (0:1)
+    SLIDE_GRID "Presentation" (0:3)
+      SLIDE_ROW "Row" (1:1563)
+        SLIDE "1" (1:1559)
+          INSTANCE "Cover" (1:1564) sym=1:1322 overrides=3
+        SLIDE "2" (1:1570)
+          INSTANCE "Content" (1:1572) sym=1:1129 overrides=7
+```
+
+Filter by node type (`--type SLIDE`, `--type INSTANCE`, `--type SYMBOL`) or limit depth. Use `--json` for machine-readable output.
+
+### `list-text` — All content
+
+```bash
+figmatk list-text file.deck
+```
+
+Shows every text string and image hash in the deck — both direct node text and symbol override text. Useful for auditing content or extracting copy.
+
+```
+SLIDE "1" → INSTANCE (1:2001) sym=1:1322
+  57:48  TEXT: "My Presentation Title"
+  57:49  TEXT: "Subtitle Goes Here"
+  75:126  IMAGE: 780960f6236bd1305ceeb2590ca395e36e705816 (1011x621)
+```
+
+### `list-overrides` — Editable fields
+
+```bash
+figmatk list-overrides file.deck [--symbol "Symbol Name"]
+```
+
+For every symbol (component) in the file, lists each node that has an `overrideKey` — these are the fields you can modify via `symbolOverrides`. Shows the key ID, node type, name, and current default value.
+
+```
+SYMBOL "Image+Text" (1:1205)
+  75:126  ROUNDED_RECTANGLE "Photo location" [IMAGE PLACEHOLDER]
+  75:127  TEXT "Header" → "Header"
+  75:131  TEXT "Subtitle" → "SUBTITLE 2"
+  75:132  TEXT "Body" → "Body small lorem ipsum..."
+```
+
+### `update-text` — Change text
+
+```bash
+figmatk update-text input.deck -o output.deck \
+  --slide 1:2000 \
+  --set "57:48=New Title" \
+  --set "57:49=New Subtitle"
+```
+
+Finds the slide (by node ID or name), locates its instance, and adds or updates text overrides. Repeat `--set` for multiple fields. Empty strings are auto-replaced with a space (empty string crashes Figma).
+
+### `insert-image` — Place images
+
+```bash
+figmatk insert-image input.deck -o output.deck \
+  --slide 1:2006 \
+  --key 75:126 \
+  --image screenshot.png \
+  [--thumb thumbnail.png]
+```
+
+Overrides an image placeholder on a slide instance. Automatically:
+- SHA-1 hashes the image and copies it to the `images/` directory
+- Generates a ~320px thumbnail (or uses `--thumb` if provided)
+- Sets the required `styleIdForFill` sentinel GUID
+- Sets `imageThumbnail` with the thumbnail hash
+
+### `clone-slide` — Duplicate with content
+
+```bash
+figmatk clone-slide input.deck -o output.deck \
+  --template 1:1559 \
+  --name "New Slide" \
+  --set "57:48=Title" \
+  --set "57:49=Subtitle" \
+  --set-image "75:126=photo.png"
+```
+
+Deep-clones a slide + instance pair from a template, assigns fresh GUIDs, applies text and image overrides, and appends to the deck. Uses `Uint8Array`-safe cloning (not `JSON.parse/stringify`).
+
+### `remove-slide` — Delete slides
+
+```bash
+figmatk remove-slide input.deck -o output.deck \
+  --slide 1:1769 \
+  --slide 1:1732
+```
+
+Marks slides and their child instances as `REMOVED`. Repeat `--slide` for multiple. Nodes are never deleted from the array — Figma requires them to remain with `phase: 'REMOVED'`.
+
+### `roundtrip` — Validate the pipeline
+
+```bash
+figmatk roundtrip input.deck -o output.deck
+```
+
+Decodes and re-encodes with zero changes. If Figma opens the output, your pipeline is sound. Prints node/slide/blob counts.
+
+## Claude Cowork / Claude Code Integration
+
+FigmaTK ships as a **Cowork plugin** with an MCP server. This lets Claude manipulate `.deck` files directly as tool calls.
+
+### Install as plugin
+
+```bash
+claude plugin marketplace add rcoenen/figmatk
+claude plugin install figmatk
+```
+
+### Or add as MCP server manually
+
+In Claude Desktop → Settings → Developer → Edit Config:
+
+```json
+{
+  "mcpServers": {
+    "figmatk": {
+      "command": "figmatk-mcp"
+    }
+  }
+}
+```
+
+### Available MCP tools
+
+| Tool | Description |
+|------|-------------|
+| `figmatk_inspect` | Show node hierarchy tree |
+| `figmatk_list_text` | List all text and image content per slide |
+| `figmatk_list_overrides` | List editable override keys per symbol |
+| `figmatk_update_text` | Apply text overrides to a slide instance |
+| `figmatk_insert_image` | Apply image fill override |
+| `figmatk_clone_slide` | Duplicate a slide |
+| `figmatk_remove_slide` | Mark a slide as REMOVED |
+| `figmatk_roundtrip` | Decode and re-encode for validation |
+
+## Using as a Library
+
+```javascript
+import { FigDeck } from 'figmatk/deck';
+import { ov, nestedOv, removeNode } from 'figmatk/node-helpers';
+import { imageOv } from 'figmatk/image-helpers';
+import { deepClone } from 'figmatk/deep-clone';
+
+// Load
+const deck = await FigDeck.fromDeckFile('template.deck');
+
+// Explore
+console.log(deck.getActiveSlides().length, 'slides');
+console.log(deck.getSymbols().map(s => s.name));
+
+// Walk the tree
+deck.walkTree('0:0', (node, depth) => {
+  console.log('  '.repeat(depth) + node.type + ' ' + (node.name || ''));
+});
+
+// Find a slide's instance and read its overrides
+const slide = deck.getActiveSlides()[0];
+const inst = deck.getSlideInstance('1:2000');
+console.log(inst.symbolData.symbolOverrides);
+
+// Save
+await deck.saveDeck('output.deck');
+```
+
+### Key classes and functions
+
+| Module | Export | Description |
+|--------|--------|-------------|
+| `lib/fig-deck.mjs` | `FigDeck` | Core class — parse, query, encode, save |
+| `lib/node-helpers.mjs` | `nid(node)` | Format node ID as `"sessionID:localID"` |
+| | `parseId(str)` | Parse `"57:48"` to `{ sessionID, localID }` |
+| | `ov(key, text)` | Build a text override for `symbolOverrides` |
+| | `nestedOv(instKey, textKey, text)` | Text override for nested instances |
+| | `removeNode(node)` | Mark node as REMOVED |
+| `lib/image-helpers.mjs` | `imageOv(key, hash, thumbHash, w, h)` | Build a complete image fill override |
+| | `hexToHash(hex)` / `hashToHex(arr)` | Convert between hex strings and `Uint8Array(20)` |
+| `lib/deep-clone.mjs` | `deepClone(obj)` | `Uint8Array`-safe deep clone |
+
+### FigDeck API
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `FigDeck.fromDeckFile(path)` | `Promise<FigDeck>` | Load from `.deck` ZIP |
+| `FigDeck.fromFigFile(path)` | `FigDeck` | Load from raw `.fig` |
+| `deck.getSlides()` | `node[]` | All SLIDE nodes |
+| `deck.getActiveSlides()` | `node[]` | Non-REMOVED slides |
+| `deck.getInstances()` | `node[]` | All INSTANCE nodes |
+| `deck.getSymbols()` | `node[]` | All SYMBOL nodes |
+| `deck.getNode(id)` | `node` | Lookup by `"s:l"` string |
+| `deck.getChildren(id)` | `node[]` | Child nodes |
+| `deck.getSlideInstance(slideId)` | `node` | INSTANCE child of a SLIDE |
+| `deck.walkTree(rootId, fn)` | void | DFS traversal |
+| `deck.maxLocalID()` | `number` | Highest ID in use |
+| `deck.rebuildMaps()` | void | Re-index after mutations |
+| `deck.encodeFig()` | `Promise<Uint8Array>` | Encode to `canvas.fig` binary |
+| `deck.saveDeck(path, opts?)` | `Promise<number>` | Write complete `.deck` ZIP |
+| `deck.saveFig(path)` | `Promise<void>` | Write raw `.fig` binary |
+
+## `.deck` File Format
+
+See **[docs/deck-format.md](docs/deck-format.md)** for the full binary format specification — archive structure, chunk layout, node types, symbol overrides, image override requirements, cloning rules, and all known format constraints.
+
+## Architecture
+
+```
+figmatk/
+  cli.mjs                    # CLI entry point — arg parsing + subcommand dispatch
+  mcp-server.mjs             # MCP server for Claude Cowork / Claude Code
+  lib/
+    fig-deck.mjs             # FigDeck class — own binary parser, no third-party deps
+    deep-clone.mjs           # Uint8Array-safe recursive deep clone
+    node-helpers.mjs         # Node ID utils, override builders, removal helper
+    image-helpers.mjs        # SHA-1 hash conversion, image override builder
+  commands/
+    inspect.mjs              # Tree view of document structure
+    list-text.mjs            # All text + image content per slide
+    list-overrides.mjs       # Editable override keys per symbol
+    update-text.mjs          # Set text overrides on a slide
+    insert-image.mjs         # Image fill override with auto-thumbnail
+    clone-slide.mjs          # Duplicate a slide with content
+    remove-slide.mjs         # Mark slides REMOVED
+    roundtrip.mjs            # Decode/re-encode validation
+  skills/
+    figmatk/SKILL.md         # Cowork skill definition
+  .claude-plugin/
+    plugin.json              # Cowork plugin manifest
+    marketplace.json         # Plugin marketplace listing
+  .mcp.json                  # MCP server config
+```
+
+Six npm packages: `kiwi-schema`, `fzstd`, `zstd-codec`, `pako`, `archiver`, `@modelcontextprotocol/sdk`.
+
+## License
+
+MIT

package/cli.mjs

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+/**
+ * FigmaTK — Swiss-army knife for Figma .deck / .fig files.
+ *
+ * Usage: figmatk <command> [args...]
+ *
+ * Commands:
+ *   inspect        Show document structure (node hierarchy tree)
+ *   list-text      List all text content in the deck
+ *   list-overrides List all editable override keys per symbol
+ *   update-text    Apply text overrides to a slide instance
+ *   insert-image   Apply an image fill override to a slide instance
+ *   clone-slide    Duplicate a template slide with new content
+ *   remove-slide   Mark slides as REMOVED
+ *   roundtrip      Decode and re-encode (pipeline validation)
+ */
+
+const COMMANDS = {
+  'inspect':        './commands/inspect.mjs',
+  'list-text':      './commands/list-text.mjs',
+  'list-overrides': './commands/list-overrides.mjs',
+  'update-text':    './commands/update-text.mjs',
+  'insert-image':   './commands/insert-image.mjs',
+  'clone-slide':    './commands/clone-slide.mjs',
+  'remove-slide':   './commands/remove-slide.mjs',
+  'roundtrip':      './commands/roundtrip.mjs',
+};
+
+const command = process.argv[2];
+
+if (!command || command === '--help' || command === '-h') {
+  console.log(`FigmaTK — Swiss-army knife for Figma .deck / .fig files\n`);
+  console.log('Commands:');
+  console.log('  inspect        Show document structure (node hierarchy tree)');
+  console.log('  list-text      List all text content in the deck');
+  console.log('  list-overrides List editable override keys per symbol');
+  console.log('  update-text    Apply text overrides to a slide instance');
+  console.log('  insert-image   Apply image fill override to a slide instance');
+  console.log('  clone-slide    Duplicate a template slide with new content');
+  console.log('  remove-slide   Mark slides as REMOVED');
+  console.log('  roundtrip      Decode and re-encode (pipeline validation)');
+  console.log('\nUsage: figmatk <command> [args...]');
+  process.exit(0);
+}
+
+if (!COMMANDS[command]) {
+  console.error(`Unknown command: ${command}\nRun with --help for available commands.`);
+  process.exit(1);
+}
+
+// Parse args: positional args + flags (--flag value, --flag=value)
+const rawArgs = process.argv.slice(3);
+const positional = [];
+const flags = {};
+
+for (let i = 0; i < rawArgs.length; i++) {
+  const arg = rawArgs[i];
+  if (arg.startsWith('--')) {
+    const eqIdx = arg.indexOf('=');
+    let key, value;
+    if (eqIdx >= 0) {
+      key = arg.substring(2, eqIdx);
+      value = arg.substring(eqIdx + 1);
+    } else {
+      key = arg.substring(2);
+      // Peek ahead for value (unless next arg is also a flag)
+      if (i + 1 < rawArgs.length && !rawArgs[i + 1].startsWith('--')) {
+        value = rawArgs[++i];
+      } else {
+        value = true;
+      }
+    }
+    // Support repeating flags (e.g. --set k=v --set k2=v2)
+    if (flags[key] !== undefined) {
+      if (!Array.isArray(flags[key])) flags[key] = [flags[key]];
+      flags[key].push(value);
+    } else {
+      flags[key] = value;
+    }
+  } else if (arg.startsWith('-') && arg.length === 2) {
+    // Short flag like -o
+    const key = arg.substring(1);
+    if (i + 1 < rawArgs.length && !rawArgs[i + 1].startsWith('-')) {
+      flags[key] = rawArgs[++i];
+    } else {
+      flags[key] = true;
+    }
+  } else {
+    positional.push(arg);
+  }
+}
+
+// Run command
+const mod = await import(COMMANDS[command]);
+try {
+  await mod.run(positional, flags);
+} catch (err) {
+  console.error(`Error: ${err.message}`);
+  if (process.env.DEBUG) console.error(err.stack);
+  process.exit(1);
+}

package/commands/clone-slide.mjs

@@ -0,0 +1,153 @@
+/**
+ * clone-slide — Duplicate a template slide with new content.
+ *
+ * Usage: node cli.mjs clone-slide <file.deck> -o <output.deck>
+ *        --template <slideId|name> --name <newName>
+ *        [--after <slideId>] [--set key=value ...] [--set-image key=path ...]
+ */
+import { FigDeck } from '../lib/fig-deck.mjs';
+import { nid, parseId, positionChar } from '../lib/node-helpers.mjs';
+import { imageOv } from '../lib/image-helpers.mjs';
+import { deepClone } from '../lib/deep-clone.mjs';
+import { readFileSync, copyFileSync, existsSync, mkdirSync } from 'fs';
+import { createHash } from 'crypto';
+import { join, resolve } from 'path';
+import { getImageDimensions, generateThumbnail } from '../lib/image-utils.mjs';
+
+function sha1Hex(buf) {
+  return createHash('sha1').update(buf).digest('hex');
+}
+
+export async function run(args, flags) {
+  const file = args[0];
+  const outPath = flags.o || flags.output;
+  const templateRef = flags.template;
+  const newName = flags.name || 'New Slide';
+  const sets = Array.isArray(flags.set) ? flags.set : (flags.set ? [flags.set] : []);
+  const setImages = Array.isArray(flags['set-image']) ? flags['set-image'] : (flags['set-image'] ? [flags['set-image']] : []);
+
+  if (!file || !outPath || !templateRef) {
+    console.error('Usage: clone-slide <file.deck> -o <out.deck> --template <id|name> --name <name> [--set key=val ...] [--set-image key=path ...]');
+    process.exit(1);
+  }
+
+  const deck = await FigDeck.fromDeckFile(file);
+
+  // Find template slide
+  const tmplSlide = findSlide(deck, templateRef);
+  if (!tmplSlide) { console.error(`Template slide not found: ${templateRef}`); process.exit(1); }
+
+  const tmplInst = deck.getSlideInstance(nid(tmplSlide));
+  if (!tmplInst) { console.error(`No instance on template slide`); process.exit(1); }
+
+  // Find SLIDE_ROW parent
+  const slideRowId = tmplSlide.parentIndex?.guid
+    ? `${tmplSlide.parentIndex.guid.sessionID}:${tmplSlide.parentIndex.guid.localID}`
+    : null;
+
+  // Generate new IDs
+  let nextId = deck.maxLocalID() + 1;
+  const slideId = nextId++;
+  const instId = nextId++;
+
+  // Clone slide node
+  const newSlide = deepClone(tmplSlide);
+  newSlide.guid = { sessionID: 1, localID: slideId };
+  newSlide.name = newName;
+  newSlide.phase = 'CREATED';
+  if (slideRowId) {
+    const activeCount = deck.getActiveSlides().length;
+    newSlide.parentIndex = {
+      guid: parseId(slideRowId),
+      position: positionChar(activeCount),
+    };
+  }
+  delete newSlide.prototypeInteractions;
+  delete newSlide.slideThumbnailHash;
+  delete newSlide.editInfo;
+
+  // Clone instance
+  const newInst = deepClone(tmplInst);
+  newInst.guid = { sessionID: 1, localID: instId };
+  newInst.name = newName;
+  newInst.phase = 'CREATED';
+  newInst.parentIndex = { guid: { sessionID: 1, localID: slideId }, position: '!' };
+  newInst.symbolData = {
+    symbolID: deepClone(tmplInst.symbolData?.symbolID),
+    symbolOverrides: [],
+    uniformScaleFactor: 1,
+  };
+  delete newInst.derivedSymbolData;
+  delete newInst.derivedSymbolDataLayoutVersion;
+  delete newInst.editInfo;
+
+  // Apply text overrides
+  for (const pair of sets) {
+    const eqIdx = pair.indexOf('=');
+    if (eqIdx < 0) continue;
+    const key = parseId(pair.substring(0, eqIdx));
+    let value = pair.substring(eqIdx + 1);
+    if (value === '') value = ' ';
+    newInst.symbolData.symbolOverrides.push({
+      guidPath: { guids: [key] },
+      textData: { characters: value },
+    });
+  }
+
+  // Apply image overrides
+  for (const pair of setImages) {
+    const eqIdx = pair.indexOf('=');
+    if (eqIdx < 0) continue;
+    const key = parseId(pair.substring(0, eqIdx));
+    const imgPath = resolve(pair.substring(eqIdx + 1));
+
+    const imgBuf = readFileSync(imgPath);
+    const imgHash = sha1Hex(imgBuf);
+    const { width: w, height: h } = await getImageDimensions(imgPath);
+
+    const tmpThumb = `/tmp/figmatk_thumb_${Date.now()}.png`;
+    await generateThumbnail(imgPath, tmpThumb);
+    const thumbHash = sha1Hex(readFileSync(tmpThumb));
+
+    copyToImages(deck, imgHash, imgPath);
+    copyToImages(deck, thumbHash, tmpThumb);
+
+    newInst.symbolData.symbolOverrides.push(
+      imageOv(key, imgHash, thumbHash, w, h)
+    );
+  }
+
+  // Set slide position
+  const activeSlides = deck.getActiveSlides();
+  if (newSlide.transform) {
+    newSlide.transform.m02 = activeSlides.length * 2160;
+  }
+
+  // Push to nodeChanges
+  deck.message.nodeChanges.push(newSlide);
+  deck.message.nodeChanges.push(newInst);
+  deck.rebuildMaps();
+
+  console.log(`Cloned slide "${tmplSlide.name}" → "${newName}" (1:${slideId} + 1:${instId})`);
+  console.log(`  ${sets.length} text override(s), ${setImages.length} image override(s)`);
+
+  const bytes = await deck.saveDeck(outPath);
+  console.log(`Saved: ${outPath} (${bytes} bytes)`);
+}
+
+function copyToImages(deck, hash, srcPath) {
+  if (!deck.imagesDir) {
+    deck.imagesDir = `/tmp/figmatk_images_${Date.now()}`;
+    mkdirSync(deck.imagesDir, { recursive: true });
+  }
+  const dest = join(deck.imagesDir, hash);
+  if (!existsSync(dest)) {
+    copyFileSync(srcPath, dest);
+  }
+}
+
+function findSlide(deck, ref) {
+  const byId = deck.getNode(ref);
+  if (byId?.type === 'SLIDE') return byId;
+  return deck.getSlides().find(s => s.name === ref);
+}