@uniweb/build 0.52.7 → 0.54.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.52.7",
+  "version": "0.54.0",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -60,12 +60,12 @@
     "@uniweb/content-reader": "^1.2.5",
     "@uniweb/semantic-parser": "^1.4.1",
     "@uniweb/schemas": "^0.3.3",
-    "@uniweb/theming": "^0.1.15",
     "@uniweb/content-writer": "^0.3.4",
+    "@uniweb/theming": "^0.1.15",
     "@uniweb/projections": "^0.7.3"
   },
   "optionalDependencies": {
-    "@uniweb/runtime": "^0.26.4"
+    "@uniweb/runtime": "^0.26.5"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0",
@@ -74,7 +74,7 @@
     "@tailwindcss/vite": "^4.0.0",
     "@vitejs/plugin-react": "^4.0.0 || ^5.0.0",
     "vite-plugin-svgr": "^4.0.0",
-    "@uniweb/runtime": "^0.26.4",
+    "@uniweb/runtime": "^0.26.5",
     "@uniweb/core": "^0.29.4"
   },
   "peerDependenciesMeta": {

package/src/i18n/audit.js

@@ -11,6 +11,17 @@ import { readFile, writeFile } from 'fs/promises'
 import { existsSync } from 'node:fs'
 import { join } from 'node:path'
 
+// Inline markdown → ProseMirror, so the markup check asks the merge's own question
+// ("would this value produce marks?") instead of pattern-matching markdown syntax.
+// Same lazy-import-with-fallback pattern as merge.js / extract.js.
+let markdownToProseMirror
+try {
+  const contentReader = await import('@uniweb/content-reader')
+  markdownToProseMirror = contentReader.markdownToProseMirror
+} catch {
+  markdownToProseMirror = null
+}
+
 /**
  * Audit a locale file against the manifest
  * @param {string} localesPath - Path to locales directory
@@ -46,18 +57,27 @@ export async function auditLocale(localesPath, locale) {
   const valid = []
   const missing = []
   const stale = []
-  const needsTags = []
+  const losesMarkup = []
 
   // Check manifest entries
   for (const hash of manifestHashes) {
     if (translationHashes.has(hash)) {
-      const source = manifest.units[hash].source
+      const unit = manifest.units[hash]
+      const source = unit.source
       const translation = getTranslationText(translations[hash])
       valid.push({ hash, source, translation })
 
-      // Flag entries where source has inline tags but translation doesn't
-      if (/<\d+>/.test(source) && !/<\d+>/.test(translation) && translation.length > 0) {
-        needsTags.push({ hash, source, translation })
+      // ⭐ The source element carries inline markdown; the translation does not.
+      // `merge` builds the translated element from the VALUE alone — it never
+      // re-applies marks from the source — so this entry will render as flat prose
+      // and its links will be gone. It still counts as translated, which is why
+      // coverage cannot see it: the whole class scores 100%.
+      // ⛔ REPLACES a `<N>`-tag check that could no longer fire. Those tags were the
+      // pre-2026-06-24 keying scheme (`d12d594`); extraction has not emitted one
+      // since, so the check was dead while looking like a live guard — and it was
+      // the only thing in the pipeline that even gestured at mark fidelity.
+      if (unit.markup && translation.length > 0 && !carriesInlineMarkup(translation)) {
+        losesMarkup.push({ hash, source, markup: unit.markup, translation })
       }
     } else {
       missing.push({
@@ -86,7 +106,29 @@ export async function auditLocale(localesPath, locale) {
     valid,
     missing,
     stale,
-    needsTags
+    losesMarkup
+  }
+}
+
+/**
+ * Does this translation value produce any inline marks when the merge parses it?
+ *
+ * Asks the parser rather than a regex: the merge resolves a value through
+ * `markdownToProseMirror`, so the only honest test of "will this keep its link"
+ * is to run the same conversion. With no converter available the check declines
+ * to fire — a missing dependency must not invent findings.
+ */
+function carriesInlineMarkup(value) {
+  if (!markdownToProseMirror) return true
+  try {
+    const doc = markdownToProseMirror(value)
+    const walk = (nodes) =>
+      (nodes || []).some(
+        (n) => (n?.marks && n.marks.length > 0) || (n?.type && n.type !== 'text' && n.type !== 'paragraph') || walk(n?.content)
+      )
+    return walk(doc?.content)
+  } catch {
+    return true
   }
 }
 
@@ -161,8 +203,8 @@ export function formatAuditReport(results, options = {}) {
     lines.push(`  Valid:   ${result.valid.length} (${coverage}%)`)
     lines.push(`  Missing: ${result.missing.length}`)
     lines.push(`  Stale:   ${result.stale.length}`)
-    if (result.needsTags?.length > 0) {
-      lines.push(`  Needs tags: ${result.needsTags.length}`)
+    if (result.losesMarkup?.length > 0) {
+      lines.push(`  Loses markup: ${result.losesMarkup.length}  (links/bold in the source, plain in the translation)`)
     }
 
     if (verbose && result.stale.length > 0) {
@@ -176,14 +218,16 @@ export function formatAuditReport(results, options = {}) {
       }
     }
 
-    if (verbose && result.needsTags?.length > 0) {
-      lines.push(`\n  Translations missing inline tags:`)
-      for (const entry of result.needsTags.slice(0, 10)) {
-        const src = truncate(entry.source, 50)
-        lines.push(`    - ${entry.hash}: "${src}"`)
+    if (verbose && result.losesMarkup?.length > 0) {
+      lines.push(`\n  Translations that drop the source's inline markup:`)
+      lines.push(`  (a translation value is inline markdown — copy the links and marks across)`)
+      for (const entry of result.losesMarkup.slice(0, 10)) {
+        lines.push(`    - ${entry.hash}`)
+        lines.push(`        source: "${truncate(entry.markup, 60)}"`)
+        lines.push(`        yours:  "${truncate(entry.translation, 60)}"`)
       }
-      if (result.needsTags.length > 10) {
-        lines.push(`    ... and ${result.needsTags.length - 10} more`)
+      if (result.losesMarkup.length > 10) {
+        lines.push(`    ... and ${result.losesMarkup.length - 10} more`)
       }
     }
   }

package/src/i18n/extract.js

@@ -9,6 +9,19 @@ import { resolveDefaultLocale } from '@uniweb/core'
 import { computeHash, stripInlineTags } from './hash.js'
 import { visitDataStrings } from './data-strings.js'
 
+// ProseMirror inline fragment → inline markdown, for the TRANSLATOR-FACING half of
+// a unit. Same lazy-import-with-fallback pattern as merge.js, so the synchronous
+// extraction path has the serializer ready at call time. The fallback is the plain
+// text we already had, so a resolution failure degrades to the old behaviour rather
+// than breaking extraction.
+let serializeInlineContent
+try {
+  const contentWriter = await import('@uniweb/content-writer')
+  serializeInlineContent = contentWriter.serializeInlineContent
+} catch {
+  serializeInlineContent = null
+}
+
 /**
  * Extract all translatable units from site content
  * @param {Object} siteContent - Parsed site-content.json
@@ -231,7 +244,7 @@ function extractFromProseMirrorDoc(doc, context, units) {
       const field = getHeadingField(level, headingIndex)
       headingIndex[`h${level}`]++
 
-      addUnit(units, text, field, context)
+      addUnit(units, text, field, context, elementMarkup(node))
       return
     }
 
@@ -242,12 +255,12 @@ function extractFromProseMirrorDoc(doc, context, units) {
     if (!text) return
 
     if (listIndex !== null) {
-      addUnit(units, text, `list.${listIndex}`, context)
+      addUnit(units, text, `list.${listIndex}`, context, elementMarkup(node))
       return
     }
 
     const field = paragraphIndex === 0 ? 'paragraph' : `paragraph.${paragraphIndex}`
-    addUnit(units, text, field, context)
+    addUnit(units, text, field, context, elementMarkup(node))
     paragraphIndex++
   })
 }
@@ -348,6 +361,37 @@ export function elementText(node) {
   return collectInlineText(node).trim()
 }
 
+/**
+ * A block element's INLINE MARKDOWN — the translator-facing half of a unit.
+ *
+ * ⛔ NOT a second key. `elementText` above stays the key and the hash input,
+ * deliberately: bolding a word or re-targeting a link must not move a hash and
+ * orphan an existing translation.
+ *
+ * WHY THIS EXISTS. `merge.js` parses a translation VALUE as inline markdown, so
+ * the value channel carries links, marks and inline atoms losslessly. The SOURCE
+ * channel did not: a unit stored only the flattened text, `uniweb i18n generate`
+ * seeded locale files from it, and a translator was therefore shown a paragraph
+ * with its links already gone. They cannot restore what they were never shown —
+ * so a fully translated, 100%-covered site rendered with zero inline links, and
+ * no instrument reported anything (coverage counts keys, not fidelity).
+ * Measured 2026-09-18 on a documentation site with 266 internal links.
+ *
+ * Returns null when the serializer is unavailable or adds nothing over the plain
+ * text, so `markup` appears on a unit only when it actually carries more.
+ */
+export function elementMarkup(node) {
+  if (!serializeInlineContent || !node?.content) return null
+  try {
+    const markup = serializeInlineContent(node.content)
+    if (typeof markup !== 'string') return null
+    const trimmed = markup.trim()
+    return trimmed && trimmed !== elementText(node) ? trimmed : null
+  } catch {
+    return null
+  }
+}
+
 function collectInlineText(node) {
   if (!node || !node.content) return ''
   let out = ''
@@ -385,14 +429,18 @@ export function blockElements(doc) {
 /**
  * Add a translation unit to the accumulator
  */
-function addUnit(units, source, field, context) {
+function addUnit(units, source, field, context, markup = null) {
   if (!source || source.length === 0) return
 
   // Hash on plain text (strip inline tags) so keys stay stable
   const hash = computeHash(stripInlineTags(source))
 
   if (units[hash]) {
-    // Unit exists - add context if not already present
+    // Unit exists - add context if not already present.
+    // Two elements can share a key and differ in markup ("Learn more" plain in one
+    // place, linked in another). The first occurrence wins the field and the order,
+    // but a later one may be the only carrier of markup, so fill it rather than drop it.
+    if (markup && !units[hash].markup) units[hash].markup = markup
     const existingContexts = units[hash].contexts
     const contextKey = `${context.page}:${context.section}`
     const exists = existingContexts.some(
@@ -402,9 +450,11 @@ function addUnit(units, source, field, context) {
       existingContexts.push({ ...context })
     }
   } else {
-    // New unit
+    // New unit. `markup` is omitted unless the element carries inline markdown —
+    // most units are plain prose and gain nothing from a duplicate string.
     units[hash] = {
       source,
+      ...(markup ? { markup } : {}),
       field,
       contexts: [{ ...context }]
     }

package/src/i18n/hash.js

@@ -31,7 +31,21 @@ export function normalizeText(text) {
 
 /**
  * Strip inline mark tags for hashing: "<1>text</1>" → "text"
- * Used to keep hash keys stable regardless of mark tagging.
+ *
+ * VESTIGIAL BUT LIVE. `<N>` tags were the pre-2026-06-24 mark-preservation scheme:
+ * a unit's source carried numbered tags and the merge re-applied the source's marks
+ * to the matching spans positionally. Whole-element keying replaced it (`d12d594`) —
+ * a translation VALUE is now inline markdown and the merge re-parses it, so nothing
+ * emits a `<N>` tag any more.
+ *
+ * ⛔ This stays anyway, because it runs on the HASH path: a manifest written before
+ * that change still holds tagged sources, and stripping keeps their keys matching
+ * what extraction produces today. Removing it would silently orphan those
+ * translations. The tag PARSER that went with it (`parseInlineTags`) had no callers
+ * and was deleted 2026-09-18; it was the only thing in the codebase that still looked
+ * like a live mark-preservation convention, which cost a peer lane a day of hunting
+ * for the placeholder syntax it implied.
+ *
  * @param {string} text
  * @returns {string}
  */
@@ -39,36 +53,3 @@ export function stripInlineTags(text) {
   if (typeof text !== 'string') return ''
   return text.replace(/<\/?(\d+)>/g, '')
 }
-
-/**
- * Parse tagged translation string into segments.
- * "plain <1>marked</1> more" →
- *   { segments: [{ text: "plain " }, { text: "marked", markIndex: 0 }, { text: " more" }], hasMarks: true }
- *
- * Tag numbers are 1-based in the string, markIndex is 0-based in the result.
- * @param {string} text
- * @returns {{ segments: Array<{ text: string, markIndex?: number }>, hasMarks: boolean }}
- */
-export function parseInlineTags(text) {
-  const regex = /<(\d+)>([\s\S]*?)<\/\1>/g
-  const segments = []
-  let lastIndex = 0
-  let hasMarks = false
-  let match
-
-  while ((match = regex.exec(text)) !== null) {
-    hasMarks = true
-    if (match.index > lastIndex) {
-      segments.push({ text: text.slice(lastIndex, match.index) })
-    }
-    segments.push({ text: match[2], markIndex: parseInt(match[1], 10) - 1 })
-    lastIndex = regex.lastIndex
-  }
-
-  if (lastIndex < text.length) {
-    segments.push({ text: text.slice(lastIndex) })
-  }
-
-  if (!hasMarks) return { segments: [{ text }], hasMarks: false }
-  return { segments, hasMarks }
-}

package/src/i18n/index.js

@@ -23,6 +23,7 @@ import {
   translateRecordData,
   RECORDS_DIR
 } from './records.js'
+import { resolveDefaultLocale } from '@uniweb/core'
 import { generateSearchIndex } from '@uniweb/projections'
 import { searchDeclaredOn } from '../site/search-declared.js'
 
@@ -329,6 +330,48 @@ export async function getTranslationStatus(siteRoot, options = {}) {
   }
 }
 
+/**
+ * ⭐ THE LOCALE SET A PAYLOAD DECLARES — resolved here, because this is the only
+ * place that knows it.
+ *
+ * ⛔ THE BUILD AND THE RUNTIME USED TO DISAGREE ABOUT WHERE LOCALES COME FROM, and
+ * nothing failed when they did. The build derives them from the FILESYSTEM —
+ * every `locales/*.json`, which is also what `languages: '*'` means — while
+ * `Website.buildLocalesList` reads `config.languages` and nothing else. So a site
+ * with locale files and no `languages:` in `site.yml` built a complete
+ * `dist/<locale>/` tree whose Website reported `hasMultipleLocales() === false`.
+ *
+ * Everything gated on that answer then silently switched off, in the rendered
+ * output, with no warning anywhere:
+ *   - no link was locale-prefixed (`applyLocale`, @uniweb/kit/utils/href) — every
+ *     internal link on a French page pointed into the English tree;
+ *   - no route translation was applied, although the build had emitted the
+ *     translated routes as directories (`/fr/a-propos/` existed; nothing linked
+ *     to it);
+ *   - any foundation UI gated on `hasMultipleLocales()` — the language switcher —
+ *     vanished from the very pages that needed it.
+ *
+ * Measured 2026-09-18 on our own `international` template, which was in exactly
+ * this state. ⇒ **The producer stamps what it resolved; the consumer reads it.**
+ * Guessing the set twice, from two different sources, is what this replaces.
+ *
+ * Declared entries are kept as authored — a `{ code, label }` object carries a
+ * label the filesystem cannot know — and resolved codes are appended.
+ */
+function declaredLanguages(config, defaultLocale, locales) {
+  const authored = Array.isArray(config?.languages) ? config.languages : []
+  const codeOf = (e) => (typeof e === 'string' ? e : e?.code)
+  const seen = new Set(authored.map(codeOf).filter(Boolean))
+  const out = authored.filter((e) => codeOf(e) && codeOf(e) !== '*')
+  for (const code of [defaultLocale, ...locales]) {
+    if (code && !seen.has(code)) {
+      seen.add(code)
+      out.push(code)
+    }
+  }
+  return out
+}
+
 /**
  * Build translated site content for all locales
  * @param {string} siteRoot - Site root directory
@@ -353,10 +396,36 @@ export async function buildLocalizedContent(siteRoot, options = {}) {
   const siteContentPath = join(outputDir, 'site-content.json')
   const siteContentRaw = await readFile(siteContentPath, 'utf-8')
   const siteContent = JSON.parse(siteContentRaw)
+  const defaultLocale = resolveDefaultLocale(siteContent.config)
 
   const outputs = {}
 
+  // ⭐ The DEFAULT locale's payload needs the same stamp. It is not written in
+  // this loop — it is the source this function reads — but a visitor landing on
+  // `/` gets a Website built from it, and without the set that page loses its
+  // language switcher while every translated page has one.
+  const stampedLanguages = declaredLanguages(siteContent.config, defaultLocale, locales)
+  if (JSON.stringify(siteContent.config?.languages) !== JSON.stringify(stampedLanguages)) {
+    siteContent.config = { ...siteContent.config, languages: stampedLanguages }
+    await writeFile(siteContentPath, JSON.stringify(siteContent, null, 2))
+  }
+
   for (const locale of locales) {
+    // ⛔ THE DEFAULT LOCALE IS THE ROOT TREE, NEVER A SUBDIRECTORY. Emitting
+    // `dist/<default>/` mints a byte-identical duplicate of every page at a second
+    // URL — duplicate content on any real domain, and the `hreflang` block already
+    // points that locale at `/` (`locale.default`, site/plugin.js) so nothing links
+    // to the copy.
+    //
+    // ⚠️ It was reachable only through the DECLARED form, which is the form the
+    // contract tells authors to use: `resolveLocales` returns an explicit
+    // `languages: [en, fr]` verbatim, default included, while the wildcard and
+    // filesystem forms exclude it by accident (there is no `locales/en.json`). So
+    // the documented spelling was the broken one. `uniweb i18n generate` has always
+    // skipped the default explicitly; this is the same rule, one stage later.
+    // Measured 2026-09-18: 47 pages duplicated under /en/.
+    if (locale === defaultLocale) continue
+
     const localePath = join(localesPath, `${locale}.json`)
 
     // Load translations (or empty object if not exists)
@@ -390,8 +459,14 @@ export async function buildLocalizedContent(siteRoot, options = {}) {
       })
     }
 
-    // Mark the active locale in the translated content
-    translated.config = { ...translated.config, activeLocale: locale }
+    // Mark the active locale in the translated content, and stamp the resolved
+    // locale set so the runtime does not have to re-derive it — see
+    // `declaredLanguages`.
+    translated.config = {
+      ...translated.config,
+      activeLocale: locale,
+      languages: declaredLanguages(siteContent.config, defaultLocale, locales)
+    }
 
     // Write to locale subdirectory
     const localeOutputDir = join(outputDir, locale)

package/src/i18n/merge.js

@@ -173,48 +173,93 @@ async function mergeTranslationsAsync(siteContent, translations, options) {
   return translated
 }
 
+/**
+ * ⭐ A TRANSLATION VALUE IS INLINE MARKDOWN, AND A PLAIN-TEXT SLOT RENDERS ITS TEXT.
+ *
+ * Units are deduplicated by normalized plain text, so ONE id carries every role
+ * that text plays on the site — and on a documentation site the two roles
+ * collide by design, because the house style is to link to a page by its title:
+ * "See [Roles and permissions](page:…)" makes that page's own title and the link
+ * to it the same string, hence the same unit.
+ *
+ * ⛔ That collision used to be unresolvable for the translator. A body occurrence
+ * needs the markdown (or the link is lost); a title occurrence was assigned the
+ * value RAW, so the same markdown landed verbatim in `<title>` — brackets,
+ * `page:` protocol and all — in the tab, the nav and every search result.
+ * Measured 2026-09-18: 32 of one site's 41 link texts were also page titles, so
+ * neither "markdown everywhere" nor "markdown nowhere" was shippable.
+ *
+ * ⭐ The resolution is on the CONSUMER, not the key. A body element parses the
+ * value into a fragment; a title takes its TEXT. One value serves both, and a
+ * page's title stays in lockstep with the links pointing at it — which is the
+ * property a cross-linked site wants and a role-keyed hash would destroy (the
+ * same word translated once per role, free to drift).
+ *
+ * ⛔ Do not add the field or the role to the hash. Genuine wording divergence by
+ * context is what `overrides` is for (`lookupTranslation`); representation
+ * divergence is this function's job.
+ */
+function toPlainText(value) {
+  if (typeof value !== 'string' || !value.includes('[') && !value.includes('*') && !value.includes('`') && !value.includes('_')) {
+    return value
+  }
+  try {
+    const doc = markdownToProseMirror(value)
+    const collect = (nodes) =>
+      (nodes || [])
+        .map((n) => (n.type === 'text' ? n.text || '' : n.type === 'hardBreak' ? ' ' : collect(n.content)))
+        .join('')
+    const text = collect(doc?.content).trim()
+    return text || value
+  } catch {
+    return value
+  }
+}
+
 /**
  * Translate page metadata (title, description, keywords, etc.)
+ *
+ * Every field here is a PLAIN-TEXT slot — `<title>`, a nav label, a meta
+ * description — so each value is flattened. See `toPlainText`.
  */
 function translatePageMeta(page, pageRoute, translations, fallbackToSource) {
   const context = { page: pageRoute, section: '_meta' }
+  const translate = (value) =>
+    toPlainText(lookupTranslation(value, context, translations, fallbackToSource))
 
   // Translate title
   if (page.title && typeof page.title === 'string') {
-    page.title = lookupTranslation(page.title, context, translations, fallbackToSource)
+    page.title = translate(page.title)
   }
 
   // Translate label (short navigation label)
   if (page.label && typeof page.label === 'string') {
-    page.label = lookupTranslation(page.label, context, translations, fallbackToSource)
+    page.label = translate(page.label)
   }
 
   // Translate description
   if (page.description && typeof page.description === 'string') {
-    page.description = lookupTranslation(page.description, context, translations, fallbackToSource)
+    page.description = translate(page.description)
   }
 
   // Translate SEO fields
   if (page.seo) {
     if (page.seo.ogTitle && typeof page.seo.ogTitle === 'string') {
-      page.seo.ogTitle = lookupTranslation(page.seo.ogTitle, context, translations, fallbackToSource)
+      page.seo.ogTitle = translate(page.seo.ogTitle)
     }
     if (page.seo.ogDescription && typeof page.seo.ogDescription === 'string') {
-      page.seo.ogDescription = lookupTranslation(page.seo.ogDescription, context, translations, fallbackToSource)
+      page.seo.ogDescription = translate(page.seo.ogDescription)
     }
   }
 
   // Translate keywords
   if (page.keywords) {
     if (Array.isArray(page.keywords)) {
-      page.keywords = page.keywords.map(keyword => {
-        if (keyword && typeof keyword === 'string') {
-          return lookupTranslation(keyword, context, translations, fallbackToSource)
-        }
-        return keyword
-      })
+      page.keywords = page.keywords.map(keyword =>
+        keyword && typeof keyword === 'string' ? translate(keyword) : keyword
+      )
     } else if (typeof page.keywords === 'string') {
-      page.keywords = lookupTranslation(page.keywords, context, translations, fallbackToSource)
+      page.keywords = translate(page.keywords)
     }
   }
 }

package/src/i18n/sync.js

@@ -15,6 +15,7 @@ export function syncManifests(previous, current) {
   const report = {
     unchanged: [],
     moved: [],
+    remarked: [],
     changed: [],
     added: [],
     removed: []
@@ -42,6 +43,23 @@ export function syncManifests(previous, current) {
           previousContexts: prevUnit.contexts,
           currentContexts: currentUnit.contexts
         })
+      } else if (prevUnit.markup !== currentUnit.markup) {
+        // ⭐ Same words, different inline markup — an author added a link, bolded a
+        // phrase or re-targeted an href without touching the text.
+        //
+        // ⛔ THE HASH CANNOT SEE THIS, BY DESIGN. It is computed over the flattened
+        // plain text precisely so that marking up a sentence does not orphan its
+        // existing translation. The cost is that nothing told a translator to go
+        // back and add the link, and the existing translation stays "valid" and
+        // fully counted while silently losing the markup the source gained.
+        // Measured 2026-09-18; before this bucket the report was simply silent.
+        report.remarked.push({
+          hash,
+          source: currentUnit.source,
+          previousMarkup: prevUnit.markup || null,
+          currentMarkup: currentUnit.markup || null,
+          contexts: currentUnit.contexts
+        })
       } else {
         report.unchanged.push({ hash, source: currentUnit.source })
       }
@@ -155,6 +173,21 @@ export function formatSyncReport(report) {
     }
   }
 
+  if (report.remarked?.length > 0) {
+    lines.push(
+      `  ✎ ${report.remarked.length} strings kept their words but changed inline markup (links/bold)`
+    )
+    lines.push(
+      `    Existing translations still count as valid — update them or the markup is lost.`
+    )
+    for (const item of report.remarked.slice(0, 5)) {
+      lines.push(`    - "${truncate(item.currentMarkup || item.source, 60)}"`)
+    }
+    if (report.remarked.length > 5) {
+      lines.push(`    ... and ${report.remarked.length - 5} more`)
+    }
+  }
+
   if (report.changed.length > 0) {
     lines.push(`  ⚠ ${report.changed.length} strings changed (need re-translation)`)
     for (const item of report.changed.slice(0, 5)) {

package/src/site/content-collector.js

@@ -1714,14 +1714,18 @@ async function processPage(pagePath, pageName, siteRoot, { isIndex = false, pare
 }
 
 /**
- * Determine the index page name from ordering config
+ * The homepage ONE config declares: the first named `pages:` entry, else `index:`.
+ * `undefined` when it declares none; `null` when its first `pages:` entry names
+ * nothing usable, which has always meant "no homepage" rather than "fall through".
  *
- * @param {Object} orderConfig - { pages: [...], index: 'name' } from parent
- * @param {Array} availableFolders - Array of { name, order } for folders at this level
- * @returns {string|null} The folder name that should be the index, or null
+ * The within-file rule, in one place — a level's config and each of the root's two
+ * configs (`rootOrderConfig`) are read by it alike.
+ *
+ * @param {Object} [config] - `{ pages, index }` as authored
+ * @returns {string|null|undefined}
  */
-function determineIndexPage(orderConfig, availableFolders) {
-  const { pages: pagesArray, index: indexName } = orderConfig || {}
+function declaredHomepage(config) {
+  const { pages: pagesArray, index: indexName } = config || {}
 
   // 1. Explicit pages array - first non-'...' item is index
   if (Array.isArray(pagesArray) && pagesArray.length > 0) {
@@ -1733,9 +1737,69 @@ function determineIndexPage(orderConfig, availableFolders) {
   }
 
   // 2. Explicit index property
-  if (indexName) {
-    return indexName
+  return indexName || undefined
+}
+
+/**
+ * The homepage a level's order config names. The root's was already decided across
+ * its two configs, and arrives as `homepage` (`rootOrderConfig`); any other level
+ * that promotes one — a folder promoted to `/`, the latest version of a scope at the
+ * root — names it in its own config.
+ */
+function homepageOf(orderConfig) {
+  return orderConfig && 'homepage' in orderConfig ? orderConfig.homepage : declaredHomepage(orderConfig)
+}
+
+/**
+ * The site's TOP LEVEL — its order and its homepage — from the two configs that can
+ * declare it: the site config (`site.yml`, or a document profile's own file) and the
+ * pages directory's own config (`pages/folder.yml`, or `pages/page.yml`).
+ *
+ * ⭐ The pages directory's config is read as a MOUNTED directory's is: the content's
+ * own declaration, under the site's. Every other directory's config orders its
+ * children, and a mounted one's does too — but the root's was read for its mode
+ * alone until 2026-09-19, so a content repository that orders itself kept its order
+ * mounted below the root and lost it as the whole pages directory: alphabetical,
+ * and in folder mode with no homepage at all.
+ *
+ * ⛔ THE HOMEPAGE IS DECIDED PER CONFIG, NOT PER KEY. Within one file the first
+ * `pages:` entry beats `index:`, as it always has; across the two, whichever form the
+ * site config uses beats the pages directory's. Merged key by key, a `pages:` list
+ * from the pages directory would override a `site.yml` `index:`. The order is the
+ * site config's `pages:`, else the pages directory's.
+ *
+ * ⚖️ `pages:` and `index:` ONLY. The root has no container page, so the keys that
+ * describe one (`title`, `seo`, …) mean nothing here — a repository carries them for
+ * when it is mounted below the root. And `layout:` stays the site config's alone: a
+ * site's layout travels on the sync lane as that file's own value, verbatim, so a
+ * second source would render on a static build and nowhere else.
+ *
+ * @param {{ pages?: Array, index?: string }} [site] - the site config's own order keys
+ * @param {Object} [root] - the pages directory's config, as `readFolderConfig` read it
+ * @returns {{ pages: Array|undefined, index: string|undefined, homepage: string|null|undefined }}
+ */
+export function rootOrderConfig(site = {}, root = {}) {
+  const listed = (value) => Array.isArray(value) && value.length > 0
+  const fromSite = declaredHomepage(site)
+  const homepage = fromSite !== undefined ? fromSite : declaredHomepage(root)
+  return {
+    pages: listed(site?.pages) ? site.pages : listed(root?.pages) ? root.pages : undefined,
+    index: homepage || undefined,
+    homepage,
   }
+}
+
+/**
+ * Determine the index page name from ordering config
+ *
+ * @param {Object} orderConfig - { pages: [...], index: 'name' } from parent
+ * @param {Array} availableFolders - Array of { name, order } for folders at this level
+ * @returns {string|null} The folder name that should be the index, or null
+ */
+function determineIndexPage(orderConfig, availableFolders) {
+  // 1–2. The first named `pages:` entry, else `index:` (`declaredHomepage`).
+  const declared = homepageOf(orderConfig)
+  if (declared !== undefined) return declared
 
   // 3. Fallback: lowest order value, or first alphabetically
   // IMPORTANT: Dynamic route folders (e.g., [slug]) can never be index pages
@@ -1953,11 +2017,7 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
     // pages: controls order only and every folder keeps its natural route.
     let indexName = null
     if (parentRoute === '/') {
-      if (pagesParsedFM && pagesParsedFM.before.length > 0) {
-        indexName = extractItemName(pagesParsedFM.before[0])
-      } else {
-        indexName = orderConfig?.index || null
-      }
+      indexName = homepageOf(orderConfig) ?? null
     }
 
     // Add md-file-pages
@@ -2505,21 +2565,22 @@ export async function collectSiteContent(sitePath, options = {}) {
     }
   }
 
+  // Root content mode default comes from the profile (folder mode for
+  // documents, page mode for sites). A folder.yml/page.yml in the pages root
+  // overrides the profile default per readFolderConfig.
+  const { mode: rootContentMode, config: rootFolderConfig } = await readFolderConfig(pagesPath, profile.defaultMode)
+
   // Extract page ordering config from the top-level config.
   // Document profile reads the `content:` field (with `pages:` as a back-compat
   // alias); site profile reads `pages:`. Either way the internal field name is
   // `pages` so collectPagesRecursive doesn't need to care about profile.
-  const siteOrderConfig = {
+  // ⭐ Layered over the pages directory's own `pages:` / `index:` — see `rootOrderConfig`.
+  const siteOrderConfig = rootOrderConfig({
     pages: profile.orderField === 'pages'
       ? siteConfig.pages
       : (siteConfig[profile.orderField] ?? siteConfig.pages),
     index: siteConfig.index
-  }
-
-  // Root content mode default comes from the profile (folder mode for
-  // documents, page mode for sites). A folder.yml/page.yml in the pages root
-  // overrides the profile default per readFolderConfig.
-  const { mode: rootContentMode } = await readFolderConfig(pagesPath, profile.defaultMode)
+  }, rootFolderConfig)
 
   // Collect layout areas from the layout/ directory, read from the site alone
   const { layouts, assetCollection: layoutAssets, iconCollection: layoutIcons } =

package/src/uwx/site-diff.js

@@ -64,8 +64,9 @@ const ownContent = (record, ...childKeys) => {
  * the projector would write it to.
  *
  * Paths use the conventional `pages/` and `layout/` roots. A site that relocates
- * them via `info.paths` still gets stable, unique keys — only the displayed prefix
- * would differ from disk, which is a labelling nicety, not a correctness issue.
+ * them via `site.yml::paths` (`settings.paths` on the wire) still gets stable, unique
+ * keys — only the displayed prefix would differ from disk, which is a labelling
+ * nicety, not a correctness issue.
  *
  * @returns {Map<string, object>} path → the unit's own record
  */

package/src/uwx/site-dirs.js

@@ -0,0 +1,32 @@
+// Where a site's pages and layout live — ONE definition for the push, which reads
+// the tree from here (`site.js`), and the pull, which writes it back here
+// (`site-project.js`). A leaf module so the pull does not import the push.
+
+import { join, resolve } from 'node:path'
+
+/**
+ * `site.yml::paths.pages` / `paths.layout`, else `pages/` and `layout/` — resolved
+ * as the build resolves them (`site/content-collector.js`).
+ *
+ * ⛔ The pull read this from the pulled document's `info.paths` until 2026-09-19.
+ * `paths` moved to the `settings` Section on 2026-09-09 and that reader did not
+ * move with it, so it read as absent: every pull wrote pages to `pages/` and layout
+ * to `layout/` whatever the site declared, while the build and the next push kept
+ * reading the declared directory — untouched by the pull, and recorded by it as
+ * current.
+ *
+ * ⭐ Reading `site.yml` rather than the document is the fix, not a detour: it is the
+ * file both readers use, and the pull writes the document's `settings.paths` into it
+ * before it places a single page.
+ *
+ * @param {string} siteRoot
+ * @param {object|null} siteYml - the parsed `site.yml`
+ * @returns {{ pagesDir: string, layoutDir: string }}
+ */
+export function siteContentDirs(siteRoot, siteYml) {
+  const paths = siteYml?.paths
+  return {
+    pagesDir: paths?.pages ? resolve(siteRoot, paths.pages) : join(siteRoot, 'pages'),
+    layoutDir: paths?.layout ? resolve(siteRoot, paths.layout) : join(siteRoot, 'layout'),
+  }
+}

package/src/uwx/site-project.js

@@ -46,6 +46,7 @@ import { createTranslationCollector, writeLocaleTranslations, writeFreeformTrans
 import { buildFreeformPath } from '../i18n/freeform.js'
 import { unwrapLocalized, unwrapLocalizedList } from './backfill.js'
 import { LOCALIZED_FIELD_ASSUMPTION } from './localize.js'
+import { siteContentDirs } from './site-dirs.js'
 
 // The pull-side identity index: a per-clone, GITIGNORED `uuid → relative path`
 // map under `.uniweb/`, the home for the backend's per-item identity so that
@@ -607,24 +608,35 @@ function pageRecordToYml(record, sectionsArray, sourceLocale, existing = null) {
   return y
 }
 
-// Delete `<name>.md` files in `pageDir` whose stableId isn't in `keep`.
+// ⛔ A PRUNE MAY ONLY DELETE WHAT A PUSH COULD HAVE SENT. An orphan is a file the
+// incoming document no longer has — but a push reads the tree with the build's own
+// rules (`isMarkdownFile`, `isIgnoredFolder`), so a `_draft.md`, a `README.md`, a
+// `_partials/` folder or a `.git/` directory never reaches the backend and can never
+// come back in a pulled document. Judged by "not in the incoming set" alone, every
+// one of them was an orphan and a default pull DELETED it — the `.git/` of a pages
+// directory that is its own clone included. The same two rules decide both sides
+// now, which is also what the layout prune below already did.
+
+// Delete the section files in `pageDir` whose stableId isn't in `keep`.
 function pruneOrphanSectionFiles(pageDir, keep, report) {
   if (!existsSync(pageDir)) return
   for (const entry of readdirSync(pageDir)) {
-    if (extname(entry).toLowerCase() !== '.md') continue
+    if (!isMarkdownFile(entry)) continue
     if (keep.has(basename(entry, extname(entry)))) continue
     const p = join(pageDir, entry)
+    if (!statSync(p).isFile()) continue
     unlinkSync(p)
     report.deleted.push(p)
   }
 }
 
-// Delete subdirectories of `pagesDir` whose name isn't an incoming page dir.
+// Delete the page directories in `pagesDir` whose name isn't an incoming page dir.
 function pruneOrphanPageDirs(pagesDir, keepDirs, report) {
   if (!existsSync(pagesDir)) return
   for (const entry of readdirSync(pagesDir)) {
+    if (isIgnoredFolder(entry) || keepDirs.has(entry)) continue
     const p = join(pagesDir, entry)
-    if (!statSync(p).isDirectory() || keepDirs.has(entry)) continue
+    if (!statSync(p).isDirectory()) continue
     rmSync(p, { recursive: true, force: true })
     report.deleted.push(p)
   }
@@ -870,11 +882,11 @@ export function siteContentDocumentToProject({ document, siteRoot, sourceLocale
   // localized scalars during the page walk.
   const ctx = { siteRoot, oldIndex: readPullIndex(siteRoot), newIndex: {}, report, collector, sourceLocale }
 
-  const paths = document?.info?.paths || {}
-  const pagesDir = paths.pages ? join(siteRoot, paths.pages) : join(siteRoot, 'pages')
+  // Where the tree goes is what `site.yml` says NOW — `siteInfoToConfig` above has
+  // written the document's `settings.paths` into it — because that is the file the
+  // next push and the build read. See `siteContentDirs`.
+  const { pagesDir, layoutDir: layoutBaseDir } = siteContentDirs(siteRoot, readAuthoredYaml(join(siteRoot, 'site.yml')))
   projectPages(document?.pages, pagesDir, sourceLocale, report, prune, ctx)
-
-  const layoutBaseDir = paths.layout ? join(siteRoot, paths.layout) : join(siteRoot, 'layout')
   projectLayout(document?.layout_sections, layoutBaseDir, report, prune, ctx)
 
   report.locales = writeLocaleTranslations(siteRoot, collector.byLocale)

package/src/uwx/site.js

@@ -56,6 +56,8 @@ import {
   checkDeclaration,
   fetchFromQueryShorthand,
   assertRouteFolder,
+  mountEntriesOf,
+  rootOrderConfig,
 } from '../site/content-collector.js'
 import { refuseBinding, refuseUnder, refuseOutsideLanguage, warnDuplicateBindings } from '../site/data-fetcher.js'
 import { readLayoutFolder } from '../site/layout-folder.js'
@@ -68,6 +70,7 @@ import { loadFreeformTranslation } from '../i18n/freeform.js'
 import { upsertYamlScalar } from './yaml-upsert.js'
 import { resolveQueriesConfig } from './queries-config.js'
 import { resolveSelfScope } from './self-scope.js'
+import { siteContentDirs } from './site-dirs.js'
 
 const SITE_ENTITY_KEY = 'site-content' // one content entity per site project
 
@@ -544,8 +547,7 @@ async function collectPageSectionsNested(pageDir, siteRoot, pageConfig) {
   }
 
   // Top-level sections: every NON-`@` markdown file, in order. `@`-prefixed files
-  // are children, pulled in via their parent's `nest:` above (an orphaned `@`
-  // file with no parent is simply omitted — it stays out of the document).
+  // are children, pulled in via their parent's `nest:` above.
   const seen = new Set()
   const sections = []
   for (const file of mdFiles) {
@@ -554,9 +556,68 @@ async function collectPageSectionsNested(pageDir, siteRoot, pageConfig) {
     sections.push(await buildSection(file, seen))
   }
 
+  // An `@` file no `nest:` claimed is an ORPHAN, and the build keeps it — appended
+  // as a top-level section, with a warning, "to avoid silent data loss" (`processPage`,
+  // `site/content-collector.js`). Mirrored exactly: at the end, in file order, with no
+  // children of its own. ⛔ This lane omitted it until 2026-09-19, and a pull of the
+  // result then DELETED the file — on disk and absent from the document, it read as
+  // something removed upstream.
+  for (const file of mdFiles) {
+    if (!isChildSection(file) || seen.has(file)) continue
+    seen.add(file)
+    const stableDefault = parseNumericPrefix(stripAtPrefix(parse(file).name)).name
+    const { section } = await processMarkdownFile(join(pageDir, file), String(seen.size), siteRoot, stableDefault)
+    section.subsections = []
+    sections.push(section)
+  }
+
   return sections.map((s, i) => sectionToRecord(s, i))
 }
 
+// A folder-mode folder's `.md` files are pages to the build and nothing to this
+// lane. Name every one of them, so the shortfall is visible at push time rather
+// than by reading the backend's store or opening the published site.
+//
+// `source` is `readFolderConfig`'s: a folder with no config of its own is in folder
+// mode because a `folder.yml` above it put it there, and the message says so —
+// "it is a folder-mode folder (`folder.yml`)" over a folder that has none would send
+// the author looking for a file that does not exist.
+async function warnFolderModePagesSkipped(dirPath, siteRoot, source = 'folder.yml') {
+  let files
+  try {
+    files = (await readdir(dirPath)).filter(isMarkdownFile)
+  } catch {
+    return
+  }
+  if (files.length === 0) return
+  const where = relative(siteRoot, dirPath)
+  const why = source === 'inherited'
+    ? 'it is a folder-mode folder (it has no `folder.yml` or `page.yml` of its own, so it inherits folder mode from the `folder.yml` above it)'
+    : 'it is a folder-mode folder (`folder.yml`)'
+  console.warn(
+    `uwx/site: ${files.length} page(s) in \`${where}\` will NOT be pushed — ` +
+      `${why}, and pushing \`.md\`-as-pages ` +
+      `is not implemented on the sync lane. A build renders them; the backend ` +
+      `will not have them.\n` +
+      files.map((f) => `  - ${where}/${f}`).join('\n') +
+      `\n  To publish them, make each one a page-mode directory ` +
+      `(\`<name>/page.yml\` + its section files). To ship them as they are, ` +
+      `use \`uniweb export\` or \`uniweb deploy --host <adapter>\`.` +
+      REPUBLISH_CLAUSE
+  )
+}
+
+// A push sends the page tree as ONE entity (see site-diff.js), so a republish does
+// not merge: the shorter document becomes the whole tree. Measured by the backend
+// lane 2026-09-18 against a current `uniwebd` — 49 stored pages replaced by 2, the
+// publish reporting success. Both skip warnings carry this, because "will not be
+// pushed" reads as "you publish short" when the real cost on an already-published
+// site is that live pages are REMOVED.
+const REPUBLISH_CLAUSE =
+  `\n  ⚠ If this site has been published before, a push REPLACES its whole page ` +
+  `tree — pages already live that are missing here are REMOVED, and the publish ` +
+  `still reports success.`
+
 // Recursively build the `pages` tree: each record carries its fields, its inline
 // `page_sections` (page mode only), and its child pages under `$children`.
 async function walkPagesNested(ctx, dirPath, parentSlugPath, inheritedMode, parentConfig, isRoot) {
@@ -572,7 +633,16 @@ async function walkPagesNested(ctx, dirPath, parentSlugPath, inheritedMode, pare
     assertRouteFolder(f.dirName, insideCatchAll ? '/:path*' : '/')
     const dyn = f.dirName.match(DYNAMIC_RE)
     const slug = dyn ? dyn[1] : f.name
-    const mode = f.source === 'folder.yml' ? 'folder' : 'page'
+    // ⭐ THE BUILD'S ANSWER, NOT A SECOND ONE. `readFolderConfig` has already resolved
+    // this folder's mode — a `folder.yml` here, a `page.yml` here, or neither and
+    // INHERITED from its parent — and that resolved mode is exactly what the build
+    // reads (`site/content-collector.js`). ⛔ This line tested the config file's NAME
+    // until 2026-09-19, so a folder with no config under a folder-mode parent — the
+    // documented cascade, one `folder.yml` at the top of a docs tree — was pushed as
+    // ONE page whose sections were its `.md` files while the build rendered each as a
+    // page of its own. Nothing warned, and a pull then wrote a `page.yml` into the
+    // folder, converting the author's own site to the wrong shape.
+    const mode = f.internalMode === 'pages' ? 'folder' : 'page'
     const slugPath = parentSlugPath ? `${parentSlugPath}/${slug}` : slug
 
     const data = buildPageData(f.config, {
@@ -594,6 +664,20 @@ async function walkPagesNested(ctx, dirPath, parentSlugPath, inheritedMode, pare
     if (mode === 'page') {
       const sections = await collectPageSectionsNested(f.path, siteRoot, f.config)
       if (sections.length > 0) record.page_sections = sections
+    } else {
+      // ⛔ FOLDER MODE: the build makes each `.md` file here a PAGE; this lane
+      // makes it nothing. It is a v0 mapper gap (bidirectional-sync.md §"Other
+      // v0 mapper gaps"), and until it closes the ONLY thing standing between an
+      // author and a site that publishes a fraction of itself is this warning.
+      //
+      // ⭐ It has to be here, not in `status` or `push`. Those compare the built
+      // document against what was last sent, so with the pages already absent
+      // from the document both correctly report "Synced" / "Nothing to push".
+      // The loss happens upstream of every diff, which is why it was invisible:
+      // measured 2026-09-18, a 49-page documentation site published 2 pages with
+      // every CLI instrument reporting success [measured:backend, channel with
+      // backend, and reproduced here against the same site].
+      await warnFolderModePagesSkipped(f.path, siteRoot, f.source)
     }
 
     const children = await walkPagesNested(ctx, f.path, slugPath, f.internalMode, f.config, false)
@@ -1345,17 +1429,54 @@ export async function siteProjectToDocument(siteRoot, opts = {}) {
   // left in an old site.yml is inert — nothing reads it, so nothing sends it.
   // (uwx-format.md → info.url.)
 
-  const ctx = { siteRoot, siteIndex: siteYml.index, sourceLocale, translations }
-  const pagesPath = siteYml.paths?.pages
-    ? join(siteRoot, siteYml.paths.pages)
-    : join(siteRoot, 'pages')
-  const pages = existsSync(pagesPath)
-    ? await walkPagesNested(ctx, pagesPath, '', 'sections', siteYml, true)
-    : []
-
-  const layoutDir = siteYml.paths?.layout
-    ? join(siteRoot, siteYml.paths.layout)
-    : join(siteRoot, 'layout')
+  // `siteIndex` — the homepage — joins below, once the pages directory's own config is read.
+  const ctx = { siteRoot, sourceLocale, translations }
+  // ⛔ ONE `paths:` CONVENTION, TWO READERS, AND THIS ONE IS A STRICT SUBSET.
+  // The build honours sub-mounts — `paths: { pages/<segment>: <dir> }`, through
+  // `resolveMounts`/`mountEntriesOf` in `site/content-collector.js` — and this
+  // lane reads `paths.pages` alone. A sub-mounted folder therefore syncs as an
+  // EMPTY container: its directory on disk holds only the `folder.yml`, so it
+  // emits with no children and nothing anywhere says so. Measured 2026-09-18 on
+  // a site whose entire corpus was one sub-mount: 49 pages built, 2 pushed.
+  // Deferred by design for now (bidirectional-sync.md); warned about here so it
+  // is not also silent.
+  //
+  // The same two directories the pull writes back to — see `siteContentDirs`.
+  const { pagesDir: pagesPath, layoutDir } = siteContentDirs(siteRoot, siteYml)
+  for (const [segment] of mountEntriesOf(siteYml.paths)) {
+    // Only a LOCAL stub (`pages/<segment>/`, the folder that gives a mounted route its
+    // layout) is walked, so the route arrives as an empty container; with no stub,
+    // nothing here stands for the route and it is not sent at all. ⚠️ The message
+    // said "empty container" in both cases until 2026-09-19.
+    const fate = existsSync(join(pagesPath, segment))
+      ? 'will be pushed as an empty container'
+      : 'will not be pushed at all'
+    console.warn(
+      `uwx/site: \`paths: { pages/${segment}: … }\` is NOT read on the sync lane — ` +
+        `\`${segment}\` ${fate} and none of the mounted ` +
+        `pages will reach the backend. A build mounts it normally. Inline the ` +
+        `directory under \`pages/${segment}/\` to push it, or ship the site with ` +
+        `\`uniweb export\` / \`uniweb deploy --host <adapter>\`.` +
+        REPUBLISH_CLAUSE
+    )
+  }
+  let pages = []
+  if (existsSync(pagesPath)) {
+    // The root has a mode too, read as the build reads it (`rootContentMode`):
+    // `pages/folder.yml` puts the whole site in folder mode, and every folder with no
+    // config of its own inherits it. ⛔ This walk started in page mode unconditionally
+    // until 2026-09-19, so such a site's top-level `.md` pages were dropped without a
+    // word and its top-level folders were pushed as pages of sections.
+    const { mode: rootMode, source: rootSource, config: rootConfig } = await readFolderConfig(pagesPath, 'sections')
+    if (rootMode === 'pages') await warnFolderModePagesSkipped(pagesPath, siteRoot, rootSource)
+    // The top level's order and homepage, decided by the build's own function: the
+    // site's `pages:` / `index:` over the pages directory's own. ⛔ The homepage read
+    // `index:` alone until 2026-09-19, so a site naming it by its first `pages:` entry
+    // — as the build does — pushed no homepage at all.
+    const top = rootOrderConfig({ pages: siteYml.pages, index: siteYml.index }, rootConfig)
+    pages = await walkPagesNested({ ...ctx, siteIndex: top.homepage }, pagesPath, '', rootMode, { pages: top.pages }, true)
+  }
+
   const layoutSections = await collectLayoutNested(layoutDir, siteRoot)
 
   // Wrap each section's content into its per-locale form (source doc + target