@uniweb/build 0.49.0 → 0.50.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.49.0",
+  "version": "0.50.0",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -58,14 +58,14 @@
     "sharp": "^0.35.3",
     "yaml": "^2.5.0",
     "@uniweb/content-reader": "^1.2.4",
-    "@uniweb/content-writer": "^0.3.4",
-    "@uniweb/semantic-parser": "^1.4.0",
-    "@uniweb/projections": "^0.7.1",
     "@uniweb/schemas": "^0.2.13",
-    "@uniweb/theming": "^0.1.15"
+    "@uniweb/semantic-parser": "^1.4.0",
+    "@uniweb/theming": "^0.1.15",
+    "@uniweb/projections": "^0.7.2",
+    "@uniweb/content-writer": "^0.3.4"
   },
   "optionalDependencies": {
-    "@uniweb/runtime": "^0.24.0"
+    "@uniweb/runtime": "^0.25.0"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0",
@@ -74,7 +74,7 @@
     "@tailwindcss/vite": "^4.0.0",
     "@vitejs/plugin-react": "^4.0.0 || ^5.0.0",
     "vite-plugin-svgr": "^4.0.0",
-    "@uniweb/core": "^0.28.0"
+    "@uniweb/core": "^0.29.0"
   },
   "peerDependenciesMeta": {
     "vite": {

package/src/generate-entry.js

@@ -10,7 +10,8 @@
  *
  * The `meta` export contains only properties needed at runtime:
  * - `background` - 'self' opt-out when component handles its own background
- * - `data` - CMS entity binding ({ type, limit })
+ * - `data` - the `content.data` keys the component declares, with their schema refs
+ * - `schemas` - field defaults for those keys
  * - `defaults` - Param default values
  * - `context` - Static capabilities for cross-block coordination
  * - `initialState` - Initial values for mutable block state

package/src/prerender.js

@@ -22,6 +22,7 @@ import {
   routeBinding,
   parentRouteOf,
   deriveCacheKey,
+  evaluateQuery,
 } from '@uniweb/core'
 import { routePatternToRegex } from '@uniweb/core/route-match'
 import { executeFetch, mergeDataIntoContent, toFetchList, stripBuildOnlyFetchKeys } from './site/data-fetcher.js'
@@ -131,21 +132,22 @@ export async function executeAllFetches(siteContent, siteDir, onProgress, locale
   const fetched = { site: new Map(), pages: new Map(), sections: new Map() }
 
   /**
-   * Read one resolved config ONCE, as two things: the records it selects, uncut
-   * (`routeSelection`), and the view it delivers — the same records cut by its
-   * `limit`. ⭐ The view is what a page renders and hydrates; the selection is what
-   * a parametric page expands over, because a `limit` is how many a list shows,
-   * never which records have a page (ruled 2026-09-13 [Diego]). ⛔ Until then the
-   * expansion read the cut list, so a query's `limit: 2` made two detail pages of
-   * five. Null when the read failed.
+   * Read one resolved config ONCE, as two things: its query's SET (`routeSelection` —
+   * the query as saved, its `limit` included), and the view it delivers — that set
+   * with the fetch's `narrow` applied (`evaluateQuery`). ⭐ The view is what a page
+   * renders and hydrates; the set is what a parametric page expands over, because a
+   * parametric page has a URL for each record of its route query's set and no other —
+   * a fetch's narrowing never decides which pages exist (ruled 2026-09-14 [Diego]).
+   *
+   * ⛔ Until 2026-09-13 the expansion read the list a `limit` cut, so a list's
+   * `limit: 2` made two detail pages of five; from then until 2026-09-14 it read the
+   * records with no `limit` at all, the query's included. Null when the read failed.
    */
   const read = async (cfg, oneFetch) => {
     const result = await executeFetch(routeSelection(cfg), optionsFor(cfg, oneFetch))
     if (!result.data || result.error) return null
     const selection = result.data
-    const view = Array.isArray(selection) && typeof cfg.limit === 'number' && cfg.limit > 0
-      ? selection.slice(0, cfg.limit)
-      : selection
+    const view = cfg.narrow ? evaluateQuery(selection, { narrow: cfg.narrow }, { locale }) : selection
     return { selection, view }
   }
 
@@ -251,8 +253,9 @@ export async function executeAllFetches(siteContent, siteDir, onProgress, locale
  * @param {Array} pages - Original pages array
  * @param {{ site?: Map, pages?: Map, sections?: Map }} fetched - what each level
  *   selected, by binding key (`executeAllFetches`): `site` key → data; `pages` and
- *   `sections` route → (key → data). Every record a binding selects, uncut by its
- *   `limit` — a record past a list's count still gets its page
+ *   `sections` route → (key → data). Each binding's query SET — the query as saved,
+ *   its `limit` included, without the fetch's narrowing: a record past a list's count
+ *   still gets its page, and one past the query's gets none
  * @param {function} onProgress - Progress callback
  * @param {Object} [stats] - receives `unrouted[route]`, the records with no param value
  * @param {Object} [options]

package/src/runtime-schema.js

@@ -6,22 +6,19 @@
  * needed at render time:
  *
  * - background: 'self' when component handles its own background
- * - data: { type, limit } for CMS entity binding
+ * - data: { <key>: <schema ref> | null } — every `content.data` key the component
+ *     declares, in order, with its schema ref (null for an inline shape)
+ * - schemas: { <key>: <lean fields> } — field defaults for the declared keys that have any
  * - defaults: param default values
  * - context: static capabilities for cross-block coordination
  * - initialState: initial values for mutable block state
- * - inheritData: internal flag for cascaded data delivery
- *     true  → deliver all data available at ancestor levels (default)
- *     false → deliver nothing (component opted out with `data: false`)
  *
- * Data delivery is default-on: a component without any `data:` field
- * receives all data cascaded from its ancestor levels (block → page →
- * parent page → site) via `content.data.{schema}`. A component that
- * genuinely cannot tolerate ambient data declares `data: false`.
- *
- * `data: { entity: 'articles' }` is a **declaration**, not a gate. It
- * tells the editor and prepare-props what shape the component expects,
- * but does not restrict delivery.
+ * ⭐ `data:` IS THE DELIVERY — ruled 2026-09-14 [Diego]: a section's `content.data` holds
+ * the keys its component declares and nothing else, and which fetch fills each is worked
+ * out at render from the keys and their schema refs (`@uniweb/core` `fillDeclaredKeys`).
+ * A component with no `data:`, or `data: false`, receives none of its own. ⛔ Until then
+ * delivery was default-on — every key that reached a section — and `data:` was a hint for
+ * defaults and the editor; `data: false` was the opt-out, emitted as `inheritData: false`.
  *
  * Full metadata (titles, descriptions, hints, etc.) stays in schema.json
  * for the visual editor.
@@ -31,23 +28,15 @@ import { isRichSchema } from '@uniweb/core'
 import { flatRecordFields } from '@uniweb/schemas/conform'
 
 /**
- * Parse data string into structured object
- * 'events' -> { type: 'events', limit: null }
- * 'events:6' -> { type: 'events', limit: 6 }
+ * A `data:` entry's schema ref — a ref string, or `{ schema }` — or null for an inline
+ * shape, which names no schema and is filled only under its own key.
  *
- * @param {string} dataString
- * @returns {{ type: string, limit: number|null }}
+ * @param {string|Object} value
+ * @returns {string|null}
  */
-function parseDataString(dataString) {
-  if (!dataString || typeof dataString !== 'string') {
-    return null
-  }
-
-  const [type, limitStr] = dataString.split(':')
-  return {
-    type: type.trim(),
-    limit: limitStr ? parseInt(limitStr, 10) : null,
-  }
+function dataRef(value) {
+  if (typeof value === 'string') return value || null
+  return value && typeof value === 'object' && typeof value.schema === 'string' && value.schema ? value.schema : null
 }
 
 /**
@@ -284,18 +273,22 @@ export function extractRuntimeSchema(fullMeta, dataSchemaMap = {}) {
     runtime.background = fullMeta.background
   }
 
-  // Data schemas. `data:` is the single declaration surface for a section's
-  // structured data: it maps each `content.data` key to its schema. A value
-  // is a named ref (`'@/member'`), an inline field map, or an inline rich-form
-  // (`{ fields: [...] }`, an editor form). Source-agnostic — the data may
-  // arrive by fetch, tagged code block, or editor form; the schema and its
-  // defaults are identical. The schema is a hint (defaults + editor), not a
-  // delivery gate; delivery is default-on. `data: false` opts the section out
-  // of all ambient data.
+  // Data. `data:` is the single declaration surface for a section's structured
+  // data: it maps each `content.data` key to its schema. A value is a named ref
+  // (`'@/member'`), an inline field map, or an inline rich-form (`{ fields: [...] }`,
+  // an editor form). Source-agnostic — the data may arrive by fetch, tagged code
+  // block, or editor form; the schema and its defaults are identical.
+  //
+  // ⭐ Every key reaches the runtime, a key with no fields included — `data` lists them
+  // with their refs, because the keys ARE what the section receives, and a key's ref is
+  // what a fetch of another name fills it by. `schemas` carries field defaults for the
+  // keys that have fields. `data: false` declares nothing, as no `data:` does.
   if (fullMeta.data === false) {
-    runtime.inheritData = false
+    // declares no key
   } else if (fullMeta.data && typeof fullMeta.data === 'object' && !Array.isArray(fullMeta.data)) {
     for (const [key, value] of Object.entries(fullMeta.data)) {
+      runtime.data = runtime.data || {}
+      runtime.data[key] = dataRef(value)
       const lean = leanDataSchema(value, dataSchemaMap)
       if (lean) {
         runtime.schemas = runtime.schemas || {}
@@ -330,11 +323,6 @@ export function extractRuntimeSchema(fullMeta, dataSchemaMap = {}) {
   // (Top-level `schemas:` is gone — inline field maps and rich-forms are now
   // just `data:` entries with an inline value. See leanDataSchema.)
 
-  // Data delivery is default-on. `runtime.inheritData` stays undefined unless
-  // the component opts out with `data: false`, in which case EntityStore
-  // delivers nothing. A `data:` binding is a hint (schema for defaults +
-  // editor), never a delivery gate.
-
   return Object.keys(runtime).length > 0 ? runtime : null
 }
 

package/src/schema.js

@@ -216,6 +216,8 @@ const DEFAULT_ONLY_CAPABILITIES = [
   'outputs',
   'handlers',
   'extension',
+  // the keys every section receives — what the foundation's handlers read (2026-09-14)
+  'data',
 ]
 
 /**

package/src/site/content-collector.js

@@ -35,7 +35,7 @@ import { normalizeHideIn, dropUnpublishedPages } from './nav-visibility.js'
 import { parseFetchConfig, toFetchList } from './data-fetcher.js'
 import { resolveExtensionUrls } from './extension-urls.js'
 import { buildTheme, extractFoundationVars } from '../theme/index.js'
-import { resolveDefaultLocale, resolvePublishableLocales, validateLanguageConfig, pageRouteQuery } from '@uniweb/core'
+import { resolveDefaultLocale, resolvePublishableLocales, validateLanguageConfig, pageRouteQuery, currentFor } from '@uniweb/core'
 import { parseFrontmatter } from '../utils/frontmatter.js'
 
 // Try to import content-reader, fall back to simplified parser
@@ -306,10 +306,14 @@ const formatQueryNames = (value) =>
   isQueryNames(value) ? (Array.isArray(value) ? `[${value.join(', ')}]` : value) : '<name>'
 
 /**
- * ⚠️ A `current:` NOTHING WILL READ — said once per binding. `current:` applies on a
- * section's binding under the key its page's URL narrows (the route query,
- * `pageRouteQuery`); anywhere else the runtime ignores it, and the author would see
- * the section deliver its list as though the line were not there.
+ * ⚠️ A `current:` NOTHING WILL READ — said once per binding. `current:` follows the query a
+ * section's fetch names (`currentFor`, `@uniweb/core`, ruled 2026-09-14): on a page with a
+ * route query (`pageRouteQuery`) it is read on a fetch of that query or of any other, so it
+ * goes unread on a page with none — a static page, a parametric page whose sections name
+ * different queries with nothing above them, a layout area. There the runtime ignores it,
+ * and the author would see the section deliver its list as though the line were not there.
+ * ⛔ Until 2026-09-14 this warned by key, as the runtime then read it: on any key but the
+ * route query's.
  *
  * @param {Array<Object>} pages - collected pages, parents linked
  * @param {Object} layouts - collected layout areas (never on a parametric route)
@@ -324,24 +328,24 @@ function warnUnreadCurrent(pages, layouts, siteFetch) {
     sectionsOf: (p) => p.sections,
     site: siteFetch,
   }
-  const check = (sections, where, routeKeyOf) => {
+  const check = (sections, where, routeOf) => {
     for (const section of sections || []) {
       for (const one of toFetchList(section.fetch)) {
         if (one?.current === undefined) continue
-        const routeKey = routeKeyOf()
-        if (one.as === routeKey) continue
+        const route = routeOf()
+        if (currentFor(one, route) !== null) continue
         console.warn(
           `[uniweb] ${where}: \`current: ${one.current}\` on content.data.${one.as} is ignored — it applies on a ` +
-            `section of a parametric page, under the key its URL narrows` +
-            (routeKey ? ` (here \`${routeKey}\`).` : '; this page has none.')
+            `section of a parametric page, to a fetch that names a query` +
+            (route ? ` (this page's URL names one of \`${route.key}\`).` : '; this page has none.')
         )
       }
-      check(section.subsections, where, routeKeyOf)
+      check(section.subsections, where, routeOf)
     }
   }
   for (const page of pages) {
-    let key
-    check(page.sections, page.route, () => (key === undefined ? (key = pageRouteQuery(page, access)?.key ?? null) : key))
+    let route
+    check(page.sections, page.route, () => (route === undefined ? (route = pageRouteQuery(page, access) ?? null) : route))
   }
   for (const [name, areas] of Object.entries(layouts || {})) {
     for (const [area, areaPage] of Object.entries(areas || {})) {
@@ -1054,12 +1058,11 @@ async function processMarkdownFile(filePath, id, siteRoot, defaultStableId = nul
   // Extract @ component references → insets (mutates doc)
   const insets = extractInsets(proseMirrorContent)
 
-  // `query: team` → `fetch: { query: team }`; a list, one config per name, each
-  // delivered under its own `content.data` key — the one helper every level uses.
-  // Unrelated to a section type's `meta.js` `data:`, which declares the SHAPE of
-  // each `content.data` key and fetches nothing: delivery is default-on, so a
-  // section receives every fetch in the section → page → site cascade whether or
-  // not it names one here.
+  // `query: team` → `fetch: { query: team }`; a list, one config per name, each under
+  // its own `as` — the one helper every level uses. Unrelated to a section type's
+  // `meta.js` `data:`, which declares the `content.data` keys a component receives and
+  // fetches nothing: which fetch fills each is worked out at render (`fillDeclaredKeys`,
+  // `@uniweb/core`, 2026-09-14).
   const resolvedFetch = declaredFetch({ fetch, query, data }, relative(siteRoot, filePath))
 
   // Stable ID for scroll targeting: frontmatter id > filename-derived > null

package/src/site/data-fetcher.js

@@ -19,7 +19,7 @@ import { readFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { existsSync } from 'node:fs'
 import yaml from 'js-yaml'
-import { matchWhere, sortRecords, queryDataUrl, applyScope, whereOutsideLanguage, CURRENT_MODES } from '@uniweb/core'
+import { matchWhere, sortRecords, queryDataUrl, evaluateQuery, whereOutsideLanguage, CURRENT_MODES } from '@uniweb/core'
 
 /**
  * Get a nested value from an object using dot notation
@@ -83,47 +83,25 @@ export function applyWhere(items, where) {
 }
 
 /**
- * Apply post-processing to fetched data (where, sort, limit)
+ * Apply post-processing to fetched data — a resolved config's two levels, by
+ * `@uniweb/core`'s `evaluateQuery`, the one order of work the runtime's default
+ * fetcher uses too:
  *
- * Order of operations:
- *   1. where (where-object predicate) — narrows the record set
- *   2. sort
- *   3. limit
+ *   1. the query's set — `scope` over each record's placement (`path`), `where`,
+ *      `sort`, `limit`;
+ *   2. the fetch's `narrow` of it — `where` (and `match`), `sort`, `limit`.
+ *
+ * A bad `sort:` throws here: an authoring error stops the build.
  *
  * @param {any} data - Fetched data
- * @param {object} config - Fetch config with optional where, sort, limit
+ * @param {object} config - A resolved fetch config
  * @param {object} [options]
  * @param {string|null} [options.locale] - the page's locale, which texts sort in
  * @returns {any} Processed data
  */
 export function applyPostProcessing(data, config, { locale = null } = {}) {
-  if (!data || !Array.isArray(data)) return data
-  if (!config.scope && !config.where && !config.sort && !config.limit) return data
-
-  let result = data
-
-  // `scope` first — the folder branch the rest of the query reads, over each
-  // record's placement (`path`), as the runtime's default fetcher applies it.
-  if (typeof config.scope === 'string' && config.scope) {
-    result = applyScope(result, config.scope)
-  }
-
-  // Apply where-object predicate first (new path)
-  if (config.where) {
-    result = applyWhere(result, config.where)
-  }
-
-  // Apply sort
-  if (config.sort) {
-    result = applySort(result, config.sort, { locale })
-  }
-
-  // Apply limit last
-  if (config.limit && config.limit > 0) {
-    result = result.slice(0, config.limit)
-  }
-
-  return result
+  if (!data || !Array.isArray(data) || !config) return data
+  return evaluateQuery(data, config, { locale })
 }
 
 /**
@@ -172,6 +150,27 @@ const RECOGNIZED_FETCH_KEYS = {
   ]),
 }
 
+/**
+ * ⛔ `route:` ON A QUERY IS RETIRED (2026-09-14 [Diego]) — refused, because a query
+ * that still declares it would build and its cards would lose their links silently. A
+ * record links to the page whose route query is its query, as `$route`, which the
+ * runtime fills at render time on every lane; a fetch picks another page with
+ * `detailPage:`. The build baked `route:` into each compiled record as `route`, a field
+ * in the author's namespace that it overwrote.
+ *
+ * @param {Object} decl - a query declaration
+ * @param {string} context - where the declaration sits, for the message
+ */
+export function refuseQueryRoute(decl, context) {
+  if (!decl || typeof decl !== 'object' || decl.route === undefined) return
+  throw new Error(
+    `[uniweb] ${context}: \`route:\` is retired. Each record links to the page that shows one record of this ` +
+      `query — the \`[slug]\` page whose URL names one of its records — as \`$route\`, with nothing to declare: ` +
+      `delete the line, and read \`record.$route\` in a component. To link to another page, add ` +
+      `\`detailPage: page:<id>\` to the fetch.`
+  )
+}
+
 /**
  * ⛔ `under` IS RETIRED (2026-09-11 [Diego]) — refused, like every retired spelling
  * here, because an ignored predicate is a silently wrong answer. It existed for
@@ -551,8 +550,10 @@ export function parseFetchConfig(fetch, context = 'fetch', { level = null } = {}
     // (`@uniweb/core/fetch-config`) — and the parser does not know which this is.
     prerender: fetch.prerender,
     merge: fetch.merge ?? false,
-    // A binding's adaptations of its query (`@uniweb/core/fetch-config`,
-    // `narrowQuery`): `where` joins the query's, `sort` and `limit` replace its.
+    // A binding's adaptations of its query, kept as authored: the resolver makes them
+    // the fetch's `narrow` of the query's set (`@uniweb/core/fetch-config`,
+    // `setAndNarrow`) — its `where` filters the set, its `sort` re-orders it, its
+    // `limit` cuts it and never reaches past it.
     where: fetch.where,
     limit: fetch.limit,
     sort: fetch.sort,

package/src/site/queries-config.js

@@ -32,6 +32,7 @@ import { join } from 'node:path'
 import { existsSync, readFileSync } from 'node:fs'
 import { briefFields, flatRecordFields } from '@uniweb/schemas/conform'
 import { detectFoundationType } from './foundation-ref.js'
+import { refuseQueryRoute } from './data-fetcher.js'
 import { readFile } from 'node:fs/promises'
 import yaml from 'js-yaml'
 
@@ -189,7 +190,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', 'route', 'path']
+const SITE_RECORDS_ONLY = ['schema', 'model', 'scope', 'deferred', 'excerpt', 'path']
 /** The keys of an external query's `record:` request. */
 const RECORD_KEYS = ['url', 'method', 'body', 'transform']
 
@@ -202,9 +203,15 @@ 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`, `route` — is refused beside `url:`. ⛔ `detailUrl:` is
+ * `deferred`, `excerpt` — is refused beside `url:`. ⛔ `detailUrl:` is
  * retired everywhere: its one real case is `record.url`.
  *
+ * ⛔ `route:` is retired everywhere too (2026-09-14 [Diego]): a record links to the page
+ * whose route query is its query, as `$route`, which the runtime fills at render time
+ * on every lane — and a fetch that wants another page names it with `detailPage:`. The
+ * build baked `route:` into each compiled record as `route`, a field in the author's
+ * namespace that it overwrote.
+ *
  * @param {Object} decl - one normalized declaration (`{ name, … }`)
  */
 export function refuseQueryDeclaration(decl) {
@@ -215,6 +222,7 @@ export function refuseQueryDeclaration(decl) {
         `on an external query — one with \`url:\`.`
     )
   }
+  refuseQueryRoute(decl, where)
   const external = decl.url !== undefined
   if (!external) {
     for (const key of ['method', 'body', 'transform', 'record']) {

package/src/site/query-processor.js

@@ -34,7 +34,8 @@
  *   merge — the loader flattens one level after collecting them.
  * - Converts markdown body to ProseMirror JSON
  * - Applies the query's fixed `where` and orders by its `sort`; its `limit` is
- *   left to the runtime, so every record the query selects compiles
+ *   left to the runtime, which makes each page's set, so every record the query's
+ *   fixed `where` selects compiles
  * - Auto-generates excerpts and extracts first images (markdown items only)
  *
  * @module @uniweb/build/site/collection-processor
@@ -55,8 +56,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, withoutRouteVariables } from '@uniweb/core'
-import { applyWhere, applySort, refuseUnder, refuseOutsideLanguage } from './data-fetcher.js'
+import { DATA_DIR, withoutRouteVariables } from '@uniweb/core'
+import { applyWhere, applySort, refuseUnder, refuseOutsideLanguage, refuseQueryRoute } 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'
@@ -93,8 +94,7 @@ try {
  *
  * // Extended form
  * parseQueryConfig('articles', {
- *   path: 'collections/articles',
- *   route: '/blog',
+ *   schema: '@/article',
  *   sort: 'date desc',
  *   filter: 'published != false',
  *   limit: 100
@@ -113,7 +113,6 @@ function parseQueryConfig(name, config) {
       name,
       schema: config,
       url: null,
-      route: null,
       scope: null,
       sort: null,
       where: null,
@@ -126,13 +125,13 @@ function parseQueryConfig(name, config) {
 
   refuseUnder(config.where, `queries.${name}`)
   refuseOutsideLanguage(config.where, `queries.${name}`)
+  refuseQueryRoute(config, `queries.${name}`)
   return {
     name,
     // The query's schema selects its records from the pool — `entities/{schema}/`
     // declares the model, so the entities of a schema ARE the query's records.
     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,
@@ -686,32 +685,6 @@ async function collectItems(siteDir, config, entitiesDir, basePath, locale = nul
 
   warnDuplicateSlugs(items, config.name)
 
-  // `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 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, then sort. Two
   // lanes evaluate the same declaration (this one materializes a query to
   // `/data/<name>.json`; that one runs a page-level `fetch:`), so a difference in
@@ -742,12 +715,15 @@ async function collectItems(siteDir, config, entitiesDir, basePath, locale = nul
     items = applySort(items, config.sort, { locale })
   }
 
-  // ⛔ `limit` IS NEVER BAKED (ruled 2026-09-13 [Diego]): it is how many a list
-  // shows, and a binding may pick its own — more than the query's included — which
-  // a file cut here could not give it. Every record the query selects compiles, and
-  // gets its detail page; the runtime cuts each list (`@uniweb/core/fetch-config`,
-  // `narrowQuery`). Until then this sliced the file, so a query's `limit: 2` made the
-  // static build emit two detail pages while the records service resolved all five.
+  // ⛔ `limit` IS NEVER BAKED. A query's `limit` is part of its set (ruled 2026-09-14
+  // [Diego]), but the set is made per page: `scope` and the route-bound clauses the
+  // runtime applies first differ from page to page, and the `limit` cuts what they
+  // leave — so a file cut here would cut before them. Every record the query's fixed
+  // `where` selects compiles, in its `sort`; the runtime makes each page's set and then
+  // applies the fetch's `narrow` (`@uniweb/core`'s `evaluateQuery`), and a parametric
+  // page is expanded over the set (`prerender.js`). ⛔ Until 2026-09-13 this sliced the
+  // file — before a page's `scope` or routed clauses, which the runtime has applied
+  // since 2026-09-11, could select anything from it.
 
   return items
 }

package/src/uwx/site.js

@@ -803,13 +803,13 @@ const DECL_NOT_ON_WIRE = new Set([
   // convention supplied it. Decides hard-error vs soft-skip during sync;
   // `collections-config.js::toConfigQueries` strips it downstream too.
   'schemaExplicit',
-  // ⭐ FRAMEWORK-LOCAL, and the one that proves the rule. `route:` is a real
-  // authored field — `parseQueryConfig` reads it, and `collectItems` composes
-  // each item's link as `<route>/<slug>` — but the backend's Model has no slot for
-  // it, so emitting it would be sending build-time config to a store that validates
-  // against a declared schema. Measured 2026-08-29: a first version of this change
-  // passed unknown keys through blindly and would have started sending `route` from
-  // every site that declares one.
+  // ⛔ RETIRED 2026-09-14, and kept here so a stale declaration never carries it.
+  // `route:` was framework-local — `collectItems` baked each item's link as
+  // `<route>/<slug>` — and the backend's Model has no slot for it. It is refused now
+  // (`data-fetcher.js::refuseQueryRoute`): a record links to its query's page as
+  // `$route`, filled at render time. Measured 2026-08-29: a first version of this list
+  // passed unknown keys through blindly and would have sent `route` from every site
+  // that declared one.
   'route',
   // Legacy predicate, translated to the canonical `where` upstream. No legacy
   // fields on the wire.

package/src/validate-data.js

@@ -27,7 +27,7 @@ import { readFile } from 'node:fs/promises'
 import { existsSync } from 'node:fs'
 import { join, resolve, basename } from 'node:path'
 import yaml from 'js-yaml'
-import { queryNameFromUrl, siteReaches } from '@uniweb/core'
+import { queryNameFromUrl, siteReaches, declaredKeys, fillDeclaredKeys } from '@uniweb/core'
 
 import { validateItem, isStaticallyCheckable, validateBound } from '@uniweb/schemas/conform'
 import { validateAndNormalizeSchema } from './resolve-data-schema.js'
@@ -103,54 +103,59 @@ export async function validateDataInputs({ siteRoot, foundationPath }) {
   const work = new Map() // pairKey -> { path, ref, schema, users: [{ route, section, key }] }
   const deferred = []
 
+  const byRoute = new Map((site.pages || []).map((p) => [p.route, p]))
   for (const page of site.pages || []) {
     walkSections(page.sections || [], (section) => {
       const type = section.type
       if (!type) return
       const bindings = foundation[type]?.data
-      // the site's binding reaches a top-level page's sections only (`siteReaches`)
-      const inputs = collectInputs(section, page.fetch, siteReaches(page.parent) ? config.fetch : null)
-
-      // ⭐ **THE JOIN, RUN THE OTHER WAY: data arrived, but under no name this
-      // section reads.** Everything below asks "for each input, is there a
-      // binding?". This asks "for each binding, was anything delivered?" — and
-      // the answer was silence until 2026-09-02.
+      // ⭐ THE RUNTIME'S JOIN (2026-09-14): a section receives the keys its component
+      // declares, and which fetch fills each is automatic `as` — `fillDeclaredKeys`, the
+      // same function the entity store delivers by — so a `post: '@std/article'` key
+      // filled by an `articles` fetch is checked against `@std/article`, and a fetch that
+      // fills no declared key is not checked at all, since no component receives it. The
+      // levels are the section's own fetch, its page's, its parent page's and — for a
+      // top-level page — the site's (`siteReaches`).
+      const declared = declaredKeys(bindings)
+      const levels = [section.fetch, page.fetch, byRoute.get(page.parent)?.fetch, siteReaches(page.parent) ? config.fetch : null]
+      const inputs = collectInputs(levels)
+      const held = nodesOfType(section.content, 'dataBlock').map((node) => node.attrs?.tag).filter(Boolean)
+      const fills = fillDeclaredKeys(declared, levels, { queries: config.queries, held })
+
+      // ⭐ **THE JOIN, RUN THE OTHER WAY: data arrived, and no key this section reads is
+      // filled by it.** Everything below asks "for each filled key, is its data right?".
+      // This asks "was anything this section reads filled?" — and the answer was silence
+      // until 2026-09-02.
       //
-      // A section reads `content.data.<key>` for the keys its `meta.js` `data:`
-      // declares. When the page delivers a query under a DIFFERENT name, the
-      // section renders its heading and nothing else: no error, no warning, HTTP
-      // 200, a clean console. Reported by `flows`, measured in a real browser —
-      // two records-backed sections carrying 8 and 6 characters of text beside
-      // static ones carrying 182/572/289/529/99.
+      // A section reads `content.data.<key>` for the keys its `meta.js` `data:` declares.
+      // When nothing on the page fills them — no fetch under the key, none of its schema —
+      // the section renders its heading and nothing else: no error, no warning, HTTP 200,
+      // a clean console. Reported by `flows`, measured in a real browser — two
+      // records-backed sections carrying 8 and 6 characters of text beside static ones
+      // carrying 182/572/289/529/99.
       //
-      // ⚖️ **Narrow on purpose: only when SOMETHING was delivered.** `data:` in
-      // `meta.js` is a hint rather than a delivery gate (`docs/reference/
-      // data-fetching.md`), so a section declaring keys on a page with no data at
-      // all is ordinary and silent. What is not ordinary is a page that fetched
-      // something and a section on it that reads none of it — there the author
-      // demonstrably intended data to arrive and the names did not meet.
-      const declaredKeys = bindings ? Object.keys(bindings) : []
-      if (declaredKeys.length > 0 && inputs.length > 0) {
+      // ⚖️ **Narrow on purpose: only when SOMETHING was delivered.** A section declaring
+      // keys on a page with no data at all is ordinary and silent. What is not ordinary is
+      // a page that fetched something and a section on it that receives none of it —
+      // there the author demonstrably intended data to arrive and the names did not meet.
+      const declaredNames = declared.map(([key]) => key)
+      if (declaredNames.length > 0 && inputs.length > 0 && fills.size === 0 && !declaredNames.some((k) => held.includes(k))) {
         const delivered = inputs.map((i) => i.as).filter(Boolean)
-        if (delivered.length > 0 && !declaredKeys.some((k) => delivered.includes(k))) {
-          setupErrors.push({
-            file: `${page.route || '/'} · ${type}`,
-            message:
-              `section reads ${declaredKeys.map((k) => `content.data.${k}`).join(' or ')}, ` +
-              `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 ` +
-              `\`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 })),
-          })
-        }
+        setupErrors.push({
+          file: `${page.route || '/'} · ${type}`,
+          message:
+            `section reads ${declaredNames.map((k) => `content.data.${k}`).join(' or ')}, ` +
+            `but this page delivers ${delivered.map((k) => `\`${k}\``).join(', ')}, and none of it fills them — ` +
+            `not by name, and not by schema. The section will render with no data and nothing else will say so. ` +
+            `Name the query for the key the section reads, give the fetch that key with \`as:\`, or give the ` +
+            `section its own \`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: declaredNames.map((k) => ({ route: page.route, section: type, key: k })),
+        })
       }
 
-      for (const input of inputs) {
-        const key = input.as // the content.data KEY
-
+      for (const [key, { fetch: input }] of fills) {
         // An external query's records are its address's, fetched where the page renders.
         const external = typeof input.query === 'string' ? config.queries?.[input.query]?.url : undefined
         if (input.url || external) {
@@ -161,7 +166,7 @@ export async function validateDataInputs({ siteRoot, foundationPath }) {
 
         const binding = bindings?.[key]
         const ref = typeof binding === 'string' ? binding : binding?.schema
-        if (!ref) continue // ungoverned input — no schema bound to this key
+        if (!ref) continue // ungoverned key — no schema declared for it
 
         const schema = dataSchemas[ref]
         if (!schema) continue // build guarantees refs resolve; defensive skip
@@ -475,17 +480,17 @@ async function loadStandardSchemas() {
 }
 
 /**
- * The data inputs available to a section, deduped by key. A section receives
- * its own fetch plus any inherited page-level and site-level fetch (default-on
- * cascade); when two levels share a key, the nearer one wins (section > page >
- * site) — the same precedence the runtime delivers.
+ * The data inputs reaching a section, deduped by key — the fetches of its levels, most
+ * specific first; when two levels share a key, the nearer one wins. What each input fills
+ * is `fillDeclaredKeys`'s to say; this lists what arrived, for the message when nothing
+ * the section reads is filled.
  */
-function collectInputs(section, pageFetch, siteFetch) {
+function collectInputs(levels) {
   const byKey = new Map()
   // ⭐ 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]) {
+  for (const source of [...levels].reverse()) {
     for (const f of toFetchList(source)) {
       // ⛔ Gate on the BINDING KEY. A gate on the wrong name silently yields
       // NOTHING here — no inputs collected, no violations found, a green run —