@uniweb/runtime 0.22.0 → 0.24.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/runtime",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "Minimal runtime for loading Uniweb foundations",
   "type": "module",
   "exports": {
@@ -36,7 +36,7 @@
     "node": ">=20.19"
   },
   "dependencies": {
-    "@uniweb/core": "^0.26.2",
+    "@uniweb/core": "^0.28.0",
     "@uniweb/theming": "^0.1.15"
   },
   "devDependencies": {
@@ -44,7 +44,7 @@
     "esbuild": "^0.21.0 || ^0.23.0 || ^0.24.0 || ^0.25.0 || ^0.27.0",
     "vite": "^7.3.1",
     "vitest": "^4.1.7",
-    "@uniweb/build": "0.47.1"
+    "@uniweb/build": "0.48.0"
   },
   "peerDependencies": {
     "react": "^19.0.0",

package/src/collect-records.js

@@ -57,11 +57,12 @@ import { createDefaultFetcher } from './default-fetcher.js'
  * @param {Function} options.fetch - the transport, `(url, init) => Response`
  * @param {AbortSignal} [options.signal]
  * @param {string[]} [options.only] - restrict to these query names
- * @param {'brief'|'full'} [options.depth='brief'] - what to ask for. `brief` is
- *   what a list shows; **`full` is what an index wants** — a brief index cannot
- *   match body text the record's own detail page displays, and a reader who
+ * @param {boolean} [options.whole=false] - what to ask for. `false` is the brief a
+ *   list shows; **`true` — whole records — is what an index wants**: a brief index
+ *   cannot match body text the record's own detail page displays, and a reader who
  *   finds a word on the page and not in search meets the inconsistency two
  *   rankings would produce. The cost is the caller's and is bounded by `maxPages`.
+ *   An external query is never collected — it has no records service to ask.
  * @param {number} [options.maxPages] - the caller's own bound on the walk. The
  *   default is a bound, not a target; a caller that knows its per-request budget
  *   passes its own.

package/src/default-fetcher.js

@@ -26,16 +26,17 @@
  * foundation level… making the runtime+core lean."* A backend with its own
  * base, headers, wire or query language is a TRANSPORT — a named
  * `{ resolve, cacheKey? }` the foundation (or an extension) registers and
- * the site selects per schema in `fetcher.transports`. The build warns once
+ * the site selects per binding key (`as`) in `fetcher.transports`. The build warns once
  * and drops a retired key from the payload, so an author's backend does not
  * silently stop being reached.
  *
- * Per-fetch, the request may still carry `method: 'POST'` + `body:` for a
- * backend that takes a query in a body (GraphQL, a search endpoint);
- * `{paramName}` placeholders in body strings are substituted from
- * `request.dynamicContext`, so a template page's detail query can reference
- * its route param. `transform:` and the object form of `detail:` (its own
- * `envelope`) stay per fetch too — they describe ONE response, not a backend.
+ * A request may carry `method: 'POST'` + `body:` for an endpoint that takes a
+ * query in a body (GraphQL, a search endpoint) — an external query's, or its
+ * `record:` request's — and `transform:`, a dot-path to the records in ONE
+ * response. `{paramName}` placeholders in body strings are substituted from
+ * `request.dynamicContext`, so a parametric page's record request can reference
+ * its route param. ⛔ `envelope` (the object form of `detail:`) is retired with
+ * it, 2026-09-13: a record request's own `transform` is `record.transform`.
  *
  * Exported from a subpath — `@uniweb/runtime/default-fetcher` — for
  * runtime-level callers (the editor's preview iframe, custom runtime
@@ -192,49 +193,23 @@ export function createDefaultFetcher({ basePath = '', dev = false, fetch: fetchI
         const response = await readOnce(target, init)
         if (ctx.signal?.aborted) return { data: [], error: 'aborted' }
 
-        // A per-request envelope (set by the object form of `detail:`) describes
-        // this one response.
-        const envelope = (request.envelope && typeof request.envelope === 'object')
-          ? request.envelope
-          : {}
-
         if (!response.ok) {
-          // If `envelope.error` names a path, try to extract a human message
-          // from the parsed body; fall back to status text if the path is
-          // missing or the body isn't JSON.
-          let extracted
-          if (envelope.error && typeof response.text === 'string') {
-            const body = safeParseJSON(response.text)
-            if (body !== undefined) {
-              const candidate = getNestedValue(body, envelope.error)
-              if (typeof candidate === 'string' && candidate.length) {
-                extracted = candidate
-              }
-            }
-          }
-          return {
-            data: [],
-            error: extracted ?? `HTTP ${response.status}: ${response.statusText}`,
-          }
+          return { data: [], error: `HTTP ${response.status}: ${response.statusText}` }
         }
 
         let data = response.body
 
-        // Unwrap the response. Per-fetch `transform:` wins; otherwise the
-        // envelope's `item` path on a single-record request, `list` on a list.
-        const isDetailRequest = !!request.dynamicContext
-        const effectiveTransform =
-          transform
-          || (isDetailRequest ? envelope.item : envelope.list)
-        if (effectiveTransform && data !== null && data !== undefined) {
-          data = getNestedValue(data, effectiveTransform)
+        // Unwrap the response: the request's own `transform:`, and nothing else — a
+        // record request carries its `record.transform`, never the list's.
+        if (transform && data !== null && data !== undefined) {
+          data = getNestedValue(data, transform)
         }
 
         // Evaluate the query locally. Only applies to array data
         // (filtering/sorting/limiting a single record doesn't make sense).
         // For non-arrays, operators are ignored — the source returned what
         // it returned.
-        data = applyOperators(data, request, { dev })
+        data = applyOperators(data, request, { dev, locale: sortLocale(request, ctx) })
 
         // ⭐ Say whether WHOLE records were delivered, so the record index can
         // file them — what the config asked for, echoed: briefs when the query
@@ -257,11 +232,12 @@ export function createDefaultFetcher({ basePath = '', dev = false, fetch: fetchI
  * One question of a batch, in the records service's own vocabulary
  * (the records contract, §2): `schema` required, `scope` a bare path, `sort`
  * one key spelled `date` / `-date`, `whole` when the whole record is wanted,
- * `match` on a parametric page's record. The where-object crosses as authored
- * except for the one spelling the language settled differently from the
- * evaluator's: `nin` is `not_in` there. Anything the service does not accept
- * (`like`, a dotted path) is sent as written and refused there by name: loud,
- * never approximated.
+ * `match` on a parametric page's record. ⭐ The where-object crosses exactly as
+ * authored: the evaluator and the service speak one language (`@uniweb/core`'s where evaluator).
+ * ⛔ `nin` was respelled `not_in` here until 2026-09-13, when the evaluator took
+ * `not_in` as its only spelling. Anything the service does not answer (a dotted
+ * path, a retired operator) is sent as written and answered there: never
+ * approximated.
  */
 function toQuestion(request) {
   const q = { schema: request.schema }
@@ -271,7 +247,7 @@ function toQuestion(request) {
   // [Diego] — the build refuses it now, so there is nothing left to respell.
   const scope = typeof request.scope === 'string' && request.scope ? request.scope : null
   if (scope) q.scope = scope
-  if (where) q.where = renameOperators(where)
+  if (where) q.where = where
   // ⭐ The record of a parametric page: the question unchanged plus `match` — one
   // key and the URL's value, beside the author's `where`, never merged into it
   // (`buildDetailConfig`; the records contract as we read it, §1d).
@@ -292,41 +268,31 @@ function toQuestion(request) {
   return q
 }
 
-const OPERATOR_ALIAS = { nin: 'not_in' }
-function renameOperators(where) {
-  if (Array.isArray(where)) return where.map(renameOperators)
-  if (!where || typeof where !== 'object') return where
-  const out = {}
-  for (const [key, value] of Object.entries(where)) {
-    out[OPERATOR_ALIAS[key] ?? key] = value && typeof value === 'object' ? renameOperators(value) : value
-  }
-  return out
-}
-
 /**
  * Send one batch to the records service and hand each question its own answer.
  *
- * The response is `{ data, depths?, errors?, cursors?, limits? }` (contract §5):
- * `data` answers exactly the keys sent, `[]` when nothing matched; a key that
- * ERRORED is absent from `data` and present in `errors`; `depths` says what was
- * actually served, which the record index files rather than what was asked for.
- * A key missing from both is a protocol violation and is reported as an error,
- * never as silence.
+ * The response is `{ data, whole?, cursors?, partial? }` (backend's records-query
+ * contract rev D, 2026-09-13), each map absent when empty: `data` answers exactly the
+ * keys sent — `[]` when nothing matched, and `[]` too for a question an author got
+ * wrong, since the service answers a mistake rather than refusing it; `whole[key]` says
+ * a key was served as whole records; `cursors[key]` that more records remain under the
+ * question's `limit`; `partial[key]` that a source of the key did not answer. A key
+ * missing from `data` is a protocol violation and is reported as an error, never as
+ * silence. ⛔ `errors` and `limits` are not read: the service stopped sending them in
+ * the same revision, and this client read both until 2026-09-14.
  *
- * ⭐ `cursors` AND `limits` ARE READ — 2026-09-06 [Diego], reversing the ruling
- * that had them "received and IGNORED, because framework has no paging concept."
- * ⛔ **That ruling described our client and was silently wrong about our USERS:**
- * the service bounds every answer at 100 (the records contract §4.2/§5), and a
- * `cursors` entry is how it says there is more. Discarding both meant a hosted
- * list of 500 rendered 100 — no error, no warning, no way for an author to tell
- * a bound from the end of the data. **The silent class, on a visitor's page.**
+ * ⭐ `cursors` ARE READ — 2026-09-06 [Diego], reversing the ruling that had them
+ * "received and IGNORED, because framework has no paging concept." ⛔ **That ruling
+ * described our client and was silently wrong about our USERS:** a `cursors` entry is
+ * how the service says there is more, and discarding it meant a hosted list could
+ * render part of its records with no way for an author to tell that from the end of
+ * the data. **The silent class, on a visitor's page.**
  *
  * Two behaviours, deliberately not one:
  *
- *   - **a page render REPORTS** — `meta.partial` and `meta.bound` ride the
- *     answer, and nothing pages automatically. Auto-paging here would put
- *     unbounded round trips in front of paint for a section that may only show
- *     ten rows.
+ *   - **a page render REPORTS** — `meta.partial` rides the answer, and nothing pages
+ *     automatically. Auto-paging here would put unbounded round trips in front of
+ *     paint for a section that may only show ten rows.
  *   - **an exhaustive caller PAGES** — `request.exhaustive` follows `cursors`
  *     until the service stops issuing them. `collectSiteRecords` is the caller
  *     that wants it (a corpus is not a page), and `maxPages` bounds the loop so
@@ -395,14 +361,14 @@ async function flushAsked(url, queue, doFetch) {
     return
   }
   const data = parsed && typeof parsed.data === 'object' && parsed.data ? parsed.data : {}
-  const errors = parsed && typeof parsed.errors === 'object' && parsed.errors ? parsed.errors : {}
   // ⭐ `whole[key]` is present only for keys delivered as WHOLE entities — so a
   // key's ABSENCE is the brief, and a key present that never asked is the
   // brief-less Model saying so. Absent entirely when every key is briefs.
   const wholes = parsed && typeof parsed.whole === 'object' && parsed.whole ? parsed.whole : {}
-  // Both absent when empty, never `{}` (the records contract §5).
   const cursors = parsed && typeof parsed.cursors === 'object' && parsed.cursors ? parsed.cursors : {}
-  const limits = parsed && typeof parsed.limits === 'object' && parsed.limits ? parsed.limits : {}
+  // ⭐ `partial[key]` — `{ source, code, detail }`: a source of that key did not answer,
+  // and the key carries what the others returned. Unread, a degraded key looked complete.
+  const degraded = parsed && typeof parsed.partial === 'object' && parsed.partial ? parsed.partial : {}
   queue.forEach((entry, i) => {
     const key = keys[i]
     // ⛔ A FAILURE MUST NOT DISCARD PAGES ALREADY COLLECTED. An exhaustive walk
@@ -410,21 +376,11 @@ async function flushAsked(url, queue, doFetch) {
     // corpus would rather have them marked partial than lose the key — losing it
     // is indistinguishable from "this query has no records".
     const held = Array.isArray(entry.collected) && entry.collected.length ? entry.collected : null
-    if (key in errors) {
-      // A per-key error is `{ code, detail }` — `schema_not_found`,
-      // `field_not_in_brief`, `scope_not_found`… The sentence is `detail`; `code`
-      // rides beside it for a reader that wants to branch on it.
-      const e = errors[key]
-      const detail = typeof e === 'string' ? e : (e?.detail || e?.message || JSON.stringify(e))
-      const out = held
-        ? { data: held, error: detail, meta: withMeta({ partial: true, pages: entry.page }) }
-        : { data: null, error: detail }
-      if (e && typeof e === 'object' && typeof e.code === 'string') out.code = e.code
-      entry.resolve(out)
-      return
-    }
     if (!(key in data)) {
-      entry.resolve({ data: null, error: `the records service answered without the key "${key}"` })
+      const error = `the records service answered without the key "${key}"`
+      entry.resolve(held
+        ? { data: held, error, meta: withMeta({ partial: true, pages: entry.page }) }
+        : { data: null, error })
       return
     }
     const whole = typeof wholes[key] === 'boolean'
@@ -432,7 +388,6 @@ async function flushAsked(url, queue, doFetch) {
       : (typeof entry.request.whole === 'boolean' ? entry.request.whole : undefined)
 
     const cursor = typeof cursors[key] === 'string' && cursors[key] ? cursors[key] : null
-    const bound = typeof limits[key] === 'number' ? limits[key] : undefined
     const rows = Array.isArray(data[key]) ? data[key] : data[key]
 
     // An exhaustive caller collects the page and asks for the next one.
@@ -443,32 +398,30 @@ async function flushAsked(url, queue, doFetch) {
         ? entry.request.maxPages
         : DEFAULT_MAX_PAGES
       if (page <= cap) {
-        pending.set(entry, { cursor, collected: acc, page, whole, bound })
+        pending.set(entry, { cursor, collected: acc, page, whole })
         return
       }
       // The caller's own bound, not the service's: report rather than spin.
-      entry.resolve({ data: acc, meta: withMeta({ whole, bound, partial: true, pages: cap }) })
+      entry.resolve({ data: acc, meta: withMeta({ whole, partial: true, pages: cap }) })
       return
     }
 
     const collected = entry.collected ? entry.collected.concat(Array.isArray(rows) ? rows : []) : rows
     const meta = withMeta({
       whole,
-      bound,
       // ⭐ ONE FLAG, MEANING **NOT THE WHOLE POPULATION** — asked for by name, so
-      // a caller has one boolean to branch on rather than three signals to
+      // a caller has one boolean to branch on rather than several signals to
       // combine. It is set in every case that means it:
       //   · a cursor came back and this caller does not page (a page render);
       //   · a cursor came back and the caller's `maxPages` stopped the walk;
       //   · the walk failed or aborted with pages already in hand;
-      //   · the service reported it BOUNDED the answer and offered no cursor.
-      // ⚠️ The last is why `limits` is read at all: a cursor is the signal for a
-      // query that declared no `limit`, and `limits` is the signal for one whose
-      // author limit was clamped (the records contract §5). Neither alone covers
-      // both. ⛔ Named `truncated` when it shipped in 0.17.0 this morning; renamed
-      // the same day, before any consumer adopted it, because "truncated" says
-      // something was cut and this also means "there is more you did not ask for".
-      partial: (cursor || bound !== undefined) ? true : undefined,
+      //   · a source of the key did not answer (`partial[key]`), and `unavailable`
+      //     carries the service's own account of which one.
+      // ⛔ Named `truncated` when it shipped in 0.17.0; renamed the same day, before
+      // any consumer adopted it, because "truncated" says something was cut and this
+      // also means "there is more you did not ask for".
+      partial: (cursor || key in degraded) ? true : undefined,
+      unavailable: key in degraded ? degraded[key] : undefined,
       pages: entry.page && entry.page > 1 ? entry.page : undefined,
     })
     entry.resolve(meta ? { data: collected, meta } : { data: collected })
@@ -491,8 +444,8 @@ async function flushAsked(url, queue, doFetch) {
 /**
  * Read one response and parse its body — the part of a fetch every view of an
  * address shares. A JSON body is parsed as JSON; anything else is tried as JSON
- * and kept as text when it is not. A failed response keeps its text, so a view
- * whose envelope names an error path can read a message out of it.
+ * and kept as text when it is not. A failed response keeps its text, so a caller
+ * can read a message out of it (the records service's problem details).
  */
 async function readResponse(doFetch, target, init) {
   const response = await doFetch(target, init)
@@ -522,12 +475,24 @@ function withMeta(fields) {
   return Object.keys(out).length ? out : undefined
 }
 
+/**
+ * The locale a list's texts are collated in: the page's (ruled 2026-09-14 [Diego]).
+ * A request asked in a locale carries it; otherwise the caller's — the website's
+ * active locale in the browser, the locale a host's prerender renders.
+ */
+function sortLocale(request, ctx) {
+  if (typeof request?.locale === 'string' && request.locale) return request.locale
+  if (typeof ctx?.locale === 'string' && ctx.locale) return ctx.locale
+  const active = ctx?.website?.getActiveLocale?.()
+  return typeof active === 'string' && active ? active : null
+}
+
 /**
  * Evaluate the query over what the source returned — the ONE evaluator,
  * `@uniweb/core`'s, so the browser orders and filters exactly as the build
  * did when it materialized `/data/<name>.json`.
  */
-function applyOperators(data, request, { dev = false } = {}) {
+function applyOperators(data, request, { dev = false, locale = null } = {}) {
   if (!Array.isArray(data)) return data
   let result = data
   // `scope` first: it names the branch the rest of the query reads. On this lane
@@ -535,7 +500,7 @@ function applyOperators(data, request, { dev = false } = {}) {
   // wrote the file — `scope: :dir` bound per page reaches here (2026-09-11).
   if (typeof request.scope === 'string' && request.scope) result = applyScope(result, request.scope)
   if (request.where) result = matchWhere(request.where, result)
-  if (request.sort) result = applySort(result, request.sort, dev)
+  if (request.sort) result = applySort(result, request.sort, dev, locale)
   if (typeof request.limit === 'number' && request.limit > 0) result = result.slice(0, request.limit)
   return result
 }
@@ -548,9 +513,9 @@ function applyOperators(data, request, { dev = false } = {}) {
  * logged once — a wrong order is not worth a broken page for a visitor.
  */
 const warnedBadSorts = new Set()
-function applySort(items, sortExpr, dev) {
+function applySort(items, sortExpr, dev, locale) {
   try {
-    return sortRecords(items, sortExpr)
+    return sortRecords(items, sortExpr, { locale })
   } catch (err) {
     if (dev) throw err
     const key = String(sortExpr)

package/src/prefetch.js

@@ -50,15 +50,14 @@
  * `{base}/…` from the payload, or the records service the host itself
  * published at `config.services.records`.
  */
-import { resolveFetchConfigs, routeQuery, sectionFetches } from '@uniweb/core/fetch-config'
+import { resolveFetchConfigs, pageRouteQuery, routeSelection, currentOf, othersView, siteReaches } from '@uniweb/core/fetch-config'
 import { deriveCacheKey } from '@uniweb/core/datastore'
 import { findPageForRoute, isDynamicRoute, routeBinding, parentRouteOf } from '@uniweb/core/route-match'
 import { buildDetailConfig } from '@uniweb/core/detail-url'
 import { resolveDefaultLocale } from '@uniweb/core/locale-config'
+import { findLayoutEntry } from '@uniweb/core/layout-name'
 import { createDefaultFetcher } from './default-fetcher.js'
 
-const isRefinement = (f) => f && typeof f === 'object' && f.refine === true
-
 /**
  * ⭐ **RE-EXPORTED, NOT IMPLEMENTED HERE — the rule lives in `@uniweb/core/route-match`.**
  *
@@ -88,11 +87,36 @@ function parentPageOf(page, pages) {
   return route ? byRoute.get(route) : null
 }
 
+/**
+ * The layout sections a page may render — every section of the layout areas it can
+ * use, subsections included. A page that names a layout uses that set (matched as the
+ * runtime matches it, `@uniweb/core/layout-name`) and nothing else; a page that names
+ * none uses its foundation's default layout, which a payload does not say, so every
+ * set's sections are included — a superset, which a prefetch can afford.
+ */
+function layoutSectionsFor(content, page) {
+  const sets = content?.layouts && typeof content.layouts === 'object' ? content.layouts : {}
+  const name = typeof page?.layout?.name === 'string' && page.layout.name ? page.layout.name : null
+  const named = name ? findLayoutEntry(sets, name) : undefined
+  const chosen = name ? (named ? [named] : []) : Object.values(sets)
+  const out = []
+  const walk = (sections) => {
+    for (const s of sections || []) {
+      if (!s || typeof s !== 'object') continue
+      out.push(s)
+      walk(s.subsections)
+    }
+  }
+  for (const set of chosen) for (const area of Object.values(set || {})) walk(area?.sections)
+  return out
+}
+
 /**
  * Every fetch config a page will need at render time, resolved once and de-duplicated by
- * cache key: the site-level fetch, the page's, its parent's, and each section's own
- * (including nested sections), each through `resolveFetchConfigs` — the same resolver the
- * entity store uses, so a host prefetches exactly what the render will ask for.
+ * cache key: the page's, its parent's, each section's own (including nested sections),
+ * its layout sections', and the site's where it reaches (`siteReaches`) — each through
+ * `resolveFetchConfigs`, the same resolver the entity store uses, so a host prefetches
+ * exactly what the render will ask for.
  *
  * @returns {Object[]} resolved fetch configs
  */
@@ -113,11 +137,22 @@ export function resolvePageFetchConfigs(content, route, { locale = null } = {})
     variables: binding?.variables ?? null,
   }
   const siteFetch = content?.config?.fetch ?? null
-  // The route query: the key this page's URL names one record of, by the rule the
-  // entity store reads it with (`routeQuery`) — never a payload field.
-  const routeKey = binding
-    ? routeQuery({ page: page.fetch, parent: parent?.fetch, site: siteFetch, sections: sectionFetches(page.sections) })?.key ?? null
+  // The route query: the key this page's URL names one record of, chosen at the page
+  // that captured its variable — by the rule the entity store reads it with
+  // (`pageRouteQuery`) — never a payload field.
+  const chosen = binding
+    ? pageRouteQuery(page, {
+        routeOf: (p) => p.route,
+        parentOf: (p) => parentPageOf(p, pages),
+        fetchOf: (p) => p.fetch ?? null,
+        sectionsOf: (p) => p.sections,
+        site: siteFetch,
+      })
     : null
+  const routeKey = chosen?.key ?? null
+  // A nested page's sections receive its capturing page's route binding, which the
+  // one-parent cascade may not reach — the entity store adds it the same way.
+  const routeSource = chosen?.nested ? chosen.config : null
 
   const out = new Map()
   const put = (cfg) => {
@@ -126,28 +161,47 @@ export function resolvePageFetchConfigs(content, route, { locale = null } = {})
   }
   const add = (sources) => {
     for (const cfg of resolveFetchConfigs(sources, options).values()) {
-      put(cfg)
+      const current = routeKey && cfg.as === routeKey ? currentOf(cfg) : null
+      if (current === 'exclude') {
+        // the list one longer, from which the render removes the page's record
+        put(othersView(cfg))
+        continue
+      }
+      if (current !== 'only') {
+        // any other key, or `current: include` — the list as the binding describes it
+        put(cfg)
+        continue
+      }
       // ⭐ A parametric page is ABOUT one record, and on a lane with a per-record
       // source (the records service, a `deferred:` query's per-record file) that
       // record is a request of its own. Built for EVERY config the route key
       // resolves to — a section re-declaring the route query asks its own record
       // question — by the one rule the entity store uses (`buildDetailConfig`), so
       // the question prefetched is the question the render asks.
-      if (routeKey && cfg.as === routeKey && cfg.detail && binding.paramValue !== undefined) {
+      if (cfg.detail && binding.paramValue !== undefined) {
         const detailCfg = buildDetailConfig(cfg, { paramName: binding.paramName, paramValue: String(binding.paramValue) })
         if (detailCfg) put(detailCfg)
       }
+      // On the records service the list is asked beside the record; off it, the
+      // record is FOUND in the route query's whole selection — the list without its
+      // `limit` (`routeSelection`) — which is all the render reads for it.
+      put(cfg.ask ? cfg : routeSelection(cfg))
     }
   }
-  // The cascade a block sees: its own fetch (unless a refinement), page, parent, site.
-  add([page.fetch ?? null, parent?.fetch ?? null, siteFetch])
+  // The cascade a block sees: its own fetch, page, parent, a nested page's route
+  // binding, and the site's — which reaches a top-level page's sections only.
+  const siteForPage = siteReaches(parent) ? siteFetch : null
+  add([page.fetch ?? null, parent?.fetch ?? null, routeSource, siteForPage])
   const walk = (sections) => {
     for (const s of sections || []) {
-      if (s?.fetch && !isRefinement(s.fetch)) add([s.fetch, page.fetch ?? null, parent?.fetch ?? null, siteFetch])
+      if (s?.fetch) add([s.fetch, page.fetch ?? null, parent?.fetch ?? null, routeSource, siteForPage])
       if (s?.subsections) walk(s.subsections)
     }
   }
   walk(page.sections)
+  // ⭐ Layout sections belong to the site: the site's binding reaches them on every
+  // page, beside each one's own fetch. A layout area has no parent page.
+  for (const s of layoutSectionsFor(content, page)) add([s.fetch ?? null, siteFetch])
   return [...out.values()]
 }
 
@@ -162,7 +216,7 @@ export function resolvePageFetchConfigs(content, route, { locale = null } = {})
  * @param {boolean} [opts.dev]
  * @returns {Promise<Array<{ config: Object, outcome: 'fetched'|'failed'|'skipped', data: any, error?: string }>>}
  */
-export async function executeFetchConfigs(configs, { content, fetch = null, dev = false, prerender = 'always' } = {}) {
+export async function executeFetchConfigs(configs, { content, fetch = null, dev = false, prerender = 'always', locale = null } = {}) {
   if (prerender !== 'author' && prerender !== 'always') {
     throw new Error(`executeFetchConfigs: prerender must be 'author' or 'always', got ${JSON.stringify(prerender)}`)
   }
@@ -171,7 +225,8 @@ export async function executeFetchConfigs(configs, { content, fetch = null, dev
     dev,
     fetch,
   })
-  const ctx = { website: null }
+  // The page's locale, which a list's texts are collated in when the runtime sorts it.
+  const ctx = { website: null, locale: locale ?? content?.config?.activeLocale ?? resolveDefaultLocale(content?.config) ?? null }
   // Dispatched together, not one after another: the records service batches the
   // requests issued in one tick into one POST, and a page's configs are
   // independent of each other. Order is preserved in the result.
@@ -190,5 +245,5 @@ export async function executeFetchConfigs(configs, { content, fetch = null, dev
 /** Resolve and execute in one call: what a host passes the isolate as `fetchedData`. */
 export async function prefetchPageData({ content, route, locale = null, fetch = null, dev = false, prerender = 'always' }) {
   const configs = resolvePageFetchConfigs(content, route, { locale })
-  return executeFetchConfigs(configs, { content, fetch, dev, prerender })
+  return executeFetchConfigs(configs, { content, fetch, dev, prerender, locale })
 }