@uniweb/build 0.37.1 → 0.39.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.37.1",
+  "version": "0.39.0",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -23,9 +23,7 @@
     "./uwx": "./src/uwx/index.js",
     "./import-map-plugin": "./src/import-map-plugin.js"
   },
-  "bin": {
-    "uniweb-dev-backend": "./src/dev-backend.js"
-  },
+  "bin": {},
   "files": [
     "src"
   ],
@@ -60,14 +58,14 @@
     "sharp": "^0.35.3",
     "yaml": "^2.5.0",
     "@uniweb/content-writer": "^0.3.4",
-    "@uniweb/content-reader": "^1.2.4",
     "@uniweb/semantic-parser": "^1.4.0",
-    "@uniweb/projections": "^0.5.7",
-    "@uniweb/schemas": "^0.2.13",
-    "@uniweb/theming": "^0.1.15"
+    "@uniweb/theming": "^0.1.15",
+    "@uniweb/content-reader": "^1.2.4",
+    "@uniweb/projections": "^0.5.9",
+    "@uniweb/schemas": "^0.2.13"
   },
   "optionalDependencies": {
-    "@uniweb/runtime": "^0.14.2"
+    "@uniweb/runtime": "^0.16.0"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0",
@@ -76,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.19.0"
+    "@uniweb/core": "^0.21.0"
   },
   "peerDependenciesMeta": {
     "vite": {

package/src/prerender.js

@@ -11,8 +11,8 @@ import { readFile, writeFile, mkdir } from 'node:fs/promises'
 import { existsSync, readdirSync, statSync } from 'node:fs'
 import { join, dirname, resolve } from 'node:path'
 import { pathToFileURL } from 'node:url'
-import { resolveDefaultLocale, isDataUrl } from '@uniweb/core'
-import { executeFetch, mergeDataIntoContent, toFetchList } from './site/data-fetcher.js'
+import { resolveDefaultLocale, resolveFetchConfigs, joinPathCapture, splitPathCapture } from '@uniweb/core'
+import { executeFetch, mergeDataIntoContent, toFetchList, stripBuildOnlyFetchKeys } from './site/data-fetcher.js'
 import { shouldSplitContent } from './site/split-content.js'
 import { FONT_LINKS_MARKER } from './site/head-markers.js'
 import { getAdapter } from './hosts/index.js'
@@ -78,37 +78,50 @@ export function resolveExtensionPath(url, distDir, projectRoot, base) {
  * @param {string} [localeInfo.distDir] - Path to dist directory (where locale-specific data lives)
  * @returns {Object} { pageFetchedData, fetchedData } - Fetched data for dynamic route expansion and DataStore pre-population
  */
-async function executeAllFetches(siteContent, siteDir, onProgress, localeInfo) {
+export async function executeAllFetches(siteContent, siteDir, onProgress, localeInfo) {
   const fetchOptions = { siteRoot: siteDir, publicDir: 'public' }
   const fetchedData = [] // Collected for DataStore pre-population
 
   // For non-default locales, translated collection data lives in dist/{locale}/data/
-  // instead of public/data/. Create a localized fetch helper.
+  // instead of public/data/.
   const isNonDefaultLocale = localeInfo &&
     localeInfo.locale !== localeInfo.defaultLocale &&
     localeInfo.distDir
 
-  function localizeFetch(config) {
-    if (!isNonDefaultLocale || !isDataUrl(config.path)) return config
-    return { ...config, path: `/${localeInfo.locale}${config.path}` }
+  // ⭐ RESOLVED THE WAY THE RUNTIME RESOLVES IT — the one rule in
+  // `@uniweb/core/fetch-config`, which is what makes the entries below hydrate:
+  // the SPA looks each one up under `deriveCacheKey(config)` of ITS resolved
+  // config, so the config baked here must be the same object — the same
+  // localized path (this used to prefix `/{locale}` by hand), the same `depth`
+  // (a `deferred:` query's compiled file is a list of briefs), the same detail
+  // pattern. A hand-built copy of that rule is how a prerendered site came to
+  // refetch on boot without anyone noticing.
+  const resolveOptions = {
+    locale: localeInfo?.locale ?? null,
+    defaultLocale: localeInfo?.defaultLocale ?? null,
+    queries: siteContent.config?.queries ?? null,
+    records: null, // the build lane: no live records; the compiled file answers
   }
+  const resolveForBuild = (oneFetch) =>
+    resolveFetchConfigs([oneFetch], resolveOptions).get(oneFetch.as) ?? oneFetch
 
   // Fetch options pointing to dist/ for localized data
   const localizedFetchOptions = isNonDefaultLocale
     ? { siteRoot: localeInfo.distDir, publicDir: '.' }
     : fetchOptions
+  const optionsFor = (cfg, oneFetch) => (cfg.path !== oneFetch.path ? localizedFetchOptions : fetchOptions)
+  const entry = (cfg, data, scope) => ({ config: cfg, data, meta: { depth: cfg.depth }, _scope: scope })
 
   // 1. Site-level fetch. ⛔ `toFetchList` rather than a property read: a `fetch:`
   // or `data:` LIST parses to an array, and `siteFetch.prerender` on one is
   // `undefined` — which passes the `!== false` test and then fetches nothing.
   for (const oneFetch of toFetchList(siteContent.config?.fetch)) {
     if (oneFetch.prerender === false) continue
-    const cfg = localizeFetch(oneFetch)
-    const opts = cfg !== oneFetch ? localizedFetchOptions : fetchOptions
+    const cfg = resolveForBuild(oneFetch)
     onProgress(`  Fetching site data: ${cfg.path || cfg.url}`)
-    const result = await executeFetch(cfg, opts)
+    const result = await executeFetch(cfg, optionsFor(cfg, oneFetch))
     if (result.data && !result.error) {
-      fetchedData.push({ config: cfg, data: result.data, _scope: '__site__' })
+      fetchedData.push(entry(cfg, result.data, '__site__'))
     }
   }
 
@@ -119,12 +132,11 @@ async function executeAllFetches(siteContent, siteDir, onProgress, localeInfo) {
     // Page-level fetch — every declaration on the page.
     for (const oneFetch of toFetchList(page.fetch)) {
       if (oneFetch.prerender === false) continue
-      const cfg = localizeFetch(oneFetch)
-      const opts = cfg !== oneFetch ? localizedFetchOptions : fetchOptions
+      const cfg = resolveForBuild(oneFetch)
       onProgress(`  Fetching page data for ${page.route}: ${cfg.path || cfg.url}`)
-      const result = await executeFetch(cfg, opts)
+      const result = await executeFetch(cfg, optionsFor(cfg, oneFetch))
       if (result.data && !result.error) {
-        fetchedData.push({ config: cfg, data: result.data, _scope: page.route })
+        fetchedData.push(entry(cfg, result.data, page.route))
         // ⚖️ Dynamic-route expansion consumes ONE query — a `[slug]` template
         // expands over a single record set. With several declared, the first
         // that prerenders is the route query, matching `parentSchema` in the
@@ -190,7 +202,8 @@ export function localizeRedirectTarget(target, { website, locale, isDefault, rou
   return (website.basePath || '') + withSlash
 }
 
-export function expandDynamicPages(pages, pageFetchedData, onProgress) {
+export function expandDynamicPages(pages, pageFetchedData, onProgress = () => {}, stats = { unrouted: {} }) {
+  if (!stats.unrouted) stats.unrouted = {}
   const expandedPages = []
 
   // Static pages win over the dynamic `[slug]` catch-all, matching the SPA's
@@ -221,8 +234,9 @@ export function expandDynamicPages(pages, pageFetchedData, onProgress) {
     }
 
     // Find the parent's data
-    // The parent route is the route without the :param suffix
-    const parentRoute = page.route.replace(/\/:[\w]+$/, '') || '/'
+    // The parent route is the route without the :param (or :path*) suffix
+    const catchAll = /\/:path\*$/.test(page.route)
+    const parentRoute = page.route.replace(/\/:[\w]+\*?$/, '') || '/'
     const parentData = pageFetchedData.get(parentRoute)
 
     if (!parentData || !Array.isArray(parentData.data)) {
@@ -238,17 +252,30 @@ export function expandDynamicPages(pages, pageFetchedData, onProgress) {
 
     onProgress(`  Expanding ${page.route} → ${items.length} pages from ${schema}`)
 
+    // ⛔ COUNTED, not only logged per record. A record with no value for the
+    // route's param gets no page — correct — but "Skipping item without slug"
+    // once per record is a line nobody reads: an author who files twenty
+    // 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
+
     // Create a concrete page for each item
     for (const item of items) {
       // Get the param value from the item (e.g., item.slug for :slug)
       const paramValue = item[paramName]
       if (!paramValue) {
-        onProgress(`    Skipping item without ${paramName}`)
+        unrouted += 1
         continue
       }
 
-      // Create concrete route: /blog/:slug → /blog/my-post
-      const concreteRoute = page.route.replace(`:${paramName}`, paramValue)
+      // 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(/:path\*$/, 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.
@@ -277,6 +304,9 @@ export function expandDynamicPages(pages, pageFetchedData, onProgress) {
         paramName,
         paramValue,
         schema,           // Plural: 'articles'
+        // A catch-all page carries its three variables, so a query binding
+        // `:dir` or `:path` resolves the same way it does in the browser.
+        ...(catchAll ? { params: splitPathCapture(capture) } : {}),
       }
 
       // Use item data for page metadata if available
@@ -285,6 +315,14 @@ export function expandDynamicPages(pages, pageFetchedData, onProgress) {
 
       expandedPages.push(concretePage)
     }
+
+    if (unrouted > 0) {
+      stats.unrouted[page.route] = unrouted
+      onProgress(
+        `  ⚠️ ${unrouted} of ${items.length} ${schema} records have no "${paramName}" — no page was ` +
+          `generated for them under ${page.route}`
+      )
+    }
   }
 
   return expandedPages
@@ -626,7 +664,7 @@ export async function prerenderSite(siteDir, options = {}) {
     onProgress(`\nRendering ${isDefault ? 'default' : locale} locale...`)
 
     // Load locale-specific content
-    const siteContent = JSON.parse(await readFile(localeContentPath, 'utf8'))
+    let siteContent = JSON.parse(await readFile(localeContentPath, 'utf8'))
 
     // Set the active locale in the content
     siteContent.config = siteContent.config || {}
@@ -644,6 +682,11 @@ export async function prerenderSite(siteDir, options = {}) {
     // Store fetchedData on siteContent for runtime DataStore pre-population
     siteContent.fetchedData = fetchedData
 
+    // The build has consumed every build-only fetch key by now (`merge`, read
+    // by the section fetches above); what ships in `__SITE_CONTENT__` is the
+    // runtime's payload and carries none of them.
+    siteContent = stripBuildOnlyFetchKeys(siteContent)
+
     // Expand dynamic pages (e.g., /blog/:slug → /blog/post-1, /blog/post-2)
     if (siteContent.pages?.some(p => p.isDynamic)) {
       onProgress('Expanding dynamic routes...')

package/src/runtime-schema.js

@@ -28,6 +28,7 @@
  */
 
 import { isRichSchema } from '@uniweb/core'
+import { flatRecordFields } from '@uniweb/schemas/conform'
 
 /**
  * Parse data string into structured object
@@ -211,8 +212,22 @@ function leanDataSchema(value, dataSchemaMap) {
     : (value && typeof value.schema === 'string' ? value.schema : null)
   if (ref) {
     const resolved = dataSchemaMap[ref]
-    if (!resolved?.fields) return null
-    const lean = extractSchemaFields(resolved.fields)
+    // ⛔ `flatRecordFields`, NOT `resolved.fields`. `dataSchemaMap` holds each
+    // schema AS AUTHORED — resolution and lowering are different steps, and only
+    // the second normalizes the two authoring forms. `fields:` at the top is the
+    // SUGAR for a one-section model; a sections-form schema has no such key, so
+    // reading it directly returned null for every `@std/*` binding and the
+    // section's `data:` declaration supplied no field defaults at all. Silent:
+    // the data still arrived, just without its defaults.
+    //
+    // This helper is the reader that takes both forms (`if (schema.fields)
+    // return schema.fields`, else walk the single sections), and
+    // `site/queries-config.js` already used it for exactly this reason.
+    // Measured 2026-09-03: `@std/article` → undefined here, 15 fields through
+    // the helper; `@/member` (sugar) → 4 either way.
+    const fields = flatRecordFields(resolved)
+    if (!fields) return null
+    const lean = extractSchemaFields(fields)
     return Object.keys(lean).length > 0 ? lean : null
   }
 

package/src/schema.js

@@ -67,6 +67,74 @@ export async function loadComponentMeta(componentDir) {
   }
 }
 
+/**
+ * Normalize `package.json`'s `uniweb.supports` — the host services this
+ * foundation is BUILT AGAINST.
+ *
+ * A foundation states what it is prepared to honour; a host states what it
+ * offers (`config.services.<name>`, read by `@uniweb/core/services`). The two
+ * declarations point in opposite directions across the same seam, which is why
+ * this one is spelled `supports` and never `services`.
+ *
+ * ## ⭐ THREE STATES, AND COLLAPSING THE FIRST TWO IS THE WHOLE POINT
+ *
+ *   absent        UNKNOWN — an older CLI, or a developer who never met this key
+ *   `[]`          an explicit NONE
+ *   `['search']`  these, and only these
+ *
+ * Same lift as `info.runtime` (`uwx/registry-package.js::buildInfo`), whose
+ * comment states the rule this follows: *"a consumer must read the omission as
+ * UNKNOWN rather than unconstrained, since a floor nobody stated cannot be shown
+ * to be satisfied."* An unstated support set is not a refusal, and a reader that
+ * treats it as one blocks every foundation built before this existed.
+ *
+ * ⛔ **So this returns `{}` for absent and `{ supports: [] }` for empty**, and
+ * they must not be flattened downstream. A default of any kind here — assuming
+ * search is present because most foundations have one — would claim a service on
+ * behalf of the developer who never heard of the feature, which is the same
+ * person as the developer who forgot to declare it. That trades a loud failure
+ * (a capability reported unknown) for a silent one (an operator paying for
+ * something their site will not render).
+ *
+ * ⚖️ Whether an unknown service is still worth offering is a POLICY question
+ * about that service, and policy on this seam is not the framework's: this
+ * package is public, and it encodes no tiers, no plan names and no entitlement
+ * (`core/src/services.js`). We report faithfully, including reporting that we do
+ * not know.
+ *
+ * Sorted and de-duplicated so a re-export of one foundation version is
+ * byte-identical — the same reason `buildRefs` sorts.
+ *
+ * @param {*} value - the raw `uniweb.supports` value, if any
+ * @param {string} packagePath - for the warning message
+ * @returns {{supports?: string[]}} `{}` when undeclared
+ */
+function normalizeSupports(value, packagePath) {
+  if (value === undefined || value === null) return {}
+
+  if (!Array.isArray(value)) {
+    console.warn(
+      `Warning: ${packagePath} declares \`uniweb.supports\` as ${typeof value}; expected an array of service names. Ignoring it.\n` +
+        `  An ignored declaration reads downstream as UNKNOWN, not as "supports nothing".`,
+    )
+    return {}
+  }
+
+  const names = []
+  const dropped = []
+  for (const entry of value) {
+    if (typeof entry === 'string' && entry.trim()) names.push(entry.trim())
+    else dropped.push(entry)
+  }
+  if (dropped.length > 0) {
+    console.warn(
+      `Warning: ${packagePath} has ${dropped.length} non-name entr${dropped.length === 1 ? 'y' : 'ies'} in \`uniweb.supports\`. Ignoring ${dropped.length === 1 ? 'it' : 'them'}.`,
+    )
+  }
+
+  return { supports: [...new Set(names)].sort() }
+}
+
 /**
  * Load package.json from a foundation's root.
  * Extracts identity fields: name, version, description.
@@ -104,6 +172,11 @@ export async function loadPackageJson(srcDir) {
       name: pkg.uniweb?.id || pkg.name,
       version: pkg.version,
       description: pkg.description,
+      // `uniweb.supports` joins them because it is the same KIND of fact: static,
+      // publish-time, read by whoever resolves a whole site, never executed here.
+      // Spread rather than assigned so an absent declaration stays ABSENT — see
+      // normalizeSupports for why that is load-bearing.
+      ...normalizeSupports(pkg.uniweb?.supports, packagePath),
     }
   } catch (error) {
     console.warn(`Warning: Failed to load package.json:`, error.message)

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

@@ -24,6 +24,7 @@ import { join, resolve, dirname } from 'node:path'
 import { resolveDefaultLocale, DATA_DIR } from '@uniweb/core'
 import { collectSiteContent } from './content-collector.js'
 import { processQueries, writeQueryFiles } from './query-processor.js'
+import { stripBuildOnlyFetchKeys } from './data-fetcher.js'
 import { processAssets, rewriteSiteContentPaths } from './asset-processor.js'
 import { processAdvancedAssets } from './advanced-processors.js'
 import {
@@ -235,6 +236,10 @@ export async function buildSiteData({
     finalContent = { ...finalContent, config: configWithoutIcons }
   }
 
+  // Build-only fetch keys (`merge`) never reach a shipped payload; this lane runs
+  // no prerender, so nothing here reads them either.
+  finalContent = stripBuildOnlyFetchKeys(finalContent)
+
   // 4. Write `dist/site-content.json` with FULL sections inlined.
   //    Important: do NOT strip sections per the split-content rule here.
   //    Stripping would silently break split-mode sites on any consumer that

package/src/site/content-collector.js

@@ -57,20 +57,69 @@ try {
 }
 
 /**
- * Check if a folder name represents a dynamic route (e.g., [slug], [id])
+ * The multi-segment route folder — ONE fixed spelling, ruled 2026-09-04 [Diego].
+ * `[...slug]`, `[...rest]` and a bare `[...]` are NOT the marker: an author does
+ * not name how the URL is parsed. The capture is split by the runtime into the
+ * standard `:path` / `:dir` / `:slug` variables (`@uniweb/core/route-match`).
+ */
+const CATCH_ALL_FOLDER = '[...path]'
+
+/**
+ * The site-level `fetcher:` vocabulary the default fetcher used to read —
+ * `baseUrl`, `headers`, `envelope`, `supports`, `request` — was RETIRED on
+ * 2026-09-04 [Diego]: a third-party endpoint is a foundation TRANSPORT, never a
+ * knob on the runtime every site loads. What stays under `fetcher:` is the
+ * site's SELECTION of transports (`transports:`) and the binding config a named
+ * transport reads (`fetcher.<name>:`). A retired key is dropped from the payload
+ * and said out loud, once, because silently ignoring it is the failure class
+ * this seam exists to remove: the author's backend simply stops being reached.
+ */
+const RETIRED_FETCHER_KEYS = ['baseUrl', 'headers', 'envelope', 'supports', 'request']
+let warnedRetiredFetcher = false
+function warnRetiredFetcherKeys(fetcher) {
+  if (!fetcher || typeof fetcher !== 'object' || Array.isArray(fetcher)) return fetcher
+  const retired = RETIRED_FETCHER_KEYS.filter((k) => k in fetcher)
+  if (retired.length === 0) return fetcher
+  if (!warnedRetiredFetcher) {
+    warnedRetiredFetcher = true
+    console.warn(
+      `[uniweb] site.yml fetcher: ${retired.map((k) => `\`${k}\``).join(', ')} ` +
+        `${retired.length === 1 ? 'is' : 'are'} retired and ignored. The default fetcher reads a ` +
+        `site's own files and a host's records lane; a backend of your own is reached through a ` +
+        `foundation transport (docs: development/connecting-a-backend.md). Kept: ` +
+        `\`fetcher.transports\` and a transport's own binding config.`
+    )
+  }
+  const kept = {}
+  for (const [k, v] of Object.entries(fetcher)) if (!RETIRED_FETCHER_KEYS.includes(k)) kept[k] = v
+  return kept
+}
+
+/**
+ * Check if a folder name represents a dynamic route (e.g., [slug], [id], [...path])
  * @param {string} folderName - The folder name to check
  * @returns {boolean}
  */
 function isDynamicRoute(folderName) {
-  return /^\[(\w+)\]$/.test(folderName)
+  return folderName === CATCH_ALL_FOLDER || /^\[(\w+)\]$/.test(folderName)
+}
+
+/** Is this the multi-segment route folder? */
+function isCatchAllRoute(folderName) {
+  return folderName === CATCH_ALL_FOLDER
 }
 
 /**
- * Extract the parameter name from a dynamic route folder (e.g., [slug] → slug)
+ * Extract the parameter name from a dynamic route folder (e.g., [slug] → slug).
+ *
+ * `[...path]` yields `slug`: the record is delivered by its handle — the LAST
+ * segment of the capture — exactly as under `[slug]`, so a query written for
+ * one route kind behaves the same under the other.
  * @param {string} folderName - The folder name (e.g., "[slug]")
  * @returns {string|null} The parameter name or null if not a dynamic route
  */
 function extractRouteParam(folderName) {
+  if (isCatchAllRoute(folderName)) return 'slug'
   const match = folderName.match(/^\[(\w+)\]$/)
   return match ? match[1] : null
 }
@@ -1389,8 +1438,10 @@ async function processPage(pagePath, pageName, siteRoot, { isIndex = false, pare
   // First, calculate the folder-based route (what the route would be without index handling)
   let folderRoute
   if (isDynamic) {
-    // Dynamic routes: /blog/[slug] → /blog/:slug (for route matching)
-    folderRoute = parentRoute === '/' ? `/:${paramName}` : `${parentRoute}/:${paramName}`
+    // Dynamic routes: /blog/[slug] → /blog/:slug (for route matching);
+    // /blog/[...path] → /blog/:path* — the one multi-segment token the matcher knows.
+    const token = isCatchAllRoute(pageName) ? ':path*' : `:${paramName}`
+    folderRoute = parentRoute === '/' ? `/${token}` : `${parentRoute}/${token}`
   } else {
     // Normal pages get parent + their name
     folderRoute = parentRoute === '/' ? `/${pageName}` : `${parentRoute}/${pageName}`
@@ -2056,8 +2107,8 @@ export async function loadFoundationInfo(foundationPath) {
   // rich per-section declaration a visual editor needs to render parameter forms
   // and component pickers — and it is not a source of truth for a site build.
   // The architecture is explicit that the declaration is emitted in two shapes
-  // for two audiences (`kb/framework/architecture/site-foundation-runtime-model.md`
-  // § The two-audience schema): the lean runtime half ships INSIDE `dist/entry.js`
+  // for two audiences (the site / foundation / runtime model, § The two-audience
+  // schema): the lean runtime half ships INSIDE `dist/entry.js`
   // as `capabilities`, and the rich half is for authoring tools only.
   //
   // Reading the editor's copy here was wrong twice over. It made a site build
@@ -2563,6 +2614,7 @@ export async function collectSiteContent(sitePath, options = {}) {
         ? { languages: publishable }
         : {}),
       fetch: parseFetchConfig(siteConfig.fetch),
+      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
       // needs no line at all on this lane (`config` spreads all of site.yml) and one