@uniweb/core 0.26.2 → 0.27.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/core",
-  "version": "0.26.2",
+  "version": "0.27.0",
   "description": "Core classes for the Uniweb platform - Uniweb, Website, Page, Block",
   "type": "module",
   "exports": {
@@ -11,6 +11,7 @@
     "./datastore": "./src/datastore.js",
     "./detail-url": "./src/detail-url.js",
     "./fetch-config": "./src/fetch-config.js",
+    "./layout-name": "./src/layout-name.js",
     "./icon-corpus": "./src/icon-corpus.js",
     "./locale-config": "./src/locale-config.js",
     "./route-match": "./src/route-match.js",

package/src/data-paths.js

@@ -115,8 +115,8 @@ export function queryNameFromUrl(path) {
  * Whether a fetch config's `path` addresses compiled query data.
  *
  * Used to scope behavior that only makes sense for build-emitted files —
- * locale prefixing in particular, which must not touch a remote `url:`
- * source or an author-declared `detailUrl:`.
+ * locale prefixing in particular, which must not touch an external query's
+ * `url:`.
  *
  * @param {*} path - A fetch config's `path` field.
  * @returns {boolean}

package/src/detail-url.js

@@ -1,14 +1,14 @@
 /**
- * Detail-record resolution — the ONE home for turning a query's `detail:`
- * declaration plus a dynamic route's params into a fetch config.
+ * Detail-record resolution — the ONE home for turning a resolved query config plus
+ * a parametric page's route value into the request for its record.
  *
  * Why this is a subpath rather than an EntityStore internal. A host that
  * renders a detail page server-side has to fetch *the same record* the browser
- * will fetch when it hydrates over that render. The four `detail:` forms below
- * each decide a different URL, so a host that resolves them even slightly
- * differently prerenders record A and hydrates record B — silently, and only on
- * the routes that have a pattern. That is the same failure `./route-match.js`
- * was extracted to end, on the fetch side instead of the routing side.
+ * will fetch when it hydrates over that render. If the two build the request even
+ * slightly differently, a host prerenders record A and the browser hydrates
+ * record B — silently, and only on parametric pages. That is the same failure
+ * `./route-match.js` was extracted to end, on the fetch side instead of the
+ * routing side.
  *
  * Zero-dependency leaf, like `./route-match.js`, `./data-paths.js` and
  * `./fetch-config.js`: it imports one sibling that itself imports nothing, so a
@@ -26,22 +26,15 @@ import { recordHandle, routeRecordKey } from './route-match.js'
 import { substitutePlaceholders } from './substitute-placeholders.js'
 
 /**
- * The substitution context for a detail pattern: the route's own param name,
+ * The substitution context for a record request: the route's own param name,
  * plus a generic `param` alias bound to the same value.
  *
- * ⭐ Why the alias exists. An AUTHOR writing a detail pattern knows their route
- * and writes `{slug}` or `{id}` — that convention is unchanged and must stay,
- * because it is what every existing site and the auto-injected per-record
- * pattern use. A HOST declaring a record address cannot know it: `param_name`
- * is the site's routing choice, and the host is publishing one pattern for
- * every site it serves. So the host writes `{param}`.
- *
- * Binding both names to one value is what lets the two conventions coexist
- * without a translation step between them — and a translation step is exactly
- * where the framework has twice grown a second copy of a rule that then drifted
- * (`route-match`, `data-paths`). `substitutePlaceholders` only resolves keys
- * present in the context, so an unrelated `{name}` still passes through
- * literally, as it always has.
+ * ⭐ Why the alias exists. An AUTHOR writing a record address knows their route
+ * and writes `{slug}` or `{id}` — that convention is unchanged and must stay. A
+ * HOST declaring a record address cannot know it: `param_name` is the site's
+ * routing choice. So the host writes `{param}`. `substitutePlaceholders` only
+ * resolves keys present in the context, so an unrelated `{name}` still passes
+ * through literally.
  */
 function paramContext(paramName, paramValue, record) {
   const context = { [paramName]: paramValue, param: paramValue }
@@ -62,33 +55,6 @@ function paramContext(paramName, paramValue, record) {
   return context
 }
 
-/**
- * Build a detail-URL fetch config from a query config + dynamic context.
- *
- * Four forms of `detail:`:
- *   - `'rest'`                — append paramValue as a path segment.
- *   - `'query'`               — append `?paramName=paramValue`.
- *   - `'/articles/{slug}'`    — custom URL pattern with {paramName} placeholders,
- *                               or the generic `{param}` alias (see below).
- *   - `{ body, envelope }`    — object form. Reuses the query's url /
- *                               method / headers / auth; adds per-detail
- *                               body (with placeholder substitution) and
- *                               per-detail envelope.
- *
- * Returns `null` — never throws — when the query declares no `detail:`,
- * when the dynamic context carries no param, or when the query has
- * neither `url:` nor `path:` to build from. A caller treats `null` as "this
- * query has no separate detail fetch", which is the common case.
- *
- * @param {Object} queryConfig - A resolved fetch config for the query
- *   (post-`resolveFetchConfigs`, so `detail` may have been auto-injected for a
- *   `deferred:` query — see `./fetch-config.js`).
- * @param {{ paramName: string, paramValue: string, record?: Object|null }} dynamicContext -
- *   the route's param and its value; `record`, when the caller already holds the
- *   matched record, lets `{slug}` resolve to the record's own slug (see
- *   `paramContext`).
- * @returns {Object|null} A fetch config carrying `url` or `path`, or null.
- */
 /**
  * The record key a `[slug]` (or `[...path]`) route matches — the entry's own
  * handle, which the records service guarantees unique among siblings (the
@@ -98,6 +64,33 @@ function paramContext(paramName, paramValue, record) {
  */
 export const ROUTE_HANDLE_KEY = routeRecordKey('slug')
 
+/**
+ * Build the request for a parametric page's record from its route query's resolved
+ * config (post-`resolveFetchConfigs`, which set `detail` — see `./fetch-config.js`).
+ * Three sources, and no others:
+ *
+ *   - **the records service** — the route query's own question, plus `match`;
+ *   - **an external query's `record:`** — its `url` (the query's when it names none),
+ *     `method` (likewise), `body` and `transform` — ⛔ never the list's `body` or
+ *     `transform`, since a record response is rarely wrapped the way the list is;
+ *   - **a `deferred:` query's per-record file** — the `/data/<query>/{slug}.json`
+ *     pattern the resolver injected.
+ *
+ * ⛔ The `detail:` forms an author wrote until 2026-09-13 — `rest`, `query`, a URL
+ * pattern and `{ body, envelope }` — are gone with inline `url:` fetches [Diego]: an
+ * external query's `record:` says the same thing, on the query. The record request
+ * reused the list's `transform` until then, so a list under `results` and a bare
+ * record endpoint delivered `[]` (measured).
+ *
+ * Returns `null` — never throws — when the config has no per-record source or the
+ * route carries no value. A caller treats `null` as "find the record in the list".
+ *
+ * @param {Object} queryConfig - a resolved config
+ * @param {{ paramName: string, paramValue: string, record?: Object|null }} dynamicContext -
+ *   the route's param and its value; `record`, when the caller already holds the
+ *   matched record, lets `{slug}` resolve to the record's own slug (`paramContext`).
+ * @returns {Object|null} a request, or null
+ */
 export function buildDetailConfig(queryConfig, dynamicContext) {
   const { detail } = queryConfig
   if (!detail) return null
@@ -125,88 +118,36 @@ export function buildDetailConfig(queryConfig, dynamicContext) {
     }
   }
 
-  // Two address kinds, and the detail request comes back as the SAME kind as
-  // the list: a `url` the author wrote stays a `url`, a compiled `path` stays a
-  // `path`.
-  const baseUrl = queryConfig.url || queryConfig.path
-  if (!baseUrl) return null
-  const addressKey = queryConfig.url ? 'url' : 'path'
-
-  // What every detail config carries beside its address:
+  // What every other record request carries beside its address:
   //   `as`             — the binding key, so the record lands where the list did;
-  //   `query`          — the query it is one record of (identity when asked);
-  //   `depth: 'full'`  — what it asks for, and what the record index files it as;
-  //   `dynamicContext` — the route param, which the default fetcher already keys
-  //                      a SINGLE-RECORD response on (`envelope.item`, body
-  //                      placeholders). ⛔ The entity store never passed it, so
-  //                      a live lane's bare record response was unwrapped with
-  //                      the LIST key and read as `[]` (found 2026-09-04).
+  //   `query`          — the query it is one record of;
+  //   `whole: true`    — what it asks for, and what the record index files it as;
+  //   `dynamicContext` — the route param, which the default fetcher substitutes
+  //                      into a POST body;
   //   `locale`         — carried from the list, so the two share a locale.
-  const common = {
-    as: queryConfig.as,
-    transform: queryConfig.transform,
-    whole: true,
-    dynamicContext: { paramName, paramValue },
-  }
+  const common = { as: queryConfig.as, whole: true, dynamicContext: { paramName, paramValue } }
   if (typeof queryConfig.query === 'string') common.query = queryConfig.query
   if (queryConfig.locale !== undefined) common.locale = queryConfig.locale
+  const context = paramContext(paramName, paramValue, record)
 
-  // Object form: `detail: { body, envelope }`. Reuses the query's URL +
-  // method + headers + auth. The body is placeholder-substituted against
-  // the dynamic context so `body: { variables: { slug: "{slug}" } }` works.
-  if (detail && typeof detail === 'object') {
+  // ⭐ AN EXTERNAL QUERY'S `record:`.
+  const spec = queryConfig.record
+  if (spec && typeof spec === 'object' && typeof queryConfig.url === 'string') {
     const out = {
-      [addressKey]: baseUrl,
+      url: typeof spec.url === 'string' && spec.url ? substitutePlaceholders(spec.url, context) : queryConfig.url,
       ...common,
     }
-    if (queryConfig.method) out.method = queryConfig.method
-    if (detail.body !== undefined) {
-      out.body = substitutePlaceholders(detail.body, paramContext(paramName, paramValue, record), { encode: false })
-    } else if (queryConfig.body !== undefined) {
-      out.body = substitutePlaceholders(queryConfig.body, paramContext(paramName, paramValue, record), { encode: false })
-    }
-    if (detail.envelope) out.envelope = detail.envelope
+    const method = typeof spec.method === 'string' && spec.method ? spec.method : queryConfig.method
+    if (method) out.method = method
+    if (spec.body !== undefined && spec.body !== null) out.body = substitutePlaceholders(spec.body, context, { encode: false })
+    if (typeof spec.transform === 'string' && spec.transform) out.transform = spec.transform
     return out
   }
 
-  // String-form: URL-based conventions.
-  //
-  // ⭐ `rest` and `query` BUILD FROM THE LIST URL, so its query string survives onto
-  // the detail request. That is deliberate and it is the safe default: the params
-  // that matter most to a single-record read are exactly the ones a list carries —
-  // `?lang=`, an API key, a tenancy id. Dropping them would 401 the detail request
-  // or return the wrong language, on every detail page.
-  //
-  // ⚠️ The cost is real and lands on ONE category: a PROJECTION param (`?fields=`,
-  // `?select=`) asks the API for a summary, and carrying it truncates the very
-  // record the detail fetch exists to get in full. The request still succeeds and
-  // only some fields are missing, so it reads as a component or API fault rather
-  // than a URL one.
-  //
-  // ⛔ Framework cannot tell the categories apart — they are the host's vocabulary,
-  // not ours. So the default keeps everything and the CUSTOM PATTERN form is the
-  // way out: it is used verbatim, so nothing carries over unless the author writes
-  // it. Documented for authors in `docs/reference/dynamic-routes.md` § *The list's
-  // query string carries over*.
-  let detailUrl
-  if (detail === 'rest') {
-    const [basePath, queryString] = baseUrl.split('?')
-    const cleanBase = basePath.replace(/\/$/, '')
-    detailUrl = queryString
-      ? `${cleanBase}/${encodeURIComponent(paramValue)}?${queryString}`
-      : `${cleanBase}/${encodeURIComponent(paramValue)}`
-  } else if (detail === 'query') {
-    const sep = baseUrl.includes('?') ? '&' : '?'
-    detailUrl = `${baseUrl}${sep}${paramName}=${encodeURIComponent(paramValue)}`
-  } else {
-    // Custom pattern like '/articles/{slug}' — substitute placeholders
-    // from the dynamic-route context. Only placeholders matching the
-    // active paramName resolve; others pass through as literal `{name}`.
-    detailUrl = substitutePlaceholders(detail, paramContext(paramName, paramValue, record))
+  // ⭐ A `deferred:` QUERY'S PER-RECORD FILE — the pattern `applyDeferredDetail` injected.
+  if (typeof detail === 'string' && typeof queryConfig.path === 'string') {
+    return { path: substitutePlaceholders(detail, context), ...common }
   }
 
-  return {
-    [addressKey]: detailUrl,
-    ...common,
-  }
+  return null
 }

package/src/entity-store.js

@@ -14,9 +14,8 @@
  * and in-flight dedup.
  */
 
-import { isFetchRefinement, resolveFetchConfigs, routeQuery, sectionFetches } from './fetch-config.js'
+import { resolveFetchConfigs, pageRouteQuery, routeSelection, currentOf, othersView, othersOf, siteReaches } from './fetch-config.js'
 import { fillRoutePattern, matchesRouteParam } from './route-match.js'
-import { sortRecords } from './sort.js'
 
 /**
  * A fetch config's binding key — the `content.data.<key>` a component reads.
@@ -26,41 +25,12 @@ import { sortRecords } from './sort.js'
 const bindingKeyOf = (cfg) => cfg?.as
 import { buildDetailConfig } from './detail-url.js'
 
-/**
- * Is `block.fetch` a per-instance refinement of the ancestor's fetch config
- * rather than a new source? The spelling is `refine: true`.
- *
- * The predicate itself lives in `./fetch-config.js` with the rest of the
- * cascade rule; this alias keeps the local call sites reading as they did.
- */
-const isRefinement = isFetchRefinement
-
-/**
- * `fetch: { inherit: true }` was the earlier spelling of `refine: true`, kept
- * "for one release" from April 2026 and removed on 2026-09-02. It is refused
- * rather than ignored: ignored, the declaration would read as a source with no
- * location and the block would render empty with nothing to say why. Dev
- * throws, so a page does not render on the old spelling; production logs once
- * and the caller drops the declaration, so the block receives the cascaded
- * data unrefined.
- */
-let inheritRefusalLogged = false
-function refuseInheritAlias(block, dev) {
-  const message =
-    "[uniweb] 'fetch: { inherit: true }' is no longer accepted; write 'fetch: { refine: true }'. " +
-    `Seen on block ${block?.id ?? '(unknown)'} of page ${block?.page?.route ?? '(unknown)'}.`
-  if (dev) throw new Error(message)
-  if (inheritRefusalLogged) return
-  inheritRefusalLogged = true
-  console.error(message)
-}
-
 export default class EntityStore {
   /**
    * @param {Object} options
    * @param {import('./website.js').default} options.website
-   * @param {boolean} [options.dev=false] - dev mode: a retired spelling throws
-   *   instead of logging once.
+   * @param {boolean} [options.dev=false] - dev mode: a failed fetch is logged
+   *   where the author is looking.
    */
   constructor({ website, dev = false }) {
     this.website = website
@@ -68,34 +38,6 @@ export default class EntityStore {
     Object.seal(this)
   }
 
-  _shouldInheritDetail(meta, block) {
-    const bf = block?.fetch
-    if (isRefinement(bf) && bf?.detail !== undefined) return bf.detail !== false
-    if (!meta) return true
-    return meta.inheritDetail !== false
-  }
-
-  _inheritLimit(meta, block) {
-    const bf = block?.fetch
-    if (isRefinement(bf) && bf?.limit > 0) return bf.limit
-    return (meta?.inheritLimit > 0) ? meta.inheritLimit : null
-  }
-
-  _inheritOrder(block) {
-    const bf = block?.fetch
-    if (isRefinement(bf) && bf?.order?.orderBy) return bf.order
-    return null
-  }
-
-  /**
-   * A refine block's `order: { orderBy, sortOrder }` — the same one-key sort the
-   * build and the fetcher fallback run (`./sort.js`), so the three cannot drift.
-   */
-  _sortItems(items, order) {
-    if (!order?.orderBy) return items
-    return sortRecords(items, { field: order.orderBy, desc: order.sortOrder === 'DESC' })
-  }
-
   /**
    * Which schemas does this component want delivered?
    *
@@ -120,13 +62,8 @@ export default class EntityStore {
    * re-inline it here — divergence between copies is what the extraction
    * exists to prevent.
    */
-  _findFetchConfigs(block, requested) {
-    let blockFetch = block.fetch
-    if (blockFetch?.inherit !== undefined) {
-      refuseInheritAlias(block, this.dev)
-      blockFetch = null
-    }
-
+  _findFetchConfigs(block, requested, route = this._route(block)) {
+    const blockFetch = block.fetch
     const page = block.page
     const website = block.website
     const dynamicContext = block.dynamicContext || page?.dynamicContext
@@ -147,10 +84,16 @@ export default class EntityStore {
 
     return resolveFetchConfigs(
       [
-        blockFetch && !isRefinement(blockFetch) ? blockFetch : null,
+        blockFetch,
         page?.fetch,
         page?.parent?.fetch,
-        website?.config?.fetch,
+        // ⭐ A page nested inside a parametric page receives its capturing page's
+        // route binding — the cascade reaches one parent up, and the binding may sit
+        // above that (`pageRouteQuery`). Its key only; the rest does not cascade.
+        route?.nested ? route.config : null,
+        // The site's binding reaches a layout section and a top-level page's
+        // sections, and nothing deeper (`siteReaches`).
+        siteReaches(page?.parent) ? website?.config?.fetch : null,
       ],
       {
         schemas: requested,
@@ -171,30 +114,33 @@ export default class EntityStore {
   }
 
   /**
-   * The binding key whose records a parametric page's URL narrows to one — its
-   * ROUTE QUERY (`routeQuery`, `./fetch-config.js`), worked out from the same
-   * sources `_findFetchConfigs` walks: the page's fetch, its parent's, the site's,
-   * and, when none of those declares one, the key the page's sections share. So
-   * what a section receives and what the URL narrows are read off one walk and
-   * cannot disagree.
+   * The ROUTE QUERY of the block's page — the query its URL names one record of —
+   * worked out from the same sources `_findFetchConfigs` walks, at the page that
+   * captured the URL's variable (`pageRouteQuery`, `./fetch-config.js`): its fetch,
+   * its parent's, the site's, and, when none of those declares one, the key its
+   * sections share. So what a section receives and what the URL narrows are read
+   * off one walk and cannot disagree.
    *
    * ⛔ This was `dynamicContext.schema`, stored on the page by whoever built it —
    * the SPA from `parentSchema`, the static build from the parent's first
    * prerendered fetch — a stored copy of a derived answer, computed by a different
    * rule from the one sections are fed by. Deleted 2026-09-11 [Diego].
    *
-   * @returns {string|null} null off a parametric page, or when it has no route query
+   * @returns {{ key: string, config: Object, nested: boolean }|null} null off a
+   *   parametric page, or when it has no route query
    */
-  _routeKey(block) {
+  _route(block) {
     const dynamicContext = block.dynamicContext || block.page?.dynamicContext
-    if (!dynamicContext) return null
-    const page = block.page
-    return routeQuery({
-      page: page?.fetch,
-      parent: page?.parent?.fetch,
+    if (!dynamicContext || !block.page) return null
+    return pageRouteQuery(block.page, {
+      // a concrete page carries its template's route; its ancestors are templates, or
+      // pages the static build expanded, which carry theirs the same way
+      routeOf: (p) => p?.dynamicContext?.templateRoute ?? p?.route,
+      parentOf: (p) => p?.parent ?? null,
+      fetchOf: (p) => p?.fetch,
+      sectionsOf: (p) => p?._bodySections,
       site: block.website?.config?.fetch,
-      sections: sectionFetches(page?._bodySections),
-    })?.key ?? null
+    })
   }
 
   /**
@@ -265,37 +211,28 @@ export default class EntityStore {
 
     if (requested === null) return { status: 'none', data: null }
 
-    const configs = this._findFetchConfigs(block, requested)
+    const route = this._route(block)
+    const configs = this._findFetchConfigs(block, requested, route)
     if (configs.size === 0) return { status: 'none', data: null }
 
     const dynamicContext = block.dynamicContext || block.page?.dynamicContext
-    const inheritDetail = this._shouldInheritDetail(meta, block)
-    const limit = this._inheritLimit(meta, block)
-    const order = this._inheritOrder(block)
     const ctx = this._ctx(block)
 
     const data = {}
     let allCached = true
 
-    const routeSchema = this._routeKey(block)
-
     for (const [schema, cfg] of configs) {
-      const isRouteQuery = dynamicContext && schema === routeSchema
-      if (isRouteQuery && !inheritDetail) {
-        // refine detail:false — the records minus the active one (related items).
-        const cached = dispatcher?.peek(cfg, ctx)
+      // `current:` applies under the key the page's URL narrows, and nowhere else.
+      const current = dynamicContext && route && schema === route.key ? currentOf(cfg) : null
+      if (current === 'exclude') {
+        // The route query's records without this page's, `limit` counting the others.
+        const cached = dispatcher?.peek(othersView(cfg), ctx)
         if (cached) {
-          const { paramName, paramValue } = dynamicContext
-          const items = cached.data
-          let filtered = Array.isArray(items)
-            ? items.filter((item) => !matchesRouteParam(item, paramName, paramValue))
-            : items
-          if (order) filtered = this._sortItems(filtered, order)
-          data[schema] = limit && Array.isArray(filtered) ? filtered.slice(0, limit) : filtered
+          data[schema] = othersOf(cached.data, cfg, isPageRecord(dynamicContext))
         } else {
           allCached = false
         }
-      } else if (isRouteQuery && cfg.ask) {
+      } else if (current === 'only' && cfg.ask) {
         // The records service: the record's own answer is cached under its own key.
         const detailCfg = this._buildDetailConfig(cfg, dynamicContext)
         const detailCached = detailCfg ? dispatcher?.peek(detailCfg, ctx) : null
@@ -305,11 +242,12 @@ export default class EntityStore {
         } else {
           allCached = false
         }
-      } else if (isRouteQuery) {
+      } else if (current === 'only') {
         // Detail page: deliver the focused record as a length-1 array under the
         // query key. A deferred/remote query fetches the full per-record;
-        // others use the matched record. Not found → [].
-        const cached = dispatcher?.peek(cfg, ctx)
+        // others use the matched record. Not found → []. Found in the route
+        // query's whole selection, never in a list its `limit` cut (`routeSelection`).
+        const cached = dispatcher?.peek(routeSelection(cfg), ctx)
         if (cached) {
           const { paramName, paramValue } = dynamicContext
           const items = cached.data
@@ -341,10 +279,11 @@ export default class EntityStore {
           allCached = false
         }
       } else {
+        // Any other key — and `current: include`, the route query's list as the
+        // binding describes it, this page's record among the rest.
         const cached = dispatcher?.peek(cfg, ctx)
         if (cached) {
-          const items = cached.data
-          data[schema] = order ? this._sortItems(items, order) : items
+          data[schema] = cached.data
         } else {
           allCached = false
         }
@@ -388,13 +327,11 @@ export default class EntityStore {
     }
     if (requested === null) return { data: null, errors: null }
 
-    const configs = this._findFetchConfigs(block, requested)
+    const route = this._route(block)
+    const configs = this._findFetchConfigs(block, requested, route)
     if (configs.size === 0) return { data: null, errors: null }
 
     const dynamicContext = block.dynamicContext || block.page?.dynamicContext
-    const inheritDetail = this._shouldInheritDetail(meta, block)
-    const limit = this._inheritLimit(meta, block)
-    const order = this._inheritOrder(block)
     const ctx = this._ctx(block, { signal })
 
     const data = {}
@@ -405,33 +342,27 @@ export default class EntityStore {
       reportFetchFailure(this.dev, block, key, cfg, message)
     }
 
-    const routeSchema = this._routeKey(block)
-
     for (const [schema, cfg] of configs) {
-      const isRouteQuery = dynamicContext && schema === routeSchema
-      if (isRouteQuery && !inheritDetail) {
-        // refine detail:false — the records minus the active one.
-        let records = peekArray(dispatcher, cfg, ctx)
-        if (records === null) {
-          const result = await dispatcher.dispatch(cfg, ctx)
+      // `current:` applies under the key the page's URL narrows, and nowhere else.
+      const current = dynamicContext && route && schema === route.key ? currentOf(cfg) : null
+      if (current === 'exclude') {
+        // The route query's records without this page's, `limit` counting the others:
+        // asked one longer (`othersView`), so removing the record still leaves enough.
+        const view = othersView(cfg)
+        parallelFetches.push(dispatcher.dispatch(view, ctx).then((result) => {
           if (result?.error) {
-            fail(schema, cfg, result.error)
-            continue
+            fail(schema, view, result.error)
+            return
           }
-          records = Array.isArray(result?.data) ? result.data : null
-        }
-        const { paramName, paramValue } = dynamicContext
-        let filtered = Array.isArray(records)
-          ? records.filter((item) => !matchesRouteParam(item, paramName, paramValue))
-          : (records ?? [])
-        if (order) filtered = this._sortItems(filtered, order)
-        data[schema] = limit && Array.isArray(filtered) ? filtered.slice(0, limit) : filtered
-      } else if (isRouteQuery && cfg.ask) {
+          if (result?.data !== undefined && result?.data !== null) {
+            data[schema] = othersOf(result.data, cfg, isPageRecord(dynamicContext))
+          }
+        }))
+      } else if (current === 'only' && cfg.ask) {
         // ⭐ THE RECORDS SERVICE needs no list to find the record: the record is the
         // same question narrowed by the route's handle, so list and record are
         // asked together — one round trip, and no client-side scan gating the
-        // fetch (F13, the live half). The list is asked too, because sections
-        // beside the record read it (`refine: true, detail: false`) and the
+        // fetch (F13, the live half). The list is asked too, because the record
         // index files its briefs; the record's own answer is the answer.
         const detailCfg = this._buildDetailConfig(cfg, dynamicContext)
         parallelFetches.push(dispatcher.dispatch(cfg, ctx).then((result) => {
@@ -445,15 +376,18 @@ export default class EntityStore {
           const answer = Array.isArray(result?.data) ? result.data : (result?.data ? [result.data] : [])
           data[schema] = answer.slice(0, 1) // a route resolves to ONE; `[]` is not found
         }))
-      } else if (isRouteQuery) {
-        // Detail page: focused record as a length-1 array under the query key.
+      } else if (current === 'only') {
+        // Detail page: focused record as a length-1 array under the query key,
+        // found in the route query's whole selection (`routeSelection`) — a record
+        // past a list's `limit` still has its page.
         const { paramName, paramValue } = dynamicContext
+        const selection = routeSelection(cfg)
 
-        let records = peekArray(dispatcher, cfg, ctx)
+        let records = peekArray(dispatcher, selection, ctx)
         if (records === null) {
-          const result = await dispatcher.dispatch(cfg, ctx)
+          const result = await dispatcher.dispatch(selection, ctx)
           if (result?.error) {
-            fail(schema, cfg, result.error)
+            fail(schema, selection, result.error)
             continue
           }
           records = Array.isArray(result?.data) ? result.data : null
@@ -500,6 +434,7 @@ export default class EntityStore {
           data[schema] = [match]
         }
       } else {
+        // Any other key — and `current: include`, the list as the binding describes it.
         parallelFetches.push(
           dispatcher.dispatch(cfg, ctx).then((result) => {
             if (result?.error) {
@@ -507,10 +442,7 @@ export default class EntityStore {
               return
             }
             if (result?.data !== undefined && result?.data !== null) {
-              // The same refine `order` the sync path applies (`resolve`), so a
-              // block sorts identically on a cache hit and on the fetch that
-              // filled it — it did not until 2026-09-04.
-              data[schema] = order ? this._sortItems(result.data, order) : result.data
+              data[schema] = result.data
             }
           })
         )
@@ -558,6 +490,11 @@ function heldWhole(dispatcher, match) {
   return held?.whole === true ? held.record : null
 }
 
+/** Matches the record a parametric page is about — the one `current: only` delivers. */
+function isPageRecord({ paramName, paramValue }) {
+  return (item) => matchesRouteParam(item, paramName, paramValue)
+}
+
 /**
  * Sync-peek helper: return the cached array for a config, or null on miss.
  */