@uniweb/build 0.1.6 → 0.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -10,9 +10,11 @@
     "./generate-entry": "./src/generate-entry.js",
     "./vite-plugin": "./src/vite-foundation-plugin.js",
     "./site": "./src/site/index.js",
+    "./site/config": "./src/site/config.js",
     "./dev": "./src/dev/index.js",
     "./prerender": "./src/prerender.js",
-    "./i18n": "./src/i18n/index.js"
+    "./i18n": "./src/i18n/index.js",
+    "./search": "./src/search/index.js"
   },
   "files": [
     "src"
@@ -52,7 +54,10 @@
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0",
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0",
-    "@uniweb/core": "0.1.5"
+    "@tailwindcss/vite": "^4.0.0",
+    "@vitejs/plugin-react": "^4.0.0 || ^5.0.0",
+    "vite-plugin-svgr": "^4.0.0",
+    "@uniweb/core": "0.1.6"
   },
   "peerDependenciesMeta": {
     "vite": {
@@ -66,6 +71,15 @@
     },
     "@uniweb/core": {
       "optional": true
+    },
+    "@tailwindcss/vite": {
+      "optional": true
+    },
+    "@vitejs/plugin-react": {
+      "optional": true
+    },
+    "vite-plugin-svgr": {
+      "optional": true
     }
   },
   "scripts": {

package/src/i18n/index.js

@@ -15,6 +15,7 @@ import { computeHash, normalizeText } from './hash.js'
 import { extractTranslatableContent } from './extract.js'
 import { syncManifests, formatSyncReport } from './sync.js'
 import { mergeTranslations, generateAllLocales } from './merge.js'
+import { generateSearchIndex, isSearchEnabled } from '../search/index.js'
 
 export {
   // Hash utilities
@@ -219,14 +220,16 @@ export async function getTranslationStatus(siteRoot, options = {}) {
  * Build translated site content for all locales
  * @param {string} siteRoot - Site root directory
  * @param {Object} options - Options
- * @returns {Object} Map of locale to output path
+ * @param {boolean} [options.generateSearchIndex=true] - Generate search indexes for each locale
+ * @returns {Object} Map of locale to output paths
  */
 export async function buildLocalizedContent(siteRoot, options = {}) {
   const {
     localesDir = DEFAULTS.localesDir,
     locales = [],
     outputDir = join(siteRoot, 'dist'),
-    fallbackToSource = true
+    fallbackToSource = true,
+    generateSearchIndexes = true
   } = options
 
   const localesPath = join(siteRoot, localesDir)
@@ -253,16 +256,33 @@ export async function buildLocalizedContent(siteRoot, options = {}) {
       fallbackToSource
     })
 
+    // Mark the active locale in the translated content
+    translated.config = { ...translated.config, activeLocale: locale }
+
     // Write to locale subdirectory
     const localeOutputDir = join(outputDir, locale)
     if (!existsSync(localeOutputDir)) {
       await mkdir(localeOutputDir, { recursive: true })
     }
 
-    const outputPath = join(localeOutputDir, 'site-content.json')
-    await writeFile(outputPath, JSON.stringify(translated, null, 2))
+    const contentOutputPath = join(localeOutputDir, 'site-content.json')
+    await writeFile(contentOutputPath, JSON.stringify(translated, null, 2))
+
+    outputs[locale] = { content: contentOutputPath }
+
+    // Generate search index for this locale if search is enabled
+    if (generateSearchIndexes && isSearchEnabled(translated)) {
+      const searchConfig = translated.config?.search || {}
+      const searchIndex = generateSearchIndex(translated, {
+        locale,
+        search: searchConfig
+      })
 
-    outputs[locale] = outputPath
+      const searchOutputPath = join(localeOutputDir, 'search-index.json')
+      await writeFile(searchOutputPath, JSON.stringify(searchIndex, null, 2))
+
+      outputs[locale].searchIndex = searchOutputPath
+    }
   }
 
   return outputs

package/src/prerender.js

@@ -7,7 +7,7 @@
 
 import { readFile, writeFile, mkdir } from 'node:fs/promises'
 import { existsSync } from 'node:fs'
-import { join, dirname } from 'node:path'
+import { join, dirname, resolve } from 'node:path'
 import { pathToFileURL } from 'node:url'
 import { createRequire } from 'node:module'
 
@@ -25,7 +25,9 @@ async function loadDependencies(siteDir) {
 
   // Create a require function that resolves from the site's perspective
   // This ensures we get the same React instance that the foundation uses
-  const siteRequire = createRequire(join(siteDir, 'package.json'))
+  // Note: createRequire requires an absolute path
+  const absoluteSiteDir = resolve(siteDir)
+  const siteRequire = createRequire(join(absoluteSiteDir, 'package.json'))
 
   try {
     // Try to load React from site's node_modules

package/src/search/extract.js

@@ -0,0 +1,340 @@
+/**
+ * Extract searchable content from site-content.json
+ *
+ * Walks through all pages and sections, extracting text content
+ * for search indexing. Reuses patterns from i18n extraction.
+ */
+
+/**
+ * Extract all searchable content from site
+ * @param {Object} siteContent - Parsed site-content.json
+ * @param {Object} options - Extraction options
+ * @param {boolean} [options.pages=true] - Include page metadata
+ * @param {boolean} [options.sections=true] - Include section content
+ * @param {boolean} [options.headings=true] - Include headings
+ * @param {boolean} [options.paragraphs=true] - Include paragraphs
+ * @param {boolean} [options.links=true] - Include link labels
+ * @param {boolean} [options.lists=true] - Include list items
+ * @param {Array<string>} [options.excludeRoutes=[]] - Routes to exclude
+ * @param {Array<string>} [options.excludeComponents=[]] - Components to exclude
+ * @returns {Array<Object>} Array of search entries
+ */
+export function extractSearchContent(siteContent, options = {}) {
+  const {
+    pages: includePagesFlag = true,
+    sections: includeSections = true,
+    headings: includeHeadings = true,
+    paragraphs: includeParagraphs = true,
+    links: includeLinks = true,
+    lists: includeLists = true,
+    excludeRoutes = [],
+    excludeComponents = []
+  } = options
+
+  const entries = []
+
+  for (const page of siteContent.pages || []) {
+    const pageRoute = page.route || '/'
+
+    // Skip excluded routes
+    if (excludeRoutes.some(r => pageRoute.startsWith(r))) {
+      continue
+    }
+
+    // Skip special pages (header, footer, etc.)
+    if (pageRoute.startsWith('/@')) {
+      continue
+    }
+
+    // Skip pages marked as noindex
+    if (page.seo?.noindex) {
+      continue
+    }
+
+    // Extract page-level entry
+    if (includePagesFlag) {
+      const pageEntry = extractFromPage(page)
+      if (pageEntry) {
+        entries.push(pageEntry)
+      }
+    }
+
+    // Extract section-level entries
+    if (includeSections) {
+      for (const section of page.sections || []) {
+        const sectionEntries = extractFromSection(section, page, {
+          includeHeadings,
+          includeParagraphs,
+          includeLinks,
+          includeLists,
+          excludeComponents
+        })
+        entries.push(...sectionEntries)
+      }
+    }
+  }
+
+  return entries
+}
+
+/**
+ * Extract search entry from page metadata
+ * @param {Object} page - Page data
+ * @returns {Object|null} Search entry or null
+ */
+function extractFromPage(page) {
+  const route = page.route || '/'
+  const title = page.title || ''
+  const description = page.description || ''
+  const keywords = page.keywords || page.seo?.keywords || []
+
+  // Skip pages with no meaningful content
+  if (!title && !description) {
+    return null
+  }
+
+  return {
+    id: `page:${route}`,
+    type: 'page',
+    route,
+    title,
+    description,
+    keywords: Array.isArray(keywords) ? keywords : [keywords].filter(Boolean),
+    content: [title, description].filter(Boolean).join(' '),
+    // Boost factor for search ranking (pages are more important)
+    weight: route === '/' ? 1.0 : 0.8
+  }
+}
+
+/**
+ * Extract search entries from a section (and subsections)
+ * @param {Object} section - Section data
+ * @param {Object} page - Parent page
+ * @param {Object} options - Extraction options
+ * @returns {Array<Object>} Array of search entries
+ */
+function extractFromSection(section, page, options) {
+  const entries = []
+  const {
+    includeHeadings,
+    includeParagraphs,
+    includeLinks,
+    includeLists,
+    excludeComponents
+  } = options
+
+  const sectionId = section.id || 'unknown'
+  const component = section.component || section.type || 'unknown'
+
+  // Skip excluded components
+  if (excludeComponents.includes(component)) {
+    return entries
+  }
+
+  // Extract text from ProseMirror content
+  const textParts = []
+  let sectionTitle = ''
+
+  if (section.content?.type === 'doc') {
+    const extracted = extractFromProseMirrorDoc(section.content, {
+      includeHeadings,
+      includeParagraphs,
+      includeLinks,
+      includeLists
+    })
+
+    sectionTitle = extracted.title || ''
+    textParts.push(...extracted.textParts)
+  }
+
+  // Also check params for title (from YAML frontmatter)
+  if (!sectionTitle && section.params?.title) {
+    sectionTitle = section.params.title
+  }
+
+  // Build content string
+  const content = textParts.join(' ').trim()
+
+  // Create entry if there's meaningful content
+  if (sectionTitle || content) {
+    entries.push({
+      id: `section:${page.route}:${sectionId}`,
+      type: 'section',
+      route: page.route,
+      sectionId,
+      anchor: `Section${sectionId}`,
+      component,
+      title: sectionTitle,
+      pageTitle: page.title || '',
+      content,
+      // Generate excerpt (first ~160 chars)
+      excerpt: generateExcerpt(content, 160),
+      // Section weight is lower than page
+      weight: 0.6
+    })
+  }
+
+  // Recursively process subsections
+  for (const subsection of section.subsections || []) {
+    const subEntries = extractFromSection(subsection, page, options)
+    entries.push(...subEntries)
+  }
+
+  return entries
+}
+
+/**
+ * Extract text from ProseMirror document
+ * @param {Object} doc - ProseMirror document
+ * @param {Object} options - Extraction options
+ * @returns {Object} Extracted content { title, textParts }
+ */
+function extractFromProseMirrorDoc(doc, options) {
+  const { includeHeadings, includeParagraphs, includeLinks, includeLists } = options
+  const textParts = []
+  let title = ''
+  let foundFirstHeading = false
+
+  if (!doc.content) {
+    return { title, textParts }
+  }
+
+  for (const node of doc.content) {
+    if (node.type === 'heading') {
+      const text = extractTextFromNode(node)
+      if (!text) continue
+
+      // First H1 becomes the title
+      if (!foundFirstHeading && node.attrs?.level === 1) {
+        title = text
+        foundFirstHeading = true
+      }
+
+      if (includeHeadings) {
+        textParts.push(text)
+      }
+    } else if (node.type === 'paragraph') {
+      if (includeParagraphs) {
+        const text = extractTextFromNode(node)
+        if (text) {
+          textParts.push(text)
+        }
+      }
+
+      // Extract link labels separately if requested
+      if (includeLinks) {
+        const links = extractLinksFromNode(node)
+        for (const link of links) {
+          if (link.label) {
+            textParts.push(link.label)
+          }
+        }
+      }
+    } else if ((node.type === 'bulletList' || node.type === 'orderedList') && includeLists) {
+      const listTexts = extractFromList(node)
+      textParts.push(...listTexts)
+    }
+  }
+
+  return { title, textParts }
+}
+
+/**
+ * Extract all text content from a node
+ * @param {Object} node - ProseMirror node
+ * @returns {string} Text content
+ */
+function extractTextFromNode(node) {
+  if (!node.content) return ''
+
+  const texts = []
+
+  for (const child of node.content) {
+    if (child.type === 'text') {
+      texts.push(child.text || '')
+    } else if (child.content) {
+      // Recurse for nested nodes
+      texts.push(extractTextFromNode(child))
+    }
+  }
+
+  return texts.join('').trim()
+}
+
+/**
+ * Extract links from a paragraph node
+ * @param {Object} node - Paragraph node
+ * @returns {Array<{label: string, href: string}>} Links
+ */
+function extractLinksFromNode(node) {
+  const links = []
+
+  if (!node.content) return links
+
+  for (const child of node.content) {
+    if (child.type === 'text' && child.marks) {
+      const linkMark = child.marks.find(m => m.type === 'link')
+      if (linkMark) {
+        links.push({
+          label: child.text || '',
+          href: linkMark.attrs?.href || ''
+        })
+      }
+    }
+  }
+
+  return links
+}
+
+/**
+ * Extract text from list items
+ * @param {Object} listNode - List node
+ * @returns {Array<string>} List item texts
+ */
+function extractFromList(listNode) {
+  const texts = []
+
+  if (!listNode.content) return texts
+
+  for (const listItem of listNode.content) {
+    if (listItem.type === 'listItem' && listItem.content) {
+      for (const child of listItem.content) {
+        if (child.type === 'paragraph') {
+          const text = extractTextFromNode(child)
+          if (text) {
+            texts.push(text)
+          }
+        }
+      }
+    }
+  }
+
+  return texts
+}
+
+/**
+ * Generate excerpt from content
+ * @param {string} content - Full content
+ * @param {number} maxLength - Maximum length
+ * @returns {string} Excerpt
+ */
+function generateExcerpt(content, maxLength = 160) {
+  if (!content) return ''
+
+  // Normalize whitespace
+  const normalized = content.replace(/\s+/g, ' ').trim()
+
+  if (normalized.length <= maxLength) {
+    return normalized
+  }
+
+  // Find a good break point (word boundary)
+  let breakPoint = normalized.lastIndexOf(' ', maxLength)
+  if (breakPoint < maxLength * 0.5) {
+    breakPoint = maxLength
+  }
+
+  return normalized.slice(0, breakPoint).trim() + '…'
+}
+
+export default extractSearchContent

package/src/search/generate.js

@@ -0,0 +1,107 @@
+/**
+ * Generate search index from site content
+ *
+ * Creates a JSON search index file that can be loaded at runtime
+ * for client-side search functionality.
+ */
+
+import { extractSearchContent } from './extract.js'
+
+/**
+ * Generate search index for a site
+ * @param {Object} siteContent - Parsed site-content.json
+ * @param {Object} options - Generation options
+ * @param {string} [options.locale] - Locale code for this index
+ * @param {Object} [options.extract] - Options passed to extractSearchContent
+ * @param {Object} [options.search] - Search configuration from site.yml
+ * @returns {Object} Search index object
+ */
+export function generateSearchIndex(siteContent, options = {}) {
+  const {
+    locale = siteContent.config?.activeLocale || siteContent.config?.defaultLanguage || 'en',
+    extract: extractOptions = {},
+    search: searchConfig = {}
+  } = options
+
+  // Merge search config with extract options
+  const mergedExtractOptions = {
+    ...extractOptions,
+    excludeRoutes: searchConfig.exclude?.routes || extractOptions.excludeRoutes || [],
+    excludeComponents: searchConfig.exclude?.components || extractOptions.excludeComponents || []
+  }
+
+  // Check what to include from config
+  if (searchConfig.include) {
+    mergedExtractOptions.pages = searchConfig.include.pages !== false
+    mergedExtractOptions.sections = searchConfig.include.sections !== false
+    mergedExtractOptions.headings = searchConfig.include.headings !== false
+    mergedExtractOptions.paragraphs = searchConfig.include.paragraphs !== false
+    mergedExtractOptions.links = searchConfig.include.links !== false
+    mergedExtractOptions.lists = searchConfig.include.lists !== false
+  }
+
+  // Extract searchable content
+  const entries = extractSearchContent(siteContent, mergedExtractOptions)
+
+  // Build the index
+  const index = {
+    version: '1.0',
+    locale,
+    generated: new Date().toISOString(),
+    count: entries.length,
+    entries
+  }
+
+  return index
+}
+
+/**
+ * Check if search is enabled for a site
+ * @param {Object} siteContent - Parsed site-content.json
+ * @returns {boolean}
+ */
+export function isSearchEnabled(siteContent) {
+  // Search is enabled by default unless explicitly disabled
+  return siteContent.config?.search?.enabled !== false
+}
+
+/**
+ * Get search configuration from site content
+ * @param {Object} siteContent - Parsed site-content.json
+ * @returns {Object} Search configuration
+ */
+export function getSearchConfig(siteContent) {
+  const config = siteContent.config?.search || {}
+
+  return {
+    enabled: config.enabled !== false,
+    include: {
+      pages: config.include?.pages !== false,
+      sections: config.include?.sections !== false,
+      headings: config.include?.headings !== false,
+      paragraphs: config.include?.paragraphs !== false,
+      links: config.include?.links !== false,
+      lists: config.include?.lists !== false
+    },
+    exclude: {
+      routes: config.exclude?.routes || [],
+      components: config.exclude?.components || []
+    }
+  }
+}
+
+/**
+ * Get the search index filename for a locale
+ * @param {string} locale - Locale code
+ * @param {string} defaultLocale - Default locale code
+ * @returns {string} Filename
+ */
+export function getSearchIndexFilename(locale, defaultLocale) {
+  // Default locale uses root filename, others use locale prefix path
+  if (locale === defaultLocale) {
+    return 'search-index.json'
+  }
+  return `${locale}/search-index.json`
+}
+
+export default generateSearchIndex

package/src/search/index.js

@@ -0,0 +1,34 @@
+/**
+ * Search Index Generation Module
+ *
+ * Generates search indexes for Uniweb sites at build time.
+ * The generated indexes can be loaded at runtime for client-side search.
+ *
+ * @module @uniweb/build/search
+ *
+ * @example
+ * import { generateSearchIndex, isSearchEnabled } from '@uniweb/build/search'
+ *
+ * // Check if search is enabled
+ * if (isSearchEnabled(siteContent)) {
+ *   // Generate index for current locale
+ *   const index = generateSearchIndex(siteContent, {
+ *     locale: 'en'
+ *   })
+ *
+ *   // Write to file
+ *   writeFileSync('dist/search-index.json', JSON.stringify(index))
+ * }
+ */
+
+export {
+  extractSearchContent,
+  extractSearchContent as default
+} from './extract.js'
+
+export {
+  generateSearchIndex,
+  isSearchEnabled,
+  getSearchConfig,
+  getSearchIndexFilename
+} from './generate.js'

package/src/site/config.js

@@ -0,0 +1,310 @@
+/**
+ * Site Vite Configuration
+ *
+ * Provides a zero-config or minimal-config Vite setup for Uniweb sites.
+ * Reads configuration from site.yml and sets up all necessary plugins.
+ *
+ * @module @uniweb/build/site/config
+ *
+ * @example
+ * // Minimal vite.config.js (recommended)
+ * export { default } from '@uniweb/build/site/config'
+ *
+ * @example
+ * // With customization
+ * import { defineSiteConfig } from '@uniweb/build/site'
+ *
+ * export default defineSiteConfig({
+ *   server: { port: 4000 },
+ *   plugins: [myCustomPlugin()],
+ * })
+ */
+
+import { existsSync, readFileSync } from 'node:fs'
+import { resolve, dirname } from 'node:path'
+import yaml from 'js-yaml'
+
+// Virtual module ID for the site entry
+const VIRTUAL_ENTRY_ID = 'virtual:uniweb-site-entry'
+const RESOLVED_VIRTUAL_ENTRY_ID = '\0' + VIRTUAL_ENTRY_ID
+
+/**
+ * Detect foundation type from the foundation config value
+ *
+ * @param {string|Object} foundation - Foundation config from site.yml
+ * @returns {{ type: 'local'|'npm'|'url', name?: string, url?: string, cssUrl?: string, path?: string }}
+ */
+function detectFoundationType(foundation, siteRoot) {
+  // Object form with explicit URL
+  if (foundation && typeof foundation === 'object') {
+    if (foundation.url) {
+      return {
+        type: 'url',
+        url: foundation.url,
+        cssUrl: foundation.css || foundation.cssUrl || null
+      }
+    }
+    // Object form with name
+    foundation = foundation.name || 'foundation'
+  }
+
+  // String form
+  const name = foundation || 'foundation'
+
+  // Check if it's a URL
+  if (name.startsWith('http://') || name.startsWith('https://')) {
+    // Try to infer CSS URL from JS URL
+    const cssUrl = name.replace(/\.js$/, '.css').replace(/foundation\.js/, 'assets/style.css')
+    return {
+      type: 'url',
+      url: name,
+      cssUrl
+    }
+  }
+
+  // Check if it's a local workspace sibling
+  const localPath = resolve(siteRoot, '..', name)
+  if (existsSync(localPath)) {
+    return {
+      type: 'local',
+      name,
+      path: localPath
+    }
+  }
+
+  // Check in foundations/ directory (for multi-site projects)
+  const foundationsPath = resolve(siteRoot, '..', '..', 'foundations', name)
+  if (existsSync(foundationsPath)) {
+    return {
+      type: 'local',
+      name,
+      path: foundationsPath
+    }
+  }
+
+  // Assume npm package
+  return {
+    type: 'npm',
+    name,
+    path: resolve(siteRoot, 'node_modules', name)
+  }
+}
+
+/**
+ * Generate the virtual entry module code based on foundation config
+ *
+ * @param {{ type: string, url?: string, cssUrl?: string }} foundationInfo
+ * @param {boolean} isRuntimeMode
+ * @returns {string}
+ */
+function generateEntryCode(foundationInfo, isRuntimeMode) {
+  if (isRuntimeMode || foundationInfo.type === 'url') {
+    // Runtime loading - foundation loaded dynamically
+    const url = foundationInfo.url || '/foundation/foundation.js'
+    const cssUrl = foundationInfo.cssUrl || '/foundation/assets/style.css'
+
+    return `
+import { initRuntime } from '@uniweb/runtime'
+
+initRuntime({
+  url: '${url}',
+  cssUrl: '${cssUrl}'
+})
+`
+  }
+
+  // Bundled mode - foundation imported at build time
+  return `
+import { initRuntime } from '@uniweb/runtime'
+import foundation from '#foundation'
+import '#foundation/styles'
+
+initRuntime(foundation)
+`
+}
+
+/**
+ * Create the virtual entry plugin
+ */
+function virtualEntryPlugin(foundationInfo, isRuntimeMode) {
+  const entryCode = generateEntryCode(foundationInfo, isRuntimeMode)
+
+  return {
+    name: 'uniweb:virtual-entry',
+    resolveId(id) {
+      if (id === VIRTUAL_ENTRY_ID) {
+        return RESOLVED_VIRTUAL_ENTRY_ID
+      }
+    },
+    load(id) {
+      if (id === RESOLVED_VIRTUAL_ENTRY_ID) {
+        return entryCode
+      }
+    }
+  }
+}
+
+/**
+ * Read and parse site.yml configuration
+ *
+ * @param {string} siteRoot - Path to site directory
+ * @returns {Object}
+ */
+function readSiteConfig(siteRoot) {
+  const configPath = resolve(siteRoot, 'site.yml')
+  if (!existsSync(configPath)) {
+    return {}
+  }
+
+  try {
+    return yaml.load(readFileSync(configPath, 'utf8')) || {}
+  } catch (err) {
+    console.warn('[site-config] Failed to read site.yml:', err.message)
+    return {}
+  }
+}
+
+/**
+ * Create a complete Vite configuration for a Uniweb site
+ *
+ * @param {Object} [options={}] - Configuration overrides
+ * @param {Object} [options.server] - Vite server options
+ * @param {Array} [options.plugins] - Additional Vite plugins
+ * @param {Object} [options.build] - Vite build options
+ * @param {Object} [options.resolve] - Vite resolve options
+ * @param {Object} [options.seo] - SEO configuration for siteContentPlugin
+ * @param {Object} [options.assets] - Asset processing configuration
+ * @param {Object} [options.search] - Search index configuration
+ * @returns {Promise<Object>} Vite configuration
+ */
+export async function defineSiteConfig(options = {}) {
+  const {
+    plugins: extraPlugins = [],
+    server: serverOverrides = {},
+    build: buildOverrides = {},
+    resolve: resolveOverrides = {},
+    seo = {},
+    assets = {},
+    search = {},
+    ...restOptions
+  } = options
+
+  // Determine site root (where vite.config.js is)
+  const siteRoot = process.cwd()
+
+  // Read site.yml
+  const siteConfig = readSiteConfig(siteRoot)
+
+  // Detect foundation type
+  const foundationInfo = detectFoundationType(siteConfig.foundation, siteRoot)
+
+  // Check for runtime mode (env variable or URL-based foundation)
+  const isRuntimeMode =
+    process.env.VITE_FOUNDATION_MODE === 'runtime' || foundationInfo.type === 'url'
+
+  // Dynamic imports for optional peer dependencies
+  // These are imported dynamically to avoid requiring them when not needed
+  const [
+    { default: tailwindcss },
+    { default: react },
+    { default: svgr },
+    { siteContentPlugin },
+    { foundationDevPlugin }
+  ] = await Promise.all([
+    import('@tailwindcss/vite'),
+    import('@vitejs/plugin-react'),
+    import('vite-plugin-svgr'),
+    import('./plugin.js'),
+    import('../dev/plugin.js')
+  ])
+
+  // Build the plugins array
+  const plugins = [
+    // Virtual entry module
+    virtualEntryPlugin(foundationInfo, isRuntimeMode),
+
+    // Standard plugins
+    tailwindcss(),
+    react(),
+    svgr(),
+
+    // Site content collection and injection
+    siteContentPlugin({
+      sitePath: './',
+      inject: true,
+      seo,
+      assets,
+      search
+    }),
+
+    // Foundation dev server (only in runtime mode with local foundation)
+    isRuntimeMode &&
+      foundationInfo.type === 'local' &&
+      foundationDevPlugin({
+        name: foundationInfo.name,
+        path: foundationInfo.path,
+        serve: '/foundation',
+        watch: true
+      }),
+
+    // User-provided plugins
+    ...extraPlugins
+  ].filter(Boolean)
+
+  // Build resolve.alias configuration
+  const alias = {}
+
+  // Set up #foundation alias for bundled mode
+  if (!isRuntimeMode && foundationInfo.type !== 'url') {
+    alias['#foundation'] = foundationInfo.name
+  }
+
+  // Merge with user overrides
+  const resolveConfig = {
+    alias: {
+      ...alias,
+      ...resolveOverrides.alias
+    },
+    ...resolveOverrides
+  }
+  delete resolveConfig.alias // We'll add it back properly
+  resolveConfig.alias = { ...alias, ...resolveOverrides.alias }
+
+  return {
+    plugins,
+
+    resolve: {
+      alias: {
+        ...alias,
+        ...resolveOverrides?.alias
+      }
+    },
+
+    server: {
+      fs: { allow: ['..'] },
+      port: siteConfig.build?.port || 3000,
+      ...serverOverrides
+    },
+
+    build: {
+      ...buildOverrides
+    },
+
+    optimizeDeps: {
+      include: ['react', 'react-dom', 'react-dom/client', 'react-router-dom']
+    },
+
+    ...restOptions
+  }
+}
+
+/**
+ * Default export - an async function that can be used directly as vite.config.js
+ *
+ * @example
+ * // vite.config.js - simplest form
+ * export { default } from '@uniweb/build/site/config'
+ */
+export default function (overrides = {}) {
+  return defineSiteConfig(overrides)
+}

package/src/site/index.js

@@ -6,7 +6,8 @@
  * @module @uniweb/build/site
  */
 
-export { siteContentPlugin, default } from './plugin.js'
+export { siteContentPlugin } from './plugin.js'
+export { defineSiteConfig, default } from './config.js'
 export { collectSiteContent } from './content-collector.js'
 export {
   resolveAssetPath,

package/src/site/plugin.js

@@ -35,6 +35,7 @@ import { watch } from 'node:fs'
 import { collectSiteContent } from './content-collector.js'
 import { processAssets, rewriteSiteContentPaths } from './asset-processor.js'
 import { processAdvancedAssets } from './advanced-processors.js'
+import { generateSearchIndex, isSearchEnabled, getSearchIndexFilename } from '../search/index.js'
 
 /**
  * Generate sitemap.xml content
@@ -225,6 +226,9 @@ function escapeHtml(str) {
  * @param {string} [options.assets.outputDir='assets'] - Output subdirectory for processed assets
  * @param {boolean} [options.assets.videoPosters=true] - Extract poster frames from videos (requires ffmpeg)
  * @param {boolean} [options.assets.pdfThumbnails=true] - Generate thumbnails for PDFs (requires pdf-lib)
+ * @param {Object} [options.search] - Search index configuration
+ * @param {boolean} [options.search.enabled=true] - Generate search index (uses site.yml config by default)
+ * @param {string} [options.search.filename='search-index.json'] - Search index filename
  */
 export function siteContentPlugin(options = {}) {
   const {
@@ -235,7 +239,8 @@ export function siteContentPlugin(options = {}) {
     filename = 'site-content.json',
     watch: shouldWatch = true,
     seo = {},
-    assets: assetsConfig = {}
+    assets: assetsConfig = {},
+    search: searchPluginConfig = {}
   } = options
 
   // Extract asset processing options
@@ -340,6 +345,28 @@ export function siteContentPlugin(options = {}) {
           return
         }
 
+        // Serve search-index.json in dev mode (supports locale prefixes)
+        const searchIndexMatch = req.url.match(/^(?:\/([a-z]{2}))?\/search-index\.json$/)
+        if (searchIndexMatch && siteContent) {
+          const searchEnabled = searchPluginConfig.enabled !== false && isSearchEnabled(siteContent)
+          if (searchEnabled) {
+            const searchConfig = siteContent.config?.search || {}
+            const defaultLocale = siteContent.config?.defaultLanguage || 'en'
+            // Use requested locale from URL, fall back to active or default
+            const requestedLocale = searchIndexMatch[1]
+            const activeLocale = requestedLocale || siteContent.config?.activeLocale || defaultLocale
+
+            const searchIndex = generateSearchIndex(siteContent, {
+              locale: activeLocale,
+              search: searchConfig
+            })
+
+            res.setHeader('Content-Type', 'application/json')
+            res.end(JSON.stringify(searchIndex, null, 2))
+            return
+          }
+        }
+
         next()
       })
     },
@@ -482,6 +509,29 @@ export function siteContentPlugin(options = {}) {
         })
         console.log('[site-content] Generated robots.txt')
       }
+
+      // Generate search index if enabled
+      const searchEnabled = searchPluginConfig.enabled !== false && isSearchEnabled(finalContent)
+      if (searchEnabled) {
+        const searchConfig = finalContent.config?.search || {}
+        const defaultLocale = finalContent.config?.defaultLanguage || 'en'
+        const activeLocale = finalContent.config?.activeLocale || defaultLocale
+
+        // Generate search index for current locale
+        const searchIndex = generateSearchIndex(finalContent, {
+          locale: activeLocale,
+          search: searchConfig
+        })
+
+        const searchFilename = getSearchIndexFilename(activeLocale, defaultLocale)
+        this.emitFile({
+          type: 'asset',
+          fileName: searchFilename,
+          source: JSON.stringify(searchIndex, null, 2)
+        })
+
+        console.log(`[site-content] Generated ${searchFilename} (${searchIndex.count} entries)`)
+      }
     },
 
     closeBundle() {