@uniweb/build 0.6.17 → 0.6.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.6.17",
+  "version": "0.6.19",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -50,9 +50,9 @@
     "sharp": "^0.33.2"
   },
   "optionalDependencies": {
-    "@uniweb/schemas": "0.2.1",
     "@uniweb/content-reader": "1.1.2",
-    "@uniweb/runtime": "0.5.21"
+    "@uniweb/runtime": "0.5.21",
+    "@uniweb/schemas": "0.2.1"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0",

package/src/i18n/index.js

@@ -169,21 +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,
     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)
 

package/src/site/content-collector.js

@@ -24,8 +24,8 @@
  */
 
 import { readFile, readdir, stat } from 'node:fs/promises'
-import { join, parse, resolve } from 'node:path'
-import { existsSync } from 'node:fs'
+import { join, parse, resolve, sep } from 'node:path'
+import { existsSync, statSync, realpathSync } from 'node:fs'
 import yaml from 'js-yaml'
 import { collectSectionAssets, mergeAssetCollections } from './assets.js'
 import { collectSectionIcons, mergeIconCollections, buildIconManifest } from './icons.js'
@@ -229,6 +229,102 @@ async function readFolderConfig(dirPath, inheritedMode) {
   return { config: {}, mode: inheritedMode, source: 'inherited' }
 }
 
+/**
+ * Extract page mounts from site.yml paths: config.
+ *
+ * Keys like `pages/docs: ../../../docs` map a route segment to an external
+ * directory. All validation happens upfront before any page collection begins.
+ *
+ * @param {Object} pathsConfig - The paths: object from site.yml
+ * @param {string} sitePath - Absolute path to the site directory
+ * @param {string} pagesPath - Resolved absolute path to the pages directory
+ * @returns {Map<string, string>|null} Route segment → canonical absolute path, or null
+ */
+function resolveMounts(pathsConfig, sitePath, pagesPath) {
+  if (!pathsConfig || typeof pathsConfig !== 'object') return null
+
+  // Extract entries with "pages/" prefix (e.g., "pages/docs": "../../../docs")
+  const mountEntries = Object.entries(pathsConfig)
+    .filter(([key]) => key.startsWith('pages/'))
+    .map(([key, value]) => [key.slice('pages/'.length), value])
+
+  if (mountEntries.length === 0) return null
+
+  const resolved = new Map()
+  const canonicalPagesPath = existsSync(pagesPath) ? realpathSync(pagesPath) : resolve(pagesPath)
+
+  for (const [routeSegment, relativePath] of mountEntries) {
+    // Validate route segment (simple name, no slashes, no special chars)
+    if (!routeSegment || routeSegment.includes('/') || routeSegment.startsWith('.') || routeSegment.startsWith('_')) {
+      throw new Error(
+        `[content-collector] Invalid mount "pages/${routeSegment}" in site.yml paths.\n` +
+        `  The segment after "pages/" must be a simple name (no slashes, dots, or underscores prefix).`
+      )
+    }
+
+    const absolutePath = resolve(sitePath, relativePath)
+
+    // Check existence
+    if (!existsSync(absolutePath)) {
+      throw new Error(
+        `[content-collector] External pages path does not exist: ${absolutePath}\n` +
+        `  Declared in site.yml: pages/${routeSegment}: ${relativePath}`
+      )
+    }
+
+    // Check it's a directory
+    if (!statSync(absolutePath).isDirectory()) {
+      throw new Error(
+        `[content-collector] External pages path is not a directory: ${absolutePath}\n` +
+        `  Declared in site.yml: pages/${routeSegment}: ${relativePath}`
+      )
+    }
+
+    const canonical = realpathSync(absolutePath)
+
+    // Reject node_modules
+    if (canonical.includes(`${sep}node_modules${sep}`)) {
+      throw new Error(
+        `[content-collector] External pages path must not be inside node_modules: ${canonical}\n` +
+        `  Declared in site.yml: pages/${routeSegment}: ${relativePath}`
+      )
+    }
+
+    // Self-inclusion: must not overlap with site pages directory
+    if (
+      canonical === canonicalPagesPath ||
+      canonical.startsWith(canonicalPagesPath + sep) ||
+      canonicalPagesPath.startsWith(canonical + sep)
+    ) {
+      throw new Error(
+        `[content-collector] External pages path overlaps with site pages directory:\n` +
+        `  Path: ${canonical}\n` +
+        `  Site pages: ${canonicalPagesPath}\n` +
+        `  Declared in site.yml: pages/${routeSegment}`
+      )
+    }
+
+    // Cross-mount overlap: no mount target should be ancestor/descendant of another
+    for (const [otherKey, otherPath] of resolved) {
+      if (
+        canonical === otherPath ||
+        canonical.startsWith(otherPath + sep) ||
+        otherPath.startsWith(canonical + sep)
+      ) {
+        throw new Error(
+          `[content-collector] External pages paths overlap:\n` +
+          `  "pages/${routeSegment}" → ${canonical}\n` +
+          `  "pages/${otherKey}" → ${otherPath}`
+        )
+      }
+    }
+
+    resolved.set(routeSegment, canonical)
+  }
+
+  return resolved.size > 0 ? resolved : null
+}
+
 /**
  * Parse numeric prefix from filename (e.g., "1-hero.md" → { prefix: "1", name: "hero" })
  * Supports:
@@ -271,23 +367,130 @@ 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 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
+}
+
+/**
+ * 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 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 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
 }
 
 /**
@@ -482,6 +685,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
@@ -507,13 +713,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")
@@ -579,8 +786,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)
@@ -609,8 +817,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
@@ -722,9 +1001,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
@@ -762,7 +1045,7 @@ function determineIndexPage(orderConfig, availableFolders) {
  * @param {string} contentMode - 'sections' (default) or 'pages' (md files are child pages)
  * @returns {Promise<Object>} { pages, assetCollection, iconCollection, notFound, versionedScopes }
  */
