@uniweb/build 0.37.0 → 0.38.0

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