@uniweb/build 0.46.0 → 0.47.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.46.0",
+  "version": "0.47.0",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -58,14 +58,14 @@
     "sharp": "^0.35.3",
     "yaml": "^2.5.0",
     "@uniweb/semantic-parser": "^1.4.0",
-    "@uniweb/theming": "^0.1.15",
-    "@uniweb/schemas": "^0.2.13",
     "@uniweb/content-reader": "^1.2.4",
-    "@uniweb/projections": "^0.6.1",
-    "@uniweb/content-writer": "^0.3.4"
+    "@uniweb/theming": "^0.1.15",
+    "@uniweb/projections": "^0.6.2",
+    "@uniweb/content-writer": "^0.3.4",
+    "@uniweb/schemas": "^0.2.13"
   },
   "optionalDependencies": {
-    "@uniweb/runtime": "^0.20.1"
+    "@uniweb/runtime": "^0.20.3"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0",
@@ -74,7 +74,7 @@
     "@tailwindcss/vite": "^4.0.0",
     "@vitejs/plugin-react": "^4.0.0 || ^5.0.0",
     "vite-plugin-svgr": "^4.0.0",
-    "@uniweb/core": "^0.25.1"
+    "@uniweb/core": "^0.26.1"
   },
   "peerDependenciesMeta": {
     "vite": {

package/src/prerender.js

@@ -17,7 +17,7 @@ import {
   joinPathCapture,
   routeQuery,
   sectionFetches,
-  routeParamValue,
+  routeParamValues,
   routeParamName,
   routeBinding,
   parentRouteOf,
@@ -324,62 +324,81 @@ export function expandDynamicPages(pages, fetched, onProgress = () => {}, stats
     // records and names three gets three pages and no idea why. The total is
     // said once at the end, and handed back on `stats` for a caller to assert.
     let unrouted = 0
+    // route → the value that claimed it, so a second claim is reported, not silent
+    const claimed = new Map()
 
     // Create a concrete page for each item
     for (const item of items) {
-      // The value the record carries for the route's param — read through the one
-      // map (`routeParamValue`): `[slug]` its handle, `[uuid]` its identity, any
-      // other name its field. ⛔ This read `item[paramName]` until 2026-09-11.
-      const raw = routeParamValue(item, paramName)
-      if (raw === undefined || raw === null || raw === '') {
+      // EVERY value the record answers to — one for a scalar, one per member for a
+      // `multi` field (`routeParamValues`, the map every lane matches through:
+      // `[slug]` its handle, `[uuid]` its identity, any other name its field). A
+      // record holding `['a','b']` gets /tags/a AND /tags/b; a `multi` holding one
+      // value — the case the rule is for — gets exactly one page. Ruled 2026-09-12
+      // [Diego]. ⛔ This read `item[paramName]` until 2026-09-11 and the whole array
+      // until 2026-09-12, which baked `/tags/a%2Cb`, a URL no lane matches.
+      const values = routeParamValues(item, paramName)
+      if (values.length === 0) {
         unrouted += 1
         continue
       }
-      const paramValue = String(raw)
-
-      // Create concrete route: /blog/:slug → /blog/my-post. Under `[...path]` the
-      // record's URL is its placement (the folder `records.yml` put it in, carried
-      // as `path`) plus its handle — the split rule in reverse. ⛔ A FILE PATH, so
-      // decoded: the server decodes the request before looking the file up.
-      const capture = catchAll ? joinPathCapture({ dir: item.path, slug: paramValue }) : null
-      const concreteRoute = catchAll
-        ? page.route.replace(new RegExp(`:${catchAll}\\*$`), capture)
-        : page.route.replace(`:${paramName}`, paramValue)
-
-      // Static sibling wins: skip a record whose concrete route collides with
-      // an existing static page rather than overwriting its HTML at write time.
-      if (staticRoutes.has(concreteRoute)) {
-        onProgress(`    Skipping ${concreteRoute} — a static page already claims this route (${paramName}:'${paramValue}')`)
-        continue
-      }
+      for (const paramValue of values) {
+
+        // Create concrete route: /blog/:slug → /blog/my-post. Under `[...path]` the
+        // record's URL is its placement (the folder `records.yml` put it in, carried
+        // as `path`) plus its handle — the split rule in reverse. ⛔ A FILE PATH, so
+        // decoded: the server decodes the request before looking the file up.
+        const capture = catchAll ? joinPathCapture({ dir: item.path, slug: paramValue }) : null
+        const concreteRoute = catchAll
+          ? page.route.replace(new RegExp(`:${catchAll}\\*$`), capture)
+          : page.route.replace(`:${paramName}`, paramValue)
+
+        // ⛔ TWO RECORDS, ONE ROUTE — normal the moment the route field is not
+        // unique, which a `multi` member shared by two records makes easy. The first
+        // wins; WHICH is first is this lane's record order, and a hosted site orders
+        // by its own store — so it is said out loud here rather than discovered as a
+        // different record on the same URL.
+        const claimant = claimed.get(concreteRoute)
+        if (claimant !== undefined) {
+          onProgress(`    ⚠️ ${concreteRoute} is claimed by more than one ${key} record (${paramName}: '${claimant}', '${paramValue}') — the first keeps it`)
+          continue
+        }
+        claimed.set(concreteRoute, paramValue)
 
-      // Deep clone the page with modifications
-      const concretePage = JSON.parse(JSON.stringify(page))
-      concretePage.route = concreteRoute
-      concretePage.isDynamic = false // No longer dynamic
-      concretePage.paramName = undefined
-
-      // The route's binding, as the SPA makes it (`routeBinding`): the three
-      // variables a query binds, the param and its value, and the template's
-      // route. ⛔ No `schema`: the key the URL narrows is worked out where it is
-      // read (deleted 2026-09-11). The record (`currentItem`) and the full sibling
-      // list (`allItems`) are deliberately NOT baked in: the record is delivered
-      // via content.data and siblings via `fetch: { refine: true, detail: false }`,
-      // and embedding `allItems` duplicated the whole collection onto every
-      // prerendered page in split mode.
-      const binding = routeBinding(page.route, catchAll ? { [catchAll]: capture } : { [paramName]: paramValue }, paramName)
-      concretePage.dynamicContext = {
-        templateRoute: page.route,
-        params: binding.variables,
-        paramName: binding.paramName,
-        paramValue: binding.paramValue,
-      }
+        // Static sibling wins: skip a record whose concrete route collides with
+        // an existing static page rather than overwriting its HTML at write time.
+        if (staticRoutes.has(concreteRoute)) {
+          onProgress(`    Skipping ${concreteRoute} — a static page already claims this route (${paramName}:'${paramValue}')`)
+          continue
+        }
+
+        // Deep clone the page with modifications
+        const concretePage = JSON.parse(JSON.stringify(page))
+        concretePage.route = concreteRoute
+        concretePage.isDynamic = false // No longer dynamic
+        concretePage.paramName = undefined
+
+        // The route's binding, as the SPA makes it (`routeBinding`): the three
+        // variables a query binds, the param and its value, and the template's
+        // route. ⛔ No `schema`: the key the URL narrows is worked out where it is
+        // read (deleted 2026-09-11). The record (`currentItem`) and the full sibling
+        // list (`allItems`) are deliberately NOT baked in: the record is delivered
+        // via content.data and siblings via `fetch: { refine: true, detail: false }`,
+        // and embedding `allItems` duplicated the whole collection onto every
+        // prerendered page in split mode.
+        const binding = routeBinding(page.route, catchAll ? { [catchAll]: capture } : { [paramName]: paramValue }, paramName)
+        concretePage.dynamicContext = {
+          templateRoute: page.route,
+          params: binding.variables,
+          paramName: binding.paramName,
+          paramValue: binding.paramValue,
+        }
 
-      // Use item data for page metadata if available
-      if (item.title) concretePage.title = item.title
-      if (item.description || item.excerpt) concretePage.description = item.description || item.excerpt
+        // Use item data for page metadata if available
+        if (item.title) concretePage.title = item.title
+        if (item.description || item.excerpt) concretePage.description = item.description || item.excerpt
 
-      expandedPages.push(concretePage)
+        expandedPages.push(concretePage)
+      }
     }
 
     if (unrouted > 0) {
@@ -523,10 +542,41 @@ export function scopeFetchedData(fetchedData, scopeRoutes, currentRoute = null)
   // either mode: carried everywhere, a site of N such pages would embed N views —
   // or N whole records — in every page.
   const own = (e) => !e._routeBound || e._scope === currentRoute
-  if (!scopeRoutes) return fetchedData.filter(own).map(stripFetchScope)
-  return fetchedData
-    .filter((e) => own(e) && (e._scope === '__site__' || scopeRoutes.has(e._scope)))
-    .map(stripFetchScope)
+  const kept = scopeRoutes
+    ? fetchedData.filter((e) => own(e) && (e._scope === '__site__' || scopeRoutes.has(e._scope)))
+    : fetchedData.filter(own)
+  return dedupeByAddress(kept).map(stripFetchScope)
+}
+
+/**
+ * One entry per ADDRESS in a page's embedded data — first occurrence wins.
+ *
+ * ⛔ Entries are collected per PAGE (`executeAllFetches` tags each with the route
+ * that asked for it), so a query several pages declare produced one entry per page
+ * and unsplit mode embedded all of them in every page. Measured 2026-09-12 on a
+ * four-page site whose pages share two queries: 8 entries of which 2 were distinct,
+ * and **46% of the HTML was the duplicates**.
+ *
+ * ⭐ Keyed by `deriveCacheKey`, which is what the SPA looks each entry up under
+ * (`hydrateDataStore`) — so two entries with one key are the same answer to the
+ * same question by construction, and dropping the later ones cannot change what any
+ * page reads. A page's own route-bound view has its own address and survives.
+ *
+ * @param {Array<{config: Object}>} entries
+ * @returns {Array<Object>} the same entries, minus repeats of an address
+ */
+function dedupeByAddress(entries) {
+  const seen = new Set()
+  const out = []
+  for (const entry of entries) {
+    const key = entry?.config ? deriveCacheKey(entry.config) : null
+    if (key !== null) {
+      if (seen.has(key)) continue
+      seen.add(key)
+    }
+    out.push(entry)
+  }
+  return out
 }
 
 /**
@@ -1047,7 +1097,7 @@ export async function prerenderSite(siteDir, options = {}) {
       // data — but the internal `_scope` tag must never leak into it, and a
       // route-bound entry belongs to its own page's HTML, not to every page.
       if (Array.isArray(manifest.fetchedData)) {
-        manifest.fetchedData = manifest.fetchedData.filter((e) => !e?._routeBound).map(stripFetchScope)
+        manifest.fetchedData = dedupeByAddress(manifest.fetchedData.filter((e) => !e?._routeBound)).map(stripFetchScope)
       }
       await writeFile(localeContentPath, JSON.stringify(manifest))
       onProgress('Rewrote site-content.json as lightweight manifest')

package/src/site/content-collector.js

@@ -1970,9 +1970,15 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
           assetCollection = mergeAssetCollections(assetCollection, pageAssets)
           iconCollection = mergeIconCollections(iconCollection, pageIcons)
 
-          // Modern pattern: blog/index/ (isIndex) inherits the container's fetch config
-          // when it has no fetch of its own. Without this, EntityStore can't find the
-          // fetch config for sections on the index page (page.parent is null for /blog).
+          // A ROOT-PROMOTED folder inherits the container's fetch config when it has
+          // no fetch of its own. Without this, EntityStore cannot find the fetch config
+          // for that page's sections, because promotion leaves it with no parent.
+          //
+          // ⛔ **Root only, and the example this comment used to give was impossible.**
+          // It read "blog/index/ (isIndex)" — a NESTED index folder — but `indexName` is
+          // assigned only under `parentRoute === '/'` (see above), so `entry === indexName`
+          // is false at every deeper level and a nested `index/` folder is an ordinary page.
+          // Measured 2026-09-12: `pages/docs/index/` collects as `/docs/index`, isIndex=false.
           if (isIndex && !page.fetch && parentFetch) {
             page.fetch = parentFetch
           }
@@ -2805,7 +2811,19 @@ export async function collectSiteContent(sitePath, options = {}) {
     pages: dropUnpublished ? dropUnpublishedPages(pages) : pages,
     // Layout area sets: { default: { header: page, footer: page, ... }, marketing: { ... } }
     layouts,
-    notFound,
+    // ⭐ THE SAME REACHABILITY AXIS, for the 404 slot. `hidden: true` means DRAFT —
+    // "excluded from the published site" (`docs/reference/page-configuration.md`);
+    // `hideIn: ['*']` is the control for "routed but in no nav".
+    // ⛔ The 404 was exempt BY ACCIDENT until 2026-09-12: it is lifted out of
+    // `pages` before the prune runs, and the prune only filters `pages`, so the
+    // flag never reached it — we published a page its author had marked as not
+    // for publishing, while a backend-published site dropped it. Ruled
+    // [Diego, 2026-09-12]: the flag is literal and framework moves to the lane
+    // that honoured it. The site still gets a `404.html` (the SPA fallback
+    // shell), and `uniweb dev` keeps the page previewable like any other draft.
+    // No cascade to resolve: this slot is root-level only, so its own flag is
+    // the only one that can apply.
+    notFound: dropUnpublished && notFound?.hidden ? null : notFound,
     // Versioned scopes: route → { versions, latestId }
     versionedScopes: versionedScopesObj,
     assets: assetCollection.assets,