@uniweb/core 0.24.4 → 0.25.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/core",
-  "version": "0.24.4",
+  "version": "0.25.1",
   "description": "Core classes for the Uniweb platform - Uniweb, Website, Page, Block",
   "type": "module",
   "exports": {
@@ -17,7 +17,8 @@
     "./section-id": "./src/section-id.js",
     "./services": "./src/services.js",
     "./sort": "./src/sort.js",
-    "./tracker": "./src/tracker.js"
+    "./tracker": "./src/tracker.js",
+    "./scope": "./src/scope.js"
   },
   "files": [
     "src"
@@ -43,8 +44,8 @@
     "vitest": "^4.1.7"
   },
   "dependencies": {
-    "@uniweb/theming": "^0.1.15",
-    "@uniweb/semantic-parser": "^1.4.0"
+    "@uniweb/semantic-parser": "^1.4.0",
+    "@uniweb/theming": "^0.1.15"
   },
   "scripts": {
     "test": "vitest run"

package/src/datastore.js

@@ -21,21 +21,30 @@
  *
  * ⭐ TWO IDENTITIES, decided by whether the request carries an ADDRESS.
  *
- * An ADDRESSED request — `path` or `url` — is identified by where it
- * goes: the address, the binding key, the unwrap, and for a POST its method and
- * body. Post-processing fields (`limit`, `sort`, `where`) are applied after the
- * fetch over one shared copy and must not split the cache; `query` and `depth`
- * are not hashed either, because the address already carries them (a query's
- * list and its per-record file are different addresses) and because a kit hook
- * asking for `{ path, as }` must hit the entry the page's declaration filled —
- * that shared cache is a documented property of `useFetched`.
+ * An ADDRESSED request — `path` or `url` — is identified by where it goes (the
+ * address, the binding key, the unwrap, and for a POST its method and body) AND by
+ * the view it takes of what came back: `scope`, `where`, `sort`, `limit`, which
+ * the default fetcher evaluates locally over the file. `query` is not hashed: the
+ * address already carries it (a query's list and its per-record file are
+ * different addresses).
+ *
+ * ⛔ **The view was left out until 2026-09-11, on the belief that operators "are
+ * applied after the fetch over one shared copy".** They were applied BEFORE the
+ * dispatcher stored the answer, so one file with two views shared ONE entry, and
+ * whoever asked first decided what everyone got — measured: an unfiltered request
+ * received the two records a `where` had kept. Each view is now its own entry, and
+ * views asked together share one read of the file (`runtime/src/default-fetcher.js`).
+ * A kit hook asking for `{ path, as }` hits the entry of a declaration with the
+ * same view, which is the property `useFetched` documents — *"a declarative fetch
+ * for the same request."*
  *
  * An ADDRESS-LESS request — a QUESTION sent to the records service — is
- * identified by the question: `query`, `schema`, `scope`, `where`, `sort`, `limit`, `depth`.
- * ⛔ The reason: with no per-query address, two pages
+ * identified by the question: `query`, `schema`, `scope`, `where`, `match`,
+ * `sort`, `limit`, `whole`. ⛔ The reason: with no per-query address, two pages
  * binding one `as` to two queries would otherwise share an entry, and a list
- * (brief) and a record (full) of one query would collide — the one defect on
- * this path that delivers WRONG data rather than none.
+ * (brief) and a record (whole) of one query would collide — the one defect on
+ * this path that delivers WRONG data rather than none. `match` is the record a
+ * parametric page asks for; without it every record's question is one entry.
  *
  * `locale` is hashed on both when present: two locales' answers must not share
  * an entry, and an asked config always carries the locale it was asked in.
@@ -53,15 +62,15 @@ export function deriveCacheKey(request) {
     ? request.method.toUpperCase()
     : undefined
   const body = method === 'POST' ? request?.body : undefined
+  const { query, schema, scope, where, match, sort, limit, whole } = request || {}
   if (path || url) {
     // ⚠️ The field NAME is part of the hash, so renaming it moves every key ONCE.
     // In-memory stores repopulate; a consumer with a persistent cache takes one
     // cold pass. Chosen over hashing under the old name, which would have hidden
     // the rename inside the one function whose job is to be canonical.
-    return JSON.stringify({ path, url, as, transform, method, body, locale })
+    return JSON.stringify({ path, url, as, transform, method, body, locale, scope, where, sort, limit })
   }
-  const { query, schema, scope, where, sort, limit, whole } = request || {}
-  return JSON.stringify({ query, schema, scope, where, sort, limit, whole, as, transform, locale })
+  return JSON.stringify({ query, schema, scope, where, match, sort, limit, whole, as, transform, locale })
 }
 
 /**

package/src/detail-url.js

@@ -22,7 +22,7 @@
  * a matched route pattern says nothing about the record behind it.
  */
 
-import { recordHandle } from './route-match.js'
+import { recordHandle, routeRecordKey } from './route-match.js'
 import { substitutePlaceholders } from './substitute-placeholders.js'
 
 /**
@@ -90,15 +90,13 @@ function paramContext(paramName, paramValue, record) {
  * @returns {Object|null} A fetch config carrying `url` or `path`, or null.
  */
 /**
- * The key a route param narrows a QUESTION by — the entry's own handle, which
- * the records service guarantees unique among siblings (the records contract
- * §1b: `$name`, "addressed AND filtered"). ⚠️ One constant, because the spelling
- * moved four times in one day (`path_segment` → `$slug` → `$name` → `meta::name`
- * → `$name`); the service is dark until a host stamps it, so this is the one
- * place to change if it moves again. Not read by the file lane, which narrows
- * by the route's own param (`item[paramName]`).
+ * The record key a `[slug]` (or `[...path]`) route matches — the entry's own
+ * handle, which the records service guarantees unique among siblings (the
+ * records contract §1b: `$name`). Kept as the export it has been; the map from
+ * every folder name to its key is `routeRecordKey` (`./route-match.js`), whose
+ * `slug` entry this is.
  */
-export const ROUTE_HANDLE_KEY = '$name'
+export const ROUTE_HANDLE_KEY = routeRecordKey('slug')
 
 export function buildDetailConfig(queryConfig, dynamicContext) {
   const { detail } = queryConfig
@@ -106,17 +104,22 @@ export function buildDetailConfig(queryConfig, dynamicContext) {
   const { paramName, paramValue, record = null } = dynamicContext
   if (!paramName || paramValue === undefined) return null
 
-  // ⭐ THE RECORDS SERVICE: the record is the list's own question, narrowed to
-  // one entry by its handle and asked in full — the list page and the detail
-  // page are the same query, differing only by whether the parameter is bound
-  // (the records contract, §1a). `sort` and `limit` are the list's and drop;
-  // `scope` and the authored `where` stay, so a scoped query cannot be escaped
-  // through the URL.
+  // ⭐ THE RECORDS SERVICE: the record is the route query's own question, unchanged,
+  // plus `match` — the one key the page's folder names and the URL's value for it
+  // (`routeRecordKey`: `[slug]` → `$name`, `[uuid]` → `$uuid`, `[id]` → `id`) —
+  // asked in full. `sort` and `limit` are the list's and drop; `scope` and the
+  // authored `where` stay AS WRITTEN, so a query's conditions cannot be escaped
+  // through the URL (the records contract, §1a).
+  //
+  // ⛔ `where` is never touched. Until 2026-09-11 the handle was merged into it,
+  // which replaced any condition the author had on the same key; `where` is the
+  // author's and `match` is the visitor's [Diego]. The value is a string — it is a
+  // URL segment — and the service compares it as one, as the local match does.
   if (queryConfig.ask) {
-    const { sort, limit, detail: _detail, ...rest } = queryConfig
+    const { sort, limit, detail: _detail, match: _match, ...rest } = queryConfig
     return {
       ...rest,
-      where: { ...(queryConfig.where && typeof queryConfig.where === 'object' ? queryConfig.where : {}), [ROUTE_HANDLE_KEY]: String(paramValue) },
+      match: { [routeRecordKey(paramName)]: String(paramValue) },
       whole: true,
       dynamicContext: { paramName, paramValue },
     }

package/src/entity-store.js

@@ -14,7 +14,7 @@
  * and in-flight dedup.
  */
 
-import { isFetchRefinement, resolveFetchConfigs } from './fetch-config.js'
+import { isFetchRefinement, resolveFetchConfigs, routeQuery, sectionFetches } from './fetch-config.js'
 import { fillRoutePattern, routeParamValue } from './route-match.js'
 import { sortRecords } from './sort.js'
 
@@ -130,11 +130,19 @@ export default class EntityStore {
     const page = block.page
     const website = block.website
     const dynamicContext = block.dynamicContext || page?.dynamicContext
-    // The route's variables, for a query that binds `:path` / `:dir` / `:slug`.
-    // A baked page carries `params` when it has more than the one capture;
-    // otherwise the capture itself is the only variable.
+    // The route's variables, for a query that binds `:path` / `:dir` / `:slug` —
+    // `routeBinding`'s, carried as `params` by every parametric page this runtime
+    // or its build makes. A page that carries only its capture gets the same three
+    // names from it: one segment is `:slug` and `:path`, with no `:dir`.
     const variables = dynamicContext
-      ? (dynamicContext.params ?? { [dynamicContext.paramName]: dynamicContext.paramValue })
+      ? (dynamicContext.params ?? (dynamicContext.paramValue !== undefined
+          ? {
+              [dynamicContext.paramName]: dynamicContext.paramValue,
+              path: dynamicContext.paramValue,
+              dir: '',
+              slug: dynamicContext.paramValue,
+            }
+          : null))
       : null
 
     return resolveFetchConfigs(
@@ -162,6 +170,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.
+   *
+   * ⛔ 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
+   */
+  _routeKey(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,
+      site: block.website?.config?.fetch,
+      sections: sectionFetches(page?._bodySections),
+    })?.key ?? null
+  }
+
   /**
    * Post-process assembled records: for each fetch config that declares a
    * `detailPage` page-ref, resolve it to a locale route template (O(1), via the
@@ -242,7 +277,7 @@ export default class EntityStore {
     const data = {}
     let allCached = true
 
-    const routeSchema = dynamicContext?.schema
+    const routeSchema = this._routeKey(block)
 
     for (const [schema, cfg] of configs) {
       const isRouteQuery = dynamicContext && schema === routeSchema
@@ -370,7 +405,7 @@ export default class EntityStore {
       reportFetchFailure(this.dev, block, key, cfg, message)
     }
 
-    const routeSchema = dynamicContext?.schema
+    const routeSchema = this._routeKey(block)
 
     for (const [schema, cfg] of configs) {
       const isRouteQuery = dynamicContext && schema === routeSchema

package/src/fetch-config.js

@@ -42,7 +42,11 @@
  * WHAT THIS DOES NOT OWN: where the sources come from. A caller holding a live
  * object graph reads them off the graph; a caller holding a content document
  * reads them off the JSON. Both hand the same ordered array to
- * `resolveFetchConfigs`. That difference is real and stays with the caller.
+ * `resolveFetchConfigs`. That difference is real and stays with the caller —
+ * but WHICH page is the parent is not: every caller finds it by one rule,
+ * `parentRouteOf` in `./route-match.js`. ⛔ Five places found it four ways until
+ * 2026-09-11, and a prefetch that read one field while the SPA inferred the rest
+ * prefetched nothing for a parametric page.
  */
 
 import { queryDataUrl, isDataUrl, recordDataUrl } from './data-paths.js'
@@ -182,6 +186,9 @@ function applyDeferredDetail(cfg, queries) {
  */
 function resolveQuerySource(cfg, services, { queries = null, locale = null, defaultLocale = null } = {}) {
   if (typeof cfg.query !== 'string' || cfg.query.length === 0) return cfg
+  const decl = queries && typeof queries === 'object' && queries[cfg.query] && typeof queries[cfg.query] === 'object'
+    ? queries[cfg.query]
+    : null
 
   // ⭐ THE SERVICE FIRST. A host that answers questions gets the whole query —
   // `schema`, `scope`, `where`, `sort`, `limit`, `depth` — and composes no
@@ -191,7 +198,6 @@ function resolveQuerySource(cfg, services, { queries = null, locale = null, defa
   // says so. ⚠️ Dark until a host stamps the row; see `resolveRecordsService`.
   const ask = resolveRecordsService(services, locale ?? defaultLocale)
   if (ask) {
-    const decl = queries && typeof queries === 'object' ? queries[cfg.query] : null
     const schema = typeof decl?.schema === 'string' && decl.schema ? decl.schema : null
     // Drop the transitional `path`: two addresses on one request is an
     // ambiguity the fetcher would have to break by accident of field order.
@@ -212,7 +218,25 @@ function resolveQuerySource(cfg, services, { queries = null, locale = null, defa
     if (asked.limit === undefined && typeof decl.limit === 'number' && decl.limit > 0) asked.limit = decl.limit
     return asked
   }
-  return { ...cfg, path: queryDataUrl(cfg.query) }
+
+  // ⭐ THE COMPILED FILE. The build applied the named query's fixed `where` when it
+  // wrote `/data/<query>.json`; what it could NOT apply is a clause bound to the
+  // route (`where: { tag: :dir }`) — a file is written once and the route differs
+  // per page — and it never applies `scope`, fixed or routed. So those travel here
+  // and are bound per page, exactly as they are on the service
+  // (`bindRouteVariables`, below). A fetch's own `scope` / `where` win, as they do
+  // there. ⛔ Until 2026-09-11 nothing travelled: a named query's `scope: :dir` was
+  // ignored on this lane and `where: { tag: :dir }` was applied at build to the
+  // literal `':dir'`, compiling to no records (measured).
+  const out = { ...cfg, path: queryDataUrl(cfg.query) }
+  if (decl) {
+    if (out.scope === undefined && typeof decl.scope === 'string') out.scope = decl.scope
+    if (out.where === undefined) {
+      const routed = routeVariableClauses(decl.where)
+      if (routed) out.where = routed
+    }
+  }
+  return out
 }
 
 /**
@@ -269,10 +293,11 @@ function bindingKey(cfg) {
  * @param {Object|null} [options.services] - the site's `config.services`. The
  *   `records` row is a host's live-records lane; absent means the compiled
  *   artifact answers, which is the whole of what a site with no backend needs.
- * @param {Object|null} [options.variables] - the route's variables on a template
- *   page (`{ path, dir, slug }` under `[...path]`, the capture under `[slug]`);
- *   a `:path` / `:dir` / `:slug` placeholder in `where:` or `scope:` binds to
- *   them, and an unbound one drops its clause. Null off a template page.
+ * @param {Object|null} [options.variables] - the route's variables on a parametric
+ *   page (`routeBinding` in `./route-match.js`: `{ path, dir, slug }` under every
+ *   folder form); a `:path` / `:dir` / `:slug` placeholder in `where:` or
+ *   `scope:` binds to them, and an unbound or empty one drops its clause. Null
+ *   off a parametric page.
  * @returns {Map<string, Object>} schema name → resolved config
  */
 export function resolveFetchConfigs(sources, options = {}) {
@@ -300,7 +325,7 @@ export function resolveFetchConfigs(sources, options = {}) {
       // which a query ref does not have until this runs.
       const sourced = resolveQuerySource(cfg, services, { queries, locale, defaultLocale })
       const localized = localizeConfig(sourced, locale, defaultLocale)
-      const bound = foldScope(bindRouteVariables(localized, variables))
+      const bound = dropRootScope(bindRouteVariables(localized, variables))
       configs.set(key, stampDepthAndLocale(applyDeferredDetail(bound, queries), locale, defaultLocale))
     }
   }
@@ -311,27 +336,34 @@ export function resolveFetchConfigs(sources, options = {}) {
 /**
  * The three route variables a query may reference, and only these — `:path`,
  * `:dir`, `:slug` — as a VALUE in `where:` or as the whole `scope:`. Ruled
- * 2026-09-04 [Diego]: standard names, never author-chosen; a placeholder fills
- * a value, never a key or an operator, never `schema`.
+ * 2026-09-04 [Diego] and again 2026-09-11 (no `:name` under a `[name]` folder):
+ * standard names, never author-chosen; a placeholder fills a value, never a key
+ * or an operator, never `schema`.
  */
 const ROUTE_VARIABLE = /^:(path|dir|slug)$/
 
+/** A variable with no value, or an empty one, binds nothing: its clause drops. */
+function unset(value) {
+  return value === undefined || value === null || value === ''
+}
+
 /**
  * Bind a query's route placeholders from the page's variables.
  *
  * ⭐ UNBOUND ⇒ THE CLAUSE DROPS. That is what lets ONE saved query serve both
- * the list page and the detail page: `where: { tag: :dir }` narrows on
- * `/blog/rust/my-post` and vanishes on `/blog`, where there is no `:dir`. A
- * variable bound to an empty string (`:dir` on a single-segment capture) is
- * bound, and binds the empty value. The backend answering the records service
- * states the same rule from its side (the records contract, §6b).
+ * the list page and the parametric page: `where: { tag: :dir }` narrows on
+ * `/blog/rust/my-post` and vanishes on `/blog`, where there is no `:dir`. ⭐ **An
+ * EMPTY variable drops its clause too** *(ruled 2026-09-11 [Diego])* — `:dir` on a
+ * one-segment URL means "no directory", not "a directory named nothing". It bound
+ * the empty string until then, so `where: { tag: :dir }` filtered `tag == ''` on
+ * `/blog/my-post`, and `scope: :dir` split a cache entry the list page shared.
  *
  * ⚠️ The price, stated where it is paid: a MISSPELLED variable is byte-identical
  * to an intentional list page. Only an authoring surface can catch that; this
  * function cannot.
  *
  * @param {Object} cfg - a resolved config
- * @param {Object|null} variables - `{ path, dir, slug, … }` from the route, or null off a template page
+ * @param {Object|null} variables - `{ path, dir, slug, … }` from the route, or null off a parametric page
  * @returns {Object} the config, with placeholders bound or their clauses dropped
  */
 function bindRouteVariables(cfg, variables) {
@@ -340,7 +372,7 @@ function bindRouteVariables(cfg, variables) {
     const name = cfg.scope.slice(1)
     const value = variables?.[name]
     const { scope, ...rest } = out
-    out = value === undefined || value === null ? rest : { ...rest, scope: String(value) }
+    out = unset(value) ? rest : { ...rest, scope: String(value) }
   }
   if (cfg.where && typeof cfg.where === 'object') {
     const bound = bindWhere(cfg.where, variables)
@@ -372,7 +404,7 @@ function bindWhere(where, variables) {
     if (typeof value === 'string' && ROUTE_VARIABLE.test(value)) {
       const bound = variables?.[value.slice(1)]
       changed = true
-      if (bound === undefined || bound === null) continue // unbound ⇒ drop
+      if (unset(bound)) continue // unbound or empty ⇒ drop
       next[key] = String(bound)
       continue
     }
@@ -390,23 +422,154 @@ function bindWhere(where, variables) {
 }
 
 /**
- * `scope:` on a lane that cannot be ASKED — the compiled file — is the same
- * question as `where: { path: { under: scope } }`: a record's
- * `path` is the folder `records.yml` placed it in, and the evaluator's `under`
- * is segment-aware containment. Folding it keeps the language the INTERSECTION
- * of both lanes: an author
- * writes `scope: :dir` once and it means the same branch on a static site and
- * on a service that takes `scope` natively. A config carrying `ask` keeps
- * `scope` as the service's own field.
+ * ⭐ `scope:` IS ITS OWN FIELD, on both lanes. The service takes it natively; on
+ * the compiled file the evaluators apply it to each record's placement (`path`,
+ * the folder `records.yml` put it in) — `@uniweb/core`'s `applyScope`, the one the
+ * build uses too. ⛔ Until 2026-09-11 it was folded here into
+ * `where: { path: { under } }`, an authored form that is now retired in its
+ * favour [Diego]: a branch is a scope, and `where` stays the author's predicate.
+ *
+ * The root contains everything, so an empty scope is no scope — dropped rather
+ * than carried, so it cannot split a cache entry from the same query without one.
  */
-function foldScope(cfg) {
-  if (typeof cfg.scope !== 'string' || cfg.scope === '' || cfg.ask) return cfg
+function dropRootScope(cfg) {
+  if (typeof cfg.scope !== 'string' || cfg.scope.replace(/^\/+|\/+$/g, '') !== '') return cfg
   const { scope, ...rest } = cfg
-  const under = { path: { under: scope } }
-  const where = cfg.where && typeof cfg.where === 'object' && Object.keys(cfg.where).length
-    ? { and: [cfg.where, under] }
-    : under
-  return { ...rest, where }
+  return rest
+}
+
+/** Does this where-value hold a route variable anywhere inside it? */
+function holdsRouteVariable(value) {
+  if (typeof value === 'string') return ROUTE_VARIABLE.test(value)
+  if (Array.isArray(value)) return value.some(holdsRouteVariable)
+  if (value && typeof value === 'object') return Object.values(value).some(holdsRouteVariable)
+  return false
+}
+
+/**
+ * The part of a where-object that depends on the route — its top-level clauses
+ * holding a route variable anywhere inside them — or null. The compiled file's
+ * build cannot evaluate those (a file is written once; the route differs per
+ * page), so the runtime applies them, bound per page.
+ *
+ * @param {Object|null} where
+ * @returns {Object|null}
+ */
+function routeVariableClauses(where) {
+  if (!where || typeof where !== 'object' || Array.isArray(where)) return null
+  const out = {}
+  for (const [key, value] of Object.entries(where)) {
+    if (holdsRouteVariable(value)) out[key] = value
+  }
+  return Object.keys(out).length ? out : null
+}
+
+/**
+ * A named query's narrowing that is FIXED for every page — the top-level `where`
+ * clauses that hold no route variable, and its `scope` unless that is routed. The
+ * build applies the `where` part when it compiles `/data/<query>.json` (it leaves
+ * `scope` to the runtime, so a page's own can replace it); the rest is exactly
+ * `routeVariableClauses`, which the runtime binds per page (`resolveQuerySource`
+ * carries it there). A clause is split at the TOP level and never inside: an `or`
+ * holding one variable goes to the runtime whole, because applying half of it at
+ * build would drop records the bound `or` keeps.
+ *
+ * @param {{ where?: Object, scope?: string }} query
+ * @returns {{ where: Object|null, scope: string|null }}
+ */
+export function withoutRouteVariables({ where = null, scope = null } = {}) {
+  let fixed = null
+  if (where && typeof where === 'object' && !Array.isArray(where)) {
+    const out = {}
+    for (const [key, value] of Object.entries(where)) {
+      if (!holdsRouteVariable(value)) out[key] = value
+    }
+    fixed = Object.keys(out).length ? out : null
+  }
+  const fixedScope = typeof scope === 'string' && !ROUTE_VARIABLE.test(scope) && scope.replace(/^\/+|\/+$/g, '') !== ''
+    ? scope
+    : null
+  return { where: fixed, scope: fixedScope }
+}
+
+/** A `fetch` as a list: one declaration, several, or none. */
+function fetchList(fetch) {
+  if (!fetch) return []
+  return Array.isArray(fetch) ? fetch.filter(Boolean) : [fetch]
+}
+
+/**
+ * Every section-level `fetch` on a page, nested sections included — the input
+ * `routeQuery` falls back to. Plain data, so a caller holding a content document
+ * and a caller holding the object graph (`page._bodySections`) pass the same thing.
+ *
+ * @param {Array<Object>|undefined} sections - a page's raw sections
+ * @returns {Array<Object|Object[]>}
+ */
+export function sectionFetches(sections) {
+  const out = []
+  const walk = (list) => {
+    for (const s of list || []) {
+      if (!s || typeof s !== 'object') continue
+      if (s.fetch) out.push(s.fetch)
+      if (Array.isArray(s.subsections)) walk(s.subsections)
+    }
+  }
+  walk(sections)
+  return out
+}
+
+/**
+ * ⭐ THE ROUTE QUERY of a parametric page — the query its URL names ONE record of,
+ * and so the binding key the record is delivered under. The rule, ruled
+ * 2026-09-11 [Diego]:
+ *
+ *   1. the page's own query, else its parent page's, else the site's — the first
+ *      `as` of the closest of those that declares one;
+ *   2. if none does, the key the page's own sections declare, when they all
+ *      declare the same one;
+ *   3. otherwise none: the page has no record, and nothing narrows.
+ *
+ * ⭐ WHY THE PAGE LEVEL CHOOSES, not each section: which URLs exist, the page's
+ * title, not-found, the static build's expansion and a host's record index each
+ * need ONE answer per page. Who RECEIVES the record is the four-level cascade: a
+ * section the route key reaches — its own declaration of that key included —
+ * gets the record, and its own query under another key is left as declared.
+ *
+ * ⛔ This replaces `parentSchema`, which our build computed from the closest
+ * ancestor page with a query at ANY depth and never from the page's own query or
+ * the site's — a different rule from the one sections are fed by, so the URL
+ * narrowed nothing, or a key no section received (measured 2026-09-10).
+ *
+ * Plain data in, so every lane — the entity store, the SPA's parametric page, the
+ * prefetch, the static build, a host — calls this and computes no copy.
+ *
+ * @param {Object} levels
+ * @param {Object|Object[]|null} [levels.page] - the page's own `fetch`
+ * @param {Object|Object[]|null} [levels.parent] - its parent page's `fetch` (by `parentRouteOf`)
+ * @param {Object|Object[]|null} [levels.site] - the site's `fetch`
+ * @param {Array<Object|Object[]>} [levels.sections] - the page's section `fetch`es (`sectionFetches`)
+ * @returns {{ key: string, config: Object, level: 'page'|'parent'|'site'|'sections' } | null}
+ */
+export function routeQuery({ page = null, parent = null, site = null, sections = [] } = {}) {
+  for (const [level, fetch] of [['page', page], ['parent', parent], ['site', site]]) {
+    for (const cfg of fetchList(fetch)) {
+      if (isFetchRefinement(cfg)) continue
+      const key = bindingKey(cfg)
+      if (key) return { key, config: cfg, level }
+    }
+  }
+  let found = null
+  for (const fetch of sections || []) {
+    for (const cfg of fetchList(fetch)) {
+      if (isFetchRefinement(cfg)) continue
+      const key = bindingKey(cfg)
+      if (!key) continue
+      if (found && found.key !== key) return null // the sections disagree: no route query
+      if (!found) found = { key, config: cfg, level: 'sections' }
+    }
+  }
+  return found
 }
 
 /**

package/src/index.js

@@ -22,7 +22,7 @@ export { default as ObservableState } from './observable-state.js'
 export { substitutePlaceholders } from './substitute-placeholders.js'
 // `resolveRecordsService` / `RECORDS_SERVICE` are NOT re-exported here: `./fetch-config.js`
 // reads them and a consumer that needs them imports `@uniweb/core/records-service`.
-export { resolveFetchConfigs } from './fetch-config.js'
+export { resolveFetchConfigs, routeQuery, sectionFetches, withoutRouteVariables } from './fetch-config.js'
 export { buildDetailConfig, ROUTE_HANDLE_KEY } from './detail-url.js'
 // `isWildcardLanguages` is likewise internal — `./locale-config.js` reads it
 // and nothing else does. Same subpath escape hatch: `@uniweb/core/locale-config`.
@@ -51,11 +51,24 @@ export {
   isDataUrl
 } from './data-paths.js'
 export { evaluate as evaluateWhere, match as matchWhere } from './where.js'
+// A query's `scope:` over records that carry their placement — read by the runtime's
+// default fetcher and by `@uniweb/build` when it compiles a query's file.
+export { applyScope, withinScope } from './scope.js'
 // The one sort evaluator and the one href encoder — both read by `@uniweb/build`
 // (materialization, the `route:` bake) and by `@uniweb/runtime` (the fallback),
 // which is what keeps the static and live lanes answering a query identically.
 export { parseSort, sortRecords, sortToWire } from './sort.js'
-export { fillRoutePattern, splitPathCapture, joinPathCapture, recordHandle, routeParamValue } from './route-match.js'
+export {
+  fillRoutePattern,
+  splitPathCapture,
+  joinPathCapture,
+  recordHandle,
+  routeParamValue,
+  routeRecordKey,
+  routeBinding,
+  routeParamName,
+  parentRouteOf,
+} from './route-match.js'
 export { isRichSchema } from './schemas.js'
 // ⛔ `Tracker` is NOT on the package entry. It is a FEATURE, not part of the
 // object graph this package exists to define, and putting it here made every

package/src/page.js

@@ -104,7 +104,7 @@ export default class Page {
     // Scroll position memory (for navigation restoration)
     this.scrollY = 0
 
-    // Fetch configuration (from page.yml data: field)
+    // Fetch configuration (page.yml's `fetch:`, or its `query:` shorthand, desugared at build)
     // Preserved at runtime so EntityStore can walk the page hierarchy
     this.fetch = pageData.fetch || null
 

package/src/route-match.js

@@ -260,15 +260,36 @@ export function recordHandle(record) {
 }
 
 /**
- * The value a record carries for a route param. `slug` — the default param, and
- * the last segment of a `[...path]` route — is the placement handle
- * (`recordHandle`); any other param is a field the site chose to route by.
+ * The record field a route param is matched on — ONE MAP, read by the local match
+ * (`routeParamValue`, below) and by the records service's record question (`match`,
+ * `./detail-url.js`), so the two lanes cannot disagree about what a folder's name
+ * means. Ruled 2026-09-11 [Diego]:
+ *
+ *     [slug], [...path]  →  $name   the record's handle (a `[...path]` page's param is `slug`)
+ *     [uuid]             →  $uuid   the record's identity
+ *     [anything]         →  anything, the record's own field of that name
+ *
+ * @param {string} paramName
+ * @returns {string}
+ */
+export function routeRecordKey(paramName) {
+  if (paramName === 'slug') return '$name'
+  if (paramName === 'uuid') return '$uuid'
+  return paramName
+}
+
+/**
+ * The value a record carries for a route param, by `routeRecordKey`'s map. The two
+ * built-in keys fall back to the plain field a source without them carries: the
+ * handle to `slug` (`recordHandle`), the identity to `uuid` — so a remote API that
+ * routes `[uuid]` on its own `uuid` field keeps matching (ruled 2026-09-11).
  *
  * ⛔ Every reader that matches a delivered record to a route param goes through
- * this — the entity store, the website's dynamic page, the kit's detail hook,
- * the href encoder below. Until 2026-09-04 each read `item[paramName]` directly,
- * so a record served with `$name` and no `slug` matched nothing: a template page
- * on a live lane rendered `[]` and a list linked to no record.
+ * this — the entity store, the website's parametric page, the static build's
+ * expansion, the kit's detail hook, the href encoder below. Until 2026-09-04 each
+ * read `item[paramName]` directly, so a record served with `$name` and no `slug`
+ * matched nothing: a template page on a live lane rendered `[]` and a list linked
+ * to no record.
  *
  * @param {Object} record
  * @param {string} paramName
@@ -277,9 +298,99 @@ export function recordHandle(record) {
 export function routeParamValue(record, paramName) {
   if (!record || typeof record !== 'object') return undefined
   if (paramName === 'slug') return recordHandle(record)
+  if (paramName === 'uuid') {
+    const id = record.$uuid
+    return typeof id === 'string' && id.length ? id : record.uuid
+  }
   return record[paramName]
 }
 
+/**
+ * A parametric page's route binding — the param the record is matched on, its
+ * value, and the route VARIABLES a query may reference. ONE implementation, for
+ * the SPA (`Website._createDynamicPage`), the prefetch and the static build.
+ *
+ * The variables are always the three standard names (ruled 2026-09-04 and
+ * 2026-09-11 [Diego]; no others):
+ *
+ *   - `[...path]` splits its capture — `:path` the whole of it, `:dir` all but the
+ *     last segment, `:slug` the last (`splitPathCapture`);
+ *   - any other param is ONE segment used as is: `:slug` holds it, `:path` equals
+ *     it, and `:dir` is empty — which drops a clause that binds it.
+ *
+ * The raw params ride along under their own names, for a component reading
+ * `block.dynamicContext.params`; a query cannot reference them.
+ *
+ * `paramName` is the page's declared one when it has it. A page nested inside a
+ * parametric page (`/members/:slug/cv`) has no bracket of its own and binds the
+ * DEEPEST param of its route — its nearest parametric ancestor's.
+ *
+ * @param {string} pattern - the page's route pattern (`/members/:slug`, `/docs/:path*`)
+ * @param {Record<string,string>} params - what `matchDynamicRoute` captured
+ * @param {string|null} [paramName] - the page's declared param
+ * @returns {{ paramName: string|null, paramValue: string|undefined, variables: Object }}
+ */
+export function routeBinding(pattern, params = {}, paramName = null) {
+  const { catchAll } = routePatternToRegex(pattern)
+  const name = routeParamName(pattern, paramName)
+  if (catchAll && params[catchAll] !== undefined) {
+    const parts = splitPathCapture(params[catchAll])
+    return { paramName: name, paramValue: parts.slug, variables: { ...params, ...parts } }
+  }
+  const value = name ? params[name] : undefined
+  if (value === undefined) return { paramName: name, paramValue: undefined, variables: { ...params } }
+  return { paramName: name, paramValue: value, variables: { ...params, path: value, dir: '', slug: value } }
+}
+
+/**
+ * The param a parametric page's record is matched on: the page's declared one;
+ * else `slug` under `[...path]` (the record is its handle, the capture's last
+ * segment); else the route's DEEPEST param — a page nested inside a parametric
+ * page binds its nearest parametric ancestor's.
+ *
+ * @param {string} pattern
+ * @param {string|null} [declared]
+ * @returns {string|null}
+ */
+export function routeParamName(pattern, declared = null) {
+  const { paramNames, catchAll } = routePatternToRegex(pattern)
+  if (declared && paramNames.includes(declared)) return declared
+  if (catchAll) return declared || 'slug'
+  if (declared && !paramNames.length) return declared
+  return paramNames.length ? paramNames[paramNames.length - 1] : (declared || null)
+}
+
+/**
+ * The page a page's data inherits from — THE ONE RULE for a page's parent, used by
+ * the object graph (`Website.buildPageHierarchy`), the prefetch and the static
+ * build, so what a section inherits and what a parametric page's URL narrows are
+ * read off the same parent in every lane.
+ *
+ * The declared parent (`pages[].parent`, which our collector writes) when it names
+ * a page; otherwise the route minus its last segment — a `:param` or `:path*` token
+ * included — when a page holds that route. A top-level page has none: the homepage
+ * is not everyone's parent.
+ *
+ * ⛔ Measured 2026-09-11, before this existed: the prefetch read the declared field
+ * only, so on a payload without it `/members/alice` resolved no configs at all,
+ * while the SPA inferred `/members` and fetched the list and the record itself.
+ *
+ * @param {string} route
+ * @param {Object} options
+ * @param {string|null} [options.declared] - the parent route the payload declares
+ * @param {(route: string) => boolean} options.has - whether a page holds a route
+ * @returns {string|null} the parent's route, or null
+ */
+export function parentRouteOf(route, { declared = null, has } = {}) {
+  if (typeof has !== 'function' || typeof route !== 'string') return null
+  if (typeof declared === 'string' && declared && declared !== route && has(declared)) return declared
+  const r = normalizeRoute(route)
+  const cut = r.lastIndexOf('/')
+  if (cut <= 0) return null
+  const up = r.slice(0, cut)
+  return has(up) ? up : null
+}
+
 /**
  * Fill a route pattern's params from a record — the ONE encoder for a record's href.
  *

package/src/scope.js

@@ -0,0 +1,56 @@
+/**
+ * A query's `scope:` — the folder branch it reads — evaluated over records that
+ * carry their placement.
+ *
+ * A record's `path` is the folder `records.yml` placed it in (`build/src/site/
+ * query-processor.js`). A scope contains that folder and every folder below it, at
+ * SEGMENT boundaries: `field` holds `field` and `field/2025`, never `fieldwork`.
+ * The root (`''`) holds everything.
+ *
+ * ⭐ Why this is its own field and not a `where` operator: a branch is a scope,
+ * and `where` stays the author's predicate over the records' own fields. Ruled
+ * 2026-09-11 [Diego], retiring `where: { path: { under } }` — written before a
+ * query had `scope:` — together with the `under` operator. The records service
+ * takes `scope` natively; this is the same question on the lane that has no
+ * service: the compiled file, evaluated by the runtime's default fetcher and by
+ * the build that writes the file.
+ *
+ * Zero-dependency leaf.
+ */
+
+function trimSlashes(s) {
+  return s.replace(/^\/+/, '').replace(/\/+$/, '')
+}
+
+/**
+ * Is a placement inside a scope?
+ *
+ * ⛔ The `+ '/'` is the whole point: a plain `startsWith` would put `2024b` inside
+ * `2024`, the classic prefix bug, which silently returns records from a sibling
+ * folder the author never named.
+ *
+ * @param {*} placement - a record's `path`
+ * @param {string} scope
+ * @returns {boolean}
+ */
+export function withinScope(placement, scope) {
+  if (typeof scope !== 'string') return true
+  const s = trimSlashes(scope)
+  if (s === '') return true
+  if (typeof placement !== 'string') return false
+  const p = trimSlashes(placement)
+  return p === s || p.startsWith(s + '/')
+}
+
+/**
+ * The records inside a scope, in source order. No scope (or the root) keeps all.
+ *
+ * @param {Array<Object>} records
+ * @param {string|null|undefined} scope
+ * @returns {Array<Object>}
+ */
+export function applyScope(records, scope) {
+  if (!Array.isArray(records)) return records
+  if (typeof scope !== 'string' || trimSlashes(scope) === '') return records
+  return records.filter((r) => r && typeof r === 'object' && withinScope(r.path, scope))
+}

package/src/website.js

@@ -11,8 +11,8 @@ import FetcherDispatcher from './fetcher-dispatcher.js'
 import ObservableState from './observable-state.js'
 import { normalizeSeo } from './seo.js'
 import { resolveDefaultLocale, localeLabel } from './locale-config.js'
-import { matchDynamicRoute, decodeRouteValue, routePatternToRegex, splitPathCapture, routeParamValue } from './route-match.js'
-import { resolveFetchConfigs } from './fetch-config.js'
+import { matchDynamicRoute, decodeRouteValue, routeParamValue, routeBinding, routeParamName, parentRouteOf } from './route-match.js'
+import { resolveFetchConfigs, routeQuery, sectionFetches } from './fetch-config.js'
 import { buildDetailConfig } from './detail-url.js'
 import { resolveService } from './services.js'
 
@@ -382,29 +382,19 @@ export default class Website {
       pageMap.set(page.route, page)
     }
 
-    // Link pages using the declared parent route (set by build)
+    // ⭐ THE ONE PARENT RULE (`parentRouteOf`, `./route-match.js`): the declared
+    // parent route (`pages[].parent`, set by our build) when it names a page, else
+    // the route minus its last segment when a page holds that route. A top-level
+    // page (e.g. /Features) is NOT a child of the homepage. The prefetch and the
+    // static build call the same rule, so the parent a section inherits from and
+    // the parent a parametric page's route query is read from are one page in
+    // every lane — a payload that omits `parent` (published payloads may) changes
+    // nothing. Children arrays are needed for nav filtering and getNavigableRoute.
+    const has = (route) => pageMap.has(route)
     for (const page of this.pages) {
-      if (page.parentRoute) {
-        const parent = pageMap.get(page.parentRoute)
-        if (parent) {
-          parent.children.push(page)
-          page.parent = parent
-        }
-      }
-    }
-
-    // Fallback: infer parent-child from route structure for unlinked pages.
-    // The editor sets parentRoute via buildEnginePreviewPayload(), but published
-    // payloads may not include it. Infer from route nesting so children arrays
-    // are always populated (needed for nav filtering and getNavigableRoute).
-    // Only applies to nested routes (e.g., /Articles/index → parent /Articles).
-    // Top-level pages (e.g., /Features) are NOT children of the homepage.
-    for (const page of this.pages) {
-      if (page.parent || page.route === '/') continue
-      const inferredParent = page.route.replace(/\/[^/]+$/, '')
-      if (!inferredParent || inferredParent === '/' || inferredParent === page.route) continue
-      const parent = pageMap.get(inferredParent)
-      if (parent) {
+      const parentRoute = parentRouteOf(page.route, { declared: page.parentRoute, has })
+      const parent = parentRoute ? pageMap.get(parentRoute) : null
+      if (parent && parent !== page) {
         parent.children.push(page)
         page.parent = parent
       }
@@ -572,39 +562,23 @@ export default class Website {
     pageData.route = concreteRoute
     pageData.isDynamic = false // No longer a template
 
-    // ⭐ The route's variables, and the param the record is delivered by.
-    //
-    // `[slug]` — the one capture, under the folder's own label: `paramName` is
-    // that label and the record is matched on `item[paramName]`.
-    //
-    // `[...path]` — the capture is split by the rule in `route-match.js`
-    // (`:path` the whole capture · `:dir` everything before the last segment ·
-    // `:slug` the last segment); the record is delivered by `slug`, its handle,
-    // exactly as under `[slug]`, and `path` / `dir` exist for a query to bind
-    // (`scope: :dir`, `where: { tag: :dir }`). Ruled 2026-09-04 [Diego]: the
-    // variables are standard, never author-named.
-    const { catchAll } = routePatternToRegex(templatePage.route)
-    let variables = { ...params }
-    let paramName
-    let paramValue
-    if (catchAll && params[catchAll] !== undefined) {
-      const parts = splitPathCapture(params[catchAll])
-      variables = { ...params, ...parts }
-      paramName = originalData.paramName || 'slug'
-      paramValue = parts.slug
-    } else {
-      paramName = originalData.paramName || Object.keys(params)[0]
-      paramValue = params[paramName]
-    }
-    const pluralSchema = originalData.parentSchema // e.g., 'articles'
-
-    // Store dynamic context for components to access
+    // ⭐ The route's binding — the param the record is matched on, its value, and
+    // the variables a query may reference — by the ONE implementation the prefetch
+    // and the static build call too (`routeBinding`, `./route-match.js`). The
+    // variables are the three standard names under every folder form (ruled
+    // 2026-09-04 and 2026-09-11 [Diego]): `[...path]` splits its capture;
+    // `[name]` is one segment, `:slug` and `:path` equal to it and `:dir` empty.
+    // A page nested inside a parametric page binds its ancestor's param.
+    const { paramName, paramValue, variables } = routeBinding(templatePage.route, params, originalData.paramName)
+
+    // Store dynamic context for components to access. ⛔ No `schema`: the key the
+    // URL narrows is worked out where it is read (`EntityStore._routeKey`), from
+    // the page, never stored beside it (deleted 2026-09-11).
     pageData.dynamicContext = {
       templateRoute: templatePage.route,
       params: variables,
       paramName,
       paramValue,
-      schema: pluralSchema,
     }
 
     // Set dynamic context on sections so Block instances receive it
@@ -614,13 +588,22 @@ export default class Website {
       }
     }
 
-    // Try to resolve page metadata from DataStore
-    // Look up the parent page's fetch config to find data in the store
-    // The template's parent: the route without its `:param` — or `:path*` — tail.
-    const parentRoute = templatePage.route.replace(/\/:[\w-]+\*?$/, '') || '/'
-    const parentPage = this.pages.find(p => p.route === parentRoute || p.getNavRoute() === parentRoute)
+    // Try to resolve page metadata from DataStore: the record the page is about,
+    // from its ROUTE QUERY (`routeQuery`) — the page's own query, its parent's, the
+    // site's, or its sections' shared key — read off the same parent the entity
+    // store reads (`templatePage.parent`, linked by the one parent rule). ⛔ Until
+    // 2026-09-11 this probed only a parent found by stripping the route down to
+    // `/` (so a top-level page probed the homepage) and only that parent's fetch,
+    // so a page whose route query was its own or the site's never got its title.
+    const parentPage = templatePage.parent
+    const route = routeQuery({
+      page: originalData.fetch,
+      parent: parentPage?.fetch,
+      site: this.config?.fetch,
+      sections: sectionFetches(originalData.sections),
+    })
 
-    if (parentPage && pluralSchema) {
+    if (route && paramValue !== undefined) {
       // Find the record the page is ABOUT via the dispatcher's peek (a sync
       // cache probe), to set the page title / description / notFound flag
       // before the page instance is constructed.
@@ -633,23 +616,23 @@ export default class Website {
       // missed on exactly those lanes: no title, no not-found, and the page was
       // never cached (`recordsLoaded` false on every visit). Silent, on a
       // visitor's page — the "write key ≠ read key" failure.
-      const parentFetch = parentPage.fetch
       let items = []
       let currentItem = null
 
-      if (parentFetch && this.fetcher) {
-        // ⛔ `as` is the binding key. This matched on `schema` alone until
-        // 2026-09-02 — which, once the alias went, would have found nothing:
-        // `items` stays `[]` and the page reports "Not found" for a record that
-        // exists. Silent, and on a visitor's page.
-        const fetchConfig = resolveFetchConfigs([parentFetch], {
-          schemas: [pluralSchema],
-          locale: this.getActiveLocale(),
-          defaultLocale: this.getDefaultLocale(),
-          queries: this.config?.queries ?? null,
-          services: this.config?.services ?? null,
-          variables,
-        }).get(pluralSchema)
+      if (this.fetcher) {
+        // The same sources the store walks for a section that declares nothing,
+        // plus the declaring section's config when the key came from the sections.
+        const fetchConfig = resolveFetchConfigs(
+          [originalData.fetch, parentPage?.fetch, this.config?.fetch, route.level === 'sections' ? route.config : null],
+          {
+            schemas: [route.key],
+            locale: this.getActiveLocale(),
+            defaultLocale: this.getDefaultLocale(),
+            queries: this.config?.queries ?? null,
+            services: this.config?.services ?? null,
+            variables,
+          },
+        ).get(route.key)
         if (fetchConfig) {
           const ctx = { website: this }
           // ⭐ The page is about ONE record, so ask for that record first: a
@@ -689,10 +672,11 @@ export default class Website {
 
       // Track whether the records were available at creation time.
       // Note: the matched record and the sibling list are intentionally NOT
-      // stored on dynamicContext — nothing reads them (documented shape is
-      // { paramName, paramValue, schema }; the record reaches components via
-      // content.data, siblings via `fetch: { refine: true, detail: false }`).
-      // The local `currentItem`/`items` above drive title/description/notFound.
+      // stored on dynamicContext — nothing reads them (its shape is
+      // { templateRoute, params, paramName, paramValue }; the record reaches
+      // components via content.data, siblings via
+      // `fetch: { refine: true, detail: false }`). The local
+      // `currentItem`/`items` above drive title/description/notFound.
       pageData._recordsLoaded = items.length > 0 || currentItem !== null
     }
 
@@ -884,25 +868,39 @@ export default class Website {
   }
 
   /**
-   * The route template that renders ONE record of a binding key — `{ route,
-   * paramName }` for the `[param]` page whose parent query lands under `key`,
-   * or null when the site routes no detail page over it.
+   * The parametric page that renders ONE record of a query — `{ route, paramName }`
+   * for the page whose route query (`routeQuery`) lands under `name`, or null when
+   * the site routes no such page.
    *
-   * ⭐ This is how a caller outside a template page learns which record field
+   * ⭐ This is how a caller outside a parametric page learns which record field
    * the site's URL is built on: `kit`'s `useEntityDetail` asks it so a hover
    * card and the page it links to address the record by the SAME field. It
    * hardcoded `slug` until 2026-09-04, which was quietly wrong on any site
-   * routing `[id]`. The first template found
-   * wins, matching `parentSchema`'s own rule that one key indexes one template.
+   * routing `[id]`.
+   *
+   * `name` may be the binding key (`content.data.<key>`) or the query's name:
+   * `useEntityDetail` holds the query name, and the two differ under an `as:`
+   * override — which this matched by binding key only until 2026-09-11. The first
+   * page found wins, and only a page whose own folder is the parameter (a page
+   * nested inside one is not the record's page).
    *
-   * @param {string} key - a binding key (`content.data.<key>`)
+   * @param {string} name - a binding key or a query name
    * @returns {{ route: string, paramName: string } | null}
    */
-  detailTemplateFor(key) {
-    if (!key) return null
+  detailTemplateFor(name) {
+    if (!name) return null
     for (const data of this._dynamicPageData.values()) {
-      if (data?.parentSchema === key && data.paramName) {
-        return { route: data.route, paramName: data.paramName }
+      if (!data?.route || !/\/:[A-Za-z0-9_-]+\*?$/.test(data.route)) continue
+      const page = this.pages.find((p) => p.route === data.route)
+      const route = routeQuery({
+        page: data.fetch,
+        parent: page?.parent?.fetch,
+        site: this.config?.fetch,
+        sections: sectionFetches(data.sections),
+      })
+      if (!route) continue
+      if (route.key === name || route.config?.query === name) {
+        return { route: data.route, paramName: routeParamName(data.route, data.paramName) }
       }
     }
     return null

package/src/where.js

@@ -36,7 +36,6 @@
  *   nin     Value is not in the listed array.
  *   like    Glob match (`*` any run, `?` one char). String fields only.
  *   exists  Field is truthy (boolean toggle).
- *   under   Path containment at SEGMENT boundaries. String fields only.
  *
  * Composition keys:
  *
@@ -44,22 +43,11 @@
  *   or      Array of sub-predicates; at least one must match.
  *   not     Single sub-predicate; must not match.
  *
- * `under` is for fields holding a slash-separated location — a record's
- * position inside the folder, a category path, a docs section. It matches
- * the value itself and anything below it, and it respects segment boundaries so
- * a sibling with a shared prefix does not match:
- *
- *   { path: { under: '2024' } }   matches '2024' and '2024/spring'
- *                                 does NOT match '2024b'
- *   { path: { under: '' } }       matches everything (the root contains all)
- *   { path: '2024' }              plain equality — that level only
- *
- * ⭐ Why this is an operator and not a separate `recursive:` flag on a fetch
- * declaration: the architecture holds that a query says WHICH records the
- * author wants, and who evaluates it is a capability question. Recursion is
- * then the difference between `eq` and `under` — no new vocabulary above the
- * predicate, and a source free to satisfy `under` by walking one branch instead
- * of scanning is doing query planning, which is its business.
+ * ⛔ **`under` is retired (2026-09-11 [Diego]).** It existed for `where: { path:
+ * { under: X } }` — a folder branch, written before a query had `scope:`. A branch
+ * is a scope now, on both lanes (`./scope.js`), and the build refuses `under` with
+ * a message naming `scope:`. An operator object carrying it is no longer an
+ * operator object here, so it matches nothing: the build's refusal is the guard.
  *
  * Dotted paths descend into nested objects: `tenure.start: { gte: 2015 }`.
  *
@@ -71,7 +59,7 @@
 
 const COMPOSITION_KEYS = new Set(['and', 'or', 'not'])
 const OPERATORS = new Set([
-  'eq', 'ne', 'gt', 'gte', 'lt', 'lte', 'in', 'nin', 'like', 'exists', 'under',
+  'eq', 'ne', 'gt', 'gte', 'lt', 'lte', 'in', 'nin', 'like', 'exists',
 ])
 
 /**
@@ -138,30 +126,6 @@ function evaluateClause(key, value, record) {
   return matchEqual(fieldValue, value)
 }
 
-/**
- * Path containment at segment boundaries.
- *
- * Both sides are compared with leading and trailing `/` trimmed, so an author
- * who writes `'/2024'` or `'2024/'` gets what they meant. An empty ancestor is
- * the root and contains everything — which is what makes "the whole pool"
- * expressible as a predicate rather than as the absence of one.
- *
- * ⛔ The `+ '/'` is the whole point: a plain `startsWith` would match `2024b`
- * against `2024`, which is the classic prefix bug and silently returns records
- * from a sibling the author never named.
- */
-function matchUnder(fieldValue, ancestor) {
-  if (typeof fieldValue !== 'string' || typeof ancestor !== 'string') return false
-  const a = trimSlashes(ancestor)
-  if (a === '') return true
-  const f = trimSlashes(fieldValue)
-  return f === a || f.startsWith(a + '/')
-}
-
-function trimSlashes(s) {
-  return s.replace(/^\/+/, '').replace(/\/+$/, '')
-}
-
 function isOperatorObject(value) {
   if (value == null || typeof value !== 'object' || Array.isArray(value)) return false
   // An operator-object's keys are all in OPERATORS. If even one key isn't
@@ -206,8 +170,6 @@ function evaluateOperator(op, opValue, fieldValue) {
       return globMatch(opValue, fieldValue)
     case 'exists':
       return Boolean(fieldValue) === Boolean(opValue)
-    case 'under':
-      return matchUnder(fieldValue, opValue)
     default:
       // Unknown operator → fail closed.
       return false