@nextsparkjs/core 0.1.0-beta.191 → 0.1.0-beta.193

package/scripts/build/registry/discovery/blocks.mjs

@@ -8,13 +8,116 @@
 
 import { readdir, stat, readFile } from 'fs/promises'
 import { join } from 'path'
-import { existsSync } from 'fs'
+import { existsSync, readFileSync } from 'fs'
 
 import { CONFIG as DEFAULT_CONFIG } from '../config.mjs'
 import { log, verbose } from '../../../utils/index.mjs'
+import { loadTypeScriptFor } from '../shared/typescript-compiler.mjs'
 
 /**
- * Discover all blocks in the active theme
+ * How a block's schema.ts exports `schema`, read from its syntax tree (comments, strings and
+ * types don't count). The generated BLOCK_SCHEMAS map imports `schema` by name and the
+ * validation route calls `.parse()` on it, so only a zod schema bound by `const` qualifies:
+ *
+ * - `export const schema = ...`
+ * - `export { schema }` or `export { local as schema }` of a `const` declared in the file
+ *
+ * Anything else is reported with the reason, and the block gets no map entry: `let`/`var`
+ * (reassignable), `function`/`class` (not a schema), `declare` or type-only exports (no
+ * runtime value), a destructured binding, an imported binding or `export ... from`
+ * (declared in another module, so this file doesn't show it is a const).
+ *
+ * @param {string} source - schema.ts content
+ * @param {string} fileName - for the parser (extension picks TS/TSX)
+ * @param {object} ts - the TypeScript compiler API (loadTypeScriptFor)
+ * @returns {{ exportsSchema: true } | { exportsSchema: false, reason: string }}
+ */
+export function readSchemaExport(source, fileName, ts) {
+  const sourceFile = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true, ts.getScriptKindFromFileName(fileName))
+  const K = ts.SyntaxKind
+  const hasModifier = (node, kind) => Boolean(node.modifiers?.some(modifier => modifier.kind === kind))
+  const isConst = statement => (statement.declarationList.flags & ts.NodeFlags.Const) !== 0 && !(statement.declarationList.flags & (ts.NodeFlags.Let | ts.NodeFlags.Using))
+  const kindOf = statement => (statement.declarationList.flags & ts.NodeFlags.Let ? 'let' : isConst(statement) ? 'const' : 'var')
+
+  // Top-level `const` bindings, by name (for `export { local as schema }`), with how each is declared.
+  const locals = new Map()
+  for (const statement of sourceFile.statements) {
+    if (ts.isVariableStatement(statement) && !hasModifier(statement, K.DeclareKeyword)) {
+      for (const declaration of statement.declarationList.declarations) {
+        if (ts.isIdentifier(declaration.name)) locals.set(declaration.name.text, kindOf(statement))
+      }
+    } else if ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) && statement.name) {
+      locals.set(statement.name.text, ts.isFunctionDeclaration(statement) ? 'function' : 'class')
+    } else if (ts.isImportDeclaration(statement) && statement.importClause && !statement.importClause.isTypeOnly) {
+      const { name, namedBindings } = statement.importClause
+      if (name) locals.set(name.text, 'import')
+      if (namedBindings && ts.isNamespaceImport(namedBindings)) locals.set(namedBindings.name.text, 'import')
+      for (const element of namedBindings && ts.isNamedImports(namedBindings) ? namedBindings.elements : []) {
+        if (!element.isTypeOnly) locals.set(element.name.text, 'import')
+      }
+    }
+  }
+
+  const rejected = reason => ({ exportsSchema: false, reason })
+  for (const statement of sourceFile.statements) {
+    if (ts.isVariableStatement(statement) && hasModifier(statement, K.ExportKeyword)) {
+      for (const declaration of statement.declarationList.declarations) {
+        const names = ts.isIdentifier(declaration.name)
+          ? [declaration.name.text]
+          : declaration.name.elements?.map(element => element.name?.getText(sourceFile)) ?? []
+        if (!names.includes('schema')) continue
+        if (hasModifier(statement, K.DeclareKeyword)) return rejected('`schema` is declared with `declare`, so it has no runtime value')
+        if (!ts.isIdentifier(declaration.name)) return rejected('`schema` is exported through a destructuring pattern; write `export const schema = ...`')
+        if (!isConst(statement)) return rejected(`\`schema\` is declared with \`${kindOf(statement)}\`; write \`export const schema = ...\``)
+        return { exportsSchema: true }
+      }
+    }
+    if ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) && hasModifier(statement, K.ExportKeyword) && statement.name?.text === 'schema') {
+      return rejected(`\`schema\` is a ${ts.isFunctionDeclaration(statement) ? 'function' : 'class'}, not a zod schema; write \`export const schema = ...\``)
+    }
+    if (ts.isExportDeclaration(statement) && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+      for (const element of statement.exportClause.elements) {
+        if (element.name.text !== 'schema') continue
+        if (statement.isTypeOnly || element.isTypeOnly) continue
+        if (statement.moduleSpecifier) return rejected('`schema` is re-exported from another module; declare it with `export const schema = ...` in schema.ts')
+        const local = (element.propertyName ?? element.name).text
+        const kind = locals.get(local)
+        if (kind === 'const') return { exportsSchema: true }
+        if (kind === 'import') return rejected(`\`schema\` re-exports the imported \`${local}\`; declare it with \`export const schema = ...\` in schema.ts`)
+        if (kind) return rejected(`\`schema\` exports \`${local}\`, declared with \`${kind}\`; only a \`const\` zod schema is validated`)
+        return rejected(`\`schema\` exports \`${local}\`, which is not a runtime binding of schema.ts`)
+      }
+    }
+  }
+  return rejected('schema.ts does not export `schema`')
+}
+
+const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])
+
+/**
+ * The block's thumbnail import specifier, only when thumbnail.png really is a PNG: Next fails the
+ * build on an image it cannot decode (older scaffolds shipped text placeholders with that name).
+ */
+export function thumbnailImport(blockPath, blockSlug) {
+  const file = join(blockPath, 'thumbnail.png')
+  if (!existsSync(file)) return null
+  let head
+  try {
+    // The whole file is read: the registry build may not use fd-level fs calls (see safe-fs.test.mjs), and a thumbnail is small
+    head = readFileSync(file).subarray(0, 8)
+  } catch (error) {
+    log(`WARNING: Block "${blockSlug}": blocks/${blockSlug}/thumbnail.png cannot be read (${error.code ?? error.message}); it is ignored (no thumbnail)`, 'warning')
+    return null
+  }
+  if (!head.equals(PNG_SIGNATURE)) {
+    log(`WARNING: Block "${blockSlug}": blocks/${blockSlug}/thumbnail.png is not a PNG image; it is ignored (no thumbnail)`, 'warning')
+    return null
+  }
+  return `@/blocks/${blockSlug}/thumbnail.png`
+}
+
+/**
+ * Discover all blocks in the project root.
  * @param {object} config - Optional configuration object (defaults to DEFAULT_CONFIG)
  * @returns {Promise<Array>} Array of discovered blocks
  */
