@uniweb/runtime 0.23.0 → 0.25.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/runtime",
-  "version": "0.23.0",
+  "version": "0.25.0",
   "description": "Minimal runtime for loading Uniweb foundations",
   "type": "module",
   "exports": {
@@ -36,7 +36,7 @@
     "node": ">=20.19"
   },
   "dependencies": {
-    "@uniweb/core": "^0.27.0",
+    "@uniweb/core": "^0.29.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.2"
+    "@uniweb/build": "0.49.0"
   },
   "peerDependencies": {
     "react": "^19.0.0",

package/src/collect-records.js

@@ -15,19 +15,21 @@
  * page render uses**, applying each saved query's own `scope` and `where` — and
  * asks through the same client.
  *
- * ## ⛔ `limit` IS DROPPED, and it is the one place a corpus must diverge
+ * ## ⭐ Each query is asked AS SAVED — its `limit` included
  *
- * A saved query's `limit` is the LIST PAGE's presentation: `limit: 20` means the
- * page shows twenty. **Its detail pages still exist for every record matching
- * `scope` + `where`** — so a corpus that honoured `limit` would index twenty and
- * miss every page beyond them, which is worse than indexing nothing because the
- * gap is invisible.
+ * A query defines its SET: the records its `scope` and `where` select, in its
+ * `sort`, up to its `limit` (ruled 2026-09-14 [Diego]). A parametric page has a URL
+ * for each record of its route query's set and no other, so the set is exactly the
+ * population a site's pages reach — a field note older than a query's 100 most recent
+ * has no page to index. Asked with no `narrow`, the service answers the set whole in
+ * one answer, so a walk has nothing to page; it still follows a cursor if one ever
+ * comes back, bounded by `maxPages`.
  *
- * ⚠️ **This shipped wrong in 0.17.0 and was found by the consumer, not by us**
- * (2026-09-06): the config was passed through unchanged, `limit` crossed as the
- * question's own, and the corpus was capped. The claim that this surface met
- * "the population its detail pages can reach" was made *"read charitably"* — a
- * phrase doing work that one `sed` would have done better.
+ * ⛔ **Until 2026-09-14 this dropped the query's `limit`**, on the rule it replaced — a
+ * `limit` was the list page's presentation and every record matching `scope` + `where`
+ * had a page — which was right under that rule. ⚠️ And that rule's own history: the
+ * first version, in 0.17.0, passed `limit` through while claiming the corpus was the
+ * population detail pages reach, and the consumer found it (2026-09-06).
  *
  * ## What the caller supplies
  *
@@ -57,18 +59,20 @@ 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`.
- * @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.
+ *   rankings would produce. The cost is the caller's, and bounded by each query's
+ *   own `limit`. An external query is never collected — it has no records service
+ *   to ask.
+ * @param {number} [options.maxPages] - the caller's own bound on a walk that pages. A
+ *   question with no `narrow` is answered whole with no cursor, so today's walk is one
+ *   request per query; the bound holds should a service page anyway.
  * @returns {Promise<{records: Object, errors: Object|null, meta: Object}>}
  *   `records` is keyed by query NAME, each a flat array; `errors` is keyed the
- *   same and is null when nothing failed; `meta[name]` carries
- *   `{ depth, pages, partial?, bound? }`.
+ *   same and is null when nothing failed; `meta[name]`, when there is anything to
+ *   say, carries `{ whole?, pages?, partial?, unavailable? }`.
  *
  *   ⭐ **`partial` means NOT THE WHOLE POPULATION**, and a key can be in BOTH
  *   `records` and `errors`: a walk that failed or was aborted with pages already
@@ -109,9 +113,8 @@ export async function collectSiteRecords(
     // `path` has no live lane, and reading that file is the caller's business,
     // not ours — it is in the site's own URL space and they already serve it.
     if (!cfg.ask) return
-    // `limit` is the list page's, never the corpus's — see the header.
-    const { limit, ...population } = cfg
-    const asked = { ...population, whole, exhaustive: true }
+    // The query as saved — the set its pages reach, its `limit` included; see the header.
+    const asked = { ...cfg, whole, exhaustive: true }
     if (typeof maxPages === 'number' && maxPages > 0) asked.maxPages = maxPages
 
     const result = await fetcher.resolve(asked, { signal })

package/src/default-fetcher.js

@@ -15,10 +15,11 @@
  *     question the page asked, answered per key (the records contract, as this
  *     client reads it).
  *
- * `where:` / `sort:` / `limit:` are evaluated HERE, locally, over what the
- * first lane returns — with `@uniweb/core`'s one evaluator, the same the build
- * uses to materialize a file — and at the source when asked. Nothing decides
- * that per site: the LANE decides.
+ * A query's set — `scope:` / `where:` / `sort:` / `limit:` — and the `narrow`
+ * a fetch takes of it are evaluated HERE, locally, over what the first lane
+ * returns — with `@uniweb/core`'s one evaluator (`evaluateQuery`), the same the
+ * build uses — and at the source when asked. Nothing decides that per site: the
+ * LANE decides.
  *
  * ⛔ RETIRED 2026-09-04 [Diego]: `fetcher.baseUrl`, `headers`, `envelope`,
  * `supports`, `request.style` / `request.rename` and the `json-body`
@@ -52,8 +53,7 @@
 
 import {
   substitutePlaceholders,
-  matchWhere,
-  applyScope,
+  evaluateQuery,
   sortRecords,
   sortToWire,
   deriveCacheKey,
@@ -209,7 +209,7 @@ export function createDefaultFetcher({ basePath = '', dev = false, fetch: fetchI
         // (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
@@ -230,14 +230,27 @@ 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 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.
+ * (the records contract, §2).
+ * ⭐ TWO LEVELS, ruled 2026-09-14 [Diego]:
+ *
+ *   - **the top level is the query as saved** — `schema` (required), `scope` a bare
+ *     path, `where`, `sort` one key spelled `date` / `-date`, `limit` — and `whole`
+ *     when the whole record is wanted. Its records are the set, and the top level is
+ *     the same on every question about it;
+ *   - **`narrow`** — how this page takes less than the set: `where`, `match` (a
+ *     parametric page's record), `sort`, `cursor` (to resume a previous answer) and
+ *     `limit`. Absent when the question asks for the set as it is.
+ *
+ * ⛔ Until 2026-09-14 the two were one flat question — the page's `where` joined the
+ * query's, its `sort` and `limit` replaced the query's — and `match` and `cursor` sat
+ * at the top level, where the service no longer takes them. There is no fallback:
+ * the service answers an unknown or misplaced field with a `400` for the request.
+ *
+ * ⭐ A 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 retired operator) is sent as written and
+ * answered there: never approximated.
  */
 function toQuestion(request) {
   const q = { schema: request.schema }
@@ -248,50 +261,87 @@ function toQuestion(request) {
   const scope = typeof request.scope === 'string' && request.scope ? request.scope : null
   if (scope) q.scope = scope
   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).
-  if (request.match && typeof request.match === 'object') q.match = request.match
-  const sort = sortToWire(request.sort)
+  const sort = wireSort(request.sort)
   if (sort) q.sort = sort
   if (typeof request.limit === 'number' && request.limit > 0) q.limit = request.limit
   // ⛔ ONLY WHEN TRUE. The brief is the default and absent means the brief, so
   // sending `whole: false` would be noise on every list question the client makes.
   if (request.whole === true) q.whole = true
-  // ⭐ `cursor` is the ONLY field here that is not the author's: it is opaque and
-  // it comes from a previous answer's `cursors` (the records contract §2). ⛔ And
-  // `exhaustive` deliberately does NOT cross — it is a client instruction about
-  // how many times to ask, not part of the question being asked.
-  if (typeof request.cursor === 'string' && request.cursor) q.cursor = request.cursor
-  // ⛔ `maxPages` does not cross either, for the same reason `exhaustive` does not:
-  // both say how many times to ask, never what is being asked.
+  const narrow = toNarrow(request.narrow)
+  if (narrow) q.narrow = narrow
+  // ⛔ `exhaustive` and `maxPages` deliberately do NOT cross — they are client
+  // instructions about how many times to ask, never part of what is being asked.
   return q
 }
 
+/**
+ * A question's `narrow`, with only the fields the service takes inside it — any other
+ * is a `400` for the whole request there — or `null` when nothing is left.
+ *
+ *   - `where` crosses as authored;
+ *   - `match` — the record of a parametric page: one key and the URL's value, beside
+ *     the author's `where`, never merged into it (`buildDetailConfig`);
+ *   - `sort` in the service's spelling;
+ *   - ⭐ `cursor` — the ONLY field in a question that is not the author's: opaque, from a
+ *     previous answer's `cursors`, sent back on the same question and nothing else
+ *     changed. A cursor is a narrowing like the rest, so the top level stays the query as
+ *     saved on every page;
+ *   - `limit`, when it cuts.
+ */
+function toNarrow(narrow) {
+  if (!narrow || typeof narrow !== 'object') return null
+  const n = {}
+  if (narrow.where && typeof narrow.where === 'object') n.where = narrow.where
+  if (narrow.match && typeof narrow.match === 'object') n.match = narrow.match
+  const sort = wireSort(narrow.sort)
+  if (sort) n.sort = sort
+  if (typeof narrow.cursor === 'string' && narrow.cursor) n.cursor = narrow.cursor
+  if (typeof narrow.limit === 'number' && narrow.limit > 0) n.limit = narrow.limit
+  return Object.keys(n).length > 0 ? n : null
+}
+
+/**
+ * A `sort` in the service's spelling — `date` / `-date` — or, for one outside the
+ * language, the author's text AS WRITTEN, which the service answers by its own rule
+ * (ignored: the author's arrangement). ⛔ Never a throw: this runs while a page's whole
+ * batch is being composed, before any request, and until 2026-09-14 a sort `parseSort`
+ * refuses — two keys, a bad direction — threw here and left every question of the batch
+ * pending forever.
+ */
+function wireSort(sort) {
+  try {
+    return sortToWire(sort)
+  } catch {
+    return typeof sort === 'string' && sort.trim() ? sort : null
+  }
+}
+
 /**
  * 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 past the
+ * question's `narrow.limit` — a query's own `limit` defines the set and never produces
+ * one; `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
@@ -360,14 +410,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
@@ -375,21 +425,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'
@@ -397,7 +437,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.
@@ -408,32 +447,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 })
@@ -442,10 +479,13 @@ async function flushAsked(url, queue, doFetch) {
   if (pending.size === 0) return
   // Re-ask each unfinished key on its own — the cursor is per key, so a batch
   // would have to correlate several independent positions through one body.
+  // ⭐ The cursor rides inside `narrow` and NOTHING ELSE in the question changes: the
+  // service resumes only the question a cursor came from, and answers a cursor sent
+  // with anything else changed with a `400`.
   await Promise.all([...pending].map(([entry, state]) => {
     const next = {
       ...entry,
-      request: { ...entry.request, cursor: state.cursor },
+      request: { ...entry.request, narrow: { ...(entry.request.narrow || {}), cursor: state.cursor } },
       collected: state.collected,
       page: state.page,
     }
@@ -487,22 +527,30 @@ 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`.
+ * `@uniweb/core`'s `evaluateQuery`, so the browser orders and filters exactly as
+ * the build does: the query's set first (`scope` over each record's placement,
+ * `where`, `sort`, `limit`), then the fetch's `narrow` of it. Only the sort is this
+ * lane's own, for what it does with a bad `sort:` in production.
  */
-function applyOperators(data, request, { dev = false } = {}) {
-  if (!Array.isArray(data)) return data
-  let result = data
-  // `scope` first: it names the branch the rest of the query reads. On this lane
-  // it is evaluated over each record's placement (`path`), as the build did when it
-  // 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 (typeof request.limit === 'number' && request.limit > 0) result = result.slice(0, request.limit)
-  return result
+function applyOperators(data, request, { dev = false, locale = null } = {}) {
+  return evaluateQuery(data, request, {
+    locale,
+    sort: (items, sortExpr, options) => applySort(items, sortExpr, dev, options.locale),
+  })
 }
 
 /**
@@ -513,9 +561,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,7 +50,7 @@
  * `{base}/…` from the payload, or the records service the host itself
  * published at `config.services.records`.
  */
-import { resolveFetchConfigs, pageRouteQuery, routeSelection, currentOf, othersView, siteReaches } from '@uniweb/core/fetch-config'
+import { resolveFetchConfigs, fetchEntries, pageRouteQuery, routeSelection, currentFor, 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'
@@ -149,7 +149,6 @@ export function resolvePageFetchConfigs(content, route, { locale = null } = {})
         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
@@ -159,33 +158,42 @@ export function resolvePageFetchConfigs(content, route, { locale = null } = {})
     const key = deriveCacheKey(cfg)
     if (!out.has(key)) out.set(key, cfg)
   }
+  // ⭐ EVERY fetch of every level, each resolved on its own — not the first per key. A section
+  // receives the keys its component declares, and two fetches of one `as` at two levels can
+  // fill two of them (`fillDeclaredKeys`, 2026-09-14), which a prefetch holding no
+  // component's meta cannot rule out. A superset, which a prefetch can afford.
   const add = (sources) => {
-    for (const cfg of resolveFetchConfigs(sources, options).values()) {
-      const current = routeKey && cfg.as === routeKey ? currentOf(cfg) : null
+    const resolved = sources.flatMap((source) => fetchEntries(source).map((entry) => resolveFetchConfigs([entry], options).get(entry.as)))
+    for (const cfg of resolved.filter(Boolean)) {
+      // how the fetch uses the page's record — by the query it names, as the entity store asks
+      const current = currentFor(cfg, chosen)
       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
+        // no part for the page's record, or `current: include` — the list as the fetch 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.
+      // record is a request of its own. Built for EVERY config that takes the page's
+      // record, by the one rule the entity store uses (`buildDetailConfig`), so
+      // the question prefetched is the question the render asks — and since that
+      // question drops a fetch's own narrowing, sections that narrow differently ask
+      // one record question between them.
       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))
+      // ⭐ On the records service the record question checks the query's set on its
+      // own, so nothing else is asked. Off it, the record is FOUND in the set —
+      // the query as saved, without the fetch's `narrow` (`routeSelection`) — which is
+      // all the render reads for it. ⛔ Until 2026-09-14 the service's list was asked
+      // beside the record, and the page embedded the whole set to show one record.
+      if (!cfg.ask) put(routeSelection(cfg))
     }
   }
   // The cascade a block sees: its own fetch, page, parent, a nested page's route
@@ -216,7 +224,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)}`)
   }
@@ -225,7 +233,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.
@@ -244,5 +253,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 })
 }