@uniweb/build 0.37.1 → 0.39.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'
@@ -143,7 +143,7 @@ export async function readRecordsConfig(siteRoot) {
  *
  * ⛔ ONE PLACEMENT PER ENTITY. Two entries matching one file is a hard error, not
  * a second placement. The wire could carry many-to-many — `folder.js` nests, and
- * placements are keyed by their `path_segment` chain — but `core/src/where.js`'s
+ * placements are keyed by their `name` chain — but `core/src/where.js`'s
  * `matchUnder` is STRING-ONLY, so a record with two paths would match nothing
  * under `where: { path: { under: … } }`, silently. Widening `under` is a
  * predicate the backend also evaluates natively, so it is a cross-lane change to
@@ -184,7 +184,7 @@ export function resolveFolder(entries, pool) {
     const slug = slugForEntity(entity)
     const path = pathSegs.join('/')
     placements.set(key, { entity, path, slug })
-    return { kind: 'ref', path_segment: slug, $entityId: key }
+    return { kind: 'ref', name: slug, $entityId: key }
   }
 
   const resolveEntry = (entry, pathSegs, index, trail) => {
@@ -246,8 +246,13 @@ export function resolveFolder(entries, pool) {
         errors.push(`${RECORDS_YML_RELPATH}: ${where} declares a folder with no name.`)
         return []
       }
-      const branch = { kind: 'branch', path_segment: segment }
-      if (entry.label !== undefined && entry.label !== null) branch.name = String(entry.label)
+      // ⭐ `name` is the handle (the URL segment, sibling-unique); `label` is the
+      // display text. The store renamed the pair on 2026-09-04 — `path_segment` →
+      // `name`, and the old `name` (display) → `label` — so one word means one
+      // thing from records.yml (`folder:` / `label:`) to the wire to the door's
+      // `$name`.
+      const branch = { kind: 'branch', name: segment }
+      if (entry.label !== undefined && entry.label !== null) branch.label = String(entry.label)
       const kids = Array.isArray(entry.records) ? entry.records : []
       if (kids.length === 0) {
         warnings.push(

package/src/uwx/folder.js

@@ -7,10 +7,18 @@
 //   - `contents` is the self-nesting tree (an array), nesting via `$children` — the
 //     same mechanism site-content pages/sections use. Each node holds REFERENCES,
 //     never content:
-//       - a LEAF references one record entity: `{ kind: 'ref', path_segment, ... }`
-//         with `entry: <uuid>` once the record was minted (back-filled into its file),
+//       - a LEAF references one record entity: `{ kind: 'ref', name, ... }` with
+//         `entry: <uuid>` once the record was minted (back-filled into its file),
 //         or `$ref: "<id>"` while brand-new (resolved within this payload).
-//       - a BRANCH is a sub-folder: `{ kind: 'branch', path_segment, name?, $children }`.
+//       - a BRANCH is a sub-folder: `{ kind: 'branch', name, label?, $children }`.
+//
+// ⭐ `name` IS THE HANDLE — the URL segment, sibling-unique, the door's `$name` —
+// and `label` is the display text, a localized map (`{ en: "Blog" }`). The store
+// renamed the pair on 2026-09-04 (`path_segment` → `name`; the old display `name`
+// → `label`); this emitter writes the new shape only and the pull reader
+// (`records-project.js`) reads the new shape only. No alias on either side: the
+// old key's PRESENCE was the version signal, and there is no population to
+// carry.
 //
 // ⭐ THE ORGANIZATION IS AUTHORED, IN `records.yml`, AND IT IS THE ONLY SOURCE.
 // It used to be DERIVED — one branch per collection, mirroring the `collections/`
@@ -42,7 +50,7 @@ export const FOLDER_ENTITY_KEY = '@folder'
 // it currently carries the Model NAME (e.g. `@std/article`). Wire the name→uuid
 // resolution (a registry data-schema read) as a follow-up.
 function refLeaf(entity) {
-  const leaf = { kind: 'ref', path_segment: entity.slug }
+  const leaf = { kind: 'ref', name: entity.slug }
   if (entity.uuid) leaf.entry = { model: entity.model, entity: entity.uuid }
   else leaf.$ref = entity.id // the payload-local handle
   return leaf
@@ -60,13 +68,16 @@ function refLeaf(entity) {
  * @param {Map<string, object>} byEntityId - record entities, keyed by pool id
  * @param {string[]} missing - collects ids that resolved to no entity
  */
-function contentsFromNodes(nodes, byEntityId, missing) {
+function contentsFromNodes(nodes, byEntityId, missing, sourceLocale) {
   const out = []
   for (const node of nodes || []) {
     if (node.kind === 'branch') {
-      const branch = { kind: 'branch', path_segment: node.path_segment }
-      if (node.name !== undefined) branch.name = node.name
-      branch.$children = contentsFromNodes(node.$children, byEntityId, missing)
+      const branch = { kind: 'branch', name: node.name }
+      // The display text is a LOCALIZED field on the wire — a `{ locale: value }`
+      // map, like every localized scalar this producer sends — keyed by the
+      // site's source locale.
+      if (node.label !== undefined) branch.label = { [sourceLocale]: String(node.label) }
+      branch.$children = contentsFromNodes(node.$children, byEntityId, missing, sourceLocale)
       out.push(branch)
       continue
     }
@@ -82,7 +93,7 @@ function contentsFromNodes(nodes, byEntityId, missing) {
 
 /**
  * Walk a folder document's `contents` tree, visiting every item with the
- * slash-joined `path_segment` chain that addresses it.
+ * slash-joined `name` chain that addresses it.
  *
  * ⛔ IT MUST RECURSE INTO `$children`. `contents` is SELF-NESTING: a walk of the
  * top level sees the branches and misses every record under them — which is 6 of
@@ -92,7 +103,7 @@ function contentsFromNodes(nodes, byEntityId, missing) {
 function walkFolderItems(contents, cb, prefix = '') {
   for (const item of contents || []) {
     if (!item || typeof item !== 'object') continue
-    const seg = typeof item.path_segment === 'string' ? item.path_segment : null
+    const seg = typeof item.name === 'string' ? item.name : null
     const path = seg ? (prefix ? `${prefix}/${seg}` : seg) : prefix
     if (seg) cb(path, item)
     walkFolderItems(item.$children, cb, path)
@@ -102,8 +113,8 @@ function walkFolderItems(contents, cb, prefix = '') {
 /**
  * Harvest per-item identity from the folder document the backend returns.
  *
- * ⭐ THE KEY IS THE `path_segment` CHAIN, and it is the right one because the
- * backend's own model declares `path_segment` SIBLING-UNIQUE — so the chain is
+ * ⭐ THE KEY IS THE `name` CHAIN, and it is the right one because the backend's
+ * own model declares `name` SIBLING-UNIQUE — so the chain is
  * unique within the folder, stable across pushes, and derivable identically on
  * both sides without either lane holding the other's ids.
  *
@@ -163,9 +174,11 @@ export function stampFolderItemUuids(doc, pathToUuid = {}) {
  * @param {Record<string,string>} [params.itemUuids] - path → `$uuid`, harvested
  *        from the folder document a previous push returned. Absent on a first
  *        push, where every item is genuinely new.
+ * @param {string} [params.sourceLocale='en'] - the locale a branch `label` is
+ *        keyed under on the wire
  * @returns {{ id, uuid, model, file, document, warnings }|null}
  */
-export function buildFolderEntity({ recordEntities, folderNodes = [], declared, itemUuids = null }) {
+export function buildFolderEntity({ recordEntities, folderNodes = [], declared, itemUuids = null, sourceLocale = 'en' }) {
   // ⛔ `missing` AND `empty` ARE DIFFERENT, AND THE ASYMMETRY IS DELIBERATE.
   //
   //   no records.yml       → null. INERT: nothing is sent, and the server's
@@ -186,7 +199,7 @@ export function buildFolderEntity({ recordEntities, folderNodes = [], declared,
   for (const e of recordEntities || []) byEntityId.set(e.id, e)
 
   const missing = []
-  const contents = contentsFromNodes(folderNodes, byEntityId, missing)
+  const contents = contentsFromNodes(folderNodes, byEntityId, missing, sourceLocale)
   // ⚠️ `id` IS THE ENTITY'S POOL PATH, NOT A FOLDER PATH — say so, because the two
   // read identically and a reader who takes it for a placement concludes the
   // emitter is dropping a branch it never had. *(Measured 2026-08-31: the backend

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-project.js

@@ -6,8 +6,8 @@
 //
 // Identity & placement. A record's on-disk home is `(collection, slug)`:
 //   - `slug` and `collection` come from the FOLDER document — each ref leaf is
-//     `{ entry: { model, entity: <uuid> }, path_segment: <slug> }` inside a branch
-//     (its `$children`) whose `path_segment` names the folder it was placed in.
+//     `{ entry: { model, entity: <uuid> }, name: <slug> }` inside a branch
+//     (its `$children`) whose `name` names the folder it was placed in.
 //     The folder is the authoritative organization on a read (the record
 //     document's own `$id` envelope is not guaranteed to be echoed back), with
 //     the record document's `$id` (its pool identity) as a fallback when present.
@@ -40,6 +40,7 @@ import { writeRecordFile, writeQueriesConfig, writeRecordsConfig } from './proje
 import { defaultSchema, deferredFromSchema, foundationDataSchemas } from './queries-config.js'
 import { poolDirsForSchema, ENTITIES_DIR } from '../site/entity-pool.js'
 import { isContentBodyField } from './data-schema.js'
+import { unwrapLocalized } from './backfill.js'
 import { createTranslationCollector, writeLocaleTranslations, writeFreeformTranslations } from './locale-sync.js'
 import { buildFreeformRecordPath } from '../i18n/freeform.js'
 
@@ -111,9 +112,13 @@ function briefHasContentBody(declaration) {
 
 // Build `uuid → { collection, slug }` from the folder document's ref leaves. The
 // folder is a self-nesting tree under `contents`, nesting via `$children` (the
-// site-content invariant — folder.js). A leaf sits in a branch whose
-// `path_segment` is the collection; the leaf's `path_segment` is the slug and its
-// `entry` is the entity_ref open form `{ model, entity: <uuid> }`. Nested branches
+// site-content invariant — folder.js). A leaf sits in a branch whose `name` is
+// the collection; the leaf's `name` is the slug (the handle) and its `entry` is
+// the entity_ref open form `{ model, entity: <uuid> }`. ⛔ `path_segment` is not
+// read: the store renamed it on 2026-09-04 and a pull emits the new shape only —
+// a reader that kept the old key would index every record as
+// `{ folderPath: null, slug: undefined }` and rewrite records.yml with
+// `folder: undefined` branches (measured on this reader, 2026-09-04). Nested branches
 // are walked; the collection is the NEAREST enclosing branch segment (correct for
 // the default one-branch-per-collection org; a deeply nested virtual org may
 // differ — see the module header).
@@ -122,11 +127,11 @@ function indexFolder(folderDoc) {
   const walk = (nodes, folderPath) => {
     for (const node of nodes || []) {
       if (node?.kind === 'branch') {
-        walk(node.$children, node.path_segment ?? folderPath)
+        walk(node.$children, node.name ?? folderPath)
       } else if (node?.kind === 'ref' && node.entry) {
         // `entry` is `{ model, entity: <uuid> }`; tolerate a bare uuid defensively.
         const uuid = typeof node.entry === 'object' ? node.entry.entity : node.entry
-        if (uuid) byUuid.set(uuid, { folderPath, slug: node.path_segment })
+        if (uuid) byUuid.set(uuid, { folderPath, slug: node.name })
       }
     }
   }
@@ -381,7 +386,7 @@ export function declarationsToQueriesYml({ document, siteRoot }) {
  *        each record landed with.
  * @returns {{ status: 'updated'|'unchanged'|'skipped', entries: Array, warnings: string[] }}
  */
-export function folderToRecordsYml({ folderDoc, siteRoot, poolPathByUuid }) {
+export function folderToRecordsYml({ folderDoc, siteRoot, poolPathByUuid, sourceLocale = 'en' }) {
   const warnings = []
 
   const walk = (nodes) => {
@@ -389,10 +394,11 @@ export function folderToRecordsYml({ folderDoc, siteRoot, poolPathByUuid }) {
     for (const node of nodes || []) {
       if (!node || typeof node !== 'object') continue
       if (node.kind === 'branch') {
-        const entry = { folder: node.path_segment }
+        const entry = { folder: node.name }
         // Only a BRANCH takes a label. A record carries its own title; the folder
-        // does not caption its rows.
-        if (node.name !== undefined) entry.label = node.name
+        // does not caption its rows. On the wire the label is a localized map;
+        // records.yml carries the source-locale string (a bare string passes).
+        if (node.label !== undefined) entry.label = unwrapLocalized(node.label, sourceLocale)
         entry.records = walk(node.$children)
         out.push(entry)
         continue
@@ -404,7 +410,7 @@ export function folderToRecordsYml({ folderDoc, siteRoot, poolPathByUuid }) {
         // means the folder and the pool disagree, and writing the file without it
         // would quietly unpublish that record on the next push.
         warnings.push(
-          `records.yml: a folder leaf ("${node.path_segment ?? '?'}") references a record that ` +
+          `records.yml: a folder leaf ("${node.name ?? '?'}") references a record that ` +
             `was not written locally — the file was left unchanged rather than dropping it.`
         )
         return null
@@ -523,7 +529,7 @@ export function recordsToProject({ folderDoc, recordDocs = [], siteRoot, opts =
   //
   // The folder ENTITY still carries no `$uuid` we persist: the backend owns the
   // site's folder, keyed by the site-content uuid.
-  const records = folderToRecordsYml({ folderDoc, siteRoot, poolPathByUuid })
+  const records = folderToRecordsYml({ folderDoc, siteRoot, poolPathByUuid, sourceLocale })
   warnings.push(...records.warnings)
 
   // Flush localized record-field translations to locales/records/{locale}.json,