promptslide 0.3.3 → 0.3.4

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [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.4",
   "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 } 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) {
@@ -228,10 +230,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 +242,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)
@@ -283,7 +285,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,
@@ -378,33 +380,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
+    // Resolve deck slug (= deck identity, used as namespace for all items)
+    const deckSlug = await promptDeckSlug(cwd, true)
 
-    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}`
-    }
-
-    // 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")
@@ -458,7 +438,7 @@ export async function publish(args) {
     console.log()
 
     // Collect deck metadata
-    const title = await prompt("Title:", titleCase(deckBaseSlug))
+    const title = await prompt("Title:", titleCase(deckSlug))
     const description = await prompt("Description:", "")
     const tagsInput = await prompt("Tags (comma-separated):", "")
     const tags = tagsInput ? tagsInput.split(",").map(t => t.trim()).filter(Boolean) : []
@@ -500,10 +480,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 +494,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
+    }
 
-      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 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(`  [${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 +569,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 +583,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,100 +592,110 @@ 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++
+        }
       }
-    }
+    })
+    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
+        }
 
-    // ── 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) }
+        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
 
-      if (isUnchanged(slideSlug, fileHashes)) {
-        console.log(`  [${itemIndex}/${totalItems}] ${dim("—")} slide ${dim(slideSlug)} (unchanged)`)
-        skipped++
-        continue
-      }
+        const regDeps = hasTheme ? [`${deckSlug}/theme`] : []
+        regDeps.push(...layoutDeps, ...assetDeps)
 
-      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 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 ──
     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]
 
     let deckItemId = null
@@ -709,8 +714,7 @@ export async function publish(args) {
         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++
     } catch (err) {
@@ -718,6 +722,18 @@ export async function publish(args) {
       failed++
     }
 
+    // Batch-write all lockfile updates at once
+    const finalLock = readLockfile(cwd)
+    for (const update of lockfileUpdates) {
+      finalLock.items[update.slug] = {
+        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 +774,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 +804,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 +842,7 @@ export async function publish(args) {
                 auth,
                 typeOverride: depType,
                 interactive: true,
-                deckPrefix
+                deckSlug: deck
               })
               console.log()
               const depVer = result.version ? ` ${dim(`v${result.version}`)}` : ""
@@ -881,7 +897,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,

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

@@ -80,14 +80,15 @@ 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)
 }