@@ -22,13 +125,8 @@ export async function discoverBlocks(config = DEFAULT_CONFIG) {
   log('Discovering blocks...', 'info')
   const blocks = []
 
-  if (!config.activeTheme) {
-    verbose('Warning: NEXT_PUBLIC_ACTIVE_THEME not set, skipping block discovery')
-    return blocks
-  }
-
-  const themeName = config.activeTheme
-  const blocksDir = join(config.themesDir, themeName, 'blocks')
+  const themeName = config.projectName
+  const blocksDir = join(config.projectSourceDir, 'blocks')
 
   // Check if blocks directory exists
   try {
@@ -68,6 +166,17 @@ export async function discoverBlocks(config = DEFAULT_CONFIG) {
       // Read config file to extract metadata
       try {
         const configContent = await readFile(configPath, 'utf-8')
+        // The generated BLOCK_SCHEMAS map imports `schema` by name, so only a block whose
+        // schema.ts exports it gets an entry (block-registry.mjs, generateBlockSchemas).
+        const schemaExport = readSchemaExport(
+          await readFile(schemaPath, 'utf-8'),
+          schemaPath,
+          await loadTypeScriptFor(config.projectRoot ?? process.cwd())
+        )
+        const exportsSchema = schemaExport.exportsSchema
+        if (!exportsSchema) {
+          log(`WARNING: Block "${blockSlug}": ${schemaExport.reason}. /api/v1/blocks/validate cannot validate this block`, 'warning')
+        }
 
         // Extract metadata using regex (simple parsing)
         const slugMatch = configContent.match(/slug:\s*['"]([^'"]+)['"]/)
@@ -110,15 +219,15 @@ export async function discoverBlocks(config = DEFAULT_CONFIG) {
           allowInPatterns,
           themeName,
           hasExamples,
+          exportsSchema,
           paths: {
-            config: `@/contents/themes/${themeName}/blocks/${blockSlug}/config`,
-            schema: `@/contents/themes/${themeName}/blocks/${blockSlug}/schema`,
-            fields: `@/contents/themes/${themeName}/blocks/${blockSlug}/fields`,
-            component: `@/contents/themes/${themeName}/blocks/${blockSlug}/component`,
-            examples: `@/contents/themes/${themeName}/blocks/${blockSlug}/examples`,
-            thumbnail: existsSync(join(blockPath, 'thumbnail.png'))
-              ? `/theme/blocks/${blockSlug}/thumbnail.png`
-              : null
+            config: `@/blocks/${blockSlug}/config`,
+            schema: `@/blocks/${blockSlug}/schema`,
+            fields: `@/blocks/${blockSlug}/fields`,
+            component: `@/blocks/${blockSlug}/component`,
+            examples: `@/blocks/${blockSlug}/examples`,
+            // Imported statically by the registry, so Next processes the file as an asset
+            thumbnail: thumbnailImport(blockPath, blockSlug)
           }
         })
 

package/scripts/build/registry/discovery/core-routes.mjs

@@ -1,15 +1,15 @@
 /**
  * Core Routes Discovery
  *
- * Discovers API routes from app/api/v1/ directory.
+ * Discovers core's API routes (api/v1) from the core route manifest.
  * Excludes dynamic/catch-all routes (handled by generic handlers).
  *
  * @module core/scripts/build/registry/discovery/core-routes
  */
 
-import { join } from 'path'
 import { CONFIG as DEFAULT_CONFIG } from '../config.mjs'
-import { verbose, extractHttpMethods, scanDirectory } from '../../../utils/index.mjs'
+import { loadCoreRouteManifest } from '../host/core-routes.mjs'
+import { verbose, extractHttpMethods } from '../../../utils/index.mjs'
 
 /**
  * Patterns to exclude from core route discovery
@@ -30,78 +30,30 @@ function isExcludedDirectory(name) {
 }
 
 /**
- * Discover core API routes from app/api/v1/
+ * Discover core's api/v1 routes from core's route manifest, each read from the core module that
+ * implements it (what the generated src/app/api/v1 holds a facade of): src/app is output of
+ * `nextspark prepare`, never an input of the registries. Dynamic routes are left out.
  *
- * @returns {Promise<Array<{
- *   path: string,
- *   methods: string[],
- *   relativePath: string,
- *   category: string
- * }>>}
- */
-/**
- * Discover core API routes from app/api/v1/
- * @param {object} config - Optional configuration object (defaults to DEFAULT_CONFIG)
- * @returns {Promise<Array>} Array of discovered core routes
+ * @param {object} config - configuration from getConfig()
+ * @returns {Promise<Array<{ path: string, methods: string[], relativePath: string, category: string, filePath: string }>>}
  */
 export async function discoverCoreRoutes(config = DEFAULT_CONFIG) {
-  const apiDir = join(config.projectRoot, 'app', 'api', 'v1')
+  const manifest = await loadCoreRouteManifest({ coreRoot: config.coreDir })
   const routes = []
-
-  verbose(`[Core Routes] Scanning ${apiDir}`)
-
-  /**
-   * Recursively scan directory for route.ts files
-   * @param {string} dir - Current directory
-   * @param {string} relativePath - Path relative to api/v1/
-   */
-  async function scanForRoutes(dir, relativePath = '') {
-    const entries = await scanDirectory(dir)
-
-    for (const entry of entries) {
-      const fullPath = join(dir, entry.name)
-      const currentRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name
-
-      if (entry.isDirectory()) {
-        // Skip excluded patterns (dynamic routes)
-        if (isExcludedDirectory(entry.name)) {
-          verbose(`[Core Routes] Skipping dynamic directory: ${entry.name}`)
-          continue
-        }
-
-        // Recurse into subdirectory
-        await scanForRoutes(fullPath, currentRelativePath)
-      } else if (entry.name === 'route.ts') {
-        // Found a route file - extract methods
-        const routeFilePath = fullPath
-        const methods = await extractHttpMethods(routeFilePath)
-
-        // Build the API path
-        const apiPath = relativePath
-          ? `/api/v1/${relativePath}`
-          : '/api/v1'
-
-        // Determine category based on path
-        const category = getCategoryFromPath(relativePath)
-
-        routes.push({
-          path: apiPath,
-          methods,
-          relativePath: relativePath || '/',
-          category,
-          filePath: `@/app/api/v1${relativePath ? '/' + relativePath : ''}/route`
-        })
-
-        verbose(`[Core Routes] Found: ${apiPath} [${methods.join(', ')}] (${category})`)
-      }
-    }
+  for (const route of manifest?.routes ?? []) {
+    if (route.kind !== 'route' || !route.target.startsWith('api/v1/')) continue
+    const relativePath = route.target.slice('api/v1/'.length).split('/').slice(0, -1).join('/')
+    if (relativePath.split('/').some(isExcludedDirectory)) continue
+    routes.push({
+      path: relativePath ? `/api/v1/${relativePath}` : '/api/v1',
+      methods: await extractHttpMethods(route.file),
+      relativePath: relativePath || '/',
+      category: getCategoryFromPath(relativePath),
+      filePath: `@/app/api/v1${relativePath ? '/' + relativePath : ''}/route`
+    })
   }
-
-  await scanForRoutes(apiDir)
-
-  verbose(`[Core Routes] Discovered ${routes.length} core routes`)
-
-  return routes
+  verbose(`[Core Routes] ${routes.length} core routes from the core route manifest`)
+  return routes.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0))
 }
 
 /**
@@ -124,9 +76,7 @@ function getCategoryFromPath(relativePath) {
     'blocks': 'blocks',
     'media': 'media',
     'auth': 'auth',
-    'post-categories': 'content',
-    'plugin': 'plugin',
-    'theme': 'theme'
+    'post-categories': 'content'
   }
 
   return categoryMap[firstSegment] || 'other'

package/scripts/build/registry/discovery/emails.mjs

@@ -1,7 +1,7 @@
 /**
  * Email Discovery
  *
- * Discovers email template files from core defaults and the active theme.
+ * Discovers email template files from core defaults and the project root.
  * Theme files override core defaults at the same slug; new theme slugs are
  * additive (themes can ship templates that core doesn't know about).
  *
@@ -94,7 +94,7 @@ async function listEmailFiles(dir, options = {}) {
 }
 
 /**
- * Discover all email templates: core defaults first, then active theme overrides
+ * Discover all email templates: core defaults first, then project overrides
  * and additions. Theme entries take precedence per slug.
  *
  * @param {object} config - Configuration object from getConfig() (defaults to DEFAULT_CONFIG)
@@ -140,24 +140,19 @@ export async function discoverEmails(config = DEFAULT_CONFIG) {
     verbose(`No core email templates found in: ${coreEmailsDir}`)
   }
 
-  // Theme overrides + additions.
-  if (config.activeTheme && config.themesDir) {
-    const themeEmailsDir = join(config.themesDir, config.activeTheme, 'emails')
-    const themeFiles = await listEmailFiles(themeEmailsDir)
-
-    if (themeFiles.length > 0) {
-      verbose(`Found ${themeFiles.length} theme email override(s) in: ${themeEmailsDir}`)
-      for (const { slug } of themeFiles) {
-        merged.set(slug, {
-          slug,
-          source: 'theme',
-          importPath: `@/contents/themes/${config.activeTheme}/emails/${slug}`,
-          importName: `${slugToIdentifier(slug)}_theme`,
-        })
-      }
+  // Project overrides + additions.
+  const projectEmailsDir = join(config.projectSourceDir, 'emails')
+  const projectFiles = await listEmailFiles(projectEmailsDir)
+  if (projectFiles.length > 0) {
+    verbose(`Found ${projectFiles.length} project email override(s) in: ${projectEmailsDir}`)
+    for (const { slug } of projectFiles) {
+      merged.set(slug, {
+        slug,
+        source: 'theme',
+        importPath: `@/emails/${slug}`,
+        importName: `${slugToIdentifier(slug)}_theme`,
+      })
     }
-  } else if (!config.activeTheme) {
-    verbose('No active theme — only core email templates will be registered.')
   }
 
   const result = Array.from(merged.values()).sort((a, b) => a.slug.localeCompare(b.slug))

package/scripts/build/registry/discovery/entities.mjs

@@ -1,7 +1,7 @@
 /**
  * Entity Discovery
  *
- * Discovers entities from themes, plugins, and standalone entities directory
+ * Discovers entities from the project root and enabled local plugins
  *
  * @module core/scripts/build/registry/discovery/entities
  */
@@ -16,13 +16,13 @@ import { extractExportName } from '../../../utils/index.mjs'
 
 /**
  * Recursively discover nested entities within a base directory
- * Supports both plugin and theme contexts
+ * Supports project and plugin contexts
  * @param {object} config - Configuration object
  * @param {string} basePath - Base path to scan
  * @param {string} relativePath - Relative path from base
  * @param {number} depth - Current recursion depth
  * @param {string|null} parentName - Parent entity name
- * @param {object|null} ownerContext - Owner context { type: 'plugin'|'theme', name: string }
+ * @param {object|null} ownerContext - Owner context { type: 'plugin'|'project', name: string }
  * @returns {Promise<Array>} Array of discovered entities
  */
 export async function discoverNestedEntities(config, basePath, relativePath = '', depth = 0, parentName = null, ownerContext = null) {
@@ -65,17 +65,15 @@ export async function discoverNestedEntities(config, basePath, relativePath = ''
           // Determine base import path based on owner context
           let baseImportPath
           if (ownerContext?.type === 'plugin') {
-            baseImportPath = `@/contents/plugins/${ownerContext.name}/entities/${currentRelativePath}`
-          } else if (ownerContext?.type === 'theme') {
-            baseImportPath = `@/contents/themes/${ownerContext.name}/entities/${currentRelativePath}`
+            baseImportPath = `${ownerContext.importBase ?? `@/plugins/${ownerContext.name}`}/entities/${currentRelativePath}`
           } else {
-            baseImportPath = `@/contents/entities/${currentRelativePath}`
+            baseImportPath = `@/entities/${currentRelativePath}`
           }
 
           entities.push({
             name: entityName,
             exportName,
-            configPath: join(basePath, configFile.name).replace(config.contentsDir + '/', '@/contents/'),
+            configPath: `${baseImportPath}/${configFile.name.replace(/\.ts$/, '')}`,
             actualConfigFile: configFile.name,
             relativePath: currentRelativePath,
             depth,
@@ -88,8 +86,8 @@ export async function discoverNestedEntities(config, basePath, relativePath = ''
             hasAssets: false,
             messagesPath: `${baseImportPath}/messages`,
             pluginContext: ownerContext?.type === 'plugin' ? { pluginName: ownerContext.name } : null,
-            themeContext: ownerContext?.type === 'theme' ? { themeName: ownerContext.name } : null,
-            source: ownerContext?.type || 'theme'
+            themeContext: ownerContext?.type === 'project' ? { themeName: ownerContext.name } : null,
+            source: ownerContext?.type || 'project'
           })
 
           const contextLabel = ownerContext ? `[${ownerContext.name}] ` : ''
@@ -212,11 +210,9 @@ export async function discoverNestedEntities(config, basePath, relativePath = ''
         // Determine base import path based on owner context
         let baseImportPath
         if (ownerContext?.type === 'plugin') {
-          baseImportPath = `@/contents/plugins/${ownerContext.name}/entities/${currentRelativePath}`
-        } else if (ownerContext?.type === 'theme') {
-          baseImportPath = `@/contents/themes/${ownerContext.name}/entities/${currentRelativePath}`
+          baseImportPath = `${ownerContext.importBase ?? `@/plugins/${ownerContext.name}`}/entities/${currentRelativePath}`
         } else {
-          baseImportPath = `@/contents/entities/${currentRelativePath}`
+          baseImportPath = `@/entities/${currentRelativePath}`
         }
 
         entities.push({
@@ -235,8 +231,8 @@ export async function discoverNestedEntities(config, basePath, relativePath = ''
           hasAssets,
           messagesPath: `${baseImportPath}/messages`,
           pluginContext: ownerContext?.type === 'plugin' ? { pluginName: ownerContext.name } : null,
-          themeContext: ownerContext?.type === 'theme' ? { themeName: ownerContext.name } : null,
-          source: ownerContext?.type || 'theme'
+          themeContext: ownerContext?.type === 'project' ? { themeName: ownerContext.name } : null,
+          source: ownerContext?.type || 'project'
         })
 
         const features = [
@@ -264,12 +260,12 @@ export async function discoverNestedEntities(config, basePath, relativePath = ''
 }
 
 /**
- * Discover all entities (standalone entities in contents/entities)
+ * Discover all project entities
  * @param {object} config - Optional configuration object (defaults to DEFAULT_CONFIG)
  * @returns {Promise<Array>} Array of discovered entities
  */
 export async function discoverEntities(config = DEFAULT_CONFIG) {
-  const entitiesDir = join(config.contentsDir, 'entities')
+  const entitiesDir = join(config.projectSourceDir, 'entities')
 
   try {
     const entities = await discoverNestedEntities(config, entitiesDir)

package/scripts/build/registry/discovery/icons.mjs

@@ -603,16 +603,6 @@ async function collectConfigFiles(dir, matcher, found = []) {
   return found
 }
 
-function coreEntitiesDir(config) {
-  if (config.isNpmMode) {
-    return join(config.projectRoot, 'node_modules/@nextsparkjs/core/src/entities')
-  }
-  if (config.isMonorepoMode && config.monorepoRoot) {
-    return join(config.monorepoRoot, 'packages/core/src/entities')
-  }
-  return join(config.projectRoot, 'packages/core/src/entities')
-}
-
 /**
  * Discover every icon name the runtime can look up by string.
  * @param {Array} blocks - Blocks from block discovery (each with an `icon` name)
@@ -629,10 +619,11 @@ export async function discoverIcons(blocks, config) {
   // though a config rarely lives under one, for the same reason call sources
   // exclude them below.
   const isIconSource = filePath => isIconSourcePath(filePath) && !isTestFilePath(filePath)
+  const pluginSourceDirs = (config.pluginSources ?? []).map(plugin => plugin.sourceDir)
   const iconSources = [
-    ...(await collectConfigFiles(coreEntitiesDir(config), isIconSource)),
-    ...(await collectConfigFiles(config.themesDir, isIconSource)),
-    ...(await collectConfigFiles(config.pluginsDir, isIconSource))
+    ...(await collectConfigFiles(join(config.coreDir, 'src', 'entities'), isIconSource)),
+    ...(await collectConfigFiles(config.projectSourceDir, isIconSource)),
+    ...(await Promise.all(pluginSourceDirs.map(dir => collectConfigFiles(dir, isIconSource)))).flat()
   ]
 
   const unresolved = []
@@ -666,8 +657,8 @@ export async function discoverIcons(blocks, config) {
   // with a literal name isn't a real call site the production bundle needs.
   const isIconCallSource = filePath => isIconCallSourcePath(filePath) && !isTestFilePath(filePath)
   const callSources = [
-    ...(await collectConfigFiles(config.themesDir, isIconCallSource)),
-    ...(await collectConfigFiles(config.pluginsDir, isIconCallSource))
+    ...(await collectConfigFiles(config.projectSourceDir, isIconCallSource)),
+    ...(await Promise.all(pluginSourceDirs.map(dir => collectConfigFiles(dir, isIconCallSource)))).flat()
   ]
 
   for (const sourcePath of callSources) {

package/scripts/build/registry/discovery/index.mjs

@@ -11,7 +11,6 @@ export { discoverPlugins, discoverRouteFiles } from './plugins.mjs'
 export { discoverEntities, discoverNestedEntities } from './entities.mjs'
 export { discoverCoreEntities } from './core-entities.mjs'
 export { discoverThemes, discoverThemeRouteFiles } from './themes.mjs'
-export { discoverTemplates, discoverThemeTemplates } from './templates.mjs'
 export { discoverBlocks } from './blocks.mjs'
 export { discoverIcons } from './icons.mjs'
 export { discoverMiddlewares } from './middlewares.mjs'

package/scripts/build/registry/discovery/mcp-overrides.mjs

@@ -1,14 +1,14 @@
 /**
  * MCP Override Discovery
  *
- * Discovers `entities/<slug>/mcp.ts` files for the active theme — the
+ * Discovers `entities/<slug>/mcp.ts` files from the project root — the
  * extension point a theme uses to customize how one entity is exposed by the
  * MCP engine (@nextsparkjs/core/lib/mcp): exclude it, exclude specific
  * operations, relax required fields, transform input/output, or add extra
  * (non-CRUD) tools.
  *
  * Mirrors discoverApiPresets's discoverEntityFolders (same
- * `{theme}/entities/<slug>/` scan, same theme-only scope) with one
+ * `entities/<slug>/` scan, same theme-only scope) with one
  * difference: `mcp.ts` sits at the entity folder root (a sibling of `api/`,
  * `migrations/`, `messages/`), not nested under `api/` like `presets.ts`.
  *
@@ -29,20 +29,14 @@ import { existsSync } from 'fs'
 import { log, verbose } from '../../../utils/index.mjs'
 
 /**
- * Discover MCP entity overrides for the active theme.
+ * Discover MCP entity overrides from the project root.
  * @param {object} config - Configuration object from getConfig()
  * @returns {Promise<Array<{slug: string, importPath: string, themeName: string}>>}
  */
 export async function discoverMcpOverrides(config) {
   const overrides = []
-  const themeName = config.activeTheme
-
-  if (!themeName) {
-    verbose('[mcp-overrides] No active theme configured — skipping MCP override discovery')
-    return overrides
-  }
-
-  const entitiesDir = join(config.themesDir, themeName, 'entities')
+  const themeName = config.projectName
+  const entitiesDir = join(config.projectSourceDir, 'entities')
   if (!existsSync(entitiesDir)) {
     verbose(`[mcp-overrides] No entities directory found for theme "${themeName}"`)
     return overrides
@@ -59,7 +53,7 @@ export async function discoverMcpOverrides(config) {
 
       overrides.push({
         slug: entityName,
-        importPath: `@/contents/themes/${themeName}/entities/${entityName}/mcp`,
+        importPath: `@/entities/${entityName}/mcp`,
         themeName,
       })
       verbose(`[mcp-overrides] MCP override discovered: ${entityName} -> ${mcpPath}`)