@uniweb/build 0.47.2 → 0.48.0

package/src/site/content-collector.js

@@ -24,16 +24,18 @@
 import { readFile, readdir, stat } from 'node:fs/promises'
 import { resolveQueriesConfig, toConfigQueries } from './queries-config.js'
 import { parseNumericPrefix, compareByNumericPrefix } from '../utils/numeric-prefix.js'
+import { isMarkdownFile, isIgnoredFolder } from '../utils/content-files.js'
+import { readLayoutFolder, DEFAULT_LAYOUT } from './layout-folder.js'
 import { join, parse, relative, resolve, sep } from 'node:path'
 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 } from './data-fetcher.js'
+import { parseFetchConfig, toFetchList } from './data-fetcher.js'
 import { resolveExtensionUrls } from './extension-urls.js'
 import { buildTheme, extractFoundationVars } from '../theme/index.js'
-import { resolveDefaultLocale, resolvePublishableLocales, validateLanguageConfig } from '@uniweb/core'
+import { resolveDefaultLocale, resolvePublishableLocales, validateLanguageConfig, pageRouteQuery } from '@uniweb/core'
 import { parseFrontmatter } from '../utils/frontmatter.js'
 
 // Try to import content-reader, fall back to simplified parser
@@ -245,6 +247,9 @@ export function declaredFetch(config, where) {
   return config?.fetch ?? fetchFromQueryShorthand(config?.query)
 }
 
