@uniweb/build 0.5.0 → 0.6.0

package/src/i18n/index.js

@@ -20,6 +20,7 @@ import {
   extractCollectionContent,
   buildLocalizedCollections,
   getCollectionLocales,
+  translateCollectionData,
   COLLECTIONS_DIR
 } from './collections.js'
 import { generateSearchIndex, isSearchEnabled } from '../search/index.js'
@@ -69,6 +70,7 @@ export {
   extractCollectionContent,
   buildLocalizedCollections,
   getCollectionLocales,
+  translateCollectionData,
   COLLECTIONS_DIR,
 
   // Locale resolution

package/src/prerender.js

@@ -26,19 +26,19 @@ let preparePropsSSR, getComponentMetaSSR
  * @param {Object} siteContent - The site content from site-content.json
  * @param {string} siteDir - Path to the site directory
  * @param {function} onProgress - Progress callback
- * @returns {Object} { siteCascadedData, pageFetchedData } - Fetched data for dynamic route expansion
+ * @returns {Object} { pageFetchedData, fetchedData } - Fetched data for dynamic route expansion and DataStore pre-population
  */
 async function executeAllFetches(siteContent, siteDir, onProgress) {
   const fetchOptions = { siteRoot: siteDir, publicDir: 'public' }
+  const fetchedData = [] // Collected for DataStore pre-population
 
-  // 1. Site-level fetch (cascades to all pages)
-  let siteCascadedData = {}
+  // 1. Site-level fetch
   const siteFetch = siteContent.config?.fetch
   if (siteFetch && siteFetch.prerender !== false) {
     onProgress(`  Fetching site data: ${siteFetch.path || siteFetch.url}`)
     const result = await executeFetch(siteFetch, fetchOptions)
     if (result.data && !result.error) {
-      siteCascadedData[siteFetch.schema] = result.data
+      fetchedData.push({ config: siteFetch, data: result.data })
     }
   }
 
@@ -46,14 +46,13 @@ async function executeAllFetches(siteContent, siteDir, onProgress) {
   const pageFetchedData = new Map()
 
   for (const page of siteContent.pages || []) {
-    // Page-level fetch (cascades to sections in this page)
-    let pageCascadedData = { ...siteCascadedData }
+    // Page-level fetch
     const pageFetch = page.fetch
     if (pageFetch && pageFetch.prerender !== false) {
       onProgress(`  Fetching page data for ${page.route}: ${pageFetch.path || pageFetch.url}`)
       const result = await executeFetch(pageFetch, fetchOptions)
       if (result.data && !result.error) {
-        pageCascadedData[pageFetch.schema] = result.data
+        fetchedData.push({ config: pageFetch, data: result.data })
         // Store for dynamic route expansion
         pageFetchedData.set(page.route, {
           schema: pageFetch.schema,
@@ -62,11 +61,11 @@ async function executeAllFetches(siteContent, siteDir, onProgress) {
       }
     }
 
-    // Process sections recursively (handles subsections too)
-    await processSectionFetches(page.sections, pageCascadedData, fetchOptions, onProgress)
+    // Process section-level fetches (own fetch → parsedContent.data, not cascaded)
+    await processSectionFetches(page.sections, fetchOptions, onProgress)
   }
 
-  return { siteCascadedData, pageFetchedData }
+  return { pageFetchedData, fetchedData }
 }
 
 /**
@@ -142,12 +141,6 @@ function expandDynamicPages(pages, pageFetchedData, onProgress) {
         allItems: items,      // All items from parent
       }
 
-      // Also inject into sections' cascadedData for components with inheritData
-      injectDynamicData(concretePage.sections, {
-        [singularSchema]: item,  // Current item as singular
-        [schema]: items,          // All items as plural
-      })
-
       // Use item data for page metadata if available
       if (item.title) concretePage.title = item.title
       if (item.description || item.excerpt) concretePage.description = item.description || item.excerpt
@@ -159,38 +152,15 @@ function expandDynamicPages(pages, pageFetchedData, onProgress) {
   return expandedPages
 }
 
-/**
- * Inject dynamic route data into section cascadedData
- * This ensures components with inheritData receive the current item
- *
- * @param {Array} sections - Sections to update
- * @param {Object} data - Data to inject { article: {...}, articles: [...] }
- */
-function injectDynamicData(sections, data) {
-  if (!sections || !Array.isArray(sections)) return
-
-  for (const section of sections) {
-    section.cascadedData = {
-      ...(section.cascadedData || {}),
-      ...data,
-    }
-
-    // Recurse into subsections
-    if (section.subsections && section.subsections.length > 0) {
-      injectDynamicData(section.subsections, data)
-    }
-  }
-}
-
 /**
  * Process fetch configs for sections (and subsections recursively)
+ * Section-level fetches merge data into parsedContent.data (not cascaded).
  *
  * @param {Array} sections - Array of section objects
- * @param {Object} cascadedData - Data cascaded from site/page level
  * @param {Object} fetchOptions - Options for executeFetch
  * @param {function} onProgress - Progress callback
  */
-async function processSectionFetches(sections, cascadedData, fetchOptions, onProgress) {
+async function processSectionFetches(sections, fetchOptions, onProgress) {
   if (!sections || !Array.isArray(sections)) return
 
   for (const section of sections) {
@@ -210,12 +180,9 @@ async function processSectionFetches(sections, cascadedData, fetchOptions, onPro
       }
     }
 
-    // Attach cascaded data for components with inheritData
-    section.cascadedData = cascadedData
-
     // Process subsections recursively
     if (section.subsections && section.subsections.length > 0) {
-      await processSectionFetches(section.subsections, cascadedData, fetchOptions, onProgress)
+      await processSectionFetches(section.subsections, fetchOptions, onProgress)
     }
   }
 }
@@ -329,6 +296,13 @@ function getWrapperProps(block) {
     style.position = 'relative'
   }
 
+  // Apply context overrides as inline CSS custom properties (mirrors BlockRenderer.jsx)
+  if (block.contextOverrides) {
+    for (const [key, value] of Object.entries(block.contextOverrides)) {
+      style[`--${key}`] = value
+    }
+  }
+
   const sectionId = block.stableId || block.id
   return { id: `section-${sectionId}`, style, className, background }
 }
@@ -372,18 +346,16 @@ function renderBackground(background) {
 
   if (background.mode === 'gradient' && background.gradient) {
     const g = background.gradient
-    const angle = g.angle || 0
-    const start = g.start || 'transparent'
-    const end = g.end || 'transparent'
-    const startPos = g.startPosition || 0
-    const endPos = g.endPosition || 100
+    // Raw CSS gradient string (e.g., "linear-gradient(to bottom, #000, #333)")
+    const bgValue = typeof g === 'string' ? g
+      : `linear-gradient(${g.angle || 0}deg, ${g.start || 'transparent'} ${g.startPosition || 0}%, ${g.end || 'transparent'} ${g.endPosition || 100}%)`
     children.push(
       React.createElement('div', {
         key: 'bg-gradient',
         className: 'background-gradient',
         style: {
           position: 'absolute', inset: '0',
-          background: `linear-gradient(${angle}deg, ${start} ${startPos}%, ${end} ${endPos}%)`
+          background: bgValue
         },
         'aria-hidden': 'true'
       })
@@ -449,7 +421,8 @@ function renderBackground(background) {
 
 /**
  * Render a single block for SSR
- * Mirrors BlockRenderer.jsx but without hooks (no runtime data fetching in SSR)
+ * Mirrors BlockRenderer.jsx but without hooks (no runtime data fetching in SSR).
+ * block.dataLoading is always false at prerender time — runtime fetches only happen client-side.
  */
 function renderBlock(block) {
   const Component = block.initComponent()
@@ -462,35 +435,37 @@ function renderBlock(block) {
   }
 
   // Build content and params with runtime guarantees
-  let content, params
-
-  if (block.parsedContent?._isPoc) {
-    content = block.parsedContent._pocContent
-    params = block.properties
-  } else {
-    const meta = getComponentMetaSSR(block.type)
-    const prepared = preparePropsSSR(block, meta)
-    params = prepared.params
-    content = {
-      ...prepared.content,
-      ...block.properties,
-      _prosemirror: block.parsedContent
-    }
+  const meta = getComponentMetaSSR(block.type)
+  const prepared = preparePropsSSR(block, meta)
+  let params = prepared.params
+  let content = {
+    ...prepared.content,
+    ...block.properties,
   }
 
   // Background handling (mirrors BlockRenderer.jsx)
   const { background, ...wrapperProps } = getWrapperProps(block)
-  const meta = getComponentMetaSSR(block.type)
-  const hasBackground = background?.mode && meta?.background !== 'self'
 
-  if (hasBackground) {
-    params = { ...params, _hasBackground: true }
+  // Merge Component.className (static classes declared on the component function)
+  // Order: context-{theme} + block.state.className + Component.className
+  const componentClassName = Component.className
+  if (componentClassName) {
+    wrapperProps.className = wrapperProps.className
+      ? `${wrapperProps.className} ${componentClassName}`
+      : componentClassName
   }
 
+  const hasBackground = background?.mode && meta?.background !== 'self'
+
+  block.hasBackground = hasBackground
+
+  // Use Component.as as the wrapper tag (default: 'section')
+  const wrapperTag = Component.as || 'section'
+
   const componentProps = { content, params, block }
 
   if (hasBackground) {
-    return React.createElement('section', wrapperProps,
+    return React.createElement(wrapperTag, wrapperProps,
       renderBackground(background),
       React.createElement('div', { className: 'relative z-10' },
         React.createElement(Component, componentProps)
@@ -498,7 +473,7 @@ function renderBlock(block) {
     )
   }
 
-  return React.createElement('section', wrapperProps,
+  return React.createElement(wrapperTag, wrapperProps,
     React.createElement(Component, componentProps)
   )
 }
@@ -678,7 +653,10 @@ export async function prerenderSite(siteDir, options = {}) {
 
     // Execute data fetches (site, page, section levels)
     onProgress('Executing data fetches...')
-    const { siteCascadedData, pageFetchedData } = await executeAllFetches(siteContent, siteDir, onProgress)
+    const { pageFetchedData, fetchedData } = await executeAllFetches(siteContent, siteDir, onProgress)
+
+    // Store fetchedData on siteContent for runtime DataStore pre-population
+    siteContent.fetchedData = fetchedData
 
     // Expand dynamic pages (e.g., /blog/:slug → /blog/post-1, /blog/post-2)
     if (siteContent.pages?.some(p => p.isDynamic)) {
@@ -693,6 +671,14 @@ export async function prerenderSite(siteDir, options = {}) {
     // Initialize the Uniweb runtime for this locale
     onProgress('Initializing runtime...')
     const uniweb = createUniweb(siteContent)
+
+    // Pre-populate DataStore so EntityStore can resolve data during prerender
+    if (fetchedData.length > 0 && uniweb.activeWebsite?.dataStore) {
+      for (const entry of fetchedData) {
+        uniweb.activeWebsite.dataStore.set(entry.config, entry.data)
+      }
+    }
+
     uniweb.setFoundation(foundation)
 
     // Set base path from site config so components can access it during SSR

package/src/runtime-schema.js

@@ -197,15 +197,36 @@ export function extractRuntimeSchema(fullMeta) {
   }
 
   // Data binding (CMS entities)
+  // Supports both old format (data: 'person:6') and new consolidated format
+  // (data: { entity: 'person:6', schemas: {...}, inherit: [...] })
   if (fullMeta.data) {
-    const parsed = parseDataString(fullMeta.data)
-    if (parsed) {
-      runtime.data = parsed
+    if (typeof fullMeta.data === 'string') {
+      // Old format: data: 'person:6'
+      const parsed = parseDataString(fullMeta.data)
+      if (parsed) {
+        runtime.data = parsed
+      }
+    } else if (typeof fullMeta.data === 'object') {
+      // New format: data: { entity, schemas, inherit }
+      if (fullMeta.data.entity) {
+        const parsed = parseDataString(fullMeta.data.entity)
+        if (parsed) {
+          runtime.data = parsed
+        }
+      }
+      if (fullMeta.data.schemas) {
+        const schemas = extractSchemas(fullMeta.data.schemas)
+        if (schemas) {
+          runtime.schemas = schemas
+        }
+      }
+      if (fullMeta.data.inherit !== undefined) {
+        runtime.inheritData = fullMeta.data.inherit
+      }
     }
   }
 
-  // Param defaults - support both v2 'params' and v1 'properties'
-  const paramsObj = fullMeta.params || fullMeta.properties
+  const paramsObj = fullMeta.params
   const defaults = extractParamDefaults(paramsObj)
   if (defaults) {
     runtime.defaults = defaults
@@ -225,7 +246,8 @@ export function extractRuntimeSchema(fullMeta) {
 
   // Schemas - lean version for runtime validation/defaults
   // Strips editor-only fields (label, hint, description)
-  if (fullMeta.schemas) {
+  // Top-level schemas supported for backwards compat (lower priority than data.schemas)
+  if (fullMeta.schemas && !runtime.schemas) {
     const schemas = extractSchemas(fullMeta.schemas)
     if (schemas) {
       runtime.schemas = schemas
@@ -234,10 +256,17 @@ export function extractRuntimeSchema(fullMeta) {
 
   // Data inheritance - component receives cascaded data from page/site level fetches
   // Can be: true (inherit all), false (inherit none), or ['schema1', 'schema2'] (selective)
-  if (fullMeta.inheritData !== undefined) {
+  // Top-level inheritData supported for backwards compat (lower priority than data.inherit)
+  if (fullMeta.inheritData !== undefined && runtime.inheritData === undefined) {
     runtime.inheritData = fullMeta.inheritData
   }
 
+  // Auto-derive inheritData from entity type when no explicit inherit is set.
+  // data: { entity: 'articles' } implies inheritData: ['articles']
+  if (runtime.data && runtime.inheritData === undefined) {
+    runtime.inheritData = [runtime.data.type]
+  }
+
   return Object.keys(runtime).length > 0 ? runtime : null
 }
 

package/src/site/collection-processor.js

@@ -1,15 +1,15 @@
 /**
  * Collection Processor
  *
- * Processes content collections from markdown files into JSON data.
+ * Processes content collections from markdown and YAML files into JSON data.
  * Collections are defined in site.yml and processed at build time.
  *
  * Features:
- * - Discovers markdown files in collection folders
- * - Parses frontmatter for metadata
+ * - Discovers markdown (.md), data (.yml/.yaml), and JSON (.json) files in collection folders
+ * - Parses frontmatter for metadata (markdown), full YAML (data items), or JSON (data items)
  * - Converts markdown body to ProseMirror JSON
  * - Supports filtering, sorting, and limiting
- * - Auto-generates excerpts and extracts first images
+ * - Auto-generates excerpts and extracts first images (markdown items only)
  *
  * @module @uniweb/build/site/collection-processor
  *
@@ -315,6 +315,53 @@ async function processCollectionAssets(content, itemPath, siteRoot, collectionNa
 
 // Filter and sort utilities are imported from data-fetcher.js
 
+/**
+ * Process a single data item from a YAML file
+ *
+ * YAML items are pure data — no ProseMirror conversion, no body, no excerpt,
+ * no image extraction, no lastModified. The output is slug + YAML fields.
+ *
+ * @param {string} dir - Collection directory path
+ * @param {string} filename - YAML filename (.yml or .yaml)
+ * @returns {Promise<Object|null>} Processed item or null if unpublished
+ */
+async function processDataItem(dir, filename) {
+  const filepath = join(dir, filename)
+  const raw = await readFile(filepath, 'utf-8')
+  const slug = basename(filename, extname(filename))
+  const data = yaml.load(raw) || {}
+
+  // Skip unpublished items
+  if (data.published === false) return null
+
+  return { slug, ...data }
+}
+
+/**
+ * Process a single data item from a JSON file
+ *
+ * JSON items are pure data — like YAML items, no ProseMirror conversion.
+ * A JSON file containing an array returns all items (single-file collection).
+ * A JSON file containing an object returns a single item with slug from filename.
+ *
+ * @param {string} dir - Collection directory path
+ * @param {string} filename - JSON filename
+ * @returns {Promise<Object|Array|null>} Processed item(s) or null if unpublished
+ */
+async function processJsonItem(dir, filename) {
+  const filepath = join(dir, filename)
+  const raw = await readFile(filepath, 'utf-8')
+  const slug = basename(filename, '.json')
+  const data = JSON.parse(raw)
+
+  // Array → multiple items (single-file collection)
+  if (Array.isArray(data)) return data
+
+  // Object → single item
+  if (data.published === false) return null
+  return { slug, ...data }
+}
+
 /**
  * Process a single content item from a markdown file
  *
@@ -384,13 +431,27 @@ async function collectItems(siteDir, config) {
   }
 
   const files = await readdir(collectionDir)
-  const mdFiles = files.filter(f => f.endsWith('.md') && !f.startsWith('_'))
+  const itemFiles = files.filter(f =>
+    !f.startsWith('_') &&
+    (f.endsWith('.md') || f.endsWith('.yml') || f.endsWith('.yaml') || f.endsWith('.json'))
+  )
 
-  // Process all markdown files
+  // Process all collection files (markdown → content items, YAML/JSON → data items)
   let items = await Promise.all(
-    mdFiles.map(file => processContentItem(collectionDir, file, config, siteDir))
+    itemFiles.map(file => {
+      if (file.endsWith('.json')) {
+        return processJsonItem(collectionDir, file)
+      }
+      if (file.endsWith('.yml') || file.endsWith('.yaml')) {
+        return processDataItem(collectionDir, file)
+      }
+      return processContentItem(collectionDir, file, config, siteDir)
+    })
   )
 
+  // Flatten arrays from JSON files that contain multiple items
+  items = items.flat()
+
   // Filter out nulls (unpublished items)
   items = items.filter(Boolean)
 
@@ -496,11 +557,14 @@ export async function getCollectionLastModified(siteDir, config) {
   }
 
   const files = await readdir(collectionDir)
-  const mdFiles = files.filter(f => f.endsWith('.md') && !f.startsWith('_'))
+  const itemFiles = files.filter(f =>
+    !f.startsWith('_') &&
+    (f.endsWith('.md') || f.endsWith('.yml') || f.endsWith('.yaml') || f.endsWith('.json'))
+  )
 
   let lastModified = null
 
-  for (const file of mdFiles) {
+  for (const file of itemFiles) {
     const fileStat = await stat(join(collectionDir, file))
     if (!lastModified || fileStat.mtime > lastModified) {
       lastModified = fileStat.mtime

package/src/site/data-fetcher.js

@@ -245,9 +245,10 @@ export function parseFetchConfig(fetch) {
     path,
     url,
     schema,
-    prerender = true,
+    prerender = url ? false : true,
     merge = false,
     transform,
+    detail,
     // Post-processing options (also supported for path/url fetches)
     limit,
     sort,
@@ -264,6 +265,7 @@ export function parseFetchConfig(fetch) {
     prerender,
     merge,
     transform,
+    detail,
     // Post-processing options
     limit,
     sort,

package/src/site/plugin.js

@@ -41,50 +41,51 @@ import { executeFetch, mergeDataIntoContent } from './data-fetcher.js'
 
 /**
  * Execute all fetches for site content (used in dev mode)
- * Populates section.cascadedData with fetched data
+ * Collects fetchedData for DataStore pre-population at runtime
  *
  * @param {Object} siteContent - The collected site content
  * @param {string} siteDir - Path to site directory
  */
 async function executeDevFetches(siteContent, siteDir) {
   const fetchOptions = { siteRoot: siteDir, publicDir: 'public' }
+  const fetchedData = []
 
   // Site-level fetch
-  let siteCascadedData = {}
   const siteFetch = siteContent.config?.fetch
   if (siteFetch) {
     const result = await executeFetch(siteFetch, fetchOptions)
     if (result.data && !result.error) {
-      siteCascadedData[siteFetch.schema] = result.data
+      fetchedData.push({ config: siteFetch, data: result.data })
     }
   }
 
   // Process each page
   for (const page of siteContent.pages || []) {
-    let pageCascadedData = { ...siteCascadedData }
-
     // Page-level fetch
     const pageFetch = page.fetch
     if (pageFetch) {
       const result = await executeFetch(pageFetch, fetchOptions)
       if (result.data && !result.error) {
-        pageCascadedData[pageFetch.schema] = result.data
+        fetchedData.push({ config: pageFetch, data: result.data })
       }
     }
 
-    // Process sections
-    await processDevSectionFetches(page.sections, pageCascadedData, fetchOptions)
+    // Process section-level fetches (own fetch → parsedContent.data)
+    await processDevSectionFetches(page.sections, fetchOptions)
   }
+
+  // Store on siteContent for runtime DataStore pre-population
+  siteContent.fetchedData = fetchedData
 }
 
 /**
  * Process fetches for sections recursively
+ * Section-level fetches merge data into parsedContent.data (not cascaded).
  *
  * @param {Array} sections - Sections to process
- * @param {Object} cascadedData - Data from parent levels
  * @param {Object} fetchOptions - Options for executeFetch
  */
-async function processDevSectionFetches(sections, cascadedData, fetchOptions) {
+async function processDevSectionFetches(sections, fetchOptions) {
   if (!sections || !Array.isArray(sections)) return
 
   for (const section of sections) {
@@ -104,13 +105,9 @@ async function processDevSectionFetches(sections, cascadedData, fetchOptions) {
       }
     }
 
-    // Attach cascaded data for components with inheritData
-    // Note: cascadedData is from page/site level only, not section's own fetch
-    section.cascadedData = cascadedData
-
     // Process subsections recursively
     if (section.subsections && section.subsections.length > 0) {
-      await processDevSectionFetches(section.subsections, cascadedData, fetchOptions)
+      await processDevSectionFetches(section.subsections, fetchOptions)
     }
   }
 }
@@ -376,6 +373,7 @@ export function siteContentPlugin(options = {}) {
   let watcher = null
   let server = null
   let localeTranslations = {} // Cache: { locale: translations }
+  let collectionTranslations = {} // Cache: { locale: collection translations }
   let localesDir = 'locales' // Default, updated from site config
   let collectionsConfig = null // Cached for watcher setup
 
@@ -402,6 +400,29 @@ export function siteContentPlugin(options = {}) {
     }
   }
 
+  /**
+   * Load collection translations for a specific locale
+   */
+  async function loadCollectionTranslations(locale) {
+    if (collectionTranslations[locale]) {
+      return collectionTranslations[locale]
+    }
+
+    const localePath = join(resolvedSitePath, localesDir, 'collections', `${locale}.json`)
+    if (!existsSync(localePath)) {
+      return null
+    }
+
+    try {
+      const content = await readFile(localePath, 'utf-8')
+      const translations = JSON.parse(content)
+      collectionTranslations[locale] = translations
+      return translations
+    } catch {
+      return null
+    }
+  }
+
   /**
    * Get available locales from locales directory
    */
@@ -504,6 +525,7 @@ export function siteContentPlugin(options = {}) {
 
         // Clear translation cache on rebuild
         localeTranslations = {}
+        collectionTranslations = {}
       } catch (err) {
         console.error('[site-content] Failed to collect content:', err.message)
         siteContent = { config: {}, theme: {}, pages: [] }
@@ -621,6 +643,7 @@ export function siteContentPlugin(options = {}) {
           const localeWatcher = watch(localesPath, { recursive: false }, () => {
             console.log('[site-content] Translation files changed, clearing cache...')
             localeTranslations = {}
+            collectionTranslations = {}
             server.ws.send({ type: 'full-reload' })
           })
           additionalWatchers.push(localeWatcher)
@@ -643,6 +666,22 @@ export function siteContentPlugin(options = {}) {
             // freeform dir may not exist, that's ok
           }
         }
+
+        // Watch collection translations directory
+        const collectionsLocalesPath = resolve(localesPath, 'collections')
+        if (existsSync(collectionsLocalesPath)) {
+          try {
+            const collWatcher = watch(collectionsLocalesPath, { recursive: false }, () => {
+              console.log('[site-content] Collection translations changed, clearing cache...')
+              collectionTranslations = {}
+              server.ws.send({ type: 'full-reload' })
+            })
+            additionalWatchers.push(collWatcher)
+            console.log(`[site-content] Watching ${collectionsLocalesPath} for collection translation changes`)
+          } catch (err) {
+            // collections locales dir may not exist, that's ok
+          }
+        }
       }
 
       // Add additional watchers to cleanup
@@ -721,6 +760,45 @@ export function siteContentPlugin(options = {}) {
           }
         }
 
+        // Handle localized collection data (e.g., /fr/data/articles.json)
+        const localeDataMatch = req.url.match(/^\/([a-z]{2})\/data\/(.+\.json)$/)
+        if (localeDataMatch) {
+          const locale = localeDataMatch[1]
+          const filename = localeDataMatch[2]
+          const collectionName = filename.replace('.json', '')
+          const sourcePath = join(resolvedSitePath, 'public', 'data', filename)
+
+          if (existsSync(sourcePath)) {
+            try {
+              const raw = await readFile(sourcePath, 'utf-8')
+              const items = JSON.parse(raw)
+
+              // Load collection translations for this locale
+              const translations = await loadCollectionTranslations(locale) || {}
+
+              // Check for free-form translations
+              const freeformDir = join(resolvedSitePath, localesDir, 'freeform', locale)
+              const hasFreeform = existsSync(freeformDir)
+
+              // Translate using the collections module
+              const { translateCollectionData } = await import('../i18n/collections.js')
+              const translated = await translateCollectionData(items, collectionName, resolvedSitePath, {
+                locale,
+                localesDir: join(resolvedSitePath, localesDir),
+                translations,
+                freeformEnabled: hasFreeform
+              })
+
+              res.setHeader('Content-Type', 'application/json')
+              res.end(JSON.stringify(translated, null, 2))
+              return
+            } catch (err) {
+              console.warn(`[site-content] Failed to serve localized collection ${filename}: ${err.message}`)
+              // Fall through to Vite's static server
+            }
+          }
+        }
+
         next()
       })
     },