-async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig = {}, parentFetch = null, versionContext = null, contentMode = 'sections') {
+async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig = {}, parentFetch = null, versionContext = null, contentMode = 'sections', mounts = null) {
   const entries = await readdir(dirPath)
   const pages = []
   let assetCollection = {
@@ -788,7 +1071,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,
@@ -798,12 +1080,31 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
       dirMode,
       childOrderConfig: {
         pages: dirConfig.pages,
-        index: dirConfig.index,
-        order: childOrderArray
+        index: dirConfig.index
       }
     })
   }
 
+  // Inject virtual entries for mounts without physical directories
+  if (mounts) {
+    for (const [routeSegment, mountPath] of mounts) {
+      if (!pageFolders.some(f => f.name === routeSegment)) {
+        const { config: mountConfig } = await readFolderConfig(mountPath, 'pages')
+        pageFolders.push({
+          name: routeSegment,
+          path: mountPath,
+          order: typeof mountConfig.order === 'number' ? mountConfig.order : undefined,
+          dirConfig: { title: mountConfig.title || routeSegment, ...mountConfig },
+          dirMode: 'pages',
+          childOrderConfig: {
+            pages: mountConfig.pages,
+            index: mountConfig.index
+          }
+        })
+      }
+    }
+  }
+
   // Sort page folders by order (ascending), then alphabetically
   // Pages without explicit order come after ordered pages (order ?? Infinity)
   pageFolders.sort((a, b) => {
@@ -813,8 +1114,20 @@ 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)
@@ -879,12 +1192,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 folder 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) {
@@ -920,9 +1249,10 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
           pages.push(page)
 
           // Recurse into subdirectories (page mode)
+          const childDirPath = mounts?.get(entry) || entryPath
           const childParentRoute = isIndex ? parentRoute : page.route
           const childFetch = page.fetch || parentFetch
-          const subResult = await collectPagesRecursive(entryPath, childParentRoute, siteRoot, childOrderConfig, childFetch, versionContext, 'sections')
+          const subResult = await collectPagesRecursive(childDirPath, childParentRoute, siteRoot, childOrderConfig, childFetch, versionContext, 'sections', null)
           pages.push(...subResult.pages)
           assetCollection = mergeAssetCollections(assetCollection, subResult.assetCollection)
           iconCollection = mergeIconCollections(iconCollection, subResult.iconCollection)
@@ -974,7 +1304,8 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
         pages.push(containerPage)
 
         // Recurse in folder mode
-        const subResult = await collectPagesRecursive(entryPath, containerRoute, siteRoot, childOrderConfig, parentFetch, versionContext, 'pages')
+        const childDirPath = mounts?.get(entry) || entryPath
+        const subResult = await collectPagesRecursive(childDirPath, containerRoute, siteRoot, childOrderConfig, parentFetch, versionContext, 'pages', null)
         pages.push(...subResult.pages)
         assetCollection = mergeAssetCollections(assetCollection, subResult.assetCollection)
         iconCollection = mergeIconCollections(iconCollection, subResult.iconCollection)
@@ -984,6 +1315,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 }
   }
 
