@uniweb/build 0.6.16 → 0.6.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.6.16",
+  "version": "0.6.18",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -50,8 +50,8 @@
     "sharp": "^0.33.2"
   },
   "optionalDependencies": {
-    "@uniweb/runtime": "0.5.21",
     "@uniweb/schemas": "0.2.1",
+    "@uniweb/runtime": "0.5.21",
     "@uniweb/content-reader": "1.1.2"
   },
   "peerDependencies": {

package/src/i18n/index.js

@@ -169,20 +169,17 @@ async function resolveLocales(configLocales, localesPath) {
 /**
  * Extract manifest from site content and write to file
  * @param {string} siteRoot - Site root directory
+ * @param {Object} siteContent - Collected site content (from collectSiteContent)
  * @param {Object} options - Options
  * @returns {Object} { manifest, report }
  */
-export async function extractManifest(siteRoot, options = {}) {
+export async function extractManifest(siteRoot, siteContent, options = {}) {
   const {
     localesDir = DEFAULTS.localesDir,
-    siteContentPath = join(siteRoot, 'dist', 'site-content.json'),
-    verbose = false
+    verbose = false,
+    dryRun = false
   } = options
 
-  // Load site content
-  const siteContentRaw = await readFile(siteContentPath, 'utf-8')
-  const siteContent = JSON.parse(siteContentRaw)
-
   // Extract translatable content
   const manifest = extractTranslatableContent(siteContent)
 
@@ -203,8 +200,10 @@ export async function extractManifest(siteRoot, options = {}) {
   // Generate sync report
   const report = syncManifests(previousManifest, manifest)
 
-  // Write new manifest
-  await writeFile(manifestPath, JSON.stringify(manifest, null, 2))
+  // Write new manifest (skip in dry-run mode)
+  if (!dryRun) {
+    await writeFile(manifestPath, JSON.stringify(manifest, null, 2))
+  }
 
   if (verbose) {
     console.log(formatSyncReport(report))
@@ -222,7 +221,7 @@ export async function extractManifest(siteRoot, options = {}) {
  * @returns {Promise<Object>} { manifest, report }
  */
 export async function extractCollectionManifest(siteRoot, options = {}) {
-  const { localesDir = DEFAULTS.localesDir } = options
+  const { localesDir = DEFAULTS.localesDir, dryRun = false } = options
 
   // Extract translatable content from collections
   const manifest = await extractCollectionContent(siteRoot)
@@ -249,8 +248,10 @@ export async function extractCollectionManifest(siteRoot, options = {}) {
   // Generate sync report
   const report = syncManifests(previousManifest, manifest)
 
-  // Write new manifest
-  await writeFile(manifestPath, JSON.stringify(manifest, null, 2))
+  // Write new manifest (skip in dry-run mode)
+  if (!dryRun) {
+    await writeFile(manifestPath, JSON.stringify(manifest, null, 2))
+  }
 
   return { manifest, report }
 }

package/src/i18n/sync.js

@@ -143,6 +143,15 @@ export function formatSyncReport(report) {
 
   if (report.moved.length > 0) {
     lines.push(`  ↻ ${report.moved.length} strings moved (contexts updated)`)
+    for (const item of report.moved.slice(0, 5)) {
+      const preview = truncate(item.source, 40)
+      const oldCtx = formatContext(item.previousContexts?.[0])
+      const newCtx = formatContext(item.currentContexts?.[0])
+      lines.push(`    - "${preview}" ${oldCtx} → ${newCtx}`)
+    }
+    if (report.moved.length > 5) {
+      lines.push(`    ... and ${report.moved.length - 5} more`)
+    }
   }
 
   if (report.changed.length > 0) {
@@ -150,7 +159,7 @@ export function formatSyncReport(report) {
     for (const item of report.changed.slice(0, 5)) {
       const prevPreview = truncate(item.previousSource, 30)
       const currPreview = truncate(item.source, 30)
-      lines.push(`    - ${item.previousHash}: "${prevPreview}" → "${currPreview}"`)
+      lines.push(`    - "${prevPreview}" → "${currPreview}"`)
     }
     if (report.changed.length > 5) {
       lines.push(`    ... and ${report.changed.length - 5} more`)
@@ -159,15 +168,42 @@ export function formatSyncReport(report) {
 
   if (report.added.length > 0) {
     lines.push(`  + ${report.added.length} new strings`)
+    for (const item of report.added.slice(0, 5)) {
+      const preview = truncate(item.source, 40)
+      const ctx = formatContext(item.contexts?.[0])
+      lines.push(`    - "${preview}" ${ctx}`)
+    }
+    if (report.added.length > 5) {
+      lines.push(`    ... and ${report.added.length - 5} more`)
+    }
   }
 
   if (report.removed.length > 0) {
     lines.push(`  - ${report.removed.length} strings removed`)
+    for (const item of report.removed.slice(0, 5)) {
+      const preview = truncate(item.source, 40)
+      const ctx = formatContext(item.contexts?.[0])
+      lines.push(`    - "${preview}" ${ctx}`)
+    }
+    if (report.removed.length > 5) {
+      lines.push(`    ... and ${report.removed.length - 5} more`)
+    }
   }
 
   return lines.join('\n')
 }
 
+/**
+ * Format a context object for display
+ */
+function formatContext(context) {
+  if (!context) return ''
+  const location = context.page || context.collection || ''
+  const section = context.section || context.item || ''
+  if (!location && !section) return ''
+  return `(${location}:${section})`
+}
+
 /**
  * Truncate string for display
  */

package/src/site/content-collector.js

@@ -203,10 +203,12 @@ function isIgnoredFolder(name) {
 /**
  * Read folder configuration, determining content mode from config file presence.
  *
- * - folder.yml present → pages mode (md files are child pages)
- * - page.yml present → sections mode (md files are sections of this page)
+ * - folder.yml present → folder mode (md files are child pages)
+ * - page.yml present → page mode (md files are sections of this page)
  * - Neither → inherit mode from parent
  *
+ * Internal mode values: 'pages' (folder mode), 'sections' (page mode)
+ *
  * @param {string} dirPath - Directory path
  * @param {string} inheritedMode - Mode inherited from parent ('sections' or 'pages')
  * @returns {Promise<{config: Object, mode: string, source: string}>}
@@ -220,7 +222,7 @@ async function readFolderConfig(dirPath, inheritedMode) {
   if (Object.keys(pageYml).length > 0) {
     return { config: pageYml, mode: 'sections', source: 'page.yml' }
   }
-  // Check for empty folder.yml (presence signals pages mode even if empty)
+  // Check for empty folder.yml (presence signals folder mode even if empty)
   if (existsSync(join(dirPath, 'folder.yml'))) {
     return { config: {}, mode: 'pages', source: 'folder.yml' }
   }
@@ -269,27 +271,134 @@ function compareFilenames(a, b) {
 }
 
 /**
- * Apply non-strict ordering to a list of items.
- * Listed items appear first in array order, then unlisted items in their existing order.
+ * Extract the name from a config array item.
+ * Handles both string entries ("hero") and object entries ({ features: [...] }).
+ * @param {*} item - Array item from sections: or pages: config
+ * @returns {string|null} The name, or null if not a valid entry
+ */
+function extractItemName(item) {
+  if (typeof item === 'string') return item
+  if (typeof item === 'object' && item !== null) {
+    const keys = Object.keys(item)
+    if (keys.length === 1) return keys[0]
+  }
+  return null
+}
+
+/**
+ * Parse a config array that may contain '...' rest markers.
+ *
+ * Returns structured info:
+ * - mode 'strict': no '...' — only listed items visible in navigation
+ * - mode 'inclusive': '...' present — pinned items + auto-discovered rest
+ * - mode 'all': array is just ['...'] — equivalent to omitting config
+ *
+ * @param {Array} arr - Config array (may contain '...' strings and/or objects)
+ * @returns {{ mode: 'strict'|'inclusive'|'all', before: Array, after: Array }|null}
+ */
+function parseWildcardArray(arr) {
+  if (!Array.isArray(arr) || arr.length === 0) return null
+
+  const firstRestIndex = arr.indexOf('...')
+  if (firstRestIndex === -1) {
+    return { mode: 'strict', before: [...arr], after: [] }
+  }
+
+  // Find last '...' index
+  let lastRestIndex = firstRestIndex
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (arr[i] === '...') { lastRestIndex = i; break }
+  }
+
+  const before = arr.slice(0, firstRestIndex).filter(x => x !== '...')
+  const after = arr.slice(lastRestIndex + 1).filter(x => x !== '...')
+
+  if (before.length === 0 && after.length === 0) {
+    return { mode: 'all', before: [], after: [] }
+  }
+
+  return { mode: 'inclusive', before, after }
+}
+
+/**
+ * Apply wildcard-aware ordering to a list of named items.
  *
- * Unlike strict arrays (pages: [...], sections: [...]) which hide unlisted items,
- * this preserves all items — it only affects order.
+ * - strict: listed items first in listed order, then unlisted (all items returned)
+ * - inclusive: before items, then rest (in existing order), then after items
+ * - all/null: return items unchanged
  *
  * @param {Array} items - Items with a .name property
- * @param {Array<string>} orderArray - Names in desired order
- * @returns {Array} Reordered items (all items preserved)
+ * @param {{ mode: string, before: Array, after: Array }|null} parsed - From parseWildcardArray
+ * @returns {Array} Reordered items
  */
-function applyNonStrictOrder(items, orderArray) {
-  if (!Array.isArray(orderArray) || orderArray.length === 0) return items
-  const orderMap = new Map(orderArray.map((name, i) => [name, i]))
-  const listed = items.filter(i => orderMap.has(i.name))
-    .sort((a, b) => orderMap.get(a.name) - orderMap.get(b.name))
-  const unlisted = items.filter(i => !orderMap.has(i.name))
-  return [...listed, ...unlisted]
+function applyWildcardOrder(items, parsed) {
+  if (!parsed || parsed.mode === 'all') return items
+
+  const itemMap = new Map(items.map(i => [i.name, i]))
+  const beforeNames = parsed.before.map(extractItemName).filter(Boolean)
+  const afterNames = parsed.after.map(extractItemName).filter(Boolean)
+  const allPinnedNames = new Set([...beforeNames, ...afterNames])
+
+  const beforeItems = beforeNames.filter(n => itemMap.has(n)).map(n => itemMap.get(n))
+  const afterItems = afterNames.filter(n => itemMap.has(n)).map(n => itemMap.get(n))
+  const rest = items.filter(i => !allPinnedNames.has(i.name))
+
+  if (parsed.mode === 'strict') {
+    // Listed items first, then unlisted (hiding is applied separately)
+    return [...beforeItems, ...rest]
+  }
+
+  // Inclusive: before + rest + after
+  return [...beforeItems, ...rest, ...afterItems]
+}
+
+/**
+ * Find the markdown file for a section name, handling numeric prefixes.
+ * Tries exact match first ("hero.md"), then prefix-based ("1-hero.md").
+ *
+ * @param {string} pagePath - Directory containing section files
+ * @param {string} sectionName - Logical section name (e.g., 'hero')
+ * @param {string[]} [cachedFiles] - Pre-read directory listing (optimization)
+ * @returns {{ filePath: string, stableName: string, prefix: string|null }|null}
+ */
+function findSectionFile(pagePath, sectionName, cachedFiles) {
+  const exactPath = join(pagePath, `${sectionName}.md`)
+  if (existsSync(exactPath)) {
+    return { filePath: exactPath, stableName: sectionName, prefix: null }
+  }
+
+  const files = cachedFiles || []
+  for (const file of files) {
+    if (!isMarkdownFile(file)) continue
+    const { name } = parse(file)
+    const { prefix, name: parsedName } = parseNumericPrefix(name)
+    if (parsedName === sectionName) {
+      return { filePath: join(pagePath, file), stableName: sectionName, prefix }
+    }
+  }
+
+  return null
 }
 
 /**
- * Process a markdown file as a standalone page (pages mode).
+ * Extract a direct child's folder name from its route, relative to parentRoute.
+ * Returns null for the index page (route === parentRoute) or non-direct-children.
+ *
+ * @param {string} route - Page route (e.g., '/about')
+ * @param {string} parentRoute - Parent route (e.g., '/')
+ * @returns {string|null}
+ */
+function getDirectChildName(route, parentRoute) {
+  if (!route || route === parentRoute) return null
+  const prefix = parentRoute === '/' ? '/' : parentRoute + '/'
+  if (!route.startsWith(prefix)) return null
+  const rest = route.slice(prefix.length)
+  if (rest.includes('/')) return null
+  return rest
+}
+
+/**
+ * Process a markdown file as a standalone page (folder mode).
  * Creates a page with a single section from the markdown content.
  *
  * @param {string} filePath - Path to markdown file
@@ -480,6 +589,9 @@ async function processExplicitSections(sectionsConfig, pagePath, siteRoot, paren
   }
   let lastModified = null
 
+  // Cache directory listing for prefix-based file resolution
+  const cachedFiles = await readdir(pagePath)
+
   let index = 1
   for (const item of sectionsConfig) {
     let sectionName
@@ -505,13 +617,14 @@ async function processExplicitSections(sectionsConfig, pagePath, siteRoot, paren
     // Build section ID
     const id = parentId ? `${parentId}.${index}` : String(index)
 
-    // Look for the markdown file
-    const filePath = join(pagePath, `${sectionName}.md`)
-    if (!existsSync(filePath)) {
+    // Look for the markdown file (exact match or prefix-based, e.g., "hero" → "1-hero.md")
+    const found = findSectionFile(pagePath, sectionName, cachedFiles)
+    if (!found) {
       console.warn(`[content-collector] Section file not found: ${sectionName}.md`)
       index++
       continue
     }
+    const filePath = found.filePath
 
     // Process the section
     // Use sectionName as stable ID for scroll targeting (e.g., "hero", "features")
@@ -577,8 +690,9 @@ async function processPage(pagePath, pageName, siteRoot, { isIndex = false, pare
 
   // Check for explicit sections configuration
   const { sections: sectionsConfig } = pageConfig
+  const sectionsParsed = Array.isArray(sectionsConfig) ? parseWildcardArray(sectionsConfig) : null
 
-  if (sectionsConfig === undefined || sectionsConfig === '*') {
+  if (sectionsConfig === undefined || sectionsConfig === '*' || sectionsParsed?.mode === 'all') {
     // Default behavior: discover all .md files, sort by numeric prefix
     const files = await readdir(pagePath)
     const mdFiles = files.filter(isMarkdownFile).sort(compareFilenames)
@@ -607,8 +721,79 @@ async function processPage(pagePath, pageName, siteRoot, { isIndex = false, pare
     // Build hierarchy from dot notation
     hierarchicalSections = buildSectionHierarchy(sections)
 
+  } else if (sectionsParsed?.mode === 'inclusive') {
+    // Inclusive: pinned sections + auto-discovered rest via '...' wildcard
+    const files = await readdir(pagePath)
+    const mdFiles = files.filter(isMarkdownFile).sort(compareFilenames)
+
+    // Build name → file info map from discovered files
+    const discoveredMap = new Map()
+    for (const file of mdFiles) {
+      const { name } = parse(file)
+      const { prefix, name: stableName } = parseNumericPrefix(name)
+      const key = stableName || name
+      if (!discoveredMap.has(key)) {
+        discoveredMap.set(key, { file, prefix, stableName: key })
+      }
+    }
+
+    // Create items with .name property for applyWildcardOrder
+    const allItems = [...discoveredMap.keys()].map(name => ({ name }))
+    const ordered = applyWildcardOrder(allItems, sectionsParsed)
+
+    // Collect subsection configs from the original array (e.g., { features: [a, b] })
+    const subsectionConfigs = new Map()
+    for (const item of [...sectionsParsed.before, ...sectionsParsed.after]) {
+      if (typeof item === 'object' && item !== null) {
+        const keys = Object.keys(item)
+        if (keys.length === 1) {
+          subsectionConfigs.set(keys[0], item[keys[0]])
+        }
+      }
+    }
+
+    // Process sections in wildcard-expanded order
+    const sections = []
+    let sectionIndex = 1
+    for (const { name } of ordered) {
+      const entry = discoveredMap.get(name)
+      if (!entry) {
+        console.warn(`[content-collector] Section '${name}' not found in ${pagePath}`)
+        continue
+      }
+
+      const id = String(sectionIndex)
+      const { section, assetCollection: sectionAssets, iconCollection: sectionIcons } =
+        await processMarkdownFile(join(pagePath, entry.file), id, siteRoot, entry.stableName)
+      sections.push(section)
+      pageAssetCollection = mergeAssetCollections(pageAssetCollection, sectionAssets)
+      pageIconCollection = mergeIconCollections(pageIconCollection, sectionIcons)
+
+      // Track last modified
+      const fileStat = await stat(join(pagePath, entry.file))
+      if (!lastModified || fileStat.mtime > lastModified) {
+        lastModified = fileStat.mtime
+      }
+
+      // Process subsections if configured (e.g., { features: [logocloud, stats] })
+      const subsections = subsectionConfigs.get(name)
+      if (Array.isArray(subsections) && subsections.length > 0) {
+        const subResult = await processExplicitSections(subsections, pagePath, siteRoot, id)
+        section.subsections = subResult.sections
+        pageAssetCollection = mergeAssetCollections(pageAssetCollection, subResult.assetCollection)
+        pageIconCollection = mergeIconCollections(pageIconCollection, subResult.iconCollection)
+        if (subResult.lastModified && (!lastModified || subResult.lastModified > lastModified)) {
+          lastModified = subResult.lastModified
+        }
+      }
+
+      sectionIndex++
+    }
+
+    hierarchicalSections = buildSectionHierarchy(sections)
+
   } else if (Array.isArray(sectionsConfig) && sectionsConfig.length > 0) {
-    // Explicit sections array
+    // Strict: explicit sections array (only listed sections processed)
     const result = await processExplicitSections(sectionsConfig, pagePath, siteRoot)
     hierarchicalSections = result.sections
     pageAssetCollection = result.assetCollection
@@ -720,9 +905,13 @@ async function processPage(pagePath, pageName, siteRoot, { isIndex = false, pare
 function determineIndexPage(orderConfig, availableFolders) {
   const { pages: pagesArray, index: indexName } = orderConfig || {}
 
-  // 1. Explicit pages array - first item is index
+  // 1. Explicit pages array - first non-'...' item is index
   if (Array.isArray(pagesArray) && pagesArray.length > 0) {
-    return pagesArray[0]
+    const parsed = parseWildcardArray(pagesArray)
+    if (parsed && parsed.before.length > 0) {
+      return extractItemName(parsed.before[0])
+    }
+    // Array starts with '...' or is ['...'] — no index from pages, fall through
   }
 
   // 2. Explicit index property
@@ -786,7 +975,6 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
     // Read folder.yml or page.yml to determine mode and get config
     const { config: dirConfig, mode: dirMode } = await readFolderConfig(entryPath, contentMode)
     const numericOrder = typeof dirConfig.order === 'number' ? dirConfig.order : undefined
-    const childOrderArray = Array.isArray(dirConfig.order) ? dirConfig.order : undefined
 
     pageFolders.push({
       name: entry,
@@ -796,8 +984,7 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
       dirMode,
       childOrderConfig: {
         pages: dirConfig.pages,
-        index: dirConfig.index,
-        order: childOrderArray
+        index: dirConfig.index
       }
     })
   }
@@ -811,14 +998,26 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
     return a.name.localeCompare(b.name)
   })
 
-  // Apply non-strict order from parent config (if present)
-  const orderedFolders = applyNonStrictOrder(pageFolders, orderConfig?.order)
+  // Apply ordering: pages: (wildcard-aware) > order: [array] (backward compat) > default
+  let orderedFolders
+  let strictPageNames = null
+
+  const pagesParsed = Array.isArray(orderConfig?.pages) ? parseWildcardArray(orderConfig.pages) : null
+
+  if (pagesParsed && pagesParsed.mode !== 'all') {
+    orderedFolders = applyWildcardOrder(pageFolders, pagesParsed)
+    if (pagesParsed.mode === 'strict') {
+      strictPageNames = new Set(pagesParsed.before.map(extractItemName).filter(Boolean))
+    }
+  } else {
+    orderedFolders = pageFolders
+  }
 
   // Check if this directory contains version folders (versioned section)
   const folderNames = orderedFolders.map(f => f.name)
   const detectedVersions = detectVersions(folderNames)
 
-  // If versioned section, handle version folders specially (always sections mode)
+  // If versioned section, handle version folders specially (always page mode)
   if (detectedVersions && !versionContext) {
     const parentConfig = await readYamlFile(join(dirPath, 'page.yml'))
     const versionMeta = buildVersionMetadata(detectedVersions, parentConfig)
@@ -877,12 +1076,28 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
       }
     }
 
-    // Apply non-strict order to md-file-pages
-    const orderedMdPages = applyNonStrictOrder(mdPageItems, orderConfig?.order)
+    // Apply ordering: pages: (wildcard-aware) > order: [array] (backward compat) > default
+    let orderedMdPages
+    let strictPageNamesFM = null
 
-    // In pages mode, only promote an index if explicitly set via index: in folder.yml
-    // The container page itself owns the parent route — don't auto-promote children
-    const indexName = orderConfig?.index || null
+    const pagesParsedFM = Array.isArray(orderConfig?.pages) ? parseWildcardArray(orderConfig.pages) : null
+
+    if (pagesParsedFM && pagesParsedFM.mode !== 'all') {
+      orderedMdPages = applyWildcardOrder(mdPageItems, pagesParsedFM)
+      if (pagesParsedFM.mode === 'strict') {
+        strictPageNamesFM = new Set(pagesParsedFM.before.map(extractItemName).filter(Boolean))
+      }
+    } else {
+      orderedMdPages = mdPageItems
+    }
+
+    // In folder mode, determine index: pages: first item, or explicit index:
+    let indexName = null
+    if (pagesParsedFM && pagesParsedFM.before.length > 0) {
+      indexName = extractItemName(pagesParsedFM.before[0])
+    } else {
+      indexName = orderConfig?.index || null
+    }
 
     // Add md-file-pages
     for (const { name, result } of orderedMdPages) {
@@ -906,7 +1121,7 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
       const isIndex = entry === indexName
 
       if (dirMode === 'sections') {
-        // Subdirectory overrides to sections mode — process normally
+        // Subdirectory overrides to page mode — process normally
         const result = await processPage(entryPath, entry, siteRoot, {
           isIndex, parentRoute, parentFetch, versionContext
         })
@@ -917,7 +1132,7 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
           iconCollection = mergeIconCollections(iconCollection, pageIcons)
           pages.push(page)
 
-          // Recurse into subdirectories (sections mode)
+          // Recurse into subdirectories (page mode)
           const childParentRoute = isIndex ? parentRoute : page.route
           const childFetch = page.fetch || parentFetch
           const subResult = await collectPagesRecursive(entryPath, childParentRoute, siteRoot, childOrderConfig, childFetch, versionContext, 'sections')
@@ -929,7 +1144,7 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
           }
         }
       } else {
-        // Container directory in pages mode — create minimal page, recurse
+        // Container directory in folder mode — create minimal page, recurse
         const containerRoute = isIndex
           ? parentRoute
           : parentRoute === '/' ? `/${entry}` : `${parentRoute}/${entry}`
@@ -971,7 +1186,7 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
 
         pages.push(containerPage)
 
-        // Recurse in pages mode
+        // Recurse in folder mode
         const subResult = await collectPagesRecursive(entryPath, containerRoute, siteRoot, childOrderConfig, parentFetch, versionContext, 'pages')
         pages.push(...subResult.pages)
         assetCollection = mergeAssetCollections(assetCollection, subResult.assetCollection)
@@ -982,6 +1197,17 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
       }
     }
 
+    // When pages: is strict (no '...'), hide unlisted direct children from navigation
+    if (strictPageNamesFM) {
+      for (const page of pages) {
+        const childName = getDirectChildName(page.route, parentRoute)
+          || (page.sourcePath ? getDirectChildName(page.sourcePath, parentRoute) : null)
+        if (childName && !strictPageNamesFM.has(childName) && !page.hidden) {
+          page.hidden = true
+        }
+      }
+    }
+
     return { pages, assetCollection, iconCollection, notFound, versionedScopes }
   }
 
@@ -1000,8 +1226,8 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
     const isIndex = entry === indexPageName
 
     if (dirMode === 'pages') {
-      // Child directory switches to pages mode (has folder.yml) —
-      // create container page with empty sections, recurse in pages mode
+      // Child directory switches to folder mode (has folder.yml) —
+      // create container page with empty sections, recurse in folder mode
       const containerRoute = isIndex
         ? parentRoute
         : parentRoute === '/' ? `/${entry}` : `${parentRoute}/${entry}`
@@ -1090,6 +1316,17 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
     }
   }
 
+  // When pages: is strict (no '...'), hide unlisted direct children from navigation
+  if (strictPageNames) {
+    for (const page of pages) {
+      const childName = getDirectChildName(page.route, parentRoute)
+        || (page.sourcePath ? getDirectChildName(page.sourcePath, parentRoute) : null)
+      if (childName && !strictPageNames.has(childName) && !page.hidden) {
+        page.hidden = true
+      }
+    }
+  }
+
   return { pages, assetCollection, iconCollection, notFound, versionedScopes }
 }
 
@@ -1230,8 +1467,7 @@ export async function collectSiteContent(sitePath, options = {}) {
   // Extract page ordering config from site.yml
   const siteOrderConfig = {
     pages: siteConfig.pages,
-    index: siteConfig.index,
-    order: Array.isArray(siteConfig.order) ? siteConfig.order : undefined
+    index: siteConfig.index
   }
 
   // Determine root content mode from folder.yml/page.yml presence in pages directory
@@ -1289,8 +1525,11 @@ export async function collectSiteContent(sitePath, options = {}) {
     page.parent = parentPage ? parentPage.route : null
   }
 
-  // Sort pages by order
-  pages.sort((a, b) => (a.order ?? 999) - (b.order ?? 999))
+  // Page order is determined by per-level sorting during collection:
+  // 1. Numeric 'order' property in page.yml (lower first, within each level)
+  // 2. pages: array in parent config (wildcard-aware, overrides numeric order)
+  // 3. order: [array] in parent config (non-strict, backward compat)
+  // No global re-sort — collection order is authoritative.
 
   // Log asset summary
   const assetCount = Object.keys(assetCollection.assets).length
@@ -1333,4 +1572,12 @@ export async function collectSiteContent(sitePath, options = {}) {
   }
 }
 
+// Exported for testing
+export {
+  extractItemName,
+  parseWildcardArray,
+  applyWildcardOrder,
+  getDirectChildName
+}
+
 export default collectSiteContent