@uniweb/build 0.64.2 → 0.66.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.64.2",
+  "version": "0.66.0",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -57,15 +57,15 @@
     "js-yaml": "^4.1.0",
     "sharp": "^0.35.3",
     "yaml": "^2.5.0",
-    "@uniweb/schemas": "^0.7.2",
-    "@uniweb/content-reader": "^1.2.5",
     "@uniweb/content-writer": "^0.3.4",
-    "@uniweb/projections": "^0.7.4",
-    "@uniweb/semantic-parser": "^1.4.1",
-    "@uniweb/theming": "^0.1.15"
+    "@uniweb/content-reader": "^1.2.5",
+    "@uniweb/schemas": "^0.8.0",
+    "@uniweb/projections": "^0.7.6",
+    "@uniweb/theming": "^0.1.15",
+    "@uniweb/semantic-parser": "^1.4.1"
   },
   "optionalDependencies": {
-    "@uniweb/runtime": "^0.27.6"
+    "@uniweb/runtime": "^0.27.8"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0",
@@ -74,8 +74,8 @@
     "@tailwindcss/vite": "^4.0.0",
     "@vitejs/plugin-react": "^4.0.0 || ^5.0.0",
     "vite-plugin-svgr": "^4.0.0",
-    "@uniweb/runtime": "^0.27.6",
-    "@uniweb/core": "^0.30.1"
+    "@uniweb/runtime": "^0.27.8",
+    "@uniweb/core": "^0.32.0"
   },
   "peerDependenciesMeta": {
     "vite": {

package/src/i18n/records.js

@@ -24,7 +24,7 @@ import { loadFreeformRecord } from './freeform.js'
 import { resolveQueriesConfig, resolveRecordSchemas, foundationSchemaJson } from '../site/queries-config.js'
 import { dataKeyTypes, keyOfDefaultRef } from '../uwx/data-key-types.js'
 import { toDataSchemaDeclaration, isProseMirrorField, isOpenMapSection } from '../uwx/data-schema.js'
-import { toDeliveredRecord, contentBodyField, misplacedFields } from '@uniweb/schemas/conform'
+import { toDeliveredRecord, contentBodyField, misplacedFields, mergedFromStored, storedFromMerged } from '@uniweb/schemas/conform'
 import { resolveDocForLocale } from './merge.js'
 import { extractUnitsFromDoc } from './extract.js'
 import { flatFormRefusal, extractExcerpt } from '../site/query-processor.js'
@@ -361,10 +361,12 @@ function derivesExcerpt(record, whole, dataSchema, config) {
 /**
  * ⛔ A RECORD'S SYSTEM FIELDS ARE NEVER PROSE — never extracted, never translated, by
  * either path. A `$`-prefixed key at any depth is the system's (`$name`, the handle a
- * parametric page's URL names; `$uuid`), and a record's top-level `slug` and `path`
- * are its handle and its placement in `folder.yml`. Until 2026-09-14 they became
- * translation units, and a translation whose source happened to equal one rewrote it,
- * so a record's page stopped matching its URL.
+ * parametric page's URL names; `$uuid`; `$branch`, the folder a compiled list holds a
+ * record under), and a top-level `slug` is how a record's reader hands the file's name
+ * on. Until 2026-09-14 they became translation units, and a translation whose source
+ * happened to equal one rewrote it, so a record's page stopped matching its URL.
+ * ⛔ A top-level `path` was one too until 2026-09-27, when the placement it named moved to
+ * `$branch` [Diego]: a field an author names `path` is theirs, and translated as its schema says.
  *
  * @param {string|number} key - a field name (an array index is never one)
  * @param {boolean} topLevel - whether the key sits at the record's own level
@@ -372,7 +374,7 @@ function derivesExcerpt(record, whole, dataSchema, config) {
  */
 function isRecordSystemField(key, topLevel) {
   if (typeof key !== 'string') return false
-  return key.startsWith('$') || (topLevel && (key === 'slug' || key === 'path'))
+  return key.startsWith('$') || (topLevel && key === 'slug')
 }
 
 /**
@@ -392,7 +394,7 @@ function isProseMirrorDoc(value) {
 
 /**
  * Every ProseMirror document a record holds, with its path. ⭐ A markdown body is
- * delivered in its schema's content body field — `article_body.content` for
+ * delivered in its schema's content body field — `body.content` for
  * `@std/article` — and at `content` only for a record with no schema; a rich field can
  * sit anywhere else. ⛔ Until 2026-09-24 only `content` at the top was read, which is
  * where a delivered `@std/article` holds no body.
@@ -796,7 +798,7 @@ export async function extractRecordContent(siteRoot, options = {}) {
       // record whole beside its lean list, and a deferred field is exactly what the list
       // does not hold. ⛔ Until 2026-09-14 only the list was read, so a deferred body —
       // one derived from a schema's brief included — never reached the manifest.
-      const wholes = await wholeRecords(dataDir, queryName)
+      const wholes = await wholeRecords(dataDir, queryName, dataSchemas.get(queryName) ?? null)
       const extract = (item) => {
         const whole = wholes.get(recordHandle(item))
         const skip = derivesExcerpt(item, whole, dataSchemas.get(queryName), excerpts.get(queryName)) ? EXCERPT : null
@@ -847,15 +849,19 @@ async function recordFileNames(dataDir, queryName) {
 }
 
 /**
- * A query's per-record files (`recordFileNames`), each record whole, by its handle.
+ * A query's per-record files (`recordFileNames`), each record whole, by its handle — as the MERGED
+ * view this module walks (`mergedFromStored`): a file holds the record as stored, a key per
+ * section (2026-09-27), and translation reads a record with its brief's fields at the top.
  *
+ * @param {Object|null} [dataSchema] - the query's data schema; with none a file is read as it is
  * @returns {Promise<Map<string, Object>>}
  */
-async function wholeRecords(dataDir, queryName) {
+async function wholeRecords(dataDir, queryName, dataSchema = null) {
   const out = new Map()
   for (const name of await recordFileNames(dataDir, queryName)) {
     try {
-      const record = JSON.parse(await readFile(join(dataDir, queryName, name), 'utf-8'))
+      const stored = JSON.parse(await readFile(join(dataDir, queryName, name), 'utf-8'))
+      const record = dataSchema && isPlainObject(stored) ? mergedFromStored(dataSchema, stored) : stored
       if (isPlainObject(record)) out.set(recordHandle(record), record)
     } catch (err) {
       console.warn(`[i18n] Skipping ${queryName}/${name}: ${err.message}`)
@@ -890,7 +896,7 @@ async function pruneRecordFiles(recordsDir, dataDir, keep) {
 
 /**
  * Extract from a ProseMirror document — `field` is where the record holds it
- * (`content`, `article_body.content`), which each unit's `field` starts with.
+ * (`content`, `body.content`), which each unit's `field` starts with.
  */
 function extractFromProseMirrorDoc(doc, context, units, field = 'content') {
   // The units a page section's body makes (`extract.js::extractUnitsFromDoc`) — the keys translation
@@ -1043,13 +1049,18 @@ export async function buildLocalizedRecords(siteRoot, options = {}) {
         const wholes = new Map() // handle → { source, translated }
         for (const name of recordNames) {
           try {
-            const record = JSON.parse(await readFile(join(dataDir, queryName, name), 'utf-8'))
+            // ⭐ A record's file holds it AS STORED (2026-09-27); it is translated as the merged
+            // view and written back as stored (`mergedFromStored`, `storedFromMerged`).
+            const stored = JSON.parse(await readFile(join(dataDir, queryName, name), 'utf-8'))
+            const { dataSchema } = recordOptions
+            const record = dataSchema && isPlainObject(stored) ? mergedFromStored(dataSchema, stored) : stored
             const translatedRecord = isPlainObject(record)
               ? await translateItemAsync(record, recordDir, translations, schema, recordOptions)
               : record
             if (isPlainObject(record)) wholes.set(recordHandle(record), { source: record, translated: translatedRecord })
+            const written = dataSchema && isPlainObject(translatedRecord) ? storedFromMerged(dataSchema, translatedRecord) : translatedRecord
             await mkdir(localeRecordsDir, { recursive: true })
-            await writeFile(join(localeRecordsDir, name), JSON.stringify(translatedRecord, null, 2))
+            await writeFile(join(localeRecordsDir, name), JSON.stringify(written, null, 2))
           } catch (err) {
             console.error(`[i18n] Failed to translate ${queryName}/${name} for ${locale}: ${err.message}`)
             failures.push({ locale, file: `${queryName}/${name}`, message: err.message })
@@ -1265,7 +1276,6 @@ export async function translateRecordData(items, queryName, siteRoot, options =
 
   const one = !!items && typeof items === 'object' && !Array.isArray(items)
   if (!Array.isArray(items) && !one) return items
-  const records = one ? [items] : items
 
   const schema = await resolveSchema(queryName, siteRoot)
   const { poolDirs, schemas: dataSchemas, models, targets, excerpts } = await recordQueries(siteRoot)
@@ -1279,11 +1289,15 @@ export async function translateRecordData(items, queryName, siteRoot, options =
     targets,
     excerpt: excerpts.get(queryName),
   }
+  const { dataSchema } = recordOptions
+  // ONE record is a record's own file, which holds it AS STORED (2026-09-27): translated as the
+  // merged view, returned as stored (`mergedFromStored`, `storedFromMerged`).
+  const records = one ? [dataSchema ? mergedFromStored(dataSchema, items) : items] : items
 
   // A lean list's derived excerpt is derived from its record's translated body (`EXCERPT`).
   const wholes = new Map()
   if (!one) {
-    for (const [handle, record] of await wholeRecords(join(siteRoot, 'public', DATA_DIR), queryName)) {
+    for (const [handle, record] of await wholeRecords(join(siteRoot, 'public', DATA_DIR), queryName, dataSchema)) {
       wholes.set(handle, { source: record, translated: await translateItemAsync(record, recordDir, translations, schema, recordOptions) })
     }
   }
@@ -1291,7 +1305,8 @@ export async function translateRecordData(items, queryName, siteRoot, options =
     records.map((item) => translateItemAsync(item, recordDir, translations, schema, { ...recordOptions, whole: wholes.get(recordHandle(item)) }))
   )
 
-  return one ? translated[0] : translated
+  if (!one) return translated
+  return dataSchema && isPlainObject(translated[0]) ? storedFromMerged(dataSchema, translated[0]) : translated[0]
 }
 
 // ---------------------------------------------------------------------------

package/src/prerender.js

@@ -14,7 +14,6 @@ import { pathToFileURL } from 'node:url'
 import {
   resolveDefaultLocale,
   resolveFetchConfigs,
-  joinPathCapture,
   pageRouteQuery,
   routeSelection,
   routeParamValues,
@@ -24,7 +23,7 @@ import {
   deriveCacheKey,
   evaluateQuery,
 } from '@uniweb/core'
-import { recordTitle, routePatternToRegex } from '@uniweb/core/route-match'
+import { recordTitle, routePatternToRegex, routeFieldOf } from '@uniweb/core/route-match'
 import DataStore from '@uniweb/core/datastore'
 import { executeFetch, mergeDataIntoContent, toFetchList } from './site/data-fetcher.js'
 import { createFileTransport } from './site/file-transport.js'
@@ -258,6 +257,8 @@ export async function executeAllFetches(siteContent, siteDir, onProgress, locale
  * @param {Object} [stats] - receives `unrouted[route]`, the records with no param value
  * @param {Object} [options]
  * @param {Object|Array|null} [options.siteFetch] - the site's `fetch`, the last level of a route query
+ * @param {Object|null} [options.queries] - the site's `config.queries`: a route query that binds the
+ *   URL's last segment to a field (`where: { slug: ':slug' }`, `routeFieldOf`) is expanded by that field
  * @returns {Array} Expanded pages array with dynamic pages replaced by concrete instances
  */
 /**
@@ -295,7 +296,7 @@ export function localizeRedirectTarget(target, { website, locale, isDefault, rou
   return (website.basePath || '') + withSlash
 }
 
-export function expandDynamicPages(pages, fetched, onProgress = () => {}, stats = { unrouted: {} }, { siteFetch = null } = {}) {
+export function expandDynamicPages(pages, fetched, onProgress = () => {}, stats = { unrouted: {} }, { siteFetch = null, queries = null } = {}) {
   if (!stats.unrouted) stats.unrouted = {}
   const expandedPages = []
 
@@ -378,6 +379,8 @@ export function expandDynamicPages(pages, fetched, onProgress = () => {}, stats
 
     const items = data
     const key = route.key
+    // The field the route query binds the URL's last segment to, if any — else `[slug]` names `$name`.
+    const field = routeFieldOf(queries?.[route.config?.query ?? key])
 
     onProgress(`  Expanding ${page.route} → ${items.length} pages from ${key}`)
 
@@ -399,20 +402,21 @@ export function expandDynamicPages(pages, fetched, onProgress = () => {}, stats
       // value — the case the rule is for — gets exactly one page. Ruled 2026-09-12
       // [Diego]. ⛔ This read `item[paramName]` until 2026-09-11 and the whole array
       // until 2026-09-12, which baked `/tags/a%2Cb`, a URL no lane matches.
-      const values = routeParamValues(item, paramName)
+      const values = routeParamValues(item, paramName, field)
       if (values.length === 0) {
         unrouted += 1
         continue
       }
       for (const paramValue of values) {
 
-        // Create concrete route: /blog/:slug → /blog/my-post. Under `[...path]` the
-        // record's URL is its placement (the folder `folder.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
+        // Create concrete route: /blog/:slug → /blog/my-post, and the same under
+        // `[...path]`: a record carries no branch, so its own URL is its handle alone
+        // (ruled 2026-09-27 [Diego]), the URL its `$route` names (`fillRoutePattern`).
+        // ⛔ Until then this prefixed the record's `path`. ⛔ A FILE PATH, so decoded: the
+        // server decodes the request before looking the file up.
+        const capture = catchAll ? String(paramValue) : null
         const concreteRoute = catchAll
-          ? page.route.replace(new RegExp(`:${catchAll}\\*$`), capture)
+          ? page.route.replace(new RegExp(`:${catchAll}\\*$`), () => capture)
           : page.route.replace(`:${paramName}`, paramValue)
 
         // ⛔ TWO RECORDS, ONE ROUTE — normal the moment the route field is not
@@ -470,7 +474,7 @@ export function expandDynamicPages(pages, fetched, onProgress = () => {}, stats
     if (unrouted > 0) {
       stats.unrouted[page.route] = unrouted
       onProgress(
-        `  ⚠️ ${unrouted} of ${items.length} ${key} records have no "${paramName}" — no page was ` +
+        `  ⚠️ ${unrouted} of ${items.length} ${key} records have no "${paramName === 'slug' ? field || '$name' : paramName}" — no page was ` +
           `generated for them under ${page.route}`
       )
     }
@@ -893,6 +897,7 @@ export async function prerenderSite(siteDir, options = {}) {
       onProgress('Expanding dynamic routes...')
       siteContent.pages = expandDynamicPages(siteContent.pages, fetched, onProgress, undefined, {
         siteFetch: siteContent.config?.fetch ?? null,
+        queries: siteContent.config?.queries ?? null,
       })
 
       // ⭐ AN EXPANDED PAGE ASKS FOR WHAT ITS ROUTE BINDS — its branch's view, a `deferred:`

package/src/resolve-data-schema.js

@@ -38,6 +38,7 @@
 import { readFile } from 'node:fs/promises'
 import { existsSync, readdirSync, statSync } from 'node:fs'
 import { join, resolve, isAbsolute, extname, basename } from 'node:path'
+import { dataRefOf } from '@uniweb/core/data-keys'
 import { pathToFileURL } from 'node:url'
 import { createRequire } from 'node:module'
 import yaml from 'js-yaml'
@@ -105,8 +106,9 @@ export function collectSchemaRefs(components, foundationData = null) {
   const readData = (data) => {
     if (!data || typeof data !== 'object' || data === false) return
     for (const binding of Object.values(data)) {
-      const ref = typeof binding === 'string' ? binding : binding?.schema
-      if (typeof ref === 'string') refs.add(ref)
+      // `'@std/article/*'` asks for whole records of `@std/article` — the ref is what precedes it.
+      const { ref } = dataRefOf(binding)
+      if (ref) refs.add(ref)
     }
   }
   for (const meta of Object.values(components || {})) readData(meta?.data)

package/src/runtime-schema.js

@@ -25,7 +25,8 @@
  */
 
 import { isRichSchema } from '@uniweb/core'
-import { deliveredFields } from '@uniweb/schemas/conform'
+import { dataRefOf } from '@uniweb/core/data-keys'
+import { briefFieldMap, wholeFieldMap } from '@uniweb/schemas/conform'
 import { enumValues } from '@uniweb/schemas/format'
 
 /**
@@ -189,26 +190,22 @@ function normalizeRichSchemaValue(value) {
  * @returns {Object|null}
  */
 function leanDataSchema(value, dataSchemaMap) {
-  // Named ref → the resolved schema's fields.
-  const ref = typeof value === 'string'
-    ? value
-    : (value && typeof value.schema === 'string' ? value.schema : null)
+  // Named ref → the resolved schema's fields. `'@std/article/*'` asks for whole records of it.
+  const { ref, whole } = dataRefOf(value)
   if (ref) {
     const resolved = dataSchemaMap[ref]
-    // ⭐ THE DELIVERED RECORD'S FIELDS (`deliveredFields`) — the brief's at the top and each
-    // other section as one field under its name — so a default lands where the record
-    // a component receives carries its field: `@std/article`'s `status` inside
-    // `article_body`, as the records service delivers it (measured 2026-09-24). A section
-    // is filled only when the record holds it (`applySchemaToObject` recurses into what is
-    // there), so a list of briefs gains no section it was not sent.
+    // ⭐ THE FIELDS OF WHAT THE COMPONENT RECEIVES (ruled 2026-09-27 [Diego]): a brief's fields at
+    // the top (`briefFieldMap`), or, for `'@x/y/*'`, the whole record as stored — one field per
+    // section, the brief's included (`wholeFieldMap`) — so a default lands where the record carries
+    // its field: `@std/article`'s `status` inside `body`. A section is filled only when the record
+    // holds it (`applySchemaToObject` recurses into what is there).
     //
-    // ⛔ It was `flatRecordFields` until 2026-09-24 — the retired flat form, every single
-    // section's fields at the top — so on a delivered record those defaults landed beside
-    // the section they belong to. And before 2026-09-03 it read `resolved.fields`, which a
-    // sections-form schema does not have: no defaults at all. `dataSchemaMap` holds each
-    // schema normalized in its authored form (`fields:` or `sections:`), and only these
-    // readers say what one record of it looks like.
-    const fields = deliveredFields(resolved)
+    // ⛔ It was the merged `deliveredFields` until 2026-09-27 — the brief's fields beside the other
+    // sections' names, one map for two shapes; `flatRecordFields`, the retired flat form, until
+    // 2026-09-24; and before 2026-09-03 `resolved.fields`, which a sections-form schema does not
+    // have. `dataSchemaMap` holds each schema normalized in its authored form (`fields:` or
+    // `sections:`), and only these readers say what one record of it looks like.
+    const fields = whole ? wholeFieldMap(resolved) : briefFieldMap(resolved)
     if (!fields) return null
     const lean = extractSchemaFields(fields)
     return Object.keys(lean).length > 0 ? lean : null

package/src/site/data-fetcher.js

@@ -88,7 +88,7 @@ export function applyWhere(items, where) {
  * `@uniweb/core`'s `evaluateQuery`, the one order of work the runtime's default
  * fetcher uses too:
  *
- *   1. the query's set — `scope` over each record's placement (`path`), `where`,
+ *   1. the query's set — `scope` over the branch each record is held with (`$branch`), `where`,
  *      `sort`, `limit`;
  *   2. the fetch's `narrow` of it — `where` (and `match`), `sort`, `limit`.
  *

package/src/site/entity-pool.js

@@ -192,8 +192,8 @@ export function schemaForPoolDirs(dirs) {
  * ⛔ ONE IMPLEMENTATION AND ITS INVERSE, IN ONE PLACE, for the reason this file
  * exists at all: the reader derives a model from a path and the pull side derives
  * a path from a model, and if those two ever disagree a pulled record lands
- * somewhere the next build reads as a different schema. Same rule as
- * `deferredFromSchema` — a deriver and its recognizer must not be two copies.
+ * somewhere the next build reads as a different schema. A deriver and its
+ * recognizer must not be two copies.
  *
  * @param {string} schema - a ref: `@/name` or `@org/name`
  * @returns {string[]|null} the directory segments below `records/`, or null for

package/src/site/file-transport.js

@@ -72,8 +72,9 @@ export function createFileTransport({ siteRoot, distDir = null, publicDir = 'pub
       const body = await readFile(file, 'utf8')
       return response(body, path.endsWith('.json') ? 'application/json' : 'text/plain')
     }
-    // ⚖️ Not an error here. A page can ask for a per-record file a `deferred:` query never wrote,
-    // and the step reports the outcome so the caller can see it rather than crash a build.
+    // ⚖️ Not an error here. A page can ask for a per-record file that was never written — a
+    // record this run withholds as a draft, say — and the step reports the outcome so the caller
+    // can see it rather than crash a build.
     return missing(path)
   }
 }

package/src/site/queries-config.js

@@ -35,6 +35,7 @@ import { detectFoundationType, parseCatalogRef } from './foundation-ref.js'
 import { readRegisteredFoundation } from './registered-foundation.js'
 import { buildDataSchemaMap, SCHEMA_NOT_FOUND } from '../resolve-data-schema.js'
 import { resolveFoundationSrcPath } from '../utils/foundation-source-root.js'
+import { buildSchema } from '../schema.js'
 import { refuseQueryRoute, refuseLimit } from './data-fetcher.js'
 import { readFile } from 'node:fs/promises'
 import yaml from 'js-yaml'
@@ -174,8 +175,6 @@ export async function resolveQueriesConfig(siteRoot, opts = {}) {
     }
   }
 
-  await deriveDeferredFromSchemas(siteRoot, siteYml, declarations)
-
   // ⛔ `folderSync` AND `folders` WERE DELETED HERE, 2026-09-06. Both were
   // `collections.yml` survivors kept "for one step" while `records.yml` took
   // over, and both had become literals — `true` and `null` — that no longer
@@ -194,7 +193,7 @@ export async function resolveQueriesConfig(siteRoot, opts = {}) {
 }
 
 /** What a query over the site's records declares, which an external query cannot. */
-const SITE_RECORDS_ONLY = ['schema', 'model', 'scope', 'deferred', 'excerpt', 'path']
+const SITE_RECORDS_ONLY = ['schema', 'model', 'scope', 'excerpt', 'path']
 /** The keys of an external query's `record:` request. */
 const RECORD_KEYS = ['url', 'method', 'body', 'transform']
 
@@ -207,7 +206,7 @@ const RECORD_KEYS = ['url', 'method', 'body', 'transform']
  * `transform` (a dot-path to its records), `where` / `sort` / `limit` evaluated over
  * them, and `record:` — `{ url, method, body, transform }` — for one record on a
  * parametric page. What describes the site's records — `schema`, `scope`,
- * `deferred`, `excerpt` — is refused beside `url:`. ⛔ `detailUrl:` and `detail:` are
+ * `excerpt` — is refused beside `url:`. ⛔ `detailUrl:` and `detail:` are
  * retired everywhere: their one real case is `record.url`. ⛔ And `limit:` is a whole
  * number, 0 or more (`refuseLimit`).
  *
@@ -235,6 +234,17 @@ export function refuseQueryDeclaration(decl) {
         `on an external query — one with \`url:\`.`
     )
   }
+  // ⛔ `deferred:` IS RETIRED (2026-09-27 [Diego]: "the `deferred:` concept keeps getting in the way
+  // and doesn't match a hosted lane"). A list carries each record's brief, on every site, so a
+  // field a list should leave out belongs in a section of its own, outside the brief — where a
+  // host leaves it out too. `deferred:` only made a static site's lists differ from a hosted one's.
+  if (decl.deferred !== undefined) {
+    throw new Error(
+      `[uniweb] ${where}: \`deferred:\` is retired. A list carries each record's brief — the fields ` +
+        `of its schema's brief section — so a field a list should leave out belongs in a section of ` +
+        `its own, outside the brief. Remove the key.`
+    )
+  }
   refuseQueryRoute(decl, where)
   refuseLimit(decl.limit, where)
   // ⛔ `sync:` IS RETIRED (2026-09-21). `sync: false` kept a query's records off a
@@ -303,6 +313,11 @@ function refuseMethod(method, where) {
  * downstream. It is stripped here rather than at each consumer, so the payload
  * has one shape and no consumer has to know the field existed.
  *
+ * ⛔ `name` too: a declaration carries its query's name for the build's own messages, and
+ * `config.queries` is keyed by it — repeated inside, it was a second copy nothing read, and it
+ * held a key a declaration may want for something else [Diego, 2026-09-27]. Until then every
+ * query on the payload read `{ name: 'articles', … }` under `articles`.
+ *
  * Returns undefined for a site with no queries, so `config.queries`
  * stays absent rather than becoming an empty object — an empty object reads as
  * "declared, and empty" to anything checking for presence.
@@ -311,90 +326,14 @@ export function toConfigQueries(declarations) {
   const names = Object.keys(declarations || {})
   if (names.length === 0) return undefined
   const out = {}
-  for (const name of names) {
-    const { schemaExplicit, ...rest } = declarations[name]
-    out[name] = rest
+  for (const key of names) {
+    const { schemaExplicit, name, ...rest } = declarations[key]
+    out[key] = rest
   }
   return out
 }
 
 
-/**
- * Fill in `deferred:` from each collection's own data schema.
- *
- * ⭐ A schema's **brief** section already states what a record's summary is — the
- * card, the row, the thing a list shows. Everything else is wanted only when one
- * record is the focus. That is exactly what `deferred:` says, so an author with a
- * schema should not have to say it twice, in a second vocabulary, with nothing
- * checking the two against each other.
- *
- * ⇒ `deferred` = every top-level section of the schema other than its brief — the keys
- * a delivered record holds them under (`article_body` for `@std/article`), which is
- * exactly what a host's records service leaves out of a list and adds for `whole`.
- * ⛔ It was the flat form's fields minus the brief's until 2026-09-24; a delivered
- * record carries those under their section, so stripping them by name stripped nothing.
- *
- * Derived from the SCHEMA, never from a record. That is what keeps the
- * build-derived keys safe without a reserved list: `slug`, `route`, `path`,
- * `excerpt`, `image` and `lastModified` are not sections, so they are never
- * stripped. A markdown body goes where its content field is — inside `article_body`,
- * say — so it is deferred with that section.
- *
- * ⛔ Silent on every path that cannot answer, because none of them is an error:
- *
- *   - an author-declared `deferred:` wins outright — this never overrides one;
- *   - no local foundation (a linked or cataloged one), or it is unbuilt → nothing
- *     to read, and a site must still build;
- *   - the schema is not in the foundation's built map → the same soft-skip the
- *     sync lane already applies. `dist/meta/schema.json` carries the schemas
- *     COMPONENTS reference, so a collection whose schema no component binds is
- *     simply not there;
- *   - the schema has no brief, or only one section (`recordLayout`) → there is no
- *     lean shape to honour, so records stay whole.
- *
- * The last two are why this reads the built artifact rather than resolving
- * schemas itself: it is the same input the sync lane uses, so both lanes agree
- * about which schemas exist.
- */
-async function deriveDeferredFromSchemas(siteRoot, siteYml, declarations) {
-  const pending = Object.values(declarations).filter(
-    (d) => d.schema && !Array.isArray(d.deferred)
-  )
-  if (pending.length === 0) return
-
-  const dataSchemas = foundationDataSchemas(siteRoot, siteYml)
-  if (!dataSchemas) return
-
-  for (const decl of pending) {
-    const heavy = deferredFromSchema(dataSchemas[decl.schema])
-    if (heavy) decl.deferred = heavy
-  }
-}
-
-/**
- * The `deferred:` a schema implies — every top-level section but its **brief**, by name.
- *
- * ⛔ ONE IMPLEMENTATION, TWO CALLERS, and that is the point. `deriveDeferredFromSchemas`
- * above uses it to FILL an unstated `deferred:`; `uwx/records-project.js` uses it to
- * RECOGNIZE a derived value on the way back in, so a pull does not write a derivation
- * into the author's file as though they had typed it.
- *
- * ⚠️ A second copy would drift, and the drift would be invisible: the deriver and the
- * inverter would simply stop agreeing about which values are "the derived one", and the
- * pull would start persisting values it was written to drop.
- *
- * @param {object|undefined} schema a data schema, or undefined when it does not resolve
- * @returns {string[]|null} the implied deferred list, or null when the schema states no
- *   brief (a root list, say) or implies nothing heavy — in both cases there is no
- *   derivation to recognize
- */
-export function deferredFromSchema(schema) {
-  const layout = schema ? recordLayout(schema) : null
-  if (!layout || layout.flat || !layout.brief) return null
-  const heavy = layout.sections.map(([name]) => name).filter((name) => name !== layout.brief)
-  return heavy.length ? heavy : null
-}
-
 /**
  * The data schemas a site's records are shaped by, keyed by ref — each resolved from
  * the LOCAL foundation's SOURCE by the resolver its build uses (`buildDataSchemaMap`),
@@ -446,6 +385,30 @@ function localFoundationSrcDir(siteRoot, siteYml) {
   }
 }
 
+/**
+ * A site's foundation's section types, each with its `data:` — what types a query named for a data
+ * key (`uwx/data-key-types.js`). Read from the foundation's SOURCE when it is local, as
+ * `resolveRecordSchemas` reads its data schemas, so `pnpm dev` without a built foundation types a
+ * query as a production build does; else from its built or registered `schema.json`
+ * (`foundationSchemaJson`). Null when there is neither.
+ *
+ * @param {string} siteRoot
+ * @param {object} [siteYml] - an already-read site.yml
+ * @returns {Promise<object|null>}
+ */
+export async function foundationSections(siteRoot, siteYml = null) {
+  const yml = siteYml || (await readYamlFile(join(siteRoot, 'site.yml')))
+  const srcDir = localFoundationSrcDir(siteRoot, yml)
+  if (srcDir) {
+    try {
+      return await buildSchema(srcDir)
+    } catch {
+      // a foundation whose source does not read is reported by the build that builds it
+    }
+  }
+  return foundationSchemaJson(siteRoot, yml)
+}
+
 /** The data schemas a site's foundation declares, or null when unresolvable. */
 export function foundationDataSchemas(siteRoot, siteYml) {
   return foundationSchemaJson(siteRoot, siteYml)?.dataSchemas || null