blocks-dusted 0.1.1 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blocks-dusted",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Manifest-driven CLI for installing reusable Payload CMS blocks.",
   "type": "module",
   "bin": {
@@ -37,4 +37,4 @@
   },
   "homepage": "https://github.com/Hadizainal/blocks-dusted#readme",
   "license": "MIT"
-}
+}

package/src/commands/add.js

@@ -2,12 +2,15 @@ import { access } from 'node:fs/promises'
 import { join } from 'node:path'
 import { checkRequirements } from '../installers/checkRequirements.js'
 import {
+  backupExistingDestination,
   copySharedFiles,
   copyTemplateFiles,
+  plannedBackupPath,
 } from '../installers/copyTemplateFiles.js'
 import { checkDependencies } from '../installers/installDependencies.js'
 import { writeInstalledBlockReadme } from '../installers/writeInstalledBlockReadme.js'
 import { patchPayloadBlocksArray } from '../installers/patchPayloadBlocksArray.js'
+import { patchPayloadConfigCollections } from '../installers/patchPayloadConfigCollections.js'
 import { patchRenderBlocks } from '../installers/patchRenderBlocks.js'
 import { loadTemplateManifest } from '../registry/loadTemplateManifest.js'
 import { validateTemplateManifest } from '../registry/validateTemplateManifest.js'