+/** `parseFetchConfig`'s arguments for a level: its declaration, the file it sits in, and the level. */
+const fetchIn = (config, where, level) => [declaredFetch(config, where), where, { level }]
+
 /**
  * The refusals `declaredFetch` makes, alone — for a reader that must keep the
  * desugaring inline (the sync push's `settings.fetch`, whose sources
@@ -300,6 +305,51 @@ const isQueryNames = (value) =>
 const formatQueryNames = (value) =>
   isQueryNames(value) ? (Array.isArray(value) ? `[${value.join(', ')}]` : value) : '<name>'
 
+/**
+ * ⚠️ A `current:` NOTHING WILL READ — said once per binding. `current:` applies on a
+ * section's binding under the key its page's URL narrows (the route query,
+ * `pageRouteQuery`); anywhere else the runtime ignores it, and the author would see
+ * the section deliver its list as though the line were not there.
+ *
+ * @param {Array<Object>} pages - collected pages, parents linked
+ * @param {Object} layouts - collected layout areas (never on a parametric route)
+ * @param {Object|Array|null} siteFetch - the parsed site fetch
+ */
+function warnUnreadCurrent(pages, layouts, siteFetch) {
+  const byRoute = new Map(pages.map((p) => [p.route, p]))
+  const access = {
+    routeOf: (p) => p.route,
+    parentOf: (p) => (p.parent ? byRoute.get(p.parent) ?? null : null),
+    fetchOf: (p) => p.fetch,
+    sectionsOf: (p) => p.sections,
+    site: siteFetch,
+  }
+  const check = (sections, where, routeKeyOf) => {
+    for (const section of sections || []) {
+      for (const one of toFetchList(section.fetch)) {
+        if (one?.current === undefined) continue
+        const routeKey = routeKeyOf()
+        if (one.as === routeKey) continue
+        console.warn(
+          `[uniweb] ${where}: \`current: ${one.current}\` on content.data.${one.as} is ignored — it applies on a ` +
+            `section of a parametric page, under the key its URL narrows` +
+            (routeKey ? ` (here \`${routeKey}\`).` : '; this page has none.')
+        )
+      }
+      check(section.subsections, where, routeKeyOf)
+    }
+  }
+  for (const page of pages) {
+    let key
+    check(page.sections, page.route, () => (key === undefined ? (key = pageRouteQuery(page, access)?.key ?? null) : key))
+  }
+  for (const [name, areas] of Object.entries(layouts || {})) {
+    for (const [area, areaPage] of Object.entries(areas || {})) {
+      check(areaPage?.sections, `layout ${name}/${area}`, () => null)
+    }
+  }
+}
+
 /**
  * Build version metadata from detected versions and page.yml config
  * @param {Array<Object>} detectedVersions - Detected version infos
@@ -442,20 +492,6 @@ function extractInsets(doc) {
   return insets
 }
 
-/**
- * Check if a file is a markdown file that should be processed.
- * Excludes:
- * - Files not ending in .md
- * - Files starting with _ (drafts/private)
- * - README.md (repo documentation, not site content)
- */
-function isMarkdownFile(filename) {
-  if (!filename.endsWith('.md')) return false
-  if (filename.startsWith('_')) return false
-  if (filename.toLowerCase() === 'readme.md') return false
-  return true
-}
-
 /**
  * Check if a filename uses the @ prefix (child section convention).
  * @-prefixed files are excluded from auto-discovered top-level sections —
@@ -473,22 +509,6 @@ function stripAtPrefix(filename) {
   return filename.replace(/^@+/, '')
 }
 
-/**
- * Check if a folder should be ignored.
- *
- * 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('_') || name.startsWith('.')
-}
-
 /**
  * Workspace-root content profiles, dispatched on the top-level config filename.
  *
@@ -1054,7 +1074,7 @@ async function processMarkdownFile(filePath, id, siteRoot, defaultStableId = nul
     input,
     params: { ...params, ...props },
     content: proseMirrorContent,
-    fetch: parseFetchConfig(resolvedFetch),
+    fetch: parseFetchConfig(resolvedFetch, relative(siteRoot, filePath), { level: 'section' }),
     ...(insets.length > 0 ? { insets } : {}),
     subsections: []
   }
@@ -1666,7 +1686,7 @@ async function processPage(pagePath, pageName, siteRoot, { isIndex = false, pare
       },
 
       // Data fetching — `fetch:`, or the `query:` shorthand (`declaredFetch`)
-      fetch: parseFetchConfig(declaredFetch(pageConfig, relative(siteRoot, join(pagePath, 'page.yml')))),
+      fetch: parseFetchConfig(...fetchIn(pageConfig, relative(siteRoot, join(pagePath, 'page.yml')), 'page')),
 
       hasContent: hierarchicalSections.length > 0,
       sections: hierarchicalSections
@@ -2038,7 +2058,7 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
           // ⭐ `declaredFetch`, as every other level: this read `dirConfig.fetch`
           // alone until 2026-09-11, so a container's `folder.yml` shorthand reached
           // a backend on `push` and was dropped from a static build.
-          fetch: parseFetchConfig(declaredFetch(dirConfig, relative(siteRoot, join(entryPath, 'folder.yml')))) || null,
+          fetch: parseFetchConfig(...fetchIn(dirConfig, relative(siteRoot, join(entryPath, 'folder.yml')), 'page')) || null,
           hasContent: false,
           sections: [],
           order: typeof dirConfig.order === 'number' ? dirConfig.order : undefined
@@ -2135,7 +2155,7 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
         // a `folder.yml` here lost its `fetch:` (and its shorthand) on a static
         // build while `push` carried it, so its pages had the folder's data on a
         // hosted site and none on an exported one.
-        fetch: parseFetchConfig(declaredFetch(dirConfig, relative(siteRoot, join(entryPath, 'folder.yml')))) || null,
+        fetch: parseFetchConfig(...fetchIn(dirConfig, relative(siteRoot, join(entryPath, 'folder.yml')), 'page')) || null,
         hasContent: false,
         sections: [],
         order: typeof dirConfig.order === 'number' ? dirConfig.order : undefined
@@ -2222,12 +2242,6 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
   return { pages, assetCollection, iconCollection, notFound, versionedScopes }
 }
 
-/**
- * Load foundation variables from schema.json
- *
- * @param {string} foundationPath - Path to foundation directory
- * @returns {Promise<Object>} Foundation variables or empty object
- */
 /**
  * Load foundation schema data needed by the content collector.
  *
@@ -2239,11 +2253,16 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
  * the build never calls it), so it answers "something could resolve this",
  * never "Loom will".
  *
+ * ⛔ **No layout names.** This returned the foundation's layouts until 2026-09-13,
+ * for `collectLayouts` to decide whether a folder under `layout/` was a named
+ * layout. A site's meaning does not depend on a foundation the build may not have
+ * — see `./layout-folder.js`, which reads that folder from the site alone.
+ *
  * @param {string} foundationPath - Path to foundation directory
- * @returns {Promise<{ vars: Object, layoutNames: Set<string>, hasContentHandler: boolean }>}
+ * @returns {Promise<{ vars: Object, hasContentHandler: boolean }>}
  */
 export async function loadFoundationInfo(foundationPath) {
-  if (!foundationPath) return { vars: {}, layoutNames: new Set(), hasContentHandler: false }
+  if (!foundationPath) return { vars: {}, hasContentHandler: false }
 
   // ⛔ **NOT `dist/meta/schema.json`.** That file is the EDITOR's artifact — the
   // rich per-section declaration a visual editor needs to render parameter forms
@@ -2256,26 +2275,11 @@ export async function loadFoundationInfo(foundationPath) {
   // Reading the editor's copy here was wrong twice over. It made a site build
   // depend on the foundation having been BUILT, and it read a derived artifact
   // when the source it derives from is right there — `generate-entry.js` calls
-  // these same two functions (`:197` for vars, `:287` for layouts) to produce the
-  // very `schema.json` this used to read back.
-  //
-  // ⭐ **And it made dev and build classify layouts differently.** The old
-  // fallback returned an EMPTY layout set whenever no built schema existed —
-  // "the normal state for `uniweb dev`" — and `collectLayouts` treats a
-  // `layout/<Name>/` directory as a named layout only when `<Name>` is in that
-  // set, otherwise as a folder-form area of the DEFAULT layout. So the same site
-  // rendered `layout/Wide/` as the Wide layout after a build and as a default
-  // area called "Wide" in dev. Measured 2026-09-02 before this change:
-  //   built   layouts ["default","Wide"], default areas ["footer","header"]
-  //   dev     layouts ["default"],        default areas ["Wide","footer","header"]
-  // Reading from source removes the asymmetry: there is one answer, and it does
-  // not depend on whether `dist/` happens to exist.
+  // the same function to produce the very `schema.json` this used to read back.
   const { resolveFoundationSrcPath } = await import('../utils/foundation-source-root.js')
-  const { loadFoundationConfig, discoverLayoutsInPath } = await import('../schema.js')
+  const { loadFoundationConfig } = await import('../schema.js')
   const srcDir = resolveFoundationSrcPath(foundationPath)
 
-  // Two independent reads, so a failure in one does not cost the other. The
-  // previous single try/catch lost the layouts when only the config was broken.
   let vars = {}
   let hasContentHandler = false
   try {
@@ -2292,144 +2296,64 @@ export async function loadFoundationInfo(foundationPath) {
     )
   }
 
-  let layoutNames = new Set()
-  try {
-    layoutNames = new Set(Object.keys(await discoverLayoutsInPath(srcDir)))
-  } catch (err) {
-    console.warn(
-      `[content-collector] Could not discover the foundation's layouts in ${srcDir}: ${err.message}\n` +
-        `[content-collector]   Continuing WITHOUT them — a site \`layout/<Name>/\` directory will be collected as an area of the default layout rather than as that named layout.`
-    )
-  }
-
-  return { vars, layoutNames, hasContentHandler }
+  return { vars, hasContentHandler }
 }
 
 /**
- * Collect areas from a single directory (general named areas, not hardcoded).
+ * Collect the site's layout areas: `{ <layout>: { <area>: { route, title, sections } } }`.
+ *
+ * ⭐ Read through `readLayoutFolder` (`./layout-folder.js`) — the ONE reader the
+ * sync producer uses too. Depth decides what a folder under `layout/` is, never the
+ * foundation. ⛔ Until 2026-09-13 a folder was a named layout here only when the
+ * foundation declared a layout by that name, and an area of the default layout
+ * otherwise, while sync called every folder a named layout: `layout/header/` was a
+ * default header on a static build and a layout named `header` once synced
+ * (measured).
  *
- * Supports two forms per area:
- *   - Folder: dir/header/ (directory with .md files, like a page)
- *   - File shorthand: dir/header.md (single markdown file)
- * Folder takes priority when both exist.
+ * An area is a container of sections, not a page: no `page.yml` is read, so an area
+ * carries no `fetch`, `seo` or section ordering of its own. ⭐ Its sections' assets
+ * and icons join the site's manifests — ⛔ they were dropped until 2026-09-13, so a
+ * logo referenced from a header section never entered the asset manifest (measured).
  *
- * @param {string} dir - Directory to scan for area files
+ * @param {string} layoutDir - Path to layout directory
  * @param {string} siteRoot - Path to site root
- * @param {string} routePrefix - Route prefix for area pages (e.g., '/layout' or '/layout/marketing')
- * @returns {Promise<Object>} Map of areaName -> page data
+ * @returns {Promise<{ layouts: Object|null, assetCollection: Object, iconCollection: Object }>}
  */
-async function collectAreasFromDir(dir, siteRoot, routePrefix = '/layout') {
-  const result = {}
-
-  if (!existsSync(dir)) return result
+async function collectLayouts(layoutDir, siteRoot) {
+  let assetCollection = { assets: {}, hasExplicitPoster: new Set(), hasExplicitPreview: new Set() }
+  let iconCollection = { icons: new Set(), bySource: new Map() }
 
-  const entries = await readdir(dir, { withFileTypes: true })
+  const areas = await readLayoutFolder(layoutDir, { siteRoot })
+  if (areas.length === 0) return { layouts: null, assetCollection, iconCollection }
 
-  // Track which area names we've already processed (folder form takes priority)
-  const processed = new Set()
-
-  // First pass: directories (folder form, higher priority)
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue
-    if (entry.name.startsWith('_') || entry.name.startsWith('.')) continue
-
-    const areaName = entry.name
-    const entryPath = join(dir, areaName)
-    const pageResult = await processPage(entryPath, areaName, siteRoot, {
-      isIndex: false,
-      parentRoute: routePrefix
-    })
-    if (pageResult) {
-      result[areaName] = pageResult.page
-      processed.add(areaName)
+  const layouts = {}
+  for (const area of areas) {
+    const sections = []
+    for (const file of area.files) {
+      const { name } = parse(file)
+      const { prefix, name: stableName } = parseNumericPrefix(name)
+      // A one-section area keeps the handles it has always had: positional id `1`,
+      // and the area's name as its stable id — what sync sends as its `$id`. A
+      // section of a multi-section area is named the way a page's section is.
+      const id = area.form === 'file' ? '1' : (prefix || name)
+      const stableId = area.form === 'file' ? area.area : (stableName || name)
+      const result = await processMarkdownFile(join(area.dir, file), id, siteRoot, stableId)
+      sections.push(result.section)
+      assetCollection = mergeAssetCollections(assetCollection, result.assetCollection)
+      iconCollection = mergeIconCollections(iconCollection, result.iconCollection)
     }
-  }
-
-  // Second pass: markdown file shorthand (only if not already processed as folder)
-  for (const entry of entries) {
-    if (!entry.isFile()) continue
-    if (!entry.name.endsWith('.md')) continue
-    if (entry.name.startsWith('_') || entry.name.startsWith('.')) continue
-
-    const areaName = entry.name.replace('.md', '')
-    if (processed.has(areaName)) continue
-
-    const filePath = join(dir, entry.name)
-    const { section } = await processMarkdownFile(filePath, '1', siteRoot, areaName)
-    result[areaName] = {
-      route: `${routePrefix}/${areaName}`,
-      title: areaName.charAt(0).toUpperCase() + areaName.slice(1),
+    const route = area.layout === DEFAULT_LAYOUT ? `/layout/${area.area}` : `/layout/${area.layout}/${area.area}`
+    layouts[area.layout] ??= {}
+    layouts[area.layout][area.area] = {
+      route,
+      title: area.area.charAt(0).toUpperCase() + area.area.slice(1),
       description: '',
       layout: {},
-      sections: [section]
+      sections,
     }
   }
 
-  return result
-}
-
-/**
- * Collect layout areas from the layout/ directory, including named layout subdirectories.
- *
- * Root-level .md files and area directories form the "default" layout's areas.
- * Subdirectories that match a foundation-declared layout name are named layouts,
- * each with its own set of areas. All other subdirectories are folder-form areas
- * for the default layout (multi-section areas).
- *
- * @param {string} layoutDir - Path to layout directory
- * @param {string} siteRoot - Path to site root
- * @param {Set<string>} layoutNames - Layout names declared in the foundation schema
- * @returns {Promise<Object>} { layouts }
- */
-async function collectLayouts(layoutDir, siteRoot, layoutNames = new Set()) {
-  if (!existsSync(layoutDir)) {
-    return { layouts: null }
-  }
-
-  const entries = await readdir(layoutDir, { withFileTypes: true })
-
-  // Identify named layout directories: only subdirectories whose name matches
-  // a layout component declared in the foundation. All others are folder-form
-  // areas for the default layout (e.g., layout/header/ with multiple sections).
-  const namedLayoutDirs = []
-
-  for (const entry of entries) {
-    if (entry.name.startsWith('_') || entry.name.startsWith('.')) continue
-
-    if (entry.isDirectory() && layoutNames.has(entry.name)) {
-      namedLayoutDirs.push(entry)
-    }
-  }
-
-  // Collect default layout areas
-  const defaultAreas = await collectAreasFromDir(layoutDir, siteRoot, '/layout')
-  // Remove any named layout directories that got collected as areas
-  for (const dir of namedLayoutDirs) {
-    delete defaultAreas[dir.name]
-  }
-
-  // Collect named layout areas
-  const namedLayouts = {}
-  for (const entry of namedLayoutDirs) {
-    const subdir = join(layoutDir, entry.name)
-    namedLayouts[entry.name] = await collectAreasFromDir(subdir, siteRoot, `/layout/${entry.name}`)
-  }
-
-  const hasDefaultAreas = Object.keys(defaultAreas).length > 0
-  const hasNamedLayouts = Object.keys(namedLayouts).length > 0
-
-  if (!hasDefaultAreas && !hasNamedLayouts) {
-    return { layouts: null }
-  }
-
-  // Always use the layouts object format (general areas)
-  const layouts = {}
-  if (hasDefaultAreas) {
-    layouts.default = defaultAreas
-  }
-  Object.assign(layouts, namedLayouts)
-
-  return { layouts }
+  return { layouts, assetCollection, iconCollection }
 }
 
 /**
@@ -2519,9 +2443,8 @@ export async function collectSiteContent(sitePath, options = {}) {
     : join(sitePath, 'layout')
   const rawThemeConfig = await readYamlFile(join(sitePath, 'theme.yml'))
 
-  // Load foundation info (vars + layout names) and process theme
-  const { vars: foundationVars, layoutNames: layoutNames, hasContentHandler } =
-    await loadFoundationInfo(foundationPath)
+  // Load foundation info (vars) and process theme
+  const { vars: foundationVars, hasContentHandler } = await loadFoundationInfo(foundationPath)
 
   // ⭐ `placeholders:` IS DECLARED FOR A READER THAT MAY NOT EXIST, and that is
   // the one way this feature fails. Resolving `{…}` in page content is a
@@ -2581,8 +2504,9 @@ export async function collectSiteContent(sitePath, options = {}) {
   // overrides the profile default per readFolderConfig.
   const { mode: rootContentMode } = await readFolderConfig(pagesPath, profile.defaultMode)
 
-  // Collect layout areas from layout/ directory (including named layout subdirectories)
-  const { layouts } = await collectLayouts(layoutPath, sitePath, layoutNames)
+  // Collect layout areas from the layout/ directory, read from the site alone
+  const { layouts, assetCollection: layoutAssets, iconCollection: layoutIcons } =
+    await collectLayouts(layoutPath, sitePath)
 
   // Site-level layout (from `site.yml::layout`) — the ROOT of the cascade, and
   // the whole object, not just its name.
@@ -2592,6 +2516,10 @@ export async function collectSiteContent(sitePath, options = {}) {
   let { pages, assetCollection, iconCollection, notFound, versionedScopes } =
     await collectPagesRecursive(pagesPath, '/', sitePath, siteOrderConfig, null, null, rootContentMode, mounts, siteLayout)
 
+  // The layout sections' assets and icons, beside the pages'.
+  assetCollection = mergeAssetCollections(assetCollection, layoutAssets)
+  iconCollection = mergeIconCollections(iconCollection, layoutIcons)
+
   // Merge top-level config assets (e.g. document.yml's book.covers.front,
   // banner images, logos) into the manifest. The compile pipeline reads
   // website.assets[<original src>] to resolve these to filesystem paths
@@ -2650,6 +2578,9 @@ export async function collectSiteContent(sitePath, options = {}) {
     page.parent = parentPage ? parentPage.route : null
   }
 
+  const siteFetch = parseFetchConfig(...fetchIn(siteConfig, 'site.yml', 'site'))
+  warnUnreadCurrent(pages, layouts, siteFetch)
+
   // 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)
@@ -2786,7 +2717,7 @@ export async function collectSiteContent(sitePath, options = {}) {
       // shorthand reached a backend on the sync lane and was silently ignored on
       // a static build — the works-on-one-lane shape. Every level reads it
       // through `declaredFetch` now.
-      fetch: parseFetchConfig(declaredFetch(siteConfig, 'site.yml')),
+      fetch: siteFetch,
       fetcher: warnRetiredFetcherKeys(siteConfig.fetcher),
       // NOTE: `intelligence.yml` was read here and emitted as `config.intelligence`.
       // Removed 2026-08-12 — the assistant surface is `site.yml::assistant`, which