@nextsparkjs/core 0.1.0-beta.2 → 0.1.0-beta.21

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

@@ -3,12 +3,94 @@
  *
  * 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, statSync } 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)
@@ -54,23 +136,36 @@ function detectLocales(messagesDir) {
  * 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')
-    const entitiesDir = join(config.contentsDir, 'themes', theme.name, 'entities')
+    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
@@ -86,7 +181,8 @@ export function generateTranslationRegistry(themes, config) {
       })
     })
 
-    // Scan entity-level translations
+    // 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)
@@ -94,21 +190,21 @@ export function generateTranslationRegistry(themes, config) {
       })
 
       entityDirs.forEach(entityName => {
-        const entityMessagesDir = join(entitiesDir, entityName, 'messages')
-        if (existsSync(entityMessagesDir)) {
-          const entityLocaleFiles = readdirSync(entityMessagesDir).filter(f => f.endsWith('.json'))
-
-          entityLocaleFiles.forEach(file => {
-            const locale = file.replace(/\.json$/, '')
-            entityTranslations.push({
-              themeName: theme.name,
-              entityName,
-              locale,
-              filePath: `@/contents/themes/${theme.name}/entities/${entityName}/messages/${file}`,
-              importKey: `entity_${theme.name.replace(/-/g, '_')}_${entityName.replace(/-/g, '_')}_${locale.replace(/-/g, '_')}`
-            })
+        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, '_')}`
           })
-        }
+        })
       })
     }
   })
@@ -165,6 +261,8 @@ export function generateTranslationRegistry(themes, config) {
  * 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 theme translation files: ${themeTranslations.length}
  * Total entity translation files: ${entityTranslations.length}
@@ -172,6 +270,7 @@ export function generateTranslationRegistry(themes, config) {
  *
  * 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.
@@ -210,6 +309,8 @@ export const TRANSLATION_METADATA = {
   totalEntityTranslations: ${entityTranslations.length},
   totalEntitiesWithTranslations: ${uniqueEntities.size},
   generatedAt: '${new Date().toISOString()}',
+  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)

package/scripts/build/registry.mjs

@@ -20,7 +20,14 @@ import { join, dirname, resolve } from 'path'
 import { fileURLToPath } from 'url'
 import { existsSync } from 'fs'
 import dotenv from 'dotenv'
-dotenv.config({ override: true })
+
+// Load .env from the correct project root
+// Priority: NEXTSPARK_PROJECT_ROOT env var > cwd
+// This is critical for npm mode where cwd might be node_modules/@nextsparkjs/core
+const envPath = process.env.NEXTSPARK_PROJECT_ROOT
+  ? join(process.env.NEXTSPARK_PROJECT_ROOT, '.env')
+  : undefined
+dotenv.config({ path: envPath, override: true })
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
@@ -68,7 +75,8 @@ import {
   displayTreeStructure,
   generateTestEntitiesJson,
   generateTestBlocksJson,
-  cleanupOldRouteFiles
+  cleanupOldRouteFiles,
+  cleanupOrphanedTemplates
 } from './registry/post-build/index.mjs'
 import { watchContents } from './registry/watch.mjs'
 
@@ -198,7 +206,10 @@ export async function buildRegistries(projectRoot = null) {
     displayTreeStructure(plugins, entities, themes)
 
     // Clean up old generated route files first
-    await cleanupOldRouteFiles()
+    await cleanupOldRouteFiles(CONFIG)
+
+    // Clean up orphaned template files from previous theme builds
+    await cleanupOrphanedTemplates(templates, CONFIG)
 
     // Hoist plugin dependencies to root workspace for proper resolution
     // Generate all registry files (use aggregated entities for entity registry + blocks)
@@ -217,7 +228,8 @@ export async function buildRegistries(projectRoot = null) {
       const featureResult = await generateFeatureRegistryFull(
         CONFIG.activeTheme,
         CONFIG.contentsDir,
-        CONFIG.outputDir
+        CONFIG.outputDir,
+        CONFIG
       )
 
       // Write testing-registry.ts
@@ -261,7 +273,7 @@ export async function buildRegistries(projectRoot = null) {
     log('Registry System built successfully!', 'success')
     console.log(`📊 Stats:`)
     console.log(`   Plugins: ${plugins.length}`)
-    console.log(`   Entities: ${entities.length}`)
+    console.log(`   Entities: ${allEntities.length}`)
     console.log(`   Themes: ${themes.length}`)
     console.log(`   Templates: ${templates.length}`)
     console.log(`   Blocks: ${blocks.length}`)

package/templates/app/(public)/[...slug]/page.tsx

@@ -15,12 +15,12 @@
 
 import { notFound } from 'next/navigation'
 import { query } from '@nextsparkjs/core/lib/db'
-import { PageRenderer } from '@/app/components/page-renderer'
+import { PageRenderer } from '@nextsparkjs/core/components/public/pageBuilder'
 import {
   matchPathToEntity,
   getEntityBasePath,
 } from '@nextsparkjs/core/lib/entities/schema-generator'
-import { ENTITY_REGISTRY } from '@nextsparkjs/core/lib/entities/queries'
+import { getEntityRegistry } from '@nextsparkjs/core/lib/entities/queries'
 import { TemplateService } from '@nextsparkjs/core/lib/services/template.service'
 import { resolvePublicEntityFromUrl } from '@nextsparkjs/core/lib/api/entity/public-resolver'
 import { PublicEntityGrid } from '@nextsparkjs/core/components/public/entities/PublicEntityGrid'
@@ -28,11 +28,12 @@ import type { EntityConfig } from '@nextsparkjs/core/lib/entities/types'
 import type { Metadata } from 'next'
 
 /**
- * Convert ENTITY_REGISTRY to format expected by matchPathToEntity
+ * Convert entity registry to format expected by matchPathToEntity
  */
 function getEntityConfigs(): Record<string, EntityConfig> {
+  const registry = getEntityRegistry()
   const configs: Record<string, EntityConfig> = {}
-  for (const [key, entry] of Object.entries(ENTITY_REGISTRY)) {
+  for (const [key, entry] of Object.entries(registry)) {
     configs[key] = entry.config as EntityConfig
   }
   return configs

package/templates/app/accept-invite/[token]/page.tsx

@@ -68,9 +68,9 @@ export default function AcceptInvitePage() {
         }
 
         // Check email match
-        if (user.email.toLowerCase() !== data.data.email.toLowerCase()) {
+        if (!user.email || user.email.toLowerCase() !== data.data.email.toLowerCase()) {
           setStatus('email_mismatch')
-          setErrorMessage(`This invitation was sent to ${data.data.email}, but you are logged in as ${user.email}`)
+          setErrorMessage(`This invitation was sent to ${data.data.email}, but you are logged in as ${user.email || 'unknown'}`)
           return
         }
 

package/templates/app/api/devtools/config/entities/route.ts

@@ -1,6 +1,12 @@
-import { auth } from "@nextsparkjs/core/lib/auth";
+import { getTypedSession } from "@nextsparkjs/core/lib/auth";
 import { NextResponse } from "next/server";
-import { ENTITY_REGISTRY } from "@nextsparkjs/registries/entity-registry";
+import { getEntityRegistry } from "@nextsparkjs/core/lib/entities/queries";
+import type { EntityConfig, ChildEntityDefinition } from "@nextsparkjs/core/lib/entities/types";
+
+// Type guard to check if entity is a full EntityConfig
+function isEntityConfig(entity: EntityConfig | ChildEntityDefinition): entity is EntityConfig {
+  return 'slug' in entity
+}
 
 /**
  * Entity information structure
@@ -39,7 +45,7 @@ interface EntityInfo {
 export async function GET(request: Request) {
   try {
     // Verify developer role
-    const session = await auth.api.getSession({ headers: request.headers });
+    const session = await getTypedSession(request.headers);
 
     if (!session?.user || session.user.role !== "developer") {
       return NextResponse.json(
@@ -53,9 +59,11 @@ export async function GET(request: Request) {
 
     // Build entity info array
     const entities: EntityInfo[] = [];
+    const registry = getEntityRegistry();
 
-    for (const [, entry] of Object.entries(ENTITY_REGISTRY)) {
+    for (const [, entry] of Object.entries(registry)) {
       const config = entry.config;
+      if (!isEntityConfig(config)) continue;
 
       entities.push({
         slug: config.slug,

package/templates/app/api/devtools/config/theme/route.ts

@@ -1,4 +1,4 @@
-import { auth } from "@nextsparkjs/core/lib/auth";
+import { getTypedSession } from "@nextsparkjs/core/lib/auth";
 import { NextResponse } from "next/server";
 import { ThemeService } from "@nextsparkjs/core/lib/services/theme.service";
 
@@ -11,7 +11,7 @@ import { ThemeService } from "@nextsparkjs/core/lib/services/theme.service";
 export async function GET(request: Request) {
   try {
     // Verify developer role
-    const session = await auth.api.getSession({ headers: request.headers });
+    const session = await getTypedSession(request.headers);
 
     if (!session?.user || session.user.role !== "developer") {
       return NextResponse.json(

package/templates/app/api/devtools/tests/[...path]/route.ts

@@ -1,4 +1,4 @@
-import { auth } from "@nextsparkjs/core/lib/auth";
+import { getTypedSession } from "@nextsparkjs/core/lib/auth";
 import { NextResponse } from "next/server";
 import { readFile, stat } from "fs/promises";
 import { join } from "path";
@@ -18,7 +18,7 @@ export async function GET(
 ) {
   try {
     // Verify developer role
-    const session = await auth.api.getSession({ headers: request.headers });
+    const session = await getTypedSession(request.headers);
 
     if (!session?.user || session.user.role !== "developer") {
       return NextResponse.json(

package/templates/app/api/devtools/tests/route.ts

@@ -1,4 +1,4 @@
-import { auth } from "@nextsparkjs/core/lib/auth";
+import { getTypedSession } from "@nextsparkjs/core/lib/auth";
 import { NextResponse } from "next/server";
 import { readdir, stat } from "fs/promises";
 import { join } from "path";
@@ -61,7 +61,7 @@ async function buildFileTree(dirPath: string, basePath: string): Promise<FileTre
 export async function GET(request: Request) {
   try {
     // Verify developer role
-    const session = await auth.api.getSession({ headers: request.headers });
+    const session = await getTypedSession(request.headers);
 
     if (!session?.user || session.user.role !== "developer") {
       return NextResponse.json(