@uniweb/build 0.63.4 → 0.64.1

package/src/uwx/site.js

@@ -56,8 +56,7 @@ import {
   isIgnoredFolder,
   parseNumericPrefix,
   compareFilenames,
-  parseWildcardArray,
-  applyWildcardOrder,
+  orderFolders,
   processMarkdownFile,
   declaredFetch,
   checkDeclaration,
@@ -65,9 +64,11 @@ import {
   assertRouteFolder,
   mountEntriesOf,
   rootOrderConfig,
+  composeLocalizedRoute,
+  isValidSlugSegment,
 } from '../site/content-collector.js'
 import { refuseBinding, refuseUnder, refuseOutsideLanguage, warnDuplicateBindings } from '../site/data-fetcher.js'
-import { readLayoutFolder } from '../site/layout-folder.js'
+import { readLayoutFolder, layoutAreaRoute } from '../site/layout-folder.js'
 import { normalizeHideIn } from '../site/nav-visibility.js'
 import { resolveDefaultLocale, validateLanguageConfig, queryDataUrl } from '@uniweb/core'
 import { emitEntitySyncPackage } from './entity-document.js'
@@ -75,6 +76,8 @@ import { loadLocaleTranslations, localizeScalar, localizeScalarList, localizeCon
 import { unwrapLocalized } from './backfill.js'
 import { loadFreeformTranslation } from '../i18n/freeform.js'
 import { resolveLocaleList } from '../i18n/locales.js'
+import { translationContext, SITE_META_CONTEXT } from '../i18n/extract.js'
+import { splitOpenGraph, openGraphValue, seoBesideOpenGraph } from './open-graph.js'
 import { updateBackendState, readBackendState } from './sync-store.js'
 import { upsertYamlScalar } from './yaml-upsert.js'
 import { resolveQueriesConfig } from './queries-config.js'
@@ -142,6 +145,89 @@ function stripCredentials(block, label) {
 // processMarkdownFile only destructures type/component/preset/input/props/
 // fetch/data/id out of frontmatter, so `background:` and `theme:` stay
 // inside section.params — lift them into the entity type's dedicated fields.
+// The `type` a push sends for a section whose file names none — the Model requires one. A pull does
+// not write it back into a file that names none (`sectionRecordToFile`): absent, the foundation's
+// `defaultSection` renders it, which is not always `Content`.
+export const FILLED_SECTION_TYPE = 'Content'
+
+const AUTHORED_SLUG = Symbol('authoredSlug')
+const isPlainRecord = (v) => v !== null && typeof v === 'object' && !Array.isArray(v)
+
+/**
+ * Post-pass: a page's localized URL segments ride in its localized `slug`, beside the source one —
+ * the slot the site-content Model declares for them. From the form the site keeps them in, read as
+ * the build reads it (`buildRouteTranslations`): the pages' own `slug: { <locale>: <segment> }` when
+ * any page declares one, else `site.yml`'s `i18n.routeTranslations`, a whole route per locale, taken
+ * apart into each page's segment. ⛔ Until 2026-09-26 only the source slug was sent, so a clone lost
+ * every localized URL — measured on the `international` template, whose `/acerca-de` came back as
+ * `/about`.
+ *
+ * A route whose localized form is not its parent's plus one segment cannot be said per page, and is
+ * named rather than dropped in silence. Mutates the records in place.
+ */
+function localizeRouteSlugs(pages, siteYml, sourceLocale) {
+  const languages = Array.isArray(siteYml?.languages) ? new Set(siteYml.languages) : null
+  const carried = (locale, segment) =>
+    locale !== sourceLocale && (!languages || languages.has(locale)) && isValidSlugSegment(segment)
+  // Each page with the route the build gives it (`buildRouteOf`).
+  const visit = (records, parentRoute, fn) => {
+    for (const record of records || []) {
+      const route = buildRouteOf(record, parentRoute, sourceLocale)
+      fn(record, route, parentRoute)
+      visit(record.$children, route, fn)
+    }
+  }
+  let ownForm = false
+  visit(pages, '/', (record) => { if (record[AUTHORED_SLUG]) ownForm = true })
+  if (ownForm) {
+    visit(pages, '/', (record) => {
+      for (const [locale, segment] of Object.entries(record[AUTHORED_SLUG] || {})) {
+        if (carried(locale, segment)) record.slug[locale] = segment
+      }
+    })
+    return
+  }
+  const map = siteYml?.i18n?.routeTranslations
+  if (!isPlainRecord(map)) return
+  const segments = new Map() // canonical route → { locale: segment }, as the build composes them
+  visit(pages, '/', (record, route, parentRoute) => {
+    if (record.is_dynamic || record.is_index) return
+    for (const [locale, table] of Object.entries(map)) {
+      const display = isPlainRecord(table) ? table[route] : undefined
+      if (typeof display !== 'string') continue
+      const parts = display.split('/').filter(Boolean)
+      const segment = parts.pop()
+      if (`/${parts.join('/')}` !== composeLocalizedRoute(parentRoute, locale, segments)) {
+        console.warn(
+          `uwx/site: \`i18n.routeTranslations\` gives ${route} the ${locale} URL ${display}, which is not ` +
+            `its parent's plus one segment — it is not sent. Give the page \`slug: { ${locale}: … }\` instead.`
+        )
+        continue
+      }
+      if (!carried(locale, segment)) continue
+      record.slug[locale] = segment
+      segments.set(route, { ...(segments.get(route) || {}), [locale]: segment })
+    }
+  })
+}
+
+/**
+ * The route the build gives a page record: an index page takes its parent's, a parametric one is
+ * `:<param>` (`[...path]` is `:path*`), any other its slug under its parent. One rule, exported for the
+ * pull (`site-project.js`), which must address a page as the push does.
+ *
+ * @param {object} record - a page record (`slug`, `is_index`, `is_dynamic`)
+ * @param {string} parentRoute - its parent's route, `/` at the top
+ * @param {string} sourceLocale
+ * @returns {string}
+ */
+export function buildRouteOf(record, parentRoute, sourceLocale) {
+  if (record?.is_index) return parentRoute
+  const slug = unwrapLocalized(record?.slug, sourceLocale)
+  const segment = record?.is_dynamic ? (slug === CATCH_ALL_MARKER ? ':path*' : `:${slug}`) : slug
+  return parentRoute === '/' ? `/${segment}` : `${parentRoute}/${segment}`
+}
+
 // Post-pass: wrap every section's `content` (page sections + their `$children`,
 // recursing into child pages, plus layout sections) into per-locale form. Mutates
 // the records in place. Only called for multi-locale sites. Each target locale is
@@ -154,9 +240,13 @@ async function localizeContentTree(pages, layoutSections, sourceLocale, targetLo
 
   const localizeSection = async (record, page) => {
     if (!record.content) return
-    let localized = localizeContentDoc(record.content, sourceLocale, targetLocales, translations)
+    const stableId = record.stable_id || record.$id
+    // Resolved in the section's context, as the build resolves it (`translationContext`): a
+    // context-specific override applies here and nowhere else. ⛔ Until 2026-09-26 every section was
+    // resolved with none, so an override never reached a backend.
+    let localized = localizeContentDoc(record.content, sourceLocale, targetLocales, translations, translationContext({ stableId }, page?.route))
     if (page) {
-      const section = { stableId: record.stable_id || record.$id }
+      const section = { stableId }
       for (const locale of targetLocales) {
         // loadFreeformTranslation returns { content, frontmatter, … } — the doc is `.content`.
         const body = (await loadFreeformTranslation(section, page, locale, freeformBase))?.content
@@ -176,19 +266,38 @@ async function localizeContentTree(pages, layoutSections, sourceLocale, targetLo
       if (Array.isArray(s.$children)) await visitSections(s.$children, page)
     }
   }
-  const visitPages = async (pgs, routePrefix) => {
+  // A page is addressed by the route the build gives it (`buildRouteOf`): a free-form translation is
+  // looked up by it, and a translation's context names it. ⛔ Until 2026-09-26 this was the slug path,
+  // so a homepage was `home` where the build reads `/`, and its sections' free-form files were never sent.
+  const visitPages = async (pgs, parentRoute) => {
     for (const p of pgs || []) {
-      // `slug` is a localized `{lang:value}` map; the free-form route is the
-      // canonical (source-locale) path, so unwrap before building it.
-      const slug = unwrapLocalized(p.slug, sourceLocale)
-      const route = routePrefix ? `${routePrefix}/${slug}` : slug
+      const route = buildRouteOf(p, parentRoute, sourceLocale)
       const page = { route, id: p.stable_id }
+      localizePageMeta(p, route, sourceLocale, translations)
       if (Array.isArray(p.page_sections)) await visitSections(p.page_sections, page)
       if (Array.isArray(p.$children)) await visitPages(p.$children, route)
     }
   }
-  await visitPages(pages, '')
-  await visitSections(layoutSections, null) // layout sections have no free-form home
+  await visitPages(pages, '/')
+  // A layout area's section has its free-form home at the area's route, as the build reads it
+  // (`layoutAreaRoute`). ⛔ This said "layout sections have no free-form home" until 2026-09-26.
+  for (const s of layoutSections || []) await localizeSection(s, { route: layoutAreaRoute(s.layout_name, s.area || s.stable_id) })
+}
+
+// ⭐ A page's title, label, description and keywords are resolved in the page's context, as the
+// build translates them (`i18n/merge.js::translatePageMeta`, `<route>:_meta`): an override for one
+// page applies there and nowhere else. ⛔ Until 2026-09-26 they were resolved with no page, so an
+// override never reached a backend — nor, until the same day, an entry's default.
+function localizePageMeta(page, route, sourceLocale, translations) {
+  const context = { page: route, section: '_meta' }
+  const again = (value) =>
+    value && typeof value === 'object' && typeof value[sourceLocale] === 'string'
+      ? localizeScalar(value[sourceLocale], sourceLocale, translations, context)
+      : value
+  for (const key of ['title', 'label', 'description', 'og_title', 'og_description']) {
+    if (page[key] !== undefined) page[key] = again(page[key])
+  }
+  if (Array.isArray(page.keywords)) page.keywords = page.keywords.map(again)
 }
 
 function mapSectionData(section) {
@@ -198,7 +307,7 @@ function mapSectionData(section) {
   delete params.background
   delete params.theme
 
-  const data = { type: section.type || 'Content' } // entity type requires `type`
+  const data = { type: section.type || FILLED_SECTION_TYPE } // entity type requires `type`
   setIf(data, 'stable_id', section.stableId ?? undefined)
   setIf(data, 'preset', section.preset ?? undefined)
   setIf(data, 'input', section.input ?? undefined)
@@ -212,13 +321,13 @@ function mapSectionData(section) {
 }
 
 function buildPageData(config, ctx) {
-  const { slug, mode, isDynamic, paramName, isRoot, siteIndex, sourceLocale, translations, where } =
+  const { slug, mode, isDynamic, paramName, isRoot, siteIndex, sourceLocale, translations, where, pageFields } =
     ctx
   // The page `slug` is the localized route source — a `{lang: slug}` map (the
-  // site-content Model declares it localized; greenlit 2026-06-13). A single-locale
-  // site emits one entry (`{ en: "home" }`); per-locale slug overrides for
-  // multi-locale localized routes (from i18n.routeTranslations) are follow-on
-  // producer work. `mode` is the plain delivery mode.
+  // site-content Model declares it localized; greenlit 2026-06-13). The source
+  // entry is the folder name; the other locales' segments are added by
+  // `localizeRouteSlugs`, once the whole tree is known. `mode` is the plain
+  // delivery mode.
   const data = { slug: { [sourceLocale]: slug }, mode } // both required by the entity type
   setIf(data, 'stable_id', config.id)
   setIf(data, 'title', localizeScalar(config.title, sourceLocale, translations))
@@ -249,7 +358,13 @@ function buildPageData(config, ctx) {
   setIf(data, 'redirect', config.redirect)
   setIf(data, 'rewrite', config.rewrite)
   setIf(data, 'layout', config.layout)
-  setIf(data, 'seo', config.seo)
+  // ⭐ Its Open Graph title and description per language, where the deployment's page takes them
+  // (`uwx/open-graph.js`) — out of `seo`, which travels as one object. ⛔ Until 2026-09-26 they rode
+  // inside `seo` only, in the source language, though the build translates them.
+  const og = splitOpenGraph(config.seo, pageFields, sourceLocale, translations)
+  setIf(data, 'og_title', og.og_title)
+  setIf(data, 'og_description', og.og_description)
+  setIf(data, 'seo', og.seo)
   // ⭐ A `query:` or `fetch:` LIST means "fetch each" — one declaration per entry. Before
   // 2026-09-02 this kept `[0]` and dropped the rest silently, so the wire
   // carried one dataset for a page that asked for several.
@@ -351,21 +466,14 @@ async function orderedSubfolders(dirPath, inheritedMode, parentConfig) {
       order: typeof config.order === 'number' ? config.order : undefined,
     })
   }
-  // Mirror content-collector's pageFolders sort: explicit order, then
-  // numeric-prefix filename order.
-  folders.sort(
-    (a, b) =>
-      (a.order ?? Infinity) - (b.order ?? Infinity) ||
-      compareFilenames(a.dirName, b.dirName)
-  )
-  // Then the parent's `pages:` wildcard, exactly as a normal build applies it.
-  if (Array.isArray(parentConfig?.pages)) {
-    const parsed = parseWildcardArray(parentConfig.pages)
-    if (parsed && parsed.mode !== 'all') {
-      return applyWildcardOrder(folders, parsed)
-    }
-  }
-  return folders
+  // Explicit order, then numeric-prefix filename order, then the parent's `pages:` wildcard —
+  // one function, which the pull reproduces a level's order with too (`site-project.js`).
+  // ⚠️ It does NOT match the build's own page-folder sort in one case, and the note that said
+  // "mirror content-collector's pageFolders sort" here read as if it did: the collector compares
+  // a level's folder names whole, as strings, and matches `pages:` against them whole, where
+  // this strips a numeric prefix (`2-about` is `about`, and `10-` sorts after `2-`). Only a level
+  // with numbered page folders can tell them apart, and which rule is right for them is open.
+  return orderFolders(folders, parentConfig?.pages)
 }
 
 const DYNAMIC_RE = /^\[(.+)\]$/
@@ -630,7 +738,7 @@ const REPUBLISH_CLAUSE =
 // Recursively build the `pages` tree: each record carries its fields, its inline
 // `page_sections` (page mode only), and its child pages under `$children`.
 async function walkPagesNested(ctx, dirPath, parentSlugPath, inheritedMode, parentConfig, isRoot) {
-  const { siteRoot, siteIndex, sourceLocale, translations } = ctx
+  const { siteRoot, siteIndex, sourceLocale, translations, pageFields } = ctx
   const folders = await orderedSubfolders(dirPath, inheritedMode, parentConfig)
   const out = []
   // A folder inside a `[...path]` folder can never be reached, and `[dir]` /
@@ -664,11 +772,15 @@ async function walkPagesNested(ctx, dirPath, parentSlugPath, inheritedMode, pare
       siteIndex,
       sourceLocale,
       translations,
+      pageFields,
     })
     // `$id` is the stableId when authored (rename-stable), else the slug (the
     // natural handle — spec default). The path is NEVER the identity.
     const id = data.stable_id || slug
     const record = withIdentity(id, data)
+    // A page's own localized URL segments, for `localizeRouteSlugs` — under a symbol, so they
+    // are never serialized as a field of the record.
+    if (!dyn && isPlainRecord(f.config?.slug)) record[AUTHORED_SLUG] = f.config.slug
 
     if (mode === 'page') {
       const sections = await collectPageSectionsNested(f.path, siteRoot, f.config)
@@ -878,7 +990,9 @@ const DECL_EMITTED_ABOVE = new Set([
   'limit',
   'excerpt',
   'deferred',
-  'queryable'
+  'queryable',
+  // Derived by the rule above, never taken from a file.
+  'typed_by_data_key',
 ])
 
 const DECL_NOT_ON_WIRE = new Set([
@@ -920,7 +1034,7 @@ function externalSource(d) {
   return source
 }
 
-function queriesNested(declarations, uuids = null, scope = null, keyTyped = null) {
+function queriesNested(declarations, uuids = null, scope = null, keyTyped = null, queryFields = null) {
   const out = []
   for (const [name, d] of Object.entries(declarations)) {
     refuseUnder(d.where, `queries.${name}`)
@@ -939,8 +1053,13 @@ function queriesNested(declarations, uuids = null, scope = null, keyTyped = null
     // empty. The pull puts the author's `@/` back (`records-project.js::declarationsToQueriesYml`).
     // A query whose name-defaulted schema stands for the type of the data key of its name
     // names that type — the data schema its records are sent as (`data-key-types.js`).
-    const schema = (!d.schemaExplicit && keyTyped?.get(d.schema)) || d.schema
+    const typed = (!d.schemaExplicit && keyTyped?.get(d.schema)) || null
+    const schema = typed || d.schema
     setIf(data, 'schema', resolveSelfScope(schema, scope))
+    // ⭐ …AND SAYS SO, so a pull can tell the author's form (`team:`, no schema) from an explicit
+    // one — sent only where the deployment's `queries` Section declares the key (`GET /dev/config`
+    // → `siteContent.queryFields`), since one that does not refuses a push carrying it.
+    if (typed && Array.isArray(queryFields) && queryFields.includes('typed_by_data_key')) data.typed_by_data_key = true
     setIf(data, 'sort', d.sort)
     // Legacy `filter:` is not synced — it is translated to `where` upstream
     // (the canonical predicate). No legacy fields on the wire.
@@ -1136,7 +1255,7 @@ function secretsNested(provisioned) {
 // ROUND-TRIP LAW). `site-project.js::SETTINGS_TO_SITE_YML` plus its explicit
 // branches is the other half, and `producer-list-drift.test.js` fails if a key
 // emitted here has neither.
-function settingsNested(siteYml, { headHtml, themeYml, sourceLocale, translations } = {}) {
+function settingsNested(siteYml, { headHtml, themeYml, sourceLocale, translations, languages = null, settingsFields = null } = {}) {
   const settings = {}
 
   // Site-wide values an author declares once and references from page content as
@@ -1170,7 +1289,13 @@ function settingsNested(siteYml, { headHtml, themeYml, sourceLocale, translation
   // ⇒ `settings` is where they live. `publish_languages` rides VERBATIM, dangling
   // codes included: sync carries the full working set and only *publish* filters,
   // which preserves a locale's publish intent across a remove + re-add in `languages:`.
-  setIf(settings, 'languages', siteYml.languages)
+  // ⭐ A site that declares no `languages:` has the languages its translation files make — the build's
+  // rule (`i18n/locales.js`) — and sends that list (`languages`, below), as it sends a derived
+  // `deferred:`: a host may serve a site in the languages it declares and no others, and the site's
+  // localized URLs with them. The pull does not write it back where the files already say it
+  // (`siteContentDocumentToProject`). ⛔ Until 2026-09-26 only a declared list was sent, so the
+  // `international` template, which declares none, sent no language but its source.
+  setIf(settings, 'languages', siteYml.languages ?? languages ?? undefined)
   setIf(settings, 'default_language', siteYml.defaultLanguage)
   setIf(settings, 'publish_languages', siteYml.publishLanguages)
 
@@ -1179,7 +1304,12 @@ function settingsNested(siteYml, { headHtml, themeYml, sourceLocale, translation
   // (`core/src/seo.js`). Two of those are literally sitemap.xml columns. It only
   // ever passed the card test because `image` was inside it; the card's picture is
   // `info.preview` now.
-  setIf(settings, 'seo', siteYml.seo)
+  // The site's Open Graph title and description per language, where the deployment's `settings`
+  // takes them (`uwx/open-graph.js`), in the site's context (`SITE_META_CONTEXT`).
+  // (Each read inline from `siteYml.seo`, so the emit surface names its source.)
+  setIf(settings, 'og_title', openGraphValue(siteYml.seo, 'og_title', settingsFields, sourceLocale, translations, SITE_META_CONTEXT))
+  setIf(settings, 'og_description', openGraphValue(siteYml.seo, 'og_description', settingsFields, sourceLocale, translations, SITE_META_CONTEXT))
+  setIf(settings, 'seo', seoBesideOpenGraph(siteYml.seo, settingsFields))
   // ⭐ `keywords` IS seo by function — it renders into `<meta name="keywords">`
   // (`runtime/src/ssr-renderer.js`). It is top-level in site.yml for authoring
   // convenience, not because it is a different kind of thing. Localized, so it
@@ -1461,7 +1591,8 @@ export async function siteProjectToDocument(siteRoot, opts = {}) {
   // (uwx-format.md → info.url.)
 
   // `siteIndex` — the homepage — joins below, once the pages directory's own config is read.
-  const ctx = { siteRoot, sourceLocale, translations }
+  // …and the keys this deployment's page takes (`siteContent.pageFields`), for its Open Graph texts.
+  const ctx = { siteRoot, sourceLocale, translations, pageFields: opts.pageFields }
   // ⛔ ONE `paths:` CONVENTION, TWO READERS, AND THIS ONE IS A STRICT SUBSET.
   // The build honours sub-mounts — `paths: { pages/<segment>: <dir> }`, through
   // `resolveMounts`/`mountEntriesOf` in `site/content-collector.js` — and this
@@ -1506,6 +1637,7 @@ export async function siteProjectToDocument(siteRoot, opts = {}) {
     // — as the build does — pushed no homepage at all.
     const top = rootOrderConfig({ pages: siteYml.pages, index: siteYml.index }, rootConfig)
     pages = await walkPagesNested({ ...ctx, siteIndex: top.homepage }, pagesPath, '', rootMode, { pages: top.pages }, true)
+    localizeRouteSlugs(pages, siteYml, sourceLocale)
   }
 
   const layoutSections = await collectLayoutNested(layoutDir, siteRoot)
@@ -1539,7 +1671,9 @@ export async function siteProjectToDocument(siteRoot, opts = {}) {
   doc.$schema = SITE_MODEL_NAME
   doc.info = info
   // Emitted only when the file declares something — see `settingsNested`.
-  const settings = settingsNested(siteYml, { headHtml, themeYml, sourceLocale, translations })
+  // The languages the site's translation files make, for a site that declares none (`settingsNested`).
+  const languages = targetLocales.length > 0 ? [sourceLocale, ...targetLocales] : null
+  const settings = settingsNested(siteYml, { headHtml, themeYml, sourceLocale, translations, languages, settingsFields: opts.settingsFields })
   if (settings) doc.settings = settings
   doc.pages = pages
   doc.layout_sections = layoutSections
@@ -1552,7 +1686,7 @@ export async function siteProjectToDocument(siteRoot, opts = {}) {
   // ⚠️ `queriesNested` keeps its name. §2's rule: rename what an author or a
   // consumer sees, leave the identifier alone.
   const scope = opts.scope !== undefined ? opts.scope : await siteSelfScope(siteRoot)
-  doc.queries = queriesNested(colConfig.declarations, opts.queryUuids, scope, opts.keyTyped)
+  doc.queries = queriesNested(colConfig.declarations, opts.queryUuids, scope, opts.keyTyped, opts.queryFields)
   // Emitted ONLY when the file declares the key — see the header above
   // `serviceRecords`: on a replaced Section, absent and empty are different
   // requests and one of them is destructive.

package/src/uwx/sync-package.js

@@ -359,6 +359,11 @@ export async function emitSyncPackages(siteRoot, opts = {}) {
         // …and the same data schema, where a name stands for the type of its data key
         // (`@/team` → `@/member`, `data-key-types.js`): decided once, by the records.
         keyTyped: col.keyTyped,
+        // …and whether this deployment takes the key that says so (`siteContent.queryFields`) —
+        // and the page and `settings` keys that carry Open Graph texts per language.
+        ...(Array.isArray(opts.queryFields) ? { queryFields: opts.queryFields } : {}),
+        ...(Array.isArray(opts.pageFields) ? { pageFields: opts.pageFields } : {}),
+        ...(Array.isArray(opts.settingsFields) ? { settingsFields: opts.settingsFields } : {}),
         // Withhold the `$services`/`$secrets` Sections when the caller has
         // determined the file is not asking for anything new by them. Passed
         // through rather than decided here: the last-agreed state is project
@@ -517,6 +522,21 @@ export async function emitSyncPackages(siteRoot, opts = {}) {
   }))
   const changedRecords = recordChanged.filter((r) => r.changed)
 
+  // ⛔ A RECORD THAT LOST ITS IDENTITY IS NOT UNCHANGED. Its hash was banked for this backend,
+  // so a push to it succeeded — and wrote the record's `$uuid` into its file — yet it goes with no
+  // `$uuid` now: the line is gone from the file. Skipped as unchanged, the folder still named it,
+  // by `$ref`, and the backend refused a reference to a record the package does not carry
+  // (measured 2026-09-26); sent, it would be a second record. A pull writes it back.
+  const refusals = [...(col.refusals || [])]
+  for (const r of recordChanged) {
+    if (r.changed || r.entity.document.$uuid) continue
+    refusals.push(
+      `${r.entity.id}: its \`$uuid\` is gone from its file, though it was pushed to this backend ` +
+        'before — sent as it is, it would be a second record. Run `uniweb pull`, which writes it ' +
+        'back, then push.'
+    )
+  }
+
   let records = null
   // ⭐ A RECORD THAT NAMES A RECORD THIS PUSH CREATES names it by `$ref`
   // (`records.js::encodeReference`), and the backend stores the uuid it mints for it. The
@@ -572,6 +592,9 @@ export async function emitSyncPackages(siteRoot, opts = {}) {
   // banked is then, by construction, what was hashed. A future injection is covered
   // by adding one line here — not by finding every reader.
   const applied = {
+    ...(Array.isArray(opts.queryFields) ? { queryFields: opts.queryFields } : {}),
+    ...(Array.isArray(opts.pageFields) ? { pageFields: opts.pageFields } : {}),
+    ...(Array.isArray(opts.settingsFields) ? { settingsFields: opts.settingsFields } : {}),
     ...(assetRewrite ? { assetRewrite } : {}),
     ...(assetIds ? { assetIds } : {}),
     ...(injectInfo ? { injectInfo } : {}),
@@ -582,7 +605,7 @@ export async function emitSyncPackages(siteRoot, opts = {}) {
     siteContent, records, siteContentUuid, hashes, warnings, skipped,
     // Records that name a record this push creates — see `namesNew` above.
     namesNew,
-    refusals: col.refusals || [],
+    refusals,
     schemaless: col.schemaless, localAssets, applied,
     // { stamped, unknown } when identity was applied; null when the caller passed
     // no map. `unknown > 0` with `stamped === 0` on a site that has been pushed

package/src/validate-data.js

@@ -206,10 +206,19 @@ export async function validateDataInputs({ siteRoot, foundationPath }) {
         // (pass 2). A list root was deferred here until then, though the query's records
         // are exactly that list.
 
+        // ⭐ WHAT THE QUERY'S RECORDS ARE, for a key typed by a schema whose root is a list: the
+        // list's ITEMS when the query selects other records (`@/link` records feeding `@/menu`), but
+        // ENTITIES of the list schema — each holding a whole list — when the query names that schema
+        // itself (`menus: { schema: '@/menu' }`). ⛔ Until 2026-09-26 both were checked as items, so
+        // every query over a list schema failed ("missing required field '[0].label'") and a push,
+        // which gates on this check, stopped.
+        const decl = typeof input.query === 'string' ? config.queries?.[input.query] : null
+        const querySchema = decl ? decl.schema ?? keyTypes.get(input.query) ?? `@/${input.query}` : undefined
+
         const pairKey = `${input.path} ${ref}`
         let entry = work.get(pairKey)
         if (!entry) {
-          entry = { path: input.path, ref, schema, users: [] }
+          entry = { path: input.path, ref, schema, users: [], entities: querySchema === ref }
           work.set(pairKey, entry)
         }
         entry.users.push({ route: page.route, section: type, key })
@@ -234,10 +243,11 @@ export async function validateDataInputs({ siteRoot, foundationPath }) {
     schemasSeen.add(entry.ref)
     const items = Array.isArray(records) ? records : [records]
 
-    // A schema whose ROOT IS A LIST describes the whole value the key receives, and the
-    // query's records ARE that list — so they are checked once, as the list. Any other
-    // schema describes one record, checked per record.
-    if (rootListSection(entry.schema)) {
+    // A schema whose ROOT IS A LIST describes the whole value the key receives, and a query of
+    // other records delivers that list — so they are checked once, as the list. Any other
+    // schema describes one record, checked per record — and so are the entities of a list
+    // schema a query of that schema delivers, each holding its list (`validateItem`).
+    if (rootListSection(entry.schema) && !entry.entities) {
       recordCount += items.length
       const base = { file: entry.path, schema: entry.ref, users: entry.users }
       for (const finding of validateBound(entry.schema, items)) {