promptslide 0.3.3 → 0.3.5

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [0.3.5](https://github.com/prompticeu/promptslide/compare/promptslide-v0.3.4...promptslide-v0.3.5) (2026-03-08)
+
+
+### Features
+
+* bundle shared sources with deck publish and fix deck-config parsing ([5f7fd1d](https://github.com/prompticeu/promptslide/commit/5f7fd1de6e5fc58a0568bd87830094dd40c9eca7))
+* persist deck and item metadata to lockfile for publish defaults ([#68](https://github.com/prompticeu/promptslide/issues/68)) ([0dc8ca3](https://github.com/prompticeu/promptslide/commit/0dc8ca3f52b86214eb42dacd9e1ead4d05928242))
+
+## [0.3.4](https://github.com/prompticeu/promptslide/compare/promptslide-v0.3.3...promptslide-v0.3.4) (2026-03-07)
+
+
+### Features
+
+* unify deckPrefix and deckSlug into single deck slug concept ([#66](https://github.com/prompticeu/promptslide/issues/66)) ([f091c7d](https://github.com/prompticeu/promptslide/commit/f091c7dcd93738670fde4b48ff1020a358bce128))
+
+
+### Performance Improvements
+
+* optimize deck publish with parallel phases and reusable capture session ([#63](https://github.com/prompticeu/promptslide/issues/63)) ([62fb985](https://github.com/prompticeu/promptslide/commit/62fb9853f7d220be8bf5ba07e5cc55744b658229))
+
 ## [0.3.3](https://github.com/prompticeu/promptslide/compare/promptslide-v0.3.2...promptslide-v0.3.3) (2026-03-07)
 
 

package/package.json

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

package/src/commands/add.mjs

@@ -149,8 +149,7 @@ export async function add(args) {
 
   // Persist deck slug for future pull/publish if this is a deck
   if (item.type === "deck") {
-    const prefix = item.name.split("/")[0]
-    updateLockfilePublishConfig(cwd, { deckSlug: item.name, deckPrefix: prefix })
+    updateLockfilePublishConfig(cwd, { deckSlug: item.name })
   }
 
   // Auto-update deck-config.ts

package/src/commands/create.mjs

@@ -236,8 +236,7 @@ export async function create(args) {
     }
 
     // Persist deck slug for future pull/publish in the new project
-    const prefix = fromSlug.split("/")[0]
-    updateLockfilePublishConfig(targetDir, { deckSlug: fromSlug, deckPrefix: prefix })
+    updateLockfilePublishConfig(targetDir, { deckSlug: fromSlug })
 
     console.log()
   }

package/src/commands/publish.mjs

@@ -4,41 +4,43 @@ import { fileURLToPath } from "node:url"
 
 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, searchRegistry, updateLockfileItem, updateLockfilePublishConfig, readLockfile, hashContent, detectPackageManager, requestUploadTokens, uploadBinaryToBlob, assetFileToSlug, detectAssetDepsInContent } from "../utils/registry.mjs"
+import { captureSlideAsDataUri, isPlaywrightAvailable, createCaptureSession } from "../utils/export.mjs"
+import { publishToRegistry, registryItemExists, searchRegistry, updateLockfileItem, updateLockfilePublishConfig, readLockfile, writeLockfile, hashContent, detectPackageManager, requestUploadTokens, uploadBinaryToBlob, assetFileToSlug, detectAssetDepsInContent, readDeckMeta, updateDeckMeta, readItemMeta, updateItemMeta } from "../utils/registry.mjs"
 import { prompt, confirm, select, closePrompts } from "../utils/prompts.mjs"
 import { parseDeckConfig } from "../utils/deck-config.mjs"
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const CLI_VERSION = JSON.parse(readFileSync(join(__dirname, "..", "..", "package.json"), "utf-8")).version
 
-function readDeckPrefix(cwd) {
-  // Prefer stored prefix from lockfile (user's previous choice)
+function readDeckSlug(cwd) {
   const lock = readLockfile(cwd)
+  // Prefer stored deck slug — migrate old two-part format (e.g. "my-deck/name" → "my-deck")
+  if (lock.deckSlug) return lock.deckSlug.split("/")[0]
+  // Migrate legacy deckPrefix (old lockfiles stored prefix separately)
   if (lock.deckPrefix) return lock.deckPrefix
+  return ""
+}
 
-  // Fall back to package.json name
-  try {
-    const pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf-8"))
-    return (pkg.name || "").toLowerCase()
-  } catch {
-    return ""
-  }
+function defaultDeckSlug(cwd) {
+  const dirName = basename(cwd)
+  return dirName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "")
 }
 
-async function promptDeckPrefix(cwd, interactive) {
-  const defaultPrefix = readDeckPrefix(cwd)
+async function promptDeckSlug(cwd, interactive) {
+  const stored = readDeckSlug(cwd)
+  const fallback = defaultDeckSlug(cwd)
+  const defaultValue = stored || fallback
   if (!interactive) {
-    if (!defaultPrefix) throw new Error("Deck prefix is required. Set a name in package.json or publish interactively.")
-    return defaultPrefix
+    if (!defaultValue) throw new Error("Deck slug is required. Publish interactively to set it.")
+    return defaultValue
   }
-  let prefix
+  let slug
   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)`)
+    slug = await prompt("Deck slug:", defaultValue)
+    if (slug && /^[a-z0-9][a-z0-9-]*[a-z0-9]$/.test(slug)) break
+    console.log(`  ${red("Error:")} Deck slug is required (lowercase alphanumeric with hyphens, min 2 chars)`)
   }
-  return prefix
+  return slug
 }
 
 function titleCase(slug) {
@@ -89,6 +91,57 @@ function detectRegistryDeps(content) {
   return deps
 }
 
+/**
+ * Discover shared source files under src/ that aren't slides, layouts, or theme.
+ * These are files in directories like src/components/, src/lib/, src/hooks/, etc.
+ * Returns an array of { relativePath, fullPath, target } objects.
+ */
+function discoverSharedSources(cwd) {
+  const srcDir = join(cwd, "src")
+  if (!existsSync(srcDir)) return []
+
+  // Top-level dirs whose top-level files are published as individual items
+  // (slides/*.tsx → slide items, layouts/*.tsx → layout items).
+  // Subdirectories within these ARE included as shared sources (e.g. slides/commercial/slide1.tsx).
+  const ITEM_DIRS = new Set(["slides", "layouts"])
+  // Top-level files already handled (theme.ts, globals.css, deck-config.ts, App.tsx)
+  const SKIP_FILES = new Set(["theme.ts", "globals.css", "deck-config.ts", "App.tsx", "vite-env.d.ts"])
+  const SOURCE_EXTS = new Set([".tsx", ".ts", ".jsx", ".js"])
+
+  const results = []
+
+  function walk(dir, relativeDir, skipTopLevelFiles) {
+    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()) {
+        // Enter slides/ and layouts/ but mark that top-level files are handled elsewhere
+        if (!relativeDir && ITEM_DIRS.has(entry)) {
+          walk(full, entry, true)
+        } else {
+          walk(full, relativeDir ? `${relativeDir}/${entry}` : entry, false)
+        }
+      } else if (s.isFile()) {
+        // Skip known top-level files in src/
+        if (!relativeDir && SKIP_FILES.has(entry)) continue
+        // Skip top-level files in slides/ and layouts/ (published as individual items)
+        if (skipTopLevelFiles) continue
+        const ext = extname(entry).toLowerCase()
+        if (!SOURCE_EXTS.has(ext)) continue
+        const relativePath = relativeDir ? `${relativeDir}/${entry}` : entry
+        // target mirrors the src/ directory structure for @/ import resolution
+        const target = relativeDir ? `src/${relativeDir}/` : "src/"
+        results.push({ relativePath, fullPath: full, fileName: entry, target })
+      }
+    }
+  }
+
+  walk(srcDir, "", false)
+  return results
+}
+
 const IMAGE_EXTS = new Set([".png", ".jpg", ".jpeg", ".webp"])
 const MAX_IMAGE_SIZE = 2 * 1024 * 1024 // 2MB
 
@@ -228,10 +281,10 @@ function scanForFiles(cwd) {
 
 /**
  * Publish a single item to the registry.
- * @param {{ filePath: string, cwd: string, auth: object, typeOverride?: string, interactive?: boolean, deckPrefix?: string }} opts
+ * @param {{ filePath: string, cwd: string, auth: object, typeOverride?: string, interactive?: boolean, deckSlug?: string }} opts
  * @returns {Promise<{ slug: string, status: string }>}
  */
-async function publishItem({ filePath, cwd, auth, typeOverride, interactive = true, deckPrefix }) {
+async function publishItem({ filePath, cwd, auth, typeOverride, interactive = true, deckSlug: deckSlugOverride }) {
   const fullPath = join(cwd, filePath)
   if (!existsSync(fullPath)) {
     throw new Error(`File not found: ${filePath}`)
@@ -240,8 +293,8 @@ async function publishItem({ filePath, cwd, auth, typeOverride, interactive = tr
   const content = readFileSync(fullPath, "utf-8")
   const fileName = basename(fullPath)
   const baseSlug = fileName.replace(/\.tsx?$/, "")
-  const prefix = deckPrefix || await promptDeckPrefix(cwd, interactive)
-  const slug = `${prefix}/${baseSlug}`
+  const deck = deckSlugOverride || await promptDeckSlug(cwd, interactive)
+  const slug = `${deck}/${baseSlug}`
 
   const type = typeOverride || detectType(filePath) || "slide"
   const steps = detectSteps(content)
@@ -252,11 +305,13 @@ async function publishItem({ filePath, cwd, auth, typeOverride, interactive = tr
   let title, description, tags, section, releaseNotes, previewImage
 
   if (interactive) {
-    title = await prompt("Title:", titleCase(baseSlug))
-    description = await prompt("Description:", "")
-    const tagsInput = await prompt("Tags (comma-separated):", "")
+    const storedMeta = readItemMeta(cwd, slug)
+    title = await prompt("Title:", storedMeta.title || titleCase(baseSlug))
+    description = await prompt("Description:", storedMeta.description || "")
+    const storedTagsDefault = storedMeta.tags?.length ? storedMeta.tags.join(", ") : ""
+    const tagsInput = await prompt("Tags (comma-separated):", storedTagsDefault)
     tags = tagsInput ? tagsInput.split(",").map(t => t.trim()).filter(Boolean) : []
-    section = await prompt("Section:", "")
+    section = await prompt("Section:", storedMeta.section || "")
     releaseNotes = await prompt("Release notes:", "")
     const imagePath = await prompt("Preview image path (leave empty to auto-generate):", "")
     if (imagePath) {
@@ -283,7 +338,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 prefixedDeps = registryDeps.map(d => `${deck}/${d}`)
   const payload = {
     type,
     slug,
@@ -305,6 +360,13 @@ async function publishItem({ filePath, cwd, auth, typeOverride, interactive = tr
   // Track in lockfile
   const fileHashes = { [target + fileName]: hashContent(content) }
   updateLockfileItem(cwd, slug, result.version ?? 0, fileHashes)
+  // Persist item metadata for next publish
+  updateItemMeta(cwd, slug, {
+    title,
+    description: description || undefined,
+    tags,
+    section: section || undefined
+  })
 
   return { slug, status: result.status || "published", version: result.version }
 }
@@ -378,33 +440,11 @@ export async function publish(args) {
       process.exit(1)
     }
 
-    // Check if a deck slug already exists in the lockfile
-    const existingLock = readLockfile(cwd)
-    const existingSlug = existingLock.deckSlug
-    let deckPrefix, deckSlug
-
-    const dirName = basename(cwd)
-    const deckBaseSlug = dirName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "")
-
-    if (existingSlug) {
-      console.log(`  ${dim("Previously published as")} ${cyan(existingSlug)}`)
-      console.log()
-      const reuse = await confirm(`  Publish to ${bold(existingSlug)}?`)
-
-      if (reuse) {
-        deckSlug = existingSlug
-        deckPrefix = existingSlug.split("/")[0]
-      } else {
-        deckPrefix = await promptDeckPrefix(cwd, true)
-        deckSlug = `${deckPrefix}/${deckBaseSlug}`
-      }
-    } else {
-      deckPrefix = await promptDeckPrefix(cwd, true)
-      deckSlug = `${deckPrefix}/${deckBaseSlug}`
-    }
+    // Resolve deck slug (= deck identity, used as namespace for all items)
+    const deckSlug = await promptDeckSlug(cwd, true)
 
-    // Persist prefix for next time (slug is saved after successful publish)
-    updateLockfilePublishConfig(cwd, { deckPrefix })
+    // Persist slug early so it's available even if publish fails partway
+    updateLockfilePublishConfig(cwd, { deckSlug })
 
     // Walk public/ to collect assets and build reference set
     const publicDir = join(cwd, "public")
@@ -443,6 +483,9 @@ export async function publish(args) {
       ? readdirSync(slidesDir).filter(f => f.endsWith(".tsx") || f.endsWith(".ts"))
       : []
 
+    // Discover shared source files (src/components/, src/lib/, etc.)
+    const sharedSources = discoverSharedSources(cwd)
+
     const totalItems = publicAssets.length + (hasTheme ? 1 : 0) + layoutEntries.length + slideEntries.length + 1
 
     // Display summary
@@ -451,16 +494,26 @@ export async function publish(args) {
     if (hasTheme) console.log(`    Theme:   1`)
     if (layoutEntries.length) console.log(`    Layouts: ${layoutEntries.length}`)
     console.log(`    Slides:  ${slideEntries.length}`)
+    if (sharedSources.length) console.log(`    Shared:  ${sharedSources.length} ${dim("(bundled with deck)")}`)
     console.log(`    Total:   ${totalItems} items`)
+    // Info if there are slide files on disk not referenced in deck-config.ts
+    const deckConfigSlideCount = deckConfig.slides.length
+    if (deckConfigSlideCount !== slideEntries.length) {
+      console.log()
+      console.log(`  ${dim("ℹ")} deck-config.ts has ${deckConfigSlideCount} slides, ${slideEntries.length} slide files on disk`)
+      console.log(`    ${dim("All slides are published. Only deck-config slides appear in the deck preview.")}`)
+    }
     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):", "")
+    // Collect deck metadata (use stored values as defaults)
+    const storedDeckMeta = readDeckMeta(cwd)
+    const title = await prompt("Title:", storedDeckMeta.title || titleCase(deckSlug))
+    const description = await prompt("Description:", storedDeckMeta.description || "")
+    const storedTagsDefault = storedDeckMeta.tags?.length ? storedDeckMeta.tags.join(", ") : ""
+    const tagsInput = await prompt("Tags (comma-separated):", storedTagsDefault)
     const tags = tagsInput ? tagsInput.split(",").map(t => t.trim()).filter(Boolean) : []
     const releaseNotes = await prompt("Release notes:", "")
 
@@ -500,10 +553,10 @@ export async function publish(args) {
 
     // Read lockfile for skip-if-unchanged
     const lock = readLockfile(cwd)
-    let itemIndex = 0
     let published = 0
     let skipped = 0
     let failed = 0
+    const lockfileUpdates = []
 
     function isUnchanged(slug, fileHashes) {
       const entry = lock.items[slug]
@@ -514,51 +567,66 @@ export async function publish(args) {
       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
-      }
+    const CONCURRENCY = 6
 
-      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 }]
+    async function runParallel(tasks) {
+      const results = []
+      for (let i = 0; i < tasks.length; i += CONCURRENCY) {
+        const batch = tasks.slice(i, i + CONCURRENCY)
+        results.push(...await Promise.allSettled(batch.map(fn => fn())))
       }
+      return results
+    }
+
+    // ── Phase 1: Assets ──
+    let itemIndex = 0
+    const assetTasks = publicAssets.map((asset) => {
+      const myIndex = ++itemIndex
+      return async () => {
+        const assetSlug = assetFileToSlug(deckSlug, 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(`  [${myIndex}/${totalItems}] ${dim("—")} asset ${dim(assetSlug)} (unchanged)`)
+          skipped++
+          return
+        }
+
+        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++
+        try {
+          const result = await publishToRegistry({ type: "asset", slug: assetSlug, title: fileName, files }, auth)
+          console.log(`  [${myIndex}/${totalItems}] ${green("✓")} asset ${cyan(assetSlug)} ${dim(`v${result.version}`)}`)
+          lockfileUpdates.push({ slug: assetSlug, version: result.version ?? 0, fileHashes })
+          published++
+        } catch (err) {
+          console.log(`  [${myIndex}/${totalItems}] ${red("✗")} asset ${dim(assetSlug)}: ${err.message}`)
+          failed++
+        }
       }
-    }
+    })
+    await runParallel(assetTasks)
 
     // ── Phase 2: Theme ──
     if (hasTheme) {
       itemIndex++
-      const themeSlug = `${deckPrefix}/theme`
+      const themeSlug = `${deckSlug}/theme`
       const themePayloadFiles = []
       const themeFileHashes = {}
       let themeContent = ""
@@ -574,7 +642,7 @@ export async function publish(args) {
         console.log(`  [${itemIndex}/${totalItems}] ${dim("—")} theme ${dim(themeSlug)} (unchanged)`)
         skipped++
       } else {
-        const assetDeps = detectAssetDepsInContent(themeContent, deckPrefix, publicFileSet)
+        const assetDeps = detectAssetDepsInContent(themeContent, deckSlug, publicFileSet)
         const npmDeps = detectNpmDeps(themeContent)
 
         try {
@@ -588,7 +656,7 @@ export async function publish(args) {
             promptslideVersion: CLI_VERSION
           }, auth)
           console.log(`  [${itemIndex}/${totalItems}] ${green("✓")} theme ${cyan(themeSlug)} ${dim(`v${result.version}`)}`)
-          updateLockfileItem(cwd, themeSlug, result.version ?? 0, themeFileHashes)
+          lockfileUpdates.push({ slug: themeSlug, version: result.version ?? 0, fileHashes: themeFileHashes })
           published++
         } catch (err) {
           console.log(`  [${itemIndex}/${totalItems}] ${red("✗")} theme ${dim(themeSlug)}: ${err.message}`)
@@ -597,102 +665,128 @@ export async function publish(args) {
       }
     }
 
-    // ── 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) }
+    // ── Phase 3: Layouts (parallel) ──
+    const layoutTasks = layoutEntries.map((layoutFile) => {
+      const myIndex = ++itemIndex
+      return async () => {
+        const layoutName = layoutFile.replace(/\.tsx?$/, "")
+        const layoutSlug = `${deckSlug}/${layoutName}`
+        const content = readFileSync(join(cwd, "src", "layouts", layoutFile), "utf-8")
+        const fileHashes = { [`src/layouts/${layoutFile}`]: hashContent(content) }
+
+        if (isUnchanged(layoutSlug, fileHashes)) {
+          console.log(`  [${myIndex}/${totalItems}] ${dim("—")} layout ${dim(layoutSlug)} (unchanged)`)
+          skipped++
+          return
+        }
 
-      if (isUnchanged(layoutSlug, fileHashes)) {
-        console.log(`  [${itemIndex}/${totalItems}] ${dim("—")} layout ${dim(layoutSlug)} (unchanged)`)
-        skipped++
-        continue
-      }
+        const assetDeps = detectAssetDepsInContent(content, deckSlug, publicFileSet)
+        const npmDeps = detectNpmDeps(content)
+        const regDeps = hasTheme ? [`${deckSlug}/theme`] : []
+        regDeps.push(...assetDeps)
 
-      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,
-          promptslideVersion: CLI_VERSION
-        }, 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++
+        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,
+            promptslideVersion: CLI_VERSION
+          }, auth)
+          console.log(`  [${myIndex}/${totalItems}] ${green("✓")} layout ${cyan(layoutSlug)} ${dim(`v${result.version}`)}`)
+          lockfileUpdates.push({ slug: layoutSlug, version: result.version ?? 0, fileHashes })
+          published++
+        } catch (err) {
+          console.log(`  [${myIndex}/${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) }
+    })
+    await runParallel(layoutTasks)
+
+    // ── Phase 4: Slides (parallel, reuse single capture session) ──
+    const captureSession = canCapture ? await createCaptureSession({ cwd }) : null
+
+    const slideTasks = slideEntries.map((slideFile) => {
+      const myIndex = ++itemIndex
+      return async () => {
+        const slideName = slideFile.replace(/\.tsx?$/, "")
+        const slideSlug = `${deckSlug}/${slideName}`
+        const content = readFileSync(join(cwd, "src", "slides", slideFile), "utf-8")
+        const fileHashes = { [`src/slides/${slideFile}`]: hashContent(content) }
+
+        if (isUnchanged(slideSlug, fileHashes)) {
+          console.log(`  [${myIndex}/${totalItems}] ${dim("—")} slide ${dim(slideSlug)} (unchanged)`)
+          skipped++
+          return
+        }
 
-      if (isUnchanged(slideSlug, fileHashes)) {
-        console.log(`  [${itemIndex}/${totalItems}] ${dim("—")} slide ${dim(slideSlug)} (unchanged)`)
-        skipped++
-        continue
-      }
+        const assetDeps = detectAssetDepsInContent(content, deckSlug, publicFileSet)
+        const layoutDeps = detectRegistryDeps(content).map(d => `${deckSlug}/${d}`)
+        const npmDeps = detectNpmDeps(content)
+        const steps = detectSteps(content)
+        const slideConfig = deckConfig.slides.find(s => s.slug === slideName)
+        const section = slideConfig?.section || undefined
 
-      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 ? [`${deckSlug}/theme`] : []
+        regDeps.push(...layoutDeps, ...assetDeps)
 
-      const regDeps = hasTheme ? [`${deckPrefix}/theme`] : []
-      regDeps.push(...layoutDeps, ...assetDeps)
+        // Generate preview image reusing shared session
+        let slidePreview = null
+        if (captureSession) {
+          slidePreview = await captureSession.capture(`src/slides/${slideFile}`).catch(() => null)
+        }
 
-      // 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,
+            promptslideVersion: CLI_VERSION
+          }, auth)
+          console.log(`  [${myIndex}/${totalItems}] ${green("✓")} slide ${cyan(slideSlug)} ${dim(`v${result.version}`)}`)
+          lockfileUpdates.push({ slug: slideSlug, version: result.version ?? 0, fileHashes })
+          published++
+        } catch (err) {
+          console.log(`  [${myIndex}/${totalItems}] ${red("✗")} slide ${dim(slideSlug)}: ${err.message}`)
+          failed++
+        }
       }
+    })
+    await runParallel(slideTasks)
 
-      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,
-          promptslideVersion: CLI_VERSION
-        }, 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++
-      }
-    }
+    if (captureSession) await captureSession.close()
 
-    // ── Phase 5: Deck manifest ──
+    // ── Phase 5: Deck manifest (includes shared source modules) ──
     itemIndex++
-    const slideSlugs = slideEntries.map(f => `${deckPrefix}/${f.replace(/\.tsx?$/, "")}`)
-    const assetSlugs = publicAssets.map(a => assetFileToSlug(deckPrefix, a.relativePath))
+    const slideSlugs = slideEntries.map(f => `${deckSlug}/${f.replace(/\.tsx?$/, "")}`)
+    const assetSlugs = publicAssets.map(a => assetFileToSlug(deckSlug, a.relativePath))
     const allDeckDeps = [...slideSlugs, ...assetSlugs]
 
+    // Bundle shared source files with the deck item so preview/install can resolve @/ imports
+    const sharedFiles = sharedSources.map(s => ({
+      path: s.fileName,
+      target: s.target,
+      content: readFileSync(s.fullPath, "utf-8")
+    }))
+    if (sharedFiles.length) {
+      console.log(`  ${dim(`Bundling ${sharedFiles.length} shared source file(s) with deck`)}`)
+    }
+
+    // Collect npm deps from shared source files
+    const sharedNpmDeps = {}
+    for (const f of sharedFiles) {
+      Object.assign(sharedNpmDeps, detectNpmDeps(f.content))
+    }
+
     let deckItemId = null
     try {
       const result = await publishToRegistry({
@@ -702,22 +796,38 @@ export async function publish(args) {
         description: description || undefined,
         tags,
         deckConfig,
-        files: [],
+        files: sharedFiles,
+        npmDependencies: Object.keys(sharedNpmDeps).length ? sharedNpmDeps : undefined,
         registryDependencies: allDeckDeps.length ? allDeckDeps : undefined,
         releaseNotes: releaseNotes || undefined,
         previewImage: previewImage || undefined,
         promptslideVersion: CLI_VERSION
       }, auth)
       console.log(`  [${itemIndex}/${totalItems}] ${green("✓")} deck ${cyan(deckSlug)} ${dim(`v${result.version}`)}`)
-      updateLockfileItem(cwd, deckSlug, result.version ?? 0, {})
-      updateLockfilePublishConfig(cwd, { deckSlug })
+      lockfileUpdates.push({ slug: deckSlug, version: result.version ?? 0, fileHashes: {} })
       deckItemId = result.id
       published++
+      // Persist deck metadata for next publish
+      updateDeckMeta(cwd, { title, description: description || undefined, tags })
     } catch (err) {
       console.log(`  [${itemIndex}/${totalItems}] ${red("✗")} deck ${dim(deckSlug)}: ${err.message}`)
       failed++
     }
 
+    // Batch-write all lockfile updates at once
+    const finalLock = readLockfile(cwd)
+    for (const update of lockfileUpdates) {
+      const existing = finalLock.items[update.slug] || {}
+      finalLock.items[update.slug] = {
+        ...existing,
+        version: update.version,
+        installedAt: new Date().toISOString().split("T")[0],
+        files: update.fileHashes
+      }
+    }
+    if (deckItemId) finalLock.deckSlug = deckSlug
+    writeLockfile(cwd, finalLock)
+
     console.log()
     console.log(`  ${bold("Done:")} ${green(`${published} published`)}${skipped ? `, ${skipped} unchanged` : ""}${failed ? `, ${red(`${failed} failed`)}` : ""}`)
     if (auth.organizationSlug && deckItemId) {
@@ -758,12 +868,12 @@ export async function publish(args) {
   }
   console.log()
 
-  // Prompt for deck prefix (required)
-  const deckPrefix = await promptDeckPrefix(cwd, true)
-  const slug = `${deckPrefix}/${baseSlug}`
+  // Prompt for deck slug (required — items are namespaced under the deck)
+  const deck = await promptDeckSlug(cwd, true)
+  const slug = `${deck}/${baseSlug}`
 
-  // Persist prefix for next time
-  updateLockfilePublishConfig(cwd, { deckPrefix })
+  // Persist deck slug for next time
+  updateLockfilePublishConfig(cwd, { deckSlug: deck })
 
   console.log(`  Slug: ${cyan(slug)}`)
   console.log()
@@ -788,7 +898,7 @@ export async function publish(args) {
     const missing = []
 
     for (const depSlug of registryDeps) {
-      const prefixedDepSlug = `${deckPrefix}/${depSlug}`
+      const prefixedDepSlug = `${deck}/${depSlug}`
       const exists = await registryItemExists(prefixedDepSlug, auth)
       if (!exists) {
         missing.push(depSlug)
@@ -826,7 +936,7 @@ export async function publish(args) {
                 auth,
                 typeOverride: depType,
                 interactive: true,
-                deckPrefix
+                deckSlug: deck
               })
               console.log()
               const depVer = result.version ? ` ${dim(`v${result.version}`)}` : ""
@@ -848,12 +958,14 @@ export async function publish(args) {
     }
   }
 
-  // Collect metadata for main item
-  const title = await prompt("Title:", titleCase(baseSlug))
-  const description = await prompt("Description:", "")
-  const tagsInput = await prompt("Tags (comma-separated):", "")
+  // Collect metadata for main item (use stored values as defaults)
+  const storedMeta = readItemMeta(cwd, slug)
+  const title = await prompt("Title:", storedMeta.title || titleCase(baseSlug))
+  const description = await prompt("Description:", storedMeta.description || "")
+  const storedTagsDefault = storedMeta.tags?.length ? storedMeta.tags.join(", ") : ""
+  const tagsInput = await prompt("Tags (comma-separated):", storedTagsDefault)
   const tags = tagsInput ? tagsInput.split(",").map(t => t.trim()).filter(Boolean) : []
-  const section = await prompt("Section:", "")
+  const section = await prompt("Section:", storedMeta.section || "")
   const releaseNotes = await prompt("Release notes:", "")
   const previewImagePath = await prompt("Preview image path (leave empty to auto-generate):", "")
   let previewImage = null
@@ -881,7 +993,7 @@ export async function publish(args) {
   console.log()
 
   // Publish main item
-  const prefixedRegistryDeps = registryDeps.map(d => `${deckPrefix}/${d}`)
+  const prefixedRegistryDeps = registryDeps.map(d => `${deck}/${d}`)
   const payload = {
     type,
     slug,
@@ -911,6 +1023,13 @@ export async function publish(args) {
     // Track in lockfile
     const fileHashes = { [target + fileName]: hashContent(content) }
     updateLockfileItem(cwd, slug, result.version ?? 0, fileHashes)
+    // Persist item metadata for next publish
+    updateItemMeta(cwd, slug, {
+      title,
+      description: description || undefined,
+      tags,
+      section: section || undefined
+    })
   } catch (err) {
     console.error(`  ${red("Error:")} ${err.message}`)
     process.exit(1)

package/src/utils/deck-config.mjs

@@ -6,13 +6,16 @@ const DECK_CONFIG_PATH = "src/deck-config.ts"
 /**
  * Convert a kebab-case filename to PascalCase component name.
  * e.g. "slide-hero-gradient" → "SlideHeroGradient"
+ * e.g. "01-title" → "Slide01Title" (prefixed to ensure valid JS identifier)
  */
 export function toPascalCase(kebab) {
-  return kebab
+  const raw = kebab
     .replace(/\.tsx?$/, "")
     .split("-")
     .map(part => part.charAt(0).toUpperCase() + part.slice(1))
     .join("")
+  // JS identifiers cannot start with a digit — prefix with "Slide"
+  return /^\d/.test(raw) ? `Slide${raw}` : raw
 }
 
 /**
@@ -222,11 +225,20 @@ export function parseDeckConfig(cwd) {
   const content = readFileSync(configPath, "utf-8")
 
   // 1. Parse imports to build componentName -> slug map
-  //    Pattern: import { SlideTitle } from "@/slides/slide-title"
+  //    Handles: import { SlideTitle } from "@/slides/slide-title"
+  //    Handles: import { default as SlideTitle } from "@/slides/slide-title"
+  //    Handles: import { SlideTitle as Alias } from "@/slides/slide-title"
   const componentToSlug = {}
-  const importRegex = /import\s*\{\s*(\w+)\s*\}\s*from\s*["']@\/slides\/([^"']+)["']/g
+  const importRegex = /import\s*\{([^}]+)\}\s*from\s*["']@\/slides\/([^"']+)["']/g
   for (const match of content.matchAll(importRegex)) {
-    componentToSlug[match[1]] = match[2].replace(/\.tsx?$/, "")
+    const importClause = match[1].trim()
+    const slug = match[2].replace(/\.tsx?$/, "")
+    // Handle "X", "X as Y" (use Y), "default as Y" (use Y)
+    const asMatch = importClause.match(/(?:\w+\s+)?as\s+(\w+)/)
+    const componentName = asMatch ? asMatch[1] : importClause.match(/(\w+)/)?.[1]
+    if (componentName) {
+      componentToSlug[componentName] = slug
+    }
   }
 
   // 2. Parse transition exports
@@ -238,20 +250,38 @@ export function parseDeckConfig(cwd) {
   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)
+  // 3. Extract slides array content, then parse entries within it
   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)
+  const slidesArrayMatch = content.match(/export\s+const\s+slides\s*:\s*SlideConfig\[\]\s*=\s*\[/)
+  if (slidesArrayMatch) {
+    const arrayStartIdx = content.indexOf(slidesArrayMatch[0]) + slidesArrayMatch[0].length
+    // Find matching closing bracket
+    let bracketDepth = 1
+    let arrayEndIdx = arrayStartIdx
+    for (let i = arrayStartIdx; i < content.length; i++) {
+      if (content[i] === "[") bracketDepth++
+      if (content[i] === "]") bracketDepth--
+      if (bracketDepth === 0) {
+        arrayEndIdx = i
+        break
+      }
+    }
+    const arrayContent = content.slice(arrayStartIdx, arrayEndIdx)
+
+    // Match entries within the slides array only
+    const entryRegex = /\{([^}]+)\}/g
+    for (const match of arrayContent.matchAll(entryRegex)) {
+      const body = match[1]
+      const componentMatch = body.match(/component:\s*(\w+)/)
+      if (!componentMatch) continue
+      const slug = componentToSlug[componentMatch[1]]
+      if (!slug) continue // layout or unknown import — skip
+      const stepsMatch = body.match(/steps:\s*(\d+)/)
+      const entry = { slug, steps: stepsMatch ? parseInt(stepsMatch[1], 10) : 0 }
+      const sectionMatch = body.match(/section:\s*["']([^"']+)["']/)
+      if (sectionMatch) entry.section = sectionMatch[1]
+      slides.push(entry)
+    }
   }
 
   if (slides.length === 0) return null

package/src/utils/export.mjs

@@ -97,6 +97,74 @@ export async function captureSlideScreenshot({ cwd, slidePath, width = 1280, hei
   }
 }
 
+/**
+ * Create a reusable capture session that shares a single Vite server and browser
+ * instance across multiple screenshot captures.
+ *
+ * @param {{ cwd: string, width?: number, height?: number }} opts
+ * @returns {Promise<{ capture: (slidePath: string) => Promise<string | null>, close: () => Promise<void> } | null>}
+ *   null if Playwright is not available
+ */
+export async function createCaptureSession({ cwd, width = 1280, height = 720 }) {
+  let chromium
+  try {
+    const pw = await import("playwright")
+    chromium = pw.chromium
+  } catch {
+    return null
+  }
+
+  await ensureChromium(chromium)
+  ensureTsConfig(cwd)
+
+  const config = createViteConfig({ cwd, mode: "development" })
+  const server = await createServer({
+    ...config,
+    server: { port: 0, strictPort: false },
+    logLevel: "silent"
+  })
+  await server.listen()
+
+  const address = server.httpServer.address()
+  const port = typeof address === "object" ? address.port : 0
+
+  const browser = await chromium.launch({ headless: true })
+
+  async function capture(slidePath) {
+    const url = `http://localhost:${port}/?export=true&slidePath=${encodeURIComponent(slidePath)}`
+    const page = await browser.newPage({ viewport: { width, height } })
+    try {
+      const errors = []
+      page.on("pageerror", err => errors.push(err.message))
+
+      await page.goto(url, { waitUntil: "domcontentloaded", timeout: 15000 })
+      await page.waitForSelector("[data-export-ready='true']", { timeout: 15000 }).catch(err => {
+        if (errors.length) {
+          throw new Error(`${err.message}\n  Browser errors:\n    ${errors.join("\n    ")}`)
+        }
+        throw err
+      })
+      await page.waitForTimeout(200)
+
+      const element = await page.$("[data-export-ready='true']")
+      const screenshot = await element.screenshot({ type: "png" })
+      return `data:image/png;base64,${screenshot.toString("base64")}`
+    } catch (err) {
+      console.error(`  Screenshot error: ${err.message}`)
+      return null
+    } finally {
+      await page.close().catch(() => {})
+    }
+  }
+
+  async function close() {
+    await browser.close().catch(() => {})
+    await server.close()
+  }
+
+  return { capture, close }
+}
+
 /**
  * Capture a slide and return as base64 data URI.
  * Returns null if Playwright is not available or capture fails.

package/src/utils/registry.mjs

@@ -71,7 +71,9 @@ export function isFileDirty(cwd, relativePath, storedHash) {
  */
 export function updateLockfileItem(cwd, slug, version, files) {
   const lock = readLockfile(cwd)
+  const existing = lock.items[slug] || {}
   lock.items[slug] = {
+    ...existing,
     version,
     installedAt: new Date().toISOString().split("T")[0],
     files
@@ -80,14 +82,60 @@ export function updateLockfileItem(cwd, slug, version, files) {
 }
 
 /**
- * Store publish configuration (deckPrefix, deckSlug) in the lockfile.
+ * Store publish configuration (deckSlug) in the lockfile.
+ * Removes the legacy deckPrefix key if present.
  * @param {string} cwd
- * @param {{ deckPrefix?: string, deckSlug?: string }} config
+ * @param {{ deckSlug?: string }} config
  */
 export function updateLockfilePublishConfig(cwd, config) {
   const lock = readLockfile(cwd)
-  if (config.deckPrefix !== undefined) lock.deckPrefix = config.deckPrefix
   if (config.deckSlug !== undefined) lock.deckSlug = config.deckSlug
+  delete lock.deckPrefix
+  writeLockfile(cwd, lock)
+}
+
+/**
+ * Read stored deck-level publish metadata (title, description, tags).
+ * @param {string} cwd
+ * @returns {{ title?: string, description?: string, tags?: string[] }}
+ */
+export function readDeckMeta(cwd) {
+  const lock = readLockfile(cwd)
+  return lock.deckMeta || {}
+}
+
+/**
+ * Persist deck-level publish metadata so it can be reused as defaults.
+ * @param {string} cwd
+ * @param {{ title?: string, description?: string, tags?: string[] }} meta
+ */
+export function updateDeckMeta(cwd, meta) {
+  const lock = readLockfile(cwd)
+  lock.deckMeta = { ...lock.deckMeta, ...meta }
+  writeLockfile(cwd, lock)
+}
+
+/**
+ * Read stored per-item publish metadata (title, description, tags, section).
+ * @param {string} cwd
+ * @param {string} slug
+ * @returns {{ title?: string, description?: string, tags?: string[], section?: string }}
+ */
+export function readItemMeta(cwd, slug) {
+  const lock = readLockfile(cwd)
+  return lock.items[slug]?.meta || {}
+}
+
+/**
+ * Persist per-item publish metadata alongside the version/files entry.
+ * @param {string} cwd
+ * @param {string} slug
+ * @param {{ title?: string, description?: string, tags?: string[], section?: string }} meta
+ */
+export function updateItemMeta(cwd, slug, meta) {
+  const lock = readLockfile(cwd)
+  if (!lock.items[slug]) lock.items[slug] = {}
+  lock.items[slug].meta = meta
   writeLockfile(cwd, lock)
 }