@@ -23,7 +26,7 @@ export async function addTemplate({
 }) {
   if (!templateName) {
     throw new Error(
-      'A block name is required. Example: blocks-dusted add DD-Hero --dry-run',
+      'A template name is required. Example: blocks-dusted add DD-Hero --dry-run',
     )
   }
 
@@ -32,6 +35,9 @@ export async function addTemplate({
   await validateManifestSourceFiles({ manifest, templateDirectory, packageRoot })
   const checks = await checkRequirements({ manifest, targetDirectory })
   const dependencyChecks = await checkDependencies({ manifest, targetDirectory })
+  const isBlockTemplate = manifest.type === 'block'
+  const isCollectionTemplate = manifest.type === 'collection'
+  const canBackupDestination = manifest.backupExistingDestination === true
 
   if (!dryRun) {
     await validateTargetProject(targetDirectory)
@@ -43,7 +49,7 @@ export async function addTemplate({
     }
   }
 
-  heading('Block')
+  heading('Template')
   info(`Name: ${manifest.name}`)
   if (manifest.sourceName) info(`Source: ${manifest.sourceName}`)
   if (manifest.portableName) info(`Portable name: ${manifest.portableName}`)
@@ -51,7 +57,7 @@ export async function addTemplate({
   info(`Type: ${manifest.type}`)
   info(`Version: ${manifest.version}`)
   info(`Target directory: ${targetDirectory}`)
-  info(`Register: ${noRegister ? 'no' : 'yes'}`)
+  info(`Register: ${isBlockTemplate && !noRegister ? 'yes' : 'no'}`)
   info(`Source template path: ${templateDirectory}`)
   info(`Target install path: ${checks.collisions.destinationPath}`)
 
@@ -98,28 +104,50 @@ export async function addTemplate({
   }
 
   heading('Collision checks')
+  const destinationWillBeBackedUp =
+    checks.collisions.destinationExists && canBackupDestination
   collisionStatus(
-    !checks.collisions.destinationExists,
-    `Destination path: ${checks.collisions.destinationPath}`,
-  )
-  collisionStatus(
-    !checks.collisions.slugFound,
-    `Payload slug: ${manifest.slug}`,
-  )
-  collisionStatus(
-    !checks.collisions.configExportFound,
-    `Config export: ${manifest.exportName ?? manifest.name}`,
-  )
-  collisionStatus(
-    !checks.collisions.interfaceNameFound,
-    `interfaceName: ${manifest.interfaceName ?? manifest.exportName ?? manifest.name}`,
-  )
-  collisionStatus(
-    !checks.collisions.renderBlocksMappingFound,
-    `RenderBlocks mapping: ${manifest.slug}`,
+    !checks.collisions.destinationExists || destinationWillBeBackedUp,
+    destinationWillBeBackedUp
+      ? `Destination path: ${checks.collisions.destinationPath} (will be backed up)`
+      : `Destination path: ${checks.collisions.destinationPath}`,
   )
+  if (isBlockTemplate) {
+    collisionStatus(
+      !checks.collisions.slugFound,
+      `Payload slug: ${manifest.slug}`,
+    )
+    collisionStatus(
+      !checks.collisions.configExportFound,
+      `Config export: ${manifest.exportName ?? manifest.name}`,
+    )
+    collisionStatus(
+      !checks.collisions.interfaceNameFound,
+      `interfaceName: ${manifest.interfaceName ?? manifest.exportName ?? manifest.name}`,
+    )
+    collisionStatus(
+      !checks.collisions.renderBlocksMappingFound,
+      `RenderBlocks mapping: ${manifest.slug}`,
+    )
+  }
+
+  const destinationBackupPath = destinationWillBeBackedUp
+    ? await plannedBackupPath({
+        destinationPath: checks.collisions.destinationPath,
+        targetDirectory,
+      })
+    : null
+
+  if (destinationBackupPath) {
+    heading('Existing destination backup')
+    item(
+      dryRun
+        ? `Would back up existing ${checks.collisions.destinationPath} to ${destinationBackupPath}`
+        : `Existing ${checks.collisions.destinationPath} will be backed up to ${destinationBackupPath}`,
+    )
+  }
 
-  if (checks.collisions.destinationExists) {
+  if (checks.collisions.destinationExists && !canBackupDestination) {
     throw new Error(
       `Refusing to install because ${checks.collisions.destinationPath} already exists.`,
     )
@@ -164,20 +192,37 @@ export async function addTemplate({
       targetDirectory,
       dryRun: true,
     })
-    const dryRunCollectionResults = noRegister
-      ? [{ status: 'skipped', reason: '--no-register was passed' }]
-      : await patchPayloadBlocksArray({
-          manifest,
-          targetDirectory,
-          dryRun: true,
-        })
-    const dryRunRenderBlocksResults = noRegister
-      ? [{ status: 'skipped', reason: '--no-register was passed' }]
-      : await patchRenderBlocks({
-          manifest,
-          targetDirectory,
-          dryRun: true,
-        })
+    const dryRunCollectionResults = registrationResults({
+      isBlockTemplate,
+      manifest,
+      noRegister,
+      registration: 'collection block registration',
+      action: () => patchPayloadBlocksArray({
+        manifest,
+        targetDirectory,
+        dryRun: true,
+      }),
+    })
+    const dryRunPayloadConfigResults = collectionRegistrationResults({
+      isCollectionTemplate,
+      manifest,
+      action: () => patchPayloadConfigCollections({
+        manifest,
+        targetDirectory,
+        dryRun: true,
+      }),
+    })
+    const dryRunRenderBlocksResults = registrationResults({
+      isBlockTemplate,
+      manifest,
+      noRegister,
+      registration: 'RenderBlocks registration',
+      action: () => patchRenderBlocks({
+        manifest,
+        targetDirectory,
+        dryRun: true,
+      }),
+    })
 
     heading('Dry-run shared file results')
     if (dryRunSharedResults.length === 0) item('None')
@@ -186,12 +231,16 @@ export async function addTemplate({
         `${result.status}: ${result.to}${result.reason ? ` - ${result.reason}` : ''}`,
       ),
     )
+    heading('Dry-run Payload config registration')
+    ;(await dryRunPayloadConfigResults).forEach((result) =>
+      item(`${result.status}: ${result.file ?? result.reason}${result.backupPath ? ` (backup: ${result.backupPath})` : ''}`),
+    )
     heading('Dry-run collection registration')
-    dryRunCollectionResults.forEach((result) =>
+    ;(await dryRunCollectionResults).forEach((result) =>
       item(`${result.status}: ${result.file ?? result.reason}`),
     )
     heading('Dry-run RenderBlocks registration')
-    dryRunRenderBlocksResults.forEach((result) =>
+    ;(await dryRunRenderBlocksResults).forEach((result) =>
       item(`${result.status}: ${result.file ?? result.reason}`),
     )
     info('Dry run complete: no files were changed.')
@@ -204,24 +253,45 @@ export async function addTemplate({
     targetDirectory,
   })
 
+  const actualDestinationBackupPath = checks.collisions.destinationExists
+    ? await backupExistingDestination({
+        destinationPath: checks.collisions.destinationPath,
+        targetDirectory,
+      })
+    : null
+
   const copiedFiles = await copyTemplateFiles({
     manifest,
     templateDirectory,
     targetDirectory,
   })
 
-  const collectionResults = noRegister
-    ? [{ status: 'skipped', reason: '--no-register was passed' }]
-    : await patchPayloadBlocksArray({ manifest, targetDirectory })
-  const renderBlocksResults = noRegister
-    ? [{ status: 'skipped', reason: '--no-register was passed' }]
-    : await patchRenderBlocks({ manifest, targetDirectory })
+  const payloadConfigResults = await collectionRegistrationResults({
+    isCollectionTemplate,
+    manifest,
+    action: () => patchPayloadConfigCollections({ manifest, targetDirectory }),
+  })
+  const collectionResults = await registrationResults({
+    isBlockTemplate,
+    manifest,
+    noRegister,
+    registration: 'collection block registration',
+    action: () => patchPayloadBlocksArray({ manifest, targetDirectory }),
+  })
+  const renderBlocksResults = await registrationResults({
+    isBlockTemplate,
+    manifest,
+    noRegister,
+    registration: 'RenderBlocks registration',
+    action: () => patchRenderBlocks({ manifest, targetDirectory }),
+  })
   const readmePath = await writeInstalledBlockReadme({
     manifest,
     targetDirectory,
     copiedFiles,
     sharedResults,
     dependencyChecks,
+    payloadConfigResults,
     collectionResults,
     renderBlocksResults,
     packageManager: dependencyChecks.packageManager,
@@ -236,6 +306,13 @@ export async function addTemplate({
 
   heading('Copied files')
   copiedFiles.forEach((file) => item(file))
+  if (actualDestinationBackupPath) {
+    heading('Existing destination backup')
+    item(actualDestinationBackupPath)
+    item(
+      `Review ${actualDestinationBackupPath} and copy any project-specific RichText behaviour missing from the newly installed ${checks.collisions.destinationPath}.`,
+    )
+  }
   heading('Shared file results')
   if (sharedResults.length === 0) item('None')
   sharedResults.forEach((result) =>
@@ -249,6 +326,12 @@ export async function addTemplate({
     item(
       `Run manually: ${installCommandText(dependencyChecks.packageManager, dependencyChecks.missing)}`,
     )
+  heading('Payload config registration')
+  payloadConfigResults.forEach((result) =>
+    item(
+      `${result.status}: ${result.file ?? result.reason}${result.backupPath ? ` (backup: ${result.backupPath})` : ''}`,
+    ),
+  )
   heading('Collection registration')
   collectionResults.forEach((result) =>
     item(
@@ -270,6 +353,21 @@ export async function addTemplate({
   )
 }
 
+function collectionRegistrationResults({ isCollectionTemplate, manifest, action }) {
+  if (!isCollectionTemplate) {
+    return [{ status: 'skipped', reason: `${manifest.type} templates do not use Payload config collection registration` }]
+  }
+  return action()
+}
+
+function registrationResults({ isBlockTemplate, manifest, noRegister, registration, action }) {
+  if (!isBlockTemplate) {
+    return [{ status: 'skipped', reason: `${manifest.type} templates do not use ${registration}` }]
+  }
+  if (noRegister) return [{ status: 'skipped', reason: '--no-register was passed' }]
+  return action()
+}
+
 function formatDependency(dependency) {
   return typeof dependency === 'string'
     ? dependency
@@ -324,4 +422,4 @@ async function validateManifestSourceFiles({ manifest, templateDirectory, packag
   if (missing.length > 0) {
     throw new Error(`Manifest source files are missing:\n${missing.map((file) => `- ${file}`).join('\n')}`)
   }
-}
+}

package/src/commands/list.js

@@ -3,7 +3,7 @@ import { heading, info, item } from '../utils/logger.js'
 
 export async function list() {
   const templates = await listTemplates()
-  heading('Available blocks')
+  heading('Available templates')
 
   if (templates.length === 0) {
     item('None')
@@ -15,4 +15,4 @@ export async function list() {
   }
 
   info(`Total: ${templates.length}`)
-}
+}

package/src/installers/checkRequirements.js

@@ -48,6 +48,7 @@ function contains(files, text) {
 
 function commonDestination(files) {
   if (files.length === 0) return '.'
+  if (files.length === 1) return files[0].to
   return dirname(files[0].to)
 }
 

package/src/installers/copyTemplateFiles.js

@@ -1,5 +1,5 @@
 import { constants } from 'node:fs'
-import { access, copyFile, cp, mkdir, readFile, stat } from 'node:fs/promises'
+import { access, copyFile, cp, mkdir, readFile, rename, stat } from 'node:fs/promises'
 import { dirname, join } from 'node:path'
 
 export async function copyTemplateFiles({ manifest, templateDirectory, targetDirectory }) {
@@ -17,6 +17,17 @@ export async function copyTemplateFiles({ manifest, templateDirectory, targetDir
   return copiedFiles
 }
 
+export async function backupExistingDestination({ destinationPath, targetDirectory }) {
+  const targetPath = join(targetDirectory, destinationPath)
+  const backupPath = await nextBackupPath(targetPath)
+  await rename(targetPath, backupPath)
+  return backupPath
+}
+
+export async function plannedBackupPath({ destinationPath, targetDirectory }) {
+  return nextBackupPath(join(targetDirectory, destinationPath))
+}
+
 export async function copySharedFiles({ manifest, packageRoot, targetDirectory, dryRun = false }) {
   const results = []
   const sharedFiles = manifest.sharedFiles ?? []
@@ -54,6 +65,16 @@ export async function copySharedFiles({ manifest, packageRoot, targetDirectory,
   return results
 }
 
+async function nextBackupPath(path) {
+  let candidate = `${path}.bak`
+  let index = 1
+  while (await pathExists(candidate)) {
+    candidate = `${path}.bak.${index}`
+    index += 1
+  }
+  return candidate
+}
+
 async function collisionReason(sourcePath, targetPath) {
   try {
     const [sourceStats, targetStats] = await Promise.all([stat(sourcePath), stat(targetPath)])
@@ -76,4 +97,4 @@ async function pathExists(path) {
   } catch {
     return false
   }
-}
+}

package/src/installers/patchPayloadConfigCollections.js

@@ -0,0 +1,92 @@
+import { access, copyFile, readFile, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+export async function patchPayloadConfigCollections({ manifest, targetDirectory, dryRun = false }) {
+  const registration = manifest.payloadConfigRegistration ?? {}
+  if (registration.enabled === false) {
+    return [{ status: 'skipped', reason: 'Payload config registration disabled by manifest' }]
+  }
+
+  const file = await findPayloadConfig(targetDirectory)
+  if (!file) return [{ status: 'skipped', reason: 'No payload.config.ts or payload.config.js found' }]
+
+  const exportName = registration.exportName ?? manifest.exportName ?? manifest.name
+  const importPath = registration.importPath ?? `./collections/${manifest.name}`
+  const content = await readFile(file, 'utf8')
+  const patched = patchPayloadConfigContent(content, { exportName, importPath })
+
+  if (!patched.changed) return [{ file, status: 'skipped', reason: patched.reason }]
+
+  const backupPath = await nextBackupPath(file)
+  if (!dryRun) {
+    await copyFile(file, backupPath)
+    await writeFile(file, patched.content)
+  }
+
+  return [{ file, status: dryRun ? 'would-patch' : 'patched', backupPath }]
+}
+
+async function findPayloadConfig(targetDirectory) {
+  for (const fileName of ['payload.config.ts', 'payload.config.js', 'src/payload.config.ts', 'src/payload.config.js']) {
+    const file = join(targetDirectory, fileName)
+    if (await exists(file)) return file
+  }
+  return null
+}
+
+function patchPayloadConfigContent(content, { exportName, importPath }) {
+  if (content.includes(importPath) && content.includes(exportName)) {
+    return { changed: false, reason: 'Collection already appears to be registered' }
+  }
+
+  const match = selectCollectionsArray(content)
+  if (!match) return { changed: false, reason: 'No clear Payload collections array found' }
+  if (match.items.includes(exportName)) return { changed: false, reason: 'Collection already exists in collections array' }
+
+  const importLine = `import { ${exportName} } from '${importPath}'\n`
+  const nextWithImport = content.includes(importPath) ? content : insertImport(content, importLine)
+  const adjustedMatch = selectCollectionsArray(nextWithImport)
+  if (!adjustedMatch) return { changed: false, reason: 'No clear Payload collections array found after import insertion' }
+
+  const existingItems = adjustedMatch.items.replace(/,\s*$/, '').trim()
+  const insertion = existingItems
+    ? `collections: [${existingItems}, ${exportName}]`
+    : `collections: [${exportName}]`
+  const next = `${nextWithImport.slice(0, adjustedMatch.start)}${insertion}${nextWithImport.slice(adjustedMatch.end)}`
+  return { changed: next !== content, content: next }
+}
+
+function insertImport(content, importLine) {
+  const importMatches = [...content.matchAll(/^import .+$/gm)]
+  if (importMatches.length === 0) return `${importLine}${content}`
+  const last = importMatches[importMatches.length - 1]
+  const insertAt = last.index + last[0].length
+  return `${content.slice(0, insertAt)}\n${importLine}${content.slice(insertAt)}`
+}
+
+function selectCollectionsArray(content) {
+  const matches = [...content.matchAll(/collections:\s*\[([\s\S]*?)\]/gm)].map((match) => ({
+    start: match.index,
+    end: match.index + match[0].length,
+    items: match[1],
+  }))
+  if (matches.length !== 1) return null
+  return matches[0]
+}
+
+async function nextBackupPath(file) {
+  const base = `${file}.bak`
+  if (!(await exists(base))) return base
+  let index = 1
+  while (await exists(`${base}.${index}`)) index += 1
+  return `${base}.${index}`
+}
+
+async function exists(path) {
+  try {
+    await access(path)
+    return true
+  } catch {
+    return false
+  }
+}

package/src/installers/writeInstalledBlockReadme.js

@@ -7,18 +7,20 @@ export async function writeInstalledBlockReadme({
   copiedFiles,
   sharedResults,
   dependencyChecks,
+  payloadConfigResults = [],
   collectionResults,
   renderBlocksResults,
   packageManager,
   installCommand,
 }) {
-  const readmePath = join(targetDirectory, 'src', 'blocks', manifest.name, 'README.md')
+  const readmePath = join(targetDirectory, destinationDirectory(manifest.files), 'README.md')
   await mkdir(dirname(readmePath), { recursive: true })
   await writeFile(readmePath, renderReadme({
     manifest,
     copiedFiles,
     sharedResults,
     dependencyChecks,
+    payloadConfigResults,
     collectionResults,
     renderBlocksResults,
     packageManager,
@@ -32,6 +34,7 @@ function renderReadme({
   copiedFiles,
   sharedResults,
   dependencyChecks,
+  payloadConfigResults = [],
   collectionResults,
   renderBlocksResults,
   packageManager,
@@ -42,6 +45,7 @@ function renderReadme({
 
   return `# ${manifest.name}
 
+Template type: \`${manifest.type}\`
 Payload slug: \`${manifest.slug}\`
 
 ## Files installed
@@ -66,6 +70,10 @@ Install missing dependencies manually:
 ${dependencyCommand}
 \`\`\`
 
+## Payload config registration status
+
+${list(payloadConfigResults.map(formatPatchResult))}
+
 ## Collection registration status
 
 ${list(collectionResults.map(formatPatchResult))}
@@ -88,17 +96,22 @@ ${generatorPrefix} generate:importmap
 ## Copy-paste Codex prompt for finishing integration
 
 \`\`\`text
-Review the installed ${manifest.name} block integration.
+Review the installed ${manifest.name} ${manifest.type} integration.
 Only fix issues directly related to ${manifest.name}.
 Check imports, Pages collection, Posts collection, RenderBlocks, shared utilities, shared components, and missing dependencies.
 Run Payload generators manually if schema or admin imports changed.
 Do not rewrite unrelated application logic.
 Do not change environment files.
-Do not rewrite routes unless explicitly required by the block README.
+Do not rewrite routes unless explicitly required by the installed README.
 \`\`\`
 `
 }
 
+function destinationDirectory(files) {
+  if (!files || files.length === 0) return '.'
+  return dirname(files[0].to)
+}
+
 function formatDependency(dependency) {
   return `${dependency.name}${dependency.version ? `@${dependency.version}` : ''}`
 }
@@ -114,4 +127,4 @@ function manualSteps(manifest) {
 function list(values) {
   if (!values || values.length === 0) return '- None'
   return values.map((value) => `- ${value}`).join('\n')
-}
+}

package/src/registry/listTemplates.js

@@ -1,17 +1,26 @@
 import { readdir } from 'node:fs/promises'
+import { join } from 'node:path'
 import { loadTemplateManifest } from './loadTemplateManifest.js'
 import { validateTemplateManifest } from './validateTemplateManifest.js'
-import { blocksDirectory } from '../utils/paths.js'
+import { templateDirectories } from '../utils/paths.js'
 
 export async function listTemplates() {
-  const entries = await readdir(blocksDirectory, { withFileTypes: true })
   const templates = []
 
-  for (const entry of entries.filter((item) => item.isDirectory())) {
-    const { manifest } = await loadTemplateManifest(entry.name)
-    validateTemplateManifest(manifest)
-    templates.push(manifest)
+  for (const directory of templateDirectories) {
+    let entries = []
+    try {
+      entries = await readdir(directory.path, { withFileTypes: true })
+    } catch {
+      continue
+    }
+
+    for (const entry of entries.filter((item) => item.isDirectory())) {
+      const { manifest } = await loadTemplateManifest(entry.name)
+      validateTemplateManifest(manifest)
+      templates.push(manifest)
+    }
   }
 
   return templates.sort((a, b) => a.name.localeCompare(b.name))
-}
+}

package/src/registry/loadTemplateManifest.js

@@ -1,20 +1,29 @@
 import { readFile } from 'node:fs/promises'
 import { join } from 'node:path'
-import { blocksDirectory } from '../utils/paths.js'
+import { templateDirectories } from '../utils/paths.js'
 import { isSafeTemplateName } from '../utils/strings.js'
 
 export async function loadTemplateManifest(templateName) {
   if (!isSafeTemplateName(templateName)) throw new Error(`Invalid template name: ${templateName}`)
 
-  const templateDirectory = join(blocksDirectory, templateName)
-  const manifestPath = join(templateDirectory, 'manifest.json')
+  const misses = []
 
-  try {
-    const manifest = JSON.parse(await readFile(manifestPath, 'utf8'))
-    return { manifest, manifestPath, templateDirectory }
-  } catch (error) {
-    if (error.code === 'ENOENT') throw new Error(`Template not found: ${templateName}`)
-    if (error instanceof SyntaxError) throw new Error(`Invalid JSON in ${manifestPath}: ${error.message}`)
-    throw error
+  for (const directory of templateDirectories) {
+    const templateDirectory = join(directory.path, templateName)
+    const manifestPath = join(templateDirectory, 'manifest.json')
+
+    try {
+      const manifest = JSON.parse(await readFile(manifestPath, 'utf8'))
+      return { manifest, manifestPath, templateDirectory }
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        misses.push(manifestPath)
+        continue
+      }
+      if (error instanceof SyntaxError) throw new Error(`Invalid JSON in ${manifestPath}: ${error.message}`)
+      throw error
+    }
   }
-}
+
+  throw new Error(`Template not found: ${templateName}`)
+}

package/src/registry/validateTemplateManifest.js

@@ -1,4 +1,5 @@
 const REQUIRED_STRINGS = ['name', 'type', 'slug', 'version']
+const TEMPLATE_TYPES = new Set(['block', 'component', 'collection'])
 const OPTIONAL_ARRAYS = [
   'files',
   'requiredProjectFiles',
@@ -14,13 +15,13 @@ const OPTIONAL_ARRAYS = [
 export function validateTemplateManifest(manifest) {
   const errors = []
   if (!manifest || typeof manifest !== 'object' || Array.isArray(manifest)) {
-    throw new Error('Block manifest must be a JSON object.')
+    throw new Error('Template manifest must be a JSON object.')
   }
 
   for (const key of REQUIRED_STRINGS) {
     if (typeof manifest[key] !== 'string' || manifest[key].trim() === '') errors.push(`${key} must be a non-empty string`)
   }
-  if (manifest.type !== 'block') errors.push('type must be "block"')
+  if (!TEMPLATE_TYPES.has(manifest.type)) errors.push('type must be one of: block, component, collection')
   if (manifest.label !== undefined && typeof manifest.label !== 'string') errors.push('label must be a string when present')
   if (manifest.sourceName !== undefined && typeof manifest.sourceName !== 'string') errors.push('sourceName must be a string when present')
   if (manifest.portableName !== undefined && typeof manifest.portableName !== 'string') errors.push('portableName must be a string when present')
@@ -33,7 +34,7 @@ export function validateTemplateManifest(manifest) {
   if (!Array.isArray(manifest.files)) errors.push('files must be an array')
   if (manifest.source !== undefined && (!manifest.source || typeof manifest.source !== 'object' || Array.isArray(manifest.source))) errors.push('source must be an object when present')
   if (manifest.patchTargets !== undefined && (!manifest.patchTargets || typeof manifest.patchTargets !== 'object' || Array.isArray(manifest.patchTargets))) errors.push('patchTargets must be an object when present')
-  for (const key of ['collectionRegistration', 'renderBlocksRegistration', 'renderBlocksBehavior', 'pageRouteIntegration']) {
+  for (const key of ['collectionRegistration', 'renderBlocksRegistration', 'renderBlocksBehavior', 'pageRouteIntegration', 'payloadConfigRegistration']) {
     if (manifest[key] !== undefined && (!manifest[key] || typeof manifest[key] !== 'object' || Array.isArray(manifest[key]))) errors.push(`${key} must be an object when present`)
   }
 
@@ -64,6 +65,6 @@ export function validateTemplateManifest(manifest) {
     })
   }
 
-  if (errors.length > 0) throw new Error(`Invalid block manifest:\n- ${errors.join('\n- ')}`)
+  if (errors.length > 0) throw new Error(`Invalid template manifest:\n- ${errors.join('\n- ')}`)
   return manifest
-}
+}