@@ -1049,7 +1391,8 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
         pages.push(containerPage)
       }
 
-      const subResult = await collectPagesRecursive(entryPath, containerRoute, siteRoot, childOrderConfig, parentFetch, versionContext, 'pages')
+      const childDirPath = mounts?.get(entry) || entryPath
+      const subResult = await collectPagesRecursive(childDirPath, containerRoute, siteRoot, childOrderConfig, parentFetch, versionContext, 'pages', null)
       pages.push(...subResult.pages)
       assetCollection = mergeAssetCollections(assetCollection, subResult.assetCollection)
       iconCollection = mergeIconCollections(iconCollection, subResult.iconCollection)
@@ -1076,11 +1419,12 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
 
         // Recursively process subdirectories
         {
+          const childDirPath = mounts?.get(entry) || entryPath
           const childParentRoute = isIndex
             ? (hasExplicitOrder ? parentRoute : (page.sourcePath || page.route))
             : page.route
           const childFetch = page.fetch || parentFetch
-          const subResult = await collectPagesRecursive(entryPath, childParentRoute, siteRoot, childOrderConfig, childFetch, versionContext, dirMode)
+          const subResult = await collectPagesRecursive(childDirPath, childParentRoute, siteRoot, childOrderConfig, childFetch, versionContext, dirMode, null)
           pages.push(...subResult.pages)
           assetCollection = mergeAssetCollections(assetCollection, subResult.assetCollection)
           iconCollection = mergeIconCollections(iconCollection, subResult.iconCollection)
@@ -1092,6 +1436,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 }
 }
 
@@ -1202,6 +1557,8 @@ export async function collectSiteContent(sitePath, options = {}) {
     ? resolve(sitePath, siteConfig.paths.pages)
     : join(sitePath, 'pages')
 
+  const mounts = resolveMounts(siteConfig.paths, sitePath, pagesPath)
+
   const layoutPath = siteConfig.paths?.layout
     ? resolve(sitePath, siteConfig.paths.layout)
     : join(sitePath, 'layout')
@@ -1232,8 +1589,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
@@ -1244,7 +1600,7 @@ export async function collectSiteContent(sitePath, options = {}) {
 
   // Recursively collect all pages
   const { pages, assetCollection, iconCollection, notFound, versionedScopes } =
-    await collectPagesRecursive(pagesPath, '/', sitePath, siteOrderConfig, null, null, rootContentMode)
+    await collectPagesRecursive(pagesPath, '/', sitePath, siteOrderConfig, null, null, rootContentMode, mounts)
 
   // Deduplicate: remove content-less container pages whose route duplicates
   // a content-bearing page (e.g., a promoted index page)
@@ -1291,8 +1647,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
@@ -1335,4 +1694,12 @@ export async function collectSiteContent(sitePath, options = {}) {
   }
 }
 
+// Exported for testing
+export {
+  extractItemName,
+  parseWildcardArray,
+  applyWildcardOrder,
+  getDirectChildName
+}
+
 export default collectSiteContent