@uniweb/build 0.14.40 → 0.15.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.14.40",
+  "version": "0.15.1",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -59,12 +59,12 @@
     "js-yaml": "^4.1.0",
     "sharp": "^0.33.2",
     "yaml": "^2.5.0",
-    "@uniweb/content-writer": "0.2.7",
-    "@uniweb/theming": "0.1.12"
+    "@uniweb/theming": "0.1.12",
+    "@uniweb/content-writer": "0.2.7"
   },
   "optionalDependencies": {
-    "@uniweb/content-reader": "1.1.14",
-    "@uniweb/runtime": "0.8.32",
+    "@uniweb/runtime": "0.8.33",
+    "@uniweb/content-reader": "1.1.15",
     "@uniweb/schemas": "0.2.4"
   },
   "peerDependencies": {
@@ -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/core": "0.7.26"
+    "@uniweb/core": "0.7.27"
   },
   "peerDependenciesMeta": {
     "vite": {

package/src/content/index.js

@@ -28,7 +28,6 @@ export {
   applySort,
   applyPostProcessing,
   mergeDataIntoContent,
-  singularize,
 } from '../site/data-fetcher.js'
 
 // Cross-reference registry moved out of build into kit

package/src/site/build-site-data.js

@@ -98,7 +98,7 @@ export async function buildSiteData({
   //    No vite needed — collectSiteContent is a plain async function.
   //    dropUnpublished: link mode is always a published deploy — prune hidden
   //    pages + their subtree so drafts never reach the served site.
-  let siteContent = await collectSiteContent(resolvedSiteRoot, { foundationPath, dropUnpublished: true, base: basePath })
+  let siteContent = await collectSiteContent(resolvedSiteRoot, { foundationPath, dropUnpublished: true, base: basePath, strict: true })
 
   // 2. Compile content collections (file-based markdown/yaml/json).
   //    `writeCollectionFiles` lands them under `<siteRoot>/public/data/`;

package/src/site/content-collector.js

@@ -25,12 +25,12 @@
 
 import { readFile, readdir, stat } from 'node:fs/promises'
 import { join, parse, resolve, sep } from 'node:path'
-import { existsSync, statSync, realpathSync } from 'node:fs'
+import { existsSync, statSync, realpathSync, readdirSync } from 'node:fs'
 import yaml from 'js-yaml'
 import { collectSectionAssets, mergeAssetCollections, collectConfigAssets } from './assets.js'
 import { collectSectionIcons, mergeIconCollections, buildIconManifest } from './icons.js'
 import { normalizeHideIn, dropUnpublishedPages } from './nav-visibility.js'
-import { parseFetchConfig, singularize } from './data-fetcher.js'
+import { parseFetchConfig } from './data-fetcher.js'
 import { buildTheme, extractFoundationVars } from '../theme/index.js'
 import { resolveDefaultLocale, resolvePublishableLocales, validateLanguageConfig } from '@uniweb/core'
 
@@ -267,10 +267,18 @@ function stripAtPrefix(filename) {
 
 /**
  * Check if a folder should be ignored.
- * Excludes folders starting with _ (drafts/private).
+ *
+ * Excludes folders starting with `_` (drafts/private) and with `.` (hidden).
+ *
+ * Hidden folders matter more than they look. A site's own `pages/` never holds
+ * one, but a mount target routinely does: point `paths:` at a directory that is
+ * also a git working tree — a sibling clone, which the docs suggest — and `.git`
+ * is a directory sitting right next to the content. Walked as content it
+ * contributed hundreds of routes. (A submodule hides this: there, `.git` is a
+ * file, so only the plain-clone case ever showed it.)
  */
 function isIgnoredFolder(name) {
-  return name.startsWith('_')
+  return name.startsWith('_') || name.startsWith('.')
 }
 
 /**
@@ -339,6 +347,35 @@ async function readFolderConfig(dirPath, inheritedMode) {
   return { config: {}, mode: inheritedMode, source: 'inherited' }
 }
 
+/**
+ * Whether a mount target holds anything this collector would read.
+ *
+ * A mount declares "pages come from here." An existing, readable directory is
+ * not the same claim — an uninitialized git submodule is exactly that, and it
+ * is the state a plain `git clone` leaves one in. So look for content the walk
+ * would actually pick up: a folder to recurse into, a markdown file, or a
+ * folder/page config. README.md deliberately does not count; isMarkdownFile
+ * excludes it as repo documentation.
+ *
+ * @param {string} dirPath - Absolute path to the mount target
+ * @returns {boolean}
+ */
+function mountHasContent(dirPath) {
+  let entries
+  try {
+    entries = readdirSync(dirPath, { withFileTypes: true })
+  } catch {
+    return false
+  }
+
+  return entries.some(entry => {
+    const { name } = entry
+    if (name.startsWith('.') || isIgnoredFolder(name)) return false
+    if (entry.isDirectory()) return true
+    return isMarkdownFile(name) || name === 'folder.yml' || name === 'page.yml'
+  })
+}
+
 /**
  * Extract page mounts from site.yml paths: config.
  *
@@ -348,9 +385,14 @@ async function readFolderConfig(dirPath, inheritedMode) {
  * @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
+ * @param {Object} [options]
+ * @param {boolean} [options.strict=false] - Treat a mount that contributes no
+ *   pages as an error rather than a warning. Dev is forgiving — an empty folder
+ *   is normal the moment an author creates one. A build is not: shipping a route
+ *   with nothing under it is never what was meant.
  * @returns {Map<string, string>|null} Route segment → canonical absolute path, or null
  */
-function resolveMounts(pathsConfig, sitePath, pagesPath) {
+function resolveMounts(pathsConfig, sitePath, pagesPath, { strict = false } = {}) {
   if (!pathsConfig || typeof pathsConfig !== 'object') return null
 
   // Extract entries with "pages/" prefix (e.g., "pages/docs": "../../../docs")
@@ -390,6 +432,22 @@ function resolveMounts(pathsConfig, sitePath, pagesPath) {
       )
     }
 
+    // Existing, readable, and empty — which is what a mount looks like when its
+    // git submodule was never fetched. Every check above passes and the route
+    // builds with nothing under it, so say so rather than shipping the silence.
+    if (!mountHasContent(absolutePath)) {
+      const detail =
+        `External pages path is empty: ${absolutePath}\n` +
+        `  Declared in site.yml: pages/${routeSegment}: ${relativePath}\n` +
+        `  The "${routeSegment}" route will have no pages under it.\n` +
+        `  If this is a git submodule: git submodule update --init --recursive`
+
+      if (strict) {
+        throw new Error(`[content-collector] ${detail}`)
+      }
+      console.warn(`[content-collector] ${detail}`)
+    }
+
     const canonical = realpathSync(absolutePath)
 
     // Reject node_modules
@@ -1373,28 +1431,61 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
   let notFound = null
   const versionedScopes = new Map() // scope route → versionMeta
 
-  // First pass: discover all page folders and read their config
-  const pageFolders = []
+  // First pass: discover all page folders and read their config.
+  //
+  // A route can be backed by a local directory, by a mount, or by both. When
+  // both, the two configs LAYER rather than one replacing the other — the same
+  // rule as params over meta defaults, or page over folder config. The division
+  // it encodes: the mounted repo declares what its content is (ordering, title,
+  // how it nests), the local folder declares how this site presents it (layout,
+  // SEO, menu visibility). A local folder used to win outright, and since a
+  // local folder is the only place `layout:` can be declared for a mounted
+  // route, an author had to choose between a layout and the mounted repo's own
+  // config. There was no way to see which one had been dropped.
+  const localDirs = new Set()
   for (const entry of entries) {
     if (isIgnoredFolder(entry)) continue // Skip _prefixed folders
-    const entryPath = join(dirPath, entry)
-    const stats = await stat(entryPath)
-    if (!stats.isDirectory()) continue
+    const stats = await stat(join(dirPath, entry))
+    if (stats.isDirectory()) localDirs.add(entry)
+  }
+
+  const routeNames = new Set([...localDirs, ...(mounts?.keys() ?? [])])
 
-    // 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 pageFolders = []
+  for (const name of routeNames) {
+    const mountPath = mounts?.get(name) ?? null
+    const localPath = localDirs.has(name) ? join(dirPath, name) : null
+
+    // The content's declaration about itself, then the site's about presenting it.
+    const mounted = mountPath ? await readFolderConfig(mountPath, 'pages') : null
+    const local = localPath ? await readFolderConfig(localPath, contentMode) : null
+
+    const dirConfig = mounted
+      ? { title: mounted.config.title || name, ...mounted.config, ...local?.config }
+      : local.config
+
+    // Mode is not a config key — it comes from which config file exists, so it
+    // cannot be spread. An explicit local declaration wins (a `page.yml` stub
+    // with its own markdown is a real landing page above mounted children);
+    // otherwise the mount decides, because it owns the content being read.
+    const dirMode = local && local.source !== 'inherited'
+      ? local.mode
+      : mounted?.mode ?? local?.mode ?? contentMode
 
-    // Extract layout name from folder config (folder.yml layout: or page.yml layout:)
     const folderLayout = typeof dirConfig.layout === 'string' ? dirConfig.layout
       : dirConfig.layout?.name || null
 
     pageFolders.push({
-      name: entry,
-      path: entryPath,
-      order: numericOrder,
+      name,
+      path: localPath ?? mountPath,
+      order: typeof dirConfig.order === 'number' ? dirConfig.order : undefined,
       dirConfig,
       dirMode,
+      // The mode the mounted subtree is walked in belongs to the mount: it is
+      // the mount's tree. Without this a `page.yml` stub silently imposed page
+      // mode on a mounted folder of pages, and only every mounted subfolder
+      // carrying its own folder.yml kept that from collapsing them into one page.
+      mountedContentMode: mounted?.mode ?? null,
       childOrderConfig: {
         pages: dirConfig.pages,
         index: dirConfig.index
@@ -1403,29 +1494,6 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
     })
   }
 
-  // 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')
-        const mountLayout = typeof mountConfig.layout === 'string' ? mountConfig.layout
-          : mountConfig.layout?.name || null
-        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
-          },
-          childLayoutName: mountLayout
-        })
-      }
-    }
-  }
-
   // Sort page folders by order (ascending), then alphabetically
   // Pages without explicit order come after ordered pages (order ?? Infinity)
   pageFolders.sort((a, b) => {
@@ -1565,7 +1633,7 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
 
     // Process subdirectories
     for (const folder of orderedFolders) {
-      const { name: entry, path: entryPath, dirConfig, dirMode, childOrderConfig, childLayoutName } = folder
+      const { name: entry, path: entryPath, dirConfig, dirMode, mountedContentMode, childOrderConfig, childLayoutName } = folder
       const isIndex = entry === indexName
       const effectiveLayout = childLayoutName || parentLayoutName
 
@@ -1590,11 +1658,14 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
 
           pages.push(page)
 
-          // Recurse into subdirectories (page mode)
+          // Recurse into subdirectories (page mode). When the children come from
+          // a mount, they are walked in the mount's own mode — it is the mount's
+          // tree, and its root config is what declared how its content is shaped.
           const childDirPath = mounts?.get(entry) || entryPath
           const childParentRoute = isIndex ? parentRoute : page.route
           const childFetch = page.fetch || parentFetch
-          const subResult = await collectPagesRecursive(childDirPath, childParentRoute, siteRoot, childOrderConfig, childFetch, versionContext, 'sections', null, effectiveLayout)
+          const childContentMode = mountedContentMode ?? 'sections'
+          const subResult = await collectPagesRecursive(childDirPath, childParentRoute, siteRoot, childOrderConfig, childFetch, versionContext, childContentMode, null, effectiveLayout)
           pages.push(...subResult.pages)
           assetCollection = mergeAssetCollections(assetCollection, subResult.assetCollection)
           iconCollection = mergeIconCollections(iconCollection, subResult.iconCollection)
@@ -1693,7 +1764,7 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
 
   // Second pass: process each page folder
   for (const folder of orderedFolders) {
-    const { name: entry, path: entryPath, dirConfig, dirMode, childOrderConfig, childLayoutName } = folder
+    const { name: entry, path: entryPath, dirConfig, dirMode, mountedContentMode, childOrderConfig, childLayoutName } = folder
     const isIndex = entry === indexPageName
     const effectiveLayout = childLayoutName || parentLayoutName
 
@@ -1782,14 +1853,17 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
           pages.push(page)
         }
 
-        // Recursively process subdirectories
+        // Recursively process subdirectories. Children coming from a mount are
+        // walked in the mount's own mode — its root config declared how its
+        // content is shaped, and this local stub holds none of that content.
         {
           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(childDirPath, childParentRoute, siteRoot, childOrderConfig, childFetch, versionContext, dirMode, null, effectiveLayout)
+          const childContentMode = mountedContentMode ?? dirMode
+          const subResult = await collectPagesRecursive(childDirPath, childParentRoute, siteRoot, childOrderConfig, childFetch, versionContext, childContentMode, null, effectiveLayout)
           pages.push(...subResult.pages)
           assetCollection = mergeAssetCollections(assetCollection, subResult.assetCollection)
           iconCollection = mergeIconCollections(iconCollection, subResult.iconCollection)
@@ -2011,10 +2085,11 @@ async function collectLayouts(layoutDir, siteRoot, layoutNames = new Set()) {
  * @param {string} options.foundationPath - Path to foundation directory (for theme vars)
  * @param {string} [options.configFile='site.yml'] - Name of the top-level config file inside sitePath. Defaults to 'site.yml'. Document tools (unipress) pass 'document.yml'.
  * @param {'document'|'site'} [options.profile] - Explicit content profile, authoritative over the filename. Lets a tool that knows its context (unipress → 'document') read an arbitrarily named config with the right directory/mode/ordering. Falls back to the configFile-derived profile when omitted.
+ * @param {boolean} [options.strict=false] - Fail on content problems that would ship broken output rather than warning about them. A production build passes true; dev leaves it false, because a folder an author just created is empty for a moment and that is not an error.
  * @returns {Promise<Object>} Site content object with assets manifest
  */
 export async function collectSiteContent(sitePath, options = {}) {
-  const { foundationPath, configFile = 'site.yml', profile: profileName, dropUnpublished = false, base = '/' } = options
+  const { foundationPath, configFile = 'site.yml', profile: profileName, dropUnpublished = false, base = '/', strict = false } = options
 
   // Read site config and raw theme config
   const siteConfig = await readYamlFile(join(sitePath, configFile))
@@ -2054,7 +2129,7 @@ export async function collectSiteContent(sitePath, options = {}) {
       : profileDefault
   }
 
-  const mounts = resolveMounts(siteConfig.paths, sitePath, pagesPath)
+  const mounts = resolveMounts(siteConfig.paths, sitePath, pagesPath, { strict })
 
   const layoutPath = siteConfig.paths?.layout
     ? resolve(sitePath, siteConfig.paths.layout)

package/src/site/data-fetcher.js

@@ -504,58 +504,6 @@ export function mergeDataIntoContent(content, fetchedData, schema, merge = false
   return result
 }
 
-/**
- * Convert a plural schema name to singular
- * Used for dynamic routes where the parent has "articles" and
- * each child page gets the singular "article" for the current item
- *
- * @param {string} name - Plural name (e.g., 'articles', 'posts', 'people')
- * @returns {string} Singular name (e.g., 'article', 'post', 'person')
- *
- * @example
- * singularize('articles') // 'article'
- * singularize('posts')    // 'post'
- * singularize('people')   // 'person'
- * singularize('categories') // 'category'
- */
-export function singularize(name) {
-  if (!name) return name
-
-  // Handle common irregular plurals
-  const irregulars = {
-    people: 'person',
-    children: 'child',
-    men: 'man',
-    women: 'woman',
-    feet: 'foot',
-    teeth: 'tooth',
-    mice: 'mouse',
-    geese: 'goose',
-  }
-
-  if (irregulars[name]) return irregulars[name]
-
-  // Standard rules (in order of specificity)
-  if (name.endsWith('ies')) {
-    // categories -> category
-    return name.slice(0, -3) + 'y'
-  }
-  if (name.endsWith('ves')) {
-    // leaves -> leaf
-    return name.slice(0, -3) + 'f'
-  }
-  if (name.endsWith('es') && (name.endsWith('shes') || name.endsWith('ches') || name.endsWith('xes') || name.endsWith('sses') || name.endsWith('zes'))) {
-    // boxes -> box, watches -> watch
-    return name.slice(0, -2)
-  }
-  if (name.endsWith('s') && !name.endsWith('ss')) {
-    // articles -> article
-    return name.slice(0, -1)
-  }
-
-  return name
-}
-
 /**
  * Execute multiple fetch operations in parallel
  *

package/src/site/index.js

@@ -45,8 +45,7 @@ export {
   applyFilter,
   applySort,
   applyPostProcessing,
-  mergeDataIntoContent,
-  singularize
+  mergeDataIntoContent
 } from './data-fetcher.js'
 export { loadDeployYml, resolveTarget } from './deploy-config.js'
 export { recordLastDeploy, recordTarget } from './deploy-config-writer.js'

package/src/site/plugin.js

@@ -639,7 +639,9 @@ export function siteContentPlugin(options = {}) {
       try {
         // dropUnpublished only on a production build — in dev (serve) hidden
         // pages stay in the graph so in-progress drafts remain previewable.
-        siteContent = await collectSiteContent(resolvedSitePath, { foundationPath, dropUnpublished: isProduction, base: basePath })
+        // strict on a production build: a mount that contributes no pages is a
+        // warning while you author and a broken deploy once you ship.
+        siteContent = await collectSiteContent(resolvedSitePath, { foundationPath, dropUnpublished: isProduction, base: basePath, strict: isProduction })
         headHtml = await loadHeadHtml()
         console.log(`[site-content] Collected ${siteContent.pages?.length || 0} pages`)