promptslide 0.2.2 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "promptslide",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "CLI and slide engine for PromptSlide presentations",
   "type": "module",
   "main": "./dist/index.js",

package/src/commands/add.mjs

@@ -1,4 +1,4 @@
-import { existsSync, writeFileSync, mkdirSync } from "node:fs"
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs"
 import { execFileSync } from "node:child_process"
 import { join, dirname, resolve, sep } from "node:path"
 
@@ -85,8 +85,17 @@ export async function add(args) {
       const newHash = hashContent(file.content)
 
       if (existsSync(targetPath)) {
-        const existingHash = hashFile(targetPath)
-        if (existingHash === newHash) {
+        // For binary files (data URIs), compare decoded bytes directly
+        const dataUriMatch = file.content.match(/^data:[^;]+;base64,/)
+        let identical
+        if (dataUriMatch) {
+          const newBuf = Buffer.from(file.content.slice(dataUriMatch[0].length), "base64")
+          const existingBuf = readFileSync(targetPath)
+          identical = newBuf.equals(existingBuf)
+        } else {
+          identical = hashFile(targetPath) === newHash
+        }
+        if (identical) {
           console.log(`  ${dim("Skipped")} ${relativePath} ${dim("(identical)")}`)
           fileHashes[relativePath] = newHash
           continue
@@ -99,7 +108,12 @@ export async function add(args) {
       }
 
       mkdirSync(targetDir, { recursive: true })
-      writeFileSync(targetPath, file.content, "utf-8")
+      const dataUriPrefix = file.content.match(/^data:[^;]+;base64,/)
+      if (dataUriPrefix) {
+        writeFileSync(targetPath, Buffer.from(file.content.slice(dataUriPrefix[0].length), "base64"))
+      } else {
+        writeFileSync(targetPath, file.content, "utf-8")
+      }
       fileHashes[relativePath] = newHash
       written.push({ item: regItem, file })
       console.log(`  ${green("✓")} Added ${cyan(relativePath)}${regItem !== item ? dim(" (dependency)") : ""}`)

package/src/commands/create.mjs

@@ -1,11 +1,14 @@
 import { execSync } from "node:child_process"
-import { existsSync, cpSync, readFileSync, writeFileSync } from "node:fs"
+import { existsSync, cpSync, readFileSync, writeFileSync, mkdirSync } from "node:fs"
 import { join, resolve, dirname } from "node:path"
 import { fileURLToPath } from "node:url"
 
 import { bold, green, cyan, red, dim } from "../utils/ansi.mjs"
+import { requireAuth } from "../utils/auth.mjs"
 import { hexToOklch, isValidHex } from "../utils/colors.mjs"
 import { prompt, confirm, closePrompts } from "../utils/prompts.mjs"
+import { fetchRegistryItem, resolveRegistryDependencies } from "../utils/registry.mjs"
+import { toPascalCase, replaceDeckConfig } from "../utils/deck-config.mjs"
 import { ensureTsConfig } from "../utils/tsconfig.mjs"
 
 const __filename = fileURLToPath(import.meta.url)
@@ -58,7 +61,9 @@ export async function create(args) {
 
   // Parse flags
   const useDefaults = args.includes("--yes") || args.includes("-y")
-  const filteredArgs = args.filter(a => a !== "--yes" && a !== "-y")
+  const fromIdx = args.findIndex(a => a === "--from")
+  const fromSlug = fromIdx >= 0 ? args[fromIdx + 1] : null
+  const filteredArgs = args.filter((a, i) => a !== "--yes" && a !== "-y" && a !== "--from" && !(fromIdx >= 0 && i === fromIdx + 1))
 
   // 1. Parse directory name from args or prompt
   let dirName = filteredArgs[0]
@@ -69,11 +74,13 @@ export async function create(args) {
     console.log(`  Scaffolds a new PromptSlide slide deck project.`)
     console.log()
     console.log(`  ${bold("Options:")}`)
-    console.log(`    -y, --yes    Skip prompts and use defaults`)
+    console.log(`    -y, --yes              Skip prompts and use defaults`)
+    console.log(`    --from <deck-slug>     Start from a published deck`)
     console.log()
-    console.log(`  ${bold("Example:")}`)
+    console.log(`  ${bold("Examples:")}`)
     console.log(`    promptslide create my-pitch-deck`)
     console.log(`    promptslide create my-pitch-deck --yes`)
+    console.log(`    promptslide create my-deck --from promptic-pitch-deck`)
     console.log()
     process.exit(0)
   }
@@ -109,9 +116,9 @@ export async function create(args) {
   const defaultName = titleCase(dirName)
   const projectName = useDefaults ? defaultName : await prompt("Project name:", defaultName)
 
-  // 3. Ask for primary brand color (optional)
+  // 3. Ask for primary brand color (optional, skipped when using --from since deck provides its own)
   let primaryHex = "#3B82F6"
-  if (!useDefaults) {
+  if (!useDefaults && !fromSlug) {
     primaryHex = await prompt("Primary brand color (hex):", "#3B82F6")
     if (!isValidHex(primaryHex)) {
       console.log(`  ${dim("Invalid hex color, using default #3B82F6")}`)
@@ -161,7 +168,87 @@ export async function create(args) {
     replaceInFile(path, values)
   }
 
-  // 6. If running from local dev, rewrite deps to use file: paths
+  // 6. Overlay deck files if --from was specified
+  if (fromSlug) {
+    const auth = requireAuth()
+
+    let item
+    try {
+      item = await fetchRegistryItem(fromSlug, auth)
+    } catch (err) {
+      console.error(`  ${red("Error:")} ${err.message}`)
+      closePrompts()
+      process.exit(1)
+    }
+
+    if (item.type !== "deck") {
+      console.error(`  ${red("Error:")} "${fromSlug}" is a ${item.type}, not a deck. Use --from with a published deck.`)
+      closePrompts()
+      process.exit(1)
+    }
+
+    const versionTag = item.version ? ` ${dim(`v${item.version}`)}` : ""
+    console.log(`  Using deck ${bold(item.title || item.name)}${versionTag}`)
+
+    let resolved
+    try {
+      resolved = await resolveRegistryDependencies(item, auth, targetDir)
+    } catch (err) {
+      console.error(`  ${red("Error:")} ${err.message}`)
+      closePrompts()
+      process.exit(1)
+    }
+
+    // Write all deck files (no conflict prompts — fresh project)
+    for (const regItem of resolved.items) {
+      if (!regItem.files?.length) continue
+      for (const file of regItem.files) {
+        const targetPath = join(targetDir, file.target, file.path)
+        const targetFileDir = dirname(targetPath)
+        mkdirSync(targetFileDir, { recursive: true })
+
+        const dataUriPrefix = file.content.match(/^data:[^;]+;base64,/)
+        if (dataUriPrefix) {
+          writeFileSync(targetPath, Buffer.from(file.content.slice(dataUriPrefix[0].length), "base64"))
+        } else {
+          writeFileSync(targetPath, file.content, "utf-8")
+        }
+        console.log(`  ${green("✓")} Added ${cyan(file.target + file.path)}`)
+      }
+    }
+
+    // Reconstruct deck-config.ts from deckConfig metadata
+    if (item.meta?.slides) {
+      const slides = item.meta.slides.map(s => ({
+        componentName: toPascalCase(s.slug),
+        importPath: `@/slides/${s.slug}`,
+        steps: s.steps,
+        section: s.section
+      }))
+      replaceDeckConfig(targetDir, slides, {
+        transition: item.meta.transition,
+        directionalTransition: item.meta.directionalTransition
+      })
+      console.log(`  ${green("✓")} Generated ${cyan("deck-config.ts")} ${dim(`(${slides.length} slides)`)}`)
+    }
+
+    // Add npm dependencies from the deck to package.json
+    if (Object.keys(resolved.npmDeps).length > 0) {
+      const pkgList = Object.entries(resolved.npmDeps).map(([name, ver]) => `${name}@${ver}`)
+      const pkgPath = join(targetDir, "package.json")
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"))
+      for (const [name, ver] of Object.entries(resolved.npmDeps)) {
+        pkg.dependencies = pkg.dependencies || {}
+        pkg.dependencies[name] = ver
+      }
+      writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8")
+      console.log(`  ${green("✓")} Added ${dim(pkgList.join(", "))} to package.json`)
+    }
+
+    console.log()
+  }
+
+  // 7. If running from local dev, rewrite deps to use file: paths (must run after --from to not overwrite)
   const localPaths = getLocalPackagePaths()
   if (localPaths) {
     const pkgPath = join(targetDir, "package.json")
@@ -171,10 +258,10 @@ export async function create(args) {
     console.log(`  ${dim("Local dev detected — using file: paths for packages")}`)
   }
 
-  // 7. Generate tsconfig.json for editor support
+  // 8. Generate tsconfig.json for editor support
   ensureTsConfig(targetDir)
 
-  // 8. Install PromptSlide agent skill (defaults to yes; skipped with --yes since skills CLI is interactive)
+  // 9. Install PromptSlide agent skill (defaults to yes; skipped with --yes since skills CLI is interactive)
   if (useDefaults) {
     console.log(`  ${dim("Tip: Run")} npx skills add prompticeu/promptslide ${dim("to install the agent skill")}`)
   } else {
@@ -196,7 +283,7 @@ export async function create(args) {
     }
   }
 
-  // 9. Success output
+  // 10. Success output
   console.log()
   console.log(`  ${green("✓")} Created ${bold(projectName)} in ${cyan(dirName)}/`)
   console.log()

package/src/commands/publish.mjs

@@ -4,8 +4,33 @@ import { join, basename, relative, extname } from "node:path"
 import { bold, green, cyan, red, dim } from "../utils/ansi.mjs"
 import { requireAuth } from "../utils/auth.mjs"
 import { captureSlideAsDataUri, isPlaywrightAvailable } from "../utils/export.mjs"
-import { publishToRegistry, registryItemExists, updateLockfileItem, hashContent, detectPackageManager } from "../utils/registry.mjs"
+import { publishToRegistry, registryItemExists, searchRegistry, updateLockfileItem, readLockfile, hashContent, detectPackageManager, requestUploadTokens, uploadBinaryToBlob, assetFileToSlug, detectAssetDepsInContent } from "../utils/registry.mjs"
 import { prompt, confirm, closePrompts } from "../utils/prompts.mjs"
+import { parseDeckConfig } from "../utils/deck-config.mjs"
+
+function readDeckPrefix(cwd) {
+  try {
+    const pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf-8"))
+    return (pkg.name || "").toLowerCase()
+  } catch {
+    return ""
+  }
+}
+
+async function promptDeckPrefix(cwd, interactive) {
+  const defaultPrefix = readDeckPrefix(cwd)
+  if (!interactive) {
+    if (!defaultPrefix) throw new Error("Deck prefix is required. Set a name in package.json or publish interactively.")
+    return defaultPrefix
+  }
+  let prefix
+  while (true) {
+    prefix = await prompt("Deck prefix:", defaultPrefix)
+    if (prefix && /^[a-z0-9][a-z0-9-]*[a-z0-9]$/.test(prefix)) break
+    console.log(`  ${red("Error:")} Deck prefix is required (lowercase alphanumeric with hyphens, min 2 chars)`)
+  }
+  return prefix
+}
 
 function titleCase(slug) {
   return slug
@@ -69,6 +94,171 @@ function readPreviewImage(imagePath) {
   return `data:${mime};base64,${buf.toString("base64")}`
 }
 
+const BINARY_EXTS = new Set([".png", ".jpg", ".jpeg", ".webp", ".gif", ".ico", ".woff", ".woff2"])
+const MAX_INLINE_SIZE = 512_000  // 512KB for inline text content
+const MAX_DECK_FILES = 50        // registry limit
+
+const MIME_MAP = {
+  ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg",
+  ".webp": "image/webp", ".gif": "image/gif", ".ico": "image/x-icon",
+  ".woff": "font/woff", ".woff2": "font/woff2"
+}
+
+/**
+ * Read a file for registry publishing.
+ * Returns { binary: true, buffer, contentType, size } for binary files,
+ * or { binary: false, content } for text files.
+ */
+function readFileForRegistry(fullPath) {
+  const ext = extname(fullPath).toLowerCase()
+  if (BINARY_EXTS.has(ext)) {
+    const buffer = readFileSync(fullPath)
+    const contentType = MIME_MAP[ext] || "application/octet-stream"
+    return { binary: true, buffer, contentType, size: buffer.length }
+  }
+  return { binary: false, content: readFileSync(fullPath, "utf-8") }
+}
+
+/**
+ * Collect all files for deck publishing.
+ * Returns files with structured format: text files have { path, target, content },
+ * binary files have { path, target, binary: true, buffer, contentType, size }.
+ */
+function collectDeckFiles(cwd) {
+  const files = []
+  const warnings = []
+
+  function addDir(dirPath, target, filter) {
+    if (!existsSync(dirPath)) return
+    for (const entry of readdirSync(dirPath)) {
+      if (entry === ".gitkeep") continue
+      const fullPath = join(dirPath, entry)
+      const stat = statSync(fullPath)
+      if (stat.isDirectory()) {
+        addDir(fullPath, `${target}${entry}/`, filter)
+        continue
+      }
+      if (!stat.isFile()) continue
+      if (filter && !filter(entry)) continue
+      const fileData = readFileForRegistry(fullPath)
+      if (fileData.binary) {
+        files.push({ path: entry, target, binary: true, buffer: fileData.buffer, contentType: fileData.contentType, size: fileData.size })
+      } else {
+        if (fileData.content.length > MAX_INLINE_SIZE) {
+          warnings.push(`${target}${entry}: exceeds 512KB inline limit (${(fileData.content.length / 1024).toFixed(0)}KB), skipped`)
+          continue
+        }
+        files.push({ path: entry, target, content: fileData.content })
+      }
+    }
+  }
+
+  addDir(join(cwd, "src", "slides"), "src/slides/", f => f.endsWith(".tsx") || f.endsWith(".ts"))
+  addDir(join(cwd, "src", "layouts"), "src/layouts/", f => f.endsWith(".tsx") || f.endsWith(".ts"))
+
+  const themePath = join(cwd, "src", "theme.ts")
+  if (existsSync(themePath)) {
+    files.push({ path: "theme.ts", target: "src/", content: readFileSync(themePath, "utf-8") })
+  }
+
+  const globalsPath = join(cwd, "src", "globals.css")
+  if (existsSync(globalsPath)) {
+    files.push({ path: "globals.css", target: "src/", content: readFileSync(globalsPath, "utf-8") })
+  }
+
+  addDir(join(cwd, "public"), "public/")
+
+  if (files.length > MAX_DECK_FILES) {
+    warnings.push(`Deck has ${files.length} files but registry limit is ${MAX_DECK_FILES}. Only the first ${MAX_DECK_FILES} will be included.`)
+    files.length = MAX_DECK_FILES
+  }
+
+  return { files, warnings }
+}
+
+/**
+ * Upload binary files directly to Vercel Blob via pre-signed tokens,
+ * then return a unified file array ready for the publish payload.
+ *
+ * Text files get { path, target, content }.
+ * Binary files get { path, target, storageUrl, contentType } (or fall back to inline data URIs).
+ *
+ * @param {string} slug - Item slug
+ * @param {object[]} files - Mixed array from collectDeckFiles
+ * @param {{ registry: string, token: string }} auth
+ * @returns {Promise<object[]>} Files ready for publish payload
+ */
+async function uploadBinaryFiles(slug, files, auth) {
+  const binaryFiles = files.filter(f => f.binary)
+  const textFiles = files.filter(f => !f.binary)
+
+  if (binaryFiles.length === 0) {
+    return textFiles.map(f => ({ path: f.path, target: f.target, content: f.content }))
+  }
+
+  // Request upload tokens from registry
+  let tokens = []
+  try {
+    tokens = await requestUploadTokens(
+      slug,
+      binaryFiles.map(f => ({ path: f.path, contentType: f.contentType, size: f.size })),
+      auth
+    )
+  } catch (err) {
+    console.log(`  ${dim("⚠ Could not get upload tokens, falling back to inline encoding")}`)
+  }
+
+  const result = textFiles.map(f => ({ path: f.path, target: f.target, content: f.content }))
+
+  if (tokens.length === 0) {
+    // Fallback: encode binary files as base64 data URIs inline
+    for (const f of binaryFiles) {
+      result.push({
+        path: f.path,
+        target: f.target,
+        content: `data:${f.contentType};base64,${f.buffer.toString("base64")}`
+      })
+    }
+    return result
+  }
+
+  // Upload each binary file directly to Vercel Blob
+  const tokenMap = Object.fromEntries(tokens.map(t => [t.path, t]))
+
+  for (const f of binaryFiles) {
+    const token = tokenMap[f.path]
+    if (!token) {
+      // No token for this file — fall back to inline
+      result.push({
+        path: f.path,
+        target: f.target,
+        content: `data:${f.contentType};base64,${f.buffer.toString("base64")}`
+      })
+      continue
+    }
+
+    try {
+      const blobUrl = await uploadBinaryToBlob(f.buffer, token.pathname, f.contentType, token.clientToken)
+      result.push({
+        path: f.path,
+        target: f.target,
+        storageUrl: blobUrl,
+        contentType: f.contentType
+      })
+    } catch (err) {
+      console.log(`  ${dim(`⚠ Direct upload failed for ${f.path}: ${err.message}`)}`)
+      // Fall back to inline
+      result.push({
+        path: f.path,
+        target: f.target,
+        content: `data:${f.contentType};base64,${f.buffer.toString("base64")}`
+      })
+    }
+  }
+
+  return result
+}
+
 function scanForFiles(cwd) {
   const files = []
   const dirs = [
@@ -88,10 +278,10 @@ function scanForFiles(cwd) {
 
 /**
  * Publish a single item to the registry.
- * @param {{ filePath: string, cwd: string, auth: object, typeOverride?: string, interactive?: boolean }} opts
+ * @param {{ filePath: string, cwd: string, auth: object, typeOverride?: string, interactive?: boolean, deckPrefix?: string }} opts
  * @returns {Promise<{ slug: string, status: string }>}
  */
-async function publishItem({ filePath, cwd, auth, typeOverride, interactive = true }) {
+async function publishItem({ filePath, cwd, auth, typeOverride, interactive = true, deckPrefix }) {
   const fullPath = join(cwd, filePath)
   if (!existsSync(fullPath)) {
     throw new Error(`File not found: ${filePath}`)
@@ -99,7 +289,9 @@ async function publishItem({ filePath, cwd, auth, typeOverride, interactive = tr
 
   const content = readFileSync(fullPath, "utf-8")
   const fileName = basename(fullPath)
-  const slug = fileName.replace(/\.tsx?$/, "")
+  const baseSlug = fileName.replace(/\.tsx?$/, "")
+  const prefix = deckPrefix || await promptDeckPrefix(cwd, interactive)
+  const slug = `${prefix}/${baseSlug}`
 
   const type = typeOverride || detectType(filePath) || "slide"
   const steps = detectSteps(content)
@@ -110,7 +302,7 @@ async function publishItem({ filePath, cwd, auth, typeOverride, interactive = tr
   let title, description, tags, section, releaseNotes, previewImage
 
   if (interactive) {
-    title = await prompt("Title:", titleCase(slug))
+    title = await prompt("Title:", titleCase(baseSlug))
     description = await prompt("Description:", "")
     const tagsInput = await prompt("Tags (comma-separated):", "")
     tags = tagsInput ? tagsInput.split(",").map(t => t.trim()).filter(Boolean) : []
@@ -133,7 +325,7 @@ async function publishItem({ filePath, cwd, auth, typeOverride, interactive = tr
       }
     }
   } else {
-    title = titleCase(slug)
+    title = titleCase(baseSlug)
     description = ""
     tags = []
     section = ""
@@ -141,6 +333,7 @@ async function publishItem({ filePath, cwd, auth, typeOverride, interactive = tr
     previewImage = await captureSlideAsDataUri({ cwd, slidePath: filePath }).catch(() => null)
   }
 
+  const prefixedDeps = registryDeps.map(d => `${prefix}/${d}`)
   const payload = {
     type,
     slug,
@@ -151,7 +344,7 @@ async function publishItem({ filePath, cwd, auth, typeOverride, interactive = tr
     section: section || undefined,
     files: [{ path: fileName, target, content }],
     npmDependencies: Object.keys(npmDeps).length ? npmDeps : undefined,
-    registryDependencies: registryDeps.length ? registryDeps : undefined,
+    registryDependencies: prefixedDeps.length ? prefixedDeps : undefined,
     releaseNotes: releaseNotes || undefined,
     previewImage: previewImage || undefined
   }
@@ -175,11 +368,12 @@ export async function publish(args) {
   if (args[0] === "--help" || args[0] === "-h") {
     console.log(`  ${bold("Usage:")} promptslide publish ${dim("[file] [--type slide|layout|deck|theme]")}`)
     console.log()
-    console.log(`  Publish a slide or layout to the registry.`)
+    console.log(`  Publish a slide, layout, or entire deck to the registry.`)
     console.log()
     console.log(`  ${bold("Examples:")}`)
     console.log(`    promptslide publish src/slides/slide-hero.tsx`)
     console.log(`    promptslide publish --type layout`)
+    console.log(`    promptslide publish --type deck`)
     console.log()
     process.exit(0)
   }
@@ -200,7 +394,7 @@ export async function publish(args) {
   }
   let filePath = args.find((a, i) => !a.startsWith("--") && !flagIndices.has(i))
 
-  if (!filePath) {
+  if (!filePath && typeOverride !== "deck") {
     // Interactive mode: scan for files
     const available = scanForFiles(cwd)
     if (available.length === 0) {
@@ -212,16 +406,348 @@ export async function publish(args) {
     available.forEach((f, i) => {
       console.log(`    ${dim(`${i + 1}.`)} ${f.target}${f.path}`)
     })
+    console.log(`    ${dim("─".repeat(30))}`)
+    console.log(`    ${dim(`${available.length + 1}.`)} ${bold("Entire deck")}`)
     console.log()
 
     const choice = await prompt("Select file number:", "1")
     const idx = parseInt(choice, 10) - 1
-    if (idx < 0 || idx >= available.length) {
+
+    if (idx === available.length) {
+      typeOverride = "deck"
+    } else if (idx < 0 || idx >= available.length) {
       console.error(`  ${red("Error:")} Invalid selection.`)
       process.exit(1)
+    } else {
+      filePath = relative(cwd, available[idx].fullPath)
+    }
+  }
+
+  // ── Deck publish flow (decomposed) ───────────────────────────────
+  if (typeOverride === "deck") {
+    const deckConfig = parseDeckConfig(cwd)
+    if (!deckConfig) {
+      console.error(`  ${red("Error:")} Could not parse src/deck-config.ts.`)
+      console.error(`  ${dim("Ensure it has a slides array with component/steps entries.")}`)
+      process.exit(1)
     }
 
-    filePath = relative(cwd, available[idx].fullPath)
+    const deckPrefix = await promptDeckPrefix(cwd, true)
+    const dirName = basename(cwd)
+    const deckBaseSlug = dirName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "")
+    const deckSlug = `${deckPrefix}/${deckBaseSlug}`
+
+    // Walk public/ to collect assets and build reference set
+    const publicDir = join(cwd, "public")
+    const publicAssets = []
+    const publicFileSet = new Set()
+    function walkPublic(dir, prefix) {
+      if (!existsSync(dir)) return
+      for (const entry of readdirSync(dir)) {
+        if (entry.startsWith(".")) continue
+        const full = join(dir, entry)
+        const s = statSync(full)
+        if (s.isDirectory()) {
+          walkPublic(full, prefix ? `${prefix}/${entry}` : entry)
+        } else if (s.isFile()) {
+          const relPath = prefix ? `${prefix}/${entry}` : entry
+          publicAssets.push({ relativePath: relPath, fullPath: full })
+          publicFileSet.add(relPath)
+        }
+      }
+    }
+    walkPublic(publicDir, "")
+
+    // Discover theme, layout, and slide files
+    const themeFilePaths = []
+    if (existsSync(join(cwd, "src", "theme.ts"))) themeFilePaths.push("theme.ts")
+    if (existsSync(join(cwd, "src", "globals.css"))) themeFilePaths.push("globals.css")
+    const hasTheme = themeFilePaths.length > 0
+
+    const layoutsDir = join(cwd, "src", "layouts")
+    const layoutEntries = existsSync(layoutsDir)
+      ? readdirSync(layoutsDir).filter(f => f.endsWith(".tsx") || f.endsWith(".ts"))
+      : []
+
+    const slidesDir = join(cwd, "src", "slides")
+    const slideEntries = existsSync(slidesDir)
+      ? readdirSync(slidesDir).filter(f => f.endsWith(".tsx") || f.endsWith(".ts"))
+      : []
+
+    const totalItems = publicAssets.length + (hasTheme ? 1 : 0) + layoutEntries.length + slideEntries.length + 1
+
+    // Display summary
+    console.log(`  ${bold("Decomposed deck publish:")} ${cyan(deckSlug)}`)
+    if (publicAssets.length) console.log(`    Assets:  ${publicAssets.length}`)
+    if (hasTheme) console.log(`    Theme:   1`)
+    if (layoutEntries.length) console.log(`    Layouts: ${layoutEntries.length}`)
+    console.log(`    Slides:  ${slideEntries.length}`)
+    console.log(`    Total:   ${totalItems} items`)
+    if (deckConfig.transition) {
+      console.log(`    Transition: ${deckConfig.transition}${deckConfig.directionalTransition ? " (directional)" : ""}`)
+    }
+    console.log()
+
+    // Collect deck metadata
+    const title = await prompt("Title:", titleCase(deckBaseSlug))
+    const description = await prompt("Description:", "")
+    const tagsInput = await prompt("Tags (comma-separated):", "")
+    const tags = tagsInput ? tagsInput.split(",").map(t => t.trim()).filter(Boolean) : []
+    const releaseNotes = await prompt("Release notes:", "")
+
+    // Check Playwright availability once for preview images
+    const canCapture = await isPlaywrightAvailable()
+
+    // Preview image (attached to the deck manifest only)
+    let previewImage = null
+    const previewImagePath = await prompt("Preview image path (leave empty to auto-generate):", "")
+    if (previewImagePath) {
+      const resolved = join(cwd, previewImagePath)
+      previewImage = readPreviewImage(resolved)
+      if (!previewImage) {
+        console.log(`  ${dim("⚠ Skipping image: file not found, unsupported format, or > 2MB")}`)
+      }
+    } else if (canCapture) {
+      const firstSlide = deckConfig.slides[0]
+      if (firstSlide) {
+        console.log(`  ${dim("Generating deck preview image...")}`)
+        previewImage = await captureSlideAsDataUri({ cwd, slidePath: `src/slides/${firstSlide.slug}.tsx` })
+        if (previewImage) {
+          console.log(`  ${green("✓")} Deck preview image generated`)
+        } else {
+          console.log(`  ${dim("⚠ Could not generate deck preview image")}`)
+        }
+      }
+    } else {
+      const pm = detectPackageManager(cwd)
+      const installCmd = pm === "bun" ? "bun add -d playwright" : pm === "pnpm" ? "pnpm add -D playwright" : pm === "yarn" ? "yarn add -D playwright" : "npm install -D playwright"
+      console.log(`  ${dim("Tip: Install playwright for auto-generated preview images")}`)
+      console.log(`  ${dim(`     ${installCmd} && npx playwright install chromium`)}`)
+    }
+
+    console.log()
+    console.log(`  Publishing ${totalItems} items...`)
+    console.log()
+
+    // Read lockfile for skip-if-unchanged
+    const lock = readLockfile(cwd)
+    let itemIndex = 0
+    let published = 0
+    let skipped = 0
+    let failed = 0
+
+    function isUnchanged(slug, fileHashes) {
+      const entry = lock.items[slug]
+      if (!entry?.files) return false
+      const storedKeys = Object.keys(entry.files)
+      const currentKeys = Object.keys(fileHashes)
+      if (storedKeys.length !== currentKeys.length) return false
+      return currentKeys.every(k => entry.files[k] === fileHashes[k])
+    }
+
+    // ── Phase 1: Assets ──
+    for (const asset of publicAssets) {
+      itemIndex++
+      const assetSlug = assetFileToSlug(deckPrefix, asset.relativePath)
+      const fileName = basename(asset.fullPath)
+      const dirPart = asset.relativePath.includes("/")
+        ? "public/" + asset.relativePath.substring(0, asset.relativePath.lastIndexOf("/") + 1)
+        : "public/"
+
+      const fileData = readFileForRegistry(asset.fullPath)
+      const fileHash = fileData.binary
+        ? hashContent(fileData.buffer.toString("base64"))
+        : hashContent(fileData.content)
+      const fileHashes = { [dirPart + fileName]: fileHash }
+
+      if (isUnchanged(assetSlug, fileHashes)) {
+        console.log(`  [${itemIndex}/${totalItems}] ${dim("—")} asset ${dim(assetSlug)} (unchanged)`)
+        skipped++
+        continue
+      }
+
+      let files
+      if (fileData.binary) {
+        files = await uploadBinaryFiles(assetSlug, [
+          { path: fileName, target: dirPart, binary: true, buffer: fileData.buffer, contentType: fileData.contentType, size: fileData.size }
+        ], auth)
+      } else {
+        files = [{ path: fileName, target: dirPart, content: fileData.content }]
+      }
+
+      try {
+        const result = await publishToRegistry({ type: "asset", slug: assetSlug, title: fileName, files }, auth)
+        console.log(`  [${itemIndex}/${totalItems}] ${green("✓")} asset ${cyan(assetSlug)} ${dim(`v${result.version}`)}`)
+        updateLockfileItem(cwd, assetSlug, result.version ?? 0, fileHashes)
+        published++
+      } catch (err) {
+        console.log(`  [${itemIndex}/${totalItems}] ${red("✗")} asset ${dim(assetSlug)}: ${err.message}`)
+        failed++
+      }
+    }
+
+    // ── Phase 2: Theme ──
+    if (hasTheme) {
+      itemIndex++
+      const themeSlug = `${deckPrefix}/theme`
+      const themePayloadFiles = []
+      const themeFileHashes = {}
+      let themeContent = ""
+
+      for (const tf of themeFilePaths) {
+        const content = readFileSync(join(cwd, "src", tf), "utf-8")
+        themePayloadFiles.push({ path: tf, target: "src/", content })
+        themeFileHashes[`src/${tf}`] = hashContent(content)
+        themeContent += content
+      }
+
+      if (isUnchanged(themeSlug, themeFileHashes)) {
+        console.log(`  [${itemIndex}/${totalItems}] ${dim("—")} theme ${dim(themeSlug)} (unchanged)`)
+        skipped++
+      } else {
+        const assetDeps = detectAssetDepsInContent(themeContent, deckPrefix, publicFileSet)
+        const npmDeps = detectNpmDeps(themeContent)
+
+        try {
+          const result = await publishToRegistry({
+            type: "theme",
+            slug: themeSlug,
+            title: "Theme",
+            files: themePayloadFiles,
+            registryDependencies: assetDeps.length ? assetDeps : undefined,
+            npmDependencies: Object.keys(npmDeps).length ? npmDeps : undefined
+          }, auth)
+          console.log(`  [${itemIndex}/${totalItems}] ${green("✓")} theme ${cyan(themeSlug)} ${dim(`v${result.version}`)}`)
+          updateLockfileItem(cwd, themeSlug, result.version ?? 0, themeFileHashes)
+          published++
+        } catch (err) {
+          console.log(`  [${itemIndex}/${totalItems}] ${red("✗")} theme ${dim(themeSlug)}: ${err.message}`)
+          failed++
+        }
+      }
+    }
+
+    // ── Phase 3: Layouts ──
+    for (const layoutFile of layoutEntries) {
+      itemIndex++
+      const layoutName = layoutFile.replace(/\.tsx?$/, "")
+      const layoutSlug = `${deckPrefix}/${layoutName}`
+      const content = readFileSync(join(cwd, "src", "layouts", layoutFile), "utf-8")
+      const fileHashes = { [`src/layouts/${layoutFile}`]: hashContent(content) }
+
+      if (isUnchanged(layoutSlug, fileHashes)) {
+        console.log(`  [${itemIndex}/${totalItems}] ${dim("—")} layout ${dim(layoutSlug)} (unchanged)`)
+        skipped++
+        continue
+      }
+
+      const assetDeps = detectAssetDepsInContent(content, deckPrefix, publicFileSet)
+      const npmDeps = detectNpmDeps(content)
+      const regDeps = hasTheme ? [`${deckPrefix}/theme`] : []
+      regDeps.push(...assetDeps)
+
+      try {
+        const result = await publishToRegistry({
+          type: "layout",
+          slug: layoutSlug,
+          title: titleCase(layoutName),
+          files: [{ path: layoutFile, target: "src/layouts/", content }],
+          registryDependencies: regDeps.length ? regDeps : undefined,
+          npmDependencies: Object.keys(npmDeps).length ? npmDeps : undefined
+        }, auth)
+        console.log(`  [${itemIndex}/${totalItems}] ${green("✓")} layout ${cyan(layoutSlug)} ${dim(`v${result.version}`)}`)
+        updateLockfileItem(cwd, layoutSlug, result.version ?? 0, fileHashes)
+        published++
+      } catch (err) {
+        console.log(`  [${itemIndex}/${totalItems}] ${red("✗")} layout ${dim(layoutSlug)}: ${err.message}`)
+        failed++
+      }
+    }
+
+    // ── Phase 4: Slides ──
+    for (const slideFile of slideEntries) {
+      itemIndex++
+      const slideName = slideFile.replace(/\.tsx?$/, "")
+      const slideSlug = `${deckPrefix}/${slideName}`
+      const content = readFileSync(join(cwd, "src", "slides", slideFile), "utf-8")
+      const fileHashes = { [`src/slides/${slideFile}`]: hashContent(content) }
+
+      if (isUnchanged(slideSlug, fileHashes)) {
+        console.log(`  [${itemIndex}/${totalItems}] ${dim("—")} slide ${dim(slideSlug)} (unchanged)`)
+        skipped++
+        continue
+      }
+
+      const assetDeps = detectAssetDepsInContent(content, deckPrefix, publicFileSet)
+      const layoutDeps = detectRegistryDeps(content).map(d => `${deckPrefix}/${d}`)
+      const npmDeps = detectNpmDeps(content)
+      const steps = detectSteps(content)
+      const slideConfig = deckConfig.slides.find(s => s.slug === slideName)
+      const section = slideConfig?.section || undefined
+
+      const regDeps = hasTheme ? [`${deckPrefix}/theme`] : []
+      regDeps.push(...layoutDeps, ...assetDeps)
+
+      // Generate preview image for this slide
+      let slidePreview = null
+      if (canCapture) {
+        slidePreview = await captureSlideAsDataUri({ cwd, slidePath: `src/slides/${slideFile}` }).catch(() => null)
+      }
+
+      try {
+        const result = await publishToRegistry({
+          type: "slide",
+          slug: slideSlug,
+          title: titleCase(slideName),
+          files: [{ path: slideFile, target: "src/slides/", content }],
+          steps,
+          section,
+          registryDependencies: regDeps.length ? regDeps : undefined,
+          npmDependencies: Object.keys(npmDeps).length ? npmDeps : undefined,
+          previewImage: slidePreview || undefined
+        }, auth)
+        console.log(`  [${itemIndex}/${totalItems}] ${green("✓")} slide ${cyan(slideSlug)} ${dim(`v${result.version}`)}`)
+        updateLockfileItem(cwd, slideSlug, result.version ?? 0, fileHashes)
+        published++
+      } catch (err) {
+        console.log(`  [${itemIndex}/${totalItems}] ${red("✗")} slide ${dim(slideSlug)}: ${err.message}`)
+        failed++
+      }
+    }
+
+    // ── Phase 5: Deck manifest ──
+    itemIndex++
+    const slideSlugs = slideEntries.map(f => `${deckPrefix}/${f.replace(/\.tsx?$/, "")}`)
+    const assetSlugs = publicAssets.map(a => assetFileToSlug(deckPrefix, a.relativePath))
+    const allDeckDeps = [...slideSlugs, ...assetSlugs]
+
+    try {
+      const result = await publishToRegistry({
+        type: "deck",
+        slug: deckSlug,
+        title,
+        description: description || undefined,
+        tags,
+        deckConfig,
+        files: [],
+        registryDependencies: allDeckDeps.length ? allDeckDeps : undefined,
+        releaseNotes: releaseNotes || undefined,
+        previewImage: previewImage || undefined
+      }, auth)
+      console.log(`  [${itemIndex}/${totalItems}] ${green("✓")} deck ${cyan(deckSlug)} ${dim(`v${result.version}`)}`)
+      updateLockfileItem(cwd, deckSlug, result.version ?? 0, {})
+      published++
+    } catch (err) {
+      console.log(`  [${itemIndex}/${totalItems}] ${red("✗")} deck ${dim(deckSlug)}: ${err.message}`)
+      failed++
+    }
+
+    console.log()
+    console.log(`  ${bold("Done:")} ${green(`${published} published`)}${skipped ? `, ${skipped} unchanged` : ""}${failed ? `, ${red(`${failed} failed`)}` : ""}`)
+    console.log(`  Install: ${cyan(`promptslide add ${deckSlug}`)}`)
+    console.log()
+    closePrompts()
+    return
   }
 
   // Resolve full path and read content
@@ -233,7 +759,7 @@ export async function publish(args) {
 
   const content = readFileSync(fullPath, "utf-8")
   const fileName = basename(fullPath)
-  const slug = fileName.replace(/\.tsx?$/, "")
+  const baseSlug = fileName.replace(/\.tsx?$/, "")
 
   // Detect metadata
   const type = typeOverride || detectType(filePath) || "slide"
@@ -253,12 +779,34 @@ export async function publish(args) {
   }
   console.log()
 
+  // Prompt for deck prefix (required)
+  const deckPrefix = await promptDeckPrefix(cwd, true)
+  const slug = `${deckPrefix}/${baseSlug}`
+  console.log(`  Slug: ${cyan(slug)}`)
+  console.log()
+
+  // Warn if same base slug exists under a different prefix
+  try {
+    const { items: results } = await searchRegistry({ search: baseSlug, type }, auth)
+    const conflicts = (results || []).filter(r => r.name !== slug && r.name.endsWith(`/${baseSlug}`))
+    if (conflicts.length) {
+      console.log(`  ${bold("Note:")} ${baseSlug} also exists as:`)
+      for (const c of conflicts) {
+        console.log(`    ${dim("·")} ${c.name} ${dim(`(${c.title || "untitled"})`)}`)
+      }
+      console.log()
+    }
+  } catch {
+    // Search failure is non-blocking
+  }
+
   // Check if registry dependencies exist and offer to publish missing ones
   if (registryDeps.length) {
     const missing = []
 
     for (const depSlug of registryDeps) {
-      const exists = await registryItemExists(depSlug, auth)
+      const prefixedDepSlug = `${deckPrefix}/${depSlug}`
+      const exists = await registryItemExists(prefixedDepSlug, auth)
       if (!exists) {
         missing.push(depSlug)
       }
@@ -294,7 +842,8 @@ export async function publish(args) {
                 cwd,
                 auth,
                 typeOverride: depType,
-                interactive: true
+                interactive: true,
+                deckPrefix
               })
               console.log()
               const depVer = result.version ? ` ${dim(`v${result.version}`)}` : ""
@@ -311,13 +860,13 @@ export async function publish(args) {
         }
       }
 
-      console.log(`  ${dim("─── Main item:")} ${bold(slug)} ${dim("───")}`)
+      console.log(`  ${dim("─── Main item:")} ${bold(baseSlug)} ${dim("───")}`)
       console.log()
     }
   }
 
   // Collect metadata for main item
-  const title = await prompt("Title:", titleCase(slug))
+  const title = await prompt("Title:", titleCase(baseSlug))
   const description = await prompt("Description:", "")
   const tagsInput = await prompt("Tags (comma-separated):", "")
   const tags = tagsInput ? tagsInput.split(",").map(t => t.trim()).filter(Boolean) : []
@@ -349,6 +898,7 @@ export async function publish(args) {
   console.log()
 
   // Publish main item
+  const prefixedRegistryDeps = registryDeps.map(d => `${deckPrefix}/${d}`)
   const payload = {
     type,
     slug,
@@ -359,7 +909,7 @@ export async function publish(args) {
     section: section || undefined,
     files: [{ path: fileName, target, content }],
     npmDependencies: Object.keys(npmDeps).length ? npmDeps : undefined,
-    registryDependencies: registryDeps.length ? registryDeps : undefined,
+    registryDependencies: prefixedRegistryDeps.length ? prefixedRegistryDeps : undefined,
     releaseNotes: releaseNotes || undefined,
     previewImage: previewImage || undefined
   }

package/src/utils/auth.mjs

@@ -5,7 +5,7 @@ import { homedir } from "node:os"
 const AUTH_DIR = join(homedir(), ".promptslide")
 const AUTH_FILE = join(AUTH_DIR, "auth.json")
 
-const DEFAULT_REGISTRY = "https://registry.promptslide.dev"
+const DEFAULT_REGISTRY = "https://promptslide.eu"
 
 /**
  * Load stored auth credentials.

package/src/utils/deck-config.mjs

@@ -206,3 +206,58 @@ export function replaceDeckConfig(cwd, slides, opts = {}) {
   writeFileSync(configPath, content, "utf-8")
   return true
 }
+
+/**
+ * Parse deck-config.ts and extract the deckConfig structure for publishing.
+ * Returns { transition?, directionalTransition?, slides } where slides is
+ * an array of { slug, steps, section? }.
+ *
+ * @param {string} cwd - Project root directory
+ * @returns {{ transition?: string, directionalTransition?: boolean, slides: { slug: string, steps: number, section?: string }[] } | null}
+ */
+export function parseDeckConfig(cwd) {
+  const configPath = join(cwd, DECK_CONFIG_PATH)
+  if (!existsSync(configPath)) return null
+
+  const content = readFileSync(configPath, "utf-8")
+
+  // 1. Parse imports to build componentName -> slug map
+  //    Pattern: import { SlideTitle } from "@/slides/slide-title"
+  const componentToSlug = {}
+  const importRegex = /import\s*\{\s*(\w+)\s*\}\s*from\s*["']@\/slides\/([^"']+)["']/g
+  for (const match of content.matchAll(importRegex)) {
+    componentToSlug[match[1]] = match[2].replace(/\.tsx?$/, "")
+  }
+
+  // 2. Parse transition exports
+  let transition
+  const transitionMatch = content.match(/export\s+const\s+transition\s*=\s*["']([^"']+)["']/)
+  if (transitionMatch) transition = transitionMatch[1]
+
+  let directionalTransition
+  const dirMatch = content.match(/export\s+const\s+directionalTransition\s*=\s*(true|false)/)
+  if (dirMatch) directionalTransition = dirMatch[1] === "true"
+
+  // 3. Parse slides array entries (order-independent matching)
+  const slides = []
+  const entryRegex = /\{([^}]+)\}/g
+  for (const match of content.matchAll(entryRegex)) {
+    const body = match[1]
+    const componentMatch = body.match(/component:\s*(\w+)/)
+    const stepsMatch = body.match(/steps:\s*(\d+)/)
+    if (!componentMatch || !stepsMatch) continue
+    const slug = componentToSlug[componentMatch[1]]
+    if (!slug) continue // layout or unknown import — skip
+    const entry = { slug, steps: parseInt(stepsMatch[1], 10) }
+    const sectionMatch = body.match(/section:\s*["']([^"']+)["']/)
+    if (sectionMatch) entry.section = sectionMatch[1]
+    slides.push(entry)
+  }
+
+  if (slides.length === 0) return null
+
+  const result = { slides }
+  if (transition) result.transition = transition
+  if (directionalTransition !== undefined) result.directionalTransition = directionalTransition
+  return result
+}

package/src/utils/prompts.mjs

@@ -28,10 +28,12 @@ export function prompt(question, defaultValue) {
   if (!rl) return Promise.resolve(defaultValue || "")
   return new Promise(resolve => {
     const suffix = defaultValue ? ` ${dim(`(${defaultValue})`)} ` : " "
+    const onClose = () => resolve(defaultValue || "")
+    rl.once("close", onClose)
     rl.question(`  ${question}${suffix}`, answer => {
+      rl.removeListener("close", onClose)
       resolve(answer.trim() || defaultValue || "")
     })
-    rl.once("close", () => resolve(defaultValue || ""))
   })
 }
 
@@ -40,11 +42,13 @@ export function confirm(question, defaultYes = true) {
   if (!rl) return Promise.resolve(defaultYes)
   return new Promise(resolve => {
     const hint = defaultYes ? "Y/n" : "y/N"
+    const onClose = () => resolve(defaultYes)
+    rl.once("close", onClose)
     rl.question(`  ${question} ${dim(`(${hint})`)} `, answer => {
+      rl.removeListener("close", onClose)
       const a = answer.trim().toLowerCase()
       if (!a) return resolve(defaultYes)
       resolve(a === "y" || a === "yes")
     })
-    rl.once("close", () => resolve(defaultYes))
   })
 }

package/src/utils/registry.mjs

@@ -186,26 +186,23 @@ export async function resolveRegistryDependencies(item, auth, cwd) {
       Object.assign(npmDeps, current.dependencies)
     }
 
-    // Check if any files need writing (skip if all exist)
-    const needsInstall = current.files?.some(f => {
-      const targetPath = join(cwd, f.target, f.path)
-      return !existsSync(targetPath)
-    })
-
-    if (needsInstall || current === item) {
-      items.push(current)
-    }
+    // Always include items — add.mjs handles identical/overwrite logic per file
+    items.push(current)
 
-    // Recurse into registry dependencies
+    // Resolve registry dependencies in parallel
     if (current.registryDependencies?.length) {
-      for (const depName of current.registryDependencies) {
-        try {
-          const depItem = await fetchRegistryItem(depName, auth)
-          await resolve(depItem)
-        } catch (err) {
-          console.warn(`  Warning: Could not resolve dependency "${depName}": ${err.message}`)
-        }
-      }
+      const fetches = current.registryDependencies
+        .filter(depName => !seen.has(depName))
+        .map(async (depName) => {
+          try {
+            return await fetchRegistryItem(depName, auth)
+          } catch (err) {
+            console.warn(`  Warning: Could not resolve dependency "${depName}": ${err.message}`)
+            return null
+          }
+        })
+      const depItems = (await Promise.all(fetches)).filter(Boolean)
+      await Promise.all(depItems.map(dep => resolve(dep)))
     }
   }
 
@@ -317,3 +314,116 @@ export function getInstallCommand(pm, packages) {
       return { cmd: "npm", args: ["install", ...packages], display: `npm install ${packages.join(" ")}` }
   }
 }
+
+/**
+ * Request pre-signed upload tokens for binary files.
+ * Returns empty array if registry doesn't support direct upload (local dev).
+ *
+ * @param {string} slug - Item slug
+ * @param {{ path: string, contentType: string, size: number }[]} files
+ * @param {{ registry: string, token: string }} auth
+ * @returns {Promise<{ path: string, clientToken: string, pathname: string }[]>}
+ */
+export async function requestUploadTokens(slug, files, auth) {
+  const res = await fetch(`${auth.registry}/api/publish/upload-tokens`, {
+    method: "POST",
+    headers: {
+      ...authHeaders(auth),
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ slug, files })
+  })
+
+  if (res.status === 404) {
+    // Registry doesn't have this endpoint (older version) — fall back to inline
+    return []
+  }
+  if (res.status === 401) {
+    throw new Error("Authentication failed. Run `promptslide login` to re-authenticate.")
+  }
+  if (!res.ok) {
+    throw new Error(`Failed to get upload tokens (${res.status}): ${await res.text()}`)
+  }
+
+  const data = await res.json()
+  return data.tokens || []
+}
+
+/**
+ * Upload a binary file directly to Vercel Blob using a scoped client token.
+ * Uses raw fetch — no @vercel/blob dependency needed.
+ *
+ * @param {Buffer} buffer - Raw file bytes
+ * @param {string} pathname - Target pathname in blob storage
+ * @param {string} contentType - MIME type
+ * @param {string} clientToken - Scoped Vercel Blob client token
+ * @returns {Promise<string>} The permanent blob URL
+ */
+export async function uploadBinaryToBlob(buffer, pathname, contentType, clientToken) {
+  const res = await fetch(`https://blob.vercel-storage.com/${pathname}`, {
+    method: "PUT",
+    headers: {
+      Authorization: `Bearer ${clientToken}`,
+      "x-content-type": contentType,
+      "x-api-version": "7",
+      "x-vercel-blob-access": "private"
+    },
+    body: buffer
+  })
+
+  if (!res.ok) {
+    const text = await res.text()
+    throw new Error(`Blob upload failed (${res.status}): ${text}`)
+  }
+
+  const result = await res.json()
+  return result.url
+}
+
+/**
+ * Convert a public/ file path to a registry slug.
+ * Deterministic mapping used both during publish (to create the slug)
+ * and during asset reference detection (to find the right dependency slug).
+ *
+ * "logo.png"           → "{prefix}/logo-png"
+ * "images/hero.jpg"    → "{prefix}/images-hero-jpg"
+ *
+ * @param {string} prefix - Deck prefix (e.g. "my-deck")
+ * @param {string} relativePath - Path relative to public/ (e.g. "images/hero.jpg")
+ * @returns {string} Full registry slug
+ */
+export function assetFileToSlug(prefix, relativePath) {
+  const segment = relativePath
+    .replace(/[/\\]/g, "-")
+    .replace(/[^a-z0-9-]/gi, "-")
+    .toLowerCase()
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "")
+  return `${prefix}/${segment}`
+}
+
+/**
+ * Scan component source for references to public/ assets.
+ * Detects patterns like src="/file.png", href="/file.woff2", url('/file.jpg').
+ *
+ * @param {string} content - File source code (.tsx, .ts, .css)
+ * @param {string} prefix - Registry prefix (e.g. "my-deck")
+ * @param {Set<string>} publicFiles - Set of known public/ file paths (relative to public/)
+ * @returns {string[]} Array of registry dependency slugs
+ */
+export function detectAssetDepsInContent(content, prefix, publicFiles) {
+  const deps = new Set()
+  const patterns = [
+    /(?:src|href|poster|data-src)\s*=\s*\{?\s*["']\/([^"']+)["']/g,
+    /url\(\s*["']?\/([^"')]+)["']?\s*\)/g,
+  ]
+  for (const pattern of patterns) {
+    for (const match of content.matchAll(pattern)) {
+      const filePath = match[1]
+      if (publicFiles.has(filePath)) {
+        deps.add(assetFileToSlug(prefix, filePath))
+      }
+    }
+  }
+  return Array.from(deps)
+}

package/templates/default/AGENTS.md

@@ -4,6 +4,12 @@ Slide deck framework: Vite + React 19 + Tailwind v4 + Framer Motion. Each slide
 
 > **Recommended**: Install the [PromptSlide skill](https://github.com/prompticeu/promptslide) for guided slide authoring, style presets, design recipes, and best practices: `npx skills add prompticeu/promptslide`
 
+## Before You Start
+
+Do not jump straight to writing slides. First confirm the visual direction with the user — theme colors, fonts, and overall style. Then, for each slide, think about what design approach fits the content before coding. Not everything needs cards or grids — let the content shape the layout.
+
+If the PromptSlide skill is installed, follow its workflow — it includes design planning steps that should happen before writing any slides.
+
 ---
 
 ## Architecture
@@ -83,5 +89,5 @@ Layouts in `src/layouts/` and theme colors in `src/globals.css` are yours to cus
 - **Semantic colors**: Use `text-foreground`, `text-muted-foreground`, `text-primary`, `bg-background`, `bg-card`, `border-border`.
 - **Icons**: Import from `lucide-react` (e.g., `import { ArrowRight } from "lucide-react"`).
 - **Animations**: Use `<Animated step={n}>` for click-to-reveal. The `steps` value in `deck-config.ts` must equal the highest step number used. Available: `fade`, `slide-up`, `slide-down`, `slide-left`, `slide-right`, `scale`.
-- **PDF compatibility**: No `blur()` or `backdrop-filter` (dropped by Chromium). No gradients (use solid colors with opacity). Keep colored shadows at `/5` max.
+- **PDF compatibility**: No `blur()` or `backdrop-filter` (dropped by Chromium). No gradients (use solid colors with opacity). No `box-shadow` (doesn't export correctly) — use borders or background tints instead.
 - **Brand color**: Edit `--primary` in `src/globals.css`. Configure logo and fonts in `src/theme.ts`.

package/templates/default/src/theme.ts

@@ -1,8 +1,5 @@
-import type { ThemeConfig } from "@promptslide/core";
+import type { ThemeConfig } from "promptslide";
 
 export const theme: ThemeConfig = {
   name: "{{PROJECT_NAME}}",
-  logo: {
-    full: "/logo.svg",
-  },
 };

package/templates/default/public/logo.svg

@@ -1,7 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32" fill="none">
-  <rect width="32" height="32" rx="6" fill="currentColor" opacity="0.1"/>
-  <rect x="6" y="8" width="20" height="14" rx="2" stroke="currentColor" stroke-width="2" fill="none"/>
-  <line x1="6" y1="25" x2="26" y2="25" stroke="currentColor" stroke-width="2" stroke-linecap="round"/>
-  <rect x="10" y="12" width="8" height="2" rx="1" fill="currentColor" opacity="0.6"/>
-  <rect x="10" y="16" width="12" height="1.5" rx="0.75" fill="currentColor" opacity="0.3"/>
-</svg>