@uniweb/build 0.44.5 → 0.46.0

package/src/site/query-processor.js

@@ -54,8 +54,8 @@ 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, fillRoutePattern } from '@uniweb/core'
-import { applyWhere, applySort } from './data-fetcher.js'
+import { DATA_DIR, fillRoutePattern, withoutRouteVariables } from '@uniweb/core'
+import { applyWhere, applySort, refuseUnder } from './data-fetcher.js'
 import { resolveAssetPath, walkContentAssets, isLocalAssetPath } from './assets.js'
 import { readEntityPool, groupPoolBySchema, ENTITIES_DIR } from './entity-pool.js'
 import { readRecordsConfig, resolveFolder, FOLDER_MISSING } from './records-config.js'
@@ -113,6 +113,7 @@ function parseQueryConfig(name, config) {
       schema: config,
       url: null,
       route: null,
+      scope: null,
       sort: null,
       where: null,
       filter: null,
@@ -122,6 +123,7 @@ function parseQueryConfig(name, config) {
     }
   }
 
+  refuseUnder(config.where, `queries.${name}`)
   return {
     name,
     // The query's schema selects its records from the pool — `entities/{schema}/`
@@ -129,6 +131,9 @@ function parseQueryConfig(name, config) {
     schema: config.schema || null,
     url: config.url || null,
     route: config.route || null,
+    // The folder branch the query reads (`records.yml` placement). ⛔ Not read
+    // here until 2026-09-11: a named query's `scope` was ignored on this lane.
+    scope: typeof config.scope === 'string' ? config.scope : null,
     sort: config.sort || null,
     // `where:` is the CANONICAL predicate; `filter:` is the deprecated string DSL
     // it replaced. Both are carried and both are applied below, in the same order
@@ -142,7 +147,7 @@ function parseQueryConfig(name, config) {
     },
     // `deferred:` lists fields that are heavy (article body, full nested
     // arrays). Those fields are stripped from the cascade payload that
-    // ships with `data: <name>` declarations, and per-record full files
+    // ships with `query: <name>` declarations, and per-record full files
     // are emitted at public/data/<name>/<slug>.json. Components that
     // need the full record fetch the per-record file on demand, either
     // automatically on dynamic-route pages (entity-store routes the
@@ -673,6 +678,19 @@ async function collectItems(siteDir, config, entitiesDir, basePath) {
   // Filter out nulls (unpublished items)
   items = items.filter(Boolean)
 
+  // ⭐ `$name` IS THE RECORD HANDLE ON EVERY SITE (ruled 2026-09-11 [Diego]) — the
+  // field a `[slug]` or `[...path]` page matches, and the one the records service
+  // serves. It is the record's FINAL slug: set here, after every format has been
+  // read and flattened, so a frontmatter `slug:` (which wins over the filename),
+  // a BibTeX cite key and an array-form file's own `slug` all count — exactly what
+  // our sync sends as the entry's name (`uwx/entity-source.js`). `slug` stays:
+  // foundations and templates read it.
+  items = items.map((item) => (
+    item && typeof item === 'object' && item.slug !== undefined && item.slug !== null && item.slug !== ''
+      ? { ...item, $name: String(item.slug) }
+      : item
+  ))
+
   warnDuplicateSlugs(items, config.name)
 
   // `route:` on the query — bake each record's canonical href.
@@ -711,8 +729,19 @@ async function collectItems(siteDir, config, entitiesDir, basePath) {
   // the sync wire, stored — and never applied, while the DEPRECATED one it replaced
   // worked. An author following current guidance got silence and shipped unfiltered
   // data. Pinned by `tests/collection-query-terms.test.js`.
-  if (config.where) {
-    items = applyWhere(items, config.where)
+  // ⭐ ONLY THE `where` FIXED FOR EVERY PAGE. A clause bound to the route —
+  // `where: { tag: :dir }` — cannot be applied to a file written once for every
+  // page; the runtime binds it per page (`@uniweb/core/fetch-config`,
+  // `resolveQuerySource`). ⛔ Until 2026-09-11 it was applied here to the literal
+  // `':dir'`, and the query compiled to no records (measured).
+  //
+  // ⛔ `scope` is NEVER baked, fixed or routed. The runtime applies the one that
+  // wins — a page fetch's own, else this query's — which is what the records
+  // service does. Baked here, a page's `scope:` could only narrow inside the
+  // query's branch on a static site and would replace it on a hosted one.
+  const fixed = withoutRouteVariables({ where: config.where })
+  if (fixed.where) {
+    items = applyWhere(items, fixed.where)
   }
 
   // Apply sort
@@ -884,7 +913,7 @@ export async function writeQueryFiles(siteDir, byQuery, queriesConfig = null) {
     if (deferred && deferred.length > 0) {
       // `deferred:` is set — emit two payloads:
       //   1. The cascade JSON at /data/<name>.json with deferred fields stripped.
-      //      This is what `data: <name>` declarations deliver everywhere.
+      //      This is what `query: <name>` declarations deliver everywhere.
       //   2. Per-record full files at /data/<name>/<slug>.json with every field.
       //      Dynamic-route singular fetches and useEntityDetail hooks read these.
       const recordsDir = join(dataDir, name)

package/src/uwx/emit-surface.json

@@ -62,7 +62,7 @@
         ],
         "fetch": [
           "site.yml::fetch",
-          "site.yml::data"
+          "site.yml::query"
         ],
         "fetcher": [
           "site.yml::fetcher"

package/src/uwx/project-writer.js

@@ -19,15 +19,22 @@ import { parseFrontmatter } from './entity-source.js'
 import { renderEntityDocument } from './backfill.js'
 import { queriesYmlPath } from './queries-config.js'
 import { recordsYmlPath } from '../site/records-config.js'
+import { DECLARATION_KEYS } from '../site/fetch-shapes.js'
 
 // Frontmatter keys that belong to the CCA framework / the developer's local
 // authoring, not to externally-editable params. On a section write an existing
 // reserved key is preserved and never overwritten by incoming params, so a
 // projection doesn't churn fields it didn't author (the surgical-update bar).
+//
+// ⭐ The declaration keys — `query`, `fetch`, and the retired `data` — are one
+// group: a section that declares its data locally, under any of them, keeps that
+// declaration, and an incoming one under a different key does not land beside it
+// (a file holding two is refused by the build).
 export const DEFAULT_RESERVED_FRONTMATTER = new Set([
   'type',
   'preset',
   'input',
+  'query',
   'fetch',
   'data',
   'nest',
@@ -168,6 +175,7 @@ export function writeSectionFile({ filePath, content, params, reserved = DEFAULT
   const { frontmatter, body: existingBody } = parseFrontmatter(existing, filePath)
 
   const nextFrontmatter = { ...frontmatter }
+  const declaresLocally = DECLARATION_KEYS.some((k) => k in frontmatter)
   if (params) {
     for (const [key, value] of Object.entries(params)) {
       // A reserved key is preserved only when it already exists locally (the
@@ -175,6 +183,7 @@ export function writeSectionFile({ filePath, content, params, reserved = DEFAULT
       // there is nothing to protect, so the incoming value fills it — that's
       // how a newly-projected section gets its `type`/`nest`/etc.
       if (reserved.has(key) && key in frontmatter) continue
+      if (reserved.has(key) && DECLARATION_KEYS.includes(key) && declaresLocally) continue
       if (value === null || value === undefined) delete nextFrontmatter[key]
       else nextFrontmatter[key] = value
     }
@@ -186,11 +195,12 @@ export function writeSectionFile({ filePath, content, params, reserved = DEFAULT
 
 // Shallow-merge `changes` into a YAML config file and write idempotently. A key
 // whose value is null/undefined is deleted; an object value is shallow-merged one
-// level deep (so partial `theme` / `build` updates don't drop sibling keys); any
-// other value replaces. NOTE: this re-dumps the file, so author comments/order are
-// not preserved — acceptable for machine-owned config, but comment-preserving
-// merges for hand-authored config files are a quality bar to revisit.
-function mergeYamlConfig(filePath, changes) {
+// level deep (so partial `theme` / `build` updates don't drop sibling keys) unless
+// the key is in `replace`; any other value replaces. NOTE: this re-dumps the file,
+// so author comments/order are not preserved — acceptable for machine-owned
+// config, but comment-preserving merges for hand-authored config files are a
+// quality bar to revisit.
+function mergeYamlConfig(filePath, changes, { replace = [] } = {}) {
   let existing = {}
   try {
     existing = yaml.load(readFileSync(filePath, 'utf8')) || {}
@@ -200,7 +210,7 @@ function mergeYamlConfig(filePath, changes) {
   for (const [key, value] of Object.entries(changes)) {
     if (value === null || value === undefined) {
       delete existing[key]
-    } else if (typeof value === 'object' && !Array.isArray(value)) {
+    } else if (typeof value === 'object' && !Array.isArray(value) && !replace.includes(key)) {
       existing[key] = { ...(existing[key] || {}), ...value }
     } else {
       existing[key] = value
@@ -212,10 +222,15 @@ function mergeYamlConfig(filePath, changes) {
 /**
  * Merge `config` into `site.yml` (shallow). Preserves keys not present in the
  * update (foundation, base, paths, …).
+ *
+ * ⛔ The declaration keys (`query` / `fetch` / `data`) are written WHOLE, never
+ * merged: a declaration is one value, and merging an incoming `fetch:` into the
+ * local one kept whatever key the remote no longer has — a stale `limit` survived
+ * every pull.
  * @returns {'updated'|'unchanged'}
  */
 export function writeSiteConfig(siteRoot, config) {
-  return mergeYamlConfig(join(siteRoot, 'site.yml'), config)
+  return mergeYamlConfig(join(siteRoot, 'site.yml'), config, { replace: DECLARATION_KEYS })
 }
 
 /**

package/src/uwx/site-project.js

@@ -39,7 +39,7 @@ import { createHash } from 'node:crypto'
 import yaml from 'js-yaml'
 import { writeSiteConfig, writeThemeFile, writeIfChanged, writeSectionFile, writeMergedYaml } from './project-writer.js'
 import { declarationsToQueriesYml } from './records-project.js'
-import { authorableFetch } from '../site/fetch-shapes.js'
+import { authorableDeclaration, DECLARATION_KEYS } from '../site/fetch-shapes.js'
 import { createTranslationCollector, writeLocaleTranslations, writeFreeformTranslations, unwrapLocalizedContent } from './locale-sync.js'
 import { buildFreeformPath } from '../i18n/freeform.js'
 import { unwrapLocalized, unwrapLocalizedList } from './backfill.js'
@@ -138,8 +138,8 @@ const INFO_TO_SITE_YML = {
   // Authored-only, like `submit` and `assistant`: a host's tracking endpoint is
   // offered through `config.services.tracking` and resolved at render, so it
   // never enters `info` and a pull cannot launder it into authored config.
-  // ⛔ `data` IS NOT VERBATIM — see the explicit branch below. It projects to
-  // `site.yml::fetch`, not `site.yml::data`.
+  // ⛔ The site's declaration is not verbatim — see the explicit `settings.fetch`
+  // branch below: it projects to `site.yml::query` or `site.yml::fetch`.
   template: 'template',
   // ⭐ `tags` — authored, non-localized tokens; the filter facet for a list of site
   // cards. Round-trips verbatim like any authored list.
@@ -199,6 +199,16 @@ const SETTINGS_TO_SITE_YML = {
 }
 
 
+/** An authored YAML config as it stands, or null when there is none to read. */
+function readAuthoredYaml(filePath) {
+  try {
+    const value = yaml.load(readFileSync(filePath, 'utf8'))
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null
+  } catch {
+    return null
+  }
+}
+
 /**
  * Project a site-content document's `info` (+ `extensions`) onto the site's
  * config files: `site.yml`, `theme.yml`, and `head.html`. Idempotent; only the
@@ -238,22 +248,21 @@ export function siteInfoToConfig({ document, siteRoot, sourceLocale = LOCALIZED_
     if (info[infoKey] !== undefined) siteChanges[ymlKey] = info[infoKey]
   }
 
-  // ⭐ `settings.fetch` → `site.yml::fetch`.
-  //
-  // `data:` is the authoring SHORTHAND for `fetch:` and the wire carries the
-  // desugared form, so `fetch:` is the key that describes what came back. The page
-  // lane has always projected this way (`y.fetch = authorableFetch(record.fetch)`);
-  // the site lane wrote `data:` verbatim, so an author who typed `fetch:` pushed,
-  // pulled, and got a `data:` block back — the value survived and the authored key
-  // did not, which the round-trip law forbids (uwx-format.md).
+  // ⭐ `settings.fetch` → `site.yml::query` or `site.yml::fetch` — the key the file
+  // already uses, else `query:` when the declaration is nothing but query names
+  // (`authorableDeclaration`). The wire carries the desugared form and cannot say
+  // which was typed, and the round-trip law keeps the authored KEY as well as the
+  // value (the sync format's round-trip law): the site lane once wrote the shorthand back verbatim,
+  // so an author who typed `fetch:` pushed, pulled, and got the shorthand back.
+  // The other declaration keys are removed, so the file never holds two (the
+  // build refuses that) — a retired `data:` included.
   //
   // ⛔ The producer always desugars, so the wire carries a config or a list of them —
   // never a bare string. Nothing here accommodates an older shape.
   const wireFetch = settingsSection.fetch
   if (wireFetch !== undefined) {
-    siteChanges.fetch = Array.isArray(wireFetch)
-      ? wireFetch.map((f) => authorableFetch(f))
-      : authorableFetch(wireFetch)
+    const { key, value } = authorableDeclaration(wireFetch, readAuthoredYaml(join(siteRoot, 'site.yml')))
+    for (const k of DECLARATION_KEYS) siteChanges[k] = k === key ? value : null
   }
 
   // The `settings` Section — authored configuration that is not identity, so it is
@@ -409,8 +418,13 @@ export function sectionRecordToFile({ filePath, record, sourceLocale = LOCALIZED
   if (theme_override !== undefined) frontmatter.theme = theme_override
   if (preset !== undefined) frontmatter.preset = preset
   if (input !== undefined) frontmatter.input = input
-  // Invert the build's resolution rather than copy it — see fetch-shapes.js.
-  if (fetch !== undefined) frontmatter.fetch = authorableFetch(fetch)
+  // Invert the build's resolution rather than copy it — see fetch-shapes.js. A new
+  // file gets `query:` for a declaration of names alone; a section that declares
+  // its data locally keeps it (`writeSectionFile`, the declaration keys).
+  if (fetch !== undefined) {
+    const { key, value } = authorableDeclaration(fetch)
+    frontmatter[key] = value
+  }
   if (stable_id !== undefined) frontmatter.id = stable_id
 
   const body = insets ? reinlineInsets(sourceContent, insets) : sourceContent
@@ -496,10 +510,13 @@ export function pageSectionsToFiles({ pageDir, pageSections, ctx, pageContext })
 // page.yml/folder.yml. On a merge write these are replaced wholesale (a managed
 // key the record no longer carries is dropped); any other key is author-authored
 // and preserved. Keep in sync with pageRecordToYml below.
+// ⚠️ `query` and `data` are managed with `fetch`: the declaration is written under
+// ONE key (`authorableDeclaration`), so the other two — a retired `data:`
+// included — are dropped rather than left beside it.
 const PAGE_YML_MANAGED_KEYS = new Set([
   'id', 'title', 'description', 'label', 'keywords', 'index', 'hidden',
   'hideIn', 'knowledge', 'trackSections', 'redirect', 'rewrite', 'layout', 'seo',
-  'fetch', 'sections',
+  'query', 'fetch', 'data', 'sections',
 ])
 
 // Inverse of site.js buildPageData → the `page.yml` / `folder.yml` object.
@@ -507,7 +524,7 @@ const PAGE_YML_MANAGED_KEYS = new Set([
 // directory (name, page.yml vs folder.yml, `[param]/`), not the config body.
 // Identity (the backend uuid) is NOT written here — it lives in the gitignored
 // `.uniweb/` index so authored files stay clean.
-function pageRecordToYml(record, sectionsArray, sourceLocale) {
+function pageRecordToYml(record, sectionsArray, sourceLocale, existing = null) {
   const y = {}
   if (record.stable_id !== undefined) y.id = record.stable_id
   const title = unwrapLocalized(record.title, sourceLocale)
@@ -531,8 +548,12 @@ function pageRecordToYml(record, sectionsArray, sourceLocale) {
   if (record.rewrite !== undefined) y.rewrite = record.rewrite
   if (record.layout !== undefined) y.layout = record.layout
   if (record.seo !== undefined) y.seo = record.seo
-  // Invert the build's resolution rather than copy it — see fetch-shapes.js.
-  if (record.fetch !== undefined) y.fetch = authorableFetch(record.fetch)
+  // Invert the build's resolution rather than copy it — see fetch-shapes.js. Under
+  // the key the file already uses (`existing`), else `query:` for names alone.
+  if (record.fetch !== undefined) {
+    const { key, value } = authorableDeclaration(record.fetch, existing)
+    y[key] = value
+  }
   // `sections:` exists to preserve ORDER and NESTING, which the projected filenames
   // can't carry (they're `<stableId>.md`, with no numeric prefix). It must not also
   // decide MEMBERSHIP — and a bare list does: the collector reads a list without
@@ -635,7 +656,7 @@ function writePagesTree(pages, pagesDir, sourceLocale, report, ctx, routePrefix
     const ymlPath = join(pageDir, ymlName)
     // Merge (not full-dump) so author-added keys survive a pull; the projector
     // owns only PAGE_YML_MANAGED_KEYS.
-    writeMergedYaml(ymlPath, pageRecordToYml(record, sectionsArray, sourceLocale), PAGE_YML_MANAGED_KEYS)
+    writeMergedYaml(ymlPath, pageRecordToYml(record, sectionsArray, sourceLocale, readAuthoredYaml(ymlPath)), PAGE_YML_MANAGED_KEYS)
     report.pages.push(ymlPath)
 
     writePagesTree(record.$children || [], pageDir, sourceLocale, report, ctx, route)

package/src/uwx/site.js

@@ -39,7 +39,7 @@
 
 import { readdir, readFile } from 'node:fs/promises'
 import { existsSync } from 'node:fs'
-import { join, parse } from 'node:path'
+import { join, parse, relative } from 'node:path'
 import {
   readYamlFile,
   readFolderConfig,
@@ -52,8 +52,12 @@ import {
   parseWildcardArray,
   applyWildcardOrder,
   processMarkdownFile,
-  fetchFromDataShorthand,
+  declaredFetch,
+  checkDeclaration,
+  fetchFromQueryShorthand,
+  assertRouteFolder,
 } from '../site/content-collector.js'
+import { refuseUnder } from '../site/data-fetcher.js'
 import { normalizeHideIn } from '../site/nav-visibility.js'
 import { resolveDefaultLocale, validateLanguageConfig, queryDataUrl } from '@uniweb/core'
 import { emitEntitySyncPackage } from './entity-document.js'
@@ -194,7 +198,7 @@ function mapSectionData(section) {
 }
 
 function buildPageData(config, ctx) {
-  const { slug, mode, isDynamic, paramName, isRoot, siteIndex, sourceLocale, translations } =
+  const { slug, mode, isDynamic, paramName, isRoot, siteIndex, sourceLocale, translations, where } =
     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
@@ -232,10 +236,16 @@ function buildPageData(config, ctx) {
   setIf(data, 'rewrite', config.rewrite)
   setIf(data, 'layout', config.layout)
   setIf(data, 'seo', config.seo)
-  // ⭐ A `data:` LIST means "fetch each" — one declaration per entry. Before
+  // ⭐ 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.
-  let fetch = config.fetch ?? fetchFromDataShorthand(config.data)
+  // `fetch:`, or the `query:` shorthand, read and refused exactly as the build
+  // reads them (`declaredFetch`) — a `folder.yml` as much as a `page.yml`.
+  let fetch = declaredFetch(config, where ?? 'page.yml')
+  // `where: { path: { under } }` is refused here as the build refuses it
+  // (`parseFetchConfig`): a site that cannot build must not sync either. A
+  // section's fetch is refused where the collector parses it.
+  for (const one of [fetch].flat()) refuseUnder(one?.where, 'fetch')
   // Resolve the authored `query:` shorthand to the runtime-fetchable
   // `path: /data/<name>.json` (the static convention the default-fetcher uses).
   // A shell/backend-hosted site renders client-side with NO prerender, so the
@@ -243,7 +253,7 @@ function buildPageData(config, ctx) {
   // it would never resolve at render (the static build resolves it the same way
   // in site/data-fetcher.js parseFetchConfig). The gateway serves the collection
   // at `<base>/data/<name>.json`.
-  // ⛔ **Mapped, not read.** A `data:`/`fetch:` LIST reaches here as an array, and
+  // ⛔ **Mapped, not read.** A `query:`/`fetch:` LIST reaches here as an array, and
   // `fetch.query` on one is `undefined` — so a property test would skip the
   // resolution below and put bare `{ query }` entries on the wire with no
   // `path`, no `as` and no `schema`. That is the silent-empty class: a payload
@@ -548,14 +558,20 @@ async function walkPagesNested(ctx, dirPath, parentSlugPath, inheritedMode, pare
   const { siteRoot, siteIndex, sourceLocale, translations } = ctx
   const folders = await orderedSubfolders(dirPath, inheritedMode, parentConfig)
   const out = []
+  // A folder inside a `[...path]` folder can never be reached, and `[dir]` /
+  // `[path]` would name a route variable — refused here as the collector refuses
+  // them, so a site that cannot build cannot sync either (ruled 2026-09-11).
+  const insideCatchAll = (parentSlugPath || '').split('/').includes(CATCH_ALL_MARKER)
   for (let i = 0; i < folders.length; i++) {
     const f = folders[i]
+    assertRouteFolder(f.dirName, insideCatchAll ? '/:path*' : '/')
     const dyn = f.dirName.match(DYNAMIC_RE)
     const slug = dyn ? dyn[1] : f.name
     const mode = f.source === 'folder.yml' ? 'folder' : 'page'
     const slugPath = parentSlugPath ? `${parentSlugPath}/${slug}` : slug
 
     const data = buildPageData(f.config, {
+      where: relative(siteRoot, join(f.path, f.source)),
       slug,
       mode,
       isDynamic: !!dyn,
@@ -803,6 +819,7 @@ const DECL_NOT_ON_WIRE = new Set([
 function queriesNested(declarations, uuids = null, org = null) {
   const out = []
   for (const [name, d] of Object.entries(declarations)) {
+    refuseUnder(d.where, `queries.${name}`)
     const data = {}
     const source = d.path ? { path: d.path } : d.url ? { url: d.url } : d.source
     setIf(data, 'source', source)
@@ -1068,10 +1085,15 @@ function settingsNested(siteYml, { headHtml, themeYml, sourceLocale, translation
   // summarized.
   setIf(settings, 'agents', siteYml.agents)
 
-  // ⭐ The site-level fetch, DESUGARED and under its real name. `data:` is the
+  // ⭐ The site-level fetch, DESUGARED and under its real name. `query:` is the
   // authoring shorthand for `fetch:` and every other tier already calls the wire
-  // field `fetch`; the site tier called it `data` until 2026-09-09.
-  setIf(settings, 'fetch', siteYml.fetch ?? fetchFromDataShorthand(siteYml.data))
+  // field `fetch`; the site tier's wire field was `data` until 2026-09-09.
+  // `query:` / `fetch:` checked as the build checks them, and `under` refused;
+  // the `query:` shorthand carries no `where`. ⚠️ The desugaring stays inline in
+  // `setIf`: `gen-emit-surface.mjs` reads the published key's sources off it.
+  checkDeclaration(siteYml, 'site.yml')
+  for (const one of [siteYml.fetch].flat()) refuseUnder(one?.where, 'site.yml fetch')
+  setIf(settings, 'fetch', siteYml.fetch ?? fetchFromQueryShorthand(siteYml.query))
 
   // ⭐ The SITE TIER of framework's own `{name, hide, params}` layout object, which
   // the page and folder tiers have always had. `hide` is a non-destructive per-area
@@ -1249,15 +1271,6 @@ export async function siteProjectToDocument(siteRoot, opts = {}) {
   // endpoint; here it leaves the site with the RIGHT answer.
   //
   // The provisioned record rides the `$services` section instead (see servicesNested).
-  // ⭐ DESUGARED, like every other tier. `data:` is the shorthand for `fetch:`
-  // (`data: articles` → `{ query: 'articles' }`), and the page level has always
-  // desugared before emitting. The site level shipped the bare string until
-  // 2026-09-09, so `info.data` carried two different shapes depending on which
-  // key the author happened to type.
-  //
-  // 📌 The wire NAME is still `data` and becomes `fetch` when the Section moves —
-  // renaming it now would be a second destructive wire change for a cosmetic gain;
-  // renaming it during the move is free.
   // ⛔ THE CONFIGURATION KEYS ARE NOT HERE — they ride the `settings` Section
   // (`settingsNested` above). `info` is the BRIEF: what a card or a select dropdown
   // renders, plus what a listing can filter on. Eighteen keys moved off it on

package/src/validate-data.js

@@ -54,7 +54,7 @@ import { processQueries } from './site/query-processor.js'
  * agree on which schema governs what by construction.
  *
  * Inputs are consumed from what the canonical build parsers already compute —
- * `section.fetch` (the binding resolved from `data:` / `fetch:`) and
+ * `section.fetch` (the binding resolved from `query:` / `fetch:`) and
  * `schema.json[type].data` (the key→ref bindings). Re-deriving either would let
  * this command and the build disagree about what feeds what.
  *
@@ -139,7 +139,7 @@ export async function validateDataInputs({ siteRoot, foundationPath }) {
               `but this page delivers ${delivered.map((k) => `\`${k}\``).join(', ')}. ` +
               `The section will render with no data and nothing else will say so. ` +
               `Name the query for the key the section reads, or give the section its own ` +
-              `\`fetch: { query: <name> }\`.`,
+              `\`query: <name>\`.`,
             // One user per declared key, so `uniweb validate` can print
             // `used by /team › Team › data.team` — the key is the thing to rename.
             users: declaredKeys.map((k) => ({ route: page.route, section: type, key: k })),
@@ -479,7 +479,7 @@ async function loadStandardSchemas() {
  */
 function collectInputs(section, pageFetch, siteFetch) {
   const byKey = new Map()
-  // ⭐ Each level may declare SEVERAL — `data: [team, articles]` — so each is
+  // ⭐ Each level may declare SEVERAL — `query: [team, articles]` — so each is
   // flattened rather than read. Order is least- to most-specific and `set`
   // overwrites, which is what makes a section's declaration win the key.
   for (const source of [siteFetch, pageFetch, section.fetch]) {