@uniweb/build 0.37.1 → 0.38.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.37.1",
+  "version": "0.38.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"
   ],
@@ -59,15 +57,15 @@
     "js-yaml": "^4.1.0",
     "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/projections": "^0.5.8",
     "@uniweb/schemas": "^0.2.13",
+    "@uniweb/content-writer": "^0.3.4",
+    "@uniweb/semantic-parser": "^1.4.0",
     "@uniweb/theming": "^0.1.15"
   },
   "optionalDependencies": {
-    "@uniweb/runtime": "^0.14.2"
+    "@uniweb/runtime": "^0.15.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.20.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

package/src/site/data-fetcher.js

@@ -20,7 +20,7 @@ import { readFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { existsSync } from 'node:fs'
 import yaml from 'js-yaml'
-import { matchWhere, queryDataUrl } from '@uniweb/core'
+import { matchWhere, sortRecords, queryDataUrl } from '@uniweb/core'
 
 /**
  * Infer schema name from path or URL
@@ -128,42 +128,31 @@ export function applyFilter(items, filterExpr) {
 }
 
 /**
- * Apply sort expression to array of items
+ * Apply a `sort:` to an array of items — `@uniweb/core`'s ONE evaluator, the
+ * same the runtime's fallback runs, so a query orders identically on the file
+ * lane and over a fetched array.
+ *
+ * ⛔ SINGLE-KEY, BY RULING [Diego, 2026-09-04]. This was its own implementation
+ * until then, and it honoured `order asc, title asc` — a multi-key sort the
+ * records door refuses and the ruling dropped. A comma now THROWS here, at build
+ * time, which is where an authoring error on the file lane belongs.
  *
  * @param {Array} items - Items to sort
- * @param {string} sortExpr - Sort expression (e.g., "date desc" or "order asc, title asc")
+ * @param {string} sortExpr - Sort expression: `date`, `date desc`, `-date`
  * @returns {Array} Sorted items (new array)
- *
- * @example
- * applySort(items, 'date desc')
- * applySort(items, 'order asc, title asc')
  */
 export function applySort(items, sortExpr) {
   if (!sortExpr || !Array.isArray(items)) return items
-
-  const sorts = sortExpr.split(',').map(s => {
-    const [field, dir = 'asc'] = s.trim().split(/\s+/)
-    return { field, desc: dir.toLowerCase() === 'desc' }
-  })
-
-  return [...items].sort((a, b) => {
-    for (const { field, desc } of sorts) {
-      const aVal = getNestedValue(a, field) ?? ''
-      const bVal = getNestedValue(b, field) ?? ''
-      if (aVal < bVal) return desc ? 1 : -1
-      if (aVal > bVal) return desc ? -1 : 1
-    }
-    return 0
-  })
+  return sortRecords(items, sortExpr)
 }
 
 /**
  * Apply a where-object predicate to an array of items.
  *
- * The where-object is the new query language (see @uniweb/core's
- * matchWhere). Structured JSON predicate; the runtime evaluator walks
- * the object against each record. Same shape ships to backends that
- * declare `supports: [where]`.
+ * The where-object is the query language (see @uniweb/core's
+ * matchWhere). Structured JSON predicate; the one evaluator walks the
+ * object against each record, here at build time and in the runtime
+ * alike. The same shape crosses to a host's question door unchanged.
  *
  * @param {Array} items - Items to filter
  * @param {object} where - Where-object predicate
@@ -252,22 +241,39 @@ export function applyPostProcessing(data, config) {
 // once per key name per process so a 200-record build does not print 200 lines.
 const RECOGNIZED_FETCH_KEYS = {
   refine: new Set(['refine', 'detail', 'limit', 'sort', 'where', 'filter']),
+  // ⛔ `schema` IS NOT ON EITHER LIST, and its absence is the point. It was the
+  // binding key until 2026-09-02 and stopped being READ on 2026-09-03 (`e4fe077`,
+  // one name no alias) — but it was left on these lists, which exempted it from
+  // the very report this table exists to produce. So the retired spelling was
+  // dropped in the one way the author could not see: no warning, and a plausible
+  // key inferred from the path in its place. It has its own message below, since
+  // "unrecognized" understates a key that used to work.
   query: new Set([
-    'query', 'as', 'schema', 'prerender', 'merge', 'transform',
+    'query', 'as', 'prerender', 'merge', 'transform',
     'where', 'limit', 'sort', 'detailPage', 'filter',
   ]),
   source: new Set([
-    'path', 'url', 'as', 'schema', 'prerender', 'merge', 'transform', 'detail',
+    'path', 'url', 'as', 'prerender', 'merge', 'transform', 'detail',
     'detailPage', 'where', 'limit', 'sort', 'filter',
   ]),
 }
 
+// Keys that are neither recognized nor merely unknown: they USED to work, and a
+// generic "unrecognized key" line understates that. Each has a dedicated message
+// naming its replacement, so this table only has to keep the generic report from
+// firing a second, vaguer time on the same key.
+//
+// ⛔ This is not the recognized list wearing another name. A key here is still
+// dropped from the parsed config; what it buys is a better sentence.
+const RETIRED_FETCH_KEYS = new Set(['schema'])
+
 const warnedUnknownFetchKeys = new Set()
 
 function warnUnknownFetchKeys(fetch, shape) {
   const recognized = RECOGNIZED_FETCH_KEYS[shape]
   for (const key of Object.keys(fetch)) {
     if (recognized.has(key)) continue
+    if (RETIRED_FETCH_KEYS.has(key)) continue
     const seenKey = `${shape}:${key}`
     if (warnedUnknownFetchKeys.has(seenKey)) continue
     warnedUnknownFetchKeys.add(seenKey)
@@ -406,6 +412,7 @@ export function parseFetchConfig(fetch) {
   if (fetch.query) {
     warnUnknownFetchKeys(fetch, 'query')
     if (fetch.filter !== undefined) warnFilterDeprecated()
+    warnSchemaRetired(fetch, fetch.as || fetch.query)
     return {
       // ⭐ **`query` IS EMITTED, and that is what makes the two producers agree.**
       // The sync lane has always emitted it (`uwx/site.js`) and this one did not,
@@ -470,6 +477,7 @@ export function parseFetchConfig(fetch) {
   if (!path && !url) return null
 
   if (filter !== undefined) warnFilterDeprecated()
+  warnSchemaRetired(fetch, as ?? inferSchemaFromPath(path || url))
 
   return {
     path,
@@ -493,6 +501,46 @@ export function parseFetchConfig(fetch) {
   }
 }
 
+/**
+ * Report a fetch still authored with the retired `schema:` binding key.
+ *
+ * ⭐ **It names the key the fetch ACTUALLY bound to, and that is the whole
+ * value of this message.** `schema:` is not read (ruling 2026-09-03, `e4fe077`):
+ * the binding key falls back to the query name or to `inferSchemaFromPath`, so
+ * the data still arrives — under a *different* `content.data` key. The component
+ * reads `?.weather`, gets `undefined`, and renders empty with nothing anywhere
+ * saying why. A bare "unrecognized key" would not close that gap; the inferred
+ * name does, because the reader can see at once whether it happens to match.
+ *
+ * ⚠️ Measured 2026-09-03, `templates/dynamic`: five of six sections rendered
+ * empty this way, one of them from a URL whose last segment is empty
+ * (`randomuser.me/api/?results=6` → `as: ''`), which is falsy and drops the
+ * config outright. That template shipped with no warning of any kind, because
+ * `schema` was left on the recognized list when it stopped being read.
+ *
+ * Once per distinct (written → bound) pair: several files each get their own
+ * line, one file repeated across 200 records does not.
+ */
+const warnedRetiredSchema = new Set()
+function warnSchemaRetired(fetch, boundTo) {
+  if (fetch?.schema === undefined) return
+  const wrote = String(fetch.schema)
+  const bound = boundTo === '' || boundTo === undefined ? '(nothing)' : String(boundTo)
+  const seen = `${wrote}→${bound}`
+  if (warnedRetiredSchema.has(seen)) return
+  warnedRetiredSchema.add(seen)
+  console.warn(
+    `[uniweb] fetch: 'schema: ${wrote}' is retired as the binding key and is NOT read. ` +
+      `This fetch binds to content.data.${bound} instead. Write 'as: ${wrote}'. ` +
+      "(On a `queries:` declaration `schema:` is a different, current key — the Model ref.)"
+  )
+}
+
+/** Test seam — reset the retired-`schema:` memo so suites do not leak into each other. */
+export function _resetRetiredSchemaWarnings() {
+  warnedRetiredSchema.clear()
+}
+
 let filterDeprecationWarned = false
 function warnFilterDeprecated() {
   if (filterDeprecationWarned) return
@@ -505,6 +553,98 @@ function warnFilterDeprecated() {
   )
 }
 
+/**
+ * Keys a fetch declaration carries for THE BUILD ONLY, which no runtime reads.
+ *
+ * `merge` decides how a section-level fetch lands in `parsedContent.data` when
+ * prerender (or the dev server) executes it — a build-lane feature, documented as
+ * such. It rode every shipped payload regardless, and a key on the payload that
+ * nothing reads is a key a consumer will one day read. Stripped at the two emit points framework owns — the link lane's
+ * `site-content.json` and the bundle lane's embed — AFTER the build has consumed
+ * it. ⛔ Not from the sync wire: that carries the author's declaration, which
+ * `pull` must round-trip.
+ */
+const BUILD_ONLY_FETCH_KEYS = ['merge']
+
+function stripFetch(fetch) {
+  if (!fetch || typeof fetch !== 'object') return fetch
+  if (Array.isArray(fetch)) return fetch.map(stripFetch)
+  let changed = false
+  const out = {}
+  for (const [key, value] of Object.entries(fetch)) {
+    if (BUILD_ONLY_FETCH_KEYS.includes(key)) {
+      changed = true
+      continue
+    }
+    out[key] = value
+  }
+  return changed ? out : fetch
+}
+
+function stripSections(sections) {
+  if (!Array.isArray(sections)) return sections
+  return sections.map((section) => {
+    if (!section || typeof section !== 'object') return section
+    const fetch = stripFetch(section.fetch)
+    const subsections = stripSections(section.subsections)
+    if (fetch === section.fetch && subsections === section.subsections) return section
+    const out = { ...section }
+    if (fetch !== section.fetch) out.fetch = fetch
+    if (subsections !== section.subsections) out.subsections = subsections
+    return out
+  })
+}
+
+function stripPageLike(page) {
+  if (!page || typeof page !== 'object') return page
+  const fetch = stripFetch(page.fetch)
+  const sections = stripSections(page.sections)
+  if (fetch === page.fetch && sections === page.sections) return page
+  const out = { ...page }
+  if (fetch !== page.fetch) out.fetch = fetch
+  if (sections !== page.sections) out.sections = sections
+  return out
+}
+
+/**
+ * A copy of a site-content payload with the build-only fetch keys removed from
+ * every fetch declaration it carries: `config.fetch`, each page's, each
+ * section's (and subsection's), each layout area's, and the `config` inside
+ * `fetchedData` entries. Structural sharing — untouched objects are the same
+ * objects, so this is cheap on a large site.
+ *
+ * @param {Object} siteContent
+ * @returns {Object}
+ */
+export function stripBuildOnlyFetchKeys(siteContent) {
+  if (!siteContent || typeof siteContent !== 'object') return siteContent
+  const out = { ...siteContent }
+  if (out.config && typeof out.config === 'object' && out.config.fetch !== undefined) {
+    const fetch = stripFetch(out.config.fetch)
+    if (fetch !== out.config.fetch) out.config = { ...out.config, fetch }
+  }
+  if (Array.isArray(out.pages)) out.pages = out.pages.map(stripPageLike)
+  if (out.layouts && typeof out.layouts === 'object') {
+    const layouts = {}
+    for (const [name, areas] of Object.entries(out.layouts)) {
+      if (!areas || typeof areas !== 'object') { layouts[name] = areas; continue }
+      const next = {}
+      for (const [area, page] of Object.entries(areas)) next[area] = stripPageLike(page)
+      layouts[name] = next
+    }
+    out.layouts = layouts
+  }
+  if (out.notFound) out.notFound = stripPageLike(out.notFound)
+  if (Array.isArray(out.fetchedData)) {
+    out.fetchedData = out.fetchedData.map((entry) => {
+      if (!entry || typeof entry !== 'object') return entry
+      const config = stripFetch(entry.config)
+      return config === entry.config ? entry : { ...entry, config }
+    })
+  }
+  return out
+}
+
 /**
  * Execute a fetch operation
  *

package/src/site/plugin.js

@@ -33,7 +33,7 @@
 import { resolve, join } from 'node:path'
 import { watch, existsSync } from 'node:fs'
 import { readFile, readdir } from 'node:fs/promises'
-import { resolveDefaultLocale, DATA_DIR } from '@uniweb/core'
+import { resolveDefaultLocale, resolveFetchConfigs, DATA_DIR } from '@uniweb/core'
 import {
   renderSiteIndex,
   renderPageMarkdown,
@@ -136,13 +136,24 @@ export function shouldPrefetchInDev(cfg) {
 async function executeDevFetches(siteContent, siteDir) {
   const fetchOptions = { siteRoot: siteDir, publicDir: 'public' }
   const fetchedData = []
+  // Resolved the way the runtime resolves it (see prerender.js::executeAllFetches
+  // for why): the SPA hydrates by the cache key of ITS resolved config.
+  const resolveOptions = {
+    locale: siteContent.config?.activeLocale ?? null,
+    defaultLocale: resolveDefaultLocale(siteContent.config) ?? null,
+    queries: siteContent.config?.queries ?? null,
+    records: null,
+  }
+  const resolveForDev = (one) => resolveFetchConfigs([one], resolveOptions).get(one.as) ?? one
+  const entry = (cfg, data) => ({ config: cfg, data, meta: { depth: cfg.depth } })
 
   // Site-level fetch — every declaration.
   for (const siteFetch of toFetchList(siteContent.config?.fetch)) {
     if (!shouldPrefetchInDev(siteFetch)) continue
-    const result = await executeFetch(siteFetch, fetchOptions)
+    const cfg = resolveForDev(siteFetch)
+    const result = await executeFetch(cfg, fetchOptions)
     if (result.data && !result.error) {
-      fetchedData.push({ config: siteFetch, data: result.data })
+      fetchedData.push(entry(cfg, result.data))
     }
   }
 
@@ -151,9 +162,10 @@ async function executeDevFetches(siteContent, siteDir) {
     // Page-level fetch — every declaration.
     for (const pageFetch of toFetchList(page.fetch)) {
       if (!shouldPrefetchInDev(pageFetch)) continue
-      const result = await executeFetch(pageFetch, fetchOptions)
+      const cfg = resolveForDev(pageFetch)
+      const result = await executeFetch(cfg, fetchOptions)
       if (result.data && !result.error) {
-        fetchedData.push({ config: pageFetch, data: result.data })
+        fetchedData.push(entry(cfg, result.data))
       }
     }
 

package/src/site/queries-config.js

@@ -8,8 +8,7 @@
 // took `site.yml`'s values and sync took `collections.yml`'s, so an author writing
 // `sort: date desc` here got `date asc` baked into the static file.
 //
-// The broken case was the one the public docs recommend. See
-// `kb/framework/plans/one-collections-config.md`.
+// The broken case was the one the public docs recommend.
 //
 // ⭐ A QUERY IS SECOND-ORDER SITE CONTENT — it describes how to REACH content, and
 // is evaluated rather than rendered. `queries.yml` is a BARE MAP of name → query at
@@ -19,7 +18,7 @@
 // ⛔ THE THREE JOBS `collections/<name>/` USED TO FUSE ARE NOW THREE THINGS.
 // `entities/{schema}/` is the pool, `records.yml` is the folder (what makes an
 // entity a record), and a query asks the folder for a set. This file resolves the
-// LAST of those only. Model: `kb/framework/plans/records-model.md`.
+// LAST of those only.
 //
 // ⚠️ `collections.yml` and `site.yml::collections` are GONE, with no alias and no
 // deprecation path — the model's §5 ruling, and there is nothing outside this

package/src/site/query-processor.js

@@ -54,7 +54,7 @@ import { join, basename, extname, dirname, relative, resolve, sep } from 'node:p
 import { existsSync } from 'node:fs'
 import yaml from 'js-yaml'
 import { parseBibtex } from '@citestyle/bibtex'
-import { DATA_DIR } from '@uniweb/core'
+import { DATA_DIR, fillRoutePattern } from '@uniweb/core'
 import { applyWhere, applyFilter, applySort } from './data-fetcher.js'
 import { resolveAssetPath, walkContentAssets, isLocalAssetPath } from './assets.js'
 import { readEntityPool, groupPoolBySchema, ENTITIES_DIR } from './entity-pool.js'
@@ -675,13 +675,30 @@ async function collectItems(siteDir, config, entitiesDir, basePath) {
 
   warnDuplicateSlugs(items, config.name)
 
-  // Add routes to items if collection has a route configured
+  // `route:` on the query — bake each record's canonical href.
+  //
+  // ⭐ THROUGH THE ONE ENCODER (`fillRoutePattern`, `@uniweb/core/route-match`),
+  // which is what the runtime's `addDetailRoute` also calls. Until 2026-09-04 this
+  // interpolated `${baseRoute}/${item.slug}` RAW while the runtime encoded, and a
+  // record already carrying a baked route keeps it — so the same record got two
+  // different hrefs depending on which lane served it (F14): a slug with a space
+  // compared unequal to `location.pathname`, and a slug with a `/` became an
+  // extra route segment. A record with no slug gets no route rather than
+  // `/blog/undefined`.
+  //
+  // `route: /blog` names the base of a `[slug]` page, so the template is
+  // `/blog/:slug`. `route: /blog/[...path]` names a `[...path]` page: the
+  // template is `/blog/:path*` and the record's placement (`path`, the folder
+  // `records.yml` put it in) becomes part of its href — `/blog/field/my-post`.
   if (config.route) {
-    const baseRoute = config.route.replace(/\/$/, '') // Remove trailing slash
-    items = items.map(item => ({
-      ...item,
-      route: `${baseRoute}/${item.slug}`
-    }))
+    const base = config.route.replace(/\/$/, '')
+    const template = base.endsWith('/[...path]')
+      ? `${base.slice(0, -'/[...path]'.length)}/:path*`
+      : `${base}/:slug`
+    items = items.map((item) => {
+      const route = fillRoutePattern(template, item)
+      return route === null ? item : { ...item, route }
+    })
   }
 
   // ⛔ ORDER MATCHES `data-fetcher.js::applyPostProcessing` — where, filter, sort,

package/src/site/records-config.js

@@ -42,7 +42,7 @@
 // fill it in) is guarded at the CLI with a count and a confirmation; the format
 // stays honest and the CLI does the asking.
 //
-// Model: `kb/framework/plans/records-model.md`.
+// Model: entity · record · query · folder.
 
 import { existsSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'

package/src/uwx/foundation-schema.js

@@ -4,9 +4,10 @@
 // The entity has FOUR Sections — decompose only what a consumer needs to read
 // on its own; keep coarse what is shipped whole:
 //
-//   info    single, brief — identity ONLY: name, version, role, description.
-//                           Field-decomposed so identity is readable without
-//                           opening the rest. This is the summary card.
+//   info    single, brief — identity: name, version, role, description, plus the
+//                           producer statements a consumer must act on without
+//                           opening the rest (`digest`, `runtime`, `supports`).
+//                           Field-decomposed. This is the summary card.
 //   schema  single — ONE opaque `schema` json field: the whole renderable
 //                    schema.json MINUS identity and MINUS dataSchemas
 //                    (components, layouts, outputs, plus foundation-wide config
@@ -84,6 +85,11 @@ export function foundationSchemaToEntity(schema, opts = {}) {
     role: self.role || 'foundation',
   }
   if (self.description !== undefined) info.description = self.description
+  // The host services this foundation is built against (package.json's
+  // `uniweb.supports`). `Array.isArray`, not truthiness: `[]` is an explicit
+  // "none"; an ABSENT key means UNKNOWN. Mirrors `buildInfo` in
+  // `registry-package.js`, which is the path `uniweb register` actually takes.
+  if (Array.isArray(self.supports)) info.supports = self.supports
 
   // ── schema — the whole renderable schema.json minus identity and minus
   // dataSchemas, shipped WHOLE as one opaque blob. ───────────────────────────
@@ -93,6 +99,7 @@ export function foundationSchemaToEntity(schema, opts = {}) {
     version: _v,
     description: _d,
     role: _r,
+    supports: _s,
     ...selfConfig
   } = rest._self || {}
   const schemaBlob = { ...rest, _self: selfConfig }

package/src/uwx/records.js

@@ -2,7 +2,7 @@
 // referenced BY NAME, on the entity-content SYNC lane.
 //
 // Each record becomes a section-keyed `$`-document (docs/reference/entity-content.md):
-// `$id` (the slug — the producer-local handle), `$model` (the Model by name), and
+// `$id` (the producer-local handle), `$model` (the Model by name), and
 // each SINGLE section keyed by its name — the brief plus any sibling singles, not
 // the brief alone. The backend MINTS `$uuid` on first sync and
 // returns it in the finalized response; the verb back-fills it into the source
@@ -91,8 +91,9 @@ function stripSigils(value) {
     // ⛔ A `@uniweb/folder` REF LEAF ENCODES ONE REFERENCE TWO WAYS, and hashing the
     // encoding rather than the reference made the folder's hash unreproducible.
     //
-    // `refLeaf` (uwx/folder.js) emits `$ref: "<collection>/<slug>"` while the record
-    // is brand-new and `entry: { model, entity: <uuid> }` once it has been minted.
+    // `refLeaf` (uwx/folder.js) emits `$ref: <the record's $id>` — the pool position
+    // `<dirs>/<slug>` — while the record is brand-new, and `entry: { model, entity:
+    // <uuid> }` once it has been minted.
     // Both denote the same record. A push hashes the folder BEFORE submitting, then
     // back-fills the minted `$uuid` into every record's source file — so the very
     // next emit builds the OTHER encoding, and the hash the push just banked can
@@ -181,7 +182,7 @@ function encodeFieldValue(value, field, sourceLocale, translations) {
  * already carries `$uuid` (back-filled from a prior sync) round-trips it.
  *
  * @param {object} params
- * @param {string} params.queryName  - the site.yml collection name
+ * @param {string} params.queryName  - the query's name in site.yml
  * @param {object[]} params.records        - [{ slug, ...fields }]
  * @param {object} params.declaration      - the `@uniweb/data-schema` declaration
  *        (from toDataSchemaDeclaration): `{ name, brief, sections }`
@@ -272,9 +273,22 @@ export function recordsToEntities({
       warnings.push(`${queryName}: a record without a slug was skipped`)
       continue
     }
-    // `$id` is the payload-local handle = the record's path under collections/
-    // (`<collection>/<slug>`), globally unique within one sync so the @uniweb/folder
-    // entity can point a leaf at it via `$ref`. An explicit frontmatter `$id` wins.
+    // ⛔ `$id` IS NOT THE SLUG. It is the payload-local, PATH-QUALIFIED handle, so
+    // the @uniweb/folder entity can point a leaf at it via `$ref`. An explicit
+    // frontmatter `$id` wins.
+    //
+    // ⚠️ The authoritative value is the record's POOL POSITION — `<dirs>/<slug>` —
+    // and it is set upstream, at the pool walk; see the ⭐ comment there, which is
+    // where the reasoning lives. `<query>/<slug>` below is only the fallback for a
+    // record that did not arrive through the pool, and it is explicitly NOT the
+    // shape identity is meant to take: two queries over one Model would mint two
+    // identities for one file.
+    //
+    // The qualification is a CONSTRAINT, not a style: the sync response is keyed per
+    // (`$model`, `$id`), so a bare slug would collide whenever two queries over the
+    // same Model reuse one (see the duplicate check below). ⇒ Do not describe this
+    // value as "the slug" — the folder leaf's `path_segment` is the bare segment, and
+    // conflating the two has already misdirected a naming decision.
     const id = record.$id || `${queryName}/${slug}`
     const uuid = record.$uuid || null
     const hasBody = typeof record.$body === 'string' && record.$body.trim() !== ''
@@ -631,7 +645,7 @@ export async function buildRecordEntities(siteRoot, opts = {}) {
   // statically (the "data ball") instead, so the caller can route them there.
   const schemaless = []
   // The sync response is keyed per ($model, $id), so the pair must be unique
-  // within one submission (two collections on the same Model could otherwise
+  // within one submission (two queries over the same Model could otherwise
   // reuse a slug).
   const seen = new Set()
   for (const { name, decl } of mapped) {

package/src/uwx/registry-package.js

@@ -159,6 +159,11 @@ function buildInfo(self, org, digest, runtime) {
   // be satisfied. Same lift as `digest`: stated by the producer, opaque to the
   // backend, acted on by whoever resolves a whole site.
   if (runtime) info.runtime = runtime
+  // The host services this foundation is BUILT AGAINST, from package.json's
+  // `uniweb.supports`. `Array.isArray` and not truthiness: `[]` is an explicit
+  // "none" and must survive as one, while an ABSENT key means UNKNOWN — the
+  // same three-state rule `runtime` states above, for the same reason.
+  if (Array.isArray(self.supports)) info.supports = self.supports
   return info
 }
 
@@ -166,7 +171,11 @@ function buildInfo(self, org, digest, runtime) {
 // as one opaque object the backend never reads into (custodian).
 function buildSchemaBlob(schema) {
   const { dataSchemas: _ds, ...rest } = schema
-  const { name: _n, version: _v, description: _d, role: _r, ...selfConfig } = rest._self || {}
+  // Every key hoisted into `info` is stripped here, so the wire carries each
+  // fact ONCE. Two copies of one fact is a drift liability, and the copy inside
+  // an opaque blob is the one nobody would think to update.
+  const { name: _n, version: _v, description: _d, role: _r, supports: _s, ...selfConfig } =
+    rest._self || {}
   return { ...rest, _self: selfConfig }
 }
 

package/src/uwx/site-project.js

@@ -513,7 +513,12 @@ function projectPages(pages, pagesDir, sourceLocale, report, prune, ctx) {
 // is already a plain string.
 export function pageDirName(record, sourceLocale) {
   const slug = unwrapLocalized(record.slug, sourceLocale)
-  return record.is_dynamic ? `[${record.param_name || slug}]` : slug
+  if (!record.is_dynamic) return slug
+  // The multi-segment folder rides the wire as slug `...path` with
+  // `param_name: slug` (the handle it delivers by); it comes back as the one
+  // fixed spelling, never as `[slug]`.
+  if (slug === '...path') return '[...path]'
+  return `[${record.param_name || slug}]`
 }
 
 // Pass 1 — write + relocate every page dir, its page.yml/folder.yml, and its

package/src/uwx/site.js

@@ -334,6 +334,12 @@ async function orderedSubfolders(dirPath, inheritedMode, parentConfig) {
 }
 
 const DYNAMIC_RE = /^\[(.+)\]$/
+// The multi-segment route folder, one fixed spelling (`content-collector.js`).
+// On the wire its page `slug` is the marker itself (`...path`) and its
+// `param_name` is `slug`: the record is delivered by its handle, the last
+// segment, exactly as under `[slug]`. ⚠️ What a consumer's projector emits as
+// the page ROUTE for it is that consumer's; framework expects `/…/:path*`.
+const CATCH_ALL_MARKER = '...path'
 
 // ===========================================================================
 // NESTED ($-document) lane — Phase 0 de-flatten (bidirectional-sync §8).
@@ -545,7 +551,7 @@ async function walkPagesNested(ctx, dirPath, parentSlugPath, inheritedMode, pare
       slug,
       mode,
       isDynamic: !!dyn,
-      paramName: dyn ? dyn[1] : undefined,
+      paramName: dyn ? (dyn[1] === CATCH_ALL_MARKER ? 'slug' : dyn[1]) : undefined,
       isRoot,
       siteIndex,
       sourceLocale,
@@ -684,7 +690,7 @@ export function isSiteRelativeExtensionUrl(decl) {
  * declaration could occupy, nothing is ever recorded for one, and every push re-sent
  * this whole section uuid-less. The backend refuses that (an all-blank section over
  * stored items would delete every stored row), which is why `push` worked once and
- * every push after it was refused. Measured 2026-08-29; collab framework-backend-812b.
+ * every push after it was refused. Measured 2026-08-29; collab framework↔backend.
  *
  * ⭐ `name` is the right key and not merely the available one — the backend enforces
  * `unique_field(name, scope: section)` on this section, and it is the join key its
@@ -724,8 +730,6 @@ export function isSiteRelativeExtensionUrl(decl) {
  * `site.yml collections.<name>.label`; no such field has ever existed, and they have
  * corrected it.
  *
- * ⇒ Full record, including what is established vs merely claimed:
- * `kb/framework/build/collections-decl-open-questions.md`.
  *
  * @param {object} declarations resolved collection declarations, keyed by name
  * @param {Object<string,string>} [uuids] `name` → backend `$uuid`, from a push

package/src/dev-backend.js

@@ -1,247 +0,0 @@
-#!/usr/bin/env node
-/**
- * Dev backend for testing Uniweb sites with `supports: [where, limit, sort]`.
- *
- * Reads a directory of YAML recordsByQuery (each subfolder is a collection,
- * each .yml file inside is a record) and exposes them via HTTP. Evaluates
- * where-objects on the server side using @uniweb/core's matchWhere — the
- * exact same evaluator the runtime uses as a fallback. This lets you
- * develop a site against a "real" backend without standing up a database.
- *
- * Wire format matches the framework default fetcher's pushdown conventions
- * (see framework/runtime/src/default-fetcher.js):
- *
- *   GET  /api/{collection}                        — all records
- *   GET  /api/{collection}?_where=<JSON>          — filtered by where-object
- *   GET  /api/{collection}?_limit=N               — first N records
- *   GET  /api/{collection}?_sort=field:dir        — sorted
- *   POST /api/{collection}  body: { where, ... } — operators in body
- *   GET  /api/{collection}/{slug}                 — single record
- *
- * Usage:
- *   node scripts/framework/dev-backend.js --recordsByQuery <path> [--port N]
- *
- * Example (academic-metrics):
- *   node scripts/framework/dev-backend.js \
- *     --recordsByQuery framework/templates/academic-metrics/site/recordsByQuery \
- *     --port 8080
- *
- * Then in the site's site.yml:
- *   fetcher:
- *     baseUrl: http://localhost:8080
- *     supports: [where, limit, sort]
- *
- * And rewrite collection refs to URLs, e.g.:
- *   fetch: { url: /api/members, schema: members }
- */
-
-import { createServer } from 'node:http'
-import { readFile, readdir, stat } from 'node:fs/promises'
-import { existsSync } from 'node:fs'
-import { resolve, join, basename, extname } from 'node:path'
-import { parseArgs } from 'node:util'
-import yaml from 'js-yaml'
-import { matchWhere } from '@uniweb/core'
-
-const { values } = parseArgs({
-  options: {
-    entities: { type: 'string', short: 'e' },
-    port: { type: 'string', short: 'p', default: '8080' },
-  },
-})
-
-if (!values.entities) {
-  console.error('Usage: dev-backend.js --entities <path> [--port N]')
-  process.exit(1)
-}
-
-const ENTITIES_ROOT = resolve(values.entities)
-const PORT = Number(values.port)
-
-if (!existsSync(ENTITIES_ROOT)) {
-  console.error(`Entities directory not found: ${ENTITIES_ROOT}`)
-  process.exit(1)
-}
-
-// ─── Load recordsByQuery from disk ─────────────────────────────────────────────
-
-async function loadRecords(dir) {
-  const files = await readdir(dir)
-  const items = []
-  for (const file of files) {
-    const ext = extname(file).toLowerCase()
-    if (!['.yml', '.yaml', '.json'].includes(ext)) continue
-    const filepath = join(dir, file)
-    const content = await readFile(filepath, 'utf8')
-    let data
-    try {
-      data = ext === '.json' ? JSON.parse(content) : yaml.load(content)
-    } catch (err) {
-      console.warn(`[dev-backend] Failed to parse ${filepath}: ${err.message}`)
-      continue
-    }
-    if (data == null) continue
-    const slug = basename(file, ext)
-    if (Array.isArray(data)) {
-      // Array-form file: each element is a record.
-      for (const record of data) {
-        if (record && typeof record === 'object') items.push(record)
-      }
-    } else if (typeof data === 'object') {
-      items.push({ slug, ...data })
-    }
-  }
-  return items
-}
-
-async function loadAllRecords() {
-  const entries = await readdir(ENTITIES_ROOT)
-  const recordsByQuery = {}
-  for (const name of entries) {
-    const fullPath = join(ENTITIES_ROOT, name)
-    const s = await stat(fullPath)
-    if (!s.isDirectory()) continue
-    recordsByQuery[name] = await loadRecords(fullPath)
-    console.log(`[dev-backend] Loaded ${recordsByQuery[name].length} items from "${name}"`)
-  }
-  return recordsByQuery
-}
-
-// ─── Operator handling (mirrors default-fetcher pushdown wire format) ───────
-
-function applyOperators(items, operators) {
-  let result = items
-  if (operators.where) {
-    result = matchWhere(operators.where, result)
-  }
-  if (operators.sort) {
-    result = applySort(result, operators.sort)
-  }
-  if (typeof operators.limit === 'number' && operators.limit > 0) {
-    result = result.slice(0, operators.limit)
-  }
-  return result
-}
-
-function applySort(items, sortExpr) {
-  const sorts = String(sortExpr).split(',').map((s) => {
-    const [field, dir = 'asc'] = s.trim().split(/\s+/)
-    return { field, desc: dir.toLowerCase() === 'desc' }
-  })
-  return [...items].sort((a, b) => {
-    for (const { field, desc } of sorts) {
-      const av = a?.[field] ?? ''
-      const bv = b?.[field] ?? ''
-      if (av < bv) return desc ? 1 : -1
-      if (av > bv) return desc ? -1 : 1
-    }
-    return 0
-  })
-}
-
-function parseOperatorsFromQuery(searchParams) {
-  const out = {}
-  if (searchParams.has('_where')) {
-    try {
-      out.where = JSON.parse(searchParams.get('_where'))
-    } catch (err) {
-      throw new Error(`Invalid _where JSON: ${err.message}`)
-    }
-  }
-  if (searchParams.has('_limit')) {
-    out.limit = Number(searchParams.get('_limit'))
-  }
-  if (searchParams.has('_sort')) {
-    out.sort = searchParams.get('_sort')
-  }
-  return out
-}
-
-async function readJsonBody(req) {
-  return new Promise((resolve, reject) => {
-    let body = ''
-    req.on('data', (chunk) => { body += chunk })
-    req.on('end', () => {
-      if (!body) return resolve({})
-      try { resolve(JSON.parse(body)) }
-      catch (err) { reject(new Error(`Invalid JSON body: ${err.message}`)) }
-    })
-    req.on('error', reject)
-  })
-}
-
-// ─── HTTP server ────────────────────────────────────────────────────────────
-
-function send(res, status, body) {
-  res.writeHead(status, {
-    'Content-Type': 'application/json',
-    'Access-Control-Allow-Origin': '*',
-    'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
-    'Access-Control-Allow-Headers': 'Content-Type',
-  })
-  res.end(typeof body === 'string' ? body : JSON.stringify(body))
-}
-
-async function handleRequest(req, res, recordsByQuery) {
-  if (req.method === 'OPTIONS') return send(res, 204, '')
-
-  const url = new URL(req.url, `http://${req.headers.host}`)
-  const match = url.pathname.match(/^\/api\/([^/]+)(?:\/([^/]+))?$/)
-  if (!match) return send(res, 404, { error: 'Not found' })
-
-  const [, queryName, slug] = match
-  const items = recordsByQuery[queryName]
-  if (!items) return send(res, 404, { error: `Unknown query: ${queryName}` })
-
-  // Single record by slug.
-  if (slug) {
-    const item = items.find((r) => r?.slug === slug)
-    if (!item) return send(res, 404, { error: `No record with slug "${slug}"` })
-    return send(res, 200, item)
-  }
-
-  // Collection — apply operators from query string (GET) or body (POST).
-  let operators
-  try {
-    operators = req.method === 'POST'
-      ? await readJsonBody(req)
-      : parseOperatorsFromQuery(url.searchParams)
-  } catch (err) {
-    return send(res, 400, { error: err.message })
-  }
-
-  let result
-  try {
-    result = applyOperators(items, operators)
-  } catch (err) {
-    return send(res, 400, { error: `Operator evaluation failed: ${err.message}` })
-  }
-  return send(res, 200, result)
-}
-
-// ─── Boot ───────────────────────────────────────────────────────────────────
-
-const recordsByQuery = await loadAllRecords()
-const knownQueries = Object.keys(recordsByQuery)
-if (knownQueries.length === 0) {
-  console.warn('[dev-backend] No recordsByQuery found.')
-}
-
-const server = createServer((req, res) => {
-  handleRequest(req, res, recordsByQuery).catch((err) => {
-    console.error('[dev-backend] Request handler threw:', err)
-    send(res, 500, { error: 'Internal server error' })
-  })
-})
-
-server.listen(PORT, () => {
-  console.log(`[dev-backend] Listening on http://localhost:${PORT}`)
-  console.log(`[dev-backend] Queries: ${knownQueries.join(', ') || '(none)'}`)
-  console.log('[dev-backend] Endpoints:')
-  for (const name of knownQueries) {
-    console.log(`  GET  /api/${name}                  — all records`)
-    console.log(`  GET  /api/${name}?_where=<JSON>    — filtered`)
-    console.log(`  GET  /api/${name}/{slug}            — single record`)
-    console.log(`  POST /api/${name}  body: { where } — operators in body`)
-  }
-})