@nextsparkjs/core 0.1.0-beta.1 → 0.1.0-beta.11

package/scripts/build/registry/generators/feature-registry.mjs

@@ -274,7 +274,7 @@ export interface FeatureEntry {
   key: string
   name: string
   description: string
-  category: 'core' | 'entities' | 'content' | 'settings' | 'admin'
+  category: 'core' | 'entities' | 'content' | 'settings' | 'admin' | 'public'
   icon: string
   tag: string
   testing: FeatureTesting
@@ -284,7 +284,7 @@ export interface FlowEntry {
   key: string
   name: string
   description: string
-  category: 'acquisition' | 'navigation' | 'content' | 'settings' | 'admin'
+  category: 'acquisition' | 'navigation' | 'content' | 'settings' | 'admin' | 'public'
   icon: string
   tag: string
   criticalPath?: boolean
@@ -369,12 +369,15 @@ export type FlowCategory = FlowEntry['category']
 /**
  * Main generator function - orchestrates the full generation
  * @param {string} themeName - Active theme name
- * @param {string} contentsDir - Path to contents directory
+ * @param {string} contentsDir - Path to contents directory (legacy, use config.themesDir instead)
  * @param {string} outputDir - Path for registry output
+ * @param {object} config - Optional configuration object from getConfig()
  * @returns {Object} Generation result
  */
-export async function generateFeatureRegistryFull(themeName, contentsDir, outputDir) {
-  const themePath = join(contentsDir, 'themes', themeName)
+export async function generateFeatureRegistryFull(themeName, contentsDir, outputDir, config = null) {
+  // Use config.themesDir for monorepo support, fall back to contentsDir/themes
+  const themesDir = config?.themesDir || join(contentsDir, 'themes')
+  const themePath = join(themesDir, themeName)
   const testsDir = join(themePath, 'tests', 'cypress', 'e2e')
 
   // Load configs
@@ -385,7 +388,7 @@ export async function generateFeatureRegistryFull(themeName, contentsDir, output
   const blocks = loadBlockSlugs(outputDir)
 
   // Discover tags from tests
-  const rootDir = join(contentsDir, '..')
+  const rootDir = config?.monorepoRoot || join(contentsDir, '..')
   const discoveredTags = discoverTestTags(testsDir, rootDir)
 
   // Validate (includes block tag validation)

package/scripts/build/registry/generators/route-handlers.mjs

@@ -22,9 +22,36 @@
  * @returns {string} Generated TypeScript content
  */
 export function generateRouteHandlersRegistry(plugins, themes, coreRoutes = [], entities = [], config) {
+  // Filter themes by activeTheme if set (monorepo optimization)
+  let filteredThemes = themes
+  let filteredPlugins = plugins
+  let requiredPluginNames = []
+
+  if (config.activeTheme) {
+    // Only include the active theme
+    filteredThemes = themes.filter(t => t.name === config.activeTheme)
+
+    // Get required plugins from the active theme's plugins array
+    const activeTheme = filteredThemes[0]
+    if (activeTheme && activeTheme.plugins && activeTheme.plugins.length > 0) {
+      // plugins can be full names like '@nextsparkjs/plugin-langchain' or just 'langchain'
+      requiredPluginNames = activeTheme.plugins.map(p =>
+        p.replace('@nextsparkjs/plugin-', '').replace(/['"]/g, '')
+      )
+    }
+
+    // Filter plugins to only include required ones by the active theme
+    if (requiredPluginNames.length > 0) {
+      filteredPlugins = plugins.filter(p => requiredPluginNames.includes(p.name))
+    } else {
+      // If no required plugins specified, don't include any plugin routes
+      filteredPlugins = []
+    }
+  }
+
   // Collect all route handlers from themes
   const themeRoutes = []
-  themes.forEach(theme => {
+  filteredThemes.forEach(theme => {
     if (theme.routeFiles && theme.routeFiles.length > 0) {
       theme.routeFiles.forEach(route => {
         const routeKey = route.relativePath === '/' ? '' : route.relativePath
@@ -41,7 +68,7 @@ export function generateRouteHandlersRegistry(plugins, themes, coreRoutes = [],
 
   // Collect all route handlers from plugins
   const pluginRoutes = []
-  plugins.forEach(plugin => {
+  filteredPlugins.forEach(plugin => {
     if (plugin.routeFiles && plugin.routeFiles.length > 0) {
       plugin.routeFiles.forEach(route => {
         const routeKey = route.relativePath === '/' ? '' : route.relativePath

package/scripts/build/registry/generators/translation-registry.mjs

@@ -3,46 +3,213 @@
  *
  * Generates translation-registry.ts
  *
+ * Dynamically discovers available locales by scanning messages/ directories
+ * and filtering against supportedLocales from the active theme's app.config.ts
+ *
  * @module core/scripts/build/registry/generators/translation-registry
  */
 
-import { existsSync, readdirSync } from 'fs'
+import { existsSync, readdirSync, readFileSync, statSync } from 'fs'
 import { join } from 'path'
 
+/**
+ * Extract supportedLocales from a theme's app.config.ts file
+ * Uses regex to parse the TypeScript file without requiring transpilation
+ *
+ * @param {string} themesDir - Path to themes directory
+ * @param {string} activeTheme - Name of the active theme
+ * @returns {string[]} Array of supported locale codes, or empty array if not found
+ */
+function getSupportedLocales(themesDir, activeTheme) {
+  if (!activeTheme) {
+    return []
+  }
+
+  const appConfigPath = join(themesDir, activeTheme, 'config', 'app.config.ts')
+
+  if (!existsSync(appConfigPath)) {
+    return []
+  }
+
+  try {
+    const content = readFileSync(appConfigPath, 'utf8')
+
+    // Match supportedLocales array using regex
+    // Handles formats like: supportedLocales: ['en', 'es', 'fr']
+    // or: supportedLocales: ["en", "es", "fr"]
+    const match = content.match(/supportedLocales\s*:\s*\[([\s\S]*?)\]/)
+
+    if (!match) {
+      return []
+    }
+
+    // Extract individual locale strings from the matched array content
+    const arrayContent = match[1]
+    const localeMatches = arrayContent.match(/['"]([a-zA-Z-]+)['"]/g)
+
+    if (!localeMatches) {
+      return []
+    }
+
+    // Clean up the matches (remove quotes)
+    return localeMatches.map(m => m.replace(/['"]/g, ''))
+  } catch (error) {
+    console.warn(`Warning: Could not read app.config.ts for theme ${activeTheme}: ${error.message}`)
+    return []
+  }
+}
+
+/**
+ * Get available locales for an entity by scanning its messages directory
+ * Only returns locales that exist in the directory AND are in supportedLocales
+ *
+ * @param {string} entityDir - Path to the entity directory
+ * @param {string[]} supportedLocales - Array of supported locale codes from app.config
+ * @returns {string[]} Array of available and supported locale codes
+ */
+function getEntityLocales(entityDir, supportedLocales) {
+  const messagesDir = join(entityDir, 'messages')
+
+  if (!existsSync(messagesDir)) {
+    return []
+  }
+
+  try {
+    const files = readdirSync(messagesDir)
+      .filter(f => f.endsWith('.json'))
+      .map(f => f.replace('.json', ''))
+
+    // Only return locales that exist AND are supported
+    // If supportedLocales is empty, return all found locales (fallback behavior)
+    if (supportedLocales.length === 0) {
+      return files
+    }
+
+    return files.filter(locale => supportedLocales.includes(locale))
+  } catch (error) {
+    return []
+  }
+}
+
+/**
+ * Detect locale entries from a messages directory
+ * Supports both directory pattern (en/, es/ with index.ts) and flat file pattern (en.json, es.json)
+ * Directory pattern takes precedence if both exist
+ *
+ * @param {string} messagesDir - Path to the messages directory
+ * @returns {Array<{locale: string, isDirectory: boolean}>} Detected locales with their type
+ */
+function detectLocales(messagesDir) {
+  if (!existsSync(messagesDir)) {
+    return []
+  }
+
+  const entries = readdirSync(messagesDir)
+  const locales = new Map() // Use Map to ensure directory takes precedence
+
+  entries.forEach(entry => {
+    const entryPath = join(messagesDir, entry)
+    const stat = statSync(entryPath)
+
+    if (stat.isDirectory()) {
+      // Directory pattern: check for index.ts
+      const indexPath = join(entryPath, 'index.ts')
+      if (existsSync(indexPath)) {
+        // Directory pattern takes precedence
+        locales.set(entry, { locale: entry, isDirectory: true })
+      }
+    } else if (entry.endsWith('.json')) {
+      // Flat file pattern (only if directory doesn't exist)
+      const locale = entry.replace(/\.json$/, '')
+      if (!locales.has(locale)) {
+        locales.set(locale, { locale, isDirectory: false })
+      }
+    }
+  })
+
+  return Array.from(locales.values())
+}
+
 /**
  * Generate Translation Registry
  * Auto-generates lazy-loading functions for theme translations
  * Preserves i18n performance (only loads active locale)
  * Ensures ZERO runtime string interpolation in dynamic imports
  *
+ * Dynamically discovers available locales by:
+ * 1. Reading supportedLocales from active theme's app.config.ts
+ * 2. Scanning each entity's messages/ directory for .json files
+ * 3. Only generating loaders for locales that exist AND are supported
+ *
  * @param {Array} themes - Discovered themes
  * @param {object} config - Configuration object from getConfig()
  * @returns {string} Generated TypeScript content
  */
 export function generateTranslationRegistry(themes, config) {
+  // Get supported locales from active theme's app.config.ts
+  const supportedLocales = getSupportedLocales(config.themesDir, config.activeTheme)
+
   // Discover all translation files from themes
   const themeTranslations = []
+  // Discover entity translations
+  const entityTranslations = []
 
   themes.forEach(theme => {
-    const messagesDir = join(config.contentsDir, 'themes', theme.name, 'messages')
-
-    if (existsSync(messagesDir)) {
-      const files = readdirSync(messagesDir)
-      const localeFiles = files.filter(f => f.endsWith('.json') || f.endsWith('.ts'))
-
-      localeFiles.forEach(file => {
-        const locale = file.replace(/\.(json|ts)$/, '')
-        themeTranslations.push({
-          themeName: theme.name,
-          locale,
-          filePath: `@/contents/themes/${theme.name}/messages/${file}`,
-          importKey: `theme_${theme.name.replace(/-/g, '_')}_${locale.replace(/-/g, '_')}`
+    const messagesDir = join(config.themesDir, theme.name, 'messages')
+    const entitiesDir = join(config.themesDir, theme.name, 'entities')
+
+    // Scan theme-level translations
+    const locales = detectLocales(messagesDir)
+    locales.forEach(({ locale, isDirectory }) => {
+      // Filter by supportedLocales if available
+      if (supportedLocales.length > 0 && !supportedLocales.includes(locale)) {
+        return
+      }
+
+      // For directory pattern, import from the directory (index.ts)
+      // For flat file pattern, import the .json file
+      const filePath = isDirectory
+        ? `@/contents/themes/${theme.name}/messages/${locale}`
+        : `@/contents/themes/${theme.name}/messages/${locale}.json`
+
+      themeTranslations.push({
+        themeName: theme.name,
+        locale,
+        filePath,
+        isDirectory,
+        importKey: `theme_${theme.name.replace(/-/g, '_')}_${locale.replace(/-/g, '_')}`
+      })
+    })
+
+    // Scan entity-level translations dynamically
+    // Instead of reading from entity configs, scan the messages/ directory
+    if (existsSync(entitiesDir)) {
+      const entityDirs = readdirSync(entitiesDir).filter(entry => {
+        const entryPath = join(entitiesDir, entry)
+        return statSync(entryPath).isDirectory()
+      })
+
+      entityDirs.forEach(entityName => {
+        const entityDir = join(entitiesDir, entityName)
+
+        // Use getEntityLocales to dynamically discover available locales
+        // This filters by both existence AND supportedLocales
+        const availableLocales = getEntityLocales(entityDir, supportedLocales)
+
+        availableLocales.forEach(locale => {
+          entityTranslations.push({
+            themeName: theme.name,
+            entityName,
+            locale,
+            filePath: `@/contents/themes/${theme.name}/entities/${entityName}/messages/${locale}.json`,
+            importKey: `entity_${theme.name.replace(/-/g, '_')}_${entityName.replace(/-/g, '_')}_${locale.replace(/-/g, '_')}`
+          })
         })
       })
     }
   })
 
-  // Generate loader functions (lazy-loading for performance)
+  // Generate theme loader functions (lazy-loading for performance)
   const loaderEntries = {}
 
   themeTranslations.forEach(translation => {
@@ -60,15 +227,50 @@ export function generateTranslationRegistry(themes, config) {
     })
     .join(',\n')
 
+  // Generate entity loader functions
+  // Structure: { themeName: { entityName: { locale: loader } } }
+  const entityLoaderEntries = {}
+
+  entityTranslations.forEach(translation => {
+    if (!entityLoaderEntries[translation.themeName]) {
+      entityLoaderEntries[translation.themeName] = {}
+    }
+    if (!entityLoaderEntries[translation.themeName][translation.entityName]) {
+      entityLoaderEntries[translation.themeName][translation.entityName] = []
+    }
+    entityLoaderEntries[translation.themeName][translation.entityName].push(
+      `      '${translation.locale}': () => import('${translation.filePath}')`
+    )
+  })
+
+  const entityLoadersCode = Object.entries(entityLoaderEntries)
+    .map(([themeName, entities]) => {
+      const entitiesCode = Object.entries(entities)
+        .map(([entityName, loaders]) => {
+          return `    '${entityName}': {\n${loaders.join(',\n')}\n    }`
+        })
+        .join(',\n')
+      return `  '${themeName}': {\n${entitiesCode}\n  }`
+    })
+    .join(',\n')
+
+  // Count unique entities
+  const uniqueEntities = new Set(entityTranslations.map(t => `${t.themeName}:${t.entityName}`))
+
   return `/**
  * Auto-generated Translation Registry
  *
  * Generated at: ${new Date().toISOString()}
+ * Active theme: ${config.activeTheme || 'none'}
+ * Supported locales: ${supportedLocales.length > 0 ? supportedLocales.join(', ') : 'all (no filter)'}
  * Themes with translations: ${Object.keys(loaderEntries).length}
- * Total translation files: ${themeTranslations.length}
+ * Total theme translation files: ${themeTranslations.length}
+ * Total entity translation files: ${entityTranslations.length}
+ * Total entities with translations: ${uniqueEntities.size}
  *
- * ⚠️ DO NOT EDIT - This file is auto-generated by scripts/build-registry.mjs
+ * DO NOT EDIT - This file is auto-generated by scripts/build-registry.mjs
  *
+ * Locale discovery: Dynamically scans messages/ directories and filters by supportedLocales.
  * ZERO runtime string interpolation - all translation paths resolved at build time.
  * Preserves lazy-loading performance (only loads active locale).
  * Provides build-time validation and type safety.
@@ -87,14 +289,30 @@ export const THEME_TRANSLATION_LOADERS: Record<string, Record<string, Translatio
 ${loadersCode || '  // No theme translations discovered'}
 }
 
+/**
+ * Entity Translation Loaders Registry
+ * Access: ENTITY_TRANSLATION_LOADERS['theme-name']['entity-name']['locale']()
+ *
+ * Returns lazy-loading functions for entity-specific translations.
+ * Structure: theme -> entity -> locale -> loader
+ */
+export const ENTITY_TRANSLATION_LOADERS: Record<string, Record<string, Record<string, TranslationLoader>>> = {
+${entityLoadersCode || '  // No entity translations discovered'}
+}
+
 /**
  * Translation registry metadata
  */
 export const TRANSLATION_METADATA = {
   totalThemes: ${Object.keys(loaderEntries).length},
-  totalTranslations: ${themeTranslations.length},
+  totalThemeTranslations: ${themeTranslations.length},
+  totalEntityTranslations: ${entityTranslations.length},
+  totalEntitiesWithTranslations: ${uniqueEntities.size},
   generatedAt: '${new Date().toISOString()}',
-  themes: [${Object.keys(loaderEntries).map(t => `'${t}'`).join(', ')}]
+  activeTheme: ${config.activeTheme ? `'${config.activeTheme}'` : 'null'},
+  supportedLocales: [${supportedLocales.map(l => `'${l}'`).join(', ')}],
+  themes: [${Object.keys(loaderEntries).map(t => `'${t}'`).join(', ')}],
+  entities: [${Array.from(uniqueEntities).map(e => `'${e}'`).join(', ')}]
 }
 `
 }

package/scripts/build/registry/post-build/page-generator.mjs

@@ -16,8 +16,8 @@ import { cleanupOrphanedTemplates } from './route-cleanup.mjs'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
-// Default rootDir for backwards compatibility (will be overridden by config)
-let rootDir = join(__dirname, '../../../../../..')
+// Default rootDir - use cwd() for NPM compatibility (will be overridden by config.projectRoot if provided)
+let rootDir = process.cwd()
 
 /**
  * Convert string to PascalCase
@@ -203,33 +203,66 @@ function addTemplateResolverToLayout(content, layoutPath) {
 }
 
 /**
- * Duplicate a layout file to (templates) directory with template resolver integration
+ * Duplicate a layout file to (templates) directory
+ * Uses BUILD-TIME resolution: checks if template override exists and generates direct import
+ * NO runtime resolver needed - all decisions made at build time
+ *
+ * @param {string} sourcePath - Path to original layout in app/
+ * @param {string} targetPath - Path to write in app/(templates)/
+ * @param {string} layoutPath - Relative layout path (e.g., 'app/dashboard/layout.tsx')
+ * @param {Array} templates - All discovered templates (for build-time override check)
  */
-async function duplicateLayoutWithTemplateResolver(sourcePath, targetPath, layoutPath) {
+async function duplicateLayoutDirect(sourcePath, targetPath, layoutPath, templates) {
   // Create target directory if it doesn't exist
   const targetDir = dirname(targetPath)
   await mkdir(targetDir, { recursive: true })
 
-  try {
-    // Read the original layout file
-    const originalContent = await readFile(sourcePath, 'utf8')
-
-    // Check if it already uses template resolver
-    if (originalContent.includes('getTemplateOrDefault')) {
-      // Already has template resolver, just copy
-      await writeFile(targetPath, originalContent, 'utf8')
-      return
-    }
+  // BUILD-TIME CHECK: Does a template override exist for this layout?
+  const layoutOverride = templates.find(t =>
+    t.appPath === layoutPath && t.templateType === 'layout'
+  )
+
+  if (layoutOverride) {
+    // Template override exists - generate direct import to it
+    const templatePathWithoutExtension = layoutOverride.templatePath.replace(/\.(tsx|ts)$/, '')
+    const componentName = `Layout${toPascalCase(layoutPath.replace(/[^\w]/g, '_'))}`
+
+    const content = `/**
+ * Layout with template override - directly imports from theme
+ * Template: ${layoutPath}
+ * Override: ${layoutOverride.templatePath}
+ * Generated by: scripts/build-registry.mjs (build-time resolution)
+ */
+import TemplateLayout from '${templatePathWithoutExtension}'
 
-    // Parse the content to add template resolver
-    const modifiedContent = addTemplateResolverToLayout(originalContent, layoutPath)
-    await writeFile(targetPath, modifiedContent, 'utf8')
+export default TemplateLayout
+`
+    await writeFile(targetPath, content, 'utf8')
+    verbose(`Generated layout with template override: ${layoutPath}`)
+    return
+  }
 
+  // No override - copy original layout as-is (simple pass-through)
+  try {
+    const originalContent = await readFile(sourcePath, 'utf8')
+    await writeFile(targetPath, originalContent, 'utf8')
+    verbose(`Copied original layout: ${layoutPath}`)
   } catch (error) {
-    // If parsing fails, generate a basic layout wrapper
-    const componentName = `DuplicatedLayout${toPascalCase(layoutPath.replace(/[^\w]/g, '_'))}`
-    const basicLayoutContent = await generateLayoutPageContent(layoutPath, componentName, null)
-    await writeFile(targetPath, basicLayoutContent, 'utf8')
+    // If reading fails, generate a basic pass-through wrapper
+    const componentName = `PassThroughLayout${toPascalCase(layoutPath.replace(/[^\w]/g, '_'))}`
+    const basicContent = `/**
+ * Basic layout wrapper - maintains Next.js structure
+ * Generated by: scripts/build-registry.mjs
+ */
+interface ${componentName}Props {
+  children: React.ReactNode
+}
+
+export default function ${componentName}({ children }: ${componentName}Props) {
+  return <>{children}</>
+}
+`
+    await writeFile(targetPath, basicContent, 'utf8')
     verbose(`Generated basic layout wrapper for ${layoutPath}`)
   }
 }
@@ -237,8 +270,13 @@ async function duplicateLayoutWithTemplateResolver(sourcePath, targetPath, layou
 /**
  * Generate required parent layouts for a template page
  * Duplicates layouts from app/ to app/(templates)/ to preserve Next.js hierarchy
+ * Uses BUILD-TIME resolution to check for template overrides
+ *
+ * @param {string} appPath - App path (e.g., 'app/dashboard/(main)/posts/page.tsx')
+ * @param {string} templatesDir - Output directory for (templates)
+ * @param {Array} templates - All discovered templates (for build-time override check)
  */
-async function generateRequiredLayouts(appPath, templatesDir) {
+async function generateRequiredLayouts(appPath, templatesDir, templates) {
   let layoutsGenerated = 0
 
   // Extract the directory path from app path (remove filename)
@@ -257,9 +295,9 @@ async function generateRequiredLayouts(appPath, templatesDir) {
 
     // Check if core layout exists and template layout doesn't
     if (existsSync(coreLayoutPath) && !existsSync(templateLayoutPath)) {
-      await duplicateLayoutWithTemplateResolver(coreLayoutPath, templateLayoutPath, layoutPath)
+      // Pass templates for build-time override resolution
+      await duplicateLayoutDirect(coreLayoutPath, templateLayoutPath, layoutPath, templates)
       layoutsGenerated++
-      verbose(`Duplicated layout: ${layoutPath} → (templates)/${currentPath}/layout.tsx`)
     }
   }
 
@@ -310,7 +348,9 @@ export async function generateMissingPages(templates, config = null) {
   const templatesDir = join(rootDir, 'app', '(templates)')
 
   // First, clean up orphaned files before generating new ones
-  await cleanupOrphanedTemplates(templates)
+  // Note: This is also called in registry.mjs before generateMissingPages,
+  // but we keep it here for standalone usage of this function
+  await cleanupOrphanedTemplates(templates, config)
 
   if (templates.length === 0) {
     return
@@ -355,7 +395,8 @@ export async function generateMissingPages(templates, config = null) {
   }
 
   for (const dirPath of uniqueDirectories) {
-    const layoutsGenerated = await generateRequiredLayouts(`${dirPath}/page.tsx`, templatesDir)
+    // Pass templates for build-time override resolution
+    const layoutsGenerated = await generateRequiredLayouts(`${dirPath}/page.tsx`, templatesDir, templates)
     layoutsDuplicated += layoutsGenerated
   }
 

package/scripts/build/registry/post-build/route-cleanup.mjs

@@ -15,13 +15,13 @@ import { log, verbose } from '../../../utils/index.mjs'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
-// Path from packages/core/scripts/build/registry/post-build/ to project root (6 levels up)
-const rootDir = join(__dirname, '../../../../../..')
 
 /**
  * Clean up old generated route files
+ * @param {object} CONFIG - Configuration object from getConfig()
  */
-export async function cleanupOldRouteFiles() {
+export async function cleanupOldRouteFiles(CONFIG) {
+  const rootDir = CONFIG?.projectRoot || process.cwd()
   const appApiDir = join(rootDir, 'app', 'api', 'v1', 'plugin')
 
   try {
@@ -56,8 +56,11 @@ export async function cleanupOldRouteFiles() {
 /**
  * Clean up orphaned template files that no longer have corresponding templates
  * Removes files from app/(templates)/ when their source templates are deleted
+ * @param {object[]} activeTemplates - List of active templates from discovery
+ * @param {object} CONFIG - Configuration object from getConfig()
  */
-export async function cleanupOrphanedTemplates(activeTemplates) {
+export async function cleanupOrphanedTemplates(activeTemplates, CONFIG) {
+  const rootDir = CONFIG?.projectRoot || process.cwd()
   const templatesDir = join(rootDir, 'app', '(templates)')
   if (!existsSync(templatesDir)) {
     return
@@ -136,8 +139,11 @@ export async function cleanupOrphanedTemplates(activeTemplates) {
 /**
  * Map template file path to generated app template path
  * contents/themes/content-buddy/templates/(public)/pricing/page.tsx → app/(templates)/(public)/pricing/page.tsx
+ * @param {string} templateFilePath - Full path to the template file
+ * @param {object} CONFIG - Configuration object from getConfig()
  */
-export function mapTemplateToAppPath(templateFilePath) {
+export function mapTemplateToAppPath(templateFilePath, CONFIG) {
+  const rootDir = CONFIG?.projectRoot || process.cwd()
   // Extract the part after /templates/
   const templatesMatch = templateFilePath.match(/\/themes\/[^\/]+\/templates\/(.+)$/)
   if (!templatesMatch) {
@@ -150,9 +156,12 @@ export function mapTemplateToAppPath(templateFilePath) {
 
 /**
  * Clean up generated template files when original templates are deleted
+ * @param {string} templateFilePath - Full path to the template file
+ * @param {object} CONFIG - Configuration object from getConfig()
  */
-export async function cleanupDeletedTemplate(templateFilePath) {
-  const appTemplatePath = mapTemplateToAppPath(templateFilePath)
+export async function cleanupDeletedTemplate(templateFilePath, CONFIG) {
+  const rootDir = CONFIG?.projectRoot || process.cwd()
+  const appTemplatePath = mapTemplateToAppPath(templateFilePath, CONFIG)
   if (!appTemplatePath || !existsSync(appTemplatePath)) {
     return
   }

package/scripts/build/registry/post-build/test-fixtures.mjs

@@ -103,7 +103,7 @@ export async function generateTestEntitiesJson(entities, themes) {
   }
 
   // Check if tests directory exists
-  const fixturesDir = join(CONFIG.contentsDir, 'themes', activeTheme, 'tests', 'cypress', 'fixtures')
+  const fixturesDir = join(CONFIG.themesDir, activeTheme, 'tests', 'cypress', 'fixtures')
   if (!existsSync(fixturesDir)) {
     verbose(`Test fixtures directory not found for theme "${activeTheme}", skipping`)
     return
@@ -136,10 +136,10 @@ export async function generateTestEntitiesJson(entities, themes) {
         configFilePath = join(entityDir, `${singularName}.config.ts`)
       }
     } else if (entity.themeContext) {
-      entityDir = join(CONFIG.contentsDir, 'themes', entity.themeContext.themeName, 'entities', entity.relativePath)
+      entityDir = join(CONFIG.themesDir, entity.themeContext.themeName, 'entities', entity.relativePath)
       configFilePath = join(entityDir, `${entity.name}.config.ts`)
     } else if (entity.pluginContext) {
-      entityDir = join(CONFIG.contentsDir, 'plugins', entity.pluginContext.pluginName, 'entities', entity.relativePath)
+      entityDir = join(CONFIG.pluginsDir, entity.pluginContext.pluginName, 'entities', entity.relativePath)
       configFilePath = join(entityDir, `${entity.name}.config.ts`)
     }
 
@@ -195,7 +195,7 @@ export async function generateTestBlocksJson(blocks) {
   }
 
   // Check if tests directory exists
-  const fixturesDir = join(CONFIG.contentsDir, 'themes', activeTheme, 'tests', 'cypress', 'fixtures')
+  const fixturesDir = join(CONFIG.themesDir, activeTheme, 'tests', 'cypress', 'fixtures')
   if (!existsSync(fixturesDir)) {
     verbose(`Test fixtures directory not found for theme "${activeTheme}", skipping blocks.json`)
     return

package/scripts/build/registry/watch.mjs

@@ -22,9 +22,9 @@ export async function watchContents(buildRegistries) {
   log('Starting watch mode...', 'info')
 
   const watchPaths = [
-    join(CONFIG.contentsDir, 'plugins'),
+    CONFIG.pluginsDir,
     join(CONFIG.contentsDir, 'entities'),
-    join(CONFIG.contentsDir, 'themes'),
+    CONFIG.themesDir,
     join(CONFIG.contentsDir, 'config')
   ]
 
@@ -101,7 +101,7 @@ export async function watchContents(buildRegistries) {
           // File was deleted (was tracked but no longer exists)
           if (wasTracked && !currentlyExists) {
             log(`Template deleted: ${filename}`, 'info')
-            await cleanupDeletedTemplate(fullTemplatePath)
+            await cleanupDeletedTemplate(fullTemplatePath, CONFIG)
             templateFileTracker.delete(filename)
           }
           // File was added (exists but wasn't